Build with the IGL API Transform Identity into Governed Intelligence
01Applications are built on IGL.
02IGL is delivered through the IGL API.
03Identity becomes governed intelligence.
Most AI systems understand prompts.IGL understands identity, authority, context, policy, evidence, and outcomes.
Rather than treating identity as authentication, Identity Governed Logic transforms identity into a governed intelligence asset that continuously expands through interaction, learning, and outcomes.
Five layers, one governed path
Customer applications sit on the IGL API. The API is the product: sixteen service groups over six governed graphs, specified as an OpenAPI 3.1 contract, reasoned over by the models and agents you choose, grounded in the enterprise data you already hold.
Customer Applications
built on IGLIGL API Layer
the product · one base URL, sixteen service groups · OpenAPI 3.1 v0.2/identities/purposes · /projection/authority/knowledge/policies/evidence/outcomes/graph/query/research/crosswalk/investigate/agents/workflows/runs/audit/health · /capabilities/authority/knowledge/policy/evidence/outcomes/query/research/agents/workflows/audit/graphIGL Intelligence Layer
six governed graphs · the compounding assetReasoning & Orchestration
interchangeable · the model can change, the asset staysEnterprise Data Sources
where the organization's knowledge already livesBuild with the IGL API
Each graph is exposed as a REST service. Write to it from your application; read from it in your agents; every call is governed, attributed and recorded.
Identity API /identities
- Identity resolution across person, organization, system, agent, asset, place, document, program, course and product
- Governed context accumulation: interests, goals, expertise, constraints, observations
- Relationship mapping with confidence and effective dates
- Purpose-bounded projections with per-node gate explanations, obligations with attested or proposed status (v0.2)
Knowledge API /knowledge
- Organizational memory
- Entity management
- Governed facts
- seed → proposed → certified
Authority & Policy /authority · /policies
- allow · deny · conditional · escalate
- Required approvals
- Rule enforcement
- Decision authority
Evidence API /evidence
- Source attribution
- Provenance
- Corroboration counts
- Auditability
Outcome API /outcomes
- Decision tracking
- Outcome measurement
- Feedback loops
- Continuous learning
Graph API /graph
- Multi-hop paths, up to 12
- Relationship discovery
- Point-in-time asOf
- Confidence floors
Audit API /audit
- Hash-chained events
- Governance receipts
- Immutable activity
- Capability discovery
Intelligence API /query · /research · /crosswalk · /investigate
One request shape for all four. Answers return with citations, entities, graph paths, findings and a governance receipt. Long runs return 202 and a run to poll. Especially important for TortGraph, LeaseXPlorer, RealStar, VDRPros and Lamar.
Agents & Workflows /agents · /workflows · /runs
- Agents registered with capabilities, allowed tools, policies and model routing
- Workflow steps: query, research, agent, human_approval, policy_check, tool, transform, outcome
- Runs that pause in awaiting_approval and fire the approvalRequired webhook
42 paths · 46 operations · 63 schemas · 3 webhooks · OAuth 2.0 scopes and API key · tenant-boundary headers · purpose-bounded projections since v0.2. Full reference under Documentation; the contract is model-agnostic, so Claude, Moonshot or another reasoning model can run beneath it without changing how applications call it.
Ten steps, and the last one feeds the first
Where the intelligence lives
Traditional SaaS stores records. Traditional AI generates responses. IGL puts a governed graph between the application and the model, so what the organization learns stays with the organization.
Traditional SaaS
Traditional AI
Identity Governed Logic
| Traditional AI | Identity Governed Logic |
|---|---|
| Understands prompts | Understands identity |
| Produces responses | Produces governed intelligence |
| Learns inside the model | Learns inside the organization |
| Limited organizational memory | Persistent organizational memory |
| Answers questions | Improves future decisions |
| Temporary interactions | Compounding intelligence asset |
IGL is not another application.IGL is a Governed Identity Platform and API framework.
It allows organizations to build intelligence systems where identity, authority, knowledge, policy, evidence, and outcomes continuously compound into a strategic asset.
IGL Governed Identity Platform
Build with the IGL API. Transform Identity into Governed Intelligence.
The simplest way to think about IGL
Three stacks. The first stores records, the second generates answers, the third turns every interaction into organizational intelligence that stays with you.
Traditional Software
The application stores records. It does not understand relationships, decisions, outcomes, or context beyond what developers explicitly program.
Traditional AI
The AI generates an answer. The conversation has value in the moment, but very little becomes a permanent organizational asset. The intelligence largely remains inside the model provider.
Identity Governed Logic
Now every interaction expands organizational intelligence.
The same question, two very different answers
A compliance lead at an operator asks one question. Here is what happens in a conventional system, and what happens when the question enters the IGL runtime.
Traditional compliance software
What filings are due next month?
That's it.
IGL Compliance Intelligence
What filings are due next month?
Identity GET /identities/{identityId}
IGL understands who is asking.
- Who is asking
- Their responsibilities
- Their assets
- Their role
- Their authority
Authority POST /authority/evaluate
IGL determines the boundary of the answer before looking anything up.
- What the user can see
- What actions they can take
- What approvals are required
Knowledge POST /query
IGL retrieves the governed facts, not a keyword match.
- Wells
- Permits
- Reports
- Prior filings
- Regulatory obligations
Policy POST /policies/evaluate
IGL applies the rules that govern the recommendation.
- Company policy
- State regulations
- Internal controls
Evidence POST /evidence
Every recommendation is linked to what supports it.
- Source document
- Filing requirement
- Regulation
- Previous submission
Outcome POST /outcomes POST /outcomes/{outcomeId}/measurements
When the filing is completed, the result goes back into the graph.
- Result is captured
- Success is measured
- Future recommendations improve
The next compliance decision is better informed.
Most AI systems answer questions.IGL answers questions and learns from the results.
From search to a governed graph
Current tools are mostly search systems
IGL introduces a governed graph
Now one answer can expose hundreds of related facts. Not because the model memorized them. Because IGL already organized them.
From a conversation that ends to a user who becomes understood
Most AI remembers almost nothing
Ricorsa
The user becomes more understandable over time. The system develops continuity. The intelligence compounds.
Five kinds of logic before any AI response is generated
Most platforms have
IGL introduces
The result is explainable and auditable intelligence.
Five things the graph gives the organization
Model independence
Today:
- Claude
- OpenAI
- Moonshot
- Gemini
Tomorrow: something else.
The model becomes interchangeable. The intelligence stays with the customer.
Institutional memory
Organizations stop losing knowledge when:
- employees leave
- projects end
- systems change
- conversations disappear
The graph preserves context.
Explainability
Every answer can be linked to:
- sources
- evidence
- policies
- decisions
You can explain why an answer exists.
Governance
Every action can be governed by:
- permissions
- roles
- regulations
- approvals
- policies
Before execution occurs.
Cross-domain intelligence
The same architecture works for:
- Ricorsa
- WellSite
- LeaseXPlorer
- VDRPros
- TortGraph
- RealEChat
- RealStar
- Higher Education
Because the core problem is identical.
Organizations do not suffer from a lack of information.Organizations suffer from a lack of governed intelligence.
IGL is not really an AI platform.It is an Intelligence Infrastructure Platform.
SMEs, universities, energy operators, law firms, brokerages, and enterprises can continuously accumulate intelligence that remains theirs regardless of which AI model powers the reasoning layer.
Build on governed identity projections
IGL hands your application a projection of a person's identity graph, bounded by a purpose profile, a consent record and a cross-border policy. This guide covers the MCP tools and purposes for model callers, and the full REST contract (OpenAPI 3.1, v0.2.0) for applications.
Quickstart
Connect the igl_identity_mcp server with an API key and tenant id from the Developer Console (the same headers the REST contract uses), then call whoami before any task that depends on knowing the person. The answer is one their organization has governed, so it saves asking.
# mcp.json { "mcpServers": { "igl_identity_mcp": { "url": "https://api.id-me.ai/v1/mcp", "headers": { "X-IGL-API-Key": "igl_live_…", "X-IGL-Tenant-Id": "e7bcde63-4ccd-4594-aa64-6de1cce72ae8" } } } } # first call whoami({ purpose: "identity-introduction" }) → { name: "Maria Santos", role: "Compliance Lead", employer: "Rio Diablo Operating", jurisdiction: "US-TX", truncated: false } # the same resolution over REST (v0.2) GET /identities/me?purpose=identity-introduction → Projection { nodes: Person · Role · Organization · Jurisdiction, withheld: { Credential: 2, Obligation: 3, Facility: 1 }, truncated: false, governance: receipt }
What you get is a projection, not the graph
The context you receive is deliberately partial. Every node is admitted through four gates in order: node type, sensitivity, consent, jurisdiction. The first failure is the reason a node is missing.
Absence of a fact is not evidence the fact is false. If someone asks about something the projection does not contain, say you do not have it in this context, not that it does not exist.
Proposed relationships are excluded. Anything not attested by a human never reaches the model, and that is correct behaviour, not a gap to work around.
Purposes
Ask for the purpose that matches the task, not the widest one available. You get less context, which is the point. list_purposes returns what each permits; read it rather than guessing from the name.
| Purpose | Admits | Typical use |
|---|---|---|
| identity-introduction | Name, role, employer, jurisdiction | The default. Greeting, routing, addressing the person correctly. |
| directory-lookup | Name and title only | Rosters, mentions, org charts. |
| scientific-research | Adds credentials, occupational codes, facilities | Qualification checks, study eligibility. |
| regulatory-filing | Adds obligations and the facilities that trigger them | Deadline tracking, filing preparation. |
The seven tools
Each tool has a REST equivalent since v0.2, so an application and the model it hosts read the same projection under the same purpose.
| Tool | What it does | REST equivalent (v0.2) |
|---|---|---|
| whoami | Resolves the calling person under a purpose and returns their projection. | GET /identities/me?purpose= |
| list_purposes | Lists the purpose profiles available to this key and what each admits. | GET /purposes |
| get_identity_context | Projects a named identity under a purpose, with node budget and depth. | GET /identities/{id}/projection |
| list_obligations | What the person owes to whom by when, each carrying attested or proposed status. | GET /identities/{id}/obligations |
| explain_projection | Every node considered, with the four gates it passed or failed. | GET /identities/{id}/projection/explain |
| search_graph | Finds people, organizations, facilities and credentials inside the admitted projection. | GET /identities?q= · POST /graph/paths |
| record_interaction | Records what the model did with the projection. Metadata only. | POST /audit/interactions |
Four things that change what you should say
truncated: true— the node budget bound before traversal finished. Say the context is incomplete rather than reasoning confidently over it.empty_warning— no nodes admitted at all. The identity exists; the context does not. Usually no consent covers this purpose.- Proposed relationships are excluded. You will not see them. Do not work around it.
- Obligation
status.attestedmeans a human reviewed it and it is a real deadline.proposedmeans the system computed it and nobody has checked. Never present a proposed obligation as a confirmed date.
Explaining a projection
When someone asks "how do you know that?" or "why don't you know that?", call explain_projection. Pass the reason through rather than paraphrasing it. "Your purpose profile does not permit Credential nodes" is actionable; "I don't have access" is not.
explain_projection({ purpose: "identity-introduction" })
→ { "node": "Obligation:Q3-W3-filing",
"gates": { nodeType: pass, sensitivity: pass,
consent: fail, jurisdiction: — },
"reason": "purpose profile does not permit Obligation nodes" }
Recording what you did
After doing something consequential on the person's behalf, call record_interaction, especially when you refused, or when the projection was incomplete and you proceeded anyway. It writes metadata only; the conversation is not captured.
record_interaction({
purpose: "identity-introduction",
outcome: "refused",
reason: "obligation status was proposed, not attested",
truncated: false })
What the server cannot do
It cannot change anything about governance. No profile edits, no consent grants, no attestation. That is the control plane's job, and the separation is deliberate: a model that can rewrite the policy governing it is not governed.
If a projection is too narrow for a legitimate task, tell the person which purpose or consent is missing so a human can widen it. Not find another route to the data.
API reference OpenAPI 3.1 · v0.2.0
What changed in v0.2. The MCP governance model is now in the REST contract. A new Projection service adds purpose profiles (GET /purposes), caller resolution (GET /identities/me), purpose-bounded projections with node budgets and a per-node gate explanation, obligations carrying attested or proposed status, read-only consent records, and interaction records (POST /audit/interactions). Every intelligence request accepts a purpose. The 34 v0.1 paths are unchanged.
Proposed API contract for Identity Governed Logic (IGL). The API exposes governed identity, authority, knowledge, policy, evidence, outcome, graph, query, research, agent, workflow, and audit services. It is model-agnostic: reasoning providers can be changed without changing the governed intelligence contract. Version 0.2 adds purpose-bounded projections: purpose profiles, identity projections with per-node gate explanations, obligations with attestation status, caller resolution, consent records, and interaction records, so applications and model callers share one governance model.
The contract covers 42 paths, 46 operations, 63 reusable schemas and 3 webhooks. The source of truth is the specification file itself: igl-openapi-v0.2.yaml (v0.1 kept for comparison).
| Server | URL |
|---|---|
| Production | https://api.id-me.ai/v1 |
| Sandbox | https://sandbox.id-me.ai/v1 |
Authentication, tenancy and conventions
OAuth 2.0 client credentials for workloads and authorization code for user-delegated access; an API key header is accepted on write endpoints that list it. Every governed call carries the tenant boundary header.
| Scope | Grants |
|---|---|
| igl.read | Read governed intelligence |
| igl.write | Create or update governed intelligence |
| igl.execute | Execute queries, agents, and workflows |
| igl.admin | Manage policies, authority, and platform configuration |
| Header / parameter | Required | Meaning |
|---|---|---|
| Authorization: Bearer | yes | OAuth 2.0 token from https://auth.id-me.ai/oauth2/token |
| X-IGL-API-Key | alt. | API key alternative where an operation lists apiKey |
| X-Request-Id | no | Caller-provided correlation identifier. |
| Idempotency-Key | no | Required by clients when safely retrying mutation requests. |
| X-IGL-Tenant-Id | yes | Governed tenant boundary. |
| cursor | no | Pagination: query parameter |
| limit | no | Pagination: query parameter |
Errors use application/problem+json (RFC 9457): type, title, status, traceId and optional field-level violations. 403 means the action was denied by authority or policy; 422 means the request was valid but could not be governed or executed; 429 carries Retry-After. Lists page with cursor and limit (max 200) and return page.nextCursor / page.hasMore.
# governed query from WellSite: obligations due in the next 30 days
curl -X POST https://sandbox.id-me.ai/v1/query \
-H "Authorization: Bearer $IGL_TOKEN" \
-H "X-IGL-Tenant-Id: e7bcde63-4ccd-4594-aa64-6de1cce72ae8" \
-H "Content-Type: application/json" \
-d '{ "question": "Which obligations are due for this asset in the next 30 days, who owns them, and what evidence is required?",
"scope": { "assetId": "95dcad56-20a5-4b65-b8e7-6bb3e91510a2" },
"maxHops": 4, "requireCitations": true, "minimumConfidence": 0.8 }'
Operations by service
Each row is one operation. The scope column is what the token must carry; public needs no credential.
Identity Resolve identities, context, and relationships.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| GET /identities | List or search identities | igl.read | — | 200 IdentityPage |
| POST /identities | Create an identity | igl.write or API key | IdentityCreate | 201 Identity |
| GET /identities/me | Resolve the calling identity under a purpose | igl.read | — | 200 Projection |
| GET /identities/{identityId} | Get an identity | igl.read | — | 200 Identity |
| PATCH /identities/{identityId} | Update identity attributes | igl.write or API key | object | 200 Identity |
| POST /identities/{identityId}/context | Append governed identity context | igl.write | IdentityContextAppend | 200 Identity |
| GET /identities/{identityId}/relationships | List identity relationships | igl.read | — | 200 RelationshipPage |
Projection Purpose-bounded projections of an identity: what a caller may see, why, and what was withheld.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| GET /purposes | List purpose profiles | igl.read | — | 200 PurposePage |
| GET /purposes/{purposeId} | Get a purpose profile | igl.read | — | 200 Purpose |
| GET /identities/{identityId}/projection | Project an identity under a purpose | igl.read | — | 200 Projection |
| GET /identities/{identityId}/projection/explain | Explain a projection, node by node | igl.read | — | 200 ProjectionExplanation |
| GET /identities/{identityId}/obligations | List obligations in scope for an identity | igl.read | — | 200 ObligationPage |
| GET /identities/{identityId}/consents | List consent records for an identity | igl.read | — | 200 ConsentPage |
Authority Evaluate access, roles, delegations, and decision authority.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /authority/evaluate | Evaluate authority for an action | igl.execute | AuthorityEvaluateRequest | 200 AuthorityDecision |
Knowledge Create and retrieve governed entities and facts.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /knowledge/entities | Create a governed knowledge entity | igl.write | KnowledgeEntityCreate | 201 KnowledgeEntity |
| GET /knowledge/entities/{entityId} | Get a knowledge entity | igl.read | — | 200 KnowledgeEntity |
| GET /knowledge/facts | Search governed facts | igl.read | — | 200 FactPage |
| POST /knowledge/facts | Create a governed fact | igl.write | FactCreate | 201 Fact |
Policy Create policies and evaluate governed actions.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /policies | Create a policy | igl.admin | PolicyCreate | 201 Policy |
| GET /policies/{policyId} | Get a policy | igl.read | — | 200 Policy |
| POST /policies/evaluate | Evaluate active policies | igl.execute | PolicyEvaluateRequest | 200 AuthorityDecision |
Evidence Capture provenance, citations, corroboration, and findings.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| GET /evidence | List evidence | igl.read | — | 200 EvidencePage |
| POST /evidence | Create evidence or a finding | igl.write | EvidenceCreate | 201 Evidence |
| GET /evidence/{evidenceId} | Get evidence | igl.read | — | 200 Evidence |
| POST /evidence/{evidenceId}/corroborate | Corroborate or contradict evidence | igl.write | CorroborateRequest | 200 Evidence |
Outcomes Record decisions, actions, measurements, and feedback.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /outcomes | Record an outcome | igl.write | OutcomeCreate | 201 Outcome |
| GET /outcomes/{outcomeId} | Get an outcome | igl.read | — | 200 Outcome |
| POST /outcomes/{outcomeId}/measurements | Append an outcome measurement | igl.write | OutcomeMeasureRequest | 200 Outcome |
Graph Traverse and manage governed graph relationships.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /graph/relationships | Create a graph relationship | igl.write | RelationshipCreate | 201 Relationship |
| POST /graph/paths | Find governed multi-hop paths | igl.read | GraphPathRequest | 200 GraphPath[] |
| GET /graph/entities/{entityId}/neighbors | Get neighboring entities | igl.read | — | 200 RelationshipPage |
Intelligence Run governed queries, research, crosswalks, and investigations.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /query | Run a governed intelligence query | igl.execute | IntelligenceRequest | 200 IntelligenceResponse; 202 Run |
| POST /research | Run governed research | igl.execute | IntelligenceRequest | 200 IntelligenceResponse; 202 Run |
| POST /crosswalk | Run a multi-hop crosswalk | igl.execute | IntelligenceRequest | 200 IntelligenceResponse; 202 Run |
| POST /investigate | Run a governed investigation | igl.execute | IntelligenceRequest | 200 IntelligenceResponse; 202 Run |
Agents Register and invoke governed agents.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /agents | Register a governed agent | igl.admin | AgentCreate | 201 Agent |
| GET /agents/{agentId} | Get an agent | igl.read | — | 200 Agent |
| POST /agents/{agentId}/invocations | Invoke a governed agent | igl.execute | AgentInvokeRequest | 202 Run |
| GET /runs/{runId} | Get execution status and results | igl.read | — | 200 Run |
Workflows Define and run governed workflows.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| POST /workflows | Create a governed workflow | igl.admin | WorkflowCreate | 201 Workflow |
| POST /workflows/{workflowId}/runs | Run a governed workflow | igl.execute | WorkflowRunRequest | 202 Run |
Audit Retrieve immutable activity and runtime receipts.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| GET /audit/events | Search audit events | igl.read | — | 200 AuditEventPage |
| GET /audit/receipts/{receiptId} | Get a governance receipt | igl.read | — | 200 GovernanceReceipt |
| POST /audit/interactions | Record what a caller did with a projection | igl.write | InteractionRecordCreate | 201 InteractionRecord |
System Service health and capability discovery.
| Operation | Summary | Scope | Request | Response |
|---|---|---|---|---|
| GET /health | Check service health | public | — | 200 Health |
| GET /capabilities | Discover platform capabilities | igl.read | — | 200 Capabilities |
Webhooks
IGL calls your endpoint; reply 200 or 202. Payloads reuse the public schemas.
| Event | When | Payload |
|---|---|---|
| outcomeRecorded | An outcome was recorded or materially updated | Outcome |
| approvalRequired | A governed execution requires human approval | { runId, requirements } |
| graphUpdated | A certified graph entity or relationship changed | { eventType, resource, occurredAt } |
Examples from the specification
POST /query — WellSite · obligations due on an asset
{
"question": "Which obligations are due for this asset in the next 30 days, who owns them, and what evidence is required?",
"actor": {
"identityId": "b9d4507a-36ce-4d1b-970d-d85797141ff7",
"organizationId": "e7bcde63-4ccd-4594-aa64-6de1cce72ae8",
"roleIds": [
"07e7a6c8-30aa-4a22-85ba-61c3f024e401"
]
},
"scope": {
"assetId": "95dcad56-20a5-4b65-b8e7-6bb3e91510a2"
},
"filters": [
{
"field": "dueDate",
"operator": "between",
"value": [
"2026-10-06",
"2026-11-05"
]
}
],
"maxHops": 4,
"requireCitations": true,
"minimumConfidence": 0.8
}
POST /crosswalk — TortGraph · matter-independent silica crosswalk
{
"question": "Map the relationships among sites, products, manufacturers, witnesses, experts, and treaters.",
"scope": {
"matterIndependent": true,
"domains": [
"toxic-tort",
"silica"
]
},
"filters": [
{
"field": "relationship.status",
"operator": "in",
"value": [
"proposed",
"certified"
]
}
],
"maxHops": 6,
"asOf": "2026-10-06T00:00:00Z",
"requireCitations": true,
"minimumConfidence": 0.65
}
Schemas (63)
Required fields are marked; enumerations are listed inline. Status enumerations (seed → proposed → certified) are the governance ladder: nothing is certified without a human or a rule the organization controls.
Problem7 fields · 4 required
- type* string
- title* string
- status* integer
- detail string
- instance string
- traceId* string
- violations Violation[]
Violation3 fields
- field string
- code string
- message string
PageInfo2 fields · 1 required
- nextCursor string|null
- hasMore* boolean
ActorRef3 fields · 1 required
- identityId* string
- organizationId string|null
- roleIds string[]
SourceRef7 fields · 2 required
- sourceId* string
- sourceType* string document · database · api · web · email · transcript · human · system · other
- uri string|null
- title string|null
- retrievedAt string|null
- contentHash string|null
- locator string|null Page, line, paragraph, timestamp, row, or other pinpoint locator.
Provenance6 fields · 2 required
- createdAt* string
- createdBy* ActorRef
- sources SourceRef[]
- model string|null
- workflowRunId string|null
- policyDecisionIds string[]
IdentityType0 fields
- person · organization · system · agent · asset · place · document · program · course · product · other
Identity11 fields · 5 required
- id* string
- type* IdentityType
- displayName* string
- aliases string[]
- externalIds object
- attributes object
- status* string active · inactive · merged · restricted
- confidence number
- createdAt* string
- updatedAt string|null
- provenance Provenance
IdentityCreate6 fields · 2 required
- type* IdentityType
- displayName* string
- aliases string[]
- externalIds object
- attributes object
- source SourceRef
IdentityContextAppend4 fields · 2 required
- kind* string interest · goal · project · relationship · expertise · preference · constraint · observation · other
- value* any
- confidence number
- source SourceRef
Relationship11 fields · 5 required
- id* string
- fromId* string
- type* string
- toId* string
- direction string directed · undirected
- attributes object
- effectiveFrom string|null
- effectiveTo string|null
- confidence number
- status* string proposed · certified · rejected · superseded
- provenance Provenance
RelationshipCreate10 fields · 3 required
- fromId* string
- type* string
- toId* string
- direction string directed · undirected
- attributes object
- effectiveFrom string|null
- effectiveTo string|null
- confidence number
- status string proposed · certified
- sources SourceRef[]
AuthorityDecision7 fields · 3 required
- decisionId* string
- effect* string allow · deny · conditional · escalate
- reasonCodes string[]
- requiredApprovals ApprovalRequirement[]
- obligations string[]
- evaluatedAt* string
- policyDecisionIds string[]
ApprovalRequirement4 fields · 1 required
- authorityType* string
- roleId string|null
- identityId string|null
- count integer
AuthorityEvaluateRequest4 fields · 3 required
- actor* ActorRef
- action* string
- resource* ResourceRef
- context object
ResourceRef3 fields · 2 required
- type* string
- id* string
- attributes object
KnowledgeEntity3 fields
- …Identity all fields of Identity
- schemaType string
- summary string|null
KnowledgeEntityCreate3 fields · 1 required
- …IdentityCreate all fields of IdentityCreate
- schemaType* string
- summary string|null
Fact10 fields · 6 required
- id* string
- subjectId* string
- predicate* string
- object* any
- qualifiers object
- status* string seed · proposed · certified · rejected · superseded
- confidence* number
- validFrom string|null
- validTo string|null
- provenance Provenance
FactCreate9 fields · 3 required
- subjectId* string
- predicate* string
- object* any
- qualifiers object
- status string seed · proposed · certified
- confidence number
- validFrom string|null
- validTo string|null
- sources SourceRef[]
Policy10 fields · 6 required
- id* string
- name* string
- version* string
- description string|null
- effect* string allow · deny · conditional · escalate
- status* string draft · active · retired
- scope object
- rule* object Vendor-neutral policy expression object.
- effectiveFrom string|null
- effectiveTo string|null
PolicyCreate9 fields · 4 required
- name* string
- version* string
- description string|null
- effect* string allow · deny · conditional · escalate
- status string draft · active
- scope object
- rule* object
- effectiveFrom string|null
- effectiveTo string|null
PolicyEvaluateRequest5 fields · 3 required
- actor* ActorRef
- action* string
- resource* ResourceRef
- facts object
- requestedOutcome string|null
Evidence10 fields · 5 required
- id* string
- kind* string finding · citation · document · observation · testimony · measurement · other
- claim* string
- sources* SourceRef[]
- confidence number
- status* string seed · proposed · certified · disputed · rejected · superseded
- corroborationCount integer
- contradictionCount integer
- attributes object
- provenance Provenance
EvidenceCreate6 fields · 3 required
- kind* string finding · citation · document · observation · testimony · measurement · other
- claim* string
- sources* SourceRef[]
- confidence number
- status string seed · proposed · certified
- attributes object
CorroborateRequest4 fields · 1 required
- supportingEvidenceIds* string[]
- contradictingEvidenceIds string[]
- method string manual · rule · model · hybrid
- notes string|null
Outcome9 fields · 5 required
- id* string
- subjectId* string
- decisionId string|null
- type* string
- status* string expected · observed · validated · disputed · superseded
- value any
- metrics object
- occurredAt* string
- provenance Provenance
OutcomeCreate8 fields · 4 required
- subjectId* string
- decisionId string|null
- type* string
- status string expected · observed · validated
- value* any
- metrics object
- occurredAt* string
- sources SourceRef[]
OutcomeMeasureRequest5 fields · 3 required
- metric* string
- value* number|string|boolean
- unit string|null
- measuredAt* string
- source SourceRef
GraphPathRequest6 fields · 2 required
- fromId* string
- toId* string
- maxHops integer
- relationshipTypes string[]
- asOf string|null
- minimumConfidence number
GraphPath3 fields · 2 required
- nodes* Identity[]
- edges* Relationship[]
- score number
IntelligenceRequest10 fields · 1 required
- question* string
- actor ActorRef
- scope object
- filters Filter[]
- maxHops integer
- asOf string|null
- requireCitations boolean
- minimumConfidence number
- modelPreference string|null Optional routing preference; governance may override.
- purpose string|null Purpose profile id bounding every identity projection the run may read. Omitted: the key's default purpose.
Filter3 fields · 3 required
- field* string
- operator* string eq · ne · in · not_in · gt · gte · lt · lte · contains · exists · between
- value* any
IntelligenceResponse8 fields · 5 required
- requestId* string
- answer* string
- citations* SourceRef[]
- entities Identity[]
- paths GraphPath[]
- findings Evidence[]
- governance* GovernanceReceipt
- createdAt* string
GovernanceReceipt7 fields · 5 required
- receiptId* string
- actor* ActorRef
- authorityDecision* AuthorityDecision
- policiesEvaluated* string[]
- evidenceIds string[]
- outputHash string|null
- createdAt* string
Agent8 fields · 4 required
- id* string
- name* string
- description string|null
- status* string draft · active · suspended · retired
- capabilities* string[]
- allowedTools string[]
- policyIds string[]
- modelRouting object
AgentCreate6 fields · 2 required
- name* string
- description string|null
- capabilities* string[]
- allowedTools string[]
- policyIds string[]
- modelRouting object
AgentInvokeRequest5 fields · 1 required
- instruction* string
- actor ActorRef
- input object
- resourceScope ResourceRef[]
- requireApproval boolean
Run9 fields · 4 required
- id* string
- type* string agent · workflow · research · investigation
- status* string queued · running · awaiting_approval · succeeded · failed · cancelled
- createdAt* string
- startedAt string|null
- completedAt string|null
- output any
- error any
- governance any
Workflow6 fields · 5 required
- id* string
- name* string
- version* string
- status* string draft · active · retired
- steps* WorkflowStep[]
- policyIds string[]
WorkflowStep5 fields · 2 required
- id* string
- type* string query · research · agent · human_approval · policy_check · tool · transform · outcome
- config object
- onSuccess string|null
- onFailure string|null
WorkflowCreate5 fields · 3 required
- name* string
- version* string
- status string draft · active
- steps* WorkflowStep[]
- policyIds string[]
WorkflowRunRequest3 fields
- actor ActorRef
- input object
- dryRun boolean
AuditEvent11 fields · 5 required
- id* string
- eventType* string
- actor* ActorRef
- resource* ResourceRef
- action string
- occurredAt* string
- requestId string|null
- decisionId string|null
- details object
- previousHash string|null
- eventHash string|null
Health3 fields · 3 required
- status* string ok · degraded
- version* string
- time* string
Capabilities4 fields · 2 required
- apiVersion* string
- features* string[]
- modelProviders string[]
- maximumGraphHops integer
IdentityPage2 fields · 2 required
- items* Identity[]
- page* PageInfo
RelationshipPage2 fields · 2 required
- items* Relationship[]
- page* PageInfo
FactPage2 fields · 2 required
- items* Fact[]
- page* PageInfo
EvidencePage2 fields · 2 required
- items* Evidence[]
- page* PageInfo
AuditEventPage2 fields · 2 required
- items* AuditEvent[]
- page* PageInfo
Purpose6 fields · 3 required
- id* string
- name* string
- description string|null
- permits* string[] Node types this profile admits, e.g. Person, Role, Organization, Jurisdiction, Credential, Facility, Obligation.
- sensitivityCeiling string public · internal · confidential · restricted
- default boolean
PurposePage2 fields · 2 required
- items* Purpose[]
- page* PageInfo
ProjectionNode6 fields · 3 required
- id* string
- type* string
- label* string
- attributes object
- confidence number
- status string seed · proposed · certified
Projection9 fields · 7 required
- identityId* string
- purpose* string
- nodes* ProjectionNode[]
- edges* Relationship[] Certified relationships only. Proposed relationships never reach a projection.
- truncated* boolean True when the node budget bound before traversal finished; the context is incomplete.
- emptyWarning string|null Set when no nodes were admitted. The identity exists; the context does not. Usually no consent covers this purpose.
- withheld object Count of withheld nodes by node type. Use the explain endpoint for the reason per node.
- governance* GovernanceReceipt
- createdAt* string
GateResult3 fields · 2 required
- gate* string nodeType · sensitivity · consent · jurisdiction
- result* string pass · fail · skipped
- reason string|null Actionable, e.g. "purpose profile does not permit Obligation nodes". Pass it through rather than paraphrasing.
ProjectionExplanation4 fields · 3 required
- identityId* string
- purpose* string
- considered* object[]
- truncated boolean
Obligation11 fields · 5 required
- id* string
- subjectId* string
- title* string
- obligee string|null Who it is owed to: a regulator, a counterparty, an internal authority.
- facilityId string|null The facility or asset that triggers it, when one does.
- regulation string|null
- dueDate* string
- status* string attested · proposed attested: a human reviewed it and it is a real deadline. proposed: computed by the system, unchecked.
- attestedBy any
- attestedAt string|null
- evidenceIds string[]
ObligationPage2 fields · 2 required
- items* Obligation[]
- page* PageInfo
ConsentRecord9 fields · 5 required
- id* string
- identityId* string
- purpose* string
- grantedBy ActorRef
- scope string|null Applications or workspaces the grant covers.
- jurisdictions string[]
- status* string active · revoked · expired
- grantedAt* string
- expiresAt string|null
ConsentPage2 fields · 2 required
- items* ConsentRecord[]
- page* PageInfo
InteractionRecordCreate7 fields · 2 required
- identityId string|null The identity acted for. Omitted: the caller.
- purpose* string
- outcome* string completed · refused · proceeded_on_truncated · proceeded_on_empty · escalated
- reason string|null
- projectionReceiptId string|null
- runId string|null
- model string|null
InteractionRecord5 fields · 3 required
- …InteractionRecordCreate all fields of InteractionRecordCreate
- id* string
- actor* ActorRef
- recordedAt* string
- eventHash string|null
Priced per governed projection
Every plan includes all seven tools, the four purpose profiles and hash-chained journals. You pay for projections served, not for the size of the graph behind them.
Developer
For building and testing against a sandbox graph.
- 10,000 projections / month
- Sandbox identities and journals
- All purpose profiles
- Community support
Team Most chosen
For applications in production with real people in the graph.
- Unmetered whoami and list_purposes
- Production journals, chain verification
- Interaction records retained 13 months
- Email support, 1 business day
Enterprise
Your control plane, your jurisdictions, your signers.
- Dedicated control plane or on-premises
- Cross-border transfer policies per region
- Custom purpose profiles and signer registry
- Named support, 99.95% SLA
| Included | Developer | Team | Enterprise |
|---|---|---|---|
| Projections / month | 10,000 | Metered | Committed volume |
| Node budget per projection | 100 | 250 | Configurable |
| Purpose profiles | 4 standard | 4 standard | Standard + custom |
| Journal verification | Sandbox | Production | Production, exportable |
| Cross-border policy | — | Single region | Per region |
| Signer registry (Ed25519) | Shared | Shared | Your keys |
Plan figures shown are placeholders for this build; replace with the published rate card before launch. Pricing is visible to signed-in console users only. Back to console
Governance your auditors can recompute
Every projection, grant and interaction folds into a hash-chained journal. Fold it again under the same parameters and the digest matches byte for byte. Nothing is self-reported by the process that did the work.
Separated control plane
Purpose profiles, consent grants and attestation live in a control plane the model cannot reach. The MCP server can read a projection and record what was done with it. It cannot widen its own access.
Cross-border by policy
A transfer policy per jurisdiction gates every node before it crosses a border. A projection served in Texas and one served in Frankfurt differ by policy, not by configuration drift.
Keyed human attestation
Obligations and relationships become load-bearing only when a registered signer attests them with an Ed25519 receipt. Proposed items stay visibly proposed until then.
Deploy where the data lives
Dedicated cloud control plane, your VPC, or fully on-premises. Journals stay in your custody; verification runs anywhere the digest does.
Interaction records
Every consequential model action, refusals included, is written as metadata to the journal. Governance that records what the system decided but not what the model did has a hole in the middle.
Signer registry
Bring your own key registry. Rotate signers, revoke receipts, and keep a chain of custody from the person who attested to the projection that relied on it.
Talk to our sales team
Tell us what you're building and the scale you expect. A member of the team will reply within two business days to scope the right plan, and where it helps, provision a sandbox tenant seeded with your purpose profiles.
Good reasons to reach us
- Committed-volume pricing above 1 million projections a month
- Dedicated or on-premises control plane, per-region transfer policies
- Custom purpose profiles, your own signer registry
- Building one of the application categories on IGL: compliance, litigation, transaction, institutional, agents
security@id-me.aipartners@id-me.aipress@id-me.aiBuild against the contract
Two working tools. The API Explorer composes any of the 46 operations in OpenAPI v0.2 into a request you can run from your terminal or paste into code. The Projection Sandbox runs the four governance gates on a sample identity graph so you can see exactly what a purpose admits, what it withholds, and why. Nothing here calls a server; requests are composed locally and keys never leave this page.
Projection as JSON (schema: Projection)
| Node | Type | Node type | Sensitivity | Consent | Jurisdiction | Result |
|---|
What this console does and does not do
It reads the published OpenAPI v0.2 contract and builds requests, bodies, and response shapes from it, so what you copy is exactly what the contract requires: tenant header, idempotency key on mutations, scopes, and schema-correct examples.
It does not send requests. This page runs in a locked frame with no network path to an IGL server, and that is the right place for a credential to never go. Run the composed request from your terminal or your service.
Your identity, as IGL projects it
This is what an application sees when it calls whoami on your behalf, purpose by purpose. Grants and attestations are changed in the control plane by your organization's administrators, not here.
Maria Santos
Compliance Lead · Rio Diablo Operating
Projection preview
Choose a purpose to see which nodes an application receives.
Consent grants
| Purpose | Granted by | Scope | Status |
|---|---|---|---|
| identity-introduction | Self, 2026-08-16 | All applications | active |
| directory-lookup | Org admin, 2026-08-16 | Internal only | active |
| regulatory-filing | Org admin, 2026-08-19 | Filing assistant | active |
| scientific-research | — | — | not granted |
Recent interactions
Sign in to IGL
Your session is itself a governed identity.