Wireup BY TANISH

Built for Track 1: Automated Agent Engineering at Syndicate by Maximor, hosted by Agent Orchestrator (AO).

Describe the work. Build the team. Learn from every attempt.

Most AI demos end when the agent gives an answer.

We wanted to ask what happens next: Did it actually finish the job? What went wrong? Will it do better next time?

Agent Foundry turns a plain-language request into a team of agents, tests their work, and uses what it learns to improve future attempts.

              YOUR IDEA
                  ↓
         Build an agent workflow
                  ↓
           Try a test task
                  ↓
          Check what happened
             ↙         ↘
       Needs work     Meets the target
           ↓                ↓
      Learn and repair   Ready for your input
           ↓
        Try again
     within a set limit

The inspiration

Setting up an agent is becoming easier. Getting one to work reliably with real apps is still difficult.

An agent might misunderstand a tool, repeat the same failed action, or confidently say it completed something that never happened.

We built Agent Foundry for people who know the work they want done but do not want to design, connect, and debug every step themselves.

What it does

You start with a conversation:

“Turn these customer and order spreadsheets into invoice drafts in Zoho Books. Hold anything that needs my attention.”

Agent Foundry creates a visual workflow showing the agents, their responsibilities, and the tools they use.

Tests appear in the chat, alongside results and explanations. If an attempt falls short, the system can inspect the failure and revise the workflow within a set limit. You can also continue the conversation to change its instructions.

When you are ready, you provide your own documents and run the workflow separately from its tests.

What makes it different

It remembers useful lessons.
Each task keeps its own context. A separate store carries limited knowledge about using tools across tasks, so a new workflow can benefit from earlier experience without inheriting another task’s document contents.

It checks whether memory actually helps.
We built paired comparisons that run the same workflow with and without memory. That lets us measure improvement instead of assuming that collecting more memories makes an agent better.

It separates an answer from an action.
Writing “invoice created” is not proof. For our Zoho integration, success requires a real creation receipt and a check of the saved invoice.

It keeps you involved.
You can inspect the workflow, review proposed changes, and approve actions that write to connected apps.

A real lesson from our demo

One test produced a perfect-looking score, but there were no invoices in Zoho.

The system had evaluated the preparation rather than confirmed delivery. That exposed exactly the kind of failure we wanted to solve.

We added direct invoice creation and verification, then completed an authorized connector demonstration using sample Excel data:

Result	What happened
EUR 600 invoice	Created and verified as a draft
Email and reminders	Off
USD invoice groups	Held because the required tax setup was unavailable
Customer without a billing address	Held for review

This was a connector demonstration, not proof that every generated workflow works autonomously.

What we learned

Our early memory comparison also needed correcting: both sides initially ran without useful learned memory. We added a warm-up step and checks to prevent that misleading comparison.

In three subsequent paired comparisons, memory-enabled runs passed on their first attempt. Runs without memory needed a second attempt, and one failed. That is encouraging early evidence, with a sample too small for broad claims.