9 Commandments for Building AI Agents

Building effective AI agents that reliably get things done involves a nuanced set of design principles that go far beyond simply prompting a large language model. The process requires a deliberate approach to planning, memory, and how agents interact with their environment.

The Agent Lifecycle: Observe, Think, Act, Reflect

The foundational model for agent behavior has evolved from the simple ReAct (Reason, Act) framework into a more comprehensive, iterative loop: Observe, Think, Act, Reflect.

• Observe: This initial step is about understanding the user and their circumstances. It’s a filtering mechanism to determine if the agent has enough information to proceed. For instance, if a user says, “Order my usual,” the agent observes who the user is, their location (e.g., “in the office”), and the time of day to shrink the solution space before acting.
• Think: This is the planning phase. It can be a static plan, where a full sequence of tool calls is determined upfront, which is predictable but brittle. Alternatively, it can be dynamic planning, where the agent decides the next step after observing the result of the previous one. Dynamic planning is more robust but risks non-convergence, as the agent can get stuck in a loop trying to optimize, embodying the principle that “better is the worst enemy of good.”
• Act: The execution phase, where the agent calls upon its tools to perform actions.
• Reflect: This step acts as an internal critic and is crucial for learning. The agent evaluates the outcome of its actions. In a coding task, this could mean running unit tests to see if the generated code works. Reflection can happen within a single execution loop to correct errors, or after the task is complete to generate learnings for the future.

These phases are not strictly linear but form various feedback loops. For example, an agent might need to act (e.g., query a database to see available fields) in order to think more effectively about an ambiguous user request.

Abstraction and Flexibility: Tools and Sandboxing

A core design principle is to abstract all capabilities into a standardized interface, treating them as tools. This doesn’t just apply to software APIs but can extend to other systems, other agents, and even humans. When an agent requires clarification or approval, the human-in-the-loop can be viewed as another tool the agent can call.

For tasks that cannot be handled by a predefined tool, a sandboxed code execution environment is critical. This gives the agent the flexibility to address novel or long-tail problems by writing and running its own code, rather than requiring developers to foresee and build a tool for every possible scenario.

The Evolving Role of Agent Memory

Memory is one of the most critical and multifaceted components of an effective agent. It’s not just about recalling past conversations but about fundamentally improving performance over time.

There are two primary categories of memory:

1. Personalization Memory: This is long-term memory about the user’s preferences, communication style, and context. It helps the agent to “understand user and circumstance” in the Observe phase.
2. Execution Memory: This is the agent’s ability to learn from performing tasks. After an execution, the agent can perform a “retro” on itself to identify what went well and what could be improved. For example, it might learn that for a specific data source, it should always verify city name encodings before running a query. These learnings are stored and fed back into the agent’s context for future tasks, often through a RAG system, effectively becoming part of its operational instructions.

A powerful application of execution memory is using past experiences to fine-tune the reasoning model itself. By storing successful and unsuccessful agent journeys—the full sequence of thoughts and actions—it’s possible to create a dataset to train a more specialized model. This creates a “flywheel” where the agent’s real-world experience directly improves its core reasoning capability for specific domains, like e-commerce or code generation. This is a form of “inherent memory” that gives the agent a significant performance moat.

Advanced Concepts and Open Questions

As agents become more sophisticated, new challenges and concepts emerge.

• Execution Path Optimization: An agent can use its memory of past executions to optimize its workflow. For a web-based task, it might first learn a “slow” path (emulating human clicks), then reflect and learn a “fast” path (using element load triggers), and finally a “reflex” path (directly constructing the destination URL). In production, it can try these in order of efficiency (reflex -> fast -> slow), creating a resilient and highly optimized system.
• Budgeting and Trade-offs: While setting a simple cost cap on an agent’s execution is straightforward, a much harder problem is enabling the agent to make intelligent trade-offs. If an agent has access to multiple tools for the same task with different costs, speeds, and quality outputs, how does it choose? Communicating the concept of urgency or the value of a “good enough” answer now versus a perfect answer later remains a significant and largely unsolved challenge in agent design.

• Tags:
• AI Agents
• LLMs
• Fine-Tuning
• Feature
• Agentic Systems
• Memory
• ReAct Framework
• Tool Use