IGL Studio scheduled for release November 5, 2026
Documentation

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.3.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",   # self-hosted: http://127.0.0.1:8787/mcp from npm run provision
    "headers": { "X-IGL-API-Key": "igl_live_...",
                 "X-IGL-Tenant-Id": "e7bcde63-4ccd-4594-aa64-6de1cce72ae8" } } } }

# first call
whoami({ purpose: "identity-introduction" })
 to Projection { nodes: [ Person "Maria Santos", Role "Compliance Lead",
                 Organization "Rio Diablo Operating", Jurisdiction "US-TX" ],
    withheld: { Credential: 2, Obligation: 3, Facility: 1 },
    truncated: false, governance: { receiptId } }

# the same resolution over REST (since v0.2)
GET /identities/me?purpose=identity-introduction
 to 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 behavior, 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.

PurposeAdmitsTypical use
identity-introductionName, role, employer, jurisdictionThe default. Greeting, routing, addressing the person correctly.
directory-lookupName and title onlyRosters, mentions, org charts.
scientific-researchAdds credentials, occupational codes, facilitiesQualification checks, study eligibility.
regulatory-filingAdds obligations and the facilities that trigger themDeadline 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. The subject controls added in v0.3 (pause, forget, reset, export) are deliberately not tools: a model cannot change what is learned about a person; the person does, through the application.

ToolWhat it doesREST equivalent
whoamiResolves the calling person under a purpose and returns their projection.GET /identities/me?purpose=
list_purposesLists the purpose profiles available to this key and what each admits.GET /purposes
get_identity_contextProjects a named identity under a purpose, with node budget and depth.GET /identities/{id}/projection
list_obligationsWhat the person owes to whom by when, each carrying attested or proposed status.GET /identities/{id}/obligations
explain_projectionEvery node considered, with the four gates it passed or failed.GET /identities/{id}/projection/explain
search_graphFinds people, organizations, facilities and credentials inside the admitted projection.GET /identities?q=, POST /graph/paths
record_interactionRecords 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. attested means a human reviewed it and it is a real deadline. proposed means 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" })
 to  { "node": "Obligation:Q3-W3-filing",
    "gates": { nodeType: pass, sensitivity: pass,
               consent: fail, jurisdiction: skipped },
    "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.

The person's controls

What the model cannot do, the person can, through the application. Since v0.3 the contract carries the four controls a person holds over what is learned about them, each a governed action with a signed receipt and an entry in the tenant's audit chain. Learning can be paused and resumed; while paused, anything that would add to the record is refused with 409 and what is known is still served. Any learned record (a fact, a relationship, a context entry) can be forgotten: it is emptied in place and leaves every projection, search, path and intelligence context at once, and the chain keeps the act and a SHA-256 of what it was, never the content. The learned graph can be reset. And the whole record can be exported in one signed document with a fingerprint and the lineage of chain events behind it.

# pause learning about a person
POST /identities/{identityId}/learning   { "paused": true, "reason": "the person asked" }

# forget two learned records; the response carries a tombstone per target and a receipt
POST /identities/{identityId}/forget     { "targets": [ { "type": "fact", "id": "..." }, { "type": "context", "id": "..." } ] }

# the whole record, with a fingerprint anyone can recompute and the lineage of chain events
GET  /identities/{identityId}/export
 to { fingerprint, fingerprintOf, identity, context, facts, relationships, obligations, consents,
      tombstones: [ { type, id, contentHash, forgottenAt } ], lineage: [ { seq, eventType, eventHash } ],
      governance: { receiptId, auditHead, signature } }

The controls are deliberately not MCP tools. A model reads the projection and records what it did; it never changes what is learned about a person. See docs/RICORSA.md for where these rules come from.

Open-source runtime

The runtime underneath the platform is public at github.com/SMEPro-Technologies-LLC/igl under Apache-2.0: the IGL language core, the hash-chained journal with Merkle inclusion proofs, signed receipts with runtime attestation, the governed decode bridge, and a provisioning service with an MCP endpoint. 151 tests; releases are tagged and signed. The platform contract on this page is versioned there as spec/openapi.yaml, and docs/PLATFORM.md maps runtime concepts (BOUNDARY and FOOTPRINT graphs, grants and observations) to the six graphs and purpose-bounded projections described here.

git clone https://github.com/SMEPro-Technologies-LLC/igl.git
cd igl && npm ci && npm test        # 151 tests
npm run provision                        # IGL Studio at http://127.0.0.1:8787, MCP at /mcp
npx --yes @redocly/cli@1 lint spec/openapi.yaml

API reference OpenAPI 3.1, v0.3.0

What changed in v0.3. The Subject service: the controls a person holds over what is learned about them, as governed operations. Learning can be paused and resumed (/identities//learning), any learned record can be forgotten (/forget: the record is emptied in place and the chain keeps the act and a SHA-256 of what it was, never the content), the learned graph can be reset (/reset), and the whole record can be exported in one signed document with a fingerprint and the lineage of chain events behind it (/export). Every one is policy-evaluated, receipted and chained. The 42 v0.2 paths are unchanged.

What changed in v0.2. The MCP governance model entered the REST contract: the Projection service with 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).

The 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. Version 0.3 adds the Subject service: the controls a person holds over what is learned about them, as governed operations with signed receipts. Learning can be paused and resumed, any learned record can be forgotten (the record is emptied in place and the chain keeps the act and a hash, never the content), the learned graph can be reset, and the whole record can be exported with a fingerprint and the lineage of chain events that produced it.

The contract covers 46 paths, 51 operations, 72 reusable schemas and 3 webhooks. The source of truth is the specification file in the repository, spec/openapi.yaml, also served here as igl-openapi.yaml. Earlier versions are in the repository history.

ServerURL
Productionhttps://api.id-me.ai/v1
Sandboxhttps://sandbox.id-me.ai/v1

Authentication, tenancy and conventions

Every call carries a credential and the tenant boundary header. The credential is an API key sent as the bearer token, or a one-hour EdDSA access token minted from that key at the token endpoint (OAuth 2.0 client credentials: the key id is the client id and the key is the secret) when a workload should hold narrower scope than the key. The X-IGL-API-Key header is accepted on the operations that list it. A credential in the query string is ignored.

ScopeGrants
igl.readRead governed intelligence
igl.writeCreate or update governed intelligence
igl.executeExecute queries, agents, and workflows
igl.adminManage policies, authority, and platform configuration
Header / parameterRequiredMeaning
Authorization: BeareryesAn API key, or an access token from https://auth.id-me.ai/oauth2/token (sandbox: https://sandbox.id-me.ai/oauth2/token)
X-IGL-API-Keyalt.API key alternative where an operation lists apiKey
X-Request-IdnoCaller-provided correlation identifier.
Idempotency-KeynoCaller-chosen key for a mutation. The same key and body replays the stored response; the same key with a different body is refused with 409.
X-IGL-Tenant-IdyesGoverned tenant boundary.
cursornoPagination: query parameter
limitnoPagination: 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.

OperationSummaryScopeRequestResponse
GET /identitiesList or search identitiesigl.readnone200 IdentityPage
POST /identitiesCreate an identityigl.write or API keyIdentityCreate201 Identity
GET /identities/meResolve the calling identity under a purposeigl.readnone200 Projection
GET /identities/{identityId}Get an identityigl.readnone200 Identity
PATCH /identities/{identityId}Update identity attributesigl.write or API keynone200 Identity
POST /identities/{identityId}/contextAppend governed identity contextigl.writeIdentityContextAppend200 Identity
GET /identities/{identityId}/relationshipsList identity relationshipsigl.readnone200 RelationshipPage

Projection Purpose-bounded projections of an identity: what a caller may see, why, and what was withheld.

OperationSummaryScopeRequestResponse
GET /purposesList purpose profilesigl.readnone200 PurposePage
GET /purposes/{purposeId}Get a purpose profileigl.readnone200 Purpose
GET /identities/{identityId}/projectionProject an identity under a purposeigl.readnone200 Projection
GET /identities/{identityId}/projection/explainExplain a projection, node by nodeigl.readnone200 ProjectionExplanation
GET /identities/{identityId}/obligationsList obligations in scope for an identityigl.readnone200 ObligationPage
GET /identities/{identityId}/consentsList consent records for an identityigl.readnone200 ConsentPage

Subject The controls a person holds over what is learned about them: pause, forget, reset, export. Every one is a governed action with a signed receipt and a chain entry.

OperationSummaryScopeRequestResponse
GET /identities/{identityId}/learningRead whether learning about an identity is pausedigl.readnone200 LearningState
POST /identities/{identityId}/learningPause or resume learning about an identityigl.writeLearningStateChange200 LearningState
POST /identities/{identityId}/forgetForget learned records about an identityigl.writeForgetRequest200 ForgetResult
POST /identities/{identityId}/resetReset the learned graph of an identityigl.writeResetRequest200 ForgetResult
GET /identities/{identityId}/exportExport the whole record of an identityigl.readnone200 IdentityExport

Authority Evaluate access, roles, delegations, and decision authority.

OperationSummaryScopeRequestResponse
POST /authority/evaluateEvaluate authority for an actionigl.executeAuthorityEvaluateRequest200 AuthorityDecision

Knowledge Create and retrieve governed entities and facts.

OperationSummaryScopeRequestResponse
POST /knowledge/entitiesCreate a governed knowledge entityigl.writeKnowledgeEntityCreate201 KnowledgeEntity
GET /knowledge/entities/{entityId}Get a knowledge entityigl.readnone200 KnowledgeEntity
GET /knowledge/factsSearch governed factsigl.readnone200 FactPage
POST /knowledge/factsCreate a governed factigl.writeFactCreate201 Fact

Policy Create policies and evaluate governed actions.

OperationSummaryScopeRequestResponse
POST /policiesCreate a policyigl.adminPolicyCreate201 Policy
GET /policies/{policyId}Get a policyigl.readnone200 Policy
POST /policies/evaluateEvaluate active policiesigl.executePolicyEvaluateRequest200 AuthorityDecision

Evidence Capture provenance, citations, corroboration, and findings.

OperationSummaryScopeRequestResponse
GET /evidenceList evidenceigl.readnone200 EvidencePage
POST /evidenceCreate evidence or a findingigl.writeEvidenceCreate201 Evidence
GET /evidence/{evidenceId}Get evidenceigl.readnone200 Evidence
POST /evidence/{evidenceId}/corroborateCorroborate or contradict evidenceigl.writeCorroborateRequest200 Evidence

Outcomes Record decisions, actions, measurements, and feedback.

OperationSummaryScopeRequestResponse
POST /outcomesRecord an outcomeigl.writeOutcomeCreate201 Outcome
GET /outcomes/{outcomeId}Get an outcomeigl.readnone200 Outcome
POST /outcomes/{outcomeId}/measurementsAppend an outcome measurementigl.writeOutcomeMeasureRequest200 Outcome

Graph Traverse and manage governed graph relationships.

OperationSummaryScopeRequestResponse
POST /graph/relationshipsCreate a graph relationshipigl.writeRelationshipCreate201 Relationship
POST /graph/pathsFind governed multi-hop pathsigl.readGraphPathRequest200 GraphPath[]
GET /graph/entities/{entityId}/neighborsGet neighboring entitiesigl.readnone200 RelationshipPage

Intelligence Run governed queries, research, crosswalks, and investigations.

OperationSummaryScopeRequestResponse
POST /queryRun a governed intelligence queryigl.executeIntelligenceRequest200 IntelligenceResponse; 202 Run
POST /researchRun governed researchigl.executeIntelligenceRequest200 IntelligenceResponse; 202 Run
POST /crosswalkRun a multi-hop crosswalkigl.executeIntelligenceRequest200 IntelligenceResponse; 202 Run
POST /investigateRun a governed investigationigl.executeIntelligenceRequest200 IntelligenceResponse; 202 Run

Agents Register and invoke governed agents.

OperationSummaryScopeRequestResponse
POST /agentsRegister a governed agentigl.adminAgentCreate201 Agent
GET /agents/{agentId}Get an agentigl.readnone200 Agent
POST /agents/{agentId}/invocationsInvoke a governed agentigl.executeAgentInvokeRequest202 Run
GET /runs/{runId}Get execution status and resultsigl.readnone200 Run

Workflows Define and run governed workflows.

OperationSummaryScopeRequestResponse
POST /workflowsCreate a governed workflowigl.adminWorkflowCreate201 Workflow
POST /workflows/{workflowId}/runsRun a governed workflowigl.executeWorkflowRunRequest202 Run

Audit Retrieve immutable activity and runtime receipts.

OperationSummaryScopeRequestResponse
GET /audit/eventsSearch audit eventsigl.readnone200 AuditEventPage
GET /audit/receipts/{receiptId}Get a governance receiptigl.readnone200 GovernanceReceipt
POST /audit/interactionsRecord what a caller did with a projectionigl.writeInteractionRecordCreate201 InteractionRecord

System Service health and capability discovery.

OperationSummaryScopeRequestResponse
GET /healthCheck service healthpublicnone200 Health
GET /capabilitiesDiscover platform capabilitiesigl.readnone200 Capabilities

Webhooks

IGL calls your endpoint over https and expects 200 or 202; payloads reuse the public schemas. Subscriptions are registered per tenant with POST /admin/webhooks (a platform or admin credential), which returns the signing secret once. Every delivery carries X-IGL-Event, X-IGL-Delivery and X-IGL-Signature: t=<unix seconds>,v1=<HMAC-SHA256(secret, t + "." + body)>; verify the signature and reject stale timestamps. A delivery that does not get a 2xx is retried twice more with backoff and every attempt is recorded.

EventWhenPayload
outcomeRecordedAn outcome was recorded or materially updatedOutcome
approvalRequiredA governed execution requires human approval{ runId, requirements }
graphUpdatedA certified graph entity or relationship changed{ eventType, resource, occurredAt }

Examples from the specification

GET /identities/me: response 200

{
  "identityId": "b9d4507a-36ce-4d1b-970d-d85797141ff7",
  "purpose": "identity-introduction",
  "nodes": [
    {
      "id": "b9d4507a-36ce-4d1b-970d-d85797141ff7",
      "type": "Person",
      "label": "Maria Santos",
      "status": "certified"
    },
    {
      "id": "6b1d3e2a-5a51-4b0c-9a7e-0a2c0e3f9c11",
      "type": "Role",
      "label": "Compliance Lead",
      "status": "certified"
    },
    {
      "id": "e7bcde63-4ccd-4594-aa64-6de1cce72ae8",
      "type": "Organization",
      "label": "Rio Diablo Operating",
      "status": "certified"
    },
    {
      "id": "3d2c1b0a-9f8e-4d7c-b6a5-4e3d2c1b0a99",
      "type": "Jurisdiction",
      "label": "US-TX",
      "status": "certified"
    }
  ],
  "edges": [],
  "truncated": false,
  "withheld": {
    "Credential": 2,
    "Obligation": 3,
    "Facility": 1
  },
  "governance": {
    "receiptId": "0c1d2e3f-4a5b-4c6d-8e9f-0a1b2c3d4e5f",
    "actor": {
      "identityId": "b9d4507a-36ce-4d1b-970d-d85797141ff7"
    },
    "authorityDecision": {
      "decisionId": "1a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d",
      "effect": "allow",
      "evaluatedAt": "2026-10-14T14:02:11Z"
    },
    "policiesEvaluated": [],
    "createdAt": "2026-10-14T14:02:11Z"
  },
  "createdAt": "2026-10-14T14:02:11Z"
}

POST /query: Run a governed intelligence query

{
  "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: Run a multi-hop 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 (72)

Required fields are marked with an asterisk; enumerations are listed inline. The status values seed, proposed and 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* enum(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[]
IdentityType11 values
  • 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* enum(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* enum(interest, goal, project, relationship, expertise, preference, constraint, observation, other)
  • value* object
  • confidence number
  • source SourceRef
Relationship11 fields, 5 required
  • id* string
  • fromId* string
  • type* string
  • toId* string
  • direction enum(directed, undirected)
  • attributes object
  • effectiveFrom string|null
  • effectiveTo string|null
  • confidence number
  • status* enum(proposed, certified, rejected, superseded)
  • provenance Provenance
RelationshipCreate10 fields, 3 required
  • fromId* string
  • type* string
  • toId* string
  • direction enum(directed, undirected)
  • attributes object
  • effectiveFrom string|null
  • effectiveTo string|null
  • confidence number
  • status enum(proposed, certified)
  • sources SourceRef[]
AuthorityDecision7 fields, 3 required
  • decisionId* string
  • effect* enum(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
KnowledgeEntity13 fields, 5 required
  • id* string
  • type* IdentityType
  • displayName* string
  • aliases string[]
  • externalIds object
  • attributes object
  • status* enum(active, inactive, merged, restricted)
  • confidence number
  • createdAt* string
  • updatedAt string|null
  • provenance Provenance
  • schemaType string
  • summary string|null
KnowledgeEntityCreate8 fields, 3 required
  • type* IdentityType
  • displayName* string
  • aliases string[]
  • externalIds object
  • attributes object
  • source SourceRef
  • schemaType* string
  • summary string|null
Fact10 fields, 6 required
  • id* string
  • subjectId* string
  • predicate* string
  • object* object
  • qualifiers object
  • status* enum(seed, proposed, certified, rejected, superseded)
  • confidence* number
  • validFrom string|null
  • validTo string|null
  • provenance Provenance
FactCreate9 fields, 3 required
  • subjectId* string
  • predicate* string
  • object* object
  • qualifiers object
  • status enum(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* enum(allow, deny, conditional, escalate)
  • status* enum(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* enum(allow, deny, conditional, escalate)
  • status enum(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* enum(finding, citation, document, observation, testimony, measurement, other)
  • claim* string
  • sources* SourceRef[]
  • confidence number
  • status* enum(seed, proposed, certified, disputed, rejected, superseded)
  • corroborationCount integer
  • contradictionCount integer
  • attributes object
  • provenance Provenance
EvidenceCreate6 fields, 3 required
  • kind* enum(finding, citation, document, observation, testimony, measurement, other)
  • claim* string
  • sources* SourceRef[]
  • confidence number
  • status enum(seed, proposed, certified)
  • attributes object
CorroborateRequest4 fields, 1 required
  • supportingEvidenceIds* string[]
  • contradictingEvidenceIds string[]
  • method enum(manual, rule, model, hybrid)
  • notes string|null
Outcome9 fields, 5 required
  • id* string
  • subjectId* string
  • decisionId string|null
  • type* string
  • status* enum(expected, observed, validated, disputed, superseded)
  • value object
  • metrics object
  • occurredAt* string
  • provenance Provenance
OutcomeCreate8 fields, 4 required
  • subjectId* string
  • decisionId string|null
  • type* string
  • status enum(expected, observed, validated)
  • value* object
  • 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* enum(eq, ne, in, not_in, gt, gte, lt, lte, contains, exists, between)
  • value* object
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* enum(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* enum(agent, workflow, research, investigation)
  • status* enum(queued, running, awaiting_approval, succeeded, failed, cancelled)
  • createdAt* string
  • startedAt string|null
  • completedAt string|null
  • output object
  • error Problem|null
  • governance GovernanceReceipt|null
Workflow6 fields, 5 required
  • id* string
  • name* string
  • version* string
  • status* enum(draft, active, retired)
  • steps* WorkflowStep[]
  • policyIds string[]
WorkflowStep5 fields, 2 required
  • id* string
  • type* enum(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 enum(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* enum(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 enum(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 enum(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* enum(nodeType, sensitivity, consent, jurisdiction)
  • result* enum(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* enum(attested, proposed) attested: a human reviewed it and it is a real deadline. proposed: computed by the system, unchecked.
  • attestedBy ActorRef|null
  • 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* enum(active, revoked, expired)
  • grantedAt* string
  • expiresAt string|null
ConsentPage2 fields, 2 required
  • items* ConsentRecord[]
  • page* PageInfo
LearningState6 fields, 2 required
  • identityId* string
  • paused* boolean
  • since string|null
  • reason string|null
  • changedBy ActorRef
  • governance GovernanceReceipt
LearningStateChange2 fields, 1 required
  • paused* boolean
  • reason string
ForgetTarget2 fields, 2 required
  • type* enum(fact, relationship, context)
  • id* string
ForgetRequest2 fields, 1 required
  • targets* ForgetTarget[]
  • reason string
ResetRequest2 fields, 1 required
  • confirmIdentityId* string Must equal the identity in the path. A reset is not undoable.
  • reason string
Tombstone4 fields, 4 required
  • type* enum(fact, relationship, context)
  • id* string
  • contentHash* string SHA-256 of the record as it was, so a holder of the original can prove what was forgotten; the content is gone.
  • forgottenAt* string
ForgetResult4 fields, 3 required
  • identityId* string
  • forgotten* Tombstone[]
  • notFound ForgetTarget[]
  • governance* GovernanceReceipt
LineageEntry5 fields, 4 required
  • seq* integer
  • eventType* string
  • occurredAt* string
  • decisionId string|null
  • eventHash* string
IdentityExport14 fields, 6 required
  • identityId* string
  • generatedAt* string
  • fingerprint* string
  • fingerprintOf string The sentence describing how the fingerprint is computed, so a holder can recompute it.
  • identity* Identity
  • context object[]
  • facts Fact[]
  • relationships Relationship[]
  • obligations Obligation[]
  • consents ConsentRecord[]
  • learning LearningState
  • tombstones Tombstone[]
  • lineage* LineageEntry[]
  • governance* GovernanceReceipt
InteractionRecordCreate7 fields, 2 required
  • identityId string|null The identity acted for. Omitted: the caller.
  • purpose* string
  • outcome* enum(completed, refused, proceeded_on_truncated, proceeded_on_empty, escalated)
  • reason string|null
  • projectionReceiptId string|null
  • runId string|null
  • model string|null
InteractionRecord11 fields, 5 required
  • identityId string|null The identity acted for. Omitted: the caller.
  • purpose* string
  • outcome* enum(completed, refused, proceeded_on_truncated, proceeded_on_empty, escalated)
  • reason string|null
  • projectionReceiptId string|null
  • runId string|null
  • model string|null
  • id* string
  • actor* ActorRef
  • recordedAt* string
  • eventHash string|null