Inference that knows where to run.
Callozum splits each AI request into parts and decides where each part runs: on the device, on a GPU on site, at the cloud edge, or in the cloud. Parts that need no model are dropped, and your data rules decide what may leave. The first version is in progress, and the waitlist is open.
- Requests
- 0
- Dropped on the device, no model
- 0
- Answered without the internet
- 0
- Private items kept on site
- 0
- Time saved against all to cloud
- 0 s
Try the live routing demo: paste a request, Cloudflare's Clef model classifies it, and you see where each part would run.
Every request should ask one question first: where should this run?
Today's AI gateways choose a model and a provider. They assume the answer to "where" is always the same: a big data centre, far away. That worked when AI was a chat box. It doesn't work when AI runs in robots, cars, glasses, and factories, or in companies with rules about where their data may go.
Callozum makes "where" a decision for every request, across five places:
| Where | What it is | Delay | Best for |
|---|---|---|---|
| Drop | No inference. Nothing changed since the last check. | Microseconds | The many requests that don't need a model at all |
| Device | The device itself: a robot, a phone, glasses, a laptop | None | Reflexes, private data, working offline |
| Local Edge | A GPU nearby, one Wi-Fi or Bluetooth hop away, never crossing the internet | About 1 to 10 ms | Larger models, including reasoning, for data that must stay on site |
| Cloud Edge | Edge workers, such as Cloudflare Workers, running close to the device in the same region | About 10 to 30 ms | Fast decisions, shared state, in-country processing |
| Cloud | Data centres with the largest models, and long-term data from many users and devices | About 50 to 200 ms | Deep reasoning, long context, and analysis that compares many users or devices over time |
How Callozum works
You plug it in once. After that, every request goes through the same six steps.
Read the request
Callozum takes the query and its context: the prompt, attached data, the device it came from, and how fast the answer is needed.
Break it into parts
One request often holds several jobs: pull out fields, make a decision, reason about the result. Callozum splits them into parts, or into subagents, when they belong in different places.
Choose System 1 or System 2 for each part
System 1 is a fast decision or extraction model, such as Cloudflare's Clef or Clairic. System 2 is a large language model. If System 1 can answer a part, Callozum uses it, and it calls System 2 only when the part needs real reasoning.
Place each part
Each part goes to Drop, Device, Local Edge, Cloud Edge, or Cloud. The choice depends on your data rules, the time budget, the network, the device's battery, and cost.
Run and combine
Each part runs where it was placed, and the results combine into one answer on your side. When the network drops, parts fall back to the device.
Log every decision
For each part: where it ran, which model answered, how long it took, what it cost, and which rule placed it.
One request, split four ways
An example from a support tool. The request holds private customer data, but a good answer needs a large model.
"Why was this customer charged twice, and what should we tell them?"
Context: the customer's account record, their last 20 transactions, and the refund policy.
- DeviceRead the account record and remove names, card numbers, and addresses. The raw record never leaves.
- Cloud EdgeFind the two matching charges with an extraction model, in the customer's own region.
- CloudReason over the redacted charges and the policy with a large model, and draft a reply.
- DevicePut the customer's details back into the draft before anyone sees it.
What Callozum does
-
Split and place every request
Each request, or each part of it, goes where it fits: dropped, on the device, on a local GPU, at the cloud edge, or in the cloud. When the network drops, parts fall back to the device and keep running.
-
System 1 before System 2
Fast decision and extraction models, such as Cloudflare's Clef and Clairic, answer first. A large model is called only when a part needs real reasoning.
-
Keep data where it's allowed to be
Set rules once: what never leaves the device, what stays in the country, which providers each type of data may reach. Callozum splits the request so protected parts stay put, and only what may travel goes to a larger model. Every placement is logged for your auditors.
It will ship as an SDK for devices and services, or as a plugin for the AI router you already use.
Why now
The amount of inference is growing fast, and where it runs matters more every year.
- AI is getting a body. Robots, cars, and wearables could need about 100 times today's off-device inference within five years.
- Devices run real models. Every system is now split between the device and the cloud.
- Data rules are tightening. More data can't leave the device, the building, or the country.
- Models are splitting by job. Small fast models and large slow ones each do part of the work.
More on this: Where physical AI runs and The router I want to build.
Join the waitlist
Today you can try the routing demo, and a first demo on a live stream is in progress. We're building the first version now: the SDK, a plugin for existing AI routers, data rules, and per-part logs. If you run AI on devices, or you have rules about where your data can go, join the waitlist and we'll reach out.
Built by System3 Inference
System 1 is fast thinking. System 2 is slow, careful thinking. AI now has both, as small fast models and large slow ones. System3 is the part that decides which to use, and where. Callozum is named after the corpus callosum, which connects the two halves of the brain.