ReconcileAi

AI agent that autonomously reconciles small-business finances and flags only what needs human attention.

Comment

What inspired us

Small businesses don't usually struggle because they lack accounting software. They struggle because someone still has to manually connect the dots: invoices, bank transactions, receipts, payments, discrepancies, and follow-ups.

That work is repetitive, time-consuming, and surprisingly judgment-heavy. A conventional dashboard can show that something is wrong, but it doesn't actually investigate the problem or decide what should happen next.

We built ReconcileAI around a simple idea:

Small businesses don't need another accounting chatbot. They need an agent that actually closes the books.

What ReconcileAI does

ReconcileAI is an AI agent for small-business finance operations. It takes transaction and invoice data, reconciles payments, identifies exceptions, explains likely causes, and determines which actions can safely proceed and which require human approval.

Instead of asking an owner to manually inspect every transaction, the agent prioritizes the exceptions that actually need attention.

For example, if a bank transaction matches an invoice with high confidence, ReconcileAI can mark it as reconciled. If an amount differs, a payment is duplicated, or supporting information is missing, it creates an exception and explains why.

Financial actions are deliberately separated into three states:

  • SAFE — the agent can proceed automatically.
  • REVIEW — a human should approve the proposed action.
  • BLOCKED — the action should not proceed.

This gives the system autonomy without pretending that an AI should have unlimited control over someone's money.

How we built it

The agent is built around the Strands Agents SDK, which gives ReconcileAI a model-driven agent loop capable of reasoning about a task and selecting the appropriate tools.

The architecture separates deterministic financial logic from probabilistic AI reasoning.

The reconciliation engine handles calculations and matching rules, while the Strands agent handles investigation, tool selection, explanations, prioritization, and workflow decisions.

The core flow is:

Invoices + Transactions
          ↓
   Reconciliation Engine
          ↓
      Strands Agent
          ↓
 ┌────────┼─────────┐
 ↓        ↓         ↓
Match   Investigate  Classify
                  Action
          ↓
   Human Approval Gate
          ↓
      Audit Events

We designed the system so that important financial calculations remain deterministic. For example, reconciliation can be represented as:

$$ \text{Variance} = \text{Transaction Amount} - \text{Expected Amount} $$

and a candidate match can be evaluated using multiple signals such as amount, reference, date, and counterparty rather than allowing an LLM to invent the accounting result.

For deployment, we designed the agent around Amazon Bedrock and Amazon Bedrock AgentCore, allowing the same agent architecture to move from deterministic local demonstration into an AWS-native runtime.

What we learned

The biggest lesson was that building an agent is fundamentally different from building a chatbot.

A chatbot can generate a useful answer from a prompt. An agent has to understand a goal, choose tools, inspect their results, decide what to do next, and know when it should stop or ask for help.

We also learned that autonomy needs boundaries.

For a financial workflow, maximizing autonomous actions is not necessarily the goal. A better design is to maximize useful automation while making uncertainty visible.

That led us to build explicit action-safety states and a human approval boundary rather than allowing the model to perform unrestricted financial operations.

Challenges we faced

The hardest challenge was deciding where AI should and should not be trusted.

Purely deterministic reconciliation is reliable but inflexible. Giving every decision to an LLM is flexible but introduces unnecessary risk. We therefore separated the system into deterministic financial primitives and an agentic reasoning layer.

Another challenge was making the demo reliable enough for real-world evaluation. We created deterministic demo data and tests so the core workflow remains reproducible while still allowing the architecture to connect to live AWS services.

We also had to design the system around incomplete and conflicting financial information. Real businesses rarely have perfectly clean data, so exceptions are treated as a first-class product outcome rather than an error state.

Why this matters

Our goal is not to replace the business owner or accountant.

It is to remove the hours spent searching through transactions and invoices so humans can focus on the exceptions and decisions that actually matter.

ReconcileAI turns financial reconciliation from:

search → compare → investigate → decide → repeat

into:

delegate → monitor → approve exceptions.

That is the kind of work we believe AI agents are uniquely positioned to handle.

Built With

Share this project:

Updates

Submission history