Inspiration
Ajo is simple in principle: a group of people contribute money regularly, and everyone relies on the group to keep its promises.
The difficult part starts when something goes wrong.
A contribution is missing. Someone sends payment evidence. A dispute is raised. An administrator has to check what happened, decide whether the payment is valid, and keep track of the decision.
That made us ask a simple question:
What if an AI agent could handle the routine coordination and verification, while leaving important financial decisions to humans?
That became the idea behind Ajo Continuity Agent.
We wanted to build something practical rather than another chatbot that answers questions. The agent needed to observe real group activity, reason about evidence, take useful actions, and know when it should stop and ask a human.
What it does
Ajo Continuity Agent acts as an operational layer for community savings groups.
It monitors contribution activity, processes payment evidence, identifies potential conflicts, and maintains an audit trail of actions taken by the system.
The important part is that the agent does not get unlimited authority.
When an action such as recording a payment requires human approval, the agent pauses through a Human-in-the-Loop flow. An administrator can inspect the situation and explicitly approve or deny the action.
The system therefore follows a simple principle:
Automate the work. Keep humans in control of the decisions that matter.
The dashboard makes this process visible through contribution records, disputes, evidence status, pending contributions, and action receipts.
How we built it
We built Ajo as a full-stack application with a Python backend and a Next.js frontend.
The backend handles the core application logic, persistence, contribution records, disputes, evidence processing, and agent execution.
The frontend is built with Next.js, TypeScript, and Tailwind CSS v4, providing an operational console for administrators.
For the agent layer, we used Strands Agents and its Human-in-the-Loop capability. This allowed us to build an actual approval workflow rather than simply displaying a fake "Approve" button in the UI.
The frontend communicates with the backend through explicit API endpoints. We also made a deliberate effort to keep the UI grounded in real backend data.
Where the original design contained information that the backend did not provide, we did not fabricate it. We either added the necessary backend data or replaced the design element with a truthful equivalent.
For example, the Evidence column is derived from actual payment verification and dispute data. The administrator identity comes from the seeded is_admin member. Agent connectivity is represented by a real health check rather than a fake monitoring timestamp.
That approach took a little more work, but it made the demo honest.
Challenges we ran into
The biggest challenge was not getting an LLM to generate text. It was figuring out where an AI agent should actually have authority.
A financial coordination system cannot simply let an agent make every decision because the model is confident about something.
We had to separate agent reasoning from human authorization.
That led to two distinct approval paths: direct administrator dispute resolution, and an actual agent pause when record_payment requires human approval.
Another challenge was the gap between the design mockups and the data available from the backend.
Several elements in the mockups looked straightforward but had no corresponding backend field. Instead of hardcoding values to make the interface look complete, we changed the backend where appropriate and used truthful alternatives where the underlying capability did not exist.
We also had to make the frontend handle real states rather than only the happy path: loading, errors, missing evidence, pending contributions, and incomplete information.
The lesson was fairly blunt:
A convincing demo is easy to fake. A trustworthy system is not.
Accomplishments that we're proud of
We are proud that Ajo is more than an AI interface.
There is an actual agent workflow behind the dashboard, real backend state behind the UI, and a human approval mechanism between the agent and sensitive actions.
We also built an audit trail through Action Receipts, giving administrators a way to see what happened instead of simply trusting that the agent did the right thing.
Another thing we deliberately prioritized was honesty.
When the backend did not support something shown in the original mockup, we did not invent data just to make the screenshot prettier. We changed the implementation to reflect what the system could actually verify.
That principle shaped the entire project.
What we learned
We learned that building an agentic application is less about making an LLM do more and more things.
It is about deciding what the agent should do, what it should never do, and when it should hand control back to a person.
We also learned that agent reliability depends heavily on the surrounding system.
The model can reason about evidence, but the application still needs structured data, explicit tools, validation, permissions, persistence, and auditability.
Most importantly, we learned that human-in-the-loop should not be treated as a decorative confirmation dialog.
It should be an actual control boundary.
In Ajo, the agent can reach that boundary, pause, explain why approval is required, and wait for a real human decision before continuing.
What's next for Ajo Continuity Agent
The current version focuses on the core continuity workflow. The next step is to make it useful for larger and more diverse savings communities.
We want to expand the agent's ability to detect contribution patterns, identify recurring issues, assist with dispute resolution, and provide clearer explanations of why a payment or contribution was flagged.
We also want to strengthen the operational side of the product with richer monitoring, better mobile support, more granular permissions, and stronger audit capabilities.
The long-term goal is not to replace the people running Ajo groups.
It is to remove the repetitive administrative work that gets in their way.
The agent handles the coordination. The community keeps the control.
Built With
- ai
- fastapi
- python
- strands-agent
- typescript
Log in or sign up for Devpost to join the conversation.