How to Build Stateful AI Agents for Enterprise Workflows with Letta and Claude Code

Introduction: Why AI agents are transforming business workflows

Modern businesses need automation that remembers context, operates securely, and adapts to change. Recent advancements in tools like Kyutai CADRE, Letta, and Anthropic’s sandbox-runtime have made it possible to create AI agents that maintain persistent state, operate with ultra-low latency, and enforce strict security policies.

The short answer:Yes, you can build AI agents that seamlessly integrate into your business processes, retain memory, and operate securely using the latest open-source platforms.

Why a stateful AI agent is a game-changer for businesses

Traditional agents operate independently on each request. In contrast, a stateful agent retains context, preferences, and past actions, delivering tangible benefits:

• Continuous memory:Remembers customer details, order statuses, or approval decisions across sessions.
• Consistent workflows:
• Custom tools:Securely accesses internal systems (ERP, CRM) via MCP servers.
• Scalability:Reuses the same agent across multiple departments, reducing time-to-market.

Letta is the library that makes this possible, offering core memory, semantic retrieval, and custom tools.

Technical foundations: sandboxing and low latency

Security and speed are critical in business workflows. Two recent trends are driving this:

• Kyutai CADRE:A family of video autoencoders that keep world model latency under 230 ms, ideal for agents requiring real-time perception.
• Anthropic sandbox-runtime (srt):An open-source, OS-level sandbox that isolates agents and restricts file and network access without containers.

When creating an agent with Claude Code, you can automatically enable srt:

# Install the sandbox runtime
pip install anthropic-sandbox-runtime

# Run an agent with security restrictions
claude-code-run --agent my-workflow-agent --sandbox-enabled

Building an agent with Letta

Letta simplifies memory management. Here’s a quick example:

from letta import create_agent
from letta.memory import LettaMemory

# Define core memory
memory = LettaMemory()
memory.add_section("company_policy", "All expenses over €500 require CFO approval.")

# Create the agent with custom tools
agent = create_agent(
    name="expense_approval_agent",
    memory=memory,
    tools=["mcp_server_expense_api", "mcp_server_email_outbound"]
)

Now the agent can retrieve policies, check expenses, and send approval emails while maintaining context throughout the conversation.

Connecting the agent to a business workflow

A typical workflow consists of three stages:

1. Trigger:A user or system (e.g., ERP) sends a request.
2. Processing:The agent retrieves relevant data, applies rules, and decides on an action.
3. Action:Uses secure tools to record, approve, or notify.

Using MCP servers, you can connect the agent to internal systems without exposing APIs directly:

# Example MCP server for an accounting system 
from mcp import Client
client = Client("mcp_server_accounting")

# Workflow: approve a spending
spending = client.fetch_expense("ID_12345")
if spending.amount > 500:
    agent.run("approve_spending", context={"expense_id": "ID_12345"})

Practical example: an AI agent for expense approval

Imagine an agent that automates expense approval:

• Input:Receives an expense report from the accounting system.
• Check:Uses Letta’s memory to verify company policy.
• Decision:Automatically decides whether to approve or request a review.
• Action:Writes a note in the CRM and sends an email to the employee.

This flow reduces manual bottlenecks, ensures compliance, and leaves an audit trail.

Error handling and best practices

• Input validation:Always verify incoming data for type and format.
• Use of sandbox:Always enable srt to isolate the agent from malicious changes.
• Latency monitoring:Use CADRE’s low latency to ensure a smooth user experience.
• Memory limitation:Store only necessary data to avoid context overload.
• Logging:Record every agent action and outcome for auditing.

Key takeaways

• Start small:Build an agent with Letta that stores a single business rule.
• Enable sandbox:Use srt to protect internal systems.
• Monitor performance:Keep an eye on latency, especially if using world models like CADRE.
• Iterate with tools:Connect MCP servers as the workflow expands.
• Document:Write down workflow steps and decision logic for future maintenance.

Conclusion

Stateful AI agents are becoming the backbone of modern business automation. By combining Letta’s persistent memory, Anthropic’s secure sandboxing, and the speed of world models like Kyutai CADRE, you can create workflows that learn, act, and comply with policies without human intervention. Start with a small agent, connect your critical systems, and watch efficiency improve exponentially.