Towards Self-Improving Agent Infrastructure

Every company needs an agent platform.

Your product will have agents. Your engineering team will have agents. Sales, support, marketing and finance will have agents. Some will respond to people, some will run on a schedule, and others will work inside your applications.

They'll use different models, frameworks, and harnesses. But they'll need much of the same infrastructure: somewhere to run, access to company knowledge, persistent state, sandboxes, permissions, and a record of what they did.

Your company needs a shared foundation for that work.

And once that foundation exists, it creates a more interesting opportunity: the platform has the data and tools to improve itself.

By self-improvement, I mean using the data agents generate over time to make incremental improvements, then tracking that those changes help long-term. The result could be better instructions, a fixed tool, updated knowledge, or a simpler workflow. The same infrastructure that runs your agents can make them better.

Agents generate data we can learn from

An agent platform starts by solving technical problems. Agents need to work beyond an HTTP request. Conversations need history. Agents need access to the right tools and knowledge. People need to see what happened and approve sensitive actions.

Building this separately for every agent means repeating a lot of work. It also makes problems harder to understand because the information you need is scattered across different systems.

A shared platform brings these records together. You can inspect what the user asked, what context the agent used, which tools it called, and what happened next.

This gives observability another job. A trace can help you understand a failure. Give a coding agent access to that trace and the source code, and it can investigate what needs to be fixed.

A bad answer can have several causes. The agent might have found an old document, misunderstood an instruction, called the wrong tool, or hit a service failure. Each needs a different fix. Changing the prompt won't repair a broken integration.

Over time, these records also tell you something about your company. You see which questions come up repeatedly, where people correct the agents, and where work gets stuck. That gives you a better starting point for deciding what to improve.

Coding agents turn data into improvements

Imagine a support agent that keeps giving people the wrong instructions for inviting a colleague to a workspace. Users correct it repeatedly.

You could ask a coding agent to investigate. With access to those conversations, the traces, and the code, it might find that the agent's search keeps returning an old setup guide. The fix could be to update that guide and improve how the agent finds current information.

The coding agent could then test the change with requests from users in different workspace roles, questions with missing details, and other ways of asking for the same thing. It could compare the results before and after the change, including whether the agent asks for clarification when it should.

You'd get a change you can review, results that show what it fixes, and tests to catch the problem if it comes back.

The platform gives the coding agent access to source code, conversations, traces, and evaluation results. A sandbox gives it a separate environment to make changes and run tests.

The platform becomes part of the improvement

The same process that improves agents can improve the platform itself.

Imagine several agents failing when they call the same MCP server. Each conversation might look like a separate problem. Looking across their tool calls could reveal a common cause: the shared integration can't handle a particular type of response from the server.

A coding agent could inspect the integration, reproduce the problem using examples, fix it, and test the agents that use it. Once you adopt the fix, it can benefit every agent using that integration, including ones you build later.

A fix to a shared integration or the runtime can benefit every agent that uses it. The scope, schedule, and level of automation are choices you make for your company.

Small improvements make the system better every day

Each improvement might be small in itself. An agent stops using an outdated document. A tool handles a case that used to fail. A workflow gets simpler. But each change saves someone from dealing with the same problem again.

Now make this process part of how the platform runs. Coding agents regularly look through conversations and traces, find recurring problems, and test changes. Evaluations help check whether those changes work. Your team reviews the results and decides what to adopt. As the process earns your trust, more of it can happen automatically.

Over time, your team spends less effort fixing the same problems and more time on new work. Each fix becomes part of the system, and each new task gives it more to learn from. Improvement becomes part of how the platform runs every day.

Small improvements compound and a team whose agents and infrastructure keeps getting better automatically is hard to keep up with.