part of Project LEO
Give your agents a metacognitive layer that detects uncertainty, verifies decisions, and prevents confident mistakes in real-time, adding also a self learning background over time backed by pure math.
or see all features →Works with the model you already use
Autonomous agents often act with unwavering confidence, even when they're guessing. A single "confident mistake" in financial, legal, or operational workflows can be catastrophic. LEO Soul adds the missing metacognitive layer, ensuring agents know exactly what they know—and what they don't.
The agent proceeds with tasks, makes decisions, or provides information without truly knowing its own certainty. Errors are discovered downstream, often after significant impact, leading to costly rectifications and eroded trust.
Before every critical output, LEO Soul measures the agent's genuine certainty. Solid, verified outputs proceed directly. Shaky or uncertain ones trigger a metacognitive loop, allowing the agent to ask for clarification, confirm, or refuse, preventing confident mistakes from impacting critical operations or users. This continuous feedback loop also sharpens the agent's understanding over time.
Route each message through LEO Soul instead of straight to the model. You get back the reply plus a small memory blob - store it and pass it back next turn. That round-trip is how your agent learns.
Send the user's message through LEO Soul. A near-zero-cost triage sizes up the risk so calm turns stay fast and cheap.
It weighs its own uncertainty, checks for flattery, considers the stakes, then decides whether to answer, ask, confirm, refuse, or hold.
You receive the reply, a readable trace of the decision, and updated memory. Persist it - calibration and beliefs ride inside, and they stay yours.
LEO Soul runs in your backend, between your app and the model it already calls. If your code can call an AI model, it can call LEO Soul. Most teams are live in an afternoon.
Keep the OpenAI or Anthropic SDK you already use. Change one line, the base URL, so your calls go through LEO Soul first.
client = OpenAI(
base_url="https://soul.kadropiclabs.com/v1",
api_key="sk-leo-…",
)Each request runs the full decision loop, weighing uncertainty, pressure, and stakes, then returns the same response shape your code already parses, plus a small memory blob.
Store that blob and pass it in next turn. That round-trip is how your agent remembers and gets sharper - and the memory stays yours.
Everything beyond these three - policies, self-hosting, SSO, webhooks - is optional tuning. See the full integration guide →
Not clever prompt instructions - real methods doing real work, with every decision on the record. The tag on each card names the math underneath, for anyone who wants to check.
It doesn't just sound sure. It checks how much its possible answers actually agree, then tunes the number so that "90% sure" really is right about 9 times out of 10.
When it isn't sure enough, it asks a question or holds back instead of guessing. You set how careful it has to be, and it keeps its mistakes under that line.
It changes its mind for new facts, not for a raised voice. Push back without anything new and it holds its ground - instead of being talked into a wrong answer.
It quietly learns which kinds of questions trip it up in your product and gets sharper every turn - no training runs, no data team. And what it learns lives in your own memory, so it stays yours.
When it needs to ask, it picks the one question that clears up the most confusion - not a pile of them - and comes back to the rest later.
Easy questions get an instant answer; it only slows down to think hard when the stakes are real. Speed where it's safe, care where it counts.
Each method is documented with its guarantees in the architecture reference.
Everything around the engine is built to the standard a serious company expects - secure by default, controllable, and transparent.
A real-time window on your agent's metacognition: decisions, warnings, anomalies, boundaries, and recoveries stream onto your dashboard as turns run - without one word of message content. The pilot's instrument panel, not the conversation. On every plan, Free included.
Protect every account with app-based 2FA (TOTP) and one-time backup codes. Sign-in, sign-up, and password reset are rate-limited against brute force.
Lock each key to an expiry date and an IP allowlist (CIDR supported), so a key only works where and when it should. Rotate or revoke instantly.
Stream events - new key, usage thresholds, and escalations when a turn needs a human - to your systems over HMAC-signed HTTPS. Verify every delivery, no polling.
Live analytics, proactive alerts at 80% and 100% of your quota, and one-click CSV export - a busy month never surprises you.
An in-dashboard Playground runs a real turn and shows the full decision trace - no key needed. It even puts the raw model beside the Soul-governed answer, so you can see exactly what the judgement layer changes. Official Python & JS SDKs, SSO (SAML) / SCIM, Prometheus metrics, an audit trail, and self-hosting round out the enterprise story.
Wiring it in is the easy part (three steps, above). The hard part is answering "how do you know it works?" without hand-waving - so LEO Soul measures itself and hands you the proof.
Text streams as the model writes it - but this layer's job is to catch answers that shouldn't be given, and a word you've already read can't be unsaid. So we hold each sentence until nothing can still change it. You never see a "sorry, ignore that".
Report real outcomes whenever you learn them - a ticket that resolved, a rating overnight - and get your own error rate on answered turns, with a 95% upper bound, against your own budget. The report is built not to flatter us: no verdict until there's enough data, judged on the bound rather than the average. It's what a security review or an AI Act assessment actually asks for.
The engine is stateless - everything it learns lives in a small memory blob that you store and pass back each turn. Run it as a library or self-host the whole thing in your own cloud. Switch away whenever you like and you keep everything your agent has learned.
Wrap one turn, keep your model and your data, and ship an agent that knows when not to answer.