Get your free personalized podcast brief

We scan new podcasts and send you the top 5 insights daily.

Anne Griffin shipped ten agents in under two and a half months by treating each agent as assembled from smaller tools and skills. That let her team reuse pieces when an agent failed or when a new one needed similar context and tools, instead of starting from scratch.

Related Insights

The initial effort to build an agentic operating system (OS) is high because you're creating the foundation and the first agent simultaneously. However, this investment yields compounding returns. Subsequent agents are built much faster as they inherit the entire OS, only requiring a new job description and a few specific skills.

Resist building complex, multi-agent systems from day one. Instead, start with a single agent and build its skills based on actual workflows. Add sub-agents only when a clear productivity need arises. This approach is more effective than scaling for what looks impressive.

Instead of codebases becoming harder to manage over time, use an AI agent to create a "compounding engineering" system. Codify learnings from each feature build—successful plans, bug fixes, tests—back into the agent's prompts and tools, making future development faster and easier.

Avoid building one AI agent to do everything. Instead, create a hierarchy with a 'manager' agent that delegates tasks to specialized sub-agents (e.g., for coding, research). This prevents context overload and performance degradation, mirroring an effective human team structure for scalable automation.

To scale your use of AI agents, move beyond single-use builds. Identify recurring capabilities and package them as reusable 'skills.' This modular approach makes your work transportable, allowing you to easily apply successful processes across different projects and agents, which compounds your efficiency over time.

Instead of building monolithic agents, create modular sub-workflows that function as reusable 'tools' (e.g., an 'image-to-video' tool). These can be plugged into any number of different agents. This software engineering principle of modularity dramatically speeds up development and increases scalability across your automation ecosystem.

A single AI agent attempting multiple complex tasks produces mediocre results. The more effective paradigm is creating a team of specialized agents, each dedicated to a single task, mimicking a human team structure and avoiding context overload.

Instead of creating one monolithic "Ultron" agent, build a team of specialized agents (e.g., Chief of Staff, Content). This parallels existing business mental models, making the system easier for humans to understand, manage, and scale.

Instead of building a monolithic agentic system, a more reliable approach is to orchestrate a collection of smaller, well-scoped, and thoroughly tested AI agents. This modular design reduces risk and improves system predictability.

Overcome the memory and context limitations of large AI models by creating smaller, specialized sub-agents. Each agent has a specific goal and toolset (e.g., a "Blockage Radar" agent), which improves reliability by consistently feeding its goals into the system prompt for each task.