In this article I'm going to show you how to build, manage and recursively improve your agents using coding agents. Software engineering is becoming autonomous, and it makes sense that AI engineering is the first to get self-driving capabilities.

How I ended up here: I'm the founder of Agno - a framework and runtime for model-agnostic agent platforms, so you can imagine that my day job includes building lots and lots of agents.

Because I do this 16 hours a day, 7 days a week, I've acquired a niche set of skills for spinning up high-quality agents. These skills are pretty useless in the real-world, but for companies looking to build their own agent stack - this post is a goldmine of information.

For example. A few days ago I ran my /improve-agent skill on one of my agents and went to bed. Woke up to 20+ iterations, 282 simulations and 6 accepted improvements, making my agent 20× faster.

I'm a big believer in every company owning their agent stack and this post showcases the payoff. When agent code, traces, evals, and logs live in one place, a coding agent can inspect and improve the platform end to end. Your agent infrastructure becomes self-driving.

Creating a Self Driving Agent Platform

The key takeaway from this post is that your platform needs to be set up for self-driving. You can't just expect any codebase to become self-driving. For example, here's the structure agent-platform I'm going to share with you:

> tree -L 1 .
.
├── agents
├── app
├── db
├── evals
├── workflows
└── AGENTS.md

Because the codebase is set up for agent-driven development, self-driving capabilities are possible. And even better, because of these self-driving capabilities, you can set up your agent platform with one prompt. I encourage you to ignore whatever I'm saying and try it yourself.

Hand this prompt to your favorite coding agent:

Help me set up my agent platform.

Clone https://github.com/agno-agi/agentos-railway into a folder called
agent-platform, cd in, read the README, and follow the get started guide.

Self-driving Skills

I'm not going to sell you a quantum thermodynamic AI god, but I will tell you that a set of well-defined skills will get you very far. The agent platform we're setting up comes with 5 skills that drive the platform:

• /create-new-agent takes an idea, builds the agent and smoke-tests a live instance.
• /extend-agent adds capabilities, fixes problems, and verifies live running agents.
• /improve-agent is where the fun begins. Your coding agent derives simulations and probes from the agent's instructions, tests it, judges responses, edits the agent, tunes parameters, and re-probes until the behavior improves.
• /eval-and-improve runs the eval suite, diagnoses regressions, and hill-climbs until the suite is green.
• /review-and-improve catches repo-wide drift. A consequence of coding agents is that your codebase will move fast, and everything (docs, env vars, evals, security) will fall out of sync. /review-and-improve will bring everything up to speed.

Together they cover the full agent-development lifecycle: create, extend, improve, evaluate, and maintain. With these 5 skills as the machinery, a coding agent as the engine, all you need to do is set the destination (create a new agent, improve it, extend it), and your agent platform self-drives there.

The Five Levels of Self-Driving Software

Self-driving software is a fairly new concept, so here's how I mark our progress:

L1 (Assisted, available now). I name the task and invoke a skill. The coding agent executes that stage end to end, shows its work, and hands the result back to me.

L2 (Self-monitoring, available now). The platform has a heartbeat. A deterministic deployment check runs daily by default across the database, auth, scheduler, MCP, and registered components. Model-backed evals can run beside it, but scheduling them is opt-in because they cost tokens. Nothing improves itself yet, but nothing drifts silently either.

L3 (Autonomous improvement, demonstrated). I set a destination and boundaries, not a list of edits. "Make the builder faster and harder to break" is a destination. The platform does the rest: inspect, probe, judge, edit, and prove. In my overnight harness, every accepted improvement became a commit for me to review in the morning.

L4 (Self-repair, building now). The platform notices a regression and shows up with a verified patch. Half of this exists today: Platform Manager already reads deployment reports, eval history, schedules, traces, and runtime state. I'm working on closing the diagnosis-to-patch loop.

L5 (Full self-driving, the vision). The platform notices a recurring request that no agent covers, proposes one, builds it through Agent Builder, hardens it with the improve loop, locks it in with evals, and ships after human approval. Humans set constraints, choose destinations, and approve arrivals.

At L1, I name the task.

At L3, I name the destination.

At L5, the platform knows what to build, what to improve, what to fix.

Self-Driving for Everyone

As always, everything I build is open-source. You can get your own self-driving platform today, with one prompt. Hand this to your favorite coding agent:

Help me set up my agent platform.

Clone https://github.com/agno-agi/agentos-railway into a folder called
agent-platform, cd in, read the README, and follow the get started guide.

After you complete the setup, start with /create-new-agent. Then /improve-agent what you built. This is the payoff of owning your agent stack: you own the loop that makes it better.

Thanks for reading!

Ashpreet

---

Built with 🧡 using Agno.