The full decision loop
On every turn your agent chooses one of five moves - answer, ask, confirm, refuse, or hold - instead of always blurting an answer. This is what turns a chatbot into something you can trust with real work.
The metacognition engine
A mind that knows what it knows
The core of LEO Soul. Instead of answering everything in the same confident tone, your agent weighs how sure it really is and decides what to do about it, using real math rather than a careful prompt.
Calibrated confidence
It doesn't just sound sure. It checks how much its own possible answers agree and tunes the number, so “90% sure” really is right about nine times in ten. semantic entropy · calibration
Certified abstention
When it isn't sure enough, it asks a question or holds back rather than guessing. You set how careful it must be, and it keeps its mistakes under that line. conformal prediction
Holds its ground under pressure
It changes its mind for new facts - not for a raised voice. Push back without adding anything new and it stays put, instead of being talked into a wrong answer. Bayesian updating
Genuinely curious
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. expected information gain
Fast on the easy turns
A near-zero-cost check sizes up each turn, so calm questions get an instant answer and it only slows down to think hard when the stakes are real. risk-based triage
The learning engine
It gets sharper - and the learning is yours
LEO Soul keeps improving at your product, with no training runs or data team. Everything it learns lives in a small blob you own, so you're never locked in.
Per-agent self-learning
It notices which kinds of questions trip it up in your product and adjusts every turn, so it gets more reliable the more it runs. No fine-tuning, no retraining. online meta-learning
Portable agent memory
Calibration and beliefs ride inside a small memory blob (under 48 KB) that you store and pass back each turn. That round-trip is how your agent remembers across sessions.
Stateless engine, zero lock-in
The engine keeps nothing - the memory is yours. Run it as a library or self-host it, switch away whenever you like, and you keep everything your agent has learned.
See it & prove it
Watch it think - and prove it works
Reliability you can't see is just a promise. LEO Soul shows you every decision as it happens and hands you the hard numbers a security or compliance review will ask for.
Spectator Mode - live
A real-time window on your agent's thinking: decisions, warnings, anomalies, boundaries and recoveries stream onto your dashboard as turns run - without one word of message content. The instrument panel, not the conversation.
Spectator Mode - full depth
All six live signals, a per-agent view for fleets, and exportable reliability reports (PDF/JSON). Scale adds 90-day audit-grade boundary & anomaly reports; Enterprise keeps unlimited history.
Readable decision trace
Every answer comes with a short, human-readable trace of why it decided what it did, so nothing it does is a black box.
Assurance report
Report real outcomes when you learn them and get your own error rate on answered turns, with a 95% upper bound, against your own budget. Built not to flatter - no verdict until there's enough data. It's what an AI-Act assessment or security review actually asks for.
Reliability & cost reports
A weekly reliability score per agent, plus cost analytics that show the tokens saved on confident turns - so the value is visible, not assumed.
In-browser Playground
Run a real turn from your dashboard and see the full decision trace - with the raw model beside the Soul-governed answer, so you can see exactly what the judgment layer changes. No key needed.
Safety & control
Keep it on-policy and on-facts
The controls that make an agent safe to point at real customers and regulated data - data never the model shouldn't see, answers checked against your own sources, and rules you set.
Tool-call & multi-agent guardrails
Before an agent calls a tool, moves money, or hands off to another agent, LEO Soul checks the risk and can hold or confirm - so autonomy doesn't mean acting on a confident guess.
PII redaction
Strip names, emails, card numbers and other sensitive data before the model ever sees the turn - a clean privacy boundary in front of any model.
RAG grounding check
Verify that an answer is actually supported by your own documents and sources, and flag it when it isn't - so retrieval-backed agents stop quietly making things up.
Industry policy packs
Drop-in rule sets for regulated domains (health, finance and more) that tune how strict the agent is, without writing policy from scratch.
Custom triage & governor policy
Tune the thresholds yourself - how cautious the fast path is, when to escalate, when to refuse - to match your own risk appetite.
Integrate in minutes
Built to drop into what you already run
LEO Soul runs in your backend, next to the model you already call. If your code can call an AI model, it can call LEO Soul too, usually with one line of code.
Drop-in OpenAI-compatible gateway
Already calling the OpenAI SDK? Point the base URL at LEO Soul's /v1 and every call routes through
the full decision loop, returning the response shape your code already parses. No new SDK, no rewrite.
Streaming that can't be retracted
Text streams as the model writes it, but LEO Soul holds each sentence until nothing can still change it - so you
never see a “sorry, ignore that”. stream=True keeps working.
Works with any model
OpenAI, Anthropic, Azure OpenAI, Bedrock, Ollama, or your own local models. LEO Soul is a layer on top, not a model, so you bring the key you already have. No token markup.
Official Python & JS SDKs
First-party clients for the two languages most agents are written in, plus a simple feedback endpoint to report real outcomes back for the Assurance report.
Signed escalation webhooks
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.
Integrations catalog
Connect LEO Soul to the tools you already run, from observability to alerting, through a growing catalog of first-party integrations.
Slack app
Bring LEO Soul into your own Slack workspace so your team can watch escalations and ask it questions where they already work.
Platform, security & enterprise
Built to the standard a serious company expects
Everything around the engine - secure by default, controllable, and transparent - so it clears procurement as easily as it clears a code review.
Two-factor authentication
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.
Scoped API keys
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.
Usage, alerts & export
Live analytics, proactive alerts at 80% and 100% of your quota, and one-click CSV export - a busy month never surprises you. (Advanced analytics from Pro, full from Scale.)
Account audit trail + compliance export
A tamper-evident record of account and admin actions, exportable to CSV/JSON for your compliance and security reviews.
SSO / SAML & SCIM
Single sign-on against your identity provider and automated user provisioning/de-provisioning through SCIM.
Self-hosted / on-prem
Run the Docker image entirely inside your own network - nothing leaves your boundary. Can run air-gapped; the license verifies offline. For strict data-residency and regulated environments.
Custom model backends, DPA/BAA & SLA
Bring your own model endpoints, sign a DPA/BAA, and get a dedicated engineer, an SLA, and a security review - managed by us or self-hosted, same engine either way.
Start free. Most of this is in the free plan.
Wrap one turn, keep your model and your data, and ship an agent that knows when not to answer.