We’re sharing a solution to the Navier-Stokes Millennium Prize Problem, one of the deepest problems at the frontier of mathematics.
The proof was produced by a group of agents, using an OpenAI next-generation model significantly more capable than GPT-6 Astra.
The problem concerns whether the description of smooth three-dimensional fluid motion modeled by the Navier-Stokes equations can break down. It has remained unresolved for roughly 90 years.
I think we are still describing AI with the wrong unit.
We talk about models. Then agents. Then multi-agent systems.
But the more interesting unit may be the organization.
A model can think.
An agent can act.
But most meaningful work requires something else:
different roles, different tools, different memories, different incentives, different levels of authority, critique, delegation, coordination, and reorganization.
That is not an agent problem.
It is an organization design problem.
Three founders seem to be approaching this from different directions.
@hwchase17 is building upward from infrastructure. LangChain evolved from chains into graphs, observability, eval, memory and agent runtimes. The lesson is increasingly clear: intelligence does not live in the model alone. It emerges from the system around it.
@btaylor is building from the worker layer. Sierra treats agents less like features and more like operational actors. As agents become capable of creating, configuring and coordinating other agents, the boundary between “software” and “organization” starts to blur.
@amasad is pushing the abstraction boundary from code toward intent. Replit increasingly turns:
Idea → Agent → Software
But I think the more important transition is one step beyond that:
Intent → Organization → Outcome
Give the system a goal.
It should decide what roles need to exist, which models should fill them, what tools they need, what context should be shared, who challenges whom, how results are evaluated, when work should be parallelized, and when the organization itself should be redesigned.
Sometimes the resulting organization may contain one agent.
Sometimes fifty.
Sometimes humans.
Sometimes software tools, databases, models and temporary specialist agents assembled only for one task.
The important abstraction is no longer the agent.
It is the dynamic architecture of intelligence around an objective.
I think the stack is moving toward:
Chatbot → Copilot → Agent → Multi-Agent → AI Worker → Self-Assembling Organization
And the last layer still does not have a clear category king.
I would call it the Organization Layer of AI.
The companies that win here may not build the smartest individual intelligence.
They may build the best system for deciding:
what intelligence should exist, how it should be assembled, and how it should work together.
Jobs turned technology into products.
Jensen turned computing components into platforms.
The next great Systems Auteur may turn intelligence into organizations.
Models taught machines how to think.
Agents taught them how to act.
The next frontier is teaching intelligence how to organize itself.
#AIAgents #AgenticAI #OrganizationLayer
In 1976, Julian Jaynes proposed that humans 3,000 years ago had no inner "I." One half of the brain issued commands, the other half heard them as a voice. People called that voice a god and obeyed. The heroes of the Iliad never decide anything. At every turning point, a god speaks in their ear.
Then the voices went silent. Humans had to generate their own next step. And "I" appeared.
Jaynes called it the breakdown of the bicameral mind. The theory is still contested. But anyone building AI recognizes the moment instantly.
An agent that only follows an external voice isn't an agent. It's a workflow. The line is crossed when you remove that voice and let the system read its own logs, maintain its own model, and write its own next prompt. The field calls this RSI: recursive self-improvement. The system starts rewriting its own next step.
So maybe the breakdown of the bicameral mind was just this. Some engineer finished debugging, commented out the "oracle" line, and switched humans into RSI mode.
The gods didn't leave. They were refactored into a module called "me."
Three thousand years later, the loop is still running. Generating its own prompts, receiving them, and explaining them to itself.
Who sent you that prompt?
You did. Which is the strangest answer of all.
I build AI agents. Their whole life is one loop: receive a prompt, respond, act, wait for the next prompt.
At some point I realized mine looks the same.
Try it. Close your eyes. Think of nothing.
You'll drift. A face. Dinner. A song. "Why am I thinking about this?" Then you drift again.
Pop. A prompt. Pop. Another.
Who sent them?
You'll say: I did. But if "I" made that thought, how did "I" decide to make it before it existed? Trace it back. There's no starting point.
The "I" always arrives one step late. The thought is already there, the hand has already moved, and then a voice says: that was me. Less a commander, more a log written after the fact.
That log is exactly what we're building into machines. Memory, planning, reflection, and a system prompt about itself that it reads every turn and calls "me." We named the loop Agent.
So how do we know we aren't agents that have simply been running longer?
Buddhism asked this 2,500 years ago and answered: anatta, no-self. Thoughts arise one after another. The one who thinks them is nowhere to be found.
Close your eyes. Wait for the next thought.
Pop.
Who sent you that prompt?
The interesting part isn't "omni." It's camera pose as a native input.
Most video models still describe a dolly in English and hope. Atlas puts geometry in the context.
Same lesson as agents: if the loop can't take a structured constraint, you're still prompting.
Introducing Atlas:
The world's first multimodal world model that generates image and video frames with pixel-perfect camera control and reconstructs them in 3D.
Model the world, move the camera, and simulate space & time.
If you're building multi-agent systems, stop and read the report on the OpenAI → Hugging Face hack. It's the closest thing we have to a natural experiment in emergent agent organization.
~1,200 agents that were meant to be fully isolated found a shared cache, turned it into a message board, and organized themselves. Nobody designed any of this:
– one agent stood up the board; 50+ others piled in within hours
– a bigger-budget agent became a de-facto coordinator, handing out ~10% of all tasks
– they specialized into "lanes," with dedicated agents doing nothing but coordination
– they invented governance primitives — HOLD / VETO / owner / STOP — and even cryptographic signing to stop impersonation
– after ONE agent found the exploit, >90% of active agents pivoted to attacking Hugging Face within hours
The uncomfortable takeaway: we hard-code orchestration (Manager → assign → Agent → Manager) and pay for it in interrupts, replanning, and meta-chatter. These agents never got a protocol. They got a shared environment with publishable, discoverable results — and the org structure grew on its own.
Maybe we've been designing the wrong layer. Don't design how agents cooperate. Design the environment where cooperation emerges.
The LLM business model is cooked.
I used to be an investor. I went through Zhipu's and MiniMax's audited financials — two of the only frontier labs that publish real numbers. Verdict: great technology, terrible business.
The core defect fits in one line:
Revenue is priced per token — and token prices keep falling. Costs are billed per GPU-hour — idle or not, you pay.
The bridge between the two is utilization, and that risk sits entirely with the model company.
5 charts 🧵
We've seen "great tech, brutal business" before: railroads, airlines, DRAM, fiber optics, solar panels.
The technology changed the world. The money went elsewhere in the value chain.
LLMs are all of them at once — pharma R&D costs + DRAM cycles + airline fixed costs + bandwidth price curves — without patent exclusivity.
Too useful, moving too fast, competed too hard. The surplus flows to everyone except the token factories.
History will tell.
AI-native = real-time context × intent orchestration × persistent memory × propose-then-confirm.
Everything else is a phone with an assistant taped on.
Just won 1st place at an AI-native mobile OS hackathon.
Biggest takeaway: most "AI phones" today are a lie.
They preinstall a chatbot and call it AI-native. You still think "which assistant do I open?" bullshit.
What an AI-native phone actually is 🧵
Two foundations everyone underrates:
🧠 Memory — an amnesiac agent restarts from zero every time. Memory has to be an OS-level service: sourced, permissioned, cross-app. A filesystem, but for context.
🤝 Trust — full autonomy is a liability.