Applications are open for Lightning Round VIII

A fast paced pitch competition for tech founders.

Selected startups get $1M+ in perks, investor feedback, and fast-tracked consideration for 1752 Accelerate ($100K investment).

⏰ Early Bird Deadline: May 22 | 🧾 Final Deadline: June 4 | 🏁 Live Competition: June 18

Apply Now

If memory gives an agent continuity, and action gives it leverage over the world, self-evolution gives it a path to becoming something more than a static system.

This is the next frontier in agentic AI. The question is no longer just whether an agent can reason, plan, use tools, or execute tasks. It is whether it can improve the way it does those things without waiting for human engineers to redesign it from scratch.

That shift matters more than it may first appear. Much of machine learning has followed the same broad arc. Early systems depended heavily on handcrafted features, manually chosen pipelines, and human-designed heuristics. Over time, those brittle, labor-intensive components were replaced by learned representations and more automated search procedures. Neural networks displaced hand-engineered features. Neural architecture search began to reduce the need for manually specified network design. AutoML extended this logic further, automating parts of the modeling pipeline that had once required expert intervention.

Agentic systems are now approaching a similar threshold.

Today’s agents still depend heavily on manual design. Their prompts are tuned by hand. Their workflows are drafted by researchers. Their tools are selected, composed, and tested through human effort. Their reasoning strategies, evaluation loops, and optimization procedures are often carefully engineered in advance. Yet the stated ambition of the field is to automate more and more of what humans currently do. There is an obvious tension here: systems designed to reduce human labor are themselves still highly dependent on human labor for their construction and improvement.

That tension will not hold forever.

The deeper logic of the field points toward self-evolving agents: systems that can refine prompts, redesign workflows, create or improve tools, and eventually optimize entire agent architectures through their own interactions with tasks and environments. In that sense, the destination is not merely better agents. It is agents that can help build better agents.

This is the architecture of autonomous improvement.

In what follows, this article examines the major dimensions of self-optimization in intelligent agents. It begins with the broad logic of agent optimization and then moves through four increasingly expansive layers: prompt optimization, workflow optimization, tool optimization, and holistic system-level optimization. Together, these form the emerging machinery of agent self-evolution.

From Manual Design to Self-Evolving Systems

There is a recurring pattern in the history of AI: what begins as handcrafted engineering often becomes a target for automation.

That pattern is especially clear in traditional machine learning. Feature design was once a specialist craft. Researchers carefully selected variables, designed representations, and tuned pipelines by hand. Deep learning changed that by shifting representation learning into the model itself. Then even the design of the model began to move toward automation through techniques such as neural architecture search and hyperparameter optimization. AutoML pushed further, reducing the amount of manual intervention required to select models, configure training strategies, and optimize full machine learning pipelines.

Agentic systems now sit in a similar position to machine learning just before that transition.

Most current agents are still assembled, not truly grown. Researchers decide what the system prompt should say. They decide how many steps the workflow should contain, which tools should be available, how task decomposition should happen, and what kinds of feedback loops should be used. Even in cases where agents appear autonomous at runtime, their design-time evolution is still largely human-led.

Yet if the aim is autonomous intelligence, that arrangement looks temporary.

A mature agentic system should not merely perform tasks. It should improve the way it performs them. It should be able to examine its own failures, revise its strategies, change how it structures subproblems, reconfigure its tool use, and adjust its internal operating procedures in response to new environments or requirements. That is what self-evolution means in practice: not mystical self-awareness, but systematic, iterative self-improvement across the components that determine agent performance.

This has three immediate attractions.

The first is scalability. It is expensive to keep improving agents solely by upgrading the underlying foundation model. Retraining or replacing frontier models requires enormous capital, data, and compute. Self-evolution offers another route. An agent may improve substantially by changing its prompts, restructuring its workflow, choosing tools more intelligently, or redesigning task strategies, even if the underlying model remains unchanged. That does not eliminate the importance of stronger base models. But it does provide a cheaper and more flexible way to extract better behavior from existing ones.

The second is labor reduction. Building agents by hand is still cumbersome. It requires technical expertise, repeated experimentation, and substantial debugging effort. Self-improving systems promise to automate part of that process, lowering the cost of development and making agentic systems more adaptive in the field.

The third is conceptual alignment with natural intelligence. Humans improve through experience. They refine habits, develop heuristics, learn which tools work best in which situations, and reorganize behavior over time. If artificial agents are meant to become more autonomous, some version of this adaptive loop is not optional. It is essential.

The result is an emerging research program: to make agent optimization itself a first-class object of design.

The Optimization Landscape of Intelligent Agents

To understand self-evolution, it helps to think of an agent not as a monolithic entity but as a layered system with multiple optimization surfaces.

At the base lies prompt optimization. This governs how the agent interacts with the underlying language model: how it frames instructions, requests reasoning, structures constraints, and elicits behavior.

Above that sits workflow optimization. This concerns how multiple steps, modules, or model invocations are organized into a functioning process. A single prompt may matter, but so does the larger logic of coordination: what happens first, what branches, what loops, what gets checked, and what gets revised.

Then comes tool optimization. Agents increasingly rely on external tools such as search, APIs, databases, calculators, code interpreters, simulators, and specialized software. Optimizing how those tools are selected, invoked, composed, or even created becomes central to agent performance.

At the broadest level sits holistic agent optimization. This is the system-wide problem. It treats prompts, workflows, tools, and supporting policies as interacting parts of one evolving architecture.

These layers are not independent. A better prompt may improve tool use. A different workflow may reduce cost or latency. A new tool may change what workflow structure is best. Holistic optimization matters precisely because local improvements do not always add up to global gains.

This introduces a familiar problem from machine learning and systems design: multi-objective optimization. Agent performance is not measured along a single axis. Typically, there are at least three competing criteria.

One is performance in the narrow sense: did the agent solve the task correctly or effectively?

Another is inference cost: how many model calls, tokens, tools, or compute resources were required?

The third is latency: how quickly did the system produce a useful result?

These goals often conflict. A larger workflow with more checking may improve accuracy but increase cost and delay. A faster agent may become shallower or less reliable. A tool-rich system may handle harder tasks but at the cost of orchestration overhead.

Self-evolution in agents therefore is not just about improving performance in the abstract. It is about learning to navigate these trade-offs intelligently.

Prompt Optimization: The First Layer of Self-Improvement

Prompt optimization is the most immediate and perhaps most intuitive form of agent self-improvement.

If the foundation model is the cognitive engine, the prompt is one of the most important ways of steering that engine. Small changes in wording, decomposition strategy, examples, formatting, or constraints can produce large differences in reliability, reasoning quality, or cost. In practice, prompt design often determines whether an agent behaves like a brittle script or a robust problem solver.

The formal objective is simple: for a task distribution, find the prompt that maximizes expected performance. But the path to that objective is more complicated, because prompt optimization depends on how prompts are evaluated, what signals are produced by that evaluation, and how those signals are used to generate improved prompts.

How prompts are evaluated

The first issue is evaluation source. In some cases, prompts are assessed against ground truth: a known correct answer, a labeled task outcome, or a benchmark metric. In other cases, only model outputs are available and must be compared against expectations, rules, or alternative outputs. Some systems use pairwise comparison rather than absolute scoring, treating prompt improvement as a relative rather than binary question.

The second issue is evaluation method.

Benchmark-based evaluation is the most straightforward. It uses predefined metrics such as accuracy, pass rates, F1, or domain-specific scoring rules. This is scalable and automated, but it only works well when the benchmark captures what really matters.

A second route is LLM-as-a-judge. Here another language model evaluates the output, often with structured instructions and qualitative criteria. This is especially useful for open-ended tasks where rigid metrics are inadequate. It also allows for richer feedback, including explanations of why an output failed or where a prompt could be improved.

A third route is human feedback. This remains the most direct way to align prompts with human preferences, especially in ambiguous or creative tasks. But it is costly, slow, and difficult to scale.

What kinds of feedback matter

Evaluation can generate different forms of signals.

Numerical signals are simple scores. These are useful for ranking prompts or for optimization loops that depend on scalar objectives. They are easy to automate, but often too coarse to explain why a prompt succeeded or failed.

Textual signals are more sophisticated. They provide explanations, critiques, and suggested revisions. These are especially powerful when the agent is expected to learn from failure rather than merely detect it.

Ranking signals occupy the middle ground. Rather than assigning absolute quality, they indicate that one prompt performed better than another. This is often enough to drive improvement without requiring perfect scoring rules.

How prompts are improved

Once signals exist, optimization can proceed in two broad ways.

The first is optimization through evaluation signals alone. In effect, the system searches the space of candidate prompts, keeps what works, mutates or recombines it, and repeats. This resembles evolutionary search. It does not require explicit understanding of why a prompt is better, only a reliable way to compare candidates.

The second is optimization through richer optimization signals. Here the system uses critiques, error analyses, or “textual gradients” to revise prompts more deliberately. Rather than blindly searching, it tries to learn from specific weaknesses: unclear instructions, missing constraints, insufficient decomposition, or poor output formatting.

This distinction matters because it reflects two different theories of self-improvement. One treats optimization as search. The other treats optimization as reflection.

In practice, the strongest systems increasingly combine both.

Why prompt optimization matters

Prompt optimization may sound narrow, but it has broader implications.

It is often the fastest way to improve agent performance without retraining the base model. It can reduce hallucinations, improve reliability, sharpen tool use, and lower token cost by eliminating wasteful reasoning patterns. It also serves as a prototype for other forms of self-evolution: evaluate, critique, revise, and re-evaluate.

In that sense, prompt optimization is not merely a practical trick. It is the simplest working example of agents learning to improve themselves.

Workflow Optimization: Improving the Structure of Thought and Action

If prompt optimization improves how an agent asks a model to think, workflow optimization improves how the system organizes thinking overall.

This matters because many serious tasks can no longer be solved effectively through a single prompt-response exchange. They require decomposition, intermediate verification, branching strategies, multi-step planning, or coordination across several model invocations. In these settings, the workflow becomes as important as the prompt itself.

An agentic workflow can be thought of as a structured network of LLM-invoking nodes connected by edges. Each node performs a local function: generate a plan, evaluate evidence, produce a draft, verify a claim, call a tool, critique a result. The edges determine how information moves between those nodes.

Optimizing the edges

The representation of workflow structure matters.

A graph-based workflow allows branching, hierarchy, and parallelism. It is useful when tasks require explicit orchestration among specialized steps or subagents.

A neural-network-like representation introduces non-linear and adaptive interactions. This is less interpretable but can be powerful for learning complex coordination patterns.

A code-based representation is the most expressive. It supports branching, loops, conditionals, reusable modules, and precise execution logic. It also aligns naturally with language models’ growing competence at generating and modifying code.

The optimization problem here is not trivial. Changing workflow structure changes the search space itself. A prompt can be revised locally; a workflow redesign may change the agent’s entire operating procedure.

This has led to a shift from fixed workflows toward generated workflows. Some systems now use language models to produce workflow code or topology directly, then test and revise those workflows based on performance. Others use reinforcement learning or search to optimize the arrangement of nodes and paths.

The important point is that the workflow is increasingly treated as something dynamic rather than predetermined.

Optimizing the nodes

Each node in a workflow introduces its own optimization problem.

Which model should be used? What prompt should it receive? What temperature or decoding parameters are appropriate? What output format should it produce? Should its output be free-form, JSON, XML, executable code, or something else?

These choices multiply quickly as workflows grow. A multi-node system can become combinatorially difficult to optimize. Yet this node-level tuning matters. The wrong model in the wrong step, or the wrong output format for a downstream tool, can break the entire system.

This is why workflow optimization is best seen as both structural and parametric. It is not just about drawing a better graph. It is about calibrating each part of that graph to work well within the whole.

Why workflow optimization matters

A prompt can improve an answer. A workflow can improve a system.

This is the level at which agents begin to resemble organizations rather than single models. They route work, assign subtasks, create checking procedures, and develop internal division of labor. The quality of those internal arrangements often determines whether agents remain clever demos or become dependable systems.

Workflow optimization is therefore one of the clearest signs that the field is moving from model use to system design.

Tool Optimization: Learning to Use and Create Capabilities Beyond the Model

If workflows define how an agent organizes cognition, tools define how it extends cognition into the world.

Tool use is one of the most consequential developments in agentic AI because it breaks the boundary of the static model. Search lets the agent access current information. Code execution lets it compute. APIs let it interact with services. Databases let it retrieve structured knowledge. Simulators let it test plans. Robotic interfaces let it act physically.

This makes tool optimization central to self-evolution.

Learning to use tools

Tool learning can proceed in two main ways.

The first is learning from demonstrations. Here the agent is shown examples of correct tool use: which tool to call, with what parameters, in what order, and for what purpose. Supervised training or imitation learning can then teach the agent to reproduce those patterns.

The second is learning from feedback. In this mode, the agent discovers better tool behavior through reward, evaluation, or outcome-based signals. It may learn whether it should have called a tool at all, whether it chose the right one, whether the sequence of calls was efficient, and whether the final outcome justified the cost.

This second route has become especially important as reinforcement learning methods have improved. Rather than merely predicting tool calls from data, agents can now optimize them based on environmental success.

The key problems in tool use

Tool optimization is not one problem but several.

The first is invocation: should the agent use a tool or rely on internal reasoning? Overuse creates cost and latency. Underuse creates errors and hallucinations.

The second is selection: if a tool is needed, which one should be chosen from the available candidates?

The third is retrieval efficiency: how fast and accurately can the system identify relevant tools?

The fourth is planning: for complex tasks, tools often need to be used in sequence, with one result feeding into the next. This makes tool use a planning problem, not just a classification problem.

The fifth is parameterization and execution fidelity: even if the right tool is selected, poor argument construction or misinterpretation of outputs can derail performance.

These layers explain why tool optimization matters so much. It is not simply about giving the agent more capabilities. It is about teaching it when, why, and how to use them intelligently.

Creating new tools

The more ambitious frontier is tool creation.

Rather than merely using existing tools, some agentic systems are beginning to generate new ones when they identify a capability gap. This usually means writing code, wrapping it into a reusable module, validating it through testing, and then adding it to the agent’s growing toolbox.

This is a major conceptual shift. It means the agent is no longer limited to a fixed action repertoire. It can expand that repertoire.

Different approaches emphasize different mechanisms. Some generate tools from examples. Some synthesize utilities from task descriptions. Some create atomic, reusable components that can later be composed into more complex chains. Some use iterative debugging and validation loops to ensure reliability before the tool is incorporated.

The most interesting implication is cumulative growth. Each solved task can potentially leave behind a new capability. Over time, the agent’s tool library becomes not just an external dependency but a record of its own accumulated problem-solving history.

That is a powerful form of self-evolution.

Toward Holistic Agent Optimization

Prompt optimization, workflow optimization, and tool optimization are all important. But optimizing them separately can still leave a system trapped in local optima.

A better prompt may not help if the workflow is badly structured. A powerful tool may not matter if the prompt never invokes it correctly. A clean workflow may still fail if the model selection or output formatting is misaligned. These interactions are why a broader level of optimization is needed.

Holistic agent optimization treats the entire agent as a coupled system.

This approach asks a different question: not how to improve one component, but how to improve the configuration of the whole. That may involve changing prompts, changing workflow topology, changing tools, changing model assignments, or changing the very optimization process itself.

This is where self-evolution becomes most interesting.

Some systems now search over entire workflow designs rather than fixed templates. Others evolve codebases that define agent behavior. Some perform self-referential optimization, where the system examines and rewrites parts of its own structure. Others generate new tasks for themselves as a way of expanding capability through self-challenge.

The unifying idea is that the agent is no longer merely executing a predefined architecture. It is beginning to participate in redesigning that architecture.

The rise of self-referential systems

This is perhaps the most radical trend in current research.

A system that can inspect its own prompts and change them is already one kind of self-improver. A system that can rewrite its workflow code, synthesize new tools, generate its own curricula, and create better versions of itself is something more ambitious: a self-referential optimizer.

That does not mean full autonomy has arrived. These systems remain constrained, brittle, and heavily scaffolded. But the direction is unmistakable. The field is moving from agents that act within systems to agents that modify systems.

This is the beginning of recursive agency.

The Real Challenges of Self-Evolution

The idea of self-improving agents is powerful, but it comes with non-trivial challenges.

One is computational efficiency. Search and optimization across prompts, workflows, tools, and full-system configurations can become extremely expensive. Self-evolution that costs more than manual improvement is not a viable long-term path.

A second challenge is evaluation. Optimization depends on feedback, and feedback depends on good metrics. For many real-world tasks, success is hard to score cleanly. Overly narrow metrics risk rewarding shallow shortcuts. Poor evaluation creates bad evolution.

A third challenge is coordination across modules. Improving one component can destabilize another. Holistic optimization is difficult precisely because the system is interdependent.

A fourth challenge is safety. Agents that can change prompts, workflows, tools, or code raise obvious control questions. Self-evolution without strong constraints can drift into misalignment, unreliability, or unsafe behavior. The same capability that allows autonomous improvement can also produce autonomous failure.

A fifth challenge is transparency. As systems evolve their own internal procedures, it may become harder for humans to understand why they behave as they do. That creates practical and regulatory problems, especially in high-stakes domains.

And there is a deeper philosophical issue as well.

Self-evolution sounds like a purely technical matter, but it is also a governance question. Once improvement becomes endogenous to the system, humans are no longer only designers. They become supervisors of systems that increasingly redesign themselves.

That is a very different relationship.

Why This Matters

Self-evolution is not just another feature in the agent stack. It changes the logic of the stack itself.

A static agent can only be as good as what designers put into it. A self-evolving agent can improve through use, restructure itself around recurring failures, and adapt more efficiently to unfamiliar environments. That makes it potentially more scalable, more resilient, and more autonomous.

It also brings agentic AI closer to the developmental logic of natural intelligence. Humans do not merely execute. They refine. They revise strategies, discover tools, develop habits, and improve workflows through experience. Artificial agents are now beginning to acquire analogous capabilities, even if in far more primitive and formalized ways.

The important thing is not that current systems have solved self-improvement. They clearly have not.

It is that self-improvement has become an explicit design objective.

That marks a turning point. It means the field is no longer satisfied with making agents that work. It is trying to make agents that become better at working.

What Comes Next in This Series

This article has focused on how intelligent agents begin to improve themselves.

That is a decisive step in the broader architecture of autonomy. Once agents can optimize prompts, refine workflows, learn or create tools, and reorganize their own operating procedures, they stop being merely task executors. They become systems capable of directed adaptation.

But self-evolution introduces another question that is even larger.

How do these agents behave when they are no longer improving in isolation?

The next article turns to that problem. It examines how intelligent agents interact with one another in larger systems—how they coordinate, compete, communicate, divide labor, and generate collective behavior across networks rather than single architectures.

If this article is about how agents improve themselves, the next is about what happens when many such agents begin to evolve and act together.

That is where the story moves from individual intelligence to collective intelligence—and where agentic systems start to look less like tools and more like ecosystems.

Series Note: Derived from Advances and Challenges in Foundation Agents

This series draws heavily from the paper Advances and Challenges in Foundation Agents: From Brain-Inspired Intelligence to Evolutionary, Collaborative, and Safe Systems (Aug 2, 2025). The work brings together an impressive group of researchers from institutions including MetaGPT, Mila, Stanford, Microsoft Research, Google DeepMind, and many others to explore the evolving landscape of foundation agents and the challenges that lie ahead. We would like to sincerely thank the authors and researchers who contributed to this outstanding work for compiling such a comprehensive and insightful resource. Their research provides an important foundation for many of the ideas explored throughout this series.