
FlowForge: From Intent to Execution with Agentic AI and AWS
FlowForge is a domain-agnostic agentic workflow automation system that turns natural-language goals into structured, validated workflows and executes them with human oversight. Built with Amazon Bedrock and Claude, FlowForge combines AI reasoning with deterministic workflow execution, document intelligence, validation, and auditability.
FlowForge: From Intent to Execution with Agentic AI and AWS
Building software that can understand what a user wants is one challenge. Building software that can reliably turn that intent into an executable process is a much harder one.
For this hackathon, we built FlowForge, a domain-agnostic agentic workflow automation platform designed around one simple idea:
From intent to execution.
Instead of forcing users to manually define every step of a workflow, FlowForge accepts a natural-language goal, uses AI to translate that goal into a structured workflow, validates the generated workflow, executes it through deterministic state transitions, processes documents when required, and keeps a complete audit trail.
For our demonstration, we used a scholarship application workflow as the concrete use case.
The scholarship scenario is only a demonstration domain. The underlying architecture is designed so the same system can be adapted to other workflows involving documents, validation, approvals, and structured actions.
The Problem
Many real-world processes still require people to repeatedly perform the same sequence of actions:
- Understand a requirement.
- Collect relevant documents.
- Extract information from those documents.
- Check whether the information satisfies requirements.
- Resolve missing or conflicting information.
- Ask a human for approval.
- Submit the information.
- Maintain a record of what happened.
These workflows are structured, but the input is often not.
A user might simply say:
"Help me apply for this scholarship and check whether my documents satisfy the requirements."
Turning that sentence into a reliable workflow requires much more than generating text.
An AI system needs to understand the intent, identify the required steps, extract information from documents, validate the results, handle uncertainty, and know when it should stop and ask a human rather than making an unsupported decision.
That was the problem we wanted FlowForge to explore.
What We Built
FlowForge converts a natural-language objective into an executable workflow.
The high-level flow is:
Natural-language goal → AI-generated workflow → Schema validation → Deterministic execution → Document processing → AI extraction & validation → Human approval → Action → Audit log
The important design decision was that AI does not control everything.
Instead, we separated probabilistic AI reasoning from deterministic workflow execution.
The AI can interpret intent, classify information, extract fields, and reason about ambiguous documents.
The workflow engine is responsible for controlling what happens next.
This gives us a system that combines the flexibility of an LLM with the predictability of a state machine.
How FlowForge Works
1. Start with Natural Language
The user begins by describing what they want to accomplish.
For example:
"Check my scholarship documents against the eligibility requirements and prepare my application."
FlowForge sends the goal to Amazon Bedrock, where the model converts the natural-language request into a structured workflow definition.
2. Generate a Structured Workflow
Instead of allowing the model to directly execute arbitrary actions, FlowForge asks it to produce a structured workflow representation.
The generated workflow is then checked against a defined schema.
We use Pydantic-based validation on the backend to make sure that the AI-generated output follows the structure expected by the application.
This gives us an important boundary:
LLM output → validated data → application logic
rather than:
LLM output → arbitrary execution
3. Deterministic Workflow Execution
Once the workflow passes validation, FlowForge executes it using a deterministic state-machine approach.
Each step has a defined state and transition.
This means that the AI can help decide what the workflow should look like, while the workflow engine determines how that workflow is actually executed.
This separation was one of the most important architectural decisions in the project.
4. Document Processing
The scholarship workflow requires users to provide documents.
FlowForge uses AWS services to support this process.
Documents can be stored using Amazon S3, while Amazon Textract can be used to extract text and structured information from uploaded documents.
The extracted information is then passed through the validation pipeline.
5. AI-Powered Extraction and Cross-Validation
Not every document has the same structure.
This is where Claude becomes useful.
FlowForge uses Amazon Bedrock to access Claude models for tasks such as:
- Document classification
- Information extraction
- Requirement matching
- Cross-validation
- Handling ambiguous information
For example, information extracted from one document can be compared against information found in another document.
The system doesn't simply return an answer. It assigns an outcome based on the validation process:
PASS → REVIEW → BLOCK
This allows the workflow to distinguish between information that appears valid, information that needs human attention, and information that fails a requirement.
6. Human-in-the-Loop
One of the biggest lessons from building FlowForge was that automation shouldn't necessarily mean removing humans.
Some decisions are inherently ambiguous.
Instead of forcing the AI to make a final decision, FlowForge can stop the workflow and request human approval.
The user can review the extracted information and validation results before the workflow continues.
This creates a human-in-the-loop architecture:
AI reasoning → validation → human review when necessary → execution
The goal is not to blindly automate every decision.
The goal is to automate the repetitive parts while keeping humans in control of important decisions.
7. Simulated Submission and Auditability
After approval, FlowForge can continue to the submission stage.
For the hackathon demonstration, the actual external submission is simulated rather than sending a real scholarship application.
Every important workflow action is recorded in an audit log.
This allows us to answer questions such as:
- What workflow was generated?
- What documents were processed?
- What information was extracted?
- What validation happened?
- Why did the workflow enter REVIEW?
- When was human approval given?
- What action happened afterward?
This becomes particularly important when building agentic systems, because understanding why and how an agent reached an action matters almost as much as the action itself.
Architecture
At a high level, our architecture looks like this:
User │ ▼ React / TypeScript │ ▼ FastAPI API │ ┌──────────┴──────────┐ │ │ ▼ ▼ Workflow Engine AI Services │ │ │ Amazon Bedrock │ │ │ Claude │ ├──────────────► S3 │ ├──────────────► Textract │ ├──────────────► DynamoDB │ └──────────────► Lambda / API Gateway │ ▼ Human Approval │ ▼ Final Workflow │ ▼ Audit LogThe architecture also supports local mock adapters and a
DEMO_MODE fallback, which allowed us to develop and demonstrate the system without making every component dependent on live cloud resources.
Technology Stack
Frontend
We built the frontend using:
- React
- TypeScript
- Vite
- Tailwind CSS
- React Flow
React Flow was particularly useful for visualizing the generated workflow as a graph instead of presenting it as a collection of disconnected steps.
The frontend includes components such as:
- Goal Input
- Workflow Graph
- Document Upload
- Validation Results
- Approval Modal
- Audit Log
Backend
The backend is built using:
- Python
- FastAPI
- Pydantic
- Boto3
The backend is organized around separate modules for:
- API handling
- Workflow execution
- AI services
- Document processing
- Storage
- Data models
- Validation
This separation made it easier to keep the workflow engine independent from the AI layer.
AWS Services
AWS was an important part of the project rather than simply being used as infrastructure.
Our architecture uses:
Amazon Bedrock
Bedrock provides access to the Claude models used for workflow generation, classification, extraction, and validation.
We worked with Claude through Bedrock using the AWS SDK and inference profiles.
Amazon S3
Used for document storage within the document-processing workflow.
Amazon Textract
Used for extracting text and structured information from uploaded documents.
Amazon DynamoDB
Used as the persistence layer for workflow-related data and audit information.
AWS Lambda
Used as part of the serverless architecture for workflow/backend operations.
Amazon API Gateway
Provides an API layer for communication with backend/serverless components.
AWS IAM
IAM was especially important because the application needs controlled access to Bedrock and other AWS resources.
We created a dedicated policy for FlowForge's Bedrock invocation rather than embedding credentials directly into the application.
Working With Amazon Bedrock
Getting Bedrock working was itself part of the hackathon journey.
Our local development setup uses an AWS CLI profile specifically for FlowForge and the backend communicates with AWS through Boto3.
The intended architecture was:
FlowForge Backend │ ▼ Boto3 │ ▼ AWS CLI Profile │ ▼ IAM │ ▼Amazon Bedrock │ ▼ ClaudeWe deliberately kept AWS credentials outside the source code.
The backend supports live Bedrock verification through a dedicated verification script, while
DEMO_MODE provides a controlled fallback for demonstrations.
What Fought Back
The most interesting part of a hackathon isn't when everything works.
It's when it doesn't.
And we definitely encountered that.
AWS CLI Setup
At one point, PowerShell couldn't recognize the
aws command at all.The problem wasn't with our application.
The AWS CLI simply wasn't available in the shell environment.
We installed the AWS CLI and configured a dedicated FlowForge profile before continuing with Bedrock integration.
Bedrock Model Access
Another challenge was understanding the difference between:
- Foundation models
- Model access
- Inference profiles
- Regional availability
- IAM permissions
A model appearing in the AWS console did not automatically mean that our application could invoke it.
We had to work through Bedrock access configuration, IAM permissions, regional configuration, and inference-profile identifiers before getting the backend talking to the model successfully.
IAM Permissions
Authentication and authorization were another important part of the process.
We didn't want to solve the problem by simply giving the application broad permissions.
Instead, we created a dedicated FlowForgeBedrockInvoke policy for the required Bedrock operations.
That forced us to understand exactly what the application needed access to.
Model Invocation Errors
During development, we also encountered validation and invocation errors while testing Bedrock models.
Some failures initially looked like application problems, but the actual issue was related to the model identifier, inference configuration, or the way the request was being constructed.
Debugging these issues taught us an important lesson:
When working with cloud AI APIs, the model isn't the only thing you have to debug.
You also have to understand the surrounding infrastructure:
IAM → region → model availability → inference profile → API request → application
Why We Chose a Hybrid AI Architecture
One of the biggest architectural decisions in FlowForge was not making the LLM responsible for the entire workflow.
LLMs are extremely useful for tasks involving ambiguity and natural language.
But deterministic systems are better suited for:
- State transitions
- Schema validation
- Permission boundaries
- Audit logs
- Workflow control
- Explicit business rules
So we combined both.
AI ┌─────────────────┐ │ Intent │ │ Extraction │ │ Classification │ │ Reasoning │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Validation │ │ + Schema │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Deterministic │ │ Workflow Engine │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Human Approval │ └─────────────────┘This architecture makes the system easier to reason about and provides clear boundaries around what the AI is allowed to do.
Designing for Failure
Another principle we tried to build into FlowForge was that failure should be an explicit state rather than an unexpected crash.
For example:
PASS
The extracted information satisfies the expected requirements.
REVIEW
The information is ambiguous or requires a human decision.
BLOCK
The information fails a defined requirement.
This makes the system's behavior easier to understand and gives the user visibility into why a workflow stopped.
What We Learned
Building FlowForge gave us several lessons beyond simply learning how to use AWS services.
1. Agentic systems need boundaries
Giving an LLM complete control over an application is easy to prototype but much harder to make reliable.
Structured outputs, validation, and deterministic execution provide important boundaries.
2. AI isn't always the answer
Some parts of the system are better handled without an LLM.
Workflow state management, schema validation, permissions, and audit logs should be deterministic whenever possible.
3. Human-in-the-loop isn't a failure
If an AI system doesn't know something confidently, asking a human is often a better outcome than pretending to know.
4. Cloud infrastructure becomes part of the engineering problem
Getting the model to work required understanding IAM, AWS regions, model access, inference profiles, CLI configuration, SDK behavior, and API request formats.
The AI model was only one part of the system.
5. Observability and auditability matter
Once a system can make decisions and trigger actions, being able to understand what happened becomes critical.
What's Next for FlowForge?
The scholarship workflow is only one example of what the architecture can support.
The long-term idea is to make FlowForge capable of handling many different workflow domains.
Potential applications include:
- Document-heavy business processes
- Compliance workflows
- Internal approvals
- Onboarding
- Grant applications
- Insurance workflows
- Financial document processing
- Administrative automation
The core idea remains the same:
Give FlowForge an intent. Let AI help understand it. Validate the resulting plan. Execute it deterministically. Bring humans into the loop when necessary. Keep an audit trail of everything that happened.
Final Thoughts
FlowForge started as a hackathon idea around agentic automation.
It became a much more interesting engineering problem once we started asking:
How do you make an AI system useful without giving it uncontrolled authority?
Our answer was to combine the flexibility of Claude through Amazon Bedrock with deterministic workflow execution, structured validation, document intelligence, human approval, and auditability.
The result is FlowForge — From Intent to Execution.
Building it also reminded us that hackathons aren't just about getting a demo working.
They're about discovering where your assumptions break, debugging systems you don't fully understand yet, and turning those failures into a better architecture.
GitHub: https://github.com/Lokeshrao69/FirstCommit
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article