Stop Paying Twice
For the Same Things.
On every question, an agent reads your context as text, interprets it, writes queries from scratch, then guesses. Define that logic once as a deterministic rule on your data and run it on ordinary compute. Every deterministic step is a step your LLM is not billing.
supplier_risk · MCPProven in production
Read. Interpret.
Query. Guess.
Most agent spend isn't language. It's the model rebuilding the same understanding of your business on every call. Prometheux turns that understanding into rules that run on your data, so there's far less to send to the model.
Describing Data
Isn't Running It.
A semantic layer tells an agent what your terms mean. To get an answer, something still has to write a query against it, in SQL or the layer's own language, every time. Prometheux connects to your data and runs the definition itself, so the agent gets the answer, not homework. See semantic layer.
Move the Repeatable
Work Out
Find the Repeats
Pick the questions agents answer again and again: definitions, eligibility, rollups, multi-tier dependencies.
Write Them as Rules
Encode each one once as a deterministic rule over your live data. No data is copied.
Point Agents at Them
Agents call the rules through MCP, REST or Python and receive a small, computed answer instead of raw tables.
Watch and Tune
Cap rows and reply length per LLM step, pick lighter models where they suffice, and read usage via API. See AI observability.
Fewer Calls.
Smaller Prompts.
Gateways change how calls are routed and cached. Prometheux changes what reaches the model at all: joins, definitions and multi-hop logic run in the engine, and the same rules serve every agent, app and report. See token spend control.
Logic Written Once
A rule serves every agent and every phrasing of the question, instead of being regenerated per request.
Reuse, Not Recompute
Deterministic rules can return cached results when their inputs haven't changed, so repeat questions don't repeat work.
Capped Inputs
row_limit caps the rows that reach a prompt (100 by default) and max_tokens caps the reply (4096 by default).
Spend You Can See
Each LLM run reports what was included or trimmed, and an API returns usage, limits and remaining quota.
Bring AI spend back into the budget. Scale agents without scaling re-derivation. Get more consistent answers as a side effect.
Repeat Questions,
Answered Once
Popular Questions
Many people ask the same KPI question in different words. They all hit one rule, instead of each prompt generating its own SQL.
Multi-Tier Risk
"Which plants depend on Kora Steel, at any tier?" runs as a recursive rule in the engine. The model only writes the summary for Lyon, Turin and Gdańsk.
Cross-System Agents
Agents stop scanning several databases through prompts. Cross-database joins run once in the engine.
Right-Sized Models
Route short summaries to smaller models and keep larger ones for the steps that need them, in the same workflow.
“Prometheux enabled us to build a system that can access our databases, process all the client's historical variables, and provide an intelligent, understandable explanation autonomously.”
Massimiliano MalinHead of Credit Risk · Banca Sella
“With Prometheux, we achieved a speed-up of over 250% on critical tasks involving complex reasoning over knowledge graphs with hundreds of millions of nodes and billions of edges.”
Financial institution
Questions,
Answered
How does Prometheux reduce LLM spend?
By taking repeatable work out of the model. Definitions, joins, calculations and multi-hop logic run as deterministic rules on your data, and agents call the results. The LLM is used for language, so there are fewer and smaller calls to pay for.
How much will we save?
It depends on how much of your agents' work is repeatable logic versus language. We'll help you measure it on your own workloads rather than quote a generic figure.
We already have a semantic layer. Isn't that enough?
It helps agents use the right definitions, and you can keep it. But an agent still has to write a query against it for every question, and logic like dependencies at any tier is left to that query. Prometheux runs the logic itself on your connected data, so agents call a rule and get the answer.
How is this different from an AI gateway or semantic cache?
Gateways and caches act on the call: they route it to a cheaper model, cap it, or replay a response to a similar prompt. Prometheux removes repeatable work from the prompt altogether, and a rule reuses its result only while its inputs are unchanged, so savings don't cost correctness. They fit together: a gateway can manage the LLM calls that remain.
Will cutting tokens make answers worse?
No. The work that moves into rules is the work that should be exact. It runs deterministically, so answers get more consistent, and the LLM keeps the language tasks it is good at.
Can we track and cap usage?
Yes. Each LLM step has row_limit and max_tokens caps, truncation is always reported, and GET /api/v1/users/usage-status returns usage, limits and remaining quota for LLM and embedding calls.
More Use Cases
Define It Once.
Run It Cheaply.
Bring the agent workloads behind your AI bill. We'll show you which steps can run as rules on ordinary compute instead of prompts.
