# Scaling the Next Paradigm of Heterogeneous Intelligence

Adrian Bertagnoli

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/WRBNDpUhsJQ-scaling-next-paradigm-heterogeneous-intelligence) · [Video](https://www.youtube.com/watch?v=WRBNDpUhsJQ)

## Scaling the Next Paradigm of Heterogeneous Intelligence

Different steps in an AI workflow need different capabilities. Heterogeneous orchestration matches those steps to models and hardware, changing the cost and latency of the whole system.

Familiarity with LLM context windows, inference, and basic Python will help with the recursive-context example.

### From one model on identical chips to coordinated specialists

[0:16](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=16s)

Why solve every part of a complex problem by scaling one model on a fleet of identical chips? That is the opening question behind Adrian Bertagnoli’s account of heterogeneous intelligence. Introducing himself as a founding engineer at Callosum, he starts with the prevailing alternative: **homogeneous scaling**, where more training data and more parameters produce a more capable model. Neural scaling laws made that approach productive; his question is what changes when the engineering emphasis moves from training models to running inference.

The shift is already visible at three layers:

| Layer | Homogeneous starting point | Emerging heterogeneity |
|---|---|---|
| Architecture | Large dense model | Mixture of experts |
| Workflow | Single LLM call | Multiple interacting agents |
| Hardware | One chip role | Separate prefill and decode roles |

These changes introduce specialization inside the model, between calls, and underneath inference. They do not yet require an entirely heterogeneous cluster.

![Slide showing three identical network symbols and text listing mixture of experts, prefill/decode disaggregation, and multi-agent systems with different models.](https://ai.engineer/api/talk-essay-media/a75431e85d74f0c3fb054be1c8458d716c44d330819d79f7750de31e49f7f043)

The current paradigm: homogeneous intelligence, with early shifts toward heterogeneity.

At this mild stage, agents can use different prompts or different LLMs while still running on largely homogeneous infrastructure. Greater heterogeneity assigns different models to different GPUs, then combines architectures such as state-space models and diffusion models on hardware suited to their computation. The proposed endpoint goes further than choosing from existing chips: models, software systems, and hardware co-evolve into a vertically integrated system.

### Match collective capabilities to the problem’s demand

[3:24](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=204s)

Real-world problems are multistep and open-ended. Their subproblems require different capabilities, so increasing one kind of intelligence can be an inefficient way to solve the whole task. Bertagnoli calls the alternative **multi-agent heterogeneous intelligence**: models of different sizes and architectures cooperating over long horizons. There is an infrastructure problem alongside the modeling problem. New silicon needs an interface through which it can contribute to the existing compute stack; simply making another accelerator available does not establish how agents should use it.

The [principle of maximum heterogeneity](https://www.callosum.com/blog/the-principle-of-maximum-heterogeneity) formalizes this intuition through a distributed production model. In the diagram Bertagnoli describes, each agent has a distribution over a skill space, represented by its color. A ring connects the agents, representing communication. Together, their skills and interactions produce a collective **production function**: a profile of what the system can supply. That profile can fit one problem’s demand, labeled demand A, while serving demand B poorly.

Homogeneous scaling has two limitations in this picture. Replicating a specialist raises one peak without filling other gaps in capability. Replicating broad generalists spreads capacity across the skill space, producing the short cylinder in the illustration rather than enough capacity where demand is highest. Bertagnoli presents mathematical support and parallels across neuroscience, economics, and ecology. The corresponding [distributed-production paper](https://arxiv.org/abs/2604.07602) bounds the result by modeled skill distributions, communication, resource constraints, and environmental demand. The useful design principle is therefore to match diversity to the workload and its communication topology—not to maximize the number of different components indiscriminately.

### Three places to optimize

[5:56](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=356s)

This becomes an orchestration problem across three connected decisions:

- **Hardware:** Select where an agent runs according to its computational demands.
- **Agents:** Select the models and capabilities that perform the work.
- **Workflows:** Determine how agents interact and how their work is composed.

Bertagnoli develops two examples: heterogeneous recursion at the workflow layer, followed by a mixture of multimodal models for visual web navigation at the agent layer. In both, the opportunity comes from decomposing a task before deciding which resources should execute it.

### Treat long context as an environment

[6:52](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=412s)

A large context window does not guarantee that a model can reason reliably over everything in it. **Recursive language models** address that distinction. Bertagnoli refers to an MIT introduction from the previous October: the [October 2025 author write-up](https://alexzhang13.github.io/blog/2025/rlm/) preceded the [paper submitted in December 2025](https://arxiv.org/abs/2512.24601). The motivating issue is context rot: performance can deteriorate even when the input occupies only part of the available window, depending on how much information the answer requires.

The distinction is easiest to see through two tasks:

| Task | Information needed as input grows |
|---|---|
| Find one needle in a haystack | O(1): retrieve a fixed amount |
| Add values across supplied rows | O(N): inspect a growing number of rows |

A longer haystack does not necessarily require a longer answer or more facts to construct it. Aggregation does require more of the input to participate in the result. Bertagnoli says constant-demand retrieval can remain effective across the full context window, while linear or quadratic demands can degrade at roughly 30–60% occupancy. He does not assign separate thresholds to the two complexity classes or specify a universal cutoff.

The recursive approach changes how the agent accesses the input:

1. Keep the long context outside the model’s immediate prompt, in an environment the agent can inspect.
2. Let a coding agent use a Python REPL to search it with keywords, regular expressions, or other programmatic operations.
3. Extract relevant subcontexts and pass them to recursive calls.
4. Let each call answer its question or delegate again.

Bertagnoli describes a file-backed context and identical recursive agents. The original RLM design also supports context held in an environment variable and calls to other models; neither files nor identical child models are requirements. The central mechanism is **programmatic access to context**, followed by bounded reasoning over selected portions.

For example, a support log can stay in a file while Python extracts complete records mentioning refunds. The resulting strings are the subcontexts a recursive call would receive:

```python
from pathlib import Path
import re

context = Path("support-log.txt").read_text(encoding="utf-8")
records = re.split(r"\n\s*\n", context.strip())
refund_records = [
    record
    for record in records
    if re.search(r"\brefund(?:s|ed)?\b", record, re.IGNORECASE)
]

batch_size = 20
subcontexts = [
    "\n\n".join(refund_records[start:start + batch_size])
    for start in range(0, len(refund_records), batch_size)
]

for index, subcontext in enumerate(subcontexts):
    print(f"--- Subcontext {index} ---")
    print(subcontext)
```

This illustrates the extraction step, leaving the recursive calls pending. The filter must match the question: a keyword search can select explicit refund mentions, but it would miss relevant records expressed with different vocabulary.

### Route recursive work across models and chips

[8:44](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=524s)

Once a workflow exposes smaller subcontexts, orchestration can choose how to process each one. Callosum’s extension maps generated subcontexts to different models and different chips, aiming to preserve the quality of frontier-model reasoning while reducing cost and latency. The distinguishing step is the joint selection of **model and hardware**, rather than recursion alone.

Bertagnoli presents results on [OOLONG](https://arxiv.org/abs/2511.02817), the long-context reasoning and aggregation benchmark also used in the RLM work. He names **GPT-5** and then **GPT-5.2** as the contemporary baseline. For that baseline, Bertagnoli reports about 2,000 seconds to run through the benchmark and about $3.75 for one task. Those spoken units differ, so they should not be combined into a derived per-task throughput estimate.

The reported hardware choices produce different cost–latency tradeoffs:

| Configuration | Reported cost reduction | Reported speedup |
|---|---|---|
| Cerebras | 7× cheaper | 5× faster |
| SambaNova | 12× cheaper | 3× faster |

Both rows compare with the baseline described in the talk. SambaNova reduces the price further than Cerebras while giving up some latency advantage. These are Callosum-reported OOLONG results; the exact evaluation split, timing aggregation, and accuracy comparison are not specified in the presentation. The architectural point is that model-and-chip assignment creates choices along both cost and time axes.

![Scatter plot of cost per task against wall clock time beside highlighted claims: Cerebras seven times cheaper and five times faster; SambaNova twelve times cheaper and three times faster.](https://ai.engineer/api/talk-essay-media/b79087be6bc4cf42af3f5103896cbc4b3c7b959c01e497cb135605c965a43e27)

Long-context results comparing cost and time, with highlighted Cerebras and SambaNova gains.

### Separate visual reasoning from textual reasoning

[10:20](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=620s)

Visual web navigation introduces another kind of heterogeneity. A browser agent must interpret images, reason about text, and decide what action to take. Callosum combines open and closed video action language models for this work. Bertagnoli reports improvements of 18% over GPT-5.2 and 25% over **Gemini 2.5** on the benchmark he calls Video Web Arena. The [company’s companion account](https://www.callosum.com/blog/welcome-heterogeneous-intelligence) identifies the evaluation as VisualWebArena shopping and expresses the gains as relative pass-rate improvements over named agent systems, rather than bare models. That distinction matters when interpreting the claimed state of the art.

The decomposition is the mechanism: visual reasoning and textual reasoning become separate components that can use different models. Bertagnoli describes the resulting cost–latency comparison as a shift in the **Pareto frontier**: heterogeneous mixtures outperform the individual-model configurations plotted alongside them, including **Kimi K2.5** and GPT-5.2.

The model pairings must be kept separate. **Qwen3-VL-8B-Instruct** supplies the smaller vision-language model in the configurations described here; the companion account resolves the talk’s abbreviated Qwen3-plus-GPT pairing as Qwen3-VL-8B-Instruct plus GPT-5.2.

| Pairing | Reported speed comparison | Reported cost comparison |
|---|---|---|
| Qwen3-VL-8B-Instruct + Kimi K2.5 | 1.3× faster than Kimi K2.5 alone | 18× cheaper than GPT-5.2 alone |
| Qwen3-VL-8B-Instruct + GPT-5.2 | 3× faster than GPT-5.2 alone | 3.7× cheaper than GPT-5.2 alone |

The first row uses different baselines for speed and cost. Reading it as a single comparison against Kimi would change the claim.

One source of the savings is an operation as simple as zooming. A larger model may need a closer view before making a decision, but preparing that view does not require the same capability as interpreting it. Callosum maps zooming and other visual-view preparation to less capable models. Bertagnoli describes this construction as having no downside in the demonstrated comparison. For those visual subtasks alone, he reports 11× faster execution and 43× lower cost than using ChatGPT. These local savings contribute to the overall threefold speedup and 3.7-fold cost reduction of the GPT pairing; the much larger subtask ratios do not describe the whole workflow.

### Build infrastructure around heterogeneous workloads

[12:38](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=758s)

Bertagnoli places these examples in a three-era history of compute. The CPU era made computation faster. The GPU era made it massively parallel, with NVIDIA dominating that transition. His proposed third era maps multi-agent workloads onto different chips according to what each step needs. Scaling then depends not just on the capacity of a device, but on how effectively the system assigns work across devices.

He connects that direction to Callosum’s work with [ARIA](https://aria.org.uk/opportunity-spaces/nature-inspired-computation/scaling-compute/scaling-inference-lab), reporting a rounded 3 million grant toward what he calls the UK’s first heterogeneous co-located cluster. Callosum’s [funding announcement](https://www.callosum.com/blog/we-are-scaling-heterogeneous-compute) describes funding for cluster research and development with CommonAI, rather than establishing that a commissioned cluster was already operating. The infrastructure ambition is to bring different hardware into one coordinated system.

Homogeneous scaling still receives credit for the progress that made these systems possible. The closing proposal is to let models, workflows, and silicon co-evolve, so that new forms of specialization can improve the system’s intelligence, speed, and cost together. Bertagnoli ends the prepared talk with an infrastructure builder’s expression of optimism: “This is the worst our infrastructure will ever be.”

### How does the system choose a model?

[14:01](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=841s)

The audience’s final technical question returns to the zoom example: is the assignment hard-coded, or does another model decide which model should do the work? Bertagnoli says the first implementation used bespoke mappings from simple subtasks to simple models. Callosum subsequently added an automation layer that detects task complexity and predicts the best-suited model and hardware. He does not describe the predictor’s implementation or validation. This leaves the routing decision itself as a central part of the system: decomposition exposes the choices, and the orchestrator must turn them into assignments that preserve quality while reducing execution cost.

## Resources

- [Welcome, Heterogeneous Intelligence](https://www.callosum.com/blog/welcome-heterogeneous-intelligence) — Callosum’s technical account of heterogeneous recursion and visual web navigation, with model configurations and cost–latency comparisons.
- [The Principle of Maximum Heterogeneity](https://arxiv.org/abs/2604.07602) — A distributed production model connecting agent specialization, communication, resource constraints and workload demand.
- [Recursive Language Models: Original Write-up](https://alexzhang13.github.io/blog/2025/rlm/) — The authors’ October 2025 introduction to inspecting context programmatically and delegating subqueries through a REPL.
- [Recursive Language Models](https://arxiv.org/abs/2512.24601) — The research paper describing recursive inference over context held outside the model’s immediate prompt.
- [Oolong: Long-Context Reasoning and Aggregation](https://arxiv.org/abs/2511.02817) — A benchmark testing whether models can analyze many text fragments and aggregate their findings.
- [We Are Scaling Heterogeneous Compute](https://www.callosum.com/blog/we-are-scaling-heterogeneous-compute) — Callosum’s announcement of hardware partnerships and ARIA-funded research on co-located heterogeneous computing.
- [ARIA Scaling Inference Lab](https://aria.org.uk/opportunity-spaces/nature-inspired-computation/scaling-compute/scaling-inference-lab) — ARIA’s description of the lab, participating organizations and heterogeneous inference research goals.

## Slides

### AI Engineer Europe

The AI Engineer Europe logo opens the recording.

[0:00](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=0s) [AI Engineer Europe logo on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/24e440bf5dfd4ecccd4fffdc9ef9243be07fff10b16e87c6b80fbc594828e3ea.webp)

AI Engineer
EUROPE

### Presenting Sponsor

[0:05](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=5s) [Google DeepMind presenting sponsor card.](https://assets.ai.engineer/sites/aiecode2025/sha256/e0a2733394b9e76d5cbcc292edcb1e7d0d4305725368334cfa74aa4dc6f38f30.webp)

PRESENTING SPONSOR

Google DeepMind

### Platinum Sponsors

[0:10](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=10s) [Platinum sponsors Braintrust, WorkOS and OpenAI.](https://assets.ai.engineer/sites/aiecode2025/sha256/89dc1308e52949084b65e89cafb6c581e795e5db5cb5cd74c4cd0e87c4fc8258.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### Scaling the Next Paradigm of Heterogeneous Intelligence

Adrian Bertagnoli introduces why heterogeneity matters for scaling AI, how it is used today, and how it might shape future intelligence systems.

[0:25](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=25s) [Agenda listing why heterogeneity, heterogeneity in practice, and looking ahead.](https://assets.ai.engineer/sites/aiecode2025/sha256/c4117e2038ac610c617a9b027d71b826265f26386a083416a3e1f63c2d8cc771.webp)

Scaling the Next Paradigm of Heterogeneous Intelligence

Why Heterogeneity
Heterogeneity in Practice
Looking Ahead

© 2026 Callosum Technologies Ltd

AIE
AI Engineer EUROPE 2026
Google DeepMind

Interface text:
Finder File Edit View Go Window Help
Fri 10 Apr 12:44

### Current Paradigm: Homogeneous Intelligence

Three identical diagrams represent single models scaled across identical chips. Mixture of experts, multi-agent systems and prefill/decode disaggregation signal a shift toward heterogeneity.

[1:09](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=69s) [Slide describes scaling single models on single chips and lists mixture of experts, prefill/decode disaggregation, and multi-agent systems.](https://assets.ai.engineer/sites/aiecode2025/sha256/628699188b6272f39d7dcf63e5063e6854c6baa476210c914b32e221e56c0d96.webp)

Current Paradigm:
Homogeneous Intelligence

Current Paradigm is largely defined by scaling single models on single chips

This era was largely brought about by the discovery of neural scaling laws

We already see a shift from this paradigm:
• Mixture of Experts
• Prefill/Decode disaggregation
• Multi-agent systems with different models

© 2026 Callosum Technologies Ltd
4

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:44
AIE
AI Engineer EUROPE
2026

### The Shift to Heterogeneous Intelligence

The slide maps a progression from models on homogeneous hardware to mixed models on mixed hardware, then integrated intelligence with co-evolved software and hardware.

[2:01](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=121s) [Diagram compares mild, increased, and high heterogeneity across models and hardware.](https://assets.ai.engineer/sites/aiecode2025/sha256/2a0ff4fa1d9a6e3f529f4081b4b7bf64a7f7c1ac2265787f18a76d3caee49b1e.webp)

The shift to Heterogeneous Intelligence
From homogeneous clusters to heterogeneous systems

Heterogeneity

Mild Heterogeneity
Mixture of Experts (Intra-model)
Mixed LLMs (inter-model)
• Homogenous hardware clusters
• Different model architectures

Increased Heterogeneity
Mixed models on mixed hardware
Diffusion + SSMs + LLMs

High Heterogeneity
Integrated Intelligence
• Co-evolved software & hardware
• Vertical integrated systems for complex problems

© 2026 Callosum Technologies Ltd
5

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:45
AIE
AI Engineer EUROPE
2026

### Why Heterogeneity?

Complex problems split into sub-problems that call for different models. The charts illustrate different hardware strengths across those sub-problems; the slide says infrastructure to unify them is missing.

[3:23](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=203s) [Slide describes complex problems, interacting models, and specialized hardware, with an agent diagram and performance charts.](https://assets.ai.engineer/sites/aiecode2025/sha256/d9d99bda6361d9943ab810b66f6685fc87c83c66901f32c68cc1318989d91e48.webp)

Why heterogeneity?

Real-world problems are complex, multi-step, and open-ended.

Solving them requires models of different sizes and architectures, reasoning and acting together across long horizons - heterogeneous multi-agent intelligence.

New generations of silicon have emerged to unlock new performance for specialised tasks.

Yet no infrastructure exists to unify them.

Problem
(e.g., autonomous payments, computer use, coding)

Next-gen GPUs
Y-axis: Performance
X-axis: Sub-problem

In-memory compute
Y-axis: Performance
X-axis: Sub-problem

Custom ASICs
Y-axis: Performance
X-axis: Sub-problem

...
Other chip types include Thermodynamic chips, HPC Neuromorphic, Quantum, ...)

© 2026 Callosum Technologies Ltd
6

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:47
AIE
AI Engineer EUROPE

### Intelligence is a systems-level problem

Callosum describes orchestration across hardware, agents and workflows: hardware is chosen for agents’ computational demands, while orchestration also shapes how agents interact and construct workflows.

[5:55](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=355s) [Slide outlining orchestration across workflows, agents and hardware.](https://assets.ai.engineer/sites/aiecode2025/sha256/0dd6626b0a8b1a1772a821ba77fabc9bdc68f498a8147c7382d2bb20fc21c4e7.webp)

Intelligence is a systems-level problem

We optimise multi-agent inferencing through end-to-end orchestration across three layers of the stack.

We have demonstrated this across multiple problem categories critical to multi-agentic AI:

Full vertical integration & learning system
Performance
Sub-problem

Agentic workflow discovery

Heterogeneous hardware orchestration
Next-gen GPUs
In-memory compute
Custom ASICs

Multi-cloud + multi chip integration
AMD
NVIDIA
Cerebras
Google Cloud
Azure
AWS

Workflows
• Automated workload decomposition
• Heterogeneous recursion

Agents
• Multi-modal video-action-language models
• Combined frontier and open model orchestration
• KV cache management
• Latent communication

Hardware
• Heterogeneous hardware orchestration (current & new chips)
• Multi-cloud & multi-chip integration

© 2026 Callosum Technologies Ltd
8

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:49
AIE
AI Engineer EUROPE
2026

### Deep context: Heterogeneous Recursion (e.g., in codebases)

A root model routes subtasks and context to models on different chips. Those models can recurse further and return responses, aiming to save cost and speed.

[6:51](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=411s) [Slide showing recursive subtasks routed to different models and chips.](https://assets.ai.engineer/sites/aiecode2025/sha256/c6629e5d8cdeda604cb10d114b6a3cee7dbfa66bb1d696fc28b84f8838a5576b.webp)

Deep context:
Heterogeneous Recursion
(e.g., in codebases)

• Expanding naive RLMs to mixed model, mixed chip systems
• Depending on the context, we orchestrate models and chips to operate on different context chunks at different depths to save cost and speed.

Root/Seed
User
Query
Context
Model A
Environment
Chip A
Final Response

Heterogeneous Recursion [depth 1 → n]
Sub-Task Set 1
Sub-Query
Sub-Context
Model B
Sub-Response
Chip B
Sub-Task Set 2
Sub-Query
Sub-Context
Model C
Sub-Response
Environment
Chip C
Sub-Task Set 2.1
Sub-Task Set 2.2
...

© 2026 Callosum Technologies Ltd
9

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:50
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

[7:53](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=473s) [Diagram showing a root model distributing context and subtasks to different models and chips.](https://assets.ai.engineer/sites/aiecode2025/sha256/87a494b2373e25949eece4d300b1568e0e0d2d2ae2d301193ae33d639f8ff68b.webp)

Deep context:
Heterogeneous Recursion
(e.g., in codebases)

• Expanding naive RLMs to mixed model, mixed chip systems
• Depending on the context, we orchestrate models and chips to operate on different context chunks at different depths to save cost and speed.

Root/Seed
User
Query
Context
Model A
Environment
Chip A
Final Response

Heterogeneous Recursion [depth 1 → n]
Sub-Task Set 1
Sub-Query
Sub-Context
Model B
Sub-Response
Chip B
Sub-Task Set 2
Sub-Query
Sub-Context
Model C
Sub-Response
Environment
Chip C
Sub-Task Set 2.1
Sub-Task Set 2.2
...

© 2026 Callosum Technologies Ltd
9

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:51
AIE
AI Engineer EUROPE 2026
Braintrust  WorkOS  OpenAI

### Long-context benchmark

On the OOLONG benchmark, the system matches GPT-5-level accuracy. Cerebras is reported as 7x cheaper and 5x faster; SambaNova cuts cost further but takes longer.

[9:20](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=560s) [A cost-versus-time chart and reported speed and cost comparisons for long-context tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/08280d348a6a45093dd2392cac4cb8b8d839f5aefcd2a79fea1f714b572da285.webp)

Deep context:
12x cheaper and 5x faster on long contexts

While matching GPT-5 level accuracy:
• Cerebras [Qwen-2-235B]
x7 cheaper, 5x faster
• Sambanova [GPT-OSS-120B]
x12 cheaper, 3x faster

Chart:
Cost per Task (USD) — lower is better
Y-axis ticks: 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0
Wall Clock Time (seconds) — lower is better
X-axis ticks: 0, 500, 1000, 1500, 2000, 2500, 3000
Performance: Lower, Medium, Higher
Cerebras [Llama-70B]
Cerebras [Qwen-3-235B]
Cerebras [GPT-OSS-120B]
Cerebras [Llama-8B]
SambaNova [GPT-OSS-120B]
SambaNova [Llama-70B]
SambaNova [Llama-8B]
OpenAI [GPT-5]
OpenAI [GPT-5-Nano]
OpenAI [GPT-5-Mini]
* All models seeded with GPT-5

© 2026 Callosum Technologies Ltd
10

Interface text:
Finder File Edit View Go Window Help
Fri 10 Apr 12:53
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Open-web shopping demonstration

A mixed-model web agent compares a robot toy across Amazon and OnBuy; the demo reports an order after finding Amazon cheaper. The slide claims gains of 18% and 25% over GPT-5.2 and Gemini 2.5 on VideoWebArena.

[10:32](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=632s) [The agent reaches another shopping site and displays an initial product result while a consent dialog is open.](https://assets.ai.engineer/sites/aiecode2025/sha256/aea9ca87a52388709b0803dbb7d28448490d9da2df79aef3f0b5b933d0c381fd.webp)

Open web:
Mixed specialised open/closed models

System has active perception for modality selection, treating the web as a heterogeneous environment

• End-to-end video-action-language utilising open models, for any web environment
• Broke VideoWebArena SOTA, beating GPT-5.2 & Gemini 2.5, by 18% & 25% respectively

Found Tundra Prime on Amazon — £24.99

© 2026 Callosum Technologies Ltd
11

Interface text:
https://www.onbuy.com/gb/
We value your privacy
DECLINE ALL  CUSTOMISE  ACCEPT ALL

Callosum
[Step 9] click_coordinate [0.297, 0.253]
[illegible]
[Step 10] new_tab
[illegible]
[Step 11] goto [https://www.onbuy.com/gb/]
[illegible]
[Step 12] click_coordinate [0.750, 0.556]
[illegible]
[Step 13] click_coordinate [0.750, 0.556]
[illegible]
[Step 14] click_coordinate [0.750, 0.556]
[illegible]
[Step 15] click_coordinate [0.716, 0.398]
[illegible]
[Step 16] click_coordinate [0.750, 0.526]
[illegible]

AI Engineer EUROPE

[10:54](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=654s) [A shopping task and its reported result appear beside a description of the mixed-model web agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/34733c6deb889dc28938d9a4d9255b39177acf31f86a6a1e613546f1ab6e23c9.webp)

Open web:
Mixed specialised open/closed models

System has active perception for modality selection, treating the web as a heterogeneous environment

• End-to-end video-action-language utilising open models, for any web environment
• Broke VideoWebArena SOTA, beating GPT-5.2 & Gemini 2.5, by 18% & 25% respectively

“Find a robot in Amazon UK that looks similar to the one on the right of image 1, playing the ball as in image 2, from the same team of the player in image 2. Compare the price of the same product on OnBuy. If Amazon is indeed cheaper, purchase it with gift option and ship to our offices.”

✓ Found Tundra Prime on Amazon — £24.99
✓ Price check: OnBuy wants £28.47 — Amazon wins
✓ Gift wrapped for the office
✓ Order placed — Tundra Prime is on its way

Purchased Product
Image 1
Image 2

www.callosum.com
© 2026 Callosum Technologies Ltd
11

Interface text:
AI Engineer EUROPE

### Open web shopping demonstration: task

The shopping task combines image matching and price comparison before a conditional purchase. The system selects models for visual and textual reasoning steps.

[10:58](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=658s) [A shopping task asks an agent to identify a robot using two reference images and compare prices.](https://assets.ai.engineer/sites/aiecode2025/sha256/fac83a604bada3af123e55908422a32045282ebc742be67ec14eb5758499b77f.webp)

Open web:
Mixed specialised open/closed models

System has active perception for modality selection, treating the web as a heterogeneous environment

• End-to-end video-action-language utilising open models, for any web environment
• Broke VideoWebArena SOTA, beating GPT-5.2 & Gemini 2.5, by 18% & 25% respectively

“Find a robot in Amazon UK that looks similar to the one on the right of image 1, playing the ball as in image 2, from the same team of the player in image 2. Compare the price of the same product on OnBuy. If Amazon is indeed cheaper, purchase it with gift option and ship to our offices.”

Image 1
Image 2

© 2026 Callosum Technologies Ltd
11

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:54
AIE
AI Engineer EUROPE
2026

### Mixed-model latency and cost

For open-web tasks, Qwen paired with GPT-5.2 is shown as 3x faster and 3.7x cheaper than GPT-5.2 alone. Qwen paired with Kimi-K2.5 is shown as 1.3x faster than Kimi alone.

[11:10](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=670s) [A chart compares task latency and cost for individual models and heterogeneous model combinations.](https://assets.ai.engineer/sites/aiecode2025/sha256/fe434bd02e024a6b406fb96afcdff13f2ce32171e5299e94f7688f51aa26a532.webp)

Open web:
Mixed specialised open/closed models

• 3x faster and 3.7x cheaper than GPT-5.2 alone
• 18x cheaper and 1.3x faster than Kimi-K2.5
• Optimal with orchestrated Qwen & GPT-2

Active perception enables the system to match action sub-types to the appropriate model.

Chart legend: Individual large models; Heterogeneous models (Callosum)
Y-axis: Average Cost per Task (USD)
Y-axis ticks: 0.0, 0.2, 0.4, 0.6, 0.8, 1.0
X-axis: Average Latency per Task (s)
X-axis ticks: 0, 200, 400, 600, 800, 1000
Lower is better
GPT-5.2
Qwen3-VL-8B-Instruct + GPT-5.2
Kimi-K2.5
Qwen3-VL-8B-Instruct + Kimi-K2.5
3.0x faster
3.7x cheaper
18x cheaper
1.3x faster

© 2026 Callosum Technologies Ltd
12

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:54
AIE
AI Engineer
EUROPE
2026

### Open web: Sub-tasks (e.g., Zoom), 11x faster and 43x cheaper

Callosum offloads zoom subtasks to Qwen3-VL-8B-Instruct. The slide reports 11x lower latency and 43x lower cost per zoom action subtask than GPT-5.2.

[11:58](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=718s) [Bar charts report that Qwen3-VL-8B-Instruct performs the zoom subtask 11 times faster and 43 times cheaper than GPT-5.2.](https://assets.ai.engineer/sites/aiecode2025/sha256/984107700f96f41902549e7d4ddd80fac99751ef472bb74118444aba11e032e9.webp)

Open web:
Sub-tasks (e.g., Zoom),
11x faster and 43x cheaper

LATENCY
Average Latency per Zoom Action Sub-Task (s)
Y-axis ticks: 0, 2, 4, 6, 8, 10, 12
GPT-5.2
Qwen3-VL-8B-Instruct
11x faster

COST
Average Cost per Zoom Action Sub-Task (USD)
Y-axis ticks: 0.000, 0.001, 0.002, 0.003, 0.004, 0.005, 0.006
GPT-5.2
Qwen3-VL-8B-Instruct
43x cheaper

© 2026 Callosum Technologies Ltd
13

Event text: AIE; AI Engineer EUROPE 2026; Engineering the future of AI

Interface text: Finder, File, Edit, View, Go, Window, Help; Fri 10 Apr 12:55

[12:21](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=741s) [Latency and cost charts compare GPT-5.2 with Qwen3-VL-8B-Instruct for zoom sub-tasks, reporting 11 times faster and 43 times cheaper.](https://assets.ai.engineer/sites/aiecode2025/sha256/2922180a7a98ba951153940f0bf1a9d75fcd4d4269615f4ded5a56fda1d827f9.webp)

Open web:
Sub-tasks (e.g., Zoom),
11x faster and 43x cheaper

LATENCY
Average Latency per Zoom Action Sub-Task (s)
Y-axis ticks: 0, 2, 4, 6, 8, 10, 12
GPT-5.2
Qwen3-VL-8B-Instruct
11x faster

COST
Average Cost per Zoom Action Sub-Task (USD)
Y-axis ticks: 0.000, 0.001, 0.002, 0.003, 0.004, 0.005, 0.006
GPT-5.2
Qwen3-VL-8B-Instruct
43x cheaper

© 2026 Callosum Technologies Ltd
13

Event text: AIE; AI Engineer EUROPE 2026; AI Engineer EUROPE

Interface text: Finder, File, Edit, View, Go, Window, Help; Fri 10 Apr 12:56

### The future of compute

Callosum presents heterogeneous compute as a third paradigm: mapping multi-agent workloads onto different chips, following faster CPUs and parallel GPUs.

[12:37](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=757s) [A diagram presents faster CPU compute, parallel GPU compute, and heterogeneous compute as three paradigms.](https://assets.ai.engineer/sites/aiecode2025/sha256/4cd7e8dddb4d4b07921e1a6d6413515d211df9f6c66195baaab5de68d019411c.webp)

Looking ahead:
The future of compute

1st paradigm:
Made compute quicker.
intel
Peak: $509 Bn
CPU scaling

2nd paradigm:
Made compute parallel.
NVIDIA
Peak $5.37 Tn
GPU scaling

We unlock the 3rd paradigm of compute:
We are making compute heterogeneous.

Unlocking a new frontier of AI capabilities and cost for large-scale agentic AI.

© 2026 Callosum Technologies Ltd
CALLOSUM
Advanced Research + Invention Agency
ARIA
14

Event text:
AIE
AI Engineer EUROPE

Interface text:
Finder  File  Edit  View  Go  Window  Help
Fri 10 Apr 12:56

## Full transcript

[0:00](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=0s) [upbeat music] Thank you for coming to my talk.

[0:16](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=16s) My name is Adrian Bertagnoli. I'm a founding engineer at Callosum, and today I'm gonna be talking about scaling the next paradigm of heterogeneous intelligence. So I'm gonna start, um, with explaining why we care about heterogeneity in the first place, what particular aspect make it very conducive for scaling AI, um, how it is actually used in practice today,

[0:40](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=40s) and how we can use-- utilize it in the future, um, to actually scale the next paradigm of intelligence. So to give you an intuition about what I mean with heterogeneous intelligence, I wanna take a step back and, um, explain the current prevailing paradigm of homogeneous, uh, intelligence.

[1:00](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=60s) So homogeneous intelligence in, in terms of AI mainly refers to scaling single models on a fleet of identical chips. So this was largely-- This era was largely brought about by the discovery of neural scaling laws, which showed us that more data and more parameters leads to better models.

[1:19](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=79s) However, this is primarily rooted in a training domain, and while we move towards an inference domain, this becomes less and less relevant. So it's already changing, um, and we already see some level of heterogeneity in-- um, going into our current systems.

[1:39](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=99s) So on the architecture level, we see that mixture of experts are replacing large dense models. On the workflow layer, we see that single LLM calls are being replaced by mi-- uh, multi-agent systems.

[1:53](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=113s) And finally, on the hardware level, single chips are being replaced by prefill decode disaggregated systems. So given that we are currently at the state of mild heterogeneity, how can you imagine, um, a, a greater level of heterogeneity?

[2:11](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=131s) How will that appear? So initially, will be what we currently are experiencing is mild heterogeneity. So everything is still running primarily on, on homogeneous clusters, but we have some variety in the prompts.

[2:27](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=147s) When we run, uh, multi-agent systems, we might use different LLMs for different sub-agents. Um, again, we have mixture of experts.

[2:36](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=156s) Uh, when we increase the heterogeneity, we might start to use different chips, um, for different models. So different LLMs might be put on different GPUs. Uh, they might be interacting.

[2:50](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=170s) We might be using different models completely. So we have a increase of state-space models, diffusion models, all interacting with each other, all on optimal hardware that exists currently. And the last stage, uh, where we really see the, the heterogeneous paradigm unfolding is when we have a co-evolution of systems, uh, hardware and software.

[3:14](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=194s) So th-there will be a unification where you'll have, um, a complete vertical integration of intelligence and hardware.

[3:24](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=204s) So why heterogeneity? Why is it a good thing in the first place? So real-world problems are complex, multi-step, and open-ended. They decompose into sub problems which require vastly different types of intelligences.

[3:40](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=220s) So scaling a singular type of intelligence to solve these is very inefficient and, and not optimal. So how do we solve them? Solving these actually requires models of different architectures and sizes working together, um, uh, acting together in long horizons, something we like to call multi-agent heterogeneous intelligence.

[4:05](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=245s) Furthermore, new generations of silicon is coming towards the market, but currently there's no interface which allows it to, um, this new hardware to be unified and, and constructively, um, help the current compute stack.

[4:20](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=260s) And so this is what we aim to change. So heterogene-heterogeneity, the benefit is not simply a belief that we have. We actually formalize it and proved it mathematically. Um, on the right-- on the left, you see a figure outlining, uh, the principle of maximum heterogeneity.

[4:42](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=282s) So these are heterogeneous agents where the color indicates, um, a distribution over a skill space. Um, if you take-- If you have a communication between these, here indicated by a ring topology, you can have a s-- what we like to call a production function.

[5:01](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=301s) And the production function is simply the demand, uh, can, can be well suited for the demand of one problem, but ill-suited for another problem. So here we have a, a production function that's well-suited for demand A and ill-suited for demand B.

[5:18](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=318s) If you want to do this in a homogeneous fashion, you would either be able to only scale one peak, or in the optimal case, to match this demand function, you would have only generalists, so as broad as possible, the skill set.

[5:31](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=331s) But then ultimately you'd have a very short cylinder that does not meet the production function readily. So we formalize this, and we, um, saw that across many domains, including neuroscience, economics, and ecology, these, these trends hold, and under any reasonable amount of constraints, heterogeneous systems outperform homogeneous ones.

[5:56](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=356s) So how do we use this in practice? Like, I've been telling you about the benefits of heterogeneity, but I've not told you anything about what it actually means in terms of AI.

[6:07](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=367s) So we optimize, um, multi-agent systems at three different parts of the workflow. So all the way from the hardware where agents run on, we choose different hardware depending on the computational demands on the agents, and then how agents interact and what workflow they construct.

[6:27](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=387s) Um, so we have already demonstrated multiple, uh, benefits of, of, uh, this type of orchestration, and I wanna go into a couple ones. Um, main- namely in the workflow, something, a primitive we like to call heterogeneous recursion, and in the agent layer, I wanna talk about multi-model, multi-modal video action language models.

[6:52](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=412s) So heterogeneous recursion. This is something, um... Who's here heard of recursive language models?

[7:01](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=421s) Okay. So for those of you who, um, know- don't know recursive language model, it's kind of a seminal paper that came out of MIT, uh, last October, and they basically showed that even if you only occupy a small, uh, percentage of the context window, you still can have dramatic context rot depending on the information complexity you want,

[7:23](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=443s) uh, from the prompt. So if you're doing a needle in a haystack task, that is O of one. The, the information requirement scales is constant throughout, regardless of how big the prompt is.

[7:36](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=456s) And then you can imagine adding up the rows. You, you, you give, uh, rows and columns. Adding up the rows would be O of N because as the prompt increases, the infor- informational requirement increases linearly.

[7:49](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=469s) So if the, if you have a constant information requirement, it scales well. You, you can occupy the full context window and actually get a, a good answer. However, when you go to linear or quadratic, uh, it degrades at around 60 to 30%.

[8:04](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=484s) So recursive language models solve this problem by actually treating the context as a, um, environment rather than putting it all into the prompt. So in practice, this looks like you present the context in a file, and then the, a coding agent interacts with it programmatically through Python REPL, um, basically doing keyword searches, regex, a- and other

[8:29](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=509s) tricks to extract subcontexts, and this subcontext is then passed off to an identical recursive agent. So this agent then can answer the question or spawn another recursive agent. And, and that's why it's called recursive, uh, language model.

[8:44](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=524s) So we simply extended this concept. Um, instead of using a single model on a single chip, we map based on the subcontext generated towards different chips and different models to emulate the performance while drastically, um, being cheaper and faster.

[9:06](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=546s) So here are results. Um, you can see this is on the OOLONG benchmark. This is basically, um, the benchmark they used in the paper. Um, and GPT-5, GPT-5.2 was the, um, most recent one when we produced this work.

[9:21](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=561s) Uh, it sits around here where it takes around two thousand seconds, um, to run through the, the benchmark, and it costs around, uh, $3.75 for one task. Our system, when we go on Cerebras, we s- are seven times cheaper and five times faster.

[9:41](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=581s) So you save incredibly much time for a lot cheaper, so it's basically like having your cake and eating it too. Um, with SambaNova, we even get, uh, further. We push the price down even further at the cost of some latency.

[9:57](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=597s) So we're 12 times cheaper and three times faster. So these are like making architectural decisions that are not like simply based on the hardware. You can make huge impactful, um, price differences and, and, and while m- emulating the intelligence you would have from frontier models.

[10:20](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=620s) So the next problem we wanted to address is basically, um, visual web navigation. So we used a mixture of open and closed, uh, video action language models, um, and we managed to beat, uh, the state-of-the-art of Video Web Arena, beating GPT-5.2 and Gemini, uh, 2.5 by 18% and 25% respectively.

[10:45](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=645s) And not only this, the way we did it is instead of treating the problem as a homogeneous one, we, we acknowledge that the problem is heterogeneous, uh, i- itself.

[10:59](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=659s) It, it decomposes into multiple steps of visual reasoning, of, of textual reasoning, and each of these subcomponents requires different models to be, um, completed successfully. So here you see a fundamental shift of the Pareto frontier where you see singular models like Kimi K, uh, 2.5 and GPT-5.2

[11:23](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=683s) are outperformed by a mixture, a heterogeneous set of, of models. So when we use Qwen3-VL-8B-Instruct and Kimi K2.5, we're 1.3 times faster than using Kimi, Kimi alone.

[11:39](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=699s) We're 18 times cheaper than using, uh, GPT-5.2 alone. Um, and if we use, uh, Qwen3, um, plus GPT, we're actually three times faster and 3.7 times cheaper. So this is only benefit.

[11:54](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=714s) There's no downside, uh, in, in constructing this in a heterogeneous manner. So one part of, of our differentiating factor, why, how we were able to beat the state-of-the-art is- That we mapped certain subtasks like zooming and, and creating a different visual, um, reasoning for the agent.

[12:14](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=734s) We offloaded that into less intelligent models because you don't need GPT to zoom for you. So alone on these subtasks, we're able to be 11 times faster and 43 times cheaper than using ChatGPT.

[12:29](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=749s) And so this is what overal- overall accumulates towards these 3.7 times cheaper and three times faster.

[12:38](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=758s) So looking ahead, how do we s- view the future of compute? The first era of scaling compute was dominated by the CPU, where compute got quicker. The second era was making compute massively parallel.

[12:54](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=774s) This is dominated by NVIDIA. And the third paradigm,

[12:59](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=779s) compute is gonna become heterogeneous, mapping onto multi-agentic workloads and optimally, um, mapping these workloads onto different chips. We are actually, um, working with ARIA, the UK institute.

[13:16](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=796s) Um, we got a 3 million grant for the first-- for operating the first heterogeneous co-located cluster in the UK. So we really wanna make a difference and, and spearhead this new era of innovation.

[13:31](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=811s) So the era of h- homogeneous scale delivered extraordinary progress. We should be grateful for it. What comes next is heterogeneous intelligence, where models, workflows, and silicon co-evolve, and every new source of diversity makes the whole system smarter, faster and cheaper.

[13:48](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=828s) This is the worst our infrastructure will ever be. Thank you. [audience applauding]

[14:01](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=841s) How do you define which task to run on the, like, faster, uh, cheaper model? Like for instance, a zoom, is that something that's hard coded like, "Oh, if you have to zoom in this model," or do you have like a smarter model that decides the

[14:15](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=855s) So it is, um... Initially, we started doing bespoke decisions on mapping, uh, certain simple subtasks to simple models. But since then, we have, um, created an automation layer that detects the task complexity and automatically predicts the best model-- the best-suited model and hardware.

[14:41](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=881s) Any other questions? Great. Thank you so much for your attention. My name is Adrian Bertagnoli, and if anyone is interested, uh, we are hiring, so

[14:55](https://www.youtube.com/watch?v=WRBNDpUhsJQ&t=895s) yeah. Great. Thank you very much. [upbeat music]
