Build Systems, Not Code - Angie Jones, Agentic AI Foundation

Key Concepts

• Agentic Systems: Complex architectures where AI agents act as components within a larger, structured environment.
• Systems Thinking: Viewing an agent as one part of a broader ecosystem involving tools, humans, and other agents.
• Decomposition: Breaking down monolithic, "giant" prompts into distinct, manageable sub-tasks.
• Separation of Concerns: Assigning specific responsibilities (logic, data, presentation) to the appropriate layer (code, sub-agent, or schema).
• Idempotency: Designing workflows so that repeating an action (e.g., due to a crash) does not cause unintended side effects.
• Blast Radius: The potential scope of damage or unintended consequences if an agent fails or is compromised.
• Contract-Driven Development: Using structured data schemas for agent outputs to ensure reliable handoffs between system components.

---

1. Systems Thinking and Workflow Design

The speaker argues that an agent should not be treated as a standalone "one-time prompt" but as a component within a persistent system.

• Systems Thinking: Before building, one must define the agent’s boundaries, dependencies, and failure modes.
• Workflow Design: Agents require a defined path, not just a goal. Every execution flow must account for three outcomes: Stop, Retry, or Escalate.
• Engineering Discipline: The speaker emphasizes that "AI did not invent automation." Traditional software engineering principles—such as avoiding "code smells" (bloated functions)—apply directly to agentic systems.

2. Decomposition and Separation of Concerns

A common pitfall in agent design is the "giant prompt," where a single instruction file handles too many tasks, leading to "drift" and unreliability.

• Decomposition: Identify distinct jobs (e.g., normalizing data, calculating commutes, researching neighborhoods) and separate them.
• Separation of Concerns:
  • Code: Use for deterministic tasks (e.g., math, filtering).
  • Skills: Reusable functions for specific tasks (e.g., data normalization).
  • Sub-agents: Specialized modules for complex, non-deterministic tasks (e.g., neighborhood research).
  • Schemas: Use structured output (JSON/data contracts) rather than free-form text to allow downstream systems to process agent results.

3. Algorithmic Thinking and Determinism

The speaker proposes a clear hierarchy for task delegation:

• Use Code for Determinism: If a task has an exact answer, use code. It is cheaper, more reliable, and less prone to variance.
• Use Agents for Judgment: Reserve LLMs for tasks involving ambiguity, fuzzy logic, or interpretation.
• Use Humans for Authority: Humans should remain the final authority for high-stakes actions (e.g., booking a tour or submitting an offer).

4. State Management and Idempotency

Agentic systems often operate in "messy realities" where network failures or crashes occur.

• Idempotency: Systems must be designed so that if a process is interrupted and restarted, it does not repeat actions already completed (e.g., sending duplicate emails to a realtor).
• Memory Layer: Use a persistent, queryable memory (e.g., a Wiki or database) to track state. This allows the agent to check what has already been done before initiating a new step.

5. Security and Threat Modeling

• Untrusted Input: Treat all external data (listings, forum posts, reviews) as "evidence, not instructions."
• Blast Radius Reduction: Implement "walls" around sensitive actions. For example, an agent can research houses autonomously, but booking a tour must require human approval.

6. Maintainability and Documentation

To avoid the "black box" problem, the speaker advocates for:

• Agentic "READMEs": Every system should include an agent.md file explaining the workflow, policies, and dependencies.
• Self-Orientation: Design systems so that an agent (or a new developer) can "jump in cold" and understand the state and requirements without reverse-engineering prompts.

---

Synthesis and Conclusion

The speaker concludes that the "thrill of building" is not lost in the age of AI; it has simply moved up a layer of abstraction. By applying traditional software engineering rigor—modularity, state management, and clear contracts—developers can build robust, maintainable agentic systems. The core takeaway is that designing agents is software engineering: the primitives have changed, but the discipline of building reliable, scalable, and understandable systems remains the same.

"Use code for determinism, use agents for judgment, and then use humans for authority."