Callozum by System3 Inference

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.

Tell us what you're building (optional)

DeviceRobot, phone, glasses. Callozum runs here.No network
Local EdgeA GPU on site, over Wi-Fi+1 to 10 ms
Cloud EdgeAn edge worker, in your region+10 to 30 ms
CloudLargest models, data from the whole fleet+50 to 200 ms

 

All to cloud
 
Callozum
 
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

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:

WhereWhat it isDelayBest for
DropNo inference. Nothing changed since the last check.MicrosecondsThe many requests that don't need a model at all
DeviceThe device itself: a robot, a phone, glasses, a laptopNoneReflexes, private data, working offline
Local EdgeA GPU nearby, one Wi-Fi or Bluetooth hop away, never crossing the internetAbout 1 to 10 msLarger models, including reasoning, for data that must stay on site
Cloud EdgeEdge workers, such as Cloudflare Workers, running close to the device in the same regionAbout 10 to 30 msFast decisions, shared state, in-country processing
CloudData centres with the largest models, and long-term data from many users and devicesAbout 50 to 200 msDeep 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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

  1. 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.

  2. 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.

  3. 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.

Tell us what you're building (optional)

We use your email only to contact you about Callozum.

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.