Cosine AI and the Case for Sovereign Frontier AI

The Sovereign AI Mandate

US export controls on frontier AI models, specifically the banning of the system known as Fable, have created a strategic necessity for the UK to develop its own sovereign Large Language Model (LLM). Alistair Pullen, CEO and co-founder of Cosine, explains that relying on outsourced AI creates a vulnerability where a nation's most capable tools can be revoked by foreign policy.

To address this, Cosine has been backed by the UK government's sovereign AI unit, receiving a critical allocation of compute on the Isambard supercomputer cluster in Bristol. This government-backed compute removes the primary financial barrier for startups—the massive cost of training hardware—enabling Cosine to pursue a frontier-scale model without the multi-billion dollar budgets seen in US labs.

Scaling with Millions, Not Billions

Building a frontier model on a smaller budget is possible by shifting the business model from an "inference company" to a "technology licensor."\n

Avoiding Inference Overhead

Most US frontier labs spend billions on data centers to host their own APIs and manage token margins. Cosine avoids this by deploying models directly into highly secure, air-gapped, or high-sided environments (such as financial services and defense). Customers either run the model weights on their own GPUs or rent their own hyperscaler cloud instances. By licensing the technology rather than selling tokens, Cosine eliminates the massive operational expenditure associated with hosting inference at scale.

The Consortium Feedback Loop

Cosine leverages a consortium of large UK companies that feed real-world use cases and requirements directly into the training process. This creates a targeted feedback loop that allows the model to be optimized for specific national and industrial needs, rather than attempting to be a general-purpose tool for the entire global internet.

Architectural Requirements for Frontier Performance

To reach the performance ceiling of closed-source models like Claude (Sonnet/Opus), Pullen identifies three critical architectural factors:

1. Total Parameter Count: Raw size remains a baseline for capability.
2. Active Parameter Count: In Mixture-of-Experts (MoE) models, the number of active parameters during a forward pass determines the "feel" and reasoning depth of the model. Pullen notes that dense models (like Devstral 2) often feel superior to MoE models with low active parameter counts (like gpt-oss-120b) despite similar total sizes.
3. Data Quality and Trajectories: While pre-training corpora converge once models reach the 30-trillion token range, the "alpha" is found in post-training data and RL (Reinforcement Learning) at scale.

Solving "Slop" and Improving Agentic Reliability

"Slop" in AI coding refers to functionally correct code that is architecturally poor—such as "spaghetti code" that passes a unit test but increases technical debt.

Rewarding Process Over Outcome

Traditional RL rewards a model if a unit test passes (a binary 1 or 0). This reinforces inefficient or unsafe paths as long as the end result is correct. Cosine is implementing "credit attribution" within trajectories to identify the specific tokens or decision points that led to a successful outcome. By rewarding the process (the elegant path) rather than just the result (the passing test), the model learns to form reusable abstractions rather than superficial statistical correlations.

Runtime Proof as Code Review

To combat the cognitive burden of AI-generated code reviews, Cosine advocates for "exploit validation" or runtime proof. Instead of a human reading a git diff, the system spins up the application in a virtual machine and forces the agent to prove the feature works (or the bug is fixed) in a live environment. This transforms code review from a manual reading task into a verification of functional proof.

Advanced Agentic Orchestration: The Swarm

While simple agentic harnesses are becoming less important as models get better at using bash, complex problem decomposition still requires orchestration. Cosine's "Swarm" system takes sub-agent orchestration to the extreme:

• Hierarchical Structure: A top-level orchestrator breaks a problem into sub-problems for "sub-planners," who then manage a flat layer of "workers."
• Massive Parallelism: In one example, Cosine used 253 sub-agents in a single shot to build a mechanical watch SDK, including a physics engine and 3D viewer—a task too complex for any single-pass LLM.
• Conflict Management: To prevent agents from overwriting each other, the system employs write-locks on files and provides context updates when a file is edited by another agent in the swarm.

The Challenge of Memory and Synthetic Data

The Memory Hack

Pullen argues that current AI memory (VectorDBs, RAG) is a "hack" because agents struggle to know when to query memory or when to write to it. The goal is to move memory into the latent space of the model via continual learning, though this remains a significant technical challenge due to reward hacking and data leakage during RL.

Synthetic Graders for RL

To perform RL on tasks that aren't simple bug fixes (which lack built-in tests), Cosine uses a pipeline to synthesize "ground truths" or graders. By taking real-world feature work and synthesizing implementation-agnostic ways to verify functional correctness, they can generate RL data for languages and stacks that lack comprehensive test suites, such as SystemVerilog.