FormWise

Your AI agent for smarter, verified paperwork.

Comment

Inspiration

Administrative paperwork is rarely difficult because of the form itself. The difficult part is everything around it.

When applying for something important, people often have to figure out which documents are required, search through old files to find the right ones, extract information from PDFs or scans, check whether the information is still valid, and make sure different documents don't contradict each other.

A normal search engine can tell you what documents are generally required. A chatbot can explain a form. A document AI can summarize a PDF.

But none of those really answer the question people actually care about:

"Do I have everything I need, and is my paperwork actually ready?"

That led us to FormWise.

Our goal was to build a personal administrative agent that could take a user's goal, work through the paperwork and evidence available to it, identify what is missing or inconsistent, and turn that work into a clear readiness assessment and a prepared paperwork package.

Instead of making the user become the project manager of their own paperwork, we wanted the agent to do that work for them.

What it does

FormWise turns an administrative goal into an evidence-backed paperwork workflow.

A user starts with a goal, such as wanting to complete an application. FormWise determines the relevant workflow and its requirements, then works through the available documents to find evidence for those requirements.

The agent can:

  • Understand an administrative goal.
  • Discover the relevant workflow.
  • Determine what information and documents are required.
  • Search through available documents for relevant evidence.
  • Read and extract information from documents.
  • Process scanned documents and images using OCR when necessary.
  • Extract structured facts from documents.
  • Match evidence against individual requirements.
  • Detect missing requirements.
  • Detect conflicting information across documents.
  • Calculate an overall readiness assessment.
  • Show the evidence and provenance behind its conclusions.
  • Prepare a structured paperwork package for human review.

One of the most important parts of FormWise is that it does not simply ask an LLM to decide whether everything "looks correct."

We use a hybrid approach:

LLM reasoning + deterministic verification.

The agent is responsible for understanding the user's goal, reasoning about what evidence is relevant, and orchestrating the available tools. Deterministic Python logic handles important verification such as requirement status, missing evidence, and conflicts between extracted facts.

For example, if one document contains a date of birth of 15/03/1995 and another contains 16/03/1995, FormWise does not quietly choose one. It surfaces the discrepancy as a conflict so the human can resolve it.

FormWise is therefore designed around evidence rather than AI-generated guesses.

The final step is intentionally human-controlled. FormWise prepares the paperwork work product and readiness assessment, but it does not silently submit applications, make payments, enter OTPs, solve CAPTCHAs, or perform other consequential external actions.

The human remains in control.

How we built it

We built FormWise around a single primary agent using the Strands Agents SDK.

Rather than creating a simple chatbot that calls an LLM once and returns a paragraph, we gave the Strands agent a set of tools that allow it to work with the paperwork workflow.

The core flow is:

User Goal → Workflow Discovery → Requirements → Evidence Gathering → OCR/Text Extraction → Fact Extraction → Verification → Readiness Assessment → Human Review → Package Preparation

The agent can use tools for workflow discovery, document discovery and reading, fact extraction, and requirement verification.

We use Pydantic structured models throughout the system so that important results are represented as structured data rather than unpredictable blocks of text. This allows the frontend to display requirements, evidence, missing items, conflicts, and readiness consistently.

Evidence-first architecture

A major design decision was to avoid treating the LLM as the user's document database.

Instead of asking the model to remember information from an entire document collection, the agent retrieves relevant evidence through tools.

Conceptually:

User goal
    ↓
Strands Agent
    ↓
Tool call
    ↓
Relevant document/evidence
    ↓
Structured facts
    ↓
Deterministic verification
    ↓
Readiness assessment

This also gives important facts provenance: where the information came from, which document contained it, and what confidence was associated with extraction where applicable.

OCR

We also wanted FormWise to work beyond clean text files.

Real paperwork often arrives as scanned PDFs or images, so we added an OCR layer with a provider architecture.

The local OCR implementation uses RapidOCR with ONNX Runtime, with scanned PDF processing support. We also implemented an optional AWS Textract provider through boto3.

OCR results are fed into the same evidence and verification pipeline rather than being treated as a separate feature.

An important safety behavior is that OCR confidence does not override conflicts. Even a high-confidence OCR result should not cause the system to ignore contradictory information from another document.

Backend and frontend

The backend is built with Python and FastAPI, with the Strands agent and its tools forming the core intelligence layer.

The frontend is built with Next.js and presents the workflow as something a user can actually work through rather than as a raw chatbot conversation.

The interface focuses on:

  • the user's request
  • requirements
  • evidence
  • missing items
  • conflicts
  • readiness
  • human review
  • preparation of the final paperwork work product

We also built deterministic demonstrations and an automated test suite so that core workflow and verification behavior can be tested without depending entirely on an external model.

Challenges we ran into

The biggest challenge was deciding what an administrative agent should actually be responsible for.

It is easy to say "AI that fills out forms." Building something trustworthy enough to do that is much harder.

Real administrative workflows can involve sensitive documents, conflicting information, changing requirements, authentication, OTPs, CAPTCHAs, payments, digital signatures, and third-party websites. We did not want to pretend that a prototype could safely automate all of those things.

That led us to a more deliberate boundary:

FormWise prepares and verifies the paperwork; the human remains responsible for consequential actions.

Another challenge was deciding how much of the system should be controlled by the LLM.

We initially considered letting the model handle more of the workflow directly, but that creates a problem: if an LLM decides that two conflicting dates are "probably the same," the user may never know that something is wrong.

We therefore separated reasoning from verification.

The agent can reason about what it needs, while deterministic code performs important checks wherever the logic can be made explicit.

OCR presented another challenge. Documents in the real world are messy: scans can have unusual layouts, low contrast, handwriting, or multiple columns. We therefore designed OCR as a provider layer rather than tying the whole system to a single extraction method.

Finally, we had to balance the larger vision with what could actually be built and tested during a hackathon. Rather than building a collection of half-working agents and integrations, we focused on making one agent and its evidence/verification workflow coherent.

Accomplishments that we're proud of

We're particularly proud that FormWise goes beyond the typical "upload a document and ask questions about it" AI experience.

The system actually performs a multi-step administrative workflow.

It can go from:

"I want to complete this application."

to:

"Here are the requirements, here is the evidence I found, these items are missing, these documents disagree, and this is how ready your application is."

We're also proud of the evidence-first architecture.

The system does not need to blindly trust generated text for every decision. Important verification is backed by structured data and deterministic checks.

Another accomplishment was adding OCR as a genuine part of the document pipeline rather than treating scanned documents as an edge case. A synthetic scanned identity document can be OCR'd, converted into structured facts, and those facts can participate in the same verification process as information extracted from ordinary text documents.

We also built the project around a clear human-approval boundary. The goal isn't to replace the person making the final decision; it is to remove the tedious administrative work that comes before that decision.

Most importantly, we ended up with something that feels like the beginning of a real personal administrative agent rather than just another document chatbot.

What we learned

We learned that building an agent is less about making the model generate better paragraphs and more about giving it the right tools, information, and boundaries.

Strands Agents SDK made the distinction particularly clear. The useful part of the agent isn't simply the model's response; it is the loop between reasoning, tool use, tool results, and further reasoning.

We also learned that deterministic components are extremely valuable alongside an LLM.

Not every problem needs AI.

If two dates are different, code can reliably detect that they are different. The model can then help explain what that conflict means and what the user should do next.

We learned that provenance matters too. When an AI system tells someone that a requirement is satisfied, the user should be able to understand why and where the evidence came from.

Finally, we learned that a good administrative agent needs to know when not to act.

For paperwork involving personal information and consequential decisions, keeping a human in the loop isn't just a limitation. It can be a feature.

What's next for FormWise

The current version of FormWise focuses on understanding, gathering, verifying, and preparing paperwork.

The natural next step is to extend that capability from the paperwork itself into the application process.

A future version could act as a browser-based application copilot: using verified information from the user's documents to assist with ordinary form fields, showing the evidence behind those values, and pausing whenever a human needs to provide an OTP, solve a CAPTCHA, make a payment, review a declaration, or give final approval.

We also want to explore stronger user-controlled document storage, richer workflow discovery, more document formats, better handling of complex forms and tables, and eventually deeper integration with administrative services.

The long-term vision is simple:

Today, FormWise helps you prepare and verify paperwork.

Tomorrow, it can help you navigate the entire administrative workflow.

The goal is to make bureaucracy less about searching through documents and remembering requirements, and more about getting things done.

Built With

Share this project:

Updates

Submission history