1 · What it does
The work it does — capability first, each labelled by maturity.
Arkheia puts AI to work on real workflows — support, revenue, operations — and makes every action trustworthy enough to approve. Governance and runtime detection are how that work is made safe to switch on, not the headline. Every capability below carries an honest maturity label. We publish no accuracy, precision, recall, or effect-size numbers on this page — verify the signal on your own prompts via the live demo and, for deeper testing, evaluation access (see Verify it yourself).
Governed AI support triage
Works on any Freshdesk / Zendesk / ServiceNow queue: reads ticket history, the knowledge base, code and docs to classify, route, and draft a fix — turning triage hours into minutes. It runs assist → supervised → autonomous as trust is earned, with the detection signal and governance gate on the execution path the whole way. Interactive demo at /x/support/.
Governed AI in your CRM
Works on top of HubSpot / Salesforce / Pipedrive: reads every signal, proposes the play that closed similar deals, and earns the right to act under the same governed gate. Interactive demo at /x/crm/.
Governed decision & data-trust surfaces
A manufacturing event stream governed so downstream decisions act only on trustworthy data; a governed reconciliation gate that approves, flags, or holds handwritten dockets against invoices, each with a receipt. Interactive demos at /x/data-trust/ and /x/recon/.
Governed enterprise workflow surfaces
The same governed runtime builds and operates workflow surfaces across CRM, revenue lifecycle, procurement, finance close, legal ops, HR service, PPM, support, marketing, and assurance — proof of governed capability, not a product you must buy first. The product governs the work that builds the product.
Governance / control plane (the how)
At the moment AI acts, the runtime trust signal becomes an execution gate: allow, block, require human approval, hold to a private note, escalate, or kill — every decision written as a tamper-evident decision receipt, with cost controls and audit evidence. Governs API models (OpenAI, Anthropic, Gemini, xAI & compatible), local / self-hosted models where deployment permits, and MCP / tool calls.
Runtime fabrication / deviation detection (the moat)
This is what governance gates on, and what no one else has. At the invocation boundary, Arkheia scores each model invocation against the model's own behavioural baseline and returns a risk verdict (e.g. LOW / MEDIUM / HIGH), a confidence, and a detection id — without needing to retain the content it scores. A public demo runs this now at /demo/.
2 · Does it actually work
Test it, don't take our word for it.
The most honest evidence is something you can run yourself, plus one early customer proof-of-concept we can describe in full. Where we lack a hard number, we point you at the self-test rather than invent one.
A crude-but-working proof of concept dropped into a real customer's environment, honestly labelled a POC / early pilot — not a production deployment: a Python script on a support agent's laptop, calling GPT-5.4, connected to their real Freshdesk ticket queue and knowledge base, with an Arkheia detection key on the path, writing private triage notes back into the ticket. Real tickets, real KB, real workflow. Point it at a ticket — it triages, suggests resolution steps, and writes a private note on what to confirm with the customer.
Observed in this POC: a task that normally takes ~3 hours became a ~2-minute prompt.Start with a private note. End with a governed operating capability. The system of record is the scaffold, not the destination.
Run your own prompts and watch the trust signal produce a verdict, confidence, and detection id. Calls a public Arkheia backend proxy — not the model vendor directly from your browser.
Governed AI triage over a ticket queue — reads context, suggests the fix, governs the AI, and earns the right to run. Watch the wheels come off with the brakes still on.
Governed AI on top of your CRM — reads every signal, proposes the play that closed similar deals, and earns the right to act under the gate.
The method, in plain terms
Most approaches read the text a model returns and guess whether it looks wrong. Arkheia instead builds a per-model behavioural fingerprint — a baseline of how that specific model behaves — and scores each new invocation against that model's own baseline. Because it measures behaviour rather than parsing meaning, the signal works at the invocation boundary, before a workflow acts on the answer, and can run without retaining the content it scores.
The output is a runtime verdict (e.g. LOW / MEDIUM / HIGH) with a confidence and a detection id you can reference, which the governance gate then acts on.
The honest caveat. Coverage depends on per-model profiles. A model that has no profile yet returns an evidence-limited LOW — that means “couldn't assess,” not a clean bill of health. We label this rather than hide it, because a governance product that overclaims is self-defeating. This page deliberately publishes no precision / recall / accuracy / effect-size figures; measure the signal on your own prompts instead.
3 · Will it work in our environment
Deployment patterns, and what data leaves.
These are deployment patterns, not shrink-wrapped SKUs. The public /demo/ is the immediately testable surface; the patterns below are how Arkheia sits in a real stack. For sensitive customers, the in-path detection self-hosts inside your tenant — prompts and data never leave.
| Pattern | How it sits | Maturity |
|---|---|---|
| API proxy | Point your SDK base URL at the Arkheia proxy. Inference flows through and is scored inline. Fail-open on inference: if detection is unavailable, inference still flows — detection degrades, it never blocks your traffic. | dogfood |
| MCP server | Arkheia exposes detection / verification, memory, and audit as MCP tools an agent or IDE can call directly. | dogfood |
| Local / self-hosted | For sensitive customers, the in-path detection component (proxy + detection) and the MCP tool server self-host on your own infrastructure, inside your tenant, so prompts and data never cross a shared backend. | pilot |
| On-prem | A fully on-premises deployment of the in-path components is offered as a deployment option for environments that require it. | roadmap |
| Data & failure posture | What it means for you |
|---|---|
| Content retention | Content-minimising, zero-retention by default: the detection signal can run without retaining prompt or response content. |
| What leaves the environment | In the public demo, prompts reach a public Arkheia backend proxy. In the local / self-hosted pattern, the in-path components run inside your tenant so prompts and data do not cross a shared backend. |
| Failure behaviour | Fail-open on inference, fail-safe on autonomy. A detection outage degrades the signal but does not stop inference; an autonomy gate that loses its trust signal falls back to the safe action — hold for human approval, not act unchecked. |
| Model coverage | API models (OpenAI, Anthropic, Gemini, xAI & compatible), local / self-hosted models where deployment permits, and MCP / tool calls. |
4 · The risk-owner answer
Autonomy is earned, not granted.
This is not AI let loose. AI doesn't get switched on all at once — it starts assistive and earns scope, stage by stage, each one widened only by evidence. Every step has execution gates, receipts, cost controls, and human escalation. Here is the path a workflow walks, using support triage as the worked example.
5 · Verify it yourself
A self-serve path to your own evidence.
No published metric substitutes for the signal on your own traffic. We're honest about what's open versus gated: the live demos are open to anyone; in-stack evaluation is arranged per engagement.
npx @arkheia/mcp-server for the MCP server, or clone + docker compose up to self-host the proxy — detection runs in your environment. See Run it in your own stack below. Higher-tier / managed evaluation keys are the upgrade path.
Run it in your own stack — download
Both surfaces ship from one public repo — github.com/arkheiaai/arkheia-mcp. Self-serve is now the primary route: install the MCP server or self-host the in-path proxy so detection runs in your environment. Higher-tier and managed evaluation keys are the upgrade path (contact below).
Detection / verification, memory, and audit exposed as MCP tools an agent or IDE can call directly. ~60-second installer (needs Node 18+, Python 3.10+, and an API key).
npx @arkheia/mcp-serverClone the repo and bring up the in-path proxy, then point your SDK / agent base URL at the local proxy. Inference flows through and is scored in your environment — secure transit, data doesn't leave. The proxy is a thin shim; detection logic runs server-side.
git clone https://github.com/arkheiaai/arkheia-mcp
cd arkheia-mcp
docker compose upFree tier: 1,500 detections / month, no credit card. Mint a free key at app.arkheia.ai/signup. For higher-tier or managed evaluation keys, contact Arkheia — the public download above is the primary, self-serve route.
6 · Take-away pack
Download it. Read it offline. Bring it to the meeting.
Four standalone documents, same facts and same maturity labels as this page, no secrets and no invented metrics. The last one is written for an AI evaluator to ingest in a single read.
Every claim with its maturity label and how to verify it.
Deployment patterns, data posture, retention, fail-open / fail-safe behaviour.
Step-by-step self-test plan and what you can measure.
Machine-readable summary for an AI assistant doing diligence.