Summary

Cosine’s sovereign-model bet is economically plausible largely because the UK supplies training compute and customers supply inference. Government backing brought an allocation on Bristol’s Isambard cluster, while Cosine licenses weights for customers to run on their own GPUs rather than financing token-serving infrastructure. That converts sovereignty from aspiration into a narrow, capital-disciplined build—though Pullen stresses there “isn’t a huge amount of room for error or wiggle room.”
Pullen argues that frontier performance likely requires matching closed labs on total and active parameter count, not merely advertising a large sparse model. He cites third-party estimates of 1.3–1.5 trillion total parameters for Sonnet and 1.5–1.8 trillion for Opus, perhaps with 150–180 billion active, while deployment economics push open models toward fewer active parameters. His blunt counterfactual: “If we could have trillion-parameter dense models, we would.”
The durable data moat may sit after pre-training, where realistic trajectories and enormous RL runs shape how models actually behave. At roughly 30 trillion pre-training tokens, Pullen says everyone is “compressing most of the internet”; differentiation shifts toward post-training data, reinforcement-learning scale and exposure to the chaotic prompts real users submit. He also says the largest labs have an edge in data procurement and mature internal data functions. He explicitly does not claim Anthropic trains on Claude Code conversations, but considers their trajectory stream a potentially formidable feedback source.
Passing a unit test is an inadequate reward because it reinforces bloated, unsafe and unmaintainable solutions alongside correct ones. Cosine gates all rewards on correctness, then evaluates qualities such as elegance and excess code, sometimes comparing an agent’s patch with the human implementation. Its deeper research target is credit attribution: identify the consequential decisions inside a trajectory instead of treating every token in a 256,000-token rollout as equally responsible for a final one-or-zero reward. Scarfe links this to benchmark limits: pass@1 and pass@5 can miss reliability, security and abstraction formation.
Coding agents still need humans because vague product intent, taste and maintainability are not yet reliably verifiable. Pullen expects eventual autonomy through better models, realistic RL environments and harness engineering, but says “we’re nowhere near there yet.” Near-term assurance shifts from reading enormous diffs to runtime proof—show that the feature works, validate suspected exploits in a live environment and maintain comprehensive end-to-end tests.
Harness value is migrating from basic tool access toward efficient orchestration, but swarms multiply understanding debt. Pullen says a strong model can now do “with Bash only basically any task,” yet Cosine’s orchestrator–subplanner–worker hierarchy can complete projects that Kimi K2.6 cannot handle alone. File locks, edit notifications and direct intervention with low-level workers reduce collisions; they do not eliminate the need to “comb through it afterwards.”
Export controls have turned sovereign AI into an urgent commercial category, while also exposing its hardware dependency. Pullen’s tentative defense is that Cosine’s required infrastructure is already installed in the UK and experimentation is underway; Scarfe frames the model as arriving toward year-end. News about 5.6 made the performance gap visceral: “We have no choice but to make it happen.”

Deep dive

1. Public compute turned sovereign AI into an executable project

Pullen describes Cosine as a UK frontier lab that, until roughly three months earlier, focused on best-in-class coding agents for regulated and “high-side” environments including financial services, insurance and defense. It still operates that business, but now carries a mandate to build the UK’s first “sort of sovereign LLM.”
Roughly nine or ten weeks before the interview, Cosine was backed—Pullen corrects himself from “inducted”—by the government’s sovereign AI unit. The practical benefit is compute on the Isambard supercomputer cluster in Bristol, supplemented by private capacity; without it, a startup raising $50–100 million might spend a large portion simply obtaining project compute.
Scarfe connects the urgency to Fable’s sudden ban under export controls. Pullen says sovereignty “was not something that was on my bingo card in January,” but Cosine already possessed the model-training infrastructure, algorithms, data operation and personnel needed to turn the government allocation into a credible attempt.

2. Avoiding inference economics makes millions compete with billions

Scarfe’s central challenge is direct: how can Cosine accomplish with millions what US labs pursuing hundreds of billions—and Mistral with single- to double-digit billions—are attempting? Pullen’s answer starts with business architecture: “We at Cosine are not an inference company.”
Customers usually receive model weights and deploy them on their own GPUs in air-gapped environments, or rent capacity through an existing Azure or AWS relationship. Cosine licenses technology rather than earning a margin on tokens, so it need not fund the inference data centers that Pullen believes motivate many of the largest infrastructure deals.
That distinction does not make training cheap. Cosine intends to complete continued pre-training, mid-training and post-training, but Pullen concedes that constrained compute limits RL generations, rollout variety and inference-time compute during RL. With ten times the capacity, he would run larger experiments; today, “there isn’t a huge amount of room for error.”
Viability therefore depends on a deliberately narrow scope and an unusually direct demand signal. Some of the UK’s largest companies are feeding their desired use cases into Cosine, allowing it to train for identifiable domestic customers rather than optimize blindly for every possible deployment.

3. Active parameters set the performance ceiling

Pullen reduces frontier competitiveness to three main variables: architecture and total model size, active parameter count, and data. Mistral Large 3, which he identifies as a 675B sparse model, may fit enterprise GPU profiles pragmatically—but that deployability also caps how far performance can scale.
A third-party latency analysis heavily influenced Cosine’s architecture. Pullen carefully calls the figures uncertain, but says Sonnet may contain 1.3–1.5 trillion total parameters with more than 100 billion active, while Opus may be 1.5–1.8 trillion with roughly 150–180 billion active, depending partly on whether inference uses FP8 or FP4.
Pullen’s example is DeepSeek V4 Pro—around 1.6 trillion total but perhaps 30–50 billion active. Scarfe extends the inference-centered argument: a model needing two B300 nodes merely to fit into memory and run at acceptable throughput may be impractical for many users. He sees this deployment constraint as one reason Chinese, European and American open models have not matched closed-source performance.
The deployment evidence behind Pullen’s dense-model preference is GPT-OSS-12B, which he recalls as having roughly five billion active parameters, against dense Devstral 2 123B. Cosine deployed both, and Pullen says Devstral felt “night and day” better. “If we could have trillion-parameter dense models, we would”; he treats sparsity primarily as an inference and deployment compromise.

4. Post-training data matters more than another copy of the internet

Pullen suspects pre-training datasets converge once they reach roughly 30 trillion tokens: “We’re compressing most of the internet at that point.” Mid-training may be similarly commoditized; post-training data and the ability to run RL at “ridiculous scale” remain sharper sources of laboratory differentiation.
He also says the largest labs have an edge because they can procure more data from brokers and have mature internal data functions, while not claiming that other labs lack those capabilities entirely.
Scarfe’s stronger version of the data-moat argument is that software engineering is not merely code generation. It is a process of running experiments, creating and revising mental abstractions, and sharing them with a team—so trajectories reveal “how you got there,” not only the final patch.
Pullen does not know whether Anthropic’s terms permit training on Claude Code activity and declines to claim that it does. The immediate value of Cosine’s own employee trajectories is simpler: they reveal how users actually prompt, replacing pristine training questions with requests resembling “It doesn’t work” and “Why the hell have you done this?”
Those conversations lack canonical rewards, although user reactions or model judges might approximate satisfaction. Pullen nevertheless speculates that a large share of the “alpha” Anthropic gets from trajectories comes from learning the real distribution of instructions, corrections and frustration—and making training-time interactions look less synthetic.

5. Correctness-only RL manufactures software slop

Scarfe’s “spaghetti monster” objection is that agents often pass tests while adding 200 lines where one would suffice, accumulating understanding debt. Pullen agrees: standard coding RL rewards a rollout when its unit test passes, reinforcing every unsafe command and ugly implementation along the successful path. The crucial question is not only whether it works, but “at what cost?”
Cosine makes correctness a gate: an elegant wrong answer receives nothing. Beyond it, separate rewards target slop, and permissively licensed pull requests can supply human reference patches; if an agent writes 500 additional lines, that discrepancy becomes evidence against granting full reward without requiring the model to copy the original implementation.
The algorithmic problem is credit attribution. A rollout might span 256,000 tokens before receiving a one or zero, yet current methods often weight every token as equally causal. Pullen compares this with a teacher marking a 2,500-word essay only “that’s a B”; hundreds of attempts might reveal the lesson statistically, but circling the bad sentence would teach it far more efficiently.
Cosine wants an “unopinionated” way to locate important decisions and assign positive or negative advantage disproportionately to those ranges. The method can sit atop GRPO, GSPO and related algorithms, using the same FLOPs to reinforce reusable choices rather than filler. Scarfe’s summary—force models higher up the “abstraction mountain”—is one Pullen accepts.
Scarfe also criticizes benchmarks centered on pass@1 and pass@5 for overlooking reliability, consistency, security and abstraction formation. He cites François Chollet’s newer ARC challenge as difficult to brute-force and therefore more demanding of genuine abstraction.

6. Verifiability keeps humans inside agentic engineering

Scarfe presses the epistemic limit: execution provides verifiable rewards in coding, maths and physics, but neither machine learning nor a reward model automatically possesses truth. Pullen’s honest non-answer for law and other non-verifiable fields is “I don’t know”; human or well-prompted LLM judges may get close, but the broad dream of effortless generalization has “been sort of shown to not really exist that much.”
Pullen believes humans can eventually leave the loop, but “we’re nowhere near there yet,” especially when a novel application is only vaguely specified. Good, maintainable software still requires taste and post-hoc correction of design decisions. Progress must combine stronger models, RL environments resembling real engineering work and better harnesses.
His near-term code-review model substitutes runtime proof for another AI merely reading diffs. Cosine’s security swarm launches the application in a production-like virtual machine and attempts to exploit each alleged vulnerability; findings the agent cannot reproduce are removed. The same principle for pull requests is: “Show me it’s doing that.”
Scarfe’s pushback remains unresolved: agents may write or weaken their own tests, while functional specifications, user stories and behavior are only different views of the “blind elephant.” Pullen adds comprehensive end-to-end tests and screenshots or recordings of the happy path, seeking an alternative to review backlogs and “looks good to me, merge” after one minute.

7. Swarms extend models while memory remains a RAG-shaped hack

Pullen’s provocative call is that “agentic harnesses are getting less important over time” because models are becoming capable enough to complete almost any task with Bash alone, albeit more slowly and expensively. Cosine still co-designs harness and model, but now optimizes primarily for fewer tokens as enterprise “tokenomics” becomes material.
Scarfe’s pushback—worth keeping—is that subagents reduce ambiguity and context rot by factorizing a difficult job into fresh, tightly specified tasks. Cosine’s swarm automates that logic: one orchestrator delegates verticals to subplanners, which dispatch parallel workers. A mechanical-watch compiler with a Python SDK, physical constraints and 3D viewer became feasible in one shot, despite being beyond standalone Kimi K2.6.
Scale introduces interference and opacity. Cosine permits users to interject directly with low-level workers, applies write locks so only one agent edits a file, and warns agents when another worker changed something they recently read. These controls help, but Pullen concedes there will still be “sweeping afterwards” when abstractions or design choices are wrong.
Memory is harder still: agents must know when to retrieve, what deserves storage and whether an entry has gone stale. Vector databases and embedded notes remain “a bit of a hack”—effectively “the one remnant of RAG.” Continual learning might place memory in latent space, but RL introduces reward hacking, leakage and the risk of querying knowledge from the future.

8. Synthetic graders convert real work into scalable RL

Cosine does not ask models to invent coding problems because “if the model can come up with a problem it can probably solve it.” Instead, it starts with real feature work, refactors and other commits, then synthesizes the missing ground truths or graders. The test must be implementation-agnostic enough to accept multiple valid solutions while remaining rigorous about functionality.
Eighteen months of pipeline work, manual labeling and specialized post-training models have made that process largely autonomous across languages, stacks and task types. It supplied RL data for Java, Fortran and C++; for Verilog and SystemVerilog, validation may require running a synthesizer in an EDA environment. Cosine is now extending the method beyond software engineering for its general sovereign model.
The hardware answer remains tentative. Pullen “naively” thinks that if the hardware is already in the UK, he does not know how much can be done about it; experiments are already running. Scarfe frames the model as due toward year-end, but Pullen does not independently confirm that schedule.
Demand from companies, government and citizens surged after the export-control shock. Pullen separately says the news about 5.6 made the performance gap personally frustrating, prompting “thank you, Donald Trump” and the final commitment: “We have no choice but to make it happen.”

Market Overview July 14, 2026 The Trillion-Dollar Industries AI Is Disrupting: Voice, Law & the End of the Billable Hour