Rules and Context
Agents Can Actually Run.
Agentic data processing as a service. An engine, a CLI and an MCP server your agents use to connect sources, define business rules and run them on data where it lives: same input, same output, lineage behind every step.
Proven in production
Stop Prompting
Your Logic.
An agent with raw table access has to infer what "at risk" or "eligible" means each time it runs. Give it a tool that already knows.
The Agent Plans.
The Rules Run.
Keep planning, memory and conversation in your agent framework. When a step needs a business decision, the agent calls a rule and gets a computed answer from your live sources. LLM steps are labelled non-deterministic, so you always know which parts of a run could vary.
Remote MCP Server
Cloud-hosted with OAuth. Works with Claude, Genie Code on Databricks and other MCP clients.
Local MCP Server
Install prometheux-mcp with pipx and add it to Claude Desktop.
REST and Python
A bearer-token REST API and the prometheux-chain SDK, for any framework or service.
The px CLI
Rules live as plain files in git: diff a change, preview it with px plan, apply it, roll it back with git.
Keep the framework and model you already use. Replay any rule call and get the same answer. Ship tools your risk team can read.
Context Agents Can Skip.
Rules They Can't.
Most agent stacks hand the model documentation and hope it follows it. Prometheux puts the knowledge where it runs, so agents use it instead of interpreting it.
Lineage on
Every Call
Rule results carry provenance: the rule that fired and the source facts it used. When someone asks why the agent flagged a supplier, you show them the chain, not a transcript. The compute behind it runs only while there is work.
Provenance Built In
Provenance records how every output fact was derived, rule by rule.
Cacheable Results
Deterministic results can be cached and re-served, so agents don't recompute or re-prompt.
Compute on Demand
Agents list, start and stop machines over MCP and the API, with the same access rights as the user they act for. Idle machines stop themselves.
Data Stays in Place
Rules run on your sources where they live, under the access controls you already have.
Answer "how did the agent decide?" in minutes. Keep the data, the logic and the deployment yours.
Connect. Define.
Run.
Connect
Point Prometheux at the warehouses, databases and files the agent needs. Nothing is copied.
Define
Write the decisions as rules: eligibility, limits, multi-tier dependencies. Version them in git.
Expose
Add the MCP server to your agent, or call rules through REST, Python or the px CLI.
Run
The agent discovers the rules, calls them and gets deterministic, traceable results back.
Agents Where
Answers Matter
Supplier Risk Agent
The agent calls one rule: a plant is at risk if any supplier in its chain, at any tier, is disrupted. Kora Steel goes down; Lyon, Turin and Gdańsk come back with the chain behind each.
See agentic workflows →Explained Credit Decisions
Banca Sella's system reads a client's full history from its own databases and explains each decision, cutting a regulatory flow from 5 hours to under a minute.
Read the case study →Questions to Saved Rules
Turn a plain-English question into a readable rule the agent can call again tomorrow, with the same result.
See natural language to query →Blast Radius Before Change
Before a change ships, an agent lists every service downstream of a component, at any depth, and attaches the path to the ticket.
See deterministic AI →“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
“Prometheux technology powers highly scalable and explainable reasoning over some of the world's largest knowledge graphs.”
Accelerating Neurosymbolic AI with RAPIDS and Vadalog Parallel
Questions,
Answered
Do we have to replace our agent framework or model?
No. Keep the framework and model you use. Prometheux is the layer your agent calls for business logic, through MCP, the REST API, the Python SDK or the px CLI. Planning, memory and conversation stay where they are.
Which agents can connect?
Any MCP-compatible client through the remote MCP server with OAuth, including Claude and Genie Code on Databricks. Claude Desktop can also use the local prometheux-mcp server. Anything else can use REST or Python.
How do agents handle compute and changes?
Agents can list, start and stop machines through MCP and the API, with the same access rights as the user they act for, and idle machines stop on a timeout. Our MCP tools are labelled read-only or destructive so your client can ask first. Rule changes go through git: preview with px plan, ship with px apply (the CLI asks before applying), roll back with git.
Is the whole agent deterministic?
No, and we don't claim it is. The rules an agent calls are deterministic: same data, same result. LLM steps are labelled non-deterministic, so you know which parts of a run could vary.
Why not let the agent write SQL directly?
It would infer your business logic on every run, differently each time, with no record of how. A rule is written once, reviewed and versioned in git, and handles what generated SQL struggles with, such as supplier chains at any depth, with every result traceable to the rows it used.
Prometheux For…
Give Your Agent
Its First Rule
Bring the step your agent keeps getting wrong. We'll turn it into a rule it can call, and show you the lineage behind every answer.
