Spend Tokens on
Judgment, Not Joins
AI costs climb with every agent you ship, because each one burns tokens rediscovering your business logic on every query. Prometheux runs that logic once as deterministic rules, so you pay for LLMs only where language is needed.
supplier_risk · MCPProven in production
Agents Re-Derive.
Engines Reuse.
Gateways route the call and caches reuse the reply. The bigger saving is taking the work out of the prompt: most agent spend goes on re-reading context, re-guessing definitions and rewriting the same query every time someone asks.
Stop Paying Twice
for the Same Answer
Agents re-read, re-reason and re-guess every time someone asks. Prometheux answers once as reusable logic, then every repeat is deterministic and nearly free. Pick your world and watch the bill.
- Per question
- —
- Per month
- —
- 12 months
- —
- Per question
- —
- Per month
- —
- 12 months
- —
For illustration only: estimates to show orders of magnitude, not a quote. Compares LLM token spend for a typical agentic run against Prometheux, where the model only routes the question and phrases the answer. Infrastructure compute is not included on either side.
Do the Work Once.
Reuse It Forever.
Business definitions, calculations, joins and multi-hop logic belong in the ontology, where the engine executes them exactly. The LLM handles the conversation and calls the result, instead of reconstructing it in tokens.
Logic Written Once
A rule defined once serves every agent, app and report, instead of being regenerated per request.
Heavy Lifting in the Engine
Joins across sources, recursion and graph analytics run in the reasoning engine, at no token cost per row.
Small Answers, Small Prompts
Agents receive a derived result rather than raw tables, so prompts stay short and focused.
Reuse, Not Recompute
Executable concepts can return cached results when their inputs haven't changed, so repeat questions don't repeat work.
Every deterministic step is a step the LLM is not billing. Make AI cost predictable as usage grows. Get more reliable answers for fewer tokens.
Every LLM Call
Has Limits
Where a step genuinely needs a language model, it is configured as an LLM concept with explicit caps. Nothing grows silently: inputs are capped, prompts are trimmed to fit and every cut is reported.
Capped Inputs
row_limit caps how many upstream rows reach the prompt (100 by default), and max_tokens caps the reply (4096 by default).
Right Model per Step
Set provider and model per LLM concept, so lighter steps can use lighter models in the same workflow.
No Silent Truncation
Each run reports how much input was included, whether the prompt was trimmed and whether the reply was cut short.
Usage and Quota via API
GET /api/v1/users/usage-status returns current usage, limits and remaining quota for LLM and embedding calls.
Know what every LLM step can cost before it runs. Keep model choice a configuration, not a rewrite.
From Token Burn
to Token Budget
Find the Repeat Work
Spot the definitions, joins and checks your agents rebuild on every request.
Move It to Rules
Encode that work once as concepts, executed deterministically by the engine.
Point Agents at Concepts
Agents call concepts via APIs or MCP and use the LLM only to understand and explain.
Cap and Watch the Rest
Set limits on each LLM concept and track usage and quota.
Fewer Tokens,
Better Answers
Self-Serve Questions
Many people asking the same question hit the same concept, instead of each triggering fresh SQL generation.
Multi-Source Agents
Agents stop scanning many databases with prompts; cross-source joins run once in the engine.
Power AI →Lean Context
Static or dynamic context concepts pass only the relevant notes, with top_k bounding dynamic search, instead of whole document sets.
Model Mix
Route simple summarisation to smaller models and keep larger ones for the steps that need them.
Questions,
Answered
How does Prometheux reduce LLM token spend?
By moving repeatable work out of the model. Business definitions, joins, calculations and graph logic run deterministically in the reasoning engine, and agents call the results through APIs or MCP. LLMs are used for language, not for re-deriving logic.
How is this different from an AI gateway or semantic cache?
Gateways and caches act on the call: they route it, cap it or reuse a reply to a similar prompt. Prometheux removes repeatable work from the prompt altogether, so joins, definitions and graph logic run in the engine and there are fewer, smaller LLM calls to make in the first place. The two work together: a gateway can still route the calls that remain.
Will cutting tokens make answers worse?
No. The work that moves into the engine is the work that should be exact: definitions, calculations and multi-hop logic. It runs deterministically, so answers get more consistent, and the LLM is left with the language tasks it is good at.
Can I limit and track what each LLM step uses?
Yes. Each LLM concept has row_limit for upstream rows (default 100) and max_tokens for the reply (default 4096), prompts are trimmed to fit the context window with every cut reported, and GET /api/v1/users/usage-status returns usage, limits and remaining quota for LLM and embedding calls.
Related Capabilities
Stop Paying Twice
for the Same Answer
Bring an agent workflow and its token bill. We'll show you which work belongs in the engine.
