Transcription
Claude Opus 4.6 just dropped, and it changed the AI agent game again. Because 16 Claude Opus 4.6 agents just coded and set the record for the length of time that an AI agent has coded autonomously. They coded for two weeks straight. No human writing the code, and they delivered a fully functional C compiler. For reference, that is over 100,000 lines of code in Rust. It can build the Linux kernel on three different architectures. It passes 99% of a special quote torture test suite developed for compilers. It compiles Postgress. It compiles a bunch of other things. And it cost only $20,000 to build, which sounds like a lot for you and me, but it's not a lot if you're thinking about how much human equivalent work it would cost to write a new compiler.
I keep saying we're moving fast, and it's even hard for me to keep up. A year ago, autonomous AI coding could top out at barely 30 minutes before the model lost the thread. Barely 30 minutes. And now we're at 2 weeks. Just last summer, Rock 10 got 7 hours out of Claude, and everybody thought it was incredible. 30 minutes to 2 weeks in 12 months. That is not a trend line. That is a phase change. The entire world is shifting. Even one of the Anthropic researchers involved in the project admitted what we're all thinking. I did not expect this to be anywhere near possible so early in 2026.
Opus 4.6 shipped on February 5th. It has been just over a week. And the version of cutting edge that existed in January, just a few weeks ago, that already feels like a lifetime ago. Here's how fast things are changing. Just in Anthropic's own road map, Opus 4.5, shipped in November of 2025, just a couple of months ago. It was Anthropic's most capable model at the time. It was good on reasoning, good at code, reliable against long documents. It was roughly the state-of-the-art. Just a few months later, Opus 4.6 shipped with a 5x expansion in the context window versus Opus 4.5. That means it went from 200,000 tokens to a million. Opus 4.6 shipped with the ability to hold roughly 50,000 lines of code in a single context session in its head, so to speak, up from 10,000 previously with Opus 4.5. That is a 4x improvement in coder document retrieval over just a couple of months.
The benchmarks measures are off the charts. And you guys know I don't pay a lot of attention to benchmarks, but when you see something like nearly doubled reasoning capacity on the ARC AGI2 measure, you got to pay attention. It shows you how fast things are moving, even if you don't entirely buy the benchmark itself. And Opus 4.6 adds a new capability that did not exist at all in January. Agent teams. Multiple instances of Claude code autonomously working together as one, with a lead agent coordinating the work, specialists handling subsystems, and direct peer-to-peer messaging between agents. That's not a metaphor for collaboration. That is automatic actual collaboration between autonomous software agents in an enterprise system. All of this in just a couple of months.
The pace of change in AI is a phrase that people keep repeating, and they don't really internalize what it means. This is what it means. The tools that you mastered in January are a different generation from the tools that shipped this week. It's not a minor update, people. It is an entirely different generation. Your January mental model of what AI can and cannot do is already wrong. I was texting with a friend just this past week, and he was telling me about the Rockin results in 7 hours. And I had to tell him, I know you think you're up to date, but the record is now 2 weeks. And by the way, Rockuten using Opus 4.6 was able to have the AI manage 50 developers. That is how fast we're moving. That AI can boss 50 engineers around.
Now, the 5x context window is the number Anthropic put in the press release. It's the wrong number to focus on. The right number is a benchmark originally developed by OpenAI called the MRCV2 score. That sounds like a mouthful, and it's used to measure something that matters enormously that nobody was testing properly. Can a model retrieve and use the information inside a long context window? In other words, can you find a needle in the haystack? It's not about whether you can quote unquote put a million tokens into the context window. Every major model can accept big context windows in January 2026. The question is whether the model can find, retrieve, and use what you put in there. That is what matters.
Sonnet 4.5, which was a great model from Claude just a few months ago, does have a million token window, but the ability to find that needle in the haystack was very low. About one chance in five, or 18.5%. Gemini 3 Pro, a little bit better at finding that needle in the haystack across its context window, about one chance in four, 26.3%. These were the best available in January. They could hold your codebase. They couldn't reliably read it. The context window was like a filing cabinet with no index. Documents went in, but retrieving them was kind of a random guess past the first quarter of the content. Guess what? Guess what? Opus 4.6 at a million tokens has a 76% chance of finding that needle in the haystack. At 256,000 tokens, or a quarter of the context window, that rises to 93%. That is the number that matters. That is why 4.6 feels like such a giant leap. It's not because of the benchmark score. It's because there's a massive difference between a model that can hold 50,000 lines of code and a model that can hold 50,000 lines of code and know what's on every line all at the same time.
This is the difference between a model that sees one file at a time and a model that holds the entire system in its head simultaneously. Every import, every dependency, every interaction between modules, all visible at once. A senior engineer working on a large codebase carries a mental model of the whole system and they know that changing the O module can break the session handler. They know the rate limiter shares state with the load balancer. It's not because they looked it up. It's because they've lived in the code long enough that the architecture becomes a matter of intuition, not a matter of documentation. That holistic awareness is often what separates a senior engineer from a contractor reading the codebase for the first time. Opus 4.6 can do this for 50,000 lines of code simultaneously. Not by summarizing, not by searching, and not with years of experience. It just holds the entire context and reasons across it the way a human mind does with a system it knows very, very deeply. And because working memory has improved this dramatically in the span of just a couple of months, it's actually not hard to see where the trajectory is going to go from here. The C compiler project, 100,000 lines in Rust, did require 16 parallel agents precisely because even a million token context window can't hold that whole project at once in its head. But at the current rate of improvement, it won't require 16 agents for long.
Let me tell you more about the Rakuten story with the 50 developers. Now, Rakuten is a Japanese e-com and fintech conglomerate, and they deployed Claude code across their engineering org, not as a pilot, but in production, handling real work and touching real code that ships to real users. Use Kaji, Rakuten's general manager for AI, reported what happened when they put Opus 4.6 on their issue tracker. Claude Opus 4.6 closed 13 issues itself. It assigned 12 issues to the right team members across a team of 50 in a single day. It effectively managed a 50-person org across six separate code repositories and also knew when to escalate to a human. It wasn't that the AI helped the engineer close the tickets. I want to be clear about that. It closed issues autonomously. It did the work of an individual contributor engineer. It also routed work correctly across a 50-person org. The model understood not just the code but the org chart. Which team owns which repo? Which engineer has context on which subsystem? What closes versus what needs to escalate? That's not just code intelligence, that is management intelligence. And a system that can route engineering work correctly is a system that understands organizational dependencies the way a human lead understands them. Which means the coordination function that engineering managers spend half their time on just became automatable in a couple of months. Think about the cost structure that implies. A senior engineering manager at a company like Rakuten might cost a quarter million dollars a year fully loaded, maybe more. A meaningful part of their job, ticket triage, work routing, dependency tracking, cross-team coordination. That is exactly what Opus 4.6 demonstrated it could handle. Not the judgment calls about what to build next, not the career development conversation, and it wasn't done over weeks and weeks and weeks, but the fact that it can do operational coordination that typically takes 15 to 20 hours a week and demonstrated it could do it for a full day, it shows you where things are going.
And the broader numbers tell the same story. It is common now to see hours and hours and hours of sustained autonomous coding for individuals who are playing with this, not in the controlled enterprise environment. Even people can kick off multi-hour long coding sessions and just walk away and do other things and come back and see fully working software. That is no longer an unusual thing in February 2026. And Rakuten isn't stopping here. They're building an ambient agent that breaks down complicated tasks into 24 parallel Claude code sessions. Each single one handling a different slice of their massive mono repo. A month of human engineering is generating a simultaneously running 24 agent stream that helps them to build and catch issues, and that's in production.
Now, the detail that gets buried under these big numbers might be more interesting than all of the numbers themselves because non-technical employees at Rakuten are able to use that system to contribute to development through the Claude code terminal interface. That is right. The terminal is not just for engineers anymore. People who have never written code are able to ship features because of the work Rakuten has done to integrate Claude code. So the boundary between technical and non-technical, it keeps breaking that down. The distinction that has organized knowledge worker hiring and compensation for 30 years is dissolving in a matter of months. It's not dissolving at the speed of your ability to deploy a multi-month project, and it's not dissolving at the speed it takes to retrain humans. That is why this is shocking. This is all happening faster than we can adjust to it.
One of the features that is most hard for us to wrap our minds around is the agent teams feature that Opus 4.6 shipped. Anthropic calls them team swarms internally, which is a little scary, and I can see why the marketing team changed that. But the name is accurate. It's not a marketing term. It's an architecture. Multiple instances of Claude code are architected to run simultaneously. Every single one in its own context window. And they coordinate through a shared task system that has three simple states: pending, in progress, and completed. Pending, in progress, and completed. One instance of Claude Code is going to act as your lead developer. It will decompose the project into work items and assign them to specialists, track dependencies, and unlock bottlenecks. This is just like what Opus 4.6 did for those 50 developers. The specialist agents work independently, and when they need something, they don't just go through the lead, by the way. They can message each other directly. Peer-to-peer coordination. It's not hub and spoke. There's a front-end agent, there's a back-end agent, there's a testing agent. Effectively, they are recreating the entire software engineering org inside Claude code team swarms. And this is how that C compiler got built. It's not one model doing everything sequentially, right? It's 16 agents that worked in parallel. Some building the parser, some building the code generator, some building the optimizer. And they all coordinated through the same kinds of structures that existing human engineering teams use, except they work 24 hours a day. They don't have standups, and they resolve coordinations through direct messaging rather than waiting for the next sprint planning session.
One of the running questions in AI has been whether agents will reinvent management. I think this argues strongly that they did. Curser's autonomous agent swarm independently organized itself into hierarchical structures, and StrongDM published a production framework called Software Factory that's built around exactly the same hierarchical pattern. And now Anthropic has shipped a feature with 13 distinct operations from spawning, managing, to coordinating agents. This is not really coincidence. It's essentially convergent evolution in AI. Hierarchy isn't a human organizational choice imposed on systems to maintain control. It's an emergent property of coordinating multiple intelligent agents on complicated tasks. Humans invented management because management is what intelligence does when it needs to coordinate at scale. AI agents effectively discovered the same thing because the constraints are structural. They're not cultural. You need someone to track dependencies, right? You need specialists. You need communication channels. You need a shared understanding of what has been done and what hasn't yet been done. We did not impose management on AI. AI effectively discovered management, and we helped to build the structure. And Opus 4.6 is the first model that ships with the infrastructure to run all of this as just another feature.
On the same day Opus 4.6 launched, Anthropic published a result that got much less attention than that C compiler story, but it might matter more in the long run. They gave Opus 4.6 six basic tools: Python, debuggers, fuzzers, and they pointed it at an open-source codebase. There were no specific vulnerability hunting instructions. There were no curated targets. This wasn't a fake test. They just said, "Here's some tools. Here's some code. Can you find the problems?" It found over 500 previously unknown high-severity, what's called zero-day vulnerabilities, which means fix it right now. 500 in code that had been reviewed by human security researchers, scanned by existing automated tools, deployed in production systems, used by millions of us. Code that the security community had considered audited. When traditional fuzzing, by the way, fuzzing is the fancy technical word for finding bugs and making sure you check all the code. It's like fuzzing your hand through the carpet and finding a pin or something. And when manual analysis failed, using a tool called ghost script, which is what you use to check these things, the model independently decided to analyze it a different way, going directly to the project's Git history. That's right. It worked around obstacles and it read through years of commit logs to understand the codebase's evolution. Nobody told it to do this. It just decided to do it. And it identified areas where security-relevant changes had been made hastily or incompletely, all on its own. It invented a detection methodology that no one had told it to use. It reasoned about the code's history, not just about its current state. And it used that understanding of time to find vulnerabilities that static analysis could not reach. Humans didn't do this. This is why it found the bugs it found. This is what happens when reasoning meets working memory. The model doesn't scan for known patterns the way existing tools do. It builds a mental model, and I think that's the only metaphor that works at this point, of how the code works, how data flows, where trust boundaries exist, where assumptions get made, and where they might break down. And then it probes the weak spots with the creativity of a researcher and the patience of a machine that never gets tired of reading commit logs. And I guarantee you, human engineers get tired of that. The security implications alone would justify calling Opus 4.6 a generational release. And yet again, I remind you, it's only been a couple of months. There'll be another one in a couple of months. But this was not the headline feature of Opus 4.6. As exciting as it is, it wasn't even the second headline feature. 500 zero days was the side demonstration. That is the density of capability improvement that has been packed into a single model update shipped on a Wednesday, February.
Look, there are skeptics for every release, and there were skeptics for 4.6 as well. And the skepticism tracks historically. AI benchmark improvements have underdelivered before, and repeatedly for years. And that is why I don't depend a lot on benchmarks. Sure enough, within hours of launch, threads started to appear on the Claude subreddit. Is Opus 4.6 labotomized? Is it nerfed? The pattern seems to repeat with every major model release. Power users who have fine-tuned their workflows for the previous version discover the new version handles certain tasks differently. The Reddit consensus, for what it's worth, has decided that 4.6 is better at coding and worse at writing. I haven't found that personally, but dismissing it would also probably be dishonest. Model releases involve trade-offs. Model releases often involve changes to the agent harness, which is all of the system prompting that the model makers put in that goes around the deployment that they don't talk about and they don't release. We don't know how it changed. We feel the change when we work with the system. So, I'm sure it's possible that if you were a Reddit user who was used to a special prompt pattern that worked on Opus 4.5, you might indeed be frustrated that that pattern did not work on a much more capable model overall. So, I get the skepticism. I also get that people are tired of hearing the world changing every couple of months. It is exhausting to keep up with. But that doesn't mean it's not real. And that is part of why I'm telling so many specific stories. It's important not to just look at the headlines. It's important not to look at some number changing on some stupid benchmark. It's important to hear the stories of how AI is actually changing in production now.
So what does this feel like if you are not an engineer? What does this feel like if you don't write code? Because the C compiler, let's be honest, it's a developer story. The benchmarks are developer metrics. But the change underneath, what makes 4.6 special isn't about developers per se. It's about what happens when AI can sustain complicated work for hours and days instead of minutes. Two CNBC reporters, Dear Drabosa and Jasmine Woo, they're not engineers, right? They're reporters. They sat down with Claude Co-work and they asked it to build them a Monday.com replacement. That's the project management tool, right? A project management dashboard that had calendar views. It had email integration, task boards, team coordination features. This is the product that Monday.com has spent years and hundreds of millions of dollars building. It currently supports a $5 billion market cap for Monday.com. It took these reporters under an hour. Total compute cost somewhere between $5 and $15. I hasten to add that is not the same thing as rebuilding Monday.com. This was personal software. It's not deployed. It's not for sale. It was just for them. So yes, it is a big deal. Yes, it is a generational change in our ability for non-technical people to make software. No, I am not saying that Dear Drebosa and Jasmine Woo can refound Monday.com for $10. The real story is that AI can build the tools you use, the software you pay per seats for, the dashboards your company spent 6 months specking out with a vendor, an AI agent can build a working version of that in an afternoon, and you don't need to write a line of code to make it happen. Yes, it might just be for you. It's a whole new category, people. It's called personal software. It didn't exist just a few months ago. It is now increasingly easy to make that happen.
Our daily experience with AI is changing in ways that are really difficult to benchmark, but that doesn't mean that they're not structural. A marketing ops team using Claude Co-work can do content audits in just a few minutes instead of hours and hours. A finance analyst running due diligence doesn't take a day to do it because the model can read the document set, identify the risks, and produce lawyer-ready redlines in just a few minutes. Our rhythm of work is different now. We can dispatch five different tasks in a few minutes on Claude Co-work. We can dispatch a PowerPoint deck, a financial model, a research synthesis, two data analyses, right? Walk away, you can grab a cup of coffee, and you can come back and the deliverables are just done. They're not drafts anymore. It's just finished work. It's mostly formatted, right? The pattern that's emerging for non-technical users is what Anthropic's Scott White calls quote vibe working. You describe the outcomes, not the process. You don't tell the AI how to build the spreadsheet. You tell it what the spreadsheet needs to show. It figures out the formulas. It figures out the formatting. It figures out the data connections. The shift is coming for all of us, and it's from operating tools to directing agents. And the skill that matters now is not technical proficiency. It's clarity of our intent. Knowing what you want, being able to articulate the real requirement, not just your surface request. That is becoming the bottleneck. Ironically, it's the same bottleneck the developers are hitting, but from a different direction. The C compiler agents didn't need anyone to write code for them. They needed someone to specify what a C compiler means precisely enough that 16 agents could coordinate on building one. The marketing team doesn't need someone to operate their analytics platform anymore. They need someone who knows which metrics matter and can explain why. The leverage across the board has shifted from execution to judgment across every function.
Whether you write code or not, if you lead an organization, the number that should restructure your planning isn't measured in weeks or days. It's actually measured in revenue per employee. Cursr, the AI coding tool, hit $100 million in annual recurring revenue with about 20 people. That's $5 million per employee. Midjourney generated $200 million with about 40 people. Lovable, the AI app builder, they reached $200 million in 8 months with 15 people. For traditional SaaS companies, $300,000 in revenue per employee is considered excellent, and $600,000 is considered elite. That would be Notion. AI-native companies are running at five to seven times that number. Not because they found better people necessarily, but because their people orchestrate agents instead of doing the execution themselves. McKinsey published a framework not for others, but for themselves last month. They're targeting parity, matching the number of AI agents at McKinsey to human workers across the firm by the end of 2026. This is the company that sells organizational design to every Fortune 500 on Earth. And they're saying the org chart is about to flip. The pattern is visible at startups, too. Jacob Bank runs a million-dollar marketing operation with zero employees and roughly 40 AI agents. Micro One conducts 3,000 AI-powered interviews every single day, handled at a tiny fraction of the headcount that enterprise recruiting firms need floors of people to do. Three developers in London built a complete business banking platform in 6 months. A project that would have required 20 engineers in 18 months before AI. Amazon's famous two-pizza team formula, the idea that no team should be larger than what two pizzas can feed, is evolving into something even smaller. The emerging model at startups is now two to three humans plus a fleet of specialized agents, all organized not by function but by outcome. The humans, regardless of what their job title says, and it increasingly doesn't matter, set direction, evaluate quality, and make judgment calls. The agents execute, coordinate, and scale. The org chart stops being a hierarchy of people, and it becomes a map of human-agent teams, each owning a complete workflow end-to-end.
For leaders, this changes the fundamental equation we've been working with for a long time. It's not about how many people do we need to hire now. It's about how many agents per person is the right ratio, and what does each person need to be really excellent at to make that ratio work. The answer to the second question is really the same thing that's distinguished really excellent people for a long time in software. It's great judgment. It's what we call taste, which is vague, but typically means deeply understanding what the customer wants and being able to build it. It's about domain expertise. It's about the ability to know whether the output is actually really, really good. And those skills now have 100x leverage because they are multiplied by the number of agents that person can direct and drive against.
Dario Amodei, Anthropic's CEO, has set the odds on a billion-dollar solo-founded company emerging by the end of 2026 at between 70 and 80%. Think about it. He thinks there's a 75% chance that there will be a billion-dollar solo-founded company by the end of this year. Sam Altman apparently has a betting pool among tech CEOs on the exact same question. Now, whether or not you believe that version, the direction is undeniable. The relationship between headcount and output is broken. And the organizations that figure out the new ratio first are going to outrun everybody who is still assuming they need dozens of developers to do one major software project.
If you follow the trajectory that Opus 4.6 set, by 2026, June, July, August, somewhere in there, I would expect agents working autonomously for weeks to become routine rather than remarkable. By the end of the year, we are likely to see agents building full applications over potentially a month or more at a time. Not toy applications, real production systems with real architecture decisions, complete with security reviews, with test suites, with documentation, all handled by agent teams. The trajectory from hours to two weeks took just 3 months. The trajectory from two weeks to months, that's coming soon. And the inference demand that this generates, agents consuming tokens continuously around the clock across thousands of parallel sessions. Companies are not ready for this. This is what makes the $650 billion in hyperscale infrastructure look conservative rather than insane. Those data centers are not being built for chatbots, people. They're being built for agent swarms running at a scale that people have had difficulty modeling or wrapping their heads around. Opus 4.6 gives us a sense of that future.
So, what can you do about it? If you're sitting here thinking, "Oh my gosh, this is too much. It is coming too fast." You're not alone. You're not alone. You can do this. If you write code, try running a multi-agent session on real work, not a toy problem, a piece of your codebase with real technical depth. Watch how the agents coordinate. That experience is going to change your mental model of what agents can do in a way that matters much more than anything else. Because increasingly, the way we work is the bottleneck for AI. If we want to go faster and build more, if we want to feel like we have the ability to do production work at the speed that AI demands, because increasingly that's what they're going to expect from humans, I got to say, if we want to be ready for the future, the best way we can do it is to change our mental models.
If you don't write code, open up Claude Co-work. Handed a task you've been procrastinating on that's felt really hard, right? A competitive analysis task, maybe a financial model task, a content audit across last quarter's output. Just describe the outcome you want, not the steps to get there. See what comes back. The gap between what you expect and what you get is the gap between your current mental model and where the tools are today. And for managers, look honestly at the 20 hours a week your team spends on operational coordination, ticket routing, dependency tracking. Ask how many of those hours really require excellent human judgment and which are just pattern matching, because I got to say, your AI can probably take over a lot of the coordination work already. And if you run an organization, if you're on the senior leadership team, you got to understand the question for your org has changed. It's not about should we adopt AI, or even which teams adopt it first. It's really, what is our agent-to-human ratio, and what does each human need to be excellent at to make that ratio work, and how do we support our humans to get there? The people working in knowledge work desperately need their leaders to understand that humans need a ton of support to get through this change management and become a new kind of worker that partners with AI. That is not an easy thing, and most orgs are underinvesting in their people.
I tell people in AI that if you are on the cutting edge of AI, it feels like you're time traveling always, because you look at what's happening around you and then you go and you talk to people who haven't heard about it, and they look at you like you're crazy. They say, "No, you can't do that. You can't run 16 agents at a time and run a Rust compiler. What do you mean?" And AI can manage 50 people. And when you tell them that's just a Wednesday in February and more is coming soon, then they really roll their eyes. But welcome to February. This is where we are. AI agents can build production-grade compilers in just two weeks. They manage engineering orgs autonomously. They can discover hundreds of security vulnerabilities that human researchers missed. They can build your competitor's product in an hour for the cost of your lunch. They can coordinate in teams, resolve conflicts, and deliver at a level that did not exist 8 weeks ago. None of this was possible in January. And we don't know where this stops. We just know it's getting faster. That's the tension underneath all of the benchmark scores, all the deployment numbers. The fact is the agents are here, they work, and it's just getting faster from here. And we're not sure what happens next. The question I have for all of us is how do we do a better job supporting each other in adjusting to what feels like a race out of Mad Max some days? Welcome to February. It's moving fast.
If you're a people leader, you need to take time to think about how to support your people to make it through this transition. If you are an individual contributor or a manager, I am putting as many tools as I can up on the Substack to help you get through this. But the best thing you can do, it's not about the Substack. I don't care. It's about you touching the AI and getting hands-on and actually building or trying to build with an AI agent system that launched not in January, not in December, but in February. And you need to take that mindset forward every single month. In March, you should be touching an AI system that was built in March. Every month now matters. Make sure that you don't miss it because our future as knowledge workers increasingly depends on our ability to keep the pace and work with AI agents.