My partner Zach recently wrote “The next generation of work won’t be about using software; it will be about managing intelligent agents that do the work for us.”

Intelligent agents are no longer a far-off vision—they’re already here, powering real-world systems in brand content (Copy), customer service (Decagon, Sierra), healthcare (Hippocratic), law (Harvey), and software development (Cursor, Claude, Copilot). The Internet era gave us the n-tier webapp and the cloud era brought us containerization and microservices. Similarly, the agent era introduces a new architecture of agents. Unlike the transaction-centered systems of the past, these agents are goal-directed, conversation-centered systems. There’s no single architectural stack for agents, as they have multiple complex components. We see three distinct stacks for agentic AI: a model training stack, an inference stack, and an agentic runtime stack. In this series, we’re going to start by unpacking the agentic runtime stack, and also outline our views on the next set of opportunities for innovation.

The Agentic Runtime Stack

The agentic runtime stack is the software stack needed to build and run agents: software systems that can reason, plan, and act autonomously while being governed and controlled.

Agents can be designed to operate in many modalities - from prompt-and-response to background task to fully autonomous with their own distinct role.

When talking to AI application developers, they often describe functional teams within their organization but rarely can offer an abstracted description of their stack. We believe that this is largely due to how early we are on this journey, how much things still remain in flux, and how many players are trying to do or expand into multiple layers of this stack. We have seen some other attempts at defining this stack but don’t feel that they align with our mental model. Thus, we present our worldview as a moment in time snapshot based on an amalgamation of conversations with these practitioners.

We’ve identified five major layers to the agentic runtime stack: the AI itself, durable execution, agentic frameworks, context, and actuators. For clarity, we have separated context from context interfaces in this diagram and are also including Observability/Security and Inter-agent Communications on the right side but will not be covering them in this post at least in part because of how nascent these spaces are.

AI Inference Stack

Agents are built on artificial intelligence. Artificial intelligence is more than just a model – it is the full stack of components needed to support fast, accurate answers at scale. Modern agentic systems often rely on multiple models, dynamically choosing between them to balance cost, performance, and accuracy. We’ll dig deeper into the specifics of the AI inference stack in a future post. 

One trend to note is that the model houses have been steadily moving up the stack and are increasingly offering built in or separate solutions at many layers of the stack.  In a sense they are trying to lick all the cookies in the cookie jar as they build out their platforms. It will be interesting to see which layers they wind up dominating and which layers more focused companies wind up best serving.

Durable Execution

Traditional transactional apps act quickly on state—book a flight, pay for a product, close a ticket. Agents behave differently. They operate over longer time horizons (hours, days, and weeks), make decisions, and often need to pause, wait, or react. This introduces the need for resilient workflows that can handle all types of failure. Durable execution frameworks guarantee the successful execution of these workflows, even in the face of a network outage, LLM timeout, or other failure.

Agentic Frameworks

At the core of the runtime stack is an agentic framework, which provides an integrated developer experience and a common set of abstractions and design patterns for agents. The ultimate boundaries of these frameworks is unclear as they all work to win the hearts and minds of agentic developers.

Most of the popular agentic frameworks incorporate abstractions for durable execution and memory – putting them in conflict with the durable execution players below and the memory players above. Meanwhile, the durable execution vendors and memory players aren’t sitting still: they’re recognizing the challenge and opportunity of agentic systems, and racing to expand their developer APIs to accommodate.

Context

Agents are only as good as the context that they can access. Their ability to reason, plan, and act depends not just on model quality, but on the relevance and completeness of the information they can see at any given moment. In practice, context comes from three main sources: knowledge, memory, and actuators.

• Knowledge systems such as vector databases, relational stores, document databases, and graph databases serve as deeper knowledge bases. These systems let agents retrieve facts and structured data as needed. They're often used to augment prompts or ground agent behavior in reality.
• Memory provides agents with short-term working space and long-term recall. These systems enable agents to retain and resurface relevant information across sessions, conversations, and tasks—critical for continuity and coherence over time.
• Actuators, discussed below, allow agents to act on live, dynamic inputs instead of relying solely on static information. This gives agents the ability to respond in real time to changing conditions. Actuators can supply context from a variety of sources, including existing APIs (e.g., checking the weather), the unstructured web (e.g., OpenAI web search), or sensor data (e.g., an IoT sensor stream).

Increasingly, agentic systems are accessing context through a common protocol: the Model Context Protocol. MCP is an open protocol that defines how LLMs access external context, providing a standardized way for models to connect to tools, storage, and memory systems. 

Actuators

Actuators don’t merely provide context–they also extend agents with entirely new capabilities and skills.

Traditionally referred to as “tools,” these components increasingly offer sophisticated, multi-step interactions that go beyond simple API calls. To reflect that shift, we’re introducing the term actuators—components that add new skills to an agent.

For example, Blender MCP allows a language model like Claude to directly generate and manipulate 3D models—something that is clearly a new capability, and not merely a set of function calls to an external API. Other subcategories include code sandboxes, which allow LLMs to safely execute generated code in a controlled environment, and browser actuators like OpenAI’s Operator, which let agents navigate and interact with the web directly. 

In practice, actuators significantly broaden an agent’s range of applications. Beyond context collection, they enable complex out-of-band analysis and meaningful, autonomous action-taking.

Opportunities

The next big wave of opportunity will be around what it takes to make agentic systems enterprise ready and addressing the challenges of managing fleets of agents..

• Data Security and Runtime Security
  
  • How can we place controls around the data that agents touch and identify malicious behaviors at runtime?
  • How do we handle unstructured data with historically no/little permissioning?
  • How do we think about identity and authorization for agents?
• Agentic Data Retrieval and Data Quality Monitoring
  
  • How can agents navigate complex paths to data of interest and how can we validate the quality of the data returned? 
  • Current evaluation systems are designed to benchmark LLM quality, but as quality can also improve with test-time compute, how do we evaluate agentic quality?
• Observability and Auditability
  
  • How can IT gain visibility and place controls in a world where agents can hire other agents autonomously?
  • How does debugging work in a multi agentic world?

Let's build it together! If you are building in this space we’d love to hear from you. Reach me on LinkedIn. Thanks to Richard, my co-author, for collaborating with me on this. You can find him at thelis.org