Field report from Imbue’s Hayes Valley office, San Francisco
Short Version
The most sophisticated agent fleet architecture in San Francisco runs on tools from 1985. Memory is the new lock-in & few are paying attention. Your Anthropic bill is not OK - for now. Agents can run your company, just maybe not the way you want. Simon Willison already told you what would go wrong. Keep your markdown files close.
Josh Albrecht has been shipping 10,000 lines of code per day. His co-founder Kanjun Qiu, CEO of Imbue, shared that number with something between pride and disbelief during a fireside chat with Harrison Chase, CEO of LangChain, at Imbue’s Hayes Valley office last night. Both companies published blog posts the same day. Manager, Imbue’s new MIT-licensed CLI for creating and managing agent fleets, launched hours before the audience arrived.
The reason Josh can sustain that output has nothing to do with genius. It has everything to do with tmux, a terminal multiplexer that lets a developer run persistent sessions across multiple windows from a single connection. A tool so boring it barely registers as technology. A tool older than most of the people building agent frameworks.
And that is exactly the point.
Intimacy Problem, Infrastructure Response
Kanjun opened the evening with a framing that stayed in the room long after the fireside shifted to architecture. Imbue’s mission is making technology serve humans. Not the slogan version. The version where the CEO puts her phone outside her bedroom because the software layer in modern life belongs to intermediaries whose incentives are not aligned with the people using it.
“Agents are much more intimate than software,” Kanjun said. “They live very intimately with our data. They have all of our memories. They know what I’m worried about, which relationships I’m concerned about.” If that intimacy sits behind a closed API controlled by a company optimizing for profit, the people building their lives on these agents are not actually free.
That ownership concern is not abstract philosophy. It is the design constraint that produced Manager’s architecture. Everything Harrison and Josh discussed afterward was a structural response to this problem: not manifestos about openness, but inspectable infrastructure that keeps agent memory, context and orchestration in the developer’s hands.
Three-Legged Stool Nobody Owns Yet
Harrison Chase frames the current agent landscape through three layers: model, harness and context. The model is the engine. The harness is the system wrapped around it, the loop-and-tool-call architecture that turns a language model into an agent. The context is everything accumulated over time, the memory, configuration and learned preferences that make an agent useful rather than generic.
“I think harness, memory, model, those are like the three legs of the stool,” Harrison said, “and I think there should be open source components for all of them.”
The harness conversation is moving toward open source, though not uniformly. Harrison was direct about the exceptions: “I would still argue Claude Code isn’t really open source.” But the architectures are converging on what he described as deceptively simple: a model running in a loop calling tools. That was always the original idea of an agent, he noted. The models just were not good enough until now.
But the context layer is where the real lock-in threat lives, and Harrison walked through a brief history of progressive closure to explain why. First, OpenAI removed log probabilities that developers used for model distillation. Then reasoning traces moved behind opaque APIs. Now memory and compaction are being pulled behind provider interfaces. Each step individually seems reasonable. The cumulative effect is a slow-motion enclosure of the developer’s own data.
“Memory and context going behind APIs is actually like 10 times worse than any of the things that I just mentioned,” Harrison said. “That creates a much bigger sense of lock-in. It becomes impossible to move conversations from one agent to another.”
What portability looks like in practice is almost disappointingly simple. An agent’s accumulated knowledge, its preferences about how a user works, what to prioritize, which contacts matter, could live as markdown files in a Git repository. Move the files to a different harness running a different model and the new agent has what it needs to continue. Harrison cautioned that state translation between old and new systems has “no real magic way around it,” but the underlying representation, text files the developer can read, version and control, is what makes the migration possible at all.
He made the point personal. Harrison runs an AI executive assistant through LangChain’s Fleet product. It handles email triage, calendar lookups, drafts. Human-in-the-loop at every outbound message. Recently, an account migration deleted the EA and all its accumulated memories vanished. Starting from a template again was, in his words, “so bad.” Not because the template was poor. Because months of learned context about how Harrison works simply disappeared.
“That memory is my memory,” he said. “I don’t want you guys to have that. I want portability between different models and providers.”
People rush to overcomplicate memory systems, Harrison added. Graph databases, vector stores, elaborate retrieval pipelines. “The main thing people use, it’s not even a set of files, it’s a single string that they just append to and update over time.” For core memory, not large-scale knowledge retrieval but the agent’s evolving understanding of who it works for, simplicity is not a compromise. It is the architecture.
If context cannot move, who actually owns the agent?
Radical Simplicity as Design Philosophy
Josh Albrecht’s response to the lock-in problem is not a competing protocol. It is a refusal to build anything that needs one.
Manager’s architecture is almost aggressively plain. No persistent state. No database. No service. No account. Agent-to-agent messaging works by pasting text into a tmux session via the send-keys command. Remote execution runs over SSH. When an audience member asked about Manager’s “secret sauce,” Josh drew a laugh: “Ours is even simpler. There’s no inbox. It literally just pastes text into Claude Code. That’s it.”
The simplicity is a deliberate infrastructure bet, not accidental naivete. Josh articulated two reasons. First, simpler code is more robust. When thousands of agents run recursively, every unnecessary abstraction becomes a failure surface. A custom messaging protocol that works at 10 agents can produce cascading failures at 500, where a single malformed message propagates through 🔄 sub-agent chains faster than any human can trace. Tmux send-keys either delivers text or it does not. The failure mode is binary, visible and fixable.
Second, and this connects Josh’s engineering instinct to Kanjun’s ownership thesis, agents already know how to use these tools. Tell Claude something runs in tmux and it understands tmux. Tell it to use a novel agent-to-agent protocol and it needs to build the entire interface first. Leveraging the training data’s existing knowledge of decades-old Unix tooling is a compound advantage that grows as models improve.
Josh described Manager as “a composable programming primitive.” Because its operations are scriptable, developers can write for-loops over agent fleets: for every flaky test from the past week, launch an agent to fix it. For every item in a style guide, check every file in the codebase. For every user flow, spin up an agent to test the workflow end to end. That kind of programmatic parallelism is difficult to achieve inside heavyweight agent products or even raw Claude Code sessions.
What Breaks at Scale
The journey from one agent to 1000 is not a smooth ramp. Josh mapped the bottleneck cascade from direct experience, and the pattern is more instructive than any architecture diagram.
The first ceiling is the developer’s own attention. Two terminal windows are manageable. Ten require a notification system. Twenty require an agent managing the other agents, which is exactly what LangChain ships next week in deep agents: sub-agent orchestration where a primary agent kicks off and monitors secondary agents, freeing the human from tab-switching triage.
Compute hits next. Multiple agents running test suites simultaneously will pin every core on a desktop. “Why is my fan spinning so much? Oh, because all the agents are running the test suite.” Imbue built Offload specifically for this, farming tests out to massively parallel cloud sandboxes so execution time collapses to the duration of the single longest test.
Code review is the most human bottleneck of all. Thirty agents produce thirty PRs. Reviewing thirty PRs takes longer than the agents took to write them. Josh described the options with characteristic directness: “You either give up like Gary Tan and just auto-merge it, or…” Imbue built Vet, a review system, and is releasing Code-Guardian, a set of Claude Code hooks that prevent agents from stopping until flagged issues are resolved. The insight underneath: structure the output for reviewability. All new tests in one PR, easy to scan. Bug fixes as individual commits, stacked by priority, reviewable through a git log rather than a diff.
Each bottleneck produces its own tool. Each tool raises the abstraction level. The developer moves from writing code to directing agents to managing the systems that manage agents.
Agents Running Companies, Identity and the Lethal Trifecta
An audience member asked whether agents could run an entire company, citing projects like Paperquake.
Josh’s answer was the evening’s sharpest moment. “Agents can definitely run the company. It depends on what outcome you want for your company though. Agents can be really good at running Enron, probably better than the people.”
The laugh was immediate, but the structural point beneath it matters. The judgment gap between median execution and novel decision-making is where current models still fall short. Average-quality work across many functions simultaneously is achievable now. Customer service agents that are better than nothing already exist and already deliver value for resource-constrained teams. But proactive agents operating without human oversight produce a specific failure mode: externalized mediocrity at scale. Harrison reinforced this. Even his email EA, which works well enough to be genuinely useful, still requires human approval on every outbound message.
John, co-founder of Ravi, pushed the conversation toward agent identity. Should agents have their own email addresses, phone numbers, platform accounts? Harrison described Fleet’s two credential models: agents with fixed credentials for dedicated roles, and assistants that inherit the credentials of whoever uses them. A PM agent that accesses Slack and Notion should not have the CEO’s access level. Agent identity and permissioning, Harrison suggested, will become a major design surface as these systems move beyond single-user prototypes.
Security followed naturally. Josh referenced Simon Willison’s “lethal trifecta” framework, the observation that agents simultaneously handling untrusted data, external communications and access to private data create an attack surface where any two are manageable but all three together invite prompt injection catastrophe. Imbue’s response is Latchkey, a local proxy that handles authentication outside the agent sandbox. The agent makes a curl request without auth headers. Latchkey intercepts it on the developer’s local machine, injects credentials, then forwards. If the agent’s environment is compromised, there is no credential to steal because the credential never entered 🛡️ the agent’s reachable environment.
“We’re still so early in this ecosystem,” Josh said. “It’s gonna be kind of a mess over the next year.”
Where the Map Points
Harrison and Josh arrived at the same destination from different starting coordinates. Open source models are approaching “good enough” for many agent workloads. GLM 5 and MiniMax 2.7 showed the most promise in LangChain’s latest benchmarks. They will probably always trail frontier models, but trailing by a gap that no longer matters for proactive agents, those that wake up periodically to check a condition and go back to sleep, is a meaningful threshold.
The cost conversation is arriving faster than anyone expected. Josh noted that someone calculated running a single o1 instance in fast mode at roughly $700,000 to $800,000 per year. Multiply by 100 parallel agents and the math does not merely get expensive. It collapses entirely. Multi-model orchestration, frontier models for complex reasoning and open source models for triage and monitoring, is no longer an optimization strategy. It is survival arithmetic. The organizations that treat model selection as a static choice rather than a dynamic routing problem will spend themselves into irrelevance.
Harrison’s prediction for mainstream adoption: agents will look like remote employees. They will show up in Slack, in Teams, in email. General-purpose coding agents under the hood, but the interface will be conversational and memory-building. The organizations already comfortable outsourcing to remote workers are the natural first wave.
The Question Underneath
The evening ended where Kanjun started it. The software layer in modern life is about to get vastly more intimate. The developers who keep that layer inspectable, portable and owned will be building on a foundation that strengthens as agents get smarter. The ones who let context accumulate behind closed APIs will discover, as Harrison did when his EA was deleted, that convenience and control are different currencies entirely.
But the harder question did not get resolved, and perhaps cannot be yet. As agents accumulate memory, develop working relationships with their operators and build context that makes them irreplaceable, the power shifts from whoever built the model to whoever holds the memory. That transfer is happening now, mostly by accident, mostly into systems 🧠 the operators do not control. Whether it stays that way depends less on what the labs build next and more on what developers refuse to give up.
Manager is MIT-licensed and available now. Josh’s offer to the room: email him and he will fix whatever breaks. Or more precisely, he will have Claude fix it.
At 10,000 lines a day, the queue moves fast.
References & Resources
Products launched or referenced at this event:
Manager (Imbue, MIT-licensed CLI for agent fleets): imbue.com/product/mngr | GitHub
Manager Part 2 blog post (April 3, 2026): imbue.com/product/mngr_part_2
Offload (parallel test execution): imbue.com/product/offload | GitHub
Vet (agent code review): GitHub
Code-Guardian (Claude Code hooks): GitHub
Latchkey (credential proxy): imbue.com/product/latchkey | GitHub
LangChain: “Open Models Have Crossed a Threshold” (April 2, 2026): blog.langchain.com
Deep Agents (LangChain open source harness): langchain.com/deep-agents | blog
Papers & frameworks referenced:
“Recursive Language Models” by Alex L. Zhang, Tim Kraska & Omar Khattab, MIT CSAIL (Dec 2025): arxiv.org/abs/2512.24601
Simon Willison, “The Lethal Trifecta” (June 2025): simonwillison.net
People Referenced
Kanjun Qiu, Co-founder & CEO, Imbue
Josh Albrecht, Co-founder & CTO, Imbue
Harrison Chase, CEO, LangChain
Bluesky: bsky.app/profile/schwentker.sandboxlabs.ai/post/3mimlvhqfmk27
Twitter: twitter.com/schwentker/status/2040169992378110222
Disclosure
Robert Schwentker (author) attended this event as an independent observer. No compensation or editorial review from Imbue or LangChain.
