Introducing the Agent Development Environment
Watch a tutorial video on the Letta ADE on our YouTube channel!
We're excited to announce the Agent Development Environment (ADE), a visual development environment that brings unprecedented transparency to agent design and debugging. At its core, the ADE makes the once-opaque world of context windows and agent reasoning visible and manageable for developers.
What makes agents special? They go beyond traditional LLMs in two fundamental ways:
- Autonomy & Reasoning - Agents can autonomously take multiple actions, and achieve complex tasks that require reasoning and multiple LLM invocations.
- State & Memory - Unlike standard LLMs that start fresh each time, agents can learn and grow from their interactions. An agent you've worked with before should remember important context and build on past conversations, just like a human colleague would.
Although features like reasoning, memory, and state are fundamental to agents, they are rarely transparently exposed to agent developers, making agents difficult to program and debug. And agents today are not easy to get right: they can get derailed, hallucinate, or run into context window overflows. These challenges are compounded by the "black box" nature of both LLM providers and agent frameworks. When something goes wrong, it's been nearly impossible to peek inside and understand why an agent made the decisions it did.
This is where the ADE comes in. Just as IDEs help developers understand what's happening inside their code, the ADE lets you see what's happening inside your agent's mind. We built it on a simple but powerful principle: designing great agents is all about designing great context windows. This means carefully crafting the system instructions, managing memory, choosing the right tools, and controlling how external data flows in. The ADE puts all these critical controls at your fingertips.
State & Context Management
The ADE puts context management front and center. As a developer, you get to shape each piece of the context window:
- The system prompt (the unchanging instructions that guide your agent)
- The tools your agent can use (which it can call on dynamically) along with their inputs and outputs
- The agent's core memory (editable memory that stays in-context)
For each of these components, you can control how much of the context window they are allocated (such as by setting character limits to sections of memory or tool responses).
As you chat with your agent, messages naturally fill up the remaining context window space. Letta handles this intelligently, using recursive summarization and message pruning to automatically limit the context size.
Letta allows you to artificially import context window limits lower than the model’s actual context window limit. Just like humans, giving an agent too much to think about at once can actually make it less effective - not to mention slower and more expensive to run. While models like Claude technically support massive 200k token contexts, maxing out that space isn't always the best move.
Memory Architecture
Think of agent memory like a brain with two parts: what's actively in mind (in-context memory) and what's stored away for later (external memory). We've built on our original ideas with MemGPT for Letta’s memory management, carving out a dedicated space in the context window for editable in-context memory (which we call “Core Memory”).
In-Context Memory: Core Memory
Core memory works through "Blocks" - which each represent a persisted, editable section of the in-context memory. These blocks live in the "Core Memory" section of the context window, and your agent can update them using core_memory_append and core_memory_replace tools.
Most developers use core memory with two blocks: a “human” block containing memories about the human, and a “persona” block with memories about the agent itself.
External Memory: Archival and Recall Memory
Letta automatically keeps track of everything in the conversation history as "recall memory" - your agent can search through this with conversation_search. For more free-form storage, there's "archival memory" - a vector database your agent can write to using archival_memory_insert. As a developer, you can also add data here directly or upload files through a data source. When your agent needs this archived information, it can find it with archival_memory_search.
We make sure your agent always knows what's available by keeping memory statistics right in the context window. This way, it knows when it should dig into these memory banks for more information.
Transparent Reasoning
One of our core principles is that agent reasoning should never be a black box. That's why Letta requires all agents to show their work, regardless of whether they're powered by Gemini, OpenAI, or Anthropic:
We've designed Letta so agents must be explicit about what they're thinking versus what they're saying to users. When an agent wants to communicate with a user, it has to deliberately use the send_message(...) tool. This separation lets agents understand that they can think and act autonomously, and that communicating with the user is an explicit action.
Tool Integration
Tools are what allow agents to take actions in the real world and achieve complex tasks through tool composition. Letta comes with essential tools built in (like send_message and memory management tools), and you can add your own custom tools or tap into 7,000+ tools from Composio.
Tools are just as much a part of your context window as your prompts: designing your tool arguments, returns, and docstrings are a critical part of designing your context window. Be careful not to give your agent too many tools at once. Just like having too much context, too many tool options can make an agent indecisive. (OpenAI has some great insights on this in their function-calling guidelines.)
Tool Development and Debugging
Want to create your own tools? The Letta tool editor lets you write and test Python code directly in the ADE. When editing tools, you can try running them with mock inputs and view the resulting tool response, logs, and error messages.
Tool updates are reflected immediately in your agent, so you can iterate quickly on agents without having to re-start or re-deploy a service.
Pre-built Tool Ecosystem
Our Composio integration gives you access to thousands of pre-built tools right out of the box. For tools that need authentication, you'll just need to create a Composio account and connect the services you want to use. Check out our Composio guide for the full details: https://docs.letta.com/guides/agents/composio
Production Deployment
The ADE is built for real-world applications. The simulator has three modes:
- Debug mode when you need to see everything
- Interactive mode for a balance of visibility and usability
- Simple mode to preview exactly what your end users will see
Interestingly, many developers we've talked to actually like showing their users the agent's reasoning process - it can be fascinating to watch how the agent thinks! Through our REST API, you can access all this data (reasoning, tool calls, messages) by specifying the agent_id.
Conclusion
We built the ADE because we needed it ourselves - we wanted to see inside our agents' heads while we were building and researching them. We hope it helps you create more powerful, reliable agents through better control over tools, memory, and context windows.
During our public beta, you can try out the ADE at https://app.letta.com. Connect it to your local Letta Server or a remote self-hosted deployment (setup instructions included). If you have early access to Letta Cloud, you can create and deploy agents without running your own server.
We're working on making the ADE even more accessible, with plans for native, offline operation that won't require login or internet access. To stay in the loop:
- Join our growing Discord community
- Keep an eye on our docs at https://docs.letta.com
- Drop us feedback on our Discord or at contact@letta.com
And for those that made it to the end of this post, a sneak preview for what’s coming next:
