From Chain‑of‑Thought to Self‑Evolving Agents: Lessons from AI Agent Engineering

After the third article on agents, many readers asked about practical deployment details. Through several engineering iterations, the agent system has diverged significantly from its original architecture.

Intelligent Agent 1.0: Engineering Chain of Thought

We previously explored how to evolve from LangChain's Agent&Tool to a full agent system. The core loop consists of three steps: prompt input, parse LLM output, and concatenate tool results back into the prompt. This chain‑of‑thought (Question → Thought → Action) enables the model to think, act, receive feedback, and converge on a conclusion.

The approach simplifies tool usage: as long as each tool’s semantics are clear, the LLM can invoke them without precise input‑output specifications. However, naïve chaining leads to parameter mismatches and occasional low‑level errors.

Inspired by object‑oriented programming, we introduced tool instantiation (e.g., .do()) so that tools can be treated like classes, reducing repetitive parameter handling.

Instantiating tools also raises a new problem: multiple instances must be remembered during reasoning, which can cause the agent to select the wrong instance. This prompted the question “Is a single agent truly universal?” and motivated further improvements.

Intelligent Agent 2.0: Instantiating Agents

We extended the instantiation idea from tools to agents themselves. An agent can act as a specialist for a narrow domain (e.g., diagnosing a specific switch). By elevating instance parameters to the top level, the agent focuses on reasoning while the middleware handles parameter passing.

In a Kubernetes‑style design, each resource can be represented as an agent instance with a URI, and a /chat endpoint enables conversational interaction.

Two practical challenges emerged:

Reasoning reliability: Large‑model reasoning can miss steps or hallucinate, which is unacceptable for production.

Tool ecosystem: Tools must be adapted for LLM consumption, and the effort to build them can outweigh the benefits.

Intelligent Agent 3.0: Structured Agents

We surveyed open‑source multi‑agent frameworks (AutoGen, CrewAI, OpenAI Swarm, LangGraph) and noted that they improve capabilities through structured roles, hierarchies, and pipelines. Inspired by Ant Group’s agentUniverse, we adopted the PEER pattern (Planning, Executing, Expressing, Reviewing) to enable multi‑step decomposition, execution, and self‑iteration.

By unifying agent == tool == workflow under LangChain’s Runnable abstraction, we allow agents to embed fixed tool chains and free‑form chain‑of‑thought within a single model, making the agent equivalent to a workflow.

Intelligent Agent 4.0: Self‑Evolving Agents

Drawing on historical ideas of program self‑evolution, we propose a mutation framework where agents can generate new tools (computation) and then use those tools to solve more complex problems (reasoning). This iterative loop mirrors the distinction between “reasoning” (language‑level decomposition) and “computation” (mathematical execution).

By separating the large‑model platform (ABM‑Mind) from a middleware layer (runnable‑hub), we achieve modular updates, asynchronous handling, and unlimited depth of reasoning, addressing the limitations of existing protocols such as Anthropic’s MCP.

All code and middleware referenced in this article are open‑source as part of Alibaba’s SREWorks platform (see GitHub links).