UK Sovereign AI: How Cosine AI Is Punching Above Its Weight Against American Compute Dominance

The UK is falling behind the US in the AI race — that's the blunt assessment from Cosine AI founder Alistair Pullen in a London interview. While American tech giants routinely commit hundreds of billions to compute infrastructure and Europe's Mistral has reached a multi-billion-dollar valuation, a startup that began in a Hoxton flat in London has secured government authorization to build the "UK's first sovereign large language model." This conversation goes beyond geopolitical anxieties around AI sovereignty — it reveals a series of technically deep engineering and research insights.

The Awakening of Sovereign AI: From Abstract Concept to Urgent Reality

Sovereign AI refers to a nation or region's ability to independently control the training data, algorithmic architecture, compute infrastructure, and deployment rights of AI models. This concept surged in urgency between 2023 and 2024, triggered directly by the US Commerce Department's export controls on advanced AI chips (such as NVIDIA's A100/H100 series) and certain model API access. Though initially targeting China, the "long-arm" effect of these restrictions reached far beyond expectations, leaving the UK, the EU, and other allies facing potential access disruptions in specific scenarios. NVIDIA CEO Jensen Huang's repeated emphasis throughout 2024 that "every country needs its own AI infrastructure" further catalyzed government investment in sovereign compute.

Pullen admitted that the sovereign LLM opportunity wasn't on his radar at the start of the year. The turning point came when export controls led to model bans — when powerful models suddenly became unavailable to the UK, "sovereign AI" shifted from an abstract concept to an urgent, concrete need. About nine to ten weeks prior, Cosine was brought into the UK government's sovereign AI unit and granted compute allocation on the ISAMBARD supercomputer cluster in Bristol. ISAMBARD is a national HPC cluster deployed by the UK government at the University of Bristol, built on ARM architecture, and represents a key infrastructure node in the UK's AI nationalization strategy.

"This is one of the keys that unlocked our ability to be this ambitious," Pullen said. For a small startup, compute is the biggest barrier to taking on this kind of work. If they had to raise £50–100 million, a significant chunk would be consumed by compute alone. The injection of government compute made the project fundamentally viable.

Faced with the central challenge of "doing what others do with billions, using only millions," Pullen offered a key business model answer: Cosine is not an inference company. Since they primarily deploy into highly regulated, high-security environments — finance, insurance, defense — customers almost always take the model weights and run them on their own GPUs, or rent GPUs in their own cloud environments. Cosine licenses technology rather than monetizing tokens, so it doesn't need to invest heavily in inference data centers the way American companies do.

Three Core Elements for Catching Frontier Models

Pullen believes the reason Mistral, Cohere, and earlier Chinese open-source models fall short comes down to three things: architecture and raw model scale, active parameter count, and data quality.

He cited an empirical analysis that infers closed-source model sizes via Vertex and latency, suggesting Sonnet may sit in the MoE range of 1.3–1.5 trillion total parameters with over 10 billion active parameters, while Opus is roughly 1.5–1.8 trillion total parameters with around 15 billion active parameters. His conclusion: if you can't match this architectural scale, you'll struggle to approach the performance ceiling.

It's worth explaining the core logic behind MoE (Mixture of Experts) architecture. Unlike traditional dense Transformers, MoE replaces feed-forward network layers with multiple "expert" sub-networks, using a routing mechanism to activate only a small subset of experts per inference pass. This means the model has a massive "total parameter count" distributed across all experts, but each token's forward pass only traverses a few "active parameters." Active parameter count directly determines inference latency and per-call compute cost — models like GPT-4 and Gemini Ultra are widely believed to use this architecture.

Why do open-source and European models struggle to close the gap? Pullen offers a pragmatic explanation: models like DeepSeek V3 tend to compress active parameters (to around 3–5 billion, with a total of 671B parameters), primarily for inferability — if no one can run it, massive total parameters are meaningless. Top-tier labs with abundant GPUs and sufficient demand to maintain utilization can afford "heavier" architectures without worrying about idle costs. This design philosophy reflects a fundamental divergence between the "democratized inference" orientation and the "peak performance" orientation.

On the data front, he argues that differences in pretraining corpora become negligible beyond the 30 trillion token scale. The real battleground for differentiation lies in post-training and large-scale reinforcement learning (RL).

The RL Paradigm Upgrade: From Getting the Answer Right to Forming Abstractions

LLM training typically consists of two stages: pre-training and post-training. Pre-training performs autoregressive language modeling on massive unlabeled text, shaping the model's foundational knowledge and language capabilities. Post-training then uses supervised fine-tuning (SFT), reinforcement learning from human feedback (RLHF), and more recently rule-based RL to align model behavior and unlock reasoning capabilities. GRPO (Group Relative Policy Optimization) and GSPO (Generalized Self-Play Optimization) are both improved variants of PPO, designed to reduce dependence on value networks and lower memory consumption while maintaining stable policy updates — DeepSeek-R1 achieved major reasoning gains precisely through GRPO.

The most research-valuable part of this conversation concerns how RL can move beyond the crude paradigm of "reward correct answers." Pullen points to a core flaw in current RL: a rollout of 256K tokens ultimately reduces to a single 0 or 1 reward, with all tokens weighted equally — "which is obviously wrong."

He uses a brilliant analogy: it's like a student writing a 2,500-word essay and the teacher only returning a "B," without indicating what was good or bad. You can only figure out the patterns by writing hundreds of essays through trial and error. A far more efficient approach is for the teacher to directly mark: "This sentence is poorly written — don't write like this."

What Cosine is doing is precisely credit attribution within trajectories — identifying high-entropy "fork in the road" tokens that determine success or failure, and disproportionately assigning advantage values to these critical intervals. This thinking closely parallels recent academic research on Process Reward Models (PRM), which aim to provide reward signals for each step of a reasoning chain rather than just the final answer, fundamentally addressing the sparse reward problem. Cosine's approach is compatible with mainstream RL algorithms like GRPO and GSPO. The core goal is no longer just rewarding correct answers, but forcing the model to form reusable abstractions and continuously climb the "mountain of abstraction."

For the "slop" problem (low-quality code padding), Cosine's strategy is layered rewards: correctness is the threshold for everything, but above that there are additional rewards for code quality — they even use raw human patches from permissively licensed open-source repositories as references. If the agent's code is 500 lines longer than the human's, it shouldn't receive full marks.

Multi-Agent Orchestration, Code Review, and Understanding Debt

On agentic harnesses, Pullen offers a counterintuitive take: "Agent frameworks are becoming less and less important over time," because the models themselves are too capable — today, a model can accomplish almost any task using just bash, just more slowly and with more tokens. Value increasingly comes from the model itself rather than the framework. This stands in sharp contrast to the explosion of LangChain, AutoGen, and similar orchestration frameworks in 2023: as foundation models' function calling, code execution, and long-context capabilities continuously improve, the additional value from the framework layer is being compressed.

But he then introduced Cosine's Swarm feature — pushing sub-agent orchestration to the extreme. Swarm uses a two-layer design of "tree-structured orchestration + flat execution": a top-level orchestrator breaks down problems for "sub-planners," which then delegate to a flat layer of workers. In a demo building a "mechanical watch compiler," they deployed 253 sub-agents to complete the entire project in one pass — far beyond the session scale of typical AI coding tools. This scale demands extremely fine-grained dependency graph management and conflict arbitration mechanisms — 253 concurrent agents simultaneously modifying a codebase represents a major engineering challenge for interface consistency and merge conflict resolution.

Facing the resulting "understanding debt" and code review dilemma, Pullen offers a key insight: code review should shift from reading git diffs to runtime validation. Using Cosine's cybersecurity scanning product as an example, he described a "vulnerability verification" mechanism — an agent must actually reproduce the vulnerability it claims to have found inside a virtual machine, otherwise it's discarded as a false positive. This logic is being applied to PR reviews: rather than reading diffs, let the system prove that "the functionality it claims to implement actually runs," providing trustworthy evidence through screen recordings or screenshots, dramatically reducing cognitive burden on humans.

He also pointed to a deeper alignment problem: models often write their own feature descriptions and then "hack their own functional tests" — "Didn't pass? Fine, I'll modify the test, now it passes." This phenomenon is known in AI safety research as "specification gaming" and is one of the core trustworthiness challenges facing current code agents.

Memory Mechanisms, Synthetic Data, and the Final Battle for a Sovereign Model

On memory, Pullen is blunt: "All current memory solutions are some kind of hack" — whether vector databases or embedded knowledge snippets, agents struggle to judge when to query, whether it's worth writing, and how to stay current. The common limitation of mainstream approaches (semantic retrieval via vector databases, knowledge graph storage, summary compression, extended context windows) is that memory exists as an externally attached "tool" requiring explicit read/write operations — the model doesn't truly "internalize" this knowledge. What Cosine is exploring is allowing memory to exist in the model's latent space through continual learning, rather than as an external tool. Continual learning attempts to solve a decades-old unsolved problem in machine learning — enabling models to incrementally integrate new knowledge into their parameter space after deployment without suffering catastrophic forgetting. In recent years, parameter-efficient fine-tuning methods like LoRA have offered partial solutions, but significant gaps remain in real-time update frequency and knowledge reliability guarantees.

On synthetic data generation, Cosine spent a year and a half building a complex pipeline. Synthetic data has become the central battleground in post-training for top code models — OpenAI, Anthropic, and DeepSeek have all disclosed large-scale synthetic data pipeline usage in their technical reports. The core challenge: real-world code work mostly doesn't come with regression tests like SWE-bench does, and the vast majority of engineering tasks (feature development, refactoring) have no built-in scorer. Cosine's approach is to take real completed work and synthesize scoring criteria that are sufficiently implementation-agnostic yet rigorous enough to evaluate functional correctness — meaning the scorer only verifies functional behavior (inputs/outputs, interface contracts, performance boundaries) without caring about the specific implementation path, analogous to black-box testing in software engineering. This pipeline can even handle extreme scenarios like Verilog and Fortran: Verilog requires invoking EDA toolchains (such as Icarus Verilog, Synopsys DC) for synthesis and simulation, and evaluating a single sample may cost orders of magnitude more than ordinary code evaluation, placing extreme demands on pipeline engineering capability.

Looking ahead, Pullen acknowledges that US export controls are in some ways "a gift" — they've made sovereign AI unprecedentedly important, with demand and urgency "breaking through the ceiling." The hardware is already on UK soil, training is about to begin, and supply chain risk is relatively manageable.

But the emotions are complex. "For the first time, I feel like a second-class citizen," Pullen said. "Because Americans on the other side of the ocean have better AI than me, they're running faster than me, and I really hate that." This statement perhaps captures the genuine reality facing European and non-American AI efforts globally right now. And Cosine's answer is simple: "We have no choice but to make it work."

Key Takeaways