Repository navigation
Why IGL
AI agents are moving from answering questions to doing things: filing reports, moving money, changing records, talking to other agents. Every one of those actions is taken on someone's behalf, under some authority, for some reason. Today almost none of that is written down in a way that can be enforced before the action or proven after it.
The usual answer is a policy document and a log file. A policy document cannot stop an action at run time. A log file can be edited, lost, or never written. When something goes wrong, the question "who allowed this, and what exactly happened" turns into a week of guesswork.
IGL closes that gap by putting the rules and the record inside the computation itself. Identity, boundary and intent are declared before anything runs, checked by the runtime, and written to a signed journal as it happens. If the declaration is missing, the program does not run. If the action is outside the boundary, it does not run. If the journal is altered later, it refuses to load.
You can hand real work to an AI system and still answer, at any moment, four questions about any action it took: who did it, under what authority, why, and what the outcome was. The answers are not in a slide deck; they are in a receipt the system produced at the time, signed with a key you can check.
Three practical consequences follow. First, incidents stop being investigations and become lookups. Second, you can give a customer, a regulator or an auditor proof of one action without opening the whole system to them, because a single journal entry can be proven against a published root. Third, you can let different applications see different slices of the same identity, each limited to a declared purpose, with consent and jurisdiction enforced on every request.
You get a small language with a hard rule, and a hosted API that applies the same rule to identity data.
In the language, a statement names an actor and a boundary, states its intent, declares which steps are deterministic and which call a pinned model, and ends in an output. Anything else fails the static check. At run time the interpreter does two-phase commit: nothing material is produced until the trace is durable, and nothing files without a human attestation when the statement says one is required.
On the platform, every request carries a key bound to an identity and a tenant. Reads of identity data go through a purpose profile and four gates. Writes are audited into a per-tenant hash chain. Intelligence operations assemble their context from records the caller is allowed to see and must cite them, or the service answers 422 instead of guessing. All 46 operations are described once in an OpenAPI 3.1 contract, and the conformance suite checks every response against it on every deploy.
Three things arrived together. Capable models now run locally and cheaply, so there will be millions of agents, not thousands. Model vendors have standardized how an assistant calls tools (MCP), so agents reach into real systems through one door. And the regulatory direction in every major market is toward explaining automated decisions, not merely logging them.
Each previous wave of computing produced a control layer once the raw capability was everywhere: a scheduler for compute, a ledger for value, an orchestrator for workloads. Intelligence is at that point now. IGL is a bet that the control layer belongs in the grammar, not in a dashboard bolted on afterwards.
It is not a content filter, and it is not a model. It does not decide whether an answer is good; it decides whether the actor was allowed to ask, what records the answer may draw on, and it proves what was returned. It is not a replacement for your identity provider; it sits beside it and governs what happens after sign-in. And it is not finished: the runtime is marked experimental, the platform contract is version 0.2, and the security audit lists what has been fixed and what is still open.
Build something in five minutes with Quickstart: the API. See the enforcement model in Core Concepts. Read the founder's longer argument in Identity Governed Logic.