AI assurance for production agents

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.

Runs in your VPC Python 3.13 appliance · 3.11+ SDK OpenTelemetry-native Air-gap capable
29Regulatory frameworks
32Built-in evaluators
2 linesTo instrument an agent
0Bytes leaving your VPC
Start in 14 days

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.

Try it hosted

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.
Try it hosted
Run it yourself

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.
Run it yourself
The AI evidence gap

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.

Your engineers want to ship. Governance that costs a sprint gets routed around. Sengol is two lines and a CI step.
Your risk team wants proof. Append-only, hash-chained records an outside party can verify.
Your business wants both. Ship agents into regulated workflows without waiting for a quarterly review.

Sengol is how you say yes to all three.

How it works

Four steps from agent to admissible evidence.

Every step is a Python call, a CLI command, an API route — and a signed record.

01

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()
02

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
03

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
04

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
Capabilities

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.
Read the guardrails guide
agent.py
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
Platform capabilities

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.

Regulatory frameworks

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.

OSFI E-23 Model risk SR 11-7 Fed / OCC / FDIC EU AI Act GDPR FINTRAC Part 6F PIPEDA HIPAA NIST AI RMF ISO/IEC 42001 OSFI B-10 Third party BCBS 239 SOX CCPA OCC 2011-12 SR 11-7
UK GDPR PRA SS1/23 FCA AI EBA ML IRB MAS TRM MAS FEAT PDPA Singapore SAMA AI Ethics PDPL Saudi Arabia RBI IT Governance IRDAI AI/ML DPDP India APRA CPG 234 US Treasury AI RMF

Adding a framework is one catalog.yaml entry — zero new Python classes. Your internal model-risk standard works exactly the same way.

Security & deployment

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.

Who Sengol is for

One chain of evidence. Three very different readers.

Chief Risk Officer · MRM

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
VP Engineering · ML Platform

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
Compliance · Model Validation

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
Frequently asked questions

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.

Start now

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.

Self-hosted Built in Canada Runtime controls Signed evidence