AGENTFORGE — The Agent That Builds Better Agents

An autonomous agent engineering lab that builds specialized agents, generates benchmarks, finds failures, runs controlled experiments, and evolves agents into measurably better versions.

Comment

Inspiration

Building an AI agent is only the beginning. We noticed that most agent systems are designed once, tested a few times, and then manually patched when they fail. There is no real engineering loop that continuously asks: Why did the agent fail? What should change? Did the change actually make it better?

That inspired us to build AGENTFORGE — an autonomous agent engineering laboratory.

Instead of treating an agent as a finished product, AGENTFORGE treats it as something that can be systematically engineered, tested, debugged, and evolved. Our goal was to create a system that can take a new task, build a specialized agent, generate tests, discover failures, identify root causes, experiment with improvements, and promote only versions that demonstrate measurable improvement.

Our core idea is simple:

Don't just build agents. Engineer them.

What it does

AGENTFORGE takes a task and turns it into an iterative agent-engineering workflow:

Task → Design → Build → Benchmark → Evaluate → Autopsy → Evolve → Regression Test → Adversarial Test → Promote

It can:

  • Design specialized agents for new tasks
  • Generate benchmark cases including normal, edge, ambiguous, adversarial, and failure scenarios
  • Evaluate agents using measurable metrics such as accuracy, reliability, completion, latency, and cost
  • Perform Failure Autopsy to identify why an agent failed and which component was responsible
  • Generate engineering hypotheses and controlled mutations
  • Compare agent versions on the same benchmark
  • Run regression tests before promotion
  • Stress-test agents through an Adversarial Lab
  • Support abstention, verification, retry, and escalation when the agent does not have enough evidence
  • Maintain an Agent Genome describing the agent's configuration and evolution history
  • Maintain evolution history connecting failures → hypotheses → mutations → experiments → results
  • Provide observability into agent runs, tools, decisions, and failures
  • Track the engineering workflow and sessions performed through AO

The key difference is that AGENTFORGE does not assume that a newer agent is better. An agent version has to prove its improvement.

How we built it

We built AGENTFORGE as a full-stack agent engineering platform.

The frontend provides the engineering workspace for:

  • Overview
  • Agent Laboratory
  • Evaluation Lab
  • Failure Autopsy
  • Evolution
  • Adversarial Lab
  • Agent Tournament
  • Agent Genome
  • AO Build Center
  • Judge Proof

The backend manages agents, versions, benchmarks, evaluations, failures, experiments, mutations, regression tests, and evolution history.

The agent-engineering pipeline follows a controlled loop:

  1. Understand the task
  2. Design the agent
  3. Generate a benchmark
  4. Run the baseline
  5. Capture failures
  6. Perform failure analysis
  7. Form an engineering hypothesis
  8. Create a controlled mutation
  9. Run the candidate against the same benchmark
  10. Compare the results
  11. Run regression and adversarial tests
  12. Promote or reject the candidate

We also used AO as the engineering/build layer to coordinate development work and iterations. AO usage is surfaced as part of the project's build evidence rather than being treated as a decorative integration.

Challenges we ran into

The biggest challenge was making the system more than a collection of agent-related UI screens.

It was easy to create dashboards for evaluations, failures, and evolution. The difficult part was connecting them into one real engineering loop where:

a failure from an evaluation becomes an investigation → the investigation creates a hypothesis → the hypothesis produces a mutation → the mutation creates a new agent version → the new version is tested against the same benchmark → the system decides whether to promote it.

Another challenge was avoiding random prompt tweaking. We wanted improvements to be explainable and measurable, which led us to controlled experiments and counterfactual debugging.

Reliability was another major challenge. Agents can encounter missing information, conflicting evidence, malformed tool responses, unavailable tools, and adversarial instructions. We therefore designed the system around verification, regression testing, adversarial testing, and the ability to abstain or escalate instead of confidently guessing.

Finally, integrating AO meaningfully into the development process required us to think about engineering sessions and evidence, rather than simply adding an AO label to the UI.

Accomplishments that we're proud of

We are proud that AGENTFORGE turns agent development into a repeatable engineering process rather than a one-time prompt-writing exercise.

Our strongest accomplishments are:

  • Building an end-to-end agent engineering lifecycle
  • Creating automated benchmark generation and evaluation
  • Connecting evaluation failures directly to Failure Autopsy
  • Introducing controlled, hypothesis-driven agent evolution
  • Comparing multiple agent versions using the same benchmark
  • Adding regression and adversarial testing before promotion
  • Building an Agent Genome and evolution history
  • Giving agents the ability to abstain or escalate when evidence is insufficient
  • Creating observability around agent execution
  • Integrating AO into the development workflow and making the build process inspectable

Most importantly, AGENTFORGE is designed around one principle:

Every improvement should be demonstrated, not assumed.

What we learned

We learned that building a good agent is less about writing the perfect prompt and more about building the right engineering feedback loop.

Failures are valuable engineering data. A failed case can reveal whether the real problem is the prompt, tool selection, routing, memory, verification, context, or orchestration.

We also learned that evaluation needs to happen continuously. An agent that performs well on normal cases can still fail badly on ambiguous or adversarial inputs.

Most importantly, we learned that an autonomous system needs to know when it should act, verify, ask, retry, escalate, or abstain.

This changed our perspective from:

"How do we make the agent answer better?"

to:

"How do we build a system that continuously discovers how the agent can become better?"

What's next for AGENTFORGE — The Agent That Builds Better Agents

The next step is to make AGENTFORGE capable of evolving increasingly complex production agents with less human intervention.

We want to expand:

  • Multi-agent engineering and orchestration
  • More sophisticated automatic benchmark generation
  • Multi-objective optimization across accuracy, reliability, speed, and cost
  • Agent Digital Twins for predicting mutation impact before deployment
  • Larger Agent Knowledge Graphs connecting tasks, agents, failures, experiments, and versions
  • Continuous production monitoring and regression detection
  • Stronger human-in-the-loop review and approval workflows
  • More agent architectures and model providers
  • Long-term evolution memory across projects and tasks

Our long-term vision is an AI engineering laboratory for AI agents — a system that doesn't just create an agent once, but continuously tests, learns from failures, and helps engineer better versions over time.

AGENTFORGE: Build. Break. Learn. Evolve.

Built With

Share this project:

Updates

Submission history