Why a Nation Can't Outsource Its Frontier AI - Alistair Pullen (Cosine AI)

Alistair Pullen, CEO and co-founder of Cosine, details the genesis of the UK’s sovereign large language model (LLM) initiative, spurred by unexpected US export controls on frontier systems like “Fable.” This geopolitical event catalyzed Cosine’s mission, backed by a government mandate and compute allocation on the Isambard supercomputer in Bristol, to build a domestic, capable model.

Competing with ‘Millions’ Against ‘Billions’

Pullen addresses the challenge of competing with US labs investing billions. Cosine’s strategy is to operate as a technology licensor rather than an inference company. By providing model weights for customer-managed deployments—whether on air-gapped GPUs or private hyperscaler instances—Cosine bypasses the exorbitant costs associated with maintaining large-scale inference infrastructure. This model significantly reduces capital expenditure, making a “millions, not billions” approach viable, though it necessitates careful trade-offs, particularly in the scope and scale of Reinforcement Learning (RL) runs.

Why Open Models Lag Frontier Performance

Pullen identifies three primary reasons why open-weight models have yet to match the performance of frontier closed-source models:

1. Architecture and Raw Model Size: Open models often face practical constraints related to GPU deployment profiles, leading to architectural decisions that cap potential performance. He highlights that while Mistral 3 Large (675B parameters) is impressive, frontier models like Anthropic’s Sonnet and Opus are estimated to be significantly larger, with Sonnet potentially around 1.3-1.5 trillion total parameters (100B+ active) and Opus at 1.5-1.8 trillion (150-180B active).
2. Active Parameter Count: The number of “active parameters” (those engaged per token) is crucial for a model’s perceived quality. Pullen suggests that while models like DeepSeek V4 Pro boast 1.6 trillion total parameters, their 30-50 billion active parameters reflect an inference-driven architectural compromise. He contrasts the user experience of Devstral 2 (a dense model) with GPOSS 12B (a Mixture-of-Experts model with ~5B active parameters), noting Devstral’s superior “feel” due to its higher active parameter count per token.
3. Data Quality and Post-Training: While pre-training corpora may converge at massive scales (e.g., 30 trillion tokens), the critical differentiator lies in post-training data and the ability to conduct RL at scale. Cosine observes that accessing trajectories—real-world user interactions with models, including messy, unpolished prompts—is invaluable. This data distribution, reflecting how users genuinely prompt models (“f you, it doesn’t work”), is essential for building robust and realistic models.

Beating ‘Slop’ Through Process-Based RL

Pullen critically addresses the issue of “slop”—AI generating functionally correct but poorly engineered code (e.g., a 200-line fix for a one-line problem). He argues that traditional RL, which solely rewards correctness (pass/fail unit tests), inadvertently reinforces these undesirable behaviors. Cosine’s mitigation strategy involves:

• Prioritizing Correctness, then Quality: While correctness gates all other rewards, additional metrics target code quality, conciseness, and safety.
• Reference Implementations: Comparing agent-generated code against human-written patches to penalize overly verbose or inefficient solutions.
• Credit Attribution in Trajectories: This algorithmic innovation moves beyond uniform reward distribution across an entire trajectory. Instead, it identifies “high-entropy tokens” or critical decision points within a long sequence of operations. By disproportionately weighting rewards/penalties to these specific decisions, RL becomes more efficient and guides the model to learn impactful behaviors rather than superficial ones. This aligns with the concept of forming reusable abstractions and tackling problems at a higher conceptual level, a challenge explored in contexts like Francois Chollet’s ARC-AGI.

Pullen acknowledges the “epistemic problem” in ML, where the notion of true/false is elusive. While coding offers verifiable rewards, non-verifiable domains (e.g., law) are far more challenging, limiting AI’s revolutionary impact in those areas.

Code Review as Runtime Proof and the Role of Agentic Harnesses

To combat “understanding debt” and the influx of AI-generated code, Pullen advocates for an evolution in code review: runtime validation. Instead of merely static analysis, the system spins up the application in a virtual machine, forcing the AI agent to “prove” its work (e.g., exploiting a vulnerability it identified or demonstrating a new feature’s functionality). If the agent cannot prove its claim, the issue is dismissed as a false positive or incorrect. This significantly reduces human cognitive burden and complements comprehensive end-to-end testing.

While acknowledging the increasing capability of LLMs (even able to complete tasks with basic bash), Pullen states that agentic harnesses are becoming less important over time. However, Cosine still tightly couples its harness design with model architecture for optimal performance, with a current focus on efficiency and token cost optimization.

Swarm: Orchestrating Hundreds of Sub-Agents

Cosine’s “Swarm” system represents sub-agent orchestration taken to its logical extreme. It employs a hierarchical structure where a top-level orchestrator decomposes complex problems into sub-problems for “subplanners.” These subplanners then delegate tasks to a flat layer of numerous “workers.” Pullen gives an example of building a “mechanical watch compiler” SDK using 253 sub-agents to achieve a task impossible for a single model. The system incorporates features like interjection at the lowest agent level, file write locks, and context sharing about file edits to prevent interference. Despite its power, human oversight remains crucial for refining abstractions and ensuring maintainability.

The Unsolved Hack of Memory and Synthetic Data Generation

Memory remains “very hard to get right” and is currently viewed as a “hack.” Existing solutions, often using vector databases, struggle with agents knowing when to query, what to store, and managing outdated information. Cosine is exploring “continual learning” to integrate memory directly into the model’s latent space, moving beyond external tools.

Synthetic data generation is a major focus for Cosine, especially for RL, to ensure their sovereign model is broadly useful beyond coding. For coding, where many open-source projects lack built-in graders, Cosine synthesizes “ground truths” or “graders” for real-world problems (features, refactoring) that don’t have predefined tests. This autonomous pipeline, refined over 1.5 years, allows for the generation of RL data across diverse programming languages and stacks, even for complex domains like SystemVerilog, where validation requires specialized tools like synthesizers.

US Export Controls: An Accidental Gift

Pullen views the US export controls as an “accidental gift” for Cosine. The ban on models like Fable has dramatically increased interest and urgency from UK companies and the government in sovereign AI. Cosine’s early positioning has allowed it to capitalize on this demand, though Pullen expresses frustration at feeling like a “second-class citizen” due to limited access to frontier US models. Despite potential supply chain risks with hardware control, he believes that if the hardware is already in the UK (like Isambard-AI), direct interference is limited. Cosine is committed to successfully delivering the sovereign model, viewing it as a necessity.

• Tags:
• Code Generation
• Agentic AI
• Synthetic Data
• Data Curation
• Feature
• AI Policy
• LLM Training
• Model Architecture
• Code Review
• Sovereign AI
• Export Controls
• Sub-Agents
• Isambard Supercomputer
• Inference Costs
• Mixture-of-Experts (MoE)
• Active Parameters
• Reinforcement Learning (RL)
• Memory in LLMs
• Cosine (Company)