Recursive Agent

A Central Agent that creates, runs, and reviews specialist agents from any mission.

Comment

Inspiration

Most agentic tools today are still developer-centric. They are powerful, but they often assume the user understands prompts, tools, APIs, workflows, repositories, and technical orchestration.

OpenClaw inspired us because it shows how powerful agent orchestration can be. But we wanted to ask a different question:

What would agentic orchestration look like for non-technical people?

Recursive Agent is built around that idea. We want to make agent creation accessible to solopreneurs, indie builders, creators, and small teams who want to build a “one-person company” with the help of specialist AI agents.

Instead of asking a non-technical user to manually design workflows or configure agents, Recursive Agent starts from a simple mission. The Central Agent researches, plans, creates specialist agents, injects skills, runs a review loop, and produces an inspectable agent package.

The goal is not just to automate one task. The goal is to help one person create a small expert team around their idea.

In short, Recursive Agent is our attempt to move agentic AI from developer tooling toward practical company-building infrastructure for solopreneurs.

What It Does

Recursive Agent turns one user mission into a Central Agent workflow.

The Central Agent can:

  • research the web with Tavily
  • extract fresh knowledge from docs and sources
  • generate specialist agent profiles
  • create reusable SKILL.md-style instructions
  • spawn a scout, worker, and reviewer fleet
  • run a bounded autonomous review loop
  • rework weak outputs before producing a final report

Instead of only generating HTML, docs, or code, the system focuses on producing reusable agent capability packages.

In simple terms:

\[ Prompt \rightarrow Central\ Agent \rightarrow Specialist\ Agents \rightarrow Review\ Loop \rightarrow Reusable\ Agent\ Package \]

How We Built It

We built Recursive Agent as a full-stack web app.

The frontend is a Next.js interface with a mission canvas, Central Agent dashboard, specialist panels, skill cards, and live progress timeline.

The backend is a Node.js worker that handles orchestration, mission execution, tool routing, web research, memory recall, and persistence.

The core pipeline is:

  1. User submits a mission.
  2. Central Agent recalls relevant memory.
  3. Tavily searches the web for fresh references.
  4. The system extracts skill knowledge from sources.
  5. Central Agent creates specialist agents.
  6. A sub-agent fleet runs in a scout → worker → reviewer pattern.
  7. A quality reviewer checks outputs.
  8. Failed outputs are reworked within a bounded loop.
  9. The final result is stored and shown as an inspectable agent package.

We also integrated OpenClaw as an orchestration path, with fallback support for OpenAI-compatible gateways.

Challenges

The hardest part was deciding what the actual product should be.

At first, the system looked like a tool for generating final artifacts such as HTML pages. But that made the project feel too broad and fragile. The breakthrough was realizing that the real value was the agent production pipeline itself: generate the specialist agent, its skills, its workflow, and its review loop.

Other challenges included:

  • keeping autonomous loops bounded so they do not run forever
  • making OpenClaw orchestration work alongside fallback LLM providers
  • avoiding generic agent outputs
  • turning web research into practical skill instructions
  • keeping long-running missions visible through streaming progress
  • designing a UI that makes agent reasoning inspectable

What We Learned

We learned that autonomous agents need more than prompts. They need structure.

A useful agent system needs:

  • clear roles
  • explicit tool boundaries
  • reusable skills
  • memory
  • review criteria
  • failure handling
  • iteration limits

We also learned that “autonomy” is more convincing when it is bounded. Recursive Agent does not run forever. It runs a controlled loop, reviews itself, and stops when quality passes or the iteration limit is reached.

What’s Next

Next, we want to make Recursive Agent more deeply recursive.

Future improvements include:

  • letting agents create new child agents dynamically
  • adding richer tool-use traces
  • improving OpenClaw runtime reliability
  • exporting agent packages for reuse in other projects
  • supporting domain-specific agent templates
  • adding stronger evaluation metrics for agent quality

Recursive Agent is our attempt to make AI agents less generic and more like reusable, inspectable expert teams.

Built With

Share this project:

Updates