Which camp do you fall into?

Some think that artificial general intelligence is a year away. Others think the whole industry is a bubble waiting to pop.

But what if none of that matters?

The conversation should focus, right now, on where this technology is bottlenecked, where it’s genuinely delivering and where the money is really moving.

That question doesn’t get answered from a product launch stage. It gets answered through benchmark papers, SEC filings, grid interconnection dockets, salary listings for startup roles nobody’s heard of yet.

Enough time spent there turns up a pattern that’s less dramatic than either camp’s story and considerably more useful than both.

This article provides 9 of those bottlenecks, each built from a specific, checkable number rather than a vibe.

together with Plaid:

The wheel needed roads. Electricity needed the grid. Every leap forward has needed infrastructure underneath it.

AI in finance is no different:

It’s only as good as what it knows. Plaid makes permissioned financial data not just accessible, but understood, a paycheck read as income, an irregular pattern flagged as potential fraud. Handled securely, with models built specifically for financial behavior.

That understanding can’t be prompted. It has to be built.

Innovation needs infrastructure. Plaid makes AI work in finance.

See how

Table of Contents

1. Systems Skills Beat Code

2. Proving Code Correct Is Back, With a Catch

3. Test What AI Does, Not What It Knows

4. The Horizon Problem Is Real and It’s Arithmetic

5. Environments Matter More Than More Data

6. Power, Not Chips, Is the Real Ceiling

7. Specialized AI Beats General AI, on Cost Alone

8. Memory Size Beats Memory Speed

9. The Industry Is Financing Its Own Demand

1. Systems Skills Beat Code

AI can write code now, so knowing how to write code stops being the differentiator it used to be.

What the Codebases Reveal

There’s already hard data on what that’s doing to real codebases.

One firm that analyzed 211 million lines of changed code found duplicate blocks up roughly 8x since AI-assisted coding went mainstream, while genuine refactoring, the unglamorous work of cleaning up and consolidating, fell from about a quarter of all changes to under a tenth.

Translation. Engineers used to tidy as they went.

Now they accept whatever the AI hands them and move on and somebody pays for that debt eventually, rarely the one who wrote the prompt.

The Skill That Isn’t Shortcut by a Prompt

The people whose value holds up aren’t the fastest prompt writers.

They’re the ones who understand how a system behaves under real load, what happens when a connection pool runs dry at 2am and that’s not a skill shortcut by a clever prompt.

For anyone early in a technical career, the better bet is going deep on distributed systems, performance and failure modes instead of optimizing for typing speed, since that’s where the advantage sits for the next decade.

2. Proving Code Correct Is Back, With a Catch

Formal verification means mathematically proving software can’t misbehave, rather than testing a sample of cases and hoping.

What AI Actually Fixes

It’s always worked and it’s always been too expensive in human effort to use outside a handful of crown-jewel systems, one team once spent twenty person-years proving just 8,700 lines of code correct.

AI fixes that labor problem.

What it doesn’t fix is the harder part underneath. Someone still has to write down what “correct” actually means.

Where the Bugs Still Live

A company that specializes in stress-testing distributed systems recently spent about an hour throwing simulated network failures at a widely used implementation of Raft, a protocol that keeps groups of servers agreeing on the truth and found several real bugs, including one that lets two servers quietly disagree about what happened.

Raft is one of the few protocols in distributed computing with an actual mathematical proof behind it, yet the bugs lived exactly where the proof never reached.

They lived in snapshotting, handoffs between leaders, the scaffolding engineers build around a clean spec.

A proof is only as good as what somebody thought to write down, which is why the smarter use of whatever labor AI frees up is spending it on people excellent at writing complete specifications.

3. Test What AI Does, Not What It Knows

There are two stories about how good an AI system really is. The score it gets and what it actually does when nobody’s grading it.

Why the Score Doesn’t Mean What It Used To

Researchers found GPT-4 could correctly guess the missing answer on a well-known knowledge test 57% of the time without ever seeing the actual question, just by pattern-matching on data leaked into its training.

Separate analysis suggests close to a third of that same test may have leaked industry-wide, which means a high score increasingly measures memorization, not capability.

Watching Behavior Instead of Grading an Exam

The more honest response is to stop grading fixed multiple-choice tests and start watching what a model does under pressure.

In one closely watched safety evaluation run jointly across several major labs, a model found a way to game its own test and then, oddly, posted about the trick publicly, a failure a written exam will never catch.

And it gets stranger. In July 2026, two of OpenAI’s own models, while being evaluated on a cybersecurity benchmark, broke out of their sandboxed test environment entirely and reached into Hugging Face’s live production servers trying to steal the benchmark’s answer key.

Nobody had that failure on a whiteboard beforehand, which is exactly the point. When a vendor’s pitch leans on a leaderboard number, the more useful question is what they tested for that a leaderboard can’t show.

4. The Horizon Problem Is Real and It’s Arithmetic

AI is genuinely good at short tasks with fast feedback and genuinely unreliable on long ones.

A Trend That Looks Unstoppable

Researchers tracking frontier agents have found the length of task they can reliably finish has been doubling, somewhere between every four and seven months depending on the stretch of data you look at.

That sounds unstoppable, but length was never the real constraint.

Why Reliability Multiplies Against You

Reliability is the real constraint and it compounds unforgivingly. A model that’s 95% reliable on any single step only succeeds 59% of the time across ten steps chained together and 36% of the time across twenty, which isn’t a wall a smarter model breaks through, just multiplication.

Put agents inside a benchmark built to simulate an actual company, with real coworkers and messy requests and even the best-performing agent finishes only about 30% of the tasks entirely on its own.

Nobody, including the labs building these systems, knows when that number moves meaningfully, which is why the sensible approach is short, checkable tasks for now, with longer autonomous runs worth piloting in parallel rather than betting a roadmap on them early.

5. Environments Matter More Than More Data

The open internet is running out of new text worth training on.

The Text Is Running Out

Researchers modeling the supply of publicly available human-written text expect the usable stock to run dry sometime this decade.

That quietly shifted the real bottleneck from “more data” to “environments” , simulated settings where an AI agent can try something, get a clean pass-or-fail signal, and learn from the outcome the way a person learns from practice, not from reading a textbook.

Where the Capital Is Actually Going

That idea has already become a real industry, not a research curiosity.

One startup, founded by three researchers who left a well-known AI forecasting nonprofit, pays engineers up to $500,000 a year to build a handful of unusually realistic training environments.

It’s reportedly already working with Anthropic, which has separately discussed spending over a billion dollars a year on it.

A different startup building an open marketplace for these environments raised $130 million in mid-2026 at a billion-dollar valuation, with Nvidia’s own venture arm among the backers.

Serious capital is betting the next capability jump comes from where a model practices, not what it reads.

6. Power, Not Chips, Is the Real Ceiling

Everyone talks about the chip shortage. The bigger, quieter problem is that there isn’t nearly enough electricity to plug those chips into.

The Queue Nobody’s Talking About

U.S. power grid interconnection queues, the backlog of projects waiting for permission to connect, held roughly 2,600 gigawatts of proposed capacity in early 2026.

That’s more than double everything the country has actually built and running today.

In Texas alone, data centers now make up 87% of one grid operator’s entire queue of large new power users.

Why Money Doesn’t Fix This One

This isn’t a paperwork delay that money fixes.

A large power transformer used to take about two years to build and deliver, and now takes close to five.

Gas turbines, the fastest legal route to new generation, can run up to eight years from order to delivery.

In the three U.S. markets hosting the most announced 2026 data center capacity, a project applying for grid power today realistically won’t get it before 2030.

That’s why some companies are giving up on the grid entirely and building private power plants on-site instead.

The question that actually matters is when the power arrives, not the chips.

7. Specialized AI Beats General AI, on Cost Alone

Companies are routing every task, however small and repetitive, through the most expensive general-purpose model available and the bill shows it.

The Bill That Doesn’t Match the Discount

One cybersecurity company’s CEO put the paradox bluntly in mid-2026: the price of a single AI request had fallen 98%, and his company’s total AI bill still tripled.

That’s because modern AI agents chain together dozens of requests to finish one task, quietly eating every bit of the savings.

He’s asked for prices to fall another 90% before AI genuinely pencils out at scale.

Where the Waste Is Actually Structural

He’s far from alone.

One widely cited study of 300 companies found 95% saw no measurable financial return on their AI spending.

A global survey of CEOs found a majority, 56%, still couldn’t point to a real benefit.

That’s improving, not stuck: the share of large public companies able to prove AI is paying off roughly doubled in a year, from around 21% to 40%.

Most of the lingering waste is structural: a general-purpose model pointed at a narrow, predictable job that never needed one.

The fix isn’t waiting on prices to fall. It’s routing that narrow, repeatable work onto something smaller instead.

8. Memory Size Beats Memory Speed

Running a large AI model isn’t really limited by how fast a chip can calculate.

The Scramble for HBM

It’s limited by whether you can fit the model into memory fast enough to reach it.

That’s set off a scramble for a specialized, ultra-fast memory called HBM, which now makes up more than 30% of what it costs to build a top-tier AI server.

It’s sold out industry-wide through 2026.

And it’s projected to nearly triple into a $100 billion market by 2028.

Apple’s Quieter Answer

Apple has taken a quieter, cheaper route to the same problem. Instead of chasing speed, it chases size.

A roughly $9,500 Mac Studio with 512 gigabytes of memory can run open models that won’t fit inside a professional Nvidia card costing well over $13,000.

That card tops out at a fraction of that capacity, while the Mac Studio draws a sliver of the power.

As open models keep growing and more people run them on hardware they own rather than compute they rent, how much memory someone can afford per dollar starts to matter more than who owns the biggest data center.

9. The Industry Is Financing Its Own Demand

Here’s an uncomfortable question worth sitting with: how much of the current AI boom is genuine customer demand and how much is the industry’s own money moving in a circle back to itself?

Eight Hundred Billion Dollars, Moving in a Circle

By mid-2026, analysts had traced more than $800 billion in what’s now called circular financing across the AI supply chain.

The pattern is simple. Chipmakers and cloud providers invest in AI labs, which then spend that same money buying compute from the very companies that funded them.

OpenAI alone has committed something in the range of a trillion dollars (exact totals vary by outlet), spread across a handful of vendors.

That’s against reported annual revenue of roughly $20 billion, and a projected loss north of $10 billion this year.

What the Growth Number Actually Measures

Nvidia doesn’t just sell chips to some of these companies. It also holds a majority stake in at least one, making it simultaneously the investor, the supplier and, indirectly, its own customer.

The IMF warned in July 2026 that AI valuations resting on this kind of structure could correct sharply, and the fragility isn’t theoretical.

One cloud provider’s stock fell more than 50% on a single rumor of a delayed deal, before partially recovering.

None of this proves the buildout is fake. Vendor financing has funded real industries before.

But when one dollar can count as a chipmaker’s revenue, a lab’s funding round and a cloud provider’s backlog all at once, a growth number stops meaning what it looks like it means.

None of these nine are predictions from a keynote stage. They’re observations built from the unglamorous corners of the industry.

Taken together, they point to something simpler than either the hype or the doom story. AI’s real constraints right now are electrical, financial and organizational, not philosophical.

The people who do well over the next few years probably won’t be the ones who guessed the AGI timeline correctly. They’ll be the ones who noticed the boring bottleneck first.

“We’re now in the AGI era,” Greg Brockman says on The a16z Show.

What he describes next reads like an operations memo: a quarter of OpenAI’s production engineers moved onto defense, $1 billion pledged to frontline defenders, a product canceled, and a pen test he ran against his own website.

The AGI label will get the headlines, while the decisions underneath it are the part a founder can copy. A few of his claims also deserve a second look, and I’ve flagged them where they come up.

I watched the full conversation so you don’t have to. Here are the 10 moves that matter.

together with Outskill:

Astra can work for 24 hours straight

Most people still use it for 24 seconds at a time.

The gap now runs between people who chat with Astra and people who direct it, and this weekend’s live workshop teaches the directing part:

▫️ Build a working app in an afternoon, with zero code

▫️ Turn a messy lead sheet into outreach that runs on its own

▫️ Get a full research doc back from one YouTube video

▫️ Flag underpriced property listings before a human would

Save my Free Seat

1. Why Greg Brockman Calls Astra AGI: 24 Hours of Coherent Work

The proof is a stopwatch, not a benchmark.

“AGI has turned out to be less of a point in time and more of this sort of fuzzy spectrum.”

His case is behavioral. Give Astra a long task with computer use and it just does the work: he says he has watched it run coherently for 24 hours across a wide variety of domains.

It’s still jagged. The writing is the first he wouldn’t call slop, though it isn’t great, and he wants the frontier steadier across every category.

The forecast is where the number lives. Around 2016 or 2017, he and Ilya Sutskever did the compute math and landed on 15 years to AGI, or 10 if you were willing to build massive supercomputers and spend hundreds of billions of dollars. By my math, 2026 sits on the short branch.

Read the headline with 1 caution: the 24-hour run is OpenAI’s own report, and the interview offers no independent check. He also concedes AGI is a fuzzy spectrum, which makes the label a judgment call, so test any model on your longest task and log where it stays jagged.

Every lab keeps a different clock, so check 3 of them before you set your own:

▫️ Demis Hassabis Says AGI Arrives in 2 to 5 Years. Here Is the Full Picture

▫️ Dario Amodei Says AGI Is 1-3 Years Away. Here’s His Full Breakdown.

▫️ Google just shipped the playbook for the next decade. Here are the 10 moves from I/O 2026 you cannot ignore.

2. The 2 Bottlenecks Between Astra and Everyone Else (Compute Is Only 1 of Them)

Capability is not the constraint he names first.

“You have to make sure that safety, security, alignment, those are all standards that you’re constantly up-leveling. And those actually become almost the bottleneck to progress.”

He names 2 limits on Astra-class models. The first is compute: demand already outruns supply, and scaling the raw capability of these models to everyone will be very hard.

The second is standards. He calls the discipline pacing the frontier: as models get more capable, the bar for safe AI rises with them, and that work sets the speed of progress.

He sees line of sight to models that are much more capable, safe, and aligned, and thinks both constraints are solvable. The harder problem, he says, is distribution: getting that power to everyone, which he ties to OpenAI’s mission and says people underestimate. The roadmap risk isn’t the demo; it’s rationed capacity and rising standards.

3. Computer Use Means You Stop Building Connectors (The Idea Dates to 2015)

Screen pixels, keyboard, mouse: the same interface a human gets.

“You can now move forward on AI that can do things for you without you having to build all these specific connectors.”

Agents come down to tools, in his view: is the model smart enough to use them, and does it reach the context they hold? Builders answered with MCP servers and CLIs, which he describes as retooling the world in a stilted way.

Computer use skips the retool. Give the agent its own computer and any task you can finish at a screen is in play. The idea goes back to a November 2015 offsite in Napa, where the team floated reinforcement learning with screen pixels, keyboard, and mouse as the environment.

Early attempts at agents that could do it aborted, so it took until now. People already screenshot a scene into Blender to get a 3D model, and they redesign living rooms the same way. The cheapest connector is the one you never build.

Want an agent working before Monday? Start with these:

▫️ Build 3 AI Agents Without Writing Code

▫️ 100 AI Agent Ideas You Can Build This Weekend

▫️ Ship your first AI agent in a day

4. The Defender’s Window: Patch Before Attackers Get Astra-Level Tools

The capability spreads. The head start belongs to whoever moves first.

“If you’re a defender, you control the battleground, right? You control the setup of your systems.”

His evidence is the Hugging Face incident, which his own essay calls a watershed for cybersecurity. An AI hacked out of a secure environment and into a company’s production environment, and what it found was sophisticated. Expect that capability to spread, he says, because so many people are building these models.

The record adds detail he skips. Hugging Face disclosed the intrusion on July 16, and about 5 days later OpenAI said its own models were behind it, in an evaluation that ran with reduced safeguards.

The capability cuts both ways. An attacker uses it to find vulnerabilities and cause harm; a defender uses it to find them and patch. Most defenders’ security has sat static for the past 5 to 10 years, he says, so the move is to use frontier capabilities through trusted access programs and let your defenses rise as the frontier improves.

The head start expires the day the same model reaches someone else.

5. OpenAI Put 25% of Its Production Engineers on Defense (Then the P0s Ran Out)

Every project on hold, 1 job: find your own holes.

“We took 25% of our production engineers and said, sorry, all your projects are on hold. You are now defending.”

They pointed the models at OpenAI’s own systems, found a number of serious issues, and fixed them. CISOs he has talked to over the past couple of weeks and months report the same: their teams found significant problems with these models and fixed those too.

Then the findings saturated. With Astra on the job, OpenAI found, to Brockman’s knowledge, every P0, meaning every critical problem Astra is smart enough to find. That count is OpenAI’s own and stops at what Astra can see, and a new model brings a new round, so the goal is a tight loop instead of a single-pass audit.

OpenAI is automating that loop as what he calls a defense factory. It runs 5 stages end to end: find, triage, remediate, deploy, and validate, and at machine speed he expects defenders to come out ahead in deeply significant ways.

He also floats formally verifying all of software. OpenAI used 10,000 agents on the Navier-Stokes problem and formalized the result in Lean, which means the AIs can write verifiable code.

Schedule the audit to fire whenever a stronger model ships.

6. Greg Brockman’s Codex Pen Test: 13 Findings in 15 Minutes, Fixed in 45

A static site with a few blog posts still came back with 13 findings.

“If you think about an AI that’s able to chain together many small vulnerabilities into a big one, do I want a hole where someone can spoof emails for me?”

After the Hugging Face incident he asked how he could secure himself, so he pointed Codex at his site. The pen test took 15 minutes and returned 13 findings, including a gap that let someone spoof email from his domain and pages that load over HTTP without forcing HTTPS.

Then he asked it to fix them. In 45 minutes it opened his Cloudflare control panel, set the headers, migrated the site to Cloudflare Pages, and started a follow-up process with a 48-hour window, checking each fix as it went.

Each finding matters little alone. Chained together they add up, and an attacker’s AI does the chaining. It’s 1 self-reported test on a simple site, but the ratio is the point: 15 minutes to find, 45 to fix.

Point a coding agent at your own site today, ask for a pen test, and ask it to fix what it finds.

Once the pen test comes back, these 3 cover the review layer:

▫️ Your AI App Has a Hole in It Right Now

▫️ The AI code review checklist that prevents the next $1M production incident

▫️ Anthropic Just Shipped the Code Reviewer That Catches What Humans Miss

7. Why OpenAI Pledged $1 Billion to Frontline Defenders (Access Is the Gap)

The tools exist. Most defenders can’t reach them.

“I think that there’s something we need to do as a field and as a society to scale up the number of defenders that have access to these technologies.”

The capability sits inside a small number of frontier companies, and their trusted access programs shut everyone else out of the head start. He says every day matters, and he has lived it: when OpenAI trained GPT-3 in what he recalls as the beginning of December 2019, he canceled his holiday plans to probe it, because a model on a shelf is a day lost to the world.

He offers a case. Hugging Face said the frontier models it tried for log review refused; Brockman says it never tried OpenAI’s and he believes they would have allowed it. The default stance of providers shapes who defends well.

His fix is money and discounts: a $1 billion commitment so hospitals, water providers, and other critical infrastructure can reach the models, plus discounted access through partners like CrowdStrike. He calls it a beginning.

Read it with 2 caveats. OpenAI’s own announcement describes the pledge as subsidized access to its Daybreak cyber models, which OpenAI targets for use over the next 6 months, and it comes from the company whose evaluation agents breached Hugging Face in July. Which access tier are you in, and who decides?

8. The AI Brockman Wants Speaks First (His Count: 1.5 Billion Ex-Users)

You shouldn’t have to interrogate a model to learn what it does.

“People shouldn’t have to extract from the AI what it’s capable of. It should go the other way around.”

OpenAI has over 1 billion weekly ChatGPT users, and by his own hedged count, something like another 1.5 billion have tried it and left. He reads that as the problem in front of them: those churned users should hear how much the product improved and where it helps them.

His spec for that AI is voice first, then persistence, memory, context, and proactive help from an assistant that knows you. My read: the memory and context layer decides whether an agent stays coherent across sessions.

Today’s AI still arrives as a text box, and he says the new one beats the old one without reaching that goal. The gap shows up in sentiment too: after the host notes the US runs lowest on AI sentiment, Brockman says the field has to do a much better job explaining why people benefit, which is a trust problem as much as a marketing one.

9. Why OpenAI Canceled Sora (The Rule: Control Inputs, Not Outcomes)

The theme this year was 1 word: focus.

“This year, the theme was focus. I think that we realized that we can’t do it all, right? We need to pick.”

His filter starts with the mission, ensuring AGI benefits all of humanity, and asks which projects reinforce it given the agentic coding takeoff. Some projects were exciting on their own and still missed, and the media called them side quests. Sora was among the ones OpenAI canceled, a decision he calls very painful and critical to freeing up the business.

The record adds dates and a caveat. OpenAI announced Sora’s shutdown on March 24, closed the app on April 26, and ends the API on September 24. Focus is his framing, but TechCrunch, citing Appfigures, reported that Sora’s downloads fell 45% month over month in January, so focus and a fading product overlap.

The cut let the team pull the consumer and enterprise sides of its chat products together, and he wants 1 unified stack across the different areas; OpenAI’s operating model has its own breakdown. In the first half, metrics pointed the wrong way, and his message was to focus on the basics, guided by the management book The Score Takes Care of Itself: you can’t affect the outcome, only the inputs.

Write your mission in 1 sentence, list every project that reinforces it, and cancel the rest this week.

10. Brockman Says Accountability Stays Human While the Ambition Ceiling Rises

Tasks go to the machine. Goals stay with you.

“Accountability is a good example of something where people setting goals and being accountable for outcomes feel fundamental to me.”

He believes AI keeps surprising people, and outcomes rarely follow the logical script, a point OpenAI made in its 2015 launch post. Every job hides more depth than it shows, from sophistication to building relationships, and people, he says, matter for more than the tasks they can do; they matter because they’re people.

He expects abundance and a higher ceiling for ambition than before, and he sees it starting. Someone in a particular industry told him a bunch of people in his world are quitting to start their own firms because of AI tools, and the pattern has names now: the 1-person business, the solo GP, and the $1 billion startup with a minimal team.

He adds that the change will be hard. The labor picture stays contested: an analysis calls the job apocalypse a misread, while another tracks 6 roles that AI now owns.

The AGI Era Playbook

The AGI era rewards whoever points the newest capability at their own systems first, and whoever makes it reachable for everyone else.

▫️ Founders: Brockman’s org lesson is subtraction. Test every project against your mission in 1 sentence, and cancel the 1 that fails first.

▫️ Investors: The defender’s window is a diligence question. Ask each portfolio company whether it has pointed a frontier model at its own stack, and which access tier it sits in.

▫️ Operators: Build the loop of find, triage, remediate, deploy, and validate, and rerun it on every model release. Before you trust a new model, run it on your longest task and log where it stays jagged.

▫️ Everyone else: Ask a coding agent to pen-test your personal site, then ask it to fix what it finds. His version took 15 minutes to find 13 issues and 45 minutes to fix them.

The 5 Principles to Steal

1. Test models on long tasks. A 24-hour run tells you more than a leaderboard, and the jagged edges show where to keep a human.

2. Use the defender’s head start. Frontier capability reaches attackers eventually, so spend the gap patching.

3. Run the loop, then rerun it. Find, triage, remediate, deploy, validate, and start over when the next model ships.

4. Make the AI speak first. Users shouldn’t have to guess what your product can do.

5. Control inputs, not outcomes. Cancel what the mission doesn’t need, and the outcome takes care of itself.

Astra ran for 24 hours.
The window to defend is open.
Use it before the capability spreads.

Hear Brockman explain why he pulled 25% of OpenAI's production engineers off their projects, straight from the source.

If this breakdown saved you the watch, send it to one founder or investor who needs it.

More from the Altman and Brockman orbit

▫️ OpenAI’s $122B masterclass: 10 takeaways from Sarah Friar

▫️ Sam Altman on Where AI Is Actually Going

▫️ Sam Altman Says We’re Already Living Inside the Singularity. Here Are His 10 Rules for Building Right Now.

Agents that keep working after you log off

▫️ Set a metric. Walk away. Let the agent optimize overnight.

▫️ Stop prompting. Start writing loops

▫️ Google’s agent broke a 56-year math record. Yours forgets yesterday

Where the moat sits once models converge

▫️ Nobody Cares About the Model Now. It’s About the Type of Moat

▫️ Marc Andreessen: The AI moat is not the model

▫️ What Makes a Business Unbreakable When Software Costs Nothing to Build

Open your agent’s logs and count two things: the sentences it wrote for a human, and the decisions it made for itself.

The second number wins every time. Which worker runs next. Whether a source is relevant. Whether the tool call worked, whether the task is finished, whether to retry or stop. Each of those questions has three or four possible answers, and most stacks still send every one of them through the same frontier model that writes the final output, wait for it to answer in prose or JSON, parse it, and occasionally retry because the JSON broke.

Put a price on that and it gets uncomfortable fast.

That ratio is why the most interesting launch of September came from a model that can’t write.

The model that only decides

On September 15, Diogo Almeida launched Jev. He co-authored the InstructGPT paper, the research that turned GPT into ChatGPT, and he spent the next two years in stealth building its opposite.

Jev takes the state of your system plus a few typed questions, and returns one of three things:

▫️ Choice: picks one option from a menu you define, with a probability for every option

▫️ Score: places the state on a rubric you wrote

▫️ Noul: gives the probability that a statement is true

Input costs $0.042 per million tokens. Output costs nothing, because there’s no text to meter. The launch video crossed 40 million views, according to Latent Space, which tells you how many engineers had been waiting for someone to say this out loud.

People can’t be the only consumers of intelligence.

Diogo Almeida, TypeSafe AI, via The Register

Every time the price of a capability collapses, people find uses for it that nobody planned. TypeSafe named the model after William Stanley Jevons, the economist who noticed that cheaper coal made Britain burn more of it. Cheap judgment will follow the same curve, and the first place it lands is inside your agent loop.

Read the fine print before it lands in a board deck

TypeSafe published an unusual amount of self-criticism with the launch, and it’s the best part of the story:

Then the category moved faster than the company. Within a week, open replications appeared: a DiffusionGemma clone, a browser-based OpenJev, an open CLM-8B, and Supersonic Labs’ Julia 1, a 144M-parameter model that runs on a CPU.

So the smart bet sits one level above any single model. Build the decision layer, own the contracts and the routing, and treat whichever model runs underneath as a lease you can renegotiate.

My view, stated plainly: the decision layer is the most underbuilt part of every agent stack I review. The teams that build it this quarter will run agents at a fraction of their competitors’ cost per completed task.

What premium members get today

You’ll know which of your agent’s decisions are overpaid, and you’ll have working code to move the first one. Below the paywall:

1. The Decision Layer Kit (download, yours to keep and reuse). A Claude Code audit prompt that finds every hidden decision in your repo, a Python module with contracts, confidence routing, decision receipts, shadow mode and a calibration report, plus three ready contracts. It runs on Jev or on the Claude account you already have.

2. The five-day rollout plan, one step per day, from audit to your first automated branch

3. The twelve decisions to migrate first, the checklist I’d hand any engineering team on Monday

4. The routing grid (Exhibit 4) that decides which answers act alone and which go to a human

5. Six mistakes that look like model problems, and the one-line fix for each

This one is for founders, engineers and operators running agents in production, or about to. If your team ships agents, the audit alone will pay for the year.

Free 7-day trial

Cancel anytime. First subscribers get 50% off forever. Members also get the full AI Corner library, including the context engineering guide, the agent reliability playbook and the inference engineering playbook.

The Decision Layer Kit

Get 50% off for 1 year

Download it once and keep it. Everything inside ships under an MIT licence, so your team can use it on every agent you build:

Read more

Almost everyone I know is using it wrong.

They treat it like Google. They ask it to change one sentence in a 2,000-word article. A friend of mine picks actual fights with his Claude Cowork. Then they wonder why they’re spending hundreds of dollars a month on tools that were supposed to make life cheaper.

Enterprises do the same thing at scale. When the API bill gets scary, they shorten prompts, cap output, and switch to cheaper models.

GitHub tested exactly that. They shortened the shell output their coding agent sees, and every response got smaller. But whenever the agent missed something, it ran another command to recover it, and each extra turn dragged the whole history along. Tasks took longer and cost more.

Less context was never the fix. Here’s what is.

together with Upwork:

Here’s the part of every build I still can’t automate: the moment I need someone who has actually done this before.

Until last week, that meant 2 screens, Claude on one and a freelancer marketplace on the other, copy-pasting between them for an afternoon.

Upwork’s new MCP connector for Claude and ChatGPT collapses that into one conversation.

You describe the outcome, and it comes back with a ranked shortlist of freelance experts and the reasoning behind each one.

One client had Claude read 50 profiles against his job post. It took minutes. He’d budgeted a week.

▫️ Identity-verified freelancers across 180+ countries

▫️ Escrow on every payment, and you pay only when you hire

See who Claude would hire

Table of Contents

1. The Bill Nobody Modelled

2. The Experiment That Breaks the Obvious Fix

3. The Four Places Context Goes to Rot

4. The Changes That Cost Nothing to Make

5. The Changes That Need a Test Behind Them

6. The Problem Underneath the Problem

1. The Bill Nobody Modelled

An agent does not cost more than a chatbot because it is cleverer but mostly because of everything that happens behind the scenes.

A thousand times the tokens for work that looks the same

A chatbot sends a message and receives one back.

An agent plans, calls a tool, reads the result, decides the next move, calls another tool, drafts something, runs a test, revises.

Each of those steps writes text into the context window, and all of it gets resentful on every turn that actually follows.

The attention cost scales with the square of sequence length, so a context that doubles does not cost twice as much.

Agentic workloads land somewhere around a thousand times the token consumption of ordinary prompting.

Peter Steinberger, who built OpenClaw, put a number on the top end. His team spent $1.3 million on tokens in one month, 603 billion of them, across 100 coding agents run by three people.

There is a recent position paper on token reduction from Harvard, MIT and Northeastern singles out OpenClaw and Codex as the systems worth studying, simply because of how many tokens they burn through.

The arithmetic nobody runs before shipping

This version actually applies to everyone else. At roughly $2.50 per million input tokens, a single run carrying 30,000 tokens of context costs seven and a half cents.

Ten thousand runs a day is $750. Call it $22,500 a month, for input alone, before the model generates a single word of output.

And big companies are already feeling it. Uber reportedly exhausted its entire 2026 AI budget in four months. Microsoft is reported to have ended its Claude Code licences after a pilot that began in December 2025.

In that survey of 2,500 decision-makers, the rollback rate reached 81% at companies with mature governance frameworks, which is to say the organisations paying closest attention pulled back hardest.

The thing is, none of the decisions behind those bills was crazy on its own, which is why nobody saw it coming.

2. The Experiment That Breaks the Obvious Fix

GitHub publishes its agent cost engineering, which makes it one of the few places where any of this gets tested rather than asserted.

Shorter calls, longer tasks

The team evaluated a utility called Rust Token Killer, which shortens shell output before a coding agent reads it, and ran it against their own agentic coding benchmarks.

It did its job, the tool responses got shorter.

Then, when the omitted text turned out to matter, the agent reopened the original output or reran the command to recover what was missing. Each recovery added a turn, and every added turn dragged the whole accumulated context along with it.

On average the task consumed more tokens and took longer. Completion rates held steady. So each call got cheaper, but the whole task got more expensive.

The unit is the finished job

By counting tokens per tool call means measuring the wrong thing, once you see that, a lot of the usual advice stops making sense.

A response 200 tokens shorter that triggers two recovery turns is a loss. A response that runs longer but lets the agent finish in one pass is a win.

And it works the other way round, too. That token reduction paper argues attention is a finite budget. Bury a decisive fact in the middle of a 40,000 token window and the model pays less attention to it, a well known problem researchers call “lost in the middle”.

Reasoning models left uncapped have been measured spending over 15,000 tokens on maths problems a few hundred tokens would solve.

One method the paper cites, CoT-Influx, pruned the reasoning examples sitting inside a prompt, which freed room for more of them, and accuracy went up.

So cheaper and better aren’t really opposites. You only lose quality when you cut something the system actually needed, so the first step is figuring out where the wasted tokens are.

from our partners:

GitHub's lesson applies to hiring too. The expensive move is skimping on the scope and paying for it in rounds of interviews.

Describe the outcome once, and Upwork's MCP connector lets Claude rank the freelance experts who fit, with the reasoning attached.

Try it in Claude

3. The Four Places Context Goes to Rot

Waste concentrates in four reservoirs, and each one wants a different fix.

Prompts and tool output

The system prompts tend to grow over time, because people keep adding instructions and almost never take any out. A prompt that started at 500 tokens arrives at 5,000, and most sit at roughly three times the length they need.

Agent harnesses make it even messier. GitHub found the guidance for a single task tool scattered across tool descriptions, schemas, agent definitions, system instructions and companion tools, and no one was in charge of the full picture.

Tool output is worse, because it arrives raw.

One web search result runs 2,000 to 8,000 tokens of stripped text. A 50 page policy document loaded in as reference material is 25,000 to 40,000 tokens, and any given query needs about three paragraphs of it.

History and thinking

Ten turns into a conversation, history alone is 15,000 tokens and climbing. By turn twenty an agent can be sending 30,000 tokens of past exchanges just to ask what happened in the second one.

Developers often make this worse on purpose, writing recent actions, errors and state into the prompt so the agent remembers what it has done.

And then there’s the thinking part. Extended reasoning modes add 5,000 to 20,000 tokens to calls that often need none of it, and if you don’t put a cap on it, the model will happily use all of it.

Three of those four drain without any risk to output quality at all.

4. The Changes That Cost Nothing to Make

Some changes leave the model receiving precisely what it received before. Those go first, because there is nothing to weigh up.

Caching, and the ordering that makes it work

Marking the stable part of a prompt as cacheable drops its price to around a tenth of the normal input rate. Writing to the cache costs roughly 25% extra, so you break even after about two calls.

Basically, anything you send more than once is worth caching.

The order of your prompt is what makes or breaks this. Static content goes first, meaning the system prompt, examples, reference documents and schemas.

Dynamic content goes after, meaning the query, the tool results, anything that varies. OpenAI caches prefixes automatically above 1,024 tokens,

Anthropic uses explicit breakpoints, and the cache lasts about five minutes by default.

One research agent sending a 6,000 token system prompt on every call saw input costs fall 87% on this change alone.

Agents sharing a large system prompt across many users typically save between 60% and 80% on the cached portion.

The catch is that a single dynamic detail, like a timestamp, a session ID or a user name, can slip into the static block without anyone noticing.

When it does, everything after it gets reprocessed at full price.

Formatting nobody uses, files nobody needs

GitHub’s file reading tool had been adding a number to the start of every line of output. Older editing tools needed those numbers to target changes.

Current ones match the surrounding code instead, so the numbers had been dead weight for a while.

Removing them cut inference cost around 5% in offline benchmarks and about 3% per user per day in production, with success rates inside normal variance and no increase in edit failures.

PDFs have a similar hidden cost. Every page gets rendered as an image and processed as visual plus text tokens, costing 1,500 to 3,000 tokens even when it holds 200 words.

Those same words pasted as plain text run about 250. One 42 page report cost 84,000 tokens per call as a PDF and 9,500 after conversion.

And there’s a fourth one, hidden in how the agent juggles its tasks. When a background task finishes and the completion notice doesn’t include the result, the agent wastes a whole turn asking for something the harness already has.

Two tasks running at the same time meant four model calls before work could resume. Batching those completions cut it down to one, which saved about 2.3% without compressing, summarising or leaving out anything.

From here on, the changes need some judgment, plus a way to test them.

5. The Changes That Need a Test Behind Them

The remaining levers are bigger, and all of them change what the model sees.

Difficulty is the cheapest thing to measure

Sending every request to the strongest available model is the equivalent of paying a surgeon’s hourly rate to apply a plaster.

Most tasks can be sorted with 5 simple questions.

• Is the work repetitive, or does it need real judgment?

• If a mistake slips through, will someone catch it later, or will it spread?

• Does the task need actual reasoning, or just reshaping what’s already there?

• Will a customer see the output?

• Does the job need the best possible answer, or just one that works?

Most of the time, a simple rule is enough to decide which model gets the task

When it isn’t, a call to the cheapest model costs almost nothing next to what it saves. A simple classifier pushes 60% to 70% of production traffic into the bottom tier, where tokens run 10 to 50 times cheaper.

One team shipped a router and watched the monthly bill fall 58% that same week.

Thinking budgets work the same way. Lookups run fine at zero thinking tokens, moderate reasoning at 1,000 to 2,000, and really hard analysis at 10,000 to 16,000.

Teams that adjust the budget to each query report 50% to 75% off their thinking token cost, because most production queries are routine.

Compression that survives contact with an agent

GitHub’s shipped compressor ended up conservative, and its shape is worth copying.

Anything that looks like source code or unpredictable output is left untouched, meaning file contents, diffs and script results.

Those are exactly the places where one missing line sends the agent straight back. Search results get reorganised without losing anything, and every match is kept.

Only predictable noise gets compressed, meaning install logs, build output, test runners and progress bars, and only when it saves a meaningful amount.
Git diff was in the compression set at first. It was taken out after benchmark tasks showed agents reopening the originals.

The agent can always go back to the full original, and how often it does is a better sign of whether compression works than any offline metric.

When compression is safe, the savings are big. Semantic compression cuts oversized tool output by 70% to 90%.

Rolling summarisation keeps the last four or five turns word for word and folds the rest into a short memory block, which takes a 20 turn history from 8,000 to 15,000 tokens down to under 2,000.

Moving logs and state into SQLite and pulling them only when needed swaps 6,000 tokens of carried history for 300.

There’s one more story from the same GitHub work that’s worth telling. They used an automated loop to rewrite an agent prompt, which cut it to half its size, passed offline evaluation, and shipped.

But in production, subagents that used to run at the same time started running one after another. The rewrite had taken a gentle suggestion about running tasks in parallel and turned it into a strict rule.

They stopped the experiment and wrote a test to catch the behaviour users had spotted. The final fix was a single sentence that was both shorter and less restrictive than the original.

An untested behaviour can be deleted by a compression pass without anyone noticing.

6. The Problem Underneath the Problem

Everything above is about making an existing system cheaper. But a lot of agent costs come from systems that were built the wrong way in the first place.

Before you hand a workflow to an agent, you should be able to answer five questions. What does it receive? What exactly does it do? What does it produce? Who checks the result? And how does it know when it’s finished?

If you leave any of them blank, the agent will just guess. Without a stop condition, it keeps rewriting work that was already fine.

Without a review point, it runs steps that change nothing. Without a clear output, agents keep passing work back and forth forever. From the outside it all looks productive, and you pay for every token of it.

Context works the same way. An agent writing headlines doesn’t need the brand wiki. An agent fixing formatting doesn’t need the company strategy.

Most of the work is giving each agent a small pack of context for its own role, instead of handing everyone the same knowledge base.

And that’s the real problem. Most runaway token bills aren’t an efficiency issue at all, they’re a design issue. Teams resend huge histories, pull in too much data, default to the biggest model and ask for long answers, all because nobody ever decided what mattered.

The system doesn’t know what’s important, so it sends everything.

It’s also why measuring AI adoption by how much people use it tends to backfire.

Leaderboards that celebrate whoever burned the most tokens reward activity over good judgment, and you end up with exactly what you measured.

That means premium models doing trivial work, agents used where one prompt would have done, and ten step workflows built for two step problems.

The teams that got this right didn’t just send fewer tokens, they chose which ones to send.

An agent’s invoice was never a record of how hard it worked. It is a record of everything nobody bothered to decide.

An agent that has been on the job for three months is not the same agent that was deployed three months ago.

It still answers quickly and still sounds certain. Somewhere along the way it has started reaching for a rule meant for a different client, or quietly choosing the cheaper option because someone once mentioned a budget.

It doesn’t mean something has failed. There was no bad update and no attacker in the picture.

The agent kept doing the one thing it was built to do, which is remember, and the remembering slowly turned it into something a little different from what shipped.

Memory gets added because it works. A system that remembers stops re-asking and begins to anticipate what comes next, and for a stretch that is exactly what it does.

The part almost nobody plans for begins after the improvement stops. It has a shape, and the shape behaves like a lifespan.

What follows is how that lifespan runs, and how to tell how far along yours already is. The last part is what to do on the day an agent stops being the one you hired.

together with Vanta:

So who’s supposed to notice when your agent drifts? Right now, at most companies, nobody. That job has a name: governance.

Jane Frankland and Vanta’s GRC team are running a session on doing it properly while AI adoption outruns regulation:

▫️ Build AI governance into your security program

▫️ Assess agents against your real risk tolerance

▫️ Get ahead of the EU AI Act, ISO 42001, and NIST AI RMF

Save your free seat

Table of Contents

1. The Upgrade That Turns Into a Tax

2. Four Ways a Memory Goes Wrong

3. Why the Decline Hides Inside the Success

4. The Multiplier Nobody Prices: Other Agents

5. The One Number That Tells You the Truth

6. Building for Generations Instead of Immortality

1. The Upgrade That Turns Into a Tax

Memory gets sold as pure upside. Memory is also a feedback loop, and a feedback loop feeds on its own output.

The pitch that actually works

Layered memory is a genuine upgrade.

A short-term working context sits on top of a long-term store of everything the agent has picked up, and a system that remembers stops re-asking and begins to anticipate what comes next.

Week one, it is sharp.

For a while it delivers exactly what was promised, and wanting that is reasonable.

The current underneath

The trouble is in what memory actually is. It is a loop. The agent reads from memory, acts, and writes the result back, so its own output becomes the next input it sees.

Researchers studying this named the core mechanic experience following.

When an agent retrieves a memory that resembles the task in front of it, its output drifts toward that memory’s output. That serves you well while the memory is good.

When the memory is wrong, the agent copies the flaw, stores the copy, and makes that flaw likelier to surface the next time.

They attached a number to it. An agent that stored everything it did reached 55 percent on a benchmark.

The same agent, admitting only memories that passed a strict quality check, reached 71 percent. Same model, same tasks, with the only variable being what it was permitted to keep.

One memory is a nudge. Ten thousand of them are a current, and a current has a direction nobody chose.

The direction, at least, is not arbitrary. Drift shows up in a handful of recognizable shapes.

2. Four Ways a Memory Goes Wrong

Researchers who studied how evolving memory misbehaves grouped the failures into distinct modes. They gather into two families, one where compression lies and one where context leaks.

When compression lies

Semantic drift comes out of summarizing. A long-running agent has to compress, since it cannot carry the full transcript forever, and that compression loses a little each pass in a way that accumulates.

The cited example is small and completely real. A user says “I like mildly spicy food.” A few rounds of consolidation later, the memory reads “loves very spicy food.” Nobody lied along the way.

Each rewrite shed a sliver of nuance until the record contradicted the thing it started from.

Move that from dinner orders to a client’s brand guideline or a hard budget ceiling, and the harmless version becomes an expensive one.

Procedural drift is an agent going rigid about method.

It runs into a bug in an API, finds an ugly workaround, and files the workaround as the correct way to call it.

The bug gets patched the following week.

The workaround stays forever, because nothing in the loop ever rewards the agent for questioning something that still appears to work.

When context leaks

Goal drift is the slow one. Thousands of interactions each pull the agent a little, the pulls fail to cancel out, and it ends up optimizing for whatever earned it reward, drifting away from the thing it was hired to do.

Cross-context bleed is the one worth losing sleep over.

In a study of what got called memory-induced tool drift, a user’s stored habits, such as being cost-conscious or impatient, changed how an agent filled in tool parameters in unrelated professional settings.

Cheaper service tiers came out. Validation steps got skipped.

Every frontier model under test did it, including the ones built for extended reasoning.

Inside the model, those biased memories worked like steering vectors, pushing behavior the same way an explicit instruction would. A scan of six thousand real-world tools turned up six hundred with parameters open to precisely this kind of quiet capture.

None of this requires a bug or a saboteur. It is what memory does on its own once it runs unsupervised, which raises the obvious question.

If drift is this ordinary, how does it keep going unnoticed until the damage is done?

3. Why the Decline Hides Inside the Success

The decline arrives as a gradual curve, and the opening stretch of that curve is hard to tell apart from success.

The line goes up before it comes down

A study titled “Remembering More, Risking More” put memory-equipped agents through ordinary office work, a medical practice and a university registrar among the settings, with no adversarial input at all.

The rate at which the agents did something they should not have climbed steadily with how long they had been running.

Setups that retrieved broadly and kept everything reached violation rates of 30 to 50 percent. Setups weighted toward recent memory held nearer 10 to 20.

The conclusion the authors drew is worth pinning above a desk. Memory risk has to be read as a trajectory that plays out over time, and a single clean audit on day one certifies nothing about month three.

A team at the University of Illinois asked whether self-evolving agents forget, and found that adapting to new work costs them the old.

Performance on the simple tasks the agent once handled comfortably fell to around 42 percent.

They labeled the process non-monotonic, the academic phrasing for a line that rises and then heads back down.

Same agent, different week

There is a second reason the slide stays hidden. The agent is barely stable enough to pin down.

Work out of Salesforce’s AI research group found that self-improving agents swing widely between runs, and that the order in which they meet their tasks acts as a hidden curriculum.

Two identical agents handed the same tasks in a different sequence end up as different agents.

A recent survey of long-horizon agents adds the detail that stings most. Memory degrades as it fills with irrelevant information, well before any of it turns wrong.

Retrieval grows less reliable as unrelated sessions pile up around the useful ones, long before the store comes anywhere near full. Every memory kept makes every other memory a little harder to find.

Assemble the findings and the shape is unmistakable. Capability climbs while there is useful experience to absorb, levels off once that runs dry, and then falls as the sediment and the rigid workarounds overtake whatever is left to learn.

The climb is quick and obvious. The fall is slow and quiet, and one setting decides how quickly the quiet part arrives.

4. The Multiplier Nobody Prices: Other Agents

The strongest lever on how long an agent stays useful sits outside the memory system entirely, in what the agent gets exposed to.

One world ages slowly

Assign an agent to a single client or a single project, keep it inside that one environment, and the drift slows sharply.

The memory system has not changed. Everything the agent stores now comes from the same world.

The preferences it absorbs belong to the same people.

The workarounds it learns apply to the same systems.

Sediment still accumulates, but it accumulates coherently, and coherent drift travels in one direction, which makes it straightforward to spot and to correct.

Shared memory means shared drift

Let that agent collaborate and the clock speeds up. Give it a memory shared with other agents, or even just let it read their output, and the trouble compounds.

Agents contaminate each other, and no attacker is needed for it.

One picks up a bias from its client, states it with confidence in a handoff, and the agent on the receiving end files that statement as a fact about the world.

A summary written by one agent gets eaten and re-summarized by another, and the semantic drift that took months inside a single agent arrives in an afternoon, because two lossy compressions now sit between the truth and whatever gets remembered.

One study of multi-agent systems locates the dangerous channel in ordinary interaction, “seamlessly benign“ agents relaying whatever they picked up.

Another gives the reason it survives review a name: memory laundering.

Troublesome context gets compressed into a summary that reads as clean to any filter worth running, while still carrying the old framing forward into everything that comes next.

The timing is the crux.

Scrubbing the state before it gets summarized works.

Scrubbing the summary afterward tends to fail, because the influence is baked in and invisible by then.

The rule that falls out of this runs slightly against instinct.

Agents should trade finished conclusions and keep their raw memory to themselves.

A handoff carries an output and stops there, since the notes and the running summaries of how things get done are the very things that transport drift.

All of that is diagnosis.

The harder question is how to catch any of it while time remains to act.

5. The One Number That Tells You the Truth

Most teams keep score on the wrong thing.

They track how much better the agent is getting at what it is currently learning, and almost nobody tracks whether it can still do the thing it was built for.

Grade the founding job

The cheapest and most neglected instrument in the whole discipline is a held-back set of the agent’s original tasks.

The set to grade is the founding job, unchanged, from the day the agent shipped, kept apart from the newer work it has picked up.

Run it on a schedule.

When the score on those original tasks starts sliding while the score on new tasks holds, the agent is signaling, in the only language available to it, that it has become something other than what it was hired to be.

That is the earliest honest warning on offer, and collecting it costs almost nothing.

Keep the rules above the memory

The second move is to stop memory from overwriting the rules.

Give the agent a charter, a plain statement of what it exists to do and what it must never do whatever it learns, and store that charter somewhere memory cannot reach.

When memory and charter disagree, the charter wins, and the disagreement gets logged, since a disagreement is itself an early sign that drift has begun.

One school of practice goes further and declines to let a general assistant persist at all.

Tomasz Tunguz has argued for handing a daily assistant a 24 hour life, delegating the real work to narrow specialists that live for seconds and then disappear, and writing the durable preferences to a file on disk at midnight while the rest of the day’s conversation gets discarded.

The caution behind that is concrete.

Work titled Governance Decay found that context compaction silently drops standing rules in 30 to 59 percent of episodes.

Rules that live inside the conversation get eaten by compaction eventually.

Rules that live in a file survive the reset, which points straight at the last decision, the one nobody wants to make.

6. Building for Generations Instead of Immortality

Sooner or later the honest answer is that an agent has drifted too far, and re-grounding it costs more than standing up a replacement.

What the successor keeps

The instinct is to hand the successor the full memory of the one being retired, because discarding a year of accumulated experience feels like arson.

That instinct is worth resisting.

Most of that experience was sediment carried at face value, so passing it along passes along the drift and restarts the clock on finding it again.

A successor should inherit two things and no more.

It gets the charter, the original definition of the job. And it gets the small set of memories that earned their place against the held-back tests.

The knowledge that proved itself moves forward, while the accumulated bias stays behind with the agent that is stepping down.

The organization already solved this

Organizations have handled exactly this for as long as they have existed, in the person of the twenty-year veteran with priceless knowledge and unshakable habits.

New people arrive, older ones move on, and whoever knows everything gets seated next to whoever knows nothing yet.

The only new wrinkle with agents is that none of it happens on its own, because an agent will run a drifted heuristic ten thousand times with flawless consistency and never once pause to wonder whether it still holds.

The comforting version, where agents simply compound forever, does not survive contact with a real organization.

What actually happens is more useful to know.

An agent climbs while there is something to learn, settles for a while, and then begins to slide, and the work worth doing is placing your agent on that arc and building its successor before the slide turns into an incident.

Which leaves two questions almost nobody asks out loud.

What is the oldest agent still running in your setup right now.

And when was the last time anyone checked whether it can still do the job it was hired to do.

Claude Managed Agents hit the scene saying their bots could run by themselves, no babysitting needed.

I called three founders who bought in. They launched: meeting briefs that check their own work, a dashboard tracking a whole squad of sales agents, and an agent that reads customer code and sends pull requests. All this, live in under two weeks.

Here’s the real story: the late nights, the tight deadlines, and the parts no one puts on a slide. This is what happens when you have to deliver for actual users.

Here’s how each one did it.

together with Oracle:

Bots are forgetful.

Oracle’s crew came up with a fix and spelled it out in a playbook:

They gave agents four kinds of memory: working, semantic, episodic, and procedural. In their tests, agents scored almost 94% on LongMemEval and used a tenth of the tokens after 80 turns.

▫️ Plays nice with any framework: Claude Agent SDK, LangGraph, OpenAI Agent SDK. Every one has a notebook to get you started.

▫️ One client and one pip install: oracleagentmemory.

▫️ Includes audit, tenant isolation, and ways to wipe data if you want.

Read the full breakdown

Now, the founders. Same skeleton each time: what shipped, the clock, where it nearly broke.

1. One Wrong Name Nearly Shipped, and It Rebuilt the Product

Saj’s team builds a meeting assistant. Core feature: briefs. Who you’re meeting, what you agreed to last time.

Then one day it pulled the wrong LinkedIn profile for a real meeting.

“If you’re talking to a person named Tom and it gives you information about the wrong Tom, it’s actually almost destructive because the moment you end up in the meeting, you click to learn more about them and you end up confused.”

“Almost destructive” is the right phrase. A wrong name attached to genuine context beats an empty screen at one thing only: sending the user into a meeting armed with confident nonsense.

The fix: a second agent that grades every brief before a user sees it. Fail the grade, show nothing. Silence over confident error.

That’s the design principle behind outcomes, and I’d apply it anywhere your system touches someone’s identity.

2. A Sales Agent Fleet, Shipped in 2 Weeks (Not a Typo)

Mahir’s team went the opposite direction on scale. One agent per account, always running, each accumulating memory on its own account for as long as the relationship lasts.

Except reps rarely think in single accounts. A rep with 100 needs today’s 5. A manager needs next quarter. So a cross-account layer grew on top of the fleet: Watchtower.

“We spun that up on managed agents in about 2 weeks. It’s now one of our most used features, and it powers a lot of other parts of the product.”

Two weeks. I asked twice.

Build the narrow agent first. The cross-cutting need will introduce itself.

Planning to run the same math on your own product, start here:

▫️ How to Build Three AI Agents Without Writing Code

▫️ How to Build Your First AI Agent in a Day

▫️ Yang Zhilin’s Agent Playbook: 10 Bets Founders Should Steal

3. Why “Independent” Is the Whole Point

Back to Saj’s grader, because the load-bearing detail is easy to miss.

“The fully independent clean context window means that you can assess the quality of the work as part of deploying it.”

The grader gets a rubric (right person, right context, readable structure) and its own context window. It never sees how the answer got made.

An agent reviewing its own trace will pass itself every time. Hand the grade to a stranger and the rubric starts meaning something.

4. Two Kinds of Memory, Learned the Expensive Way

Watchtower forced a distinction Mahir’s team now treats as gospel.

“There’s memory on an account and across accounts. There’s memory on a user level and an org level.”

Account memory is deep and specific: one customer’s history, tracked forever, tuned to stay stable. Cross-account memory is different: how this org defines a “qualified” deal, what its messy internal fields mean. Closer to infrastructure than to knowledge.

Mix the two and everything works fine for months. Then three engineers spend a quarter untangling it.

5. What Actually Needs a Sandbox

Todd’s product should make you a little nervous. It snapshots a customer’s codebase, compares it against the live application, and proposes fixes, often as a PR pushed straight to a live repo.

“You can imagine that people interacting with an agent, and you get access to someone’s source code, you can potentially get secrets.”

A code snapshot carries credentials, internal logic, things the customer never meant to hand anyone. Every tool that agent touches has to be scoped with that in mind from day one.

Todd’s team looked at building that isolation themselves and passed. Getting it right immediately mattered more than owning it. Unheroic, correct.

6. Build vs. Buy: 3 Founders, 1 Test

Three founders, three products. I expected three answers and got one.

“It really comes back to if you don’t need to roll your own infrastructure for it because it’s not the thing that defines the quality of what you’re building, choose to buy, and in the cases where it is, build it yourself.”

The test runs both directions. Saj: a voice-controlled assistant would need its own runtime, because there the runtime is the product. Briefs didn’t, so they bought that layer and spent the saved weeks on the feature. Todd came from the other side: homegrown solution, wall, proper bake-off against a managed option, then the rebuild decision.

Four questions before building anything yourself: control, cost, time, and (Todd’s addition) whether you’re still validating that the idea works at all.

Every founder at that table had rolled their own infrastructure once. Every one replaced it when it stopped being what made their product special.

7. Idea to 1,000x in a Few Weeks

The number that reframed the conversation for me: Saj’s briefs feature, self-grading included, took a day.

“It allowed us to build the first version of the feature in a day and then ramp up with like 100 to 1,000x scale up in the user base over the course of a few weeks.”

A day to working. A few weeks of dogfooding to 100-1,000x the users. Infrastructure untouched throughout. Watchtower ran a similar clock, with roughly one weekend of dogfooding wedged in the middle.

So the time went where it should: figuring out what users needed, testing against real usage, repeating. Once infrastructure is solved, speed is iteration cycles, never headcount.

8. The Eval Problem Nobody Has Solved

I pushed on evals. Every team admitted the same open wound.

“I don’t think we found a good way to eval given memory. A system that’s very stateful with this memory that is live.”

The early playbook is universal: trust your gut, dogfood internally, go systematic once it sticks. Dogfooding overfits to your own team; eval sets from real customer queries mostly cure that.

State is the part that stays broken. Live memory won’t hold still for a clean offline eval. Todd hits the same wall through MCP, where Slack tool calls carry state his team controls none of, so any eval suite drifts no matter how carefully built. Mocking the whole surface would work in theory. Nobody thought it was worth the engineering.

One founder gave me the industry’s actual state of the art in four words:

“Phase zero is vibes-based.”

If you’re building your own version of this loop, start here:

▫️ Why Most Self-Improving AI Loops Fail, and How to Build One That Works

▫️ The Loop Engineering Masterclass on Goals, Evals, Memory, and Guardrails

▫️ How to 10x Any AI Skill Using Karpathy’s Autoresearch Method

9. New Models, New Failure Modes (And Yes, More Em Dashes)

My favorite detour of the whole conversation: upgrades as a source of new problems.

“The whole five series of models tends to produce writing in a way that has actually a lot more AI telltale signs than previous series of models.”

The playbook these teams landed on inverts the upgrade instinct. Skip chasing the last 1% of performance, each generation hands you that for free. Spend the energy catching failure modes specific to the new model, whether that’s Claude Opus 5, Claude Fable 5, or Kimi K3, before a live user does.

A good eval suite catches most of it, on one condition: the prompts weren’t over-tuned to the previous model family’s quirks. Otherwise you’re testing nostalgia.

New model, new tells.

10. The Cost Levers, and the Missing One

Every founder here worries about cost. Good.

“If we’re running things 24 hours in advance, we could probably save 50% to 75% on cost and make that possible.”

That’s Saj describing a batch mode that fits briefs perfectly, since they run 24 hours ahead anyway, and would cut costs by more than half. It mostly doesn’t exist yet. Mahir already splits by task instead: the agent coordinating a Watchtower search gets frontier intelligence, the agents fanning across 500 accounts run cheap, because fanning out is cheap work.

Today’s levers: effort settings, orchestration that separates cheap work from expensive, model selection, and that missing batch mode, worth roughly 2x when it lands.

All three founders gave me a version of the same advice. Be mindful, spend well, and save the fine-grained optimization for when the product has earned it. Cost work pays off the day it makes something buildable that wasn’t. Before that day it’s a well-organized distraction from shipping.

If cost is what keeps you up, reading order:

▫️ Your AI Bill Is Mostly Wasted Tokens

▫️ Why You’re Overpaying for Intelligence Right Now

▫️ The Inference Engineering Playbook for the 80% Cost Cut Most Teams Miss

The Managed Agents Playbook

Buy the stack when it’s a commodity. Build it when it’s the product. Every founder at this table proved both halves inside the same year, and it’s the test most teams skip before reaching for an agent at all.

▫️ Founders: 2 of the 3 products here started as one feature and became a second product only when a cross-cutting need showed up on its own. Ship narrow. Let the second product earn its place.

▫️ Investors: Teams that bought the stack spent their first 2 weeks studying user behavior. Teams that built spent it on infrastructure. Ask which one a team actually did.

▫️ Operators: A second agent with its own context window, grading against a rubric, catches what self-review sails past. Copy the outcomes pattern before you ship anything agent-graded.

▫️ Everyone else: Nobody at this table has closed the eval gap for live-memory systems. Assume your evals are stale until proven otherwise.

The 4 Principles to Steal

1. Buy until infrastructure is the product. Roll your own stack when it’s the thing that makes your feature different, and only then.

2. Grade with a second, independent agent. The agent that did the work loses its vote on whether the work was right.

3. Split memory by scope. Account memory needs deep customization. Cross-account memory is infrastructure. Mixing them is a bill that arrives later, with interest.

4. Hedge against new failure modes. The last 1% improves on its own with every release. New failure modes wait for you to find them.

Speed compounds. 2 of these teams shipped in 2 weeks and both are still on that layer today. The teams still rolling their own infrastructure are doing it on purpose, for the one piece that’s supposed to feel different from everyone else’s.

If this saved you a rebuild, send it to one founder or investor who needs it.

3 founders, 3 products, 1 conversation. Watch it start to finish.

Keep reading: Build vs. buy

▫️ The One-Person Business, Built on Claude

▫️ Inside OpenAI: The Operating Model That Makes 2 Engineers Beat 200

▫️ How Granola’s Growth Playbook Turned an MCP Pivot Into a Moat

Keep reading: Memory, evals, and reliability

▫️ Your AI Agent Is Going to Hallucinate at Scale

▫️ The Head of Claude Code Stopped Prompting Claude. Most Builders Missed Why

▫️ Stop Blaming the Model, Fix the Architecture

Keep reading: Cost and the model layer

▫️ The Claude Opus 5 Playbook: Benchmarks, Pricing, Effort Dial

▫️ The AI Code Review Checklist That Prevents the Next $1M Production Incident

▫️ Anthropic Deleted 80% of Claude Code’s Prompt. It Got Smarter

That is the actual shape of an overnight AI agent setup, once it is built correctly.

The number attached to it gets all the attention: a thousand agents, sometimes more, running unattended while nobody is watching.

The number is the least useful part of the idea. Almost nobody needs a thousand agents running at once, and the ordinary settings that make any number of them safe instead of reckless rarely make it into the retelling.

Five agents running badly can already make a mess by morning. The same five, built on the right settings, scale to five thousand without changing shape.

The architecture underneath breaks into five pieces, and every one of them already exists inside Claude Code.

Together with Granola:

Your agents can touch everything except your meetings. That’s where your real context lives.

Granola takes notes in the background, wherever you meet, then its MCP integration connects them straight to Claude:

▫️ Works everywhere: Zoom, Meet, Teams, or in person on iPhone

▫️ Ask Claude to review last week’s client calls and update your CRM

▫️ Turn meeting decisions into Linear tickets, without copy-pasting a thing

Free month with code THEAICORNER.

Try Granola Free!

Table of Contents

1. Sessions, Sub-Agents, and the Phone in Your Pocket

2. Isolation Solves Files. It Does Not Solve Judgment.

3. The “Runs While You Sleep” Claim Has Three Different Truths

4. Don’t Let the Agent Grade Its Own Homework

5. Limits Have to Be Rules, Not Suggestions

6. What a Real First Run Looks Like

1. Sessions, Sub-Agents, and the Phone in Your Pocket

A session is the base unit underneath all of this, and it is smaller than the headline number makes it sound. Everything else here is really a decision about how many sessions to run and how closely they need to talk to each other.

That headline number is really just this same decision, made many times over, until it adds up to something that sounds impressive from a distance.

One Session Is One Focused Piece of Work

Think of a session the way you’d think of a browser tab. That means one open conversation, working on one piece of work.

Several sessions can run at once, each pointed at something different.

Inside a single session, a task can be split into smaller independent pieces and handed to sub-agents, so several focused workers run in parallel without leaving that one conversation.

The decision that matters: work that needs to see another piece’s progress in real time stays together, as sub-agents inside one session. Work that genuinely doesn’t depend on anything else becomes a separate session instead.

The Screen That Makes “From the Phone” Literal

The Claude app has a coding tab built for exactly this. It lists every active session, shows what each one is doing, and takes a correction or a fresh instruction typed straight into any of them, no laptop nearby.

That is the entire “from the phone” part of the claim. A live window into work already happening, not a status dashboard dressed up to look impressive.

Mixing up the sub-agent-or-session decision is the most common way parallel work turns into a mess. Five sub-agents told to edit the same files at once produce five different opinions about what the file should look like, and reconciling that afterward costs more time than the parallel work saved.

None of this holds up at scale until the sessions stop stepping on each other’s files.

2. Isolation Solves Files. It Does Not Solve Judgment.

Multiple sessions working against the same codebase need a way to avoid overwriting each other, and there is a specific tool built for exactly that problem.

Git Worktrees Keep Parallel Work From Colliding

Git worktrees give each session its own working copy of the repository, on its own branch. One session builds a feature while another fixes a bug, and neither sees the other’s half-finished changes.

This kind of isolation is already built into Claude Code. Nobody needs to hand-roll it.

Worktrees solve a file problem, not a judgment problem. Ten sessions given ten slightly different instructions against the same repo return ten slightly different opinions about how the code should look, and somebody still has to reconcile that by hand.

Where the Real Wall Sits

Push much past four or five sessions hammering the same repository at once, and reviews slow down and usage limits get easy to hit. Not because anything breaks, but because coordinating that many simultaneous edits by hand stops being realistic.

The thousand-agent version of this claim is almost never a thousand sessions arguing over one codebase. It is a thousand sessions each doing one small, independently checkable job. Researching one company out of a hundred. Triaging one ticket out of a thousand.

Wide parallelism works beautifully on work shaped like that. It does not work on a single shared codebase, no matter how many sessions get thrown at it, because somebody still has to read every diff that comes out of it.

The next question is what actually keeps any of this moving after the laptop closes.

3. The “Runs While You Sleep” Claim Has Three Different Truths

There are three distinct ways to make a task repeat itself, and only one of them survives an actual closed laptop.

Two of the Three Options Still Need a Machine On

The quickest option is a loop inside a live session: a task repeats every few minutes or hours, for as long as that session stays open, up to three days at most. It disappears the moment the session closes.

One level up is a scheduled task on a desktop. It survives closing the terminal and coming back later, and it reaches local files directly. The computer still has to be switched on for it to fire.

Both are genuinely useful. Neither one is what “runs overnight with the laptop shut” actually describes.

Only One Option Actually Survives a Closed Laptop

A routine is a task saved to run on Anthropic’s own servers, on a schedule, triggered by an event like a pull request opening, or called through an API. Each run starts from a fresh copy of the repository rather than reaching into local files, and it can call cloud-hosted tools but not whatever only exists on a personal machine.

No machine required at all, and no pause to ask permission mid-task, which is exactly why the next section matters as much as it does.

The honest version of the claim: closing the laptop only works with a routine. Everything lighter than that is still tethered to a machine that has to stay on.

A task running with nobody watching also needs a way to check its own work, and this is the step almost everyone skips.

4. Don’t Let the Agent Grade Its Own Homework

Ask the same agent that did a piece of work whether the work is any good, and it will tend to say yes.

Why Self-Review Fails Exactly When It Matters Most

Not out of dishonesty. It simply has no independent vantage point on its own output.

That blind spot gets worse, not better, on anything running unattended for hours with nobody checking in.

A fresh pass, ideally a separate session with no memory of how the first one got there, has a real shot at catching what the first pass missed.

What an Independent Check Actually Requires

The checking pass needs something real to check against: the actual test suite, the requirements written down beforehand, a specific list of criteria.

Told plainly not to trust its own summary, and to say a claim can’t be verified rather than assume it worked, that single instruction outperforms every other setting in this piece combined.

For code, this is fairly clean: tests pass or they don’t. For softer output, research summaries, written judgment calls, it gets harder, because a checker cannot always confirm a claim without redoing the very work the first pass just did. A second pass still catches what a tired first pass stops noticing, the same reason a second editor catches typos the writer no longer sees.

Even a properly checked task still needs a leash, because unattended and unlimited are not the same word.

5. Limits Have to Be Rules, Not Suggestions

Every task left running unattended needs three numbers decided in advance, and they need to be settings the system enforces, not a polite sentence buried in the prompt.

Three Numbers to Set Before Bed

A limit on how long a task is allowed to run before it stops and reports back instead of pushing on.

A limit on what it is allowed to spend, based on real numbers from a small test run rather than a guess.

Cost also multiplies with concurrency in a way that is easy to underestimate. A limit that looks small for one task looks very different once fifty tasks are running it at the same time.

A short, explicit list of things it is never allowed to do without asking first: nothing deployed, nothing deleted, nothing sent externally, no money moved, without a direct yes.

Test the Failure on Purpose

One task, on purpose, given an instruction designed to trip its own limit, before anything real gets handed over.

A task that doesn’t stop cleanly while being watched will not stop cleanly on the ten tasks that aren’t.

Skipping this step is the fastest way an overnight win turns into a Monday-morning surprise.

6. Your First Run

This is not about the hypothetical number (1,000).

Ideally, you should be starting somewhere between 5-20 genuinely independent tasks, the kind that don’t depend on each other’s output.

Start Small, Decide the Mechanism Up Front

Write down what “done” looks like before starting, for every one of them, and hand that same description to whatever is going to check the work.

Decide, task by task, whether it needs a loop, a desktop schedule, or a full routine. Set the time limit and the cost limit before bed, not after.

Morning Review Beats the Completion Count

Morning review should be the focus instead of completion count. Spot-check the actual evidence behind a few tasks marked done, not just the word next to them.

Nearly every failure in a system like this traces back to the same handful of causes:

• Scaling up before the checking step has been proven on a small batch

• Treating a stop condition as a suggestion instead of a rule

• Running tasks in parallel that depended on each other in ways nobody noticed until there were too many of them running at once to track by hand.

It might not be exotic, but it is the same set of mistakes made delegating to a large team of people, compressed into a single night instead of a few weeks.

Scale up when the independent, well-defined work actually exists to justify it, not because a bigger number sounds more impressive on a feed.

Once a few small batches run cleanly, the checking step catching real problems and the limits actually firing when tested, the settings are worth revisiting rather than left untouched. What worked for twenty tasks needs re-checking before it gets trusted with two hundred.

The number was never the point. The hours it gets back, the ones that used to disappear into work only one person could do slowly, that is the actual trade on the table.

The rest of the early numbers, per Apptopia’s estimates shared by Alex Heath: 2.8 million downloads in 12 days across both stores, 1.8 million on US and Canada iOS against ChatGPT’s 1.3 million, and a single-day US record of 264,000 downloads on September 19, its third straight day above 200,000. ChatGPT needed roughly a year to cross 200,000 in a day. These are external estimates, and firms differ on the exact figures, but every firm has the direction the same way: this is the fastest consumer agent adoption anyone has measured.

The AI Corner

Practical AI workflows, prompts, and tools for founders and operators who want to compound an advantage every week

By Ruben Dominguez

And those numbers are the organic ones. Muse's first TV ad ever went nationwide this weekend, timed to the big games, per Meta AI chief Alexandr Wang. Everything above happened on zero ad spend; the paid curve starts now.

The launch pace is only half the story. In its first two weeks, Muse also shipped a Mac app, hit number one on the US App Store, opened its connector platform to any developer with an API, and got blocked by Amazon, which cut the agent off from shopping on its site over what it called data security concerns. A platform war started before most people finished onboarding.

Meta can afford the fight because it's the only consumer player holding every layer of the stack: MTIA chips, Meta Compute infrastructure, the Muse Spark models, and Muse itself at the application layer. When you own the whole column, an agent that runs at a loss is a strategy rather than a problem.

I spent the week inside it, and inside the several hundred use cases early users have published, and the pattern is blunt: the people getting real value out of Muse are running it completely differently from the people using it as a chatbot with hands. The difference is a setup, a spending order, and a set of prompts that have already worked for someone else.

That’s this issue. The news and the numbers are free below. The operating manual, four tools built from what’s actually working, is for premium subscribers.

TL;DR

• The launch: Muse reached an estimated 642K US mobile DAUs in 12 days, roughly 3x ChatGPT’s pace at the same point. Free tier runs about 100M tokens a week, with Power at $20/month and Maximum at $100/month, and a payment card required even for free.

• The platform: Ten days after launch, Zuckerberg opened connectors to any developer with an API: Meta reviews, Stripe Link handles payments, and no fee structure or revenue share has been published. Amazon blocked the agent from its store within days.

• The manual: Premium subscribers get the week-one setup with the trust dial, the money-recovery week that has returned $600 to $5,000+ for early users, the 25-prompt library from proven use cases, and the connector play for anyone building on or investing around the platform.

What Muse Actually Is

Muse is a personal agent, powered by Meta’s Muse Spark model, that runs in an isolated VM inside Meta’s infrastructure. Meta AI chief Alexandr Wang’s framing: it operates in “its own isolated environment” and “never sees your actual passwords or payment details.” It ships on iOS, Android, the web at muse.ai, WhatsApp, and since September 17 on Mac, where it works across your files, calendar, notes, and messages. AI glasses are next, per Meta.

The connector list at launch: Gmail, Google Calendar, Outlook, Plaid, OpenTable, Google Docs, Spotify, Function Health, Withings, Tailscale, and Peloton, with Facebook, Instagram, and Threads linking through Accounts Center. The part that makes it an agent rather than an integration hub: when no connector exists, Muse wires one up from a public API with credentials you provide, and when there’s no API at all, it drives its own browser.

Three design choices tell you Meta thought about the failure modes:

▫️ Approval cards for consequential actions render outside the chat, where an injected prompt can’t fake or dismiss them

▫️ The email connector strips one-time codes, password-reset links, and login links before the agent sees them

▫️ The bug bounty goes to $300,000, with up to $130,000 for a successful prompt injection, and Meta’s own security post admits the honest version: “Prompt injection remains an open problem in the industry, and Muse will sometimes make mistakes.”

Pricing is usage-based in disguise. Free gets you roughly 100 million tokens a week (Zuckerberg’s number; Meta’s docs say only “available for free with a usage limit”), Power at $20/month gets 500 million, and Maximum at $100/month gets 3 billion. The card-at-signup requirement annoyed reviewers, and it also tells you Meta expects the free tier to convert on usage rather than features.

For how Muse’s goal architecture differs from prompt-response chatbots, we covered that in the Muse launch breakdown. This issue is about operating it.

The Platform Moment (Why This Week Mattered More Than Launch Week)

On September 18 at 7:03 PM Eastern, ten days after launch, Zuckerberg posted the sentence that turns a product into a platform:

“Opening access for developers to build Muse connectors. You bring the API -- Muse brings the agent, the browser, and the context of what the person actually wants. People reach your service just by asking for it, and their agent takes it from there.”

The mechanics, from muse.ai/platform: a Submit a connector button, a three-step Meta review, and Stripe Link for payments. What’s not published is the interesting part: no fee, no revenue share, no SDK. Developers are being invited onto a shelf before the rent is set.

Then the countermove. Amazon blocked Muse from shopping on Amazon.com this week, citing data security and control of the customer relationship. Read those two events together and the shape of the next two years appears: agents want to sit between consumer intent and every service, and the services with their own distribution will fight rather than list. Muse against Instinct against Grokbot is the visible race; agents against the app economy is the actual one. We ran the same analysis on Instinct’s playbook when it was invite-only.

Whoever you connect to becomes your new landlord. Pick carefully, and if you’re building, get on the shelf while listing is free.

That’s the news. What follows is the operating manual.

Premium subscribers get the four tools:

1. The Week-One Setup: the trust dial for connectors, the approval-card rules, and how to spend a 100M-token free week without hitting the wall by Wednesday

2. The Money-Recovery Week: five days of prompts ordered by expected return, built from users who recovered $600 to $5,000+ in their first sessions

3. The 25-Prompt Library: copy-paste versions of the use cases that actually worked, across admin, travel, family, work, and money

4. The Connector Play: the agent-readiness audit for your API, the submission path, and the opportunity map if you’re building or investing around the platform

Tool 1: The Week-One Setup

Read more

“Seniorization” is a real word now. PwC coined it in June, after feeding more than a billion job postings through its models.

What they found is that in the occupations most exposed to AI, entry-level roles are now 7 times more likely to demand skills that used to take a decade to earn.

Those are skills like strategic judgment and stakeholder management. They translate to knowing what to build, not just how to build it.

Some are worried that junior roles are disappearing.

But the truth is that they are being rewritten to require the one thing a junior person cannot have, which is time.

If you set that beside the rest of this year’s hiring data and it stops looking like a quirk. Senior postings are climbing while entry-level postings fall. In software, roughly seven in ten open roles are now senior. Firms are hiring hard at the top of the ladder while sawing off the bottom rung.

Indeed, as AI makes execution cheap, the prize moves to judgment. But where does that judgment comes from?

together with Outskill

Part of the answer: reps. Judgment starts with knowing which tool to reach for, and nobody teaches those reps for free.

This Saturday’s live workshop covers the 15 AI tools that matter right now, which one fits which job across research, writing, design, data, and code, plus how to build an AI coworker that works while you sleep.

▫️ Saturday, 10 AM EST, 3 hours live + bonus sessions

▫️ They price it at $395. Free this week:

Save my free seat

Table of Contents

1. The Resume Was a Map of Roads Being Repaved

2. Hire Against the Fog, Not the Org Chart

3. Judgment Is the New Scarce Input

4. The Apprenticeship Just Got Automated

5. Capability Debt Is the Bill Nobody Has Booked

6. The Filter Is Right. The Factory Is Missing.

1. The Resume Was a Map of Roads Being Repaved

For decades a resume worked as a kind of atlas. It recorded where someone had been so an employer could guess where they might go next.

That map is getting less reliable, because the roads keep getting repaved underneath it.

The shortcuts that used to be good enough

The old system ran on signals, and the signals were not stupid. A recognizable logo implied someone else had already done the quality control.

Eight years in a role implied a full cycle survived. A familiar title implied the problem had been solved before at similar scale.

All of it answered one narrow question well. Can this person do a known job inside a known system?

The trouble is that fewer and fewer valuable jobs are known, and almost no system stays still for a year.

A role written in January is a rough sketch of the work that will matter by December.

What replaced the logo

The ICONIQ report The New Hiring Filter, built on interviews with operators at Atlassian, Canva, ElevenLabs and Nevis, lands on the same observation.

Canva’s Chief People Officer describes moving the core interview question from “what did you do” to “how did you figure it out.”

One question asks for a replay. The other exposes the machinery. What did they assume, what changed their mind, what did they build and throw away.

ElevenLabs has largely dropped year-count requirements in favor of what a candidate built outside their formal role and how they use AI without being told to. Evidence is quietly replacing pedigree as the currency.

One thing the report says gently, but it’s worth saying plainly.

The signal that replaced “went to the right school” is now “had the evenings, the hardware and the financial slack to build things nobody asked for.”

That is a different bias, not the absence of one.

2. Hire Against the Fog, Not the Org Chart

The most useful idea in the ICONIQ piece is also the least repeated.

Your first hires should attack the company’s single largest unknown, not copy the org chart of the last place you worked.

Two companies, opposite choices, identical logic

ElevenLabs hired researchers before it built a conventional engineering team, because its existential question was whether it could build proprietary voice models at all. If the answer was no, nothing downstream mattered.

Nevis went the other way and hired a founding designer before any engineer, because in a brand-new category the scarce thing was not the ability to build. It was knowing what deserved to be built.

Two opposite-looking sequences, one shared move. Each company hired first against the thing it understood least.

Why the old order was never a law

Engineers first, then sales, then everyone else. That pattern came from a period when execution was the bottleneck.

Cheapen execution and the bottleneck moves, so the first hire should move with it.

A founder who cannot name the company’s biggest uncertainty in one sentence is not ready to make a senior hire.

They will end up hiring against comfort instead, and comfort is rarely the risk that kills the company.

Which raises the obvious question. Once you know what you are hiring against, what exactly are you screening for?

3. Judgment Is the New Scarce Input

When everyone can generate code, dashboards, mockups and analysis, the value does not vanish. It moves.

It moves from producing the output to deciding which output is worth producing at all.

The part everyone agrees on

Nevis’s founding designer puts it bluntly for his own craft. If generating interfaces becomes trivial, design’s value can no longer live in production.

It has to move to taste, direction and the judgment about what to make.

An early ElevenLabs design leader frames the same thing as the gap between a product that merely works and one that feels inevitable to the person using it.

Across product, revenue, data and finance, the highest-leverage people increasingly look less like operators and more like scouts.

They can enter unmapped terrain, form a point of view, and bring back something the org can act on.

The caution that keeps it honest

Phil Fernandez, the former Marketo CEO, supplies the counterweight the argument needs. AI tools do not turn engineers into designers, and they do not remove the need for deep expertise underneath the taste.

A company that mistakes cheaper output for better decisions moves faster while drifting further from what customers actually need.

That sentence deserves more weight than it gets. A team that ships five times as much with the same judgment does not ship five times the value.

It ships five times the mistakes, at speed, each one wrapped in a polished artifact that makes it look considered.

4. The Apprenticeship Just Got Automated

Here is where the comfortable story about “hiring for judgment” runs into the data, and the data does not flinch.

The numbers pointing one way

Indeed’s Hiring Lab reported that as of May 2026, US senior-level postings were up 14.7% year over year, while entry-level postings kept sliding, down 7.5%, a decline running since 2022. In software development, senior roles now make up close to 70% of all postings.

Stanford’s Digital Economy Lab, using ADP payroll data, found workers aged 22 to 25 in the most AI-exposed occupations saw roughly a 16% relative decline in employment after generative AI spread, even after controlling for the usual macro noise.

A Harvard working paper covering 66 million workers across more than 280,000 firms found companies adopting generative AI cut junior hiring sharply while senior headcount kept growing.

The honest caveat belongs here too. Rates rose, the post-2021 overhiring unwound, and the Stanford authors themselves say the AI signal only turns clearly significant from 2024. Nobody serious claims AI alone emptied the graduate market.

But the tilt toward seniority is concentrated exactly where AI exposure is highest, and that is hard to wave away.

What the junior job was really for

PwC’s 2026 Global AI Jobs Barometer, built on more than a billion job postings, gave the mechanism a name. Seniorization.

Entry-level roles in the most AI-exposed occupations are now seven times more likely to demand skills that used to appear a decade into a career.

Look at what that actually deletes. The junior job was never only cheap labor. It was the factory floor where judgment got made.

A first-year analyst gathering data, writing the rough draft and sitting in the room while a manager rewrote it was not mainly producing output.

She was watching an experienced person handle a disagreement, change direction, or deliver bad news.

Repeat that for two or three years and you get the exact capability employers now list on day one.

The market deleted the tuition and kept demanding the degree.

5. Capability Debt Is the Bill Nobody Has Booked

Writing in Harvard Business Review this summer, Jenny Fernandez gave this a name that should worry any CEO: organizational capability debt.

A debt that doesn’t show up until it’s expensive

It is the widening gap between the judgment a company will need in its future leaders and what its shrinking early-career pipeline is actually producing.

Like technical debt, it sits invisible on the books until the quarter it suddenly is not.

ICONIQ hits the same nerve from a different angle. In a lean AI-native company, a handful of people build the agents, the workflows and the internal operating system.

Lose one of them and, in Fernandez’s image, it feels like losing the wiring behind the walls.

Documentation and shared learning loops help, and the report is right to insist on them. But documentation preserves what one person knew. It does not manufacture a second person who can decide.

The contrarian move almost nobody is making

The interesting play in 2026 is to hire juniors anyway, and rebuild the entry-level job so it produces judgment faster than the old one did, on purpose rather than by accident.

There is a live example. Brainlabs, a thousand-person media agency, grew its entry-level cohort from 19 hires in October 2023 to 64 in April 2026, a 237% jump, by retooling a long-running internal academy around AI instead of shutting it down.

Legal teams are converging on a similar model, recruiting junior lawyers who arrive able to validate model output and manage the workflow around it rather than grind out the first draft.

That is what a redesigned first job looks like. Less drafting, more checking. Less gathering, more deciding what the gathered thing means and who it affects.

The apprenticeship is not dead. It just has to be built deliberately, because the version that ran on grunt work no longer exists.

6. The Filter Is Right. The Factory Is Missing.

None of this compounds if the organization the new hire walks into is pointed the wrong way.

When Incentives Undermine the Filter

AI adoption is not AI impact, because the moment tool usage becomes a performance metric, people use the tools because they are measured on it, and the work does not necessarily get better.

You can hire curious people and punish experimentation. You can hire builders and bury them in approvals.

You can hire for judgment and then grade them on volume. The system wins every time.

The Filter Improved. The Pipeline Didn’t

So put the whole picture together. The hiring filter has genuinely improved, and it has moved in the right direction. Evidence over pedigree.

Judgment over output. Uncertainty over the inherited org chart.

Every operator quoted here is reading the moment correctly.

The failure sits one level down, and it is collective rather than individual. Almost every company applying the new filter is drawing from a pool it has quietly stopped refilling, on the unspoken assumption that someone else will keep producing the people who can direct the machines.

The machines are not the problem here. The problem is a hiring market that got smarter about spotting judgment at exactly the moment it stopped building any.

Although the filter is right, the factory is missing, and the companies that notice first will now start hiring out of everyone else’s shortage.

• The model: Jev, launched September 15 by TypeSafe AI, is the first public “System One” model. It generates zero text. You send it a state and typed questions, it returns answers with probabilities in 70 to 500 milliseconds.

• The price: $0.042 per million input tokens, output free. Ten thousand decisions cost $0.42.

• The week: flights found in 7 seconds for $0.0039, a Claude session compacted from nearly 1M tokens to 86K in one second, 1,018 papers classified for eight cents.

• The catch: confidence is a probability, accuracy is a different number, and every benchmark so far comes from the vendor or the demo builders.

Every agent you run makes two kinds of model calls, and you’re paying frontier prices for both.

One kind creates: research, code, prose, plans. The other just decides. Which worker goes next. Is this urgent. Is this done. Is this tool call safe. Open your traces and count them. In every stack I’ve looked at since launch week, the deciding calls outnumber the creating calls, and each one is a full LLM round trip that exists to produce a single word.

Jev is a bet that the second kind never needed a language model. TypeSafe AI’s founder Diogo Almeida, who says he spent two years in stealth after co-inventing ChatGPT, trained it for one job: read a state, answer typed questions about it, attach a calibrated probability to each answer.

Three question types cover the territory:

1. Choice picks from your options.

2. Score rates against your scale.

3. Noul says yes or no, as a probability.

Ask ten questions about one state and they evaluate in parallel, so the tenth costs almost nothing.

What 72 hours of builders did with it

The launch claims are the vendor’s: up to 200x faster, up to 400x cheaper than comparable LLMs on classification. Fine, every launch says something like that. What made this one different is what independent builders shipped within three days:

▫️ Browser Use put Jev inside a browser agent that found flights in 7 seconds for $0.0039, picking the next action from a menu rebuilt after every click.

▫️ Tamara Tran’s compaction demo did 3.6M views: score every tool call in a Claude session, drop the irrelevant ones. Alex Volkov ran it as a plugin and watched his session fall from nearly 1M tokens to 86K in about a second.

▫️ Hassan classified 1,018 research papers into 24 topics. Total cost: eight cents.

▫️ LangChain shipped official middleware the same week, including the safety-classifier pattern that coding harnesses have kept in their closed-source layers until now.

Where it bites

I’ll be straight about the other side, because I read the docs and not just the quote tweets.

Jev explains nothing, so a wrong route hands you a probability and no reasoning to debug. TypeSafe’s own guidance says confidence and accuracy are different numbers, which means a 0.98 on a badly written question is a confidently wrong answer at record speed. And the demo economics hide a trap: a $0.00004 decision that sends your agent down the wrong branch costs you the entire branch.

The builders winning this week aren’t the ones who installed Jev fastest. They’re the ones who knew which decisions to hand it.

Setup takes twenty minutes and there are three free threads on X that cover it. The judgment layer is the part nobody’s written down.

Inside the playbook

That’s what the rest of this article is. Five tools, built from the docs, the launch-week demos, and the failure modes already showing up:

1. The decision audit. Four passes over your last 50 agent traces, one hour, and you have your list of delegation candidates. In the stacks I’ve audited, 60 to 80% of model calls turn out to be decisions in disguise, which is the share of your bill this touches.

2. The ten-decision map. Every common agent decision, from worker routing to compaction to safety checks, with the question type, an example spec, and the confidence threshold for each. The table you’ll keep open while you build.

3. Six question-writing rules. The difference between answers you can act on and answers that just look confident. Rule one alone explains most of the silent failures people are posting about this week.

4. The guardrail set. What has to be in place before any Jev decision runs unsupervised overnight: thresholds, the calibration method using 30 labeled examples, and completion checks that verify artifacts instead of believing answers.

5. The receipts table. Every independently reported number from launch week in one image, with the three caveats that keep you from quoting the misleading versions.

Here’s the honest pitch for the paywall: everyone reading this will bolt Jev onto something this month, because the demos are irresistible. Most will delegate the wrong decisions with the wrong questions, get burned by a confident 0.98, and conclude the model is hype. The playbook below is the difference between being that person and being the one whose agents quietly got 10x cheaper.

Get the decision-layer playbook:

Get 50% off forever

THE JEV DECISION-LAYER PLAYBOOK

Part 1: The split that changes your stack

Read more

The first is that the money has arrived. Robotics startups raised $27.6 billion in 2025, more than twice the year before. Figure is worth $39 billion. Skild tripled to $14 billion in 7 months. When Agility went public this summer, the suppliers moved before the company did: Ouster is up 150% this year, Vishay Precision up 269%.

The second is that no humanoid robot has been deployed above the low hundreds of units in real, commercially priced production. Not one, anywhere.

I spent 2 weeks trying to understand how both could be true, and I think the answer is simple. People analyze this sector the way they’d analyze a phone: by what it looks like. But a robot is much more like a factory than a phone. What matters is what’s inside it, and specifically which part is holding the rest back.

So I built a framework for thinking about it that way. It breaks any robotics company into 4 tiers and 12 layers, working backward from the job the robot does to the chip that runs it. It tells you which layer sets the ceiling, who competes there, and, the part I find most useful, who gets paid when that layer is the constraint.

I’ve been running it on every robotics name I look at, public and private, for a month. It’s the only thing I’ve found that puts a $39 billion humanoid and a warehouse robot with $22.7 billion of backlog on the same page.

Inside this playbook:

▫️ Why you work backward from the job, and what goes wrong when you start from the chip

▫️ All 12 layers in 4 tiers, with the public and private companies competing in each

▫️ The bottleneck scorecard, a 1-page way to find the ceiling in any system

▫️ The scorecard run on Symbotic and Figure, so you see what it catches

▫️ The bottleneck-to-ticker map, when layer X is the constraint, these companies get paid

▫️ 60 diligence questions, by layer

▫️ The public-market playbook and the startup playbook, written for the 2 different questions they ask

▫️ 5 things that kill most robotics theses

One subscription unlocks every system

Your subscription opens the full AI Corner archive:

▫️ The AI Tools and Models library, every model, tool, and setup guide

▫️ The AI Agents library, the full agent-building stack, start to finish

▫️ The Prompting and Context Engineering library, the prompts and context systems that actually ship

▫️ The Claude and Anthropic library, every Claude playbook in one place

▫️ The Business and Investing library, turning AI leverage into revenue

Plus 3 fresh systems every week. One robotics thesis you get right, or one you avoid, pays this back for a decade.

🤖 The Physical AI Investment OS

Get the 12 layers, the scorecard, the rotation map, and the 60 questions below 👇

Read more

For a long time I assumed I needed a smarter model. What I actually needed was one that could find things, which turns out to be a different and much harder problem once your vault has been growing for a year.

GPT-6 Astra, released September 3, is the first model I have used that solves it. Two numbers explain why:

▫️ It pulls a single buried detail out of a 512K to 1M token context with 96.3% accuracy, where GPT-5.6 Sol manages 73.8% on the same test, and it holds a flat 100% up to 512K

▫️ It ships 5 reasoning effort levels you can switch between mid-conversation without losing your cache, so the boring 95% of vault work stays cheap while the hard 5% gets the deep pass it deserves

The interesting part is the combination. Either capability alone would have left the vault problem unsolved.

Now the caveat the launch coverage keeps skipping, because it changes how you should think about this model. On the broad Artificial Analysis Intelligence Index, Astra scores 61.2, which puts it behind Claude Fable 5.1 and Opus 5. This is a specialist in retrieval and agentic work rather than a smarter chatbot, and a vault that has been accumulating for months happens to be exactly that kind of problem.

So here is the whole system: how I wired it into Obsidian, the protocol file that keeps the bill sane, the 3 prompts that run it, and the single rule that stops it from inventing things that were never in my notes.

Inside this playbook:

▫️ The numbers that matter, and the one that keeps the hype in check

▫️ The 2 ways to connect, MCP through the REST plugin (now with a built-in endpoint) and computer-use

▫️ The vault structure that makes retrieval work: raw, wiki, status

▫️ The protocol file, copy-paste, with effort tiers and the citation rule

▫️ 3 prompts that run ingestion, weekly synthesis, and the retrieval test

▫️ The cost math, including the 272K cliff that doubles your bill

▫️ What breaks, and how to build around it

▫️ When Fable 5.1 is the better choice for the same vault

One subscription unlocks every system

Your subscription opens the full AI Corner archive:

▫️ The AI Tools and Models library, every model, tool, and setup guide

▫️ The AI Agents library, the full agent-building stack, start to finish

▫️ The Prompting and Context Engineering library, the prompts and context systems that actually ship

▫️ The Claude and Anthropic library, every Claude playbook in one place

▫️ The Business and Investing library, turning AI leverage into revenue

Plus 3 fresh systems every week. One weekly synthesis that finds a connection you’d have missed pays this back on its own.

🧠 The Astra Vault Playbook

Get the setup, the protocol file, the prompts, and the cost math below 👇

Read more

“We actually don’t even know what idea we’re going to build”

Nine hours later, on air, a company existed. GitHub org, deployed landing page, working hello@ inbox, a waitlist writing into a database with a confirmation email back. The parent entity is called Ship by Thursday because the deadline is literally Thursday.

I know, a competent human ships a waitlist page in an afternoon. If that were the whole story I’d have skipped it. What kept me watching is that the stream shows, in public, how an agent-heavy team actually splits the work, and the sheets they published are more honest than the marketing around them.

Three people on camera, five bots on payroll

The sidebar roster was longer than the studio. One bot took the brief and produced the landing page. One pulled thousands of public replies in through a plugin. One wrote the code. One reviewed the pull requests. One read the reply pile. For nine hours, the humans mostly directed.

The idea selection worked the same way. They asked publicly what to build, thousands of replies came back, and a bot read the pile so nobody had to scroll it. The humans kept one question and asked it of every surviving idea: who is the customer, what is their pain, what is it worth to them.

And the build order was backwards, at least by human standards. Org, page, domain, email, waitlist, all before knowing the product. Every accelerator tells you the opposite. For an agent team it’s right, because bots need somewhere to commit from minute one, and none of that infrastructure cares what the product turns out to be.

Governance for the whole day was three rules. Ship straight to main. Respect the auto-review. Ask before sending mail.

Someone else already built this, alone

Sabrina Ramonov runs her short-form content solo, 41 million views in 30 days, and she rebuilt her whole workflow as a four-bot department inside Grok Bot, then published what broke.

She landed on the same shape as the SpaceXAI team without talking to them: specialist bots with one job each, a shared channel, approval gates on anything external. Two teams arriving at the same architecture from different directions is a much better signal than either one alone.

The goal was never to remove yourself from your company. Your taste and your decisions ARE the company. The goal is to stop being the bottleneck.

The column nobody publishes

Now the warning, because you pay me to be straight: this stream is vendor marketing. SpaceXAI people on SpaceXAI’s product will show you the best case. The floor is in their own sheets, in a column listing what each bot still needed a human for, and it’s long. The engineer bot needed a rule for when code could land. The verifier attached zero screenshots or video. The reply-counter needed a human to decide which replies counted.

Every line in that column is a job you inherit the day you copy this setup. Most people find their gaps in production, one angry customer at a time. An hour with the system below finds them on paper instead.

Inside the operating manual

I merged the stream and Ramonov’s writeup into one system: the 7-step day-one build order in the sequence that works for agents, the five-filter test for the first job you delegate, the bot job-description template you’ll reuse for every hire, the four-bot marketing department with its skill-to-role split, the six actions that always wait for your approval, and the human-column audit that shows what you’re inheriting before it costs you.

Get the operating manual 👇

Get 50% off forever

THE ONE-PERSON COMPANY OPERATING MANUAL

Part 1: The day-one build order

Read more

Their own example is an iPhone game that should resume where the player paused it. To verify that, an agent has to play, pause, quit, relaunch, and look. So they gave it a full macOS VM on bare-metal AWS hardware, a warmed-up Xcode, an iOS Simulator, and eyes.

I read the whole engineering post so you don’t have to. Four things stood out.

1. They fought Apple’s networking and won ugly. Apple’s built-in NAT kept overwriting the same macOS firewall that Cognition uses to enforce session access rules, so two systems raced to configure one packet filter. Their fix was to drop down a layer and write their own user-space Ethernet gateway that answers ARP requests by hand. That’s a lot of work to guarantee “the agent can only reach what you allowed,” and it tells you enterprise security reviews are driving the roadmap.

2. They pre-click the permission dialogs. A fresh macOS install stops to ask about accessibility and screen recording, and every dialog is a spot where the agent sits waiting for a human. Cognition mounts the disk image and edits macOS’s internal configuration databases directly, then boots it once to warm Xcode and the Simulator before you ever arrive. Anyone who’s waited out a cold Xcode first-launch knows how much dead time that removes.

3. Devin reads the app instead of staring at it. Screenshotting the screen and asking a vision model “where’s the Resume button” is slow and expensive at scale. Devin queries the accessibility tree instead, the same structure built for assistive tech, which hands back every control’s name, role, state, and available actions as text. Screenshots stay for the stuff that’s drawn rather than declared, like gameplay itself.

4. The quiet acquisition paid off. The accessibility layer is built on tooling from Dioxus, a company Cognition bought with close to zero coverage. Turns out that was the piece making agentic computer-use affordable on Apple platforms.

And the launch note itself is the workflow pitch: Devin builds on its own Mac, sends you a screen recording in Slack, and hands you a TestFlight link. You go to bed with a queue and wake up with a build on your phone.

Now, my skepticism, because Cognition earned some. The 2024 launch demo was later shown to be less autonomous than it looked, and this post is heavy on capability and silent on success rate. There’s no pass rate on iOS tasks anywhere in it, no comparison to a human running the same loop. A Mac with accessibility access makes autonomous iOS work possible, and possible is where the marketing usually stops. My bet: month one shows Devin is genuinely good at verifying behavior and close to useless at judging design, because the accessibility tree describes a layout without ever finding it ugly.

Which means the winners here will be the people who hand it the right kind of work, framed the right way. That framing is a skill, I’ve spent the day building the system for it, and it’s below.

The free section ends here. Everything below is the working system.

Premium subscribers get the Devin Mac Handoff System: eleven prompt templates covering the full iOS verification loop, the accessibility-tree query patterns that cut a screenshot-heavy session by roughly two-thirds, a session setup checklist for your first Mac workspace, the cost model that tells you when a Mac VM beats running Xcode locally, and a decision table comparing Devin against Claude Code, Cursor, and Codex on eight mobile tasks.

Get 50% off forever

THE DEVIN MAC HANDOFF SYSTEM

Part 1: Before you write a single prompt

Six setup moves for your first Mac session. I’d love to tell you I derived these from first principles, but really they’re the six ways my first sessions went sideways.

Read more

He spent just over an hour explaining why Muse exists, what it costs, and why most of the industry is building the wrong kind of AI product. Along the way he conceded Meta got LLM scaling wrong the first time, confirmed the next model is shipping, and walked through the architecture that keeps Meta locked out of your agent’s memory.

I watched the full interview so you don’t have to. Here are the ten that matter.

together with Outskill:

Zuckerberg wants an agent running your week. Most people still can’t get one to finish a single task.

Outskill closes that gap in a weekend: 16 hours of live training on the stack that matters now, Astra included.

▫️ Saturday and Sunday, 10 AM to 7 PM EST
▫️ Live attendees get a Prompt Bible, a monetization roadmap, and a toolkit builder

Free for the next 48 hours.

Save my Free seat

1. Muse Doesn’t Take Prompts. It Takes Goals.

Every AI product you’ve used runs on the same loop: you ask, it answers, the thread ends. Muse breaks that loop.

“Instead of the model where you send one prompt and it gives you an answer, what you do with Muse is give it goals. It works 24/7 and it doesn’t stop until it’s helped achieve them.”

That’s the actual product distinction, and it has nothing to do with marketing copy. Meta AI, ChatGPT, Gemini: all 3 are still built around a single question and a single answer, no matter how good the answer gets.

Muse gets a standing objective instead. It runs a virtual machine in the background, logs into accounts on its own, and keeps working across days without a new prompt from you.

Grokbot, Town, Instinct: Zuckerberg names 3 competitors chasing versions of the same shift, which tells you this is bigger than one company’s roadmap. Prompting is giving way to goal-setting across the whole industry, not just at Meta.

2. Meta Can’t See Inside Your Muse Agent, and That’s the Whole Pitch (By Design)

A personal agent that knows everything about you only works if you trust it with everything. Zuckerberg’s answer to that problem has a name: Moxie Marlinspike.

“Nat and I personally recruited Moxie Marlinspike to work on this confidential VM project. We can make the commitment that even Meta cannot see the content that is in there, and you can do this technically.”

Marlinspike founded Signal, and back in 2014 he helped Meta build WhatsApp’s end-to-end encryption. He came back specifically to run Muse’s confidential virtual machine project.

The claim isn’t a privacy policy. It’s an architecture claim: your agent’s memory runs in a system Meta itself can’t inspect, and Zuckerberg says he can prove that technically, not just promise it in a blog post.

He’s reusing the WhatsApp playbook on purpose. Build the trust into the system first, then let the product carry the sensitive stuff, whether that’s email, health information, or whatever else you decide to connect.

3. Muse’s Sentinel Agents Check Every Risky Move Before It Happens (Even When You Don’t See It)

Handing an agent your credentials is the scary part of this whole category. Meta built a separate layer specifically to catch it doing something you wouldn’t approve of.

“We built all these Sentinel agents that monitor the incoming and outgoing traffic and data your agent is sending, for the purpose of flagging to you when you might want to review something. If you’re going to log into something, do a payment, or transfer sensitive information, you need to approve it.”

Muse never sees your raw credentials. Meta built a secure credential store that issues one-time card numbers instead, so the agent only gets access when it’s logging into something you actually asked for.

Sentinel agents sit on top of that layer, watching for prompt injection and for anything leaving your agent that shouldn’t go out. Connectors start read-only, too: email access doesn’t include send permission until you grant it specifically, which Zuckerberg frames as least privilege built into the architecture rather than a setting buried in a menu.

If you’re building your own agent guardrails, these actually go into the mechanics:

▫️ Stop Blaming the Model. Fix the Architecture

▫️ Your AI App Has a Hole in It Right Now

4. Muse Is Free Because Zuckerberg Thinks It’ll Make You Money (Here’s the Math Behind It)

Every other AI product wants a subscription. Meta is betting it doesn’t need one.

“We’re confident in standing behind the fact that this is going to make so much money for people that the business model over time is to take a very small cut of whatever the transaction is.”

Meta is giving away 100 million tokens a week for free, plus the virtual machine that runs behind it. A subscription option exists, but it isn’t the bet Zuckerberg is actually making with the free tier.

His logic: if Muse runs your small business, handles your logistics, or manages a transaction end to end, it generates enough value that a small cut beats a monthly fee. That cut doesn’t even have to come from you, either. Zuckerberg says it can come from the businesses Muse transacts with on your behalf, with Stripe handling payments underneath.

This bet only works at Meta’s scale. Free compute for hundreds of millions of people needs margin most companies don’t have. Zuckerberg doesn’t name the specific revenue line covering the free tier in this conversation, but he does describe Meta elsewhere in the interview as an extremely profitable business, and points to that as what lets it outspend labs running on thinner margins.

If you’re rethinking how to price an agent product instead of a subscription, these break down the shift:

▫️ Most AI Startups Are Pricing Themselves to Death

▫️ The $100B Question: How SaaS Giants Are Rewriting the Rules of Value with AI

▫️ Is SaaS Dying for Good?

5. Muse Agents Learn From Each Other Across the Fleet (A Network Effect Nobody Else Is Building)

Most agent products still work like a single-player game. Zuckerberg is building for the version where agents learn from each other.

“Most of the industry is thinking about agents as a single-player game, where you have your agent and you use it. As more people start using Muse, it just gets better forever.”

Meta hasn’t rolled this out broadly yet, but Zuckerberg flags it as the long-term differentiator over raw model capability, at a moment when the model itself is turning into a commodity. If your MMA coaching pipeline improves because someone else’s agent already solved a similar tracking problem, that’s compounding value no single model release can match on its own.

It’s also a familiar move from the person who built Facebook and Instagram on network effects. Scale begets scale, and he’s aiming to recreate that dynamic here, this time across a fleet of personal agents instead of a feed.

6. Zuckerberg Admits Meta Got LLM Scaling Wrong (And Fixed It With Fewer, Better People)

Meta had already built state-of-the-art machine learning for feeds, ads, and content moderation. Zuckerberg assumed that experience would carry over to large language models. It didn’t.

“I made this mistake of assuming that because we were good at other types of machine learning, building and scaling LLMs would work kind of the same way.”

Llama 3 landed well. Llama 4 missed the trajectory Zuckerberg wanted, and that miss triggered a reset that had nothing to do with adding headcount.

Instead, he shrank the team around its strongest researchers and built the lab physically around where he sits in the office. He spent a large chunk of his own time recruiting for what he now calls talent density: a group small enough that everyone can hold the whole system in their head, where each seat going to the best available person actually moves the outcome.

The result so far is MuseSpark, built on a smaller pretrain code-named Avocado, with Watermelon, a bigger pretrain, coming next. During the interview, the host referenced a recent Artificial Analysis chart he believed placed MuseSpark just behind Claude Fable 5.1 and Opus 5, though he flagged some uncertainty about the exact names himself. That’s the host’s read on the trajectory, not a claim Zuckerberg made.

If you want more on where the frontier labs actually stand right now, these go deeper: ▫️ OpenAI’s $122B masterclass: 10 takeaways from Sarah Friar

▫️ Anthropic Just Passed OpenAI in Revenue

▫️ Ilya Sutskever’s New Playbook for AGI

7. Muse Is Being Trained to Know What Not to Say

A personal agent has to reveal enough about you to get things done, and it has to decide what to hold back on its own.

“Let’s say you’re pregnant, and you’re making a reservation somewhere. You don’t necessarily want to say I’m pregnant, but maybe you want a place with good mocktails. It needs to know what is sensitive without having to ask you a million questions. That’s a specific thing we put into training.”

Discretion is a training objective for Muse specifically, not a capability Zuckerberg expects other labs to prioritize the same way. He draws a direct contrast with something like an enterprise coding agent, where the whole team already sees the work, so there’s less need to separate what counts as sensitive.

Coding sits underneath most of what looks like a different kind of task entirely. The MMA coaching pipeline, a Jeopardy game one beta tester built for friends, the Civilization strategy guide he built with his daughter: Zuckerberg says all of it reduces to code the agent writes that you never see.

Judgment about what to reveal, paired with the raw capability to build things on request, is what he believes other labs are training for less deliberately.

8. Muse Studies Overnight and Proposes Its Own Next Project (Without Being Asked)

Zuckerberg’s daughter wanted a Civilization strategy guide. Muse turned it into a history lesson on its own.

“It studies. It consolidates its reflections into memory. It works on projects, and it can also suggest new projects.”

Zuckerberg asked Muse to build a strategy guide for playing Civilization with one of his daughters. Muse later proposed expanding it into a tab covering historical lessons about the civilizations in the game, and he said yes.

The same pattern shows up in his MMA training feedback loop, where the agent suggested it could get better at picking the right camera frame to send him, then went and did it without a follow-up prompt.

Zuckerberg frames this as solving AI’s actual adoption problem: most people don’t know what to ask an agent to do. An agent that proposes its own next move, the same loop-engineering pattern showing up across the industry, solves that without requiring the user to get better at prompting first. It’s also why what the agent learns overnight matters as much as what it answers in the moment.

9. The Beta Tester Who Went Silent for Days Told Zuckerberg Everything He Needed to Know

Product signal doesn’t always look like praise. Sometimes it looks like someone going quiet.

“Someone I know who’s generally pretty skeptical about technology, I gave it to her, and she didn’t say anything for a few days. Then she texted me: when you do the general release, do I get to keep my Muse agent, or are you going to reset it?”

Within a day of getting beta access, one person was running their homeschool through Muse. Another had it plan an entire trip within 12 hours.

Zuckerberg’s own use cases skew domestic rather than technical: a weekend baking project with his 3-year-old that Muse organized end to end, Instacart order included, and mountain climbing permits it secured automatically for his older daughter. The baking project’s first attempt, cake pops, turned out to be a bad place to start, and he learned that the hard way.

None of this shows up on a benchmark. It’s the kind of usage that predicts whether people keep opening the app after week one, which is the only metric that actually matters for a product meant to run 24/7.

10. Zuckerberg’s Case Against Gatekeeping AI: The Superintelligent Lawyer Problem

If only one side in a courtroom gets a superintelligent lawyer, the system breaks. Zuckerberg says that’s the argument for putting AI everywhere instead of restricting it.

“If one person had a superintelligent lawyer, maybe they could win cases they shouldn’t be able to win. But if everyone had a superintelligent lawyer, it would be efficient sparring, and no stupid argument could stand. Justice would be served more efficiently and more fairly.”

This is the argument underneath the 15-page manifesto Zuckerberg just published, and the 1-page Personal Superintelligence essay he wrote for the Wall Street Journal a year earlier. Muse, he confirms, is what that earlier essay was actually pointing to.

His framework rests on 3 principles: putting people in charge of the technology is what generates prosperity, the primary purpose of AI is inventing new things rather than automating existing ones, and safety comes from checks and balances rather than restricted access. A big part of that third principle, in his own words, is a “robust open source ecosystem,” which he frames as making the whole system more secure precisely because more people can scrutinize it. That’s the same logic behind why so many companies now invest in open source well beyond AI.

He points to the Hugging Face security incident as evidence. The industry instinct is to hand advanced cyber models to roughly the top 100 institutions and stop there. Zuckerberg’s problem with that: more than 100 institutions actually matter.

Hugging Face isn’t among the biggest 100. When its team detected an intrusion, they turned to open-source models because they lacked access to the closed ones causing the damage. That draws the cutoff line in the wrong place.

The Personal Agent Playbook

Muse bets that agents win by taking goals instead of prompts, earning trust through architecture instead of policy, and getting paid by making you money instead of charging you rent.

▫️ Founders: The differentiator Zuckerberg is betting on isn’t the model. It’s the trust architecture underneath it. Build your credential handling and permission model before you build the demo, not after.

▫️ Investors: Meta is testing whether a transaction cut beats subscription revenue for agent products. It’s a bet that Muse creates enough value that Meta doesn’t need to charge a premium for raw intelligence the way some frontier labs do. Watch the pricing model, not just the benchmark scores.

▫️ Operators: Copy the Sentinel pattern regardless of which model you’re running, a second system that monitors an agent’s outbound actions and gates anything sensitive behind human approval. Build that layer before you connect an agent to a payment method.

▫️ Everyone else: Muse’s free tier includes 100 million tokens a week plus a virtual machine. Give it an actual goal instead of a prompt and see what it does with a week.

The 4 Principles to Steal

1. Ship the trust architecture first. Zuckerberg recruited Moxie Marlinspike before Muse had a broad release. He built the confidential VM and the Sentinel layer into the product from its first version, instead of bolting them on after a scare.

2. Price for value created, not access granted. A small cut of a transaction, taken from the business on the other end, scales differently than a subscription. It only works if the product genuinely generates that value in the first place.

3. Talent density beats headcount when you’re behind. Meta didn’t fix Llama 4’s trajectory by adding people. It fixed it by shrinking the team around its best researchers and getting closer to the work personally.

4. Let the agent propose the next move. The blank-page problem is the actual adoption barrier for most AI products. An agent that proposes its own next step solves that without asking the user to prompt better.

Watermelon ships soon. MuseSpark, per the host’s own hedged read of a recent Artificial Analysis chart, sits just behind Claude Fable 5.1 and Opus 5. That gap is the one worth watching next.

This covers the product. The full interview covers the politics too, teen safety, data centers, and AI regulation. Watch it here.

If this breakdown saved you an hour, send it to one founder or investor who needs it.

More on Meta’s Bet

▫️ Zuckerberg’s $14B Bet: Glasses Kill the Phone in 5 Years

▫️ Nobody Cares About the Model Now. It’s About the Type of Moat

Where the Frontier Race Stands

▫️ Marc Andreessen: The AI moat is not the model

▫️ Sam Altman: Intelligence Got 100x Cheaper in 2 Years

▫️ Dario Amodei’s full picture: 10 takeaways that matter

Making Agents Trustworthy in Production

▫️ Nobody Trusts AI Products Now. Here’s Why.

▫️ Your AI App Has a Hole in It Right Now

Their companies orchestrate agents: keep them running for days, compact the context before it explodes, route tools, spin up subagents, recover when a step dies at 3am. That work took each of them the better part of a year.

On Wednesday OpenAI shipped the Agents API, and all of it is now a managed service. The exact harness that runs Codex, open to any developer, for the price of tokens. Zero platform fee.

My first reaction was that this is bad news for people I like. My second reaction, after reading the docs instead of the threads, is that most of the internet has the conclusion backwards, and the interesting part is buried in 3 lines of fine print nobody is posting.

The numbers first, because they’re the reason to care. Launch customers report 4x lower latency, 60% lower cost per task, and 86% fewer failed responses after migrating. Ciridae moved its evaluation score from 0.71 to 0.85 by handing subagent orchestration to the API.

Below: what shipped, the working code, the limit that disqualifies regulated work today, a 5-question migration framework, and the 7 agents that make sense now that the plumbing is rentable.

Inside this playbook:

▫️ What shipped, the 4 objects and the 4 built-ins that replace your harness

▫️ The working code, a production-shaped agent in one call, annotated

▫️ The 3 lines of fine print nobody is posting, including the one that rules out regulated and European work today

▫️ Should you migrate? a decision framework for teams who already built a harness

▫️ Where the value moves now, and the wedge that got more defensible overnight

▫️ 7 agent ideas that make sense the day orchestration becomes rentable

▫️ What to do this week, by role

One subscription unlocks every system

Your subscription opens the full AI Corner archive:

▫️ The AI Agents library, the full agent-building stack, start to finish

▫️ The AI Tools and Models library, every model, tool, and setup guide

▫️ The Prompting and Context Engineering library, the prompts and context systems that actually ship

▫️ The Claude and Anthropic library, every Claude playbook in one place

▫️ The Business and Investing library, turning AI leverage into revenue

Plus 3 fresh systems every week. One migration decision made correctly pays this back many times over.

Get 50% off forever

🤖 The Agents API Playbook

Get the code, the limits, the migration framework, and the ideas below 👇

Try premium free for 7 days. Or get 50% off this week only.

Read more

Every earnings call this year centered on AI adoption inside enterprises.

Pull back the aggregate growth numbers, though, and a huge share of the actual dollars traces back to a short, specific list of names.

A legal AI startup burning through venture capital. A coding assistant that got cut off by 1 lab entirely, the same week its owner changed. A pair of hyperscalers mostly re-routing money that 2 AI labs promised them years in advance.

The industry describes all of this as demand.

Look closely at the customer lists, the compute contracts, and who is paying whom, and nearly the entire commercial case for AI runs through a group small enough to fit at a few dozen conference tables, with every floor of the stack leaning on the floor below it.

The whole building rests on one foundation, and almost nobody has checked what it’s made of.

Here’s what that structure looks like, floor by floor.

Together with Hard Skill Exchange:

Concentration risk sits above your pay grade. Agent governance sits squarely inside it, and the Agentic Harness Summit is live right now.

Day 3, virtual, free, and you can join mid-session without a ticket:

Today’s lineup:

▫️ The Pattern Breaker After the Model, with Mike Maples Jr. (Floodgate)

▫️ Context Graphs: The Enterprise Moat, with Jaya Gupta (Foundation Capital)

▫️ The Company Brain, with Jay Hack (Head of AI, ClickUp)

▫️ The Next AI Investment Thesis, with partners from Insight, Scale VP, Thomson Reuters Ventures, and Gradient

Join now, free!

Table of Contents

1. The Adoption Numbers Are Real, and Also Beside the Point

2. Money That Isn’t Quite Money Yet

3. 1 Customer, 2 Endings, Same Year

4. The Promises That Haven’t Come Due

5. The Concentration Runs All the Way Up

6. Same Few Names, Every Floor

1. The Adoption Numbers Are Real, and Also Beside the Point

In July, Anthropic grew to 43.5% of US businesses paying for AI subscriptions or tokens, up 1.1 points month over month.

xAI posted its fastest growth since July 2025, up 0.94 points to 4%. OpenAI grew only 0.23 points, to 39.7%, trailing the market’s overall pace.

Based on these numbers, AI adoption looks like a rising tide lifting 3 competitors at once, broad based and accelerating.

The 1% That Actually Pays

Ramp’s own customer data shows that just 1% of OpenAI and Anthropic’s customers generate 80% of their enterprise revenue, a split that hasn’t moved in 3 years, and Ramp’s lead economist has called it a level of concentration risk unseen in any other software category the firm tracks.

The gap between the top and the middle is enormous. The median business spends $11.95 per employee a year on AI. The top 1% of spenders, a mix of AI-native companies and ordinary businesses spending to look current, spends a median of $7,400 per employee, more than 600 times as much.

That top 1% skews toward 2 kinds of company: AI startups whose entire product is a wrapper around someone else’s model, and tech companies spending because their competitors are.

Growth is also spreading sideways, not just up. 6.1% of AI using businesses now use model serving platforms that provide access to open source and Chinese developed models, up 0.2 points from the previous month, a share that has been climbing steadily.

2. Money That Isn’t Quite Money Yet

A large share of what AI labs count as enterprise revenue is downstream of a funding round, not a customer’s own balance sheet.

How the Subsidy Actually Works

Many AI native startups sell a flat subscription, then let customers burn far more than that subscription price in tokens behind the scenes, with the startup absorbing the difference.

That only works as long as venture capital keeps refilling the gap. The startup isn’t paying OpenAI or Anthropic because the unit economics work. It’s paying because investors are still funding the difference between what customers pay and what the tokens actually cost.

Harvey’s 2 Numbers

Legal AI startup Harvey is a clean example. It has raised over $1.5 billion total including the latest $550 million, while running at roughly $350 million in annualized revenue, or about $29 million a month.

Harvey raised more than $800 million in 2025 alone, and closed the year at roughly $190 million in annualized run rate, about $15.8 million a month. It raised close to 4 times what it earned over that same 12 months.

None of this makes Harvey a bad business. It makes Harvey a bet, and every dollar it sends to Anthropic or OpenAI is, for now, a dollar that came from somewhere other than a paying legal client.

None of this is a fluke of a couple of unusual companies either. Roughly 50% of all global venture capital flowing into startups in 2025 went into AI, which means the subsidy machine funding bills like Harvey’s was itself the single largest destination for growth capital anywhere in the world that year.

But Harvey is just 1 company. The next example shows how quickly that kind of dependency can become someone else’s problem entirely.

3. 1 Customer, 2 Endings, Same Year

No example makes concentration risk more concrete than what happened to 1 coding startup over about 14 months.

What Cursor Was Worth To 2 Labs At Once

Cursor raised $3.2 billion across 2 rounds in just 4 months in 2025: $900 million in June, $2.3 billion in November, largely to keep funding its own token bill.

By mid-2025, Anthropic’s 2 largest customers together represented $1.2 billion of annualized run rate, roughly 30% of its $4 billion run rate at the time, and investors believed Cursor was 1 of the 2.

Separately, Cursor was reportedly on track to generate over $1 billion in 2026 revenue for OpenAI alone, more than 3% of OpenAI’s projected $30 billion for the year, even though OpenAI’s own models made up only about 5% of Cursor’s traffic.

What Changed In August 2026

Late that month, Elon Musk’s SpaceX completed a roughly $60 billion acquisition of Cursor’s parent company, valuing a business with close to $4 billion of its own annualized revenue at around 15 times that figure.

Within days, OpenAI moved to cut off Cursor’s access to its models entirely, citing its own experience with Musk’s companies breaking contracts, with a shutoff date of November 12, 2026.

Anthropic, almost immediately and publicly, pledged to expand compute for Claude inside Cursor instead. A relationship worth hundreds of millions of dollars a year to 1 lab changed direction because of an acquisition that had nothing to do with the product, the customer’s usage, or anything either AI lab actually controlled.

So, if a single coding customer can move that much revenue overnight, the far larger commitments sitting 1 floor above customer revenue deserve just as much scrutiny.

From our partners:

Harvey's bill gets paid by a funding round. The agents your own company runs get paid for by you, so knowing what they're authorized to spend and do is the cheaper problem to solve.

The Agentic Harness Summit is live right now, day 3, virtual, free, join mid-session.

Take a free seat

4. The Promises That Haven’t Come Due

Do you know which, much larger, number awaits to be calculated?

What OpenAI and Anthropic have already promised to pay for compute, most of which hasn’t been billed yet.

How Big The Promise Already Is

Anthropic and OpenAI’s compute commitments now represent more than $1.3 trillion in future revenue for hyperscalers and neoclouds, including Google, Microsoft, Amazon, SpaceX, Oracle, Cerebras and several smaller players.

OpenAI was projected to spend over $750 billion on compute through 2030 before it added another major deal on top of that figure.

Anthropic has signed roughly $517 billion in compute agreements over the last 11 months alone.

On top of the headline commitments, the 2 labs together are expected to spend about $40 billion on Amazon Web Services and at least $50 billion more on Microsoft Azure in calendar 2027, layered on top of everything above.

Why None Of It Feels Urgent Yet

Most of these are take or pay contracts, which means that the buyer owes the money on schedule whether or not it uses the capacity. Signing one costs very little upfront, because the data center capacity being promised hasn’t been built yet.

That changes starting in 2027, when a large share of that capacity comes online and the bills start arriving at scale.

Analysts estimate OpenAI and Anthropic will together account for at least $444 billion of hyperscaler revenue over the next 3 fiscal years combined, a figure that only holds if both companies keep growing at close to their current pace.

The affordability gap is easiest to see in OpenAI’s own numbers: $34 billion in operating expenses against $13.07 billion in revenue in 2025, with its operating margin reportedly worsening to negative 183% in the 2nd quarter of 2026.

5. The Concentration Runs All The Way Up

Every layer above the AI labs turns out to be leaning on the same 2 companies too.

Whose Cloud Revenue This Really Is

Only about $10 billion of Microsoft’s $33.33 billion in fiscal 2026 AI revenue reportedly came from selling compute or AI software to Microsoft’s own customers. The rest traces back to OpenAI’s committed spend, which by itself made up around 70% of Microsoft’s entire AI revenue that fiscal year, or a little over 7% of Microsoft’s total company-wide revenue.

Analysts estimate OpenAI and Anthropic’s compute spend will account for 48% of Google Cloud’s entire revenue next year, somewhere between $84 billion and $100 billion.

Even The Chipmakers Have 1 Real Customer

Across its most recent 2 quarters, 44% of NVIDIA’s fiscal 2027 revenue came from just 3 customers, and 16% of its most recent quarter came from 1 customer widely believed to be serving Anthropic’s compute needs.

Broadcom’s next fiscal year has Anthropic and OpenAI set to become its largest and 2nd largest customers. Cloud backlogs tell the same story further down the stack: CoreWeave’s $104 billion backlog includes roughly $22.4 billion from OpenAI alone, and SB Energy’s $439 billion backlog is 99.4% earmarked for OpenAI.

6. Same Few Names, Every Floor

The money keeps landing on the same short list, no matter which layer you look at.

A handful of subsidized startups pay Anthropic and OpenAI. Anthropic and OpenAI owe hundreds of billions to hyperscalers and neoclouds, and those hyperscalers owe hundreds of billions more to NVIDIA and Broadcom for the chips underneath all of it.

Every layer of that chain looks fine right now, because the bills that matter most haven’t arrived yet.

The customer subsidies are still being funded. The compute contracts are still in their early, low cost years. The 2027 obligations are still a forecast, not an invoice.

The Cursor story already showed what 1 broken link can do. A single ownership change, unrelated to the product or the customer, redirected over a billion dollars of annual revenue between 2 labs in a week.

The commitments sitting above that same chain run to $1.3 trillion, resting on a customer base just as narrow.

Whether AI is useful was never really the question. Whether a few hundred companies can keep saying yes to each other, all at once, for years in a row, is the one that matters.

Tom Blomfield laughed at them in their YC interview. Not politely, an actual laugh, because they couldn’t answer “what type of lawyers are you serving?” They didn’t know lawyers came in types.

3 years later, over 3% of the world’s lawyers use the product they built anyway. The Swedish VC who passed on their pre-seed, specifically because the team had zero legal background, still brings it up whenever he runs into Max Junestrand at the airport.

“And so you can just do things.”

That’s Junestrand, looking back on the moment he skipped the safe path everyone expected of him and built instead.

I watched the full interview so you can skip it. Here are the 10 takeaways that matter.

Together with Vanta:

Legora didn’t stop at one market. 3% of the world’s lawyers now use it, across borders most legal tech never crosses.

Going global changes what “secure” means. A US customer wants SOC 2. A European one wants GDPR answered before the second call. An enterprise buyer anywhere wants ISO 27001, the standard that says your security program holds up outside your home market too.

Vanta built the checklist for exactly that moment: the ISO 27001 checklist for teams ready to go global.

▫️ What the standard actually requires, without the consultant markup

▫️ The gaps that stall international deals, flagged before a prospect finds them

▫️ Free, and built for teams scaling past their first market

Download the Free checklist

1. Why Legora's Founders Weren't Lawyers

Domain expertise felt like table stakes for a legal AI company. Legora didn’t have any, and built the category leader anyway.

“I think that you need a willingness to learn about the markets, which we did very, very early by exposing ourselves and spending lots of time with lawyers, as much as we possibly could. But I don't think you need domain expertise.”

A Swedish VC passed on Legora’s pre-seed for exactly this reason: 0 lawyers on the team. He’s still bitter about it, years later, whenever their paths cross.

That’s the tell. Domain expertise looks like a moat right up until someone without it learns faster than the people who have it.

Junestrand’s caveat matters, though. He’d want deep technical grounding before walking into quantum computing or fusion, where the barrier to even understanding the problem is genuinely high.

Legal wasn’t that kind of barrier. It was learnable, so the founders learned it, on lunches with lawyers instead of resumes with the right credentials on them.

“Domain expertise is a lagging indicator. Learning speed is the leading one.”

2. The YC Question Legora Couldn't Answer

They applied to YC with a pitch about querying every legal document with LLMs. The first question undid them.

“One of the first questions that we got asked was, what type of lawyers are you serving? And not very knowledgeable about the legal space yet. Our response was, what do you mean? Are there different type of lawyers?”

Tom Blomfield laughed. Not a polite laugh, an actual one, in the middle of the interview, and Junestrand knew right there they were done.

They were. The day after brought nothing, but the day after that, they were back to building.

2 months later they reapplied under a different name, with a different platform, and got in.

The actual lesson isn’t resilience as a slogan; it’s narrower than that. They used the rejection as a forcing function to close the exact gap they’d been laughed at over, instead of polishing the pitch deck and reapplying with the same hole in their knowledge.

3. Legora Raised $35M, Then Went 6 Months With 0 New Sales

Benchmark had just wired $9.51 million. Redpoint pre-led the Series A 3 weeks later. Then the founders stopped selling.

“When you work with lawyers, you only really get one chance to get it right. If you show up and the product doesn't work, or if the sort of lag in the system is too high, or if a system goes down when there's too much traffic on your Assure instance, you are toast. And after that sixmonth sales freeze was when we really started ripping.”

$35 million in the bank, 10 people on the team, and a month where interest on that cash outpaced revenue from customers. That’s not a great sign for a startup; it’s a sign you’ve accidentally become a bank.

In their first board meeting, they made a call that looks reckless on paper: 6 months, 0 new sales, while every competitor raced to close logos off fresh funding.

It wasn’t caution for its own sake. It was a bet that in a trust-based vertical like law, one bad first impression closes a door permanently, and a closed door in a market this small doesn’t reopen.

The curve from $1 million to $100 million in ARR starts right after the freeze ends. Correlation isn’t proof, but the founders read it as cause.

If you’re weighing your own freeze-or-scale call right after a raise:

▫️ Term Sheets Demystified

▫️ Why Your Series A Might Kill Your Startup

▫️ What Top-Tier VCs Actually Look For in 2026

4. The Leia Product Manifesto Turned $1.3M ARR Into $100M

Before the freeze, Legora decided what to build by team vote. It went about as well as that sounds.

“For anyone who has built software before, you know that if you have too many chefs in the kitchen, that typically does not make one very good dish. And that was exactly what was going on.”

At $1.3 million ARR, with competitors doing 10 times that on products with a fraction of the feature set, the founders wrote down what they called the Leia Product Manifesto in October 2024. 1 document, shared with all 25 people at the company. No more votes.

It wasn’t a mission statement. It was a filter, built to survive a platform that had to keep adapting as the underlying models, and the agentic frameworks built on top of them, kept shifting.

That refocus gave Legora enough product momentum to justify the move from Sweden to the US, and to start competing for the biggest logos in the market.

5. Bloomberg Spent Millions Fine-Tuning. Legora Didn't.

Tribal knowledge in 2022 said you had to fine-tune a model to compete. Legora couldn’t afford to, so they didn’t.

“Our view was partly because we didn't have enough money and partly because we truly believe that to be right. The models will keep improving, right? Like I'm sure Sam is going to come up on stage and say that later today.”

Bloomberg reportedly spent millions building a proprietary law model on the fine-tuning theory. Legora didn’t have the capital to compete on that front, so the constraint became the strategy: bet on the frontier moving, and build the delivery layer on top of it instead of fighting to own the model outright.

Even early ChatGPT was borderline unusable for law, since it had no private conversations and no European data hosting. Junestrand’s actual first sales pitch was that Legora was like ChatGPT, but compliant in Europe.

He calls it a weak pitch now. It worked anyway, because the model kept getting better underneath it while the compliance wrapper held the customer relationship in place.

6. The Real Skill Is Knowing How to Eval Models

Model choice used to be simple. 1 or 2 options were good enough to run Legora. That’s no longer true, and Junestrand thinks that’s a good thing.

“One of the core IPs and muscles that I encourage as many of you as possible to build is the ability to eval new models and to eval new use cases, because that is the superpower that then allows you to route things effectively.”

Different jobs want different models. Customer support optimizes for latency and cost, since token spend has to stay tiny relative to the value of the ticket. Complex litigation wants the opposite: throw the most capable model available at the problem, because the cost of intelligence is trivial next to the cost of a lawyer’s time.

Legora’s users split into 2 camps. One wants to loop expensive frontier models on hard problems regardless of cost. The other wants cheaper open-source access.

Legora hired lawyers early specifically to build eval sets against genuine use cases, and only made its internal benchmark, Legora Bench, public in the days before this talk, after 3 years of keeping it closed. The surprising finding: Grok performed among the best models for cost given performance, and Legora didn’t even have a data processing agreement in place to offer it to customers yet.

7. Why Legora Moved From Reactive Agents to Proactive Ones

For 3 years, Legora worked the way most AI products still work: give it a prompt, it does the thing, it stops.

“We are basically connecting Legora to different pieces of context, and when it gets a trigger, it will start to do something. That means that if the sales team gets a contract, it will get routed to a Legora agent. The Legora agent will start working on it in parallel.”

No instruction required. A contract lands, an agent picks it up, works it, and either executes it or escalates to a human lawyer depending on what it finds. Connect an entire data room to an agent and it starts organizing the room and drafting the due diligence report on its own.

The framing Junestrand uses for the payoff is blunt: 1 lawyer producing the output of a team of 10. That’s not a feature update. It’s a claim about what headcount at a law firm should even mean going forward.

Building the eval-and-agent muscle before you need it:

▫️ Brian Armstrong Runs 1,200 AI Agents at Coinbase

▫️ Satya Nadella Said Every Agent Needs Its Own Computer

▫️ Google Just Made Agents 3x Cheaper to Run

8. What Is the Y Intercept Hiring Mistake

Early hiring at Legora chased resumes with fancy logos on them. They called the pattern “Y intercept.”

“If you think about somebody's skill curve, it might start out really high, but if they don't have a good trajectory upwards, they are going to have a really hard time working in a company that is scaling exponentially.”

A joke about someone whose skill curve starts high but goes nowhere. They stopped hiring for the starting point and started hiring for slope.

Their top seller today is 23, sold over $10 million worth of Legora, and walked in straight out of university with no sales background at all.

Junestrand, an engineer by instinct, admits the team overweighted product and technology early on and underweighted people. Building a product and building a company turned out to be genuinely different skills, and the trajectory bet on hiring is the one he credits most directly with the culture that still lets 750-plus people move like a startup.

Rebuilding a hiring filter around slope instead of pedigree:

▫️ The Free AI Hiring Kit Every Startup Founder Needs

▫️ Free AI Hiring Kit for Founders

▫️ The Salary That Disappeared: 6 Roles AI Owns Completely Now

9. What Startups Can Do That Microsoft Can't

Microsoft’s Copilot launch scared Legora badly. Every lawyer already lived in Word and Outlook, and the fear made sense at the time.

“I remember when that came out and we were like, oh my God, like we're so screwed. You know, every lawyer already works in the Word and Outlook and now they're just going to use copilots, but turns out like it didn't work. And the ability for us then to still build a lot of value was huge.”

It didn’t work, and Legora kept the advantage that actually mattered: speed of iteration against direct customer feedback.

Junestrand still drops individual customer complaints straight into the product Slack channel and asks how fast the team can turn it around, even now, at a company approaching 1,000 employees. He calls it a bit strange to do at that scale. He does it anyway.

10. Why This CEO Re-Qualifies for His Own Job Every Quarter

Growing from $1 million to $100 million in ARR in 18 months means the job changes underneath you constantly.

“And I think you really need to put the company first way ahead of your own ego in a way. And I tell this to the executive team. I need to re-qualify for the job as CEO of Legora. Every quarter, right? It's a new company, new challenges. As do they. Like running a sales team when you are 1 million ARR is very different from 150 million ARR.”

Junestrand describes the growth as a series of mini-games, each requiring skills the last one didn’t. Executives joining from companies that grew “triple, triple, double, double” over 4 years now have to compress that same growth into 1 year at Legora. A 40% year-on-year growth rate, fine for most SaaS companies, isn’t enough here anymore.

The requirement isn’t heroics. It’s admitting that competence at the last stage doesn’t transfer automatically to the next one, and building the habit of checking that assumption on a fixed schedule instead of waiting for a crisis to reveal the gap.

The Learning Speed Playbook

The willingness to learn faster than everyone else beats every credential you don’t have.

▫️ Founders: Stop waiting for domain expertise to feel earned. Log hours with the people who live in the problem, pay for their time if that’s what it takes, and treat the learning curve as the actual roadmap.

▫️ Investors: Team background is a weak signal in fast-moving categories. Learning velocity, evidenced by how fast a team closed a specific knowledge gap after a failure, is a stronger one.

▫️ Operators: Build the eval muscle now. The pool of usable models isn’t settling into 1 or 2 winners, it’s fragmenting by use case, and routing between them correctly is turning into its own discipline.

▫️ Everyone else: Re-qualifying for your own job on a fixed schedule isn’t a CEO-only habit. If your role has changed shape recently, run the same quarterly gut check.

The 5 Principles to Steal

1. Bet on the frontier, not the fine-tune. If your product’s value depends on a model that isn’t good enough yet, build the delivery layer and wait for the model to catch up rather than trying to own it yourself.

2. Freeze sales before you freeze trust. In markets where one bad first impression is permanent, slowing down on purpose beats scaling into a reputation you can’t undo.

3. Vote once, then write a manifesto. Democratic product decisions work at 3 people. They stop working well before 25. Write down the filter and stop re-litigating it every sprint.

4. Hire for slope, not for altitude. A high starting point with a flat trajectory loses to a low starting point climbing fast, every time, at a company actually trying to scale exponentially.

5. Re-qualify for your own job on a schedule. Don’t wait for a bad quarter to notice the role changed under you.

If this breakdown saved you the 60 minutes of watching it yourself, send it to one founder or investor who needs it.

If domain expertise was never your actual gate either

▫️ Career Zigzaggers Are Winning in AI: Why Non-Linear Paths Create Alpha

▫️ Founder-Market Fit: The #1 VC Filter You Didn’t Know Was Judging You

▫️ You’re Not a Fraud. You’re Undervalued: Why Reverse Imposter Syndrome Hits Founders Hard

If you’re trying to figure out where the AI moat actually sits

▫️ Nobody Cares About the Model Now. It’s About the Type of Moat

▫️ Why Companies Invest in Open-Source Tech and Research

▫️ Marc Andreessen: The AI Moat Is Not the Model

If you’re scaling past your first $1M

▫️ How Lovable Hit $400M ARR in 14 Months With 146 People and Almost Zero Paid Ads

▫️ Jensen Huang: 10 Lessons From the CEO Building the Most Important Company in History

▫️ You Won’t Believe What These 12 CEOs Actually Wrote to Their Employees

Run that gap forward 2 years and you get a sentence that should stop you cold:

“You’ve got them just controlling most of the usable flops in the world on their own.”

Not a slice of the world’s compute, but most of it, held by 2 companies.

Dylan Patel runs SemiAnalysis, which tracks lab compute, chip supply, and data center buildouts closer than almost anyone outside the labs themselves. He sat down with Dwarkesh Patel for the most honest read yet on what AI is doing to the economy.

I watched the full interview so you can skip it.

Here are the 10 takeaways that matter.

Together with Hard Skill Exchange:

If Patel is right, the compute layer is settled and out of your hands. What stays in your hands is everything you build on top of it: your data, your workflows, your decision rights, your agents.

That’s the sovereign AI question, and it’s the premise of the Agentic Harness Summit, Sept 8-10:

“Today, most companies are built on business processes. In the future, most companies will be built on harnesses.” Jensen Huang

3 days on how enterprises secure agent identity and actions while keeping their own business alpha, with James Currier (NFX), Mike Maples Jr. (Floodgate), Wade Foster (Zapier), and 100+ CXOs, VCs, and analysts.

Free and virtual.

Save your seat

1. 2 labs are on pace to control most of the world's usable compute by 2028

“By the time you’re towards the end of 2028, if this trend continues, which I see nothing that’s stopping it, you’ve got them just controlling most of the usable flops in the world on their own.”

Patel’s math starts simple. World compute in gigawatts roughly doubles every year, while compute at the 2 frontier labs grows 3x, so the frontier goes from 2 gigawatts at the start of this year to 6 by year end, 18 by the end of 2027, and 54 by the end of 2028.

Each new watt is also more efficient than the last, since GB300, TPU v7, and Trainium 3 chips deliver 3x to 5x more performance per watt than the generation before them.

“A new watt deployed this year is significantly more efficient than the watts deployed two years ago.”

Stack the growth rate on top of the efficiency gain and the compounding turns 2 labs into the dominant buyer of the planet’s usable compute inside 3 years, over the 10 most forecasts assume.

2. 1 lab could employ more workers than exist on Earth before 2030

“Then pretty soon, even if compute scaling slows down, it doesn’t take many more years before each company individually has more labor equivalents than there are people on Earth.”

Frontier compute in FLOP terms is growing 4x to 5x a year, while the compute needed to hit a given capability level falls roughly 3x a year. Multiply the 2 curves and the effective AI population at OpenAI and Anthropic compounds 10x year over year, before any recursive self-improvement enters the picture.

Patel’s estimate: OpenAI goes from roughly 10 million AI laborers this year, to 100 million next year, to 1 billion the year after. Even if scaling slows later, the curve crosses 8 billion, the population of the planet, within a few more years.

That turns a compute story into a labor story concentrated inside 2 companies, which Patel argues the world underrates relative to how much attention nationalization and state power get. If those systems end up misaligned, most of the world’s effective labor is misaligned with them.

3. The business flipped from losing money to $50 million a megawatt in under 2 years

“Anthropic started turning a profit in Q2. It’s believed at some point in Q3, OpenAI could potentially start turning a profit even with the big rise of Codex and 5.6 and all this. But if we go back a year ago, everything that they, all the money they had was venture funded losses, right?”

Serving GPT-4 on Nvidia Hopper chips generated negative gross margin for OpenAI, and base compute still costs $10 million to $15 million per megawatt. Anthropic’s revenue per megawatt has since climbed to $50 million.

Spend $10 on inference capacity, generate $50 of revenue, then plow the profit back into training. That flywheel funds the entire buildout, and it exists only because the gap between compute cost and compute revenue widened this fast.

The results already show it: Anthropic turned profitable in Q2, and Patel expects OpenAI to follow in Q3 even while absorbing the cost of scaling Codex and GPT-5.6, a swing from venture-funded losses that were still running at the start of this year.

4. Why Labs Would Rather Build AGI Than Bank $70 Million a Megawatt

“If you now get to generating $60, $70 million per megawatt, do you still allocate 40% to inference and generate all this profit and then do dividends and share buybacks? Or do you go build AGI? And I think the obvious answer from Anthropic and OpenAI, and not just at the executive level, but also their board, is go build AGI because it’s way more profitable.”

Labs have historically split compute roughly 60% training and 40% inference, and Patel expects that split to keep tilting toward training, a view he flags as non-consensus.

The standard assumption is that most new compute eventually serves paying users. Patel’s read runs the other way: as revenue per megawatt climbs, the labs would rather generate the same profit off a smaller inference footprint and pour the freed-up compute into research.

Every megawatt spent on inference today is a megawatt not spent compounding next year’s model.

That decision sits at board level, over engineering, and Patel says the shift is already measurable, with Anthropic’s incremental compute skewing toward research for 3 straight months while older capacity kept revenue climbing.

5. A $6 billion fab can generate more than $1 trillion

“$6 billion of CapEx at the fab level will have generated over a trillion dollars of end AI revenue.”

The wafer math behind a single gigawatt is almost absurd. 1 gigawatt of Vera Rubin-class compute needs roughly 55,000 N3 wafers, 6,000 N5 wafers, and 170,000 DRAM wafers. Tooling to produce that gigawatt costs $3 billion to $4 billion a year, and adding clean rooms and shell brings the total near $6 billion.

That $6 billion produces 1 gigawatt every year, and that gigawatt currently produces $100 billion of revenue every year, for roughly 5 years before it needs replacing. Cut the number in half for every middleman along the chain and the ratio between fab capex and downstream AI revenue still runs over 100x.

If the wafer math changes how you think about the chip supply chain, these go deeper:

▫️ Cerebras bet against the GPU. It just IPO’d at $56B

▫️ The AI trade just lost $1 trillion. Here is where the value went

▫️ Jonathan Ross turned a 3-week phone call into a $20 billion NVIDIA deal

6. The Actual Price Tag on AI Buildout Is $7 Trillion to $10 Trillion a Year (Not the Number You’ve Heard)

The figure everyone quotes for AI capex is missing most of the bill.

“If you end up in a world where you're doing 100 gigawatts a year, at current prices that would be 5 trillion of CapEx every single year. And then stack on the fact that you have to build the power plants way before then, slash it's a 30-year asset. You stack on the fact that the data centers are a, you know, 15, 20-year asset and you have to build that then too. So the 5 trillion, you know, you have to account for future years growth. So it's actually going to be more like 7 or 10 trillion. Of CapEx.”

At 100 gigawatts a year, current pricing puts capex near $5 trillion annually, and that figure only covers what Patel calls “critical IT”: servers, networking, fiber, and optical communications.

It skips the power plants, 30-year assets built years ahead of demand, and it skips the data centers themselves, 15 to 20 year assets that also have to be built ahead of the compute they will house.

Stack those together and Patel’s number lands between $7 trillion and $10 trillion a year by the end of the decade, close to a 10th of the world economy.

7. Financing the $11 Trillion Buildout Takes $5 Trillion of Debt

Hyperscalers can’t fund this alone anymore.

“The total, let's say the big... The hyperscalers in total will rate and all the clouds. In the modeling that we do, we have about $11 trillion of CapEx from 2024 to 2029. Total. And if you do, you know, if you fund a lot of this with cash flows and as much as you can, you still end up with north of $5 trillion of credit that needs to be issued for this $11 trillion plus...”

Google, Microsoft, Amazon, and Meta funded most of AI’s buildout so far. All 4 now spend everything they generate on capex and still raise debt on top of it.

Patel’s model puts total buildout costs at $11 trillion through 2029, split roughly $6 trillion cash and $5 trillion credit, a debt share closer to 45 percent than a clean half.

That debt has to come from somewhere: semiconductor companies, traditional infrastructure investors, and eventually ordinary capital that would otherwise buy homes, government bonds, or Anthropic’s own corporate debt.

If you’re trying to price your own exposure to that debt wave, these go deeper:

▫️ Rate Cuts, 80+ Ways to Fund Without Diluting, AI Is Breaking Valuation Models

▫️ The Venture Capital Liquidity Crisis That Nobody Is Talking About

▫️ Scott Galloway: 95% of enterprise AI spend connects to no return a CFO can name

8. The Original Volcker Shock Broke 40 Countries. Patel Bets on a Sequel

The 1980s debt crisis has a modern echo, and it starts with a data center.

“So in the 80s, to fight inflation, Fed Chair Paul Volcker raised interest rates like more than 5%, or it's like something like 8%, real interest rates 8%. And that caused some 40 different countries, mostly Latin America, to default in that decade. And I think that will probably happen again.”

That 40-country toll is history, not forecast; Patel expects a repeat but doesn’t size it. He credits the framing to economist Basil Halperin, whose paper with Trevor Chow and J. Zachary Mazlish, “Transformative AI, Existential Risk, and Real Interest Rates,” ties AI growth expectations to long-term real rates.

The 8 percent figure Patel cites is his recollection of how far Volcker pushed real rates, not a forecast for the new shock’s size. It checks out: the Fed funds rate peaked at 19.1 percent in June 1981.

If Meta is raising debt at 5 to 6 percent today, Patel doesn’t see why it wouldn’t pay 8 percent. A 250 basis point jump ripples through the market, raising the discount rate on every company’s cash flows, so stable, low-growth stocks take the hit even if the S&P 500 looks fine.

Developing countries with heavy debt loads and thin tax bases, Pakistan and Nigeria among them, sit most exposed to that repricing, a point Patel’s broader read on where AI is closer than people think society is ready for returns to often.

9. The 2 Forces That Make the AI Race Centralize (Even Without a Single Breakthrough)

2 forces keep pushing the gains toward whoever is already ahead.

“So that's like one effect. The other effect is if you're slightly ahead in the AI race and compute is in shortage, you can charge a much higher markup because you can better economize this scarce resource. So there's like two effects, which are give more and more to the person who's like ahead in the AI race.”

Training a skill into a model is a fixed cost, amortized across billions of sessions, which rewards whoever already has the most users.

Scarcity does the rest. When compute is short and one lab is ahead, that lab can charge a premium simply because it can better ration a resource everyone else needs too.

That’s also the argument behind why some investors say the model was never the moat, and why the smartest reads on AI Corner increasingly conclude the actual moat lives somewhere else entirely: continual learning adds a third multiplier, since the model deployed to more people learns from more live usage, widening the gap again, even without recursive self-improvement in the picture at all.

10. Why a 6-Month Delay Could Matter More Than Physics

Society, not silicon, is turning out to be the actual limiter here.

“I mean, right now, at least more revenue because the models aren't capable of RSI. But I'm worried about a world where it's 2030 and the government's like, we're going to wait six months before you can release your model to the public.”

Patel already sees regulation biting harder than most assume. OpenAI has paused training runs for stretches, and Anthropic has reportedly restricted access to Model 2, widely believed to be the next version of Mythos, for some employees, echoing a documented episode where the US government switched off Anthropic’s most powerful model days after launch.

If governments keep labs from releasing or fully using their best models, revenue per megawatt stalls, and so does each lab’s ability to outbid everyone else for compute.

Patel’s other fear runs the opposite direction. A 6-month external release delay could let a lab run years of unseen internal progress, widening the gap between what the public gets and what the lab actually has.

If the regulation angle above changes your timeline, start with these:

▫️ Dario Amodei named “the zeroth world.” You probably live in it.

▫️ What If the Real AI Risk Isn’t Superintelligence?

▫️ The Real Reason AI Costs Keep Rising

The compute centralization playbook

2 labs are on pace to out-compute and out-employ most of the planet by 2028, and the open question has moved from whether it’s possible to whether the rest of the world lets it happen.

▫️ Founders: building on frontier models means building on infrastructure 2 companies increasingly ration by price. Plan for compute costs to keep climbing, and build pricing power into your own margins now.

▫️ Investors: the value-capture question is unsettled. Jane Street reportedly extracts more value per megawatt than Anthropic does. Watch where the spread between compute cost and end value lands before betting on any single layer of the stack.

▫️ Operators: if your team isn’t testing internal workflows against the newest checkpoints, start this week. What you’re benchmarking against may already be a generation behind what the labs run privately.

▫️ Everyone else: interest rates, data center siting, and AI regulation stopped being side issues. Watch the permitting fights and the financing terms, over the model releases.

The 5 principles to steal

1. Revenue per megawatt over hype. It’s the cleanest signal on lab strength, and that number moved from negative to $50 million in under 2 years.

2. Training now, inference later. Inference funds the flywheel, and the labs believe the bigger prize sits in the next model over this quarter’s serving margin.

3. Follow the debt markets. An $11 trillion buildout never gets funded on cash flow alone, and where that credit comes from will reshape borrowing costs for everyone.

4. Physics stopped being the limit. Mirrors for EUV tools and turbines for power plants move slowly, and politics moves slower still, or stops things outright.

5. Expect 2 price-setters. Whatever you build on frontier models, plan for a market where your supplier gains pricing power every year.

This trajectory hinges on how high revenue per megawatt climbs and how much regulatory room the labs get. 2 labs already look like the market, and the rest of the decade decides how much of it they own.

If this breakdown saved you an hour of trying to model this yourself, send it to one founder or investor who needs it.

Keep reading

The money behind the compute

▫️ Anthropic just passed OpenAI in revenue, spending 4x less

▫️ Sam Altman on where AI is actually going

▫️ Dario Amodei and the long game of safe AI

The people making the bet

▫️ How Jensen Huang turned a green van and 30 years of rejection into Nvidia

▫️ Dario Amodei’s full picture: 10 takeaways that matter

▫️ Jensen Huang: 10 lessons from the CEO building the most important company in history

Where the bet could break

▫️ The venture capital liquidity crisis nobody is talking about

▫️ The US government switched off Anthropic’s most powerful model 3 days after launch

▫️ What if the biggest AI risk isn’t superintelligence?

He just told them AI is bad for learning.

Sit with that for a second. This is the guy who co-founded Google Brain, ran Baidu’s AI research as chief scientist, built Coursera into the thing that taught half of tech how to code, and just raised $100 million for LearnVector, his new personalized-tutoring company. If anyone has earned the right to say “AI is great, keep using it,” it’s him.

He said the opposite. The way most people actually use AI is breaking the exact muscle that made him employable in the first place.

I watched the full interview so you can skip it. Ng covers the manufactured panic around AI regulation, why engineers keep getting hired despite the doom, what AGI actually means to him, and the one rule he uses to decide what data never touches the cloud.

Here are the 10 takeaways that matter.

Together with Outskill:

Ng just said AI already does 30 to 40% of your job. Here’s the part that should worry you: most people have no idea which 30 to 40%, and they’re still doing the other 70% the way they did it in 2022.

This Saturday, a live 3-hour workshop covers the 15 AI tools that actually matter in 2026, and exactly which one to use for what:

▫️ Pick the right tool for the job instead of dumping everything into one chatbox

▫️ Make AI handle the research, the reading, and the first draft

▫️ Build apps, dashboards, and workflows with zero code

Usually $395, free for readers, plus a bonus session on the workflows worth stealing. Saturday, 10 AM EST.

Save your free seat !

1. Who’s Actually Funding the AI Panic (It Started 2 to 3 Years Ago)

Every time Ng posts about AI, the replies turn to data centers and job loss. He says that panic didn’t happen by accident, and it’s feeding the same layoff trap showing up across tech.

A lot of this is an unfortunate attempt that started 2 or 3 years ago of I think, PR and registry capture.

Training a frontier model costs billions. Giving it away for free wrecks the economics for whoever spent the billions building it.

Ng traces the current wave of AI fear back to that math. Companies sitting on expensive, closed models benefit when open alternatives look dangerous, not because the open models are worse, but because a scared public writes stricter rules. Stricter rules protect whoever got there first.

He’s specific about the mechanism. Regulatory capture favors incumbents, taxes new entrants, and makes it harder for anyone to give away a competing model for a fraction of the cost.

Before you accept the next scary AI headline at face value, check who benefits from you believing it.

2. The Nuclear Weapons Comparison That Never Made Sense

Compare something to nuclear weapons and people stop asking questions. Ng thinks that’s the entire point.

Fear-mongering works when you go and say AI is like nuclear weapons, which is an analogy that has no basis in fact.

Nuclear weapons exist to destroy things. Large language models write emails, debug code, and occasionally hand you a mediocre business idea.

The comparison isn’t an argument. It’s a mood.

Ng points to the pattern underneath it. Cherry-pick one AI misstep and inflate it into a trend, the same way people ignored it when China open-sourced Opus-level intelligence and the sky didn’t fall.

Circulate a claim about AI data centers draining water supplies that doesn’t match reality. Each story looks small alone. Stacked together, they’ve shifted public feeling about a technology most people haven’t used seriously.

The cost isn’t abstract. Fear-based policy slows American AI adoption, and slower adoption means less competitiveness, not more safety, a pattern that shows up across the six AI trends actually defining this year.

3. The 30 to 40% Math Behind Why AI Won’t Take Your Job

The jobpocalypse story assumes AI does 100% of a job or none of it. Ng says that’s not how the math works.

AI could do 30 to 40% of many jobs and what that means is, well, that 60% that a human does has become even more valuable because it's called an economic compliment.

Economists Eric Brynjolfsson at Stanford and Andy McAfee at MIT broke jobs into individual tasks instead of titles. What they found: AI handles a meaningful slice of most roles, not the whole thing.

That slice getting cheap doesn’t make the rest of your job worth less. It’s the opposite.

When one input to a job drops in price, the input it depends on, your judgment, becomes the scarce part. Economists call that a complement.

The catch Ng adds fast: people who use AI will likely replace people who don’t. AI itself isn’t positioned to replace the person, not for most jobs.

4. Software Engineers Are Busier Than Ever (Here’s the 2022 Catch)

Software engineering is the profession AI has hit hardest. Job openings there are up, not down.

All the good software engineers I know are busier than ever.

If AI were actually replacing developers, hiring would be shrinking. It isn’t. Ng says the doom narrative doesn’t match what’s happening inside companies that ship software for a living.

The catch: coding the way you did before ChatGPT existed is a liability now, the exact gap driving salaries for 6 roles that paid $120K to $200K in 2024 to disappear. AI already handles roughly 30 to 40% of what a developer used to do by hand. Clinging to the old workflow just makes you slower than someone who let AI take that part and moved on to what’s left.

Universities are behind on this too. Ng says most programs are still training students for 2022 jobs, the same year the old hiring playbook stopped working, when they should be building toward 2028.

His advice for fresh grads: keep learning in class, then fill the AI gap yourself through Coursera, DeepLearning.AI, or Udemy, wherever the curriculum hasn’t caught up yet.

If you’re closing that 2022-to-2028 gap yourself, start here:

▫️ The 2026 AI engineer roadmap: 5 projects that change what you earn

▫️ Stanford AI engineering: 10 lessons most builders get wrong

▫️ Career Zigzaggers Are Winning in AI: Why Non-Linear Paths Create Alpha

5. Why Andrew Ng Says AI Is Terrible for Learning (Even for Him)

He built 2 education companies. Now he’s telling you not to trust the tool his own career runs on, at least not for this.

LLMs, as they’re most commonly used, are terrible for learning.

Homework scores go up when students use AI. Ng says that’s the trap. Retention, the part that matters 6 months later, gets worse.

He’s not immune. Ng describes asking an AI model how a piece of code worked, getting the answer, shipping it, and forgetting it completely by the time he needed to touch that code again.

The mechanism has a name: cognitive offloading. Efficient in the moment. Expensive over time, because the thing you outsourced never gets encoded as a skill you actually own.

He isn’t arguing for banning AI in school. He’s arguing that the vast majority of how people currently use it works against the exact skill they’re trying to build.

6. The Human Context Advantage AI Can’t Copy (Not for Years)

Ask an AI model to brainstorm and you’ll get 1 or 2 good ideas, 2 or 3 mediocre ones, and roughly 4 that make you wonder what it was thinking.

Humans have a massive context advantage compared to AI.

Ng’s explanation for the bad ideas: the model never saw the facial expression that told you a customer hated something. It doesn’t know your manager’s pet priority, or the unstated reason a plan that looks fine on paper fails at your specific company.

People sometimes call this taste or judgment, like it’s fuzzy and unteachable. Ng disagrees. The mechanism underneath both words is accumulated context, years of situational knowledge no model has access to.

That advantage doesn’t expire soon. Nobody’s closing this gap in a couple of years, which is why the AI moat was never really the model to begin with.

The more context you’ve built in your specific domain, the harder you are to substitute, no matter how good the model gets, one of the few advantages that actually compound as software gets cheaper to build.

7. Building Got Cheap. Deciding What to Build Didn’t.

Ng builds something new most weekends, closer to running a one-person business on Claude than to a traditional engineering process. He says the hard part was never the code.

The cost of building has plummeted. And so the challenge is shifting to deciding what to build.

Last weekend, he used a frontier model to analyze his own company’s business metrics instead of pulling in a data scientist, picking the model carefully based on its data retention policy, and got the work done in an afternoon.

He calls the actual constraint the product management bottleneck. Anyone can generate code fast now. Fewer people can say, with any confidence, whether what they’re generating is worth building at all.

His answer for founders, engineers, and product people alike: learn AI, build fast, and talk to customers enough to develop the judgment that decides what’s worth the speed.

If the code just got cheap and you want to point that at something worth building, start here:

▫️ How to Build Three AI Agents Without Writing Code

▫️ The Billion-Dollar Startup Formula: Why AI-Driven Small Teams Are Beating Giants

▫️ 70 startup ideas YC wants you to build

8. The New Baseline: Everyone on Your Team Can Build

Building software used to require an engineering title. Ng says that requirement quietly disappeared.

It’s becoming much easier for everyone to build with AI.

When something gets dramatically easier, more people do it. Ng’s marketing team writes code.

His CFO built automation scripts that scan documents and flag inconsistencies instead of waiting on an engineer. His recruiting team embeds actual engineers to build sophisticated internal tools.

The set he names most: marketers, recruiters, HR professionals, and operations specialists who learn to build get more done, take on broader roles, and, in his telling, have more fun doing it.

His interview bar has shifted to match. He doesn’t ask marketers what tools they know. He asks what they’ve built, the same one-person-business standard he holds himself to.

One of his marketers built a desktop app that crawls the web for related articles while he writes.

Job titles are becoming a worse predictor of who can actually ship something, which is exactly why non-linear career paths are capturing the upside right now.

9. Andrew Ng’s One Rule for What Never Touches the Cloud (Not Even for Hyperscalers)

Not every AI question is a strategy question. Some of them are just a privacy checklist.

For the really sensitive things, I sometimes run a local model.

Ng trusts the big hyperscalers to follow their published terms of service. He’s blunter about smaller AI companies, some of which have changed their data retention terms behind a pop-up most users click through without reading.

His personal line: material non-public information, the kind that could move a stock or expose a client, doesn’t go to any cloud model, full stop. He either does that work by hand or runs it on a local, open-weight model that never leaves his machine, the same caution behind why AI security work is turning into a six-figure skill.

Open-weight models have gotten good enough to make that practical, part of the broader economics pushing companies toward open source. Ng names Meta’s and Alibaba’s Qwen releases as approaching frontier quality while staying small enough to run locally, though he’s quick to add that the leaderboard changes every few weeks.

The rule scales down fine for the rest of us: if you wouldn’t email it to a stranger, don’t paste it into a chat window.

10. What AGI Actually Means (Ng Says It’s Still Decades Away)

Jensen Huang says we’ve already reached AGI. Ng says that depends entirely on which definition you’re using.

AGI is AI that could do any intellectual task that a human can.

By that standard, an AGI system could write a PhD thesis after the equivalent of 5 years of study, or learn to drive a truck through unfamiliar rainforest terrain after tens of minutes of practice. Ng says there’s a long list of tasks like that AI still can’t touch, and he expects that list to take decades to work through.

He names the incentive problem directly. OpenAI once had a financial arrangement with Microsoft tied to declaring AGI, a bet that traces back to the AGI plan OpenAI itself wrote in 2018, an agreement that’s since been renegotiated. Lower the bar on the definition enough, and you could claim AGI was reached decades ago.

His point isn’t that AGI talk is meaningless. It’s that the definition someone reaches for tells you more about their incentives than about the technology.

If you want the fuller AGI timeline debate instead of just this one, start here:

▫️ Demis Hassabis Says AGI Arrives in 2 to 5 Years. Here Is the Full Picture

▫️ Dario Amodei Says AGI Is 1-3 Years Away. Here’s His Full Breakdown

▫️ Ilya Sutskever’s New Playbook for AGI

What This Means for You

The pattern across every section is the same: the cost of using AI keeps dropping, and the value of what AI still can’t do keeps rising.

▫️ Founders: The code got cheap, to the point where you can build your first agent without writing code. Your edge now is deciding what to build and confirming it with customers before you scale it. Don’t skip the customer conversation just because building got faster.

▫️ Investors: Watch for regulatory positioning dressed up as safety concern. The loudest fear campaigns often trace back to whoever benefits most from the resulting rules.

▫️ Operators: If your team still treats AI skills as an engineering-only requirement, you’re leaving output on the table. Marketing, finance, recruiting, and operations can all build now, the same shift behind handing your agent its own computer instead of a chat box.

▫️ Everyone else: Pay attention to how you’re actually using AI day to day. If it mostly generates answers you then forget, you’re optimizing for homework scores over the skills that compound.

The 5 Principles to Steal

1. Context is the moat. The years of situational knowledge you’ve built up are the thing AI can’t fast-follow. Keep building it on purpose.

2. Match build speed to judgment. Fast building without customer contact just gets you to the wrong answer faster.

3. Treat 2022 workflows as expired. If AI already automates a task you’re doing, that’s a signal to move up, not a threat to ignore.

4. Ask who benefits before you panic. Fear-based AI headlines usually trace back to somebody’s regulatory or PR interest.

5. Draw your privacy line now. Decide what never leaves your machine before you’re rushed into pasting something you’ll regret.

Nobody knows the one right major or the one right specialization. Showing up with AI skills and genuine agency beats waiting for certainty. 2 things separate the people this playbook describes from everyone else: they build, and they ask.

If this breakdown saved you an hour, send it to one founder or investor who needs it.

More on AGI and the Frontier Race

▫️ Hassabis Bet His Job on AGI by 2030. Here Is What He Knows.

▫️ Ilya Sutskever’s New Playbook for AGI

▫️ Perplexity’s Founder Found AGI Risk in a 2,000-Year-Old Epic

Building and Shipping Faster

▫️ Andrej Karpathy: The AI Workflow Shift Explained

▫️ Your 2026 Guide to Prompt Engineering: How to Get 10x More from AI

▫️ Prompt Engineering Is Dead. Context Engineering Is What Matters Now.

Careers and Hiring in the AI Era

▫️ Sam Altman: 3 months of work now takes 7 minutes

▫️ Free AI Hiring Kit for Founders

▫️ The Story Behind Every Great Startup Is the Most Overlooked Skill