Sam Altman on PHP2Shell, Agent Teams, Compute and the Agent-Ready Web

What happens when AI can find a severe software flaw, help produce a serious mathematical proof and act on a customer's behalf? In this Cheeky Pint conversation, OpenAI CEO Sam Altman and Stripe co-founder John Collison explore all three. The practical story is less tidy than the headline: discovery still needs patches, formalized mathematics still needs scrutiny, and a personal agent still needs reliable tools, permissions and a business willing to serve it.

Watch Sam Altman and John Collison

The Cheeky Pint transcript is the companion source for the interview. Stripe Atlas appears as a sponsor segment; it is not evidence for the technical claims. Sam's internal costs, future projections and safety judgments are attributed to him, not independently reproduced here.

PHP Week: Finding a Flaw Is Not Repairing the Web

The discussion opens with a frightening question: what happens when AI helps find critical defects in software that underpins a large part of the web? Sam says the defensive response to the PHP disclosures went better than he expected on day one, but he explicitly does not declare victory. Discovery, coordinated disclosure, vendor patches and deployment are separate jobs.

OpenAI's account of the disclosure credits researcher Calif, using GPT-5.6 Sol, with finding one critical flaw. Wiz independently found and reported both flaws. The PHP project released security updates on 21 October 2026 for supported branches: 8.5.12, 8.4.27, 8.3.36 and 8.2.35. The PHP advisory says upgrading to a fixed release is the complete remedy, although a distribution may backport the fix without changing its displayed upstream version.

John asks whether a vulnerable old codebase should simply be rewritten in a safer language. Sam entertains the long-term architectural question but does not prescribe an immediate rewrite. For an operator, the near-term sequence remains straightforward: identify the running PHP branch, get the vendor's fixed package, confirm the update is deployed, and follow any incident guidance relevant to exposed systems. A model discovering bugs does not patch your server.

Sandboxing Helps, but Sam Doubts It Can Stand Alone

At 08:54, the conversation turns from vulnerabilities to containing a much more capable model. Sam says sandboxes work to a point and can improve. His concern is a hypothetical future system far beyond human security researchers: would any static containment boundary be enough on its own? He argues for layered controls, monitoring and alignment, and wonders whether multiple agents could check one another.

That is a safety argument, not a demonstration that all sandboxes fail. OpenAI's own frontier training-environment note describes isolation, microVMs, network controls and monitoring as active parts of its containment strategy. The sensible distinction is between useful present-day boundaries and confidence that those boundaries alone would contain an unknown future capability level.

Navier-Stokes: A Published Proof, Not a Finished Prize Process

Sam describes an internal OpenAI experiment on the Navier-Stokes problem and estimates its compute at roughly $10 million, perhaps more. That figure is his order-of-magnitude recollection in the interview, not an audited project bill. OpenAI published its research account, including a claimed finite-time blowup construction, and released papers and Lean formalization for examination. The company reports using about 10,000 concurrent agents during the effort.

There are two different standards of "proved" here. A proof assistant can check that a formal argument follows from its encoded definitions and assumptions. Mathematicians still need to inspect whether those definitions match the intended problem, assess the broader paper, and reach community acceptance. The Clay Mathematics Institute said the problem had apparently been settled, while stressing that evaluation takes time. The Millennium Prize has not thereby been automatically awarded. This is a significant published result, and its final standing is still a matter for mathematical review.

The more general lesson from Sam's account is about resource allocation. Giving a team more compute is not enough; it must be divided among exploration, checking and formalization in a way that improves the answer. He says OpenAI learned from the project and expects the same type of work to get cheaper as those decisions improve.

From More Thinking Time to Teams of Agents

Sam prefers agent teams to "swarms." His argument is that a better base model can use more test-time compute to reason through a problem, while multiple instances can explore different approaches and verify one another. That could make a hard task tractable even when a single uninterrupted run stalls. It also makes budgeting important: more tokens are an input cost, not the goal.

He takes the idea further, suggesting a plural system of agents that push against one another may be safer than one centralized superintelligence. That is a hypothesis about future governance and alignment, not proof that multi-agent systems are safer. Teams can also repeat the same error, share a blind spot or amplify a bad instruction. For a business workflow today, a useful team needs clearly separate roles, bounded tools, a stopping rule and an independent check of the final result.

Compute Supply, Robotics and the Value of a Result

At 25:17, Sam turns to the physical constraints behind all this work. More agent work means demand for chips, memory, power and data centers. He says OpenAI has a robotics program aimed at helping make the components needed for more compute. He and John also acknowledge that permitting and component supply can bottleneck a data center even if construction labor improves. Robot-built gigawatt facilities are an ambition, not a demonstrated production system.

Later, they use revenue per gigawatt and total cost of ownership as ways to think about infrastructure. The dollar figures in that exchange are illustrative assumptions, not public forecasts for a particular OpenAI project. Sam also argues that globally, shared inference infrastructure may use scarce memory more efficiently than every user keeping high-end local hardware idle. That does not erase the privacy or control reasons for running a local model; it is an argument about resource utilization at scale.

John's "token pricing is fake" chapter is best read as a critique of tokens as a measure of value, not as a claim that token billing is imaginary. A business buys a completed research task, a working change or a good customer answer; it does not value 10 million tokens for their own sake. But opaque per-result prices are also hard for customers to trust. Measuring both the total cost of an accepted result and its quality is more useful than cheering a high token count.

The Customer May Send an Agent Instead of Opening a Form

John asks what happens to businesses when personal agents increasingly do the browsing and form-filling. Sam describes an ideal assistant as combining intelligence, personal context, tools and reliability, and says the true personal-agent breakthrough has not arrived yet. OpenAI's Dots announcement shows a current step toward persistent agents, with its own availability and permission limits, not a universal replacement for websites.

For merchants and service providers, John's practical point is to let a customer-authorized agent retrieve facts and complete appropriate steps without fighting the interface. That does not mean every agent should be allowed to transact: identity, consent, fraud controls, inventory and payments remain real. A clear product page, machine-readable terms and a reliable handoff can help both humans and agents. Our agent-commerce guide explores the research, prepare and pay distinction in more detail.

A Small Agent-Ready Business Pilot

The first test need not be a checkout API. Pick one question customers already ask, then see whether a permitted assistant can answer it accurately from public pages. This is our editorial application of the interview, not a process Sam or John demonstrated.

Video Chapters

Security and model containment

Math, agents and compute

Pricing and customer agents

Source Note and Further Reading

Checked 29 October 2026. The video, supplied transcript and Cheeky Pint transcript are the sources for what Sam and John said. We did not audit OpenAI's internal spending, reproduce its math result, or test the forecasted agent-commerce and robotics systems. The official documents below let readers check the PHP releases, OpenAI's published work, Clay's response and current containment/product descriptions.