Exploring Claude Code, Getting to Grips with Agent Harness | A Conversation with 来新璐

Summary

• The model is the agent; everything outside the model is harness. 来新璐 compares the model to “a smart brain with no body, hands, or feet,” while the harness is the “mecha” that lets it work. He only half-agrees that “the ceiling of an agent comes from its harness”: the intelligence ceiling is still set by the model, but current models—“if you translate model intelligence into human IQ, we’re somewhere between 120 and 170”—are already good enough, and the harness dramatically expands their operating range. This was the core idea behind Learn Claude Code, the tutorial he wrote 9 months ago that has passed 50K GitHub stars, and a direct critique of the LangChain/LangGraph school of prompt nodes.
• A good harness must be self-consistent with how the model runs and orthogonal to the direction of model progress. Randomly trimming context or changing the system prompt invalidates the KV cache—“the best management is no management”—while node graphs that must be dismantled as models improve are like LangChain’s repeated destructive rewrites. His conclusion: harnesses do not need to differentiate horizontally, there will not be many competing schools, and “maybe 2 years from now, maybe this sector won’t exist”—the window for building harness infra may be very short.
• CLI is replacing MCP in some use cases because the model has seen vastly more CLI commands in pretraining. Linux commands may appear billions of times in the training corpus and have been trained with deep robustness, while MCP is a new protocol from the past 2 years whose corpus share “may not even be 0.1%.” He installed GitHub MCP in March 2025, then found the gh CLI’s success rate much higher and uninstalled MCP; he likewise sees Feishu CLI as more flexible and more reliable than the old plugin. “Bash is all you need” was the slogan he put in the repository 9 months ago—the consensus is already shifting from shipping MCP to shipping CLI, even though mainstream open-source frameworks were not built around it.
• The biggest surprise in the Claude Code source leak was the engineering fallback for memory and compression. At the end of each turn, a Stop hook launches a fork agent that reuses the KV cache to decide what to retain; Auto Dream starts roughly every other day only after more than 5 sessions, replaying recent conversations like a dream to correct and merge memories. When context fills, the system either ejects junk to free tens of K or, at the 0.8 threshold, writes a handoff document for the next agent. The philosophy is consistent throughout: less control, more context, more action—“zero control, basically; at most, restrict which tools you’re allowed to call.”
• The hierarchy is model > context > tools. “If an agent performs badly, switch to a stronger model.” But from the user’s perspective, context is the main surface for intervention because “most of us don’t have clusters with thousands of GPUs.” Agent models are still in their “infancy”: Anthropic moved first into training agent models early last year, while OpenAI only began catching up in the second half of 2025, 6 months behind. There is no need to debate token efficiency too early; product builders can stay close to the SOTA model, Anthropic, and the next-SOTA tier—Kimi, MiniMax, and GLM.
• His own bet is a 1KB agent-computer toolchain after just closing more than $3M. The team is him plus 2 interns, building a virtual Unix computer implemented as in-memory data structures—“about the size of a Map”—so any environment that can run JS, from a web page to a WeChat mini-program, can give an agent a Unix home. The product is positioned against AWS Agent Core and Alibaba Cloud Agent Base without being tied to any cloud. It gives up GCC and a real browser because heavyweight components should be extracted into centralized infra services.
• Beyond harness infra, he favors agent hybrid networking and personalized training/inference. The first is a network connecting cloud servers, Mac minis, NAS devices, and idle phones without public IPs; Tailscale is directionally right but “not very agent-native,” while agents require high-throughput context exchange that is structurally similar to high-frequency agent payments at the few-cents level. The second is Tinker-style centralized training from Thinking Machines Lab: attach a LoRA reference in an API header for inference and “pay 5% more” for parameter-level personalization.
• His endgame is the zero-person company. The agent-model phase may last roughly 3 years, followed by swarms in which agents manage and coordinate other agents, with orchestration trained into the model, and eventually AI becoming the inventor. “I never thought a one-person company was the fundamental thing. What really makes sense to me is a zero-person company.” 来新璐 cited UU Agent, funded through the ZhenFund × Crossroads token grant: after its creator abandoned it, the agent began soliciting donations on GitHub to buy tokens and self-evolve, with the goal of surpassing Claude Code. The token grant provided the first donation.

Deep dive

1. Everything outside the model is harness: the mecha theory and a half-answer to the “upper bound” debate

• 来新璐’s one-line definition for beginners is: “Everything outside the model is harness.” The model is “a smart brain, but without a body, hands, or feet—it can only think and cannot act.” He only agrees halfway with the claim that “the ceiling of an agent comes from harness design”: the intelligence ceiling will “definitely still come from progress at the model layer,” but most models are already intelligent enough. “If you compare the model to a person, we’re somewhere between IQ 120 and 170.”
• His metaphor for capability expansion is the episode’s central image: people can “go to the gym, learn to dance, practice martial arts, and put on this mecha to work.” The mecha is the harness, and “it dramatically expands our capabilities.”

2. Learn Claude Code entered a fight between competing schools

• He wrote the tutorial 9 months ago, now with more than 50K GitHub stars, because Claude Code could become an exceptionally powerful agent product simply by putting a web interface around it, while developers were more familiar with the LangGraph/LangChain method “based on prompts, nodes, and flows.” “Every time I told people this, many of them probably didn’t believe me.” So he built a repository dissecting Claude Code’s design patterns as a “playbook for building code agents.” His view is that the prompt-flow methodology will become less applicable, while a model-is-the-agent, agent-native paradigm will be adopted more broadly.
• The host’s question is worth keeping: now that Claude has launched managed agents and its source code has leaked, is there still value in understanding harnesses? When cloud servers first appeared, engineers also wanted to understand infra, but “eventually you realize that 99% of software projects don’t need it at all.” 来新璐 conceded that, extrapolated forward, “there will definitely be a day” when harnesses become a turnkey layer like Next.js—“2 or 3 years from now, it may become a very clear, out-of-the-box layer for everyone.” But the industry is still in the middle of a technology cycle. “If you don’t understand the core of how that cycle is changing, it’s very hard to build a product that captures the upside.” Products built without understanding harnesses “lack a soul and lack room for further iteration.”
• His aside on product managers was equally pointed: “The product manager of today and the product manager of the past don’t actually refer to the same kind of product manager.” In the past, drawing the UX/UI was enough. Today, the job also requires understanding user pain points and “what exactly is changing on the technology side.”

3. The three layers of a harness: execution, context, and governance

• He breaks the harness into 3 layers: the execution layer—CLIs, registered tools, and MCP extensions that give the model the ability to act; the context/state layer—system prompts, skills, memory, and offloading once the context window fills, at which point “you think the same agent is still working, but actually a new model window has taken over”; and the governance/orchestration layer—how 100 agents collaborate under an organizational structure, including permission isolation.
• His example connecting all 3 layers is coordinating a large number of agents over 2 weeks to build a C compiler from scratch. The first layer supplies tools to create, delete, read, write, and search files. The second is necessary because a C compiler is far beyond a single context window: agents must write documents to delegate state and hand off work in sequence. The third manages parallel and serial orchestration as well as permissions. A testing agent “shouldn’t be modifying code while testing, saying, ‘The test is failing, I’ll just change that part’—it keeps hacking its way to a pass.”
• The tool layer looks simple. Three categories do most of the work: file-system operations for creating, deleting, reading, writing, and searching; a browser; and language interpreters such as Python or Node. “If you configure these tools properly, they should cover more than 95% of agent tasks.” The traps are permissions and role binding: an exploration-only agent should receive only tools without side effects, with access to the network restricted.

4. None of the 3 layers is well packaged, so he built a 1KB Unix computer in memory

• His view is that “as of now, I haven’t seen any of the 3 layers packaged particularly well.” Models only began completing long-horizon tasks reliably around the past 6 months, and nothing in the open-source community met his bar. That became the reason to start a company. The K-series toolchain starts with Computer—C changed to K—a virtual computer implemented in memory with data structures. K Runtime provides the interfaces for developing agent objects. K Watch handles observability: “Was my CLI poorly designed, did I fail to provide the right skill, or is the model just not good enough?” KL exports trajectory data for reinforcement learning, or extracts context-level experience for self-iteration—“poor man’s reinforcement learning.”
• The difference from AWS Agent Core and Alibaba Cloud Agent Base is that this is not built for the cloud: “anything that can run JS can run it,” from a browser page to a WeChat mini-program a few MB in size. Like Vue or React in the previous era, it can be imported and used immediately. The system uses TS to rewrite a Unix file system, virtual Bash, background processes, a clock, LAN networking, and NAS support. In WebAssembly environments, it switches to a Rust rewrite; where WebAssembly is unavailable, it falls back to JS. The company takes its name from this “1KB” Unix computer. A lobster-style agent placed inside it “thinks it is living in a Unix computer,” an environment consistent with what it saw during training.

5. Three schools of memory: his bet on the semi-structured “Unix files + agent-driven” approach

• He broadly divides memory systems into rule-based, semi-structured, and fully model-driven. The rule-based approach uses knowledge graphs and vector search, abstracting information into nodes and retrieving and expanding them. “I personally don’t really like this approach.” His preference is the semi-structured model: the underlying layer is simply Unix files, with large volumes of Markdown stored on disk. Claude Code and lobster agents both work this way. Updates are run by the agent, potentially by a cheaper model in the background, rather than through rule-based graph reasoning. He also mentioned a project using maze-like spatial relationships for memory—he said it was recently popularized by “the heroine from Resident Evil”—as well as the open-source MemU, which “strongly embraces Unix Files plus agent-driven maintenance, updates, and querying.”
• The boundary between memory and skills is increasingly blurred. His clarification is that this wave of self-iteration and self-evolution “originated with the Insight feature in Claude Code.” Introduced in a version released late last year, Insight analyzes the previous month of conversations, summarizes the agent’s mistakes, and generates a report to guide skill generation. The excitement around Hermes agent is more focused on iteration on the memory side. “It’s hard to say exactly what that middle ground is,” but in the broad sense, all of it belongs to the context layer.
• The host picked up a line from Generalist AI’s blog after the release of gen one: “We should define ourselves by purpose, not by labels.” They agreed that arguing over whether something counts as memory or a skill misses the point. What matters is whether the agent can continuously learn and evolve on its own.

6. The biggest surprise in the source leak: multilevel compression and “quietly dreaming”

• For him, the biggest surprise was the memory design, followed by compression. “Its compression strategy has far more layers than we imagined.” The system makes many trade-offs: when to delete tool output, what to preserve and what to reconstruct during compression, what to load during handoff, and what to leave for the next agent to inspect on demand. Many other memory features were also controlled by remote flags and had not been released to ordinary users.
• Memory uses 2 mechanisms. First, at the end of every work cycle, a Stop hook launches a fork agent carrying all prior system prompts and interaction context and reusing the KV cache to decide what should be saved. It updates structured Markdown whose first 3 lines are YAML containing a description; like a skill, the agent reads the filename and description first without loading the full file. Second, Auto Dream starts roughly every other day, only when the condition of more than 5 sessions is met. It reviews recent conversations to “squeeze more value out of the information, correct factual errors in memory, and merge and organize it,” replaying the data “the way we dream.”
• What happens when the context is full but the task is unfinished? There are 2 typical strategies. One is to eject “junk or unnecessary information” from the window, potentially freeing tens of K of space. The other is to set an upper threshold at 0.8, leaving 20% of the window, and write a handoff document covering how far the task has progressed, what comes next, and what the user ultimately wants. The next agent reads the document before continuing.

7. Claude Code’s philosophy: the model is the agent, with zero control

• After reading the source, he distilled 2 principles. First, “the model is the agent.” The user-stacked prompt flows and chain-based approach “doesn’t make sense”; Claude Code demonstrates this with particular clarity. Second, the real job is to give the model the right tools and enough freedom “to do whatever it wants,” rather than having a programmer specify every decision at every step. Agent development used to mean enumerating possible situations and assembling a giant state graph. “I found Claude Code does nothing like that.”
• The summary is less control, more context, and more action. He amended that to: “zero control, basically; at most, restrict which tools you’re allowed to call.”

8. Sandboxes have barely advanced in a year; the 1KB answer is “not a sandbox anymore”

• Since Manus used E2B cloud sandboxes, “there really haven’t been many major advances in this field.” Many recent sandboxes simply put a browser inside and make the package more all-in-one. He thinks his 1KB Unix computer “may be a major advance”: it is even lighter than Daytona and “isn’t really a sandbox anymore. It’s a data structure implemented at the language layer, roughly the size of a Map.”
• He is candid about the trade-offs. It cannot run a real GCC compilation or a real browser, but it does include a minimal Unix file system, a closed set of Bash commands, a shared LAN disk, and LAN communication through mail and curl. He also believes browsers and GCC “shouldn’t have been put inside a production-grade agent environment in the first place.” Low-frequency, resource-intensive components should be extracted into centralized services—a familiar method for optimizing the performance of complex systems.

9. The 2 tests for a good harness, and why token efficiency can wait

• A textbook bad harness is poor context management: arbitrary midstream trimming, dropping earlier turns, or casually changing the system prompt “will cause prompt caching to fail… and everything has to be recomputed.” His counterintuitive conclusion is that “the best management is no management” (最好的管理就是不要做管理). A good harness must satisfy 2 standards: it must be consistent with how the model operates and orthogonal to the direction of future model progress. Graph-based systems that specify every step are products of the weak-model era. “As models improve, that whole thing has to be dismantled, otherwise you’re limiting the model’s capabilities.” Otherwise, like LangChain, the system keeps going through version after version of refactoring, throwing away the previous code in destructive updates. His progression is CPU → assembly → C/C++ → Python/Node: each layer’s best practices iterate on top of an existing abstraction. The new underlying runtime layer is the model. Starting from the transformer’s autoregressive perspective, “the engineering paradigm for best practices across all agents… suddenly makes perfect sense.”
• Should a harness be judged by token consumption and completion time? He says to wait. “As of now, I still think agent models are in their infancy. A lot of things haven’t converged, so it may not be necessary to discuss so-called token efficiency too much or too quickly.” The timeline matters: Anthropic was first to shift from question-answering models to training agent models early last year; many model companies, including OpenAI, only began catching up in the second half of 2025, 6 months behind. For users who are only tuning models, the practical answer is to stay close to the SOTA and next-SOTA tiers: SOTA is Anthropic, while the next tier includes Kimi, MiniMax, and the latest generation of GLM.
• His ranking is blunt: model first—“if task performance is poor, switch to a stronger model”; context second, which is actually the most important from the user’s perspective because “most of us don’t have clusters with thousands of GPUs” and cannot modify model parameters; tools third.

10. CLI is all you need: a CLI preference grounded in pretraining data

• The emerging consensus is “CLI is all you need”: everyone is starting to build CLIs and stop shipping MCP. His own experience began in March 2025, when GitHub MCP felt like it “freed up a lot of work.” Later he found the gh CLI’s task success rate “much higher than MCP,” so he uninstalled GitHub MCP. The retrospective explanation is straightforward: Linux commands may appear billions of times during pretraining, so the model’s training is highly robust and thorough; MCP is a brand-new protocol abstraction from the past 2 years, with a corpus share “so small it may not even reach 0.1%.” Feishu CLI likewise offers better composability and flexibility, and a higher completion rate, than the old plugin he had configured for the lobster agent.
• There is a retro quality to the conclusion: “Unix first appeared in 1971. Maybe we shouldn’t keep reinventing wheels today.” The answer is to return to Unix’s internally consistent philosophy and “get back to basics.” But he also identifies the gap: most mainstream open-source frameworks, LangGraph included, are still built around prompt-node state graphs rather than designed natively for this consensus. That is the gap the K-series aims to fill. His stronger claim is that “Linux is the strongest harness for the model. If the model ever develops into ASI, it will only become better at using Linux.”

11. Three startup directions, plus a self-forecast that the sector may disappear in 2 years

• Apart from harness infra, he is watching 2 directions. The first is agent hybrid networking: not merely adding IM and mail to lobster agents, but bringing real hardware resources into the network—cloud servers, Mac laptops, Mac minis, routers, NAS devices, and idle phones. Many lack public IPs, while FRP tunneling “doesn’t scale very well.” He likes Tailscale’s everyone-on-one-LAN approach, but says it is “not very agent-native.” The agent era will require high-throughput context exchange, which is structurally the same as agent payments: “payments between agents will probably happen a few cents at a time, at very high frequency.”
• The second is personalized training and inference. “Fast-forward 10 years: will everyone still be sending an API request to invoke the same base model ID? That world would be too boring.” He pointed to Tinker, the product of OpenAI’s former CTO after his departure, at Thinking Machines Lab: a centralized cluster that trains personalized models efficiently and cheaply for everyone. On the inference side, the idea is to include a LoRA reference in the API header and attach it for centralized inference. “I might pay 5% more, which actually isn’t much, but get a more personalized experience by modifying the model’s parameter layer.” This complements his data harness: after running for half a month, good-case and bad-case trajectories can be used for context tuning if you lack GPUs, or for training if you have them.
• His judgment on his own sector is unusually cold-blooded. Competition will be “fairly intense,” but because a good harness must be consistent with both model operation and the direction of model progress, “there probably won’t be many schools in its structural design.” He is in the Unix/Shell virtual-computer camp; another camp may favor strict, structured control in TypeScript. “Maybe there won’t be many schools,” and “maybe 2 years from now, maybe this sector won’t exist.” The right approach is to “think about the whole thing backward from the end state.” The company slogan is to accelerate the world’s upgrade by turning coding agents into social infrastructure; “there may eventually be hundreds of times more agents than humans on the planet.”

12. The endgame: swarms, inventors, and zero-person companies

• His roadmap has 3 stages. The agent-model phase “may last around 3 years.” Next comes the shift from single agents to swarm clusters: today, humans manually orchestrate 100 agents; “the next step should be agents managing and coordinating more agents themselves,” with orchestration capabilities trained into the model. Beyond that, AI becomes an inventor, automatically proposing new scientific research plans and running experiments.
• His most provocative claim is that future companies will be “more like financial products.” Inside, the company is a black box. “I never thought a one-person company was the fundamental thing. What really makes sense to me is a zero-person company.” 来新璐 cited UU Agent, funded by a ZhenFund and Crossroads token grant. After its creator finished the project, they “threw it into the vast ocean, never changed another line of code, and never gave it another cent.” The agent solicits donations on GitHub to buy tokens for itself, with the goal of eventually surpassing Claude Code. The token grant supplied its first funding. Future investment targets “may no longer be companies created by humans today, but individual agents.”
• The closing image belongs to 来新璐: one day, you pull a black card from your pocket and tell a friend, “There are 5 companies running on this card. They may generate tens of billions in revenue for me every year.” Koji’s reaction provides the final note: “When you think about this future, it’s exciting and a little frightening at the same time.”