Cherry Agent-Native Finance

Cherry Money turns finance software into an agent-ready workspace: ChatGPT can inspect bank feeds, match invoices and stage reconciliations, while payments and final approvals stay human-controlled.

Comment

Inspiration

Small businesses already have finance software, bank feeds and invoicing systems, but the next generation of users will increasingly include AI agents working alongside people.

That creates an important question: how can an agent genuinely help with bookkeeping without giving it unrestricted control over financial actions?

We started with Cherry Money, our existing accounting and open-banking product, and explored how WebMCP could make finance workflows directly understandable and actionable by browser agents.

Our goal became simple:

Let the agent investigate, match and prepare. Keep consequential financial decisions with the human.

Instead of an AI merely clicking around a finance dashboard, Cherry exposes structured finance capabilities through WebMCP. An agent can inspect transactions, find invoice matches, identify exceptions and prepare reconciliation — while approval remains explicit and visible to the user.

The WebMCP functionality in this submission was developed specifically for the OpenAI WebMCP Challenge after 25 August 2026.

What it does

Cherry Agent-Native Finance turns a finance workspace into an agent-accessible interface through WebMCP.

The demo exposes seven structured tools:

  • cherry_get_accounts — inspect available bank accounts
  • cherry_get_transactions — retrieve transactions requiring reconciliation
  • cherry_search_invoices — search invoices by customer, number, status or amount
  • cherry_suggest_reconciliation — analyse a transaction and return the best invoice match with confidence and reasoning
  • cherry_stage_reconciliation — prepare a proposed reconciliation for human approval
  • cherry_get_exceptions — surface ambiguous or low-confidence cases that require attention
  • cherry_create_payment_draft — prepare a payment draft without executing any payment

A user can ask an agent:

“Check the bank transactions that need review and tell me which ones can be confidently matched.”

The agent can inspect the finance data, analyse the transactions and identify likely matches.

For example, a transaction containing an invoice reference and matching amount can receive a high confidence score.

But if two invoices have the same value and there is insufficient identifying information, Cherry deliberately returns a lower-confidence exception rather than guessing.

The user can then ask:

“Prepare the confident reconciliation for txn_001, but don't approve it for me.”

Cherry stages the reconciliation and displays it in the human approval queue.

Only the human can press Approve reconciliation.

The same principle applies to payments: an agent can prepare a draft, but the WebMCP interface deliberately exposes no tool capable of executing or authorising money movement.

This creates a clear safety boundary:

Agent → investigate → recommend → prepare → HUMAN APPROVAL

How we built it

Cherry Money already contains accounting, invoicing, bank feeds and reconciliation concepts. For the challenge, we built a new public WebMCP layer around those workflows rather than creating an unrelated AI demo.

The challenge application is a lightweight Vite/JavaScript finance sandbox so judges can run and inspect the complete WebMCP implementation without exposing private Cherry Money production code, credentials or customer data.

The WebMCP tools are registered using:

document.modelContext.registerTool()

Each tool has a structured input schema, a clear description of its capabilities and explicit boundaries around side effects.

The reconciliation logic follows the same principles used in Cherry Money:

  1. Compare the bank transaction amount against outstanding invoices.
  2. Analyse invoice references and customer information.
  3. Produce a confidence score.
  4. Allow high-confidence matches to be prepared.
  5. Route ambiguous transactions to an exception workflow.
  6. Require human approval before final reconciliation.

We also intentionally created an ambiguous demo transaction that matches more than one unpaid invoice. This demonstrates that the system is designed to surface uncertainty rather than hide it.

The application is deployed on Vercel and includes the WebMCP-compatible response headers:

Origin-Agent-Cluster: ?1

Permissions-Policy: tools=(self)

We also added a CI pipeline that performs a clean dependency installation and production Vite build on every change.

The production build is available at:

https://cherry-webmcp.vercel.app

Source code:

https://github.com/sohamtech-uk/cherry-webmcp

Challenges we ran into

Designing the human-agent boundary

The biggest challenge was not making the agent more powerful — it was deciding where it should stop.

Finance applications contain actions with very different risk levels.

Reading transactions is low risk.

Suggesting an invoice match is advisory.

Preparing a reconciliation changes workflow state.

Approving financial records or sending money is consequential.

We therefore designed separate capabilities rather than exposing one generic “do finance” tool.

The WebMCP agent can analyse and prepare actions, but final approval remains a deliberate human interaction.

Representing uncertainty

A reconciliation system should not pretend every match is obvious.

We needed the demo to show both successful automation and cases where automation should stop.

The matching engine therefore returns confidence and reasoning. An intentionally ambiguous £680 transaction demonstrates how Cherry raises an exception when multiple invoices could plausibly match.

Extending an existing product safely

Cherry Money existed before the challenge and contains private production functionality.

We wanted to demonstrate genuine product evolution without publishing credentials, customer information or proprietary production infrastructure.

We therefore created a separate public challenge repository containing the complete new WebMCP implementation and representative finance data.

Working with an emerging browser capability

WebMCP is still an emerging browser interface. We built against the current document.modelContext.registerTool() API while maintaining graceful behaviour in browsers where WebMCP is not yet exposed.

The finance dashboard therefore remains usable even when the browser does not provide WebMCP.

Accomplishments that we're proud of

We are particularly proud that the project demonstrates more than a chatbot sitting beside finance software.

The finance application itself becomes agent-native.

An agent can discover structured capabilities directly from the webpage instead of relying on fragile DOM navigation or screen scraping.

During the challenge build we:

  • created seven structured Cherry Money WebMCP tools
  • implemented confidence-based invoice reconciliation
  • built a genuine exception workflow for ambiguous transactions
  • created an explicit human approval queue
  • prevented agents from directly completing reconciliation
  • deliberately exposed no autonomous payment-execution capability
  • added an agent/human audit trail
  • built a responsive finance dashboard for the demo
  • published the complete challenge implementation under an MIT licence
  • deployed the production application to Vercel
  • configured the required WebMCP permissions headers
  • added automated CI validation and achieved a successful production build

Most importantly, we created a pattern we believe can extend beyond this demo:

Agents should be powerful enough to remove administrative work, but constrained enough that people remain accountable for consequential financial decisions.

What we learned

WebMCP changes the way we think about application interfaces.

Traditionally we build UI primarily for humans and then attempt to make agents understand that UI afterwards.

WebMCP lets us design a second, structured interface specifically for agents while keeping both interfaces connected to the same application state.

We also learned that the most useful agent tools are not necessarily the most powerful ones.

A narrowly scoped tool such as cherry_suggest_reconciliation communicates intent, permissions and expected behaviour far more clearly than exposing generic application control.

For financial software, confidence and explainability are also essential. Returning the proposed match together with the reason and confidence gives both the agent and the human enough context to decide what should happen next.

Finally, building the human approval boundary from the beginning proved much simpler than trying to add safety controls after giving an agent broad permissions.

What's next for Cherry Agent-Native Finance

The challenge build uses representative finance data so that the entire project can remain public and safe to evaluate.

The next stage is to connect the WebMCP layer to authenticated Cherry Money workspaces and existing services.

That will allow an authorised business user to ask questions such as:

“Reconcile yesterday's bank transactions and show me anything that needs my attention.”

or:

“Which invoices appear to have been paid but are still marked outstanding?”

Future work includes:

  • authenticated Cherry Money WebMCP sessions
  • live Open Banking transaction feeds
  • integration with Cherry Money's reconciliation services
  • expense and supplier-bill matching
  • cash-flow and VAT analysis tools
  • role-based permissions for owners, finance teams and accountants
  • persistent human/agent audit trails
  • configurable confidence thresholds
  • stronger approval policies for higher-risk operations
  • payment preparation through regulated providers while preserving explicit human authorisation
  • agent-accessible accounting reports and exception monitoring

Our longer-term vision is for Cherry Money to become an agent-native finance operating system for small businesses:

AI handles the repetitive financial administration.
Humans remain informed, accountable and in control.

Built With

  • agentic
  • agentic-ai
  • ai-agents
  • bank-reconciliation
  • browser-api
  • css3
  • fintech
  • github
  • github-actions
  • html5
  • human-in-the-loop
  • javascript
  • json
  • model-context-protocol
  • open-banking
  • openai
  • vercel
  • vite
  • webmcp
Share this project:

Updates

Submission history