Case Study
How Sella Delivers Scalable Credit Risk Explanations with Prometheux
Read More
Use Cases / AI Agents

Use the Platform.
Own the IP.

Your business logic is your edge. Don't hand it to a vendor's prompts or model. Write it once as rules your team owns, keep them in your repo, and let any agent call them on your data: same input, same output, a trail behind every answer.

Proven in production

Why pilots stall

The Demo Works.
Then Audit Asks.

Most agent pilots ask the model to work out the business logic on every run. That is fine for a demo and a problem for a workflow someone has to sign off. Prometheux moves the logic out of the prompt and into rules your team owns.

Agent pilot today
Agents with Prometheux
The agent follows written instructions and works out the business rules each time
The agent calls named business rules your team wrote and reviewed
Your know-how ends up in a vendor's prompts, configs and fine-tunes
Your logic lives in rules you own: readable, versioned in git, portable
Same question, different answer; every prompt or model change means re-testing
Rules run deterministically: same data, same result, whichever model calls them
Data is copied into a sandbox or vector store for the pilot
Rules run on live data in place, under your existing access controls
Nobody can show how an answer was reached
Each result traces back to the rules and source rows behind it
Each team's agent re-implements the same logic
One set of rules serves every agent, app and report
The pilot is tied to one vendor's agent and model
Any MCP client, REST or Python, with the model you choose
Own the IP

Your Rules.
Your Advantage.

Agent platforms that work out your logic for you also end up holding it. With Prometheux the logic is yours from the first line: plain rules your experts can read, stored as files in your own repository, run on your own data and compute. Swap the model or the agent; the rules stay.

Rules in Your Repo

The px CLI keeps every concept as plain files in git: diff, review in a pull request, roll back. See context as code.

On Your Infrastructure

Run in Prometheux cloud, in your own VPC or on your own servers, with data read in place. See on-premises.

Any Model, Any Agent

Agents call your rules over MCP, REST or Python. Change the model or the framework without rewriting the logic.

Every Run on Record

Each answer keeps the rules and source rows behind it, so the record of how your business decides stays with you.

What this means for you ⟶

Talk to an engineer

Your logic is your competitive edge. Keep it readable, versioned and yours. Let agents come and go; the rules stay.

How it works

Connect. Define.
Run.

01

Connect

Point Prometheux at the warehouses, databases and files the workflow needs. Nothing is copied. See in-place data processing.

02

Define

Write the decision logic as rules: eligibility, limits, thresholds, multi-tier dependencies. Review and version them like code.

03

Run

Agents call the rules through MCP, the REST API or the Python SDK and get a computed answer, not a guess. See agentic workflows.

04

Explain

Every result keeps its derivation, so reviewers and auditors can see which rules fired on which rows. See AI lineage.

What you get

The Model Talks.
The Rules Decide.

Keep the language work with the LLM and the decision with logic you can read. Prometheux labels which steps are deterministic and which are model-generated, so you know exactly where a run could vary.

Any Agent, Open Protocols

A remote MCP server with OAuth works with Claude, Genie Code on Databricks and other MCP clients. REST and Python cover the rest.

Repeatable Steps

Rule calls return the same result for the same data, so you test a rule once, and replay, compare or cache any rule call.

Governed by Default

Data stays in place under your access controls, keys stay in saved connections, and the in-app assistant asks before making changes and always before deleting anything. See AI governance.

An Audit Trail Per Answer

Provenance links each derived fact to the rule and source facts that produced it, ready for review.

What this means for you ⟶

Plan your first production agent

Ship agents your risk team can sign off. Answer "how did it decide?" in minutes. Keep the logic, data and deployment yours.

Where agents go live first

Critical Workflows,
Not Chat Demos

Banking

Explained Credit Decisions

Banca Sella's system reads a client's full history from its own databases and explains each credit decision, cutting a regulatory flow from 5 hours to under a minute.

Read the case study →
Supply chain

Supplier Risk Agent

An agent answers "which plants are at risk?" by calling 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.

IT operations

Blast Radius Before Change

Before a change ships, an agent calls a dependency rule to list every service downstream of the component, at any depth, and attaches the path to the ticket.

Databricks

Agents in Your Workspace

Connect Genie Code to the remote MCP server and let it run your rules on data governed in Databricks.

See agentic workflows →

Proven in Production

“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 Malin
Head of Credit Risk · Banca Sella
“Generative AI without ontologies is an engine without a road. Prometheux builds the road.”
Marco Romei
Deputy CIO · Banca Sella
FAQ

Questions,
Answered

Why do AI agents get stuck in pilot?

Usually because the agent works out the business logic itself on every run. Answers vary, nobody can show how they were reached, and the data was copied somewhere for the demo. Prometheux keeps the logic in reviewed rules that run on live data, so the agent's answers are repeatable and traceable.

Who owns the logic we build?

You do. Rules are written in your workspace, can be kept as plain files in your own git repository with the px CLI, and run on your data in Prometheux cloud, your VPC or your own servers. Agents and models call them; they don't hold them.

Do we have to replace our agent framework or model?

No. Keep the agents, frameworks and models you use. Prometheux is the layer they call for business logic, through MCP, the REST API or the Python SDK. Orchestration, 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 the REST API or Python SDK.

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 explicitly labelled as non-deterministic, so you can keep them on language tasks such as summarising and know which steps could vary.

Aren't guardrails and evals enough?

They help, and you can keep them. Guardrails limit what an agent may say or do, and evals sample its behaviour. Neither makes the decision repeatable. When the decision is a reviewed rule, the outcome is computed, the same every time, and recorded with the rows behind it.

How do we show an auditor what the agent did?

Each result from a rule carries provenance: the rule that produced it and the source facts it used, which can be turned into readable explanations.

Does our data have to move?

No. Prometheux connects to your databases, warehouses and files where they are, and deploys in your cloud, on-premises or natively on Databricks and Snowflake.

Take One Agent
to Production.

Bring the workflow your pilot couldn't sign off. We'll help you turn the decision logic into rules you own and your agents can call.

We use some essential cookies to make this site work. By clicking "Accept All" you agree to the storing of cookies on your device to enhance site navigation, analyse site usage and assist our marketing efforts. For more detailed information see our Cookie Notice.

Accept AllDecline