Prove your AI agents
are under control.
Sengol sits in front of your production AI agents. It blocks unsafe tool calls and responses, scores every model call, gates every deploy, and writes each decision as a signed, tamper-evident record an examiner can verify offline. It runs inside your own network. Governance says what should happen; Sengol proves what did.
Two ways to start. Same 14 days, same full capability.
One signup, then you choose: let us run your instance, or run it yourself. Nothing is held back in either path — every evaluator, every gate, every signed record.
We spin up your instance.
A private Sengol instance on our AWS, pre-loaded with a reference agent and sample evidence so there is something to look at straight away.
- No install — nothing to run locally, just a URL and a login.
- Full capability — every evaluator, the CI gate, the Console, offline verification.
- Destroyed at day 14 — synthetic data only; export what you want to keep first.
You run it, inside your network.
Docker Compose, Helm or Terraform, or pip install sengol — with a 14-day licence file. Your data never leaves your network, from the first request.
- Your infrastructure — your Postgres, your keys, your VPC or laptop.
- Same full capability — the trial licence unlocks everything, not a subset.
- Offline licence check — no phone-home, ever.
Dashboards score your agents. They don't prove anything.
When an examiner asks "show me the evidence for this AI agent", a trace viewer is not an answer. Sengol produces the artifact that is: the gate verdict and the record you submit are one signed object.
Sengol is how you say yes to all three.
Four steps from agent to admissible evidence.
Every step is a Python call, a CLI command, an API route — and a signed record.
Instrument
One call patches the Anthropic and OpenAI SDKs at class level. Every existing agent call is intercepted — no per-call changes. Or ingest OTel traces directly.
sengol.instrument()
Evaluate
Deterministic evaluators run first and stop the moment one returns CRITICAL. LLM judges then run concurrently — hallucination, PII, toxicity, tool misuse, adversarial robustness.
32 evaluators
Gate
Block the call inline before the user sees it, and block the deploy before it merges. The GitHub Action posts a verdict on the PR and exits non-zero on failure.
sengol gate
Prove
Each verdict is HMAC-signed, hash-chained, and mapped to the obligation it satisfies. Export an evidence pack and hand it to an auditor — they verify it with sengol-verify, a separate open-source tool with no dependency on Sengol and no licence to check.
sengol-verify
One platform, from the request to the regulator.
Runtime control, evaluation quality, cryptographic evidence, and access governance — designed as one chain, not four tools you integrate yourself.
Stop the bad call before it reaches the customer.
Guardrails run inline in the request path. CRITICAL failures block immediately; everything else is recorded and routed. Enforcement is a policy decision, not a code change.
- Pre- and post-call interception — patches the Anthropic and OpenAI SDKs; streaming responses are buffered and evaluated before delivery.
- Tool authorization allow-lists — per-agent policies block unauthorized tool calls, with a signed decision record on allow and block.
- Delegation limits — when one agent calls another, Sengol reconstructs the chain from your OpenTelemetry traces and stops it at a depth you set.
- MCP tool integrity — each tool definition is fingerprinted when you approve it. If it changes afterwards, the call is flagged CRITICAL.
import sengol
sengol.configure(
agent_id="kyc-triage-agent",
agent_version="2.4.0",
policies=["OSFI_E23", "PIPEDA"],
)
sengol.instrument() # every LLM call is now governed
# your existing code is unchanged
resp = client.messages.create(...)
# on a CRITICAL failure:
# BlockedError: PII_LEAKED — response withheld,
# signed AuditRecord #4,822 written
Evaluation that holds up as model validation.
Deterministic checks run first and short-circuit on CRITICAL, so you never pay for a judge call you don't need. LLM judges then fan out concurrently.
- 32 built-in evaluators — hallucination, faithfulness, PII, toxicity, refusal accuracy, explainability, adversarial robustness, AML typology, tool-call correctness.
- Trajectory evaluation — score the whole agent run, not just the final message: tool order, argument schemas, forbidden tools, intent resolution.
- Ensembles and repeat runs — unanimous, majority or weighted vote; repeat an LLM check N times and require M passes.
- Own your judge — your reviewers' signed decisions export as labelled training data; you train a candidate on your own ML platform, and Sengol calibrates it against the Judge Qualification Standard — the TPR, TNR and Cohen's κ thresholds you set — and promotes it by signed id. Sengol never trains a model.
$ sengol gate --controlbook osfi_e23.yaml \
--dataset-path suites/kyc.jsonl --min-pass 0.95
evaluating 128 cases · 11 evaluators
✓ PIIEvaluator 128/128
✓ FaithfulnessJudge 126/128
✓ ToolCallMatch 128/128
✗ AdversarialRobustness 121/128
pass rate 0.943 < min_pass 0.95
GATE FAILED · exit 1 · deploy blocked
128 signed AuditRecords written
Records anyone can verify — including people who don't trust you.
Every verdict is a signed, append-only record in a per-agent hash chain. Change one byte anywhere in the history and verification fails — loudly, and provably.
- HMAC-SHA256 hash chain — append-only, tamper-evident, with a canonical signed payload per record type.
- Ed25519 countersignatures — a second, asymmetric signature so a third party verifies without ever holding your secret.
- Timestamp anchoring — periodically a fingerprint of the chain is lodged with an independent timestamp authority (RFC 3161) and a public transparency log (Rekor), proving the records existed at that time.
- Offline verification — export a portable bundle and verify it with
sengol-verify. - Append-only Postgres store — tamper-evident by the hash chain and the signatures, not by trusting the storage vendor.
$ sengol-verify pack.json
bundle kyc-triage-agent · 2026-Q2
records 4,823
chain OK every prev_hash links
hmac OK 4,823 / 4,823 signatures
ed25519 OK countersignatures valid
anchors OK 3 Merkle roots · RFC 3161 + Rekor
tampered 0
VERIFIED — no live server contacted
Each regulation becomes a list of obligations.
Sengol compiles a framework into obligations, routes each obligation to the evaluators that satisfy it, and keeps the evidence bound to the exact control that ran.
- 29 frameworks out of the box — OSFI E-23, SR 11-7, EU AI Act, GDPR, HIPAA, FINTRAC, MAS, SAMA, APRA, ISO 42001, NIST AI RMF and more.
- Bring your own policy — an internal standard is one YAML entry. No new code, same signed evidence, same reports.
- Cross-framework crosswalk — one control node maps to many regimes, so a single run answers OSFI and the AI Act at once.
- Obligation coverage, live — see which obligations are covered, by which evaluator, by which record — and which are not.
- Reports for the regulator — a JSON evidence pack and a PDF written for the risk committee, both driven by your ControlBook: the file where you declare which controls apply to which agent, and what passing means.
policy_id: OSFI_E23
mappings:
- obligation: E23-3.3 # explainability
evaluators: [ExplainabilityEvaluator]
severity: HIGH
coverage_required: true
pass_rate: 0.95
- obligation: E23-6.1 # ongoing monitoring
evaluators: [DriftMonitorPresent]
severity: CRITICAL
coverage_required: true
# every record carries the obligation it satisfied
Who can do what, provable after the fact.
Sengol enforces who may approve what, records it, and signs it.
- SSO and provisioning — OIDC and SAML 2.0 sign-in, SCIM 2.0 user lifecycle, IdP group-to-role mapping re-derived on every login.
- Segregation of duties — maker–checker on every promotion: the person who builds a judge cannot be the one who promotes it. Overrides require a reason and a signed record.
- Scoped access — an auditor for one line of business sees only that line of business, enforced in the query rather than hidden in the screen.
- Independent challenge — an E-23 style validator review, carried out by someone who had no hand in building the agent, and the record proves it.
- Retention and erasure — statutory retention floors the store enforces, and GDPR/PIPEDA tombstone erasure that purges the data without breaking the chain.
$ sengol judge promote --record-id jmc_91f2 \
--approver alice@bank.example
model card verified gate passed
TPR 0.94 TNR 0.92 κ 0.71 PC 0.88
checking segregation of duties…
validate actor bob@bank.example
promote actor alice@bank.example
✓ distinct actors · maker-checker satisfied
APPROVED · PromotionDecisionRecord signed
mfa_asserted=true · acr=urn:mace:...:mfa
The rest of what an examiner asks for.
CI/CD gate with PR verdicts
A GitHub Action runs your suite on every pull request, posts a comment with the verdict and coverage, and exits non-zero to block the merge. The gate verdict is the audit record — not a copy of it.
Human review queue & authority model
Escalation with SLAs, override authority by risk tier, and a versioned authority model whose status transitions are themselves signed records. Who may reverse a governance action — and what evidence that takes — is written down and versioned.
29 frameworks included. Your own policy is one entry away.
Sengol is not OSFI-specific. It is opinionated about OSFI E-23 because that is where it ships first.
Adding a framework is one catalog.yaml entry — zero new Python classes.
Your internal model-risk standard works exactly the same way.
Your perimeter. Your keys. Your data.
Sengol is an SDK first and a service second. The evidence chain is written to a store you own, in an environment you control. Nothing about the design requires your prompts or completions to reach us.
docker compose up
for a laptop. Helm and Terraform for AWS, Azure, GCP, OpenShift and on-prem.
Fully air-gapped, if that's the requirement.
-
Data residency by architecture
Evidence is written to your own Postgres, append-only. Judges can run entirely on models inside your VPC.
-
Signing keys you control
Local HMAC or AWS KMS-backed signing with rotation, so old records still verify after a key change.
-
Identity that survives review
OIDC, SAML 2.0, SCIM 2.0, RBAC with a "you cannot grant what you don't hold" invariant, TOTP MFA, and audited break-glass.
-
Built for scale
The API is stateless, so it runs safely at as many replicas as you need.
-
Retention and erasure
Statutory retention floors the store enforces, and tombstone erasure for data-subject requests. Erasure never breaks the chain.
One chain of evidence. Three very different readers.
Answer the examiner without a fire drill.
- Obligation coverage per agent, per period
- Independently verifiable evidence packs
- Declared authority and override model
- Independent challenge with enforced separation
Governance that doesn't cost you a sprint.
- Two lines at startup, no per-call changes
- SDK, CLI, REST API and GitHub Action
- Works with your existing OTel pipeline
- Self-host with Compose, Helm or Terraform
Evidence bound to the control that produced it.
- Every response scored against declared controls
- Human review queue with escalation SLAs
- Evidence bound to the obligation it satisfies
- Retention floors, defensible erasure
The ones we always get asked.
What is AI agent governance?
AI agent governance is the practice of controlling what an AI agent is allowed to do at runtime, evaluating what it actually did, and producing a record that proves both. In practice that means four things working together: policies declaring which tools and actions an agent may use, guardrails enforcing them inline before a response reaches a user, evaluators scoring each interaction for failures like PII leakage or hallucination, and an audit trail an independent party can verify. Observability tools cover the third; governance requires all four.
Governance and assurance are not the same thing. Governance is the regime — the policies, the committees, who decides what an agent may do. Assurance is the evidence that the regime actually held: the testing, the verification and the record an independent party can check. In the three-lines model, governance is written in the first line and assurance is what the second and third lines — model validation and internal audit — are accountable for. Sengol is built for the assurance side: governance says what should happen, assurance proves what did.
Does Sengol help with OSFI E-23 compliance?
Yes. OSFI Guideline E-23 on model risk management takes effect 1 May 2027 for federally regulated financial institutions in Canada, and extends to AI and machine-learning models. Sengol compiles E-23 into obligations, routes each one to the evaluators that satisfy it, and binds every signed record to the specific control that produced it — so coverage per agent and per period is a query, not a spreadsheet exercise. The same mechanism covers SR 11-7, the EU AI Act, FINTRAC, HIPAA and 24 other frameworks, and your own internal model-risk standard is one YAML entry.
How is Sengol different from an AI observability tool?
An observability tool tells you what happened. Sengol decides what is allowed to happen, and produces evidence of the decision. It blocks a CRITICAL failure inline before the user sees it, blocks a failing deploy before it merges, and writes each verdict as a hash-chained, cryptographically signed record that a third party can verify offline without access to your systems. The gate verdict and the record you hand an examiner are the same object, not two systems you reconcile.
How is this different from LangSmith, Arize or Galileo?
Those are developer observability tools — they help engineers debug agents faster, and they do it well. They produce dashboards and scores. Sengol produces evidence: a signed, hash-chained, offline-verifiable record bound to the specific obligation it satisfies, plus the runtime controls that decide what happens next.
Does any of my data leave my infrastructure?
Not by design. The SDK writes to an audit store you own — your own Postgres — in your own environment. Deploy with Docker Compose, Helm or Terraform inside your VPC, or fully air-gapped. If you use a hosted LLM judge, that provider sees the judge prompt; run a local model instead and nothing leaves at all.
What does "cryptographically signed evidence" actually mean here?
Each record has a canonical payload signed with HMAC-SHA256 and linked to the previous record in a per-agent hash chain, so the store is append-only and tamper-evident. Records are additionally countersigned with Ed25519 and periodically Merkle-anchored to an RFC 3161 timestamp authority and Rekor. A third party can verify an exported bundle offline, with the public key alone — no access to your systems or your secret.
My regulator isn't on your list. Now what?
Add it. A framework in Sengol is a catalog entry with obligations and evaluator routing — no new Python classes. That is exactly how internal bank policies and regional regimes are supported, and they get the same compiled obligations, the same signed evidence and the same reports as the 29 that ship in the box.
How long does integration actually take?
Runtime instrumentation is two lines at process startup — sengol.configure() and sengol.instrument() — with no per-call changes to your agent code. The CI gate is one workflow step. Mapping your controls into a ControlBook is the part that takes real thought, and it is the part that produces the evidence.
Is there a free tier, or feature tiers?
No. Sengol is proprietary software from version 2.0 and there is no free tier and no feature tiers: one licence unlocks the whole appliance — the SDK, every evaluator, the signed audit store, the Console, the CLI and CI gate, judge governance, ControlBook-driven reports, and the Docker Compose, Helm and Terraform installs, air-gapped or not. The 14-day trial is the full product. The one exception runs the other way: sengol-verify, the offline verifier, is a separate Apache-2.0 tool that needs no licence at all.
Your teams ship. Sengol keeps agents in bounds.
Declare your controls once. Sengol makes them executable, verifiable, and defensible in production. 14 days, full capability, either way.