The agent architecture conversation has shifted from proof-of-concept demos to production deployment patterns. These five posts from LangChain and Slack Engineering chart the evolution from simple agents to complex, long-running systems that manage context, memory, and parallelism at scale.
Deep Agents
LangChain defines "deep agents" as systems built for complex, multi-step tasks through four architectural components: detailed system prompts with examples, planning tools like todo lists, the ability to spawn sub-agents, and file system access for persistent memory. This isn't just theory. Production apps like Claude Code and Deep Research already use this pattern, and LangChain's open-source deepagents package lets you build domain-specific agents with the same architecture.
// Example: Deep agent with planning and sub-agent spawning
const deepAgent = createDeepAgent({
systemPrompt: detailedPromptWithExamples,
planningTools: ['todo_list', 'task_tracker'],
subAgentConfig: { maxConcurrent: 3 },
fileSystem: { persistTo: './agent-memory' }
});Managing context in long-run agentic applications
Slack Engineering tackles context window limits in multi-agent security investigations that run hundreds of inference requests. Their solution uses three context channels: a Director's Journal for working memory, a Critic's Review that scores findings on credibility (0.0-1.0), and a chronological Critic's Timeline. The Critic filters out 26% of low-plausibility findings before they consume context budget, a concrete example of how to prevent garbage from accumulating in long-running agents.
Deep Agents Deploy: an open alternative to Claude Managed Agents
LangChain's answer to Claude Managed Agents prioritizes memory ownership and model portability. Deploy model-agnostic agent harnesses with one command, store memory in standard formats you control, and switch between OpenAI, Anthropic, or Google without rewriting infrastructure. As agents accumulate months or years of contextual knowledge, vendor lock-in on memory becomes a real risk. This platform exposes agents through open standards like MCP and Agent Protocol while supporting self-hosting.
Previewing Interrupt 2026: Agents at Enterprise Scale
The May 13-14 conference in San Francisco features production case studies worth watching: Apple serving 15,000+ employees with a low-code agent platform, LinkedIn running AI recruiting agents that hire 10x faster, and Lyft building custom evaluation systems. The shift from "can agents work?" to "how do you scale them?" signals maturity in the space. Expect practical patterns on evaluation, deployment, and organizational adoption.
Running Subagents in the Background
Inline subagents block the supervisor until completion, preventing parallel work or mid-task corrections. Async subagents run as separate processes, return a task ID immediately, and support a "fire-and-steer" workflow where supervisors launch multiple subagents, communicate with users, and cancel work as needed. Built on Agent Protocol, they work with LangSmith or self-hosted infrastructure through a standard interface. This pattern matters for any agent running tasks longer than a few seconds.
The through-line here is clear: agent systems are moving from synchronous, single-threaded demos to asynchronous, multi-agent architectures that manage context, memory, and parallelism across extended timelines. The tooling and patterns are stabilizing fast. 🚀