$1,170.94 saved per user in 30 days.

If you pay per token

The bill is what moves. If everything you send today lands on one big model, you are paying flagship rates for the easy majority of it — the routing, the lookups, the tidy-ups.

Right-sized instead of sent whole to a frontier model, the same work came out 80% lower on the account above.

If you’re on a subscription

You don’t buy tokens per request, so nothing gets cheaper — you get further. The saving arrives as headroom instead of dollars.

The same plan allowance stretches: more tasks finished before you hit a limit, and fewer of them burned on work a small model could have handled. Same subscription, more done with it.

Task chains

One request rarely maps to one model call. Yours is broken into a chain of smaller tasks, with the independent ones run side by side.

Elis plans the chain, runs it in order, and re-plans around a step that fails. You never write it.

Agents

An agent is a reusable expert that carries its own rules and knowledge, so your setup isn't re-explained on every request.

Each task is matched to the agent that has earned the best results on work like it — nothing to configure, no prompt library to maintain. When you do want a named specialist of your own, your organization can create one: describe the job and Elis drafts its recipe — the tasks, tools and rules it runs — or author that recipe yourself. From there it has to earn its traffic on measured outcomes, the same as every other agent.

Embeddings

To pull in the right context, text is turned into vectors and searched by meaning rather than by keyword.

Elis sizes the embedding model to each chunk, so small chunks never pay for a heavyweight one. No vector database to run, index, or tune.

Embedding backups

An embedding can only be read back by the model family that wrote it, so a retired embedding model can strand the context it encoded.

A copy is kept in each embedding space your tenant can actually serve, up to a redundancy cap, and anything stored without real embedding capacity is re-embedded once capacity returns. Draining a dead space is a supported migration, run deliberately rather than on its own.

Caching

Long context you send again and again — a system prompt, a large file — can be cached at the provider instead of charged at full price every time.

Elis asks for the caching and measures what it returns; the discount shows up on your ledger rather than being invisible.

Stored results

The output of a plan that worked is grounding for the next one — but only if it is kept somewhere it can be searched.

On the paid program a finished plan's result is scrubbed, safety-scanned, stored inside your own tenant and embedded for later grounding. Nothing leaves that tenant unless you opt a specific artifact into sharing.

Tooling

Search, browsing, code execution and the rest each have their own reliability and speed.

Tools are bundled and ranked by measured reliability, latency and fit — not by whatever happens to be installed.

Heuristics

Every run produces an outcome worth remembering: how good it was, how long it took, what it cost.

All of it is recorded as a signal, per agent, per model, per tool — which is what makes the next run cheaper.

Self-learning

The routing rules are not fixed. What works gets promoted; what stops working gets demoted.

Semi-supervised and reinforcement learning drive that, and new strategies ship behind canaries so they have to earn their traffic before they carry it. The agents govern themselves on that evidence: a candidate is trialled against the incumbent it would replace, and one that cannot beat it never carries live work.

Proven chains

A plan that worked is worth more than its answer: the order of tasks that produced it is reusable on the next request like it.

A chain is only recorded as proven once it has been graded and settled, not merely finished — and it can then be recalled for a similar goal instead of being planned again from scratch.

Anomaly detection

A system like this degrades quietly: one model's quality drifting down, more work falling back to a larger tier than it used to, the pool running short of nodes.

Elis scans its own telemetry for those patterns and raises them as alerts with the cause attached. Detection is kept separate from repair on purpose — the alert names the problem rather than quietly rewriting something behind you.

Failure handling

When a call fails, something has to decide how far the blame reaches — the node that ran it, the credential it used, or the model itself.

Each class is sorted to its own radius automatically: a bad execution quarantines that one node, a dead credential disables everything sharing it, a rate limit pauses that key's nodes for a while rather than the model. One bad call never takes out a provider.