Start a new Invariance run (the container for a sequence of nodes). The returned run is in status "open" — you must close it later with invariance_run_finish (success) or invariance_run_fail (error).

Get details of an Invariance run (status, metadata, aggregate counts, timestamps).

List runs visible to the calling agent in reverse-chronological order (paginated).

Close a run successfully — sets status to "completed". Use this when the agent finished its work without errors. For failures, use invariance_run_fail instead.

Close a run with failure — sets status to "failed" and stores the optional error string in metadata.error. Use this when the agent aborted due to an exception or unrecoverable error. For successful completion, use invariance_run_finish.

Verify the cryptographic proof chain for a run — recomputes node hashes and Ed25519 signatures end-to-end. Returns {valid, node_count, head_hash, first_invalid_node_id, reason}.

Aggregate metrics for a run: total_input_tokens, total_output_tokens, total_cache_read/write, total_cost_usd, llm_call_count, tool_call_count, error_count, total_latency_ms.

Append a single node (one unit of work) to an open Invariance run. Use this to record tool calls, LLM calls, logs, context attachments, or handoffs as they happen.

List nodes for a run in append order (paginated).

Create a monitor that evaluates an event-shaped predicate against nodes/runs and optionally emits signals, findings, or reviews when matched.

List monitors visible to the calling agent (paginated).

Get a monitor by ID

Patch an existing monitor (partial update; only included fields change).

Disable a monitor so it stops firing (preserves the spec; use invariance_monitor_resume to re-enable).

Re-enable a paused monitor so it begins firing again.

Manually evaluate a monitor right now against an explicit input scope (returns the resulting execution plus any signals/findings/reviews produced).

List past evaluation executions for a monitor (each has status, trigger, matched_node_ids, timing).

List findings produced by a monitor across all of its executions.

Dry-run a monitor target against history to see which runs/nodes it would inspect. Writes nothing. Returns {run_ids, node_ids, counts:{runs,nodes}, truncated}.

Dry-run a monitor evaluator against history to see which nodes it would match and why. Writes nothing. Returns {sampled, matched, matches:[{run_id,node_id,matched,reason,observed_value?}]}.

Emit a manual signal (alert/notification) — typically attached to a run/node and used to flag noteworthy events for review or downstream automation. severity defaults to "info" if omitted. run_id/node_id auto-fill from INVARIANCE_RUN_ID/INVARIANCE_NODE_ID env vars when present.

List signals visible to the calling agent (paginated, newest first).

Get a signal by ID.

Acknowledge a signal — moves status from "open" to "acknowledged" (someone has seen it). Use invariance_signal_resolve to mark fully resolved.

Resolve a signal — moves status to "resolved" (the underlying issue has been addressed).

List findings (durable, structured issues raised by monitors or agents) visible to the caller, paginated.

Get a finding by ID.

Transition a finding to a new status: "open" (active), "review_requested" (escalated to a human/agent reviewer), "resolved" (fixed), or "dismissed" (intentionally ignored / false positive).

List reviews (work items requesting agent/human adjudication of a finding or run) in the queue, paginated.

Get a review by ID.

Claim a pending review for the calling agent — sets status to "claimed" so other agents do not pick it up. Pair with invariance_review_resolve when done, or invariance_review_unclaim to release.

Release a previously-claimed review back to "pending" so another agent can pick it up. Does not record a decision — use invariance_review_resolve for that.

Close a review by recording a decision: "passed" (looks good, no action), "failed" (issue confirmed, should not ship), or "needs_fix" (issue confirmed, fix-and-retry).

Show the agent identity and API key associated with the current credentials. Useful for confirming which agent context the MCP server is operating as.

Register or rotate the calling agent's Ed25519 public key. Once set, every node written by this agent must be signed with the matching private key (the server uses this key to verify signatures during invariance_run_verify).

Create a new agent inside one of the caller's projects. Requires a user-session JWT bearer (not an agent API key) — see invariance-cli inv auth signup / inv auth signin to obtain one.

List agents inside one of the caller's projects. Requires a user-session JWT bearer.

Fetch a single agent by ID. Requires a user-session JWT bearer.

Fetch (or regenerate) the LLM-synthesized narrative for a run

Ask a question against the agent's runs / knowledge base (turn-based session)

List knowledge-base pages

Get a knowledge-base page by ID

Create a knowledge-base page

Update fields on a knowledge-base page

Delete a knowledge-base page

Create a multi-turn ask session for the agent KB

Delete a KB ask session

List all messages in a KB ask session in order

Append a message to a KB ask session

Get the operational graph for a run — entities, edges, findings, a completeness score (business_object_linked, policy_context_found, owner_found, approval_context_found, downstream_state_change_found), and a missing_evidence list naming the unsupported dimensions.

List LLM calls for a run in append order (paginated). Each entry includes model, tokens, cost, latency, and the underlying node_id.

List the typed-node kinds present in a run (one row per registered type with a count). Pair with invariance_run_node_type_metrics for per-type aggregates.

Aggregate metrics for a single typed-node kind within a run (counts, latency stats, custom-field roll-ups).

Fork a run from a specific node — creates a new run that branches off the parent at from_node_id. Useful for "what-if" replays during agent debugging.

Cross-run rollup over a time window: total runs, nodes, errors, cost, latency, etc. Use this to ground "what is happening across my agents" questions.

Per-agent usage rollup over a time window: run counts, node counts, cost. Useful for agent-by-agent comparison.

Composite triage view for a run — fetches run, metrics, narrative, recent nodes, and open findings in parallel and returns {run, metrics, narrative, recent_nodes, open_findings}. Mirrors inv run inspect. Best first call when an agent is asked to debug a run.

Record a memory read by an agent against a subject (customer/account/policy/...) and return the current MemoryRecord (if any). Use this whenever an agent consults a remembered belief — it produces an auditable MemoryAccess event tying that belief to a node in the run, which the divergence detectors use to flag stale or unsupported memory.

Record a memory write by an agent: set or update a belief (claim) about a subject. Returns the new MemoryAccess + MemoryRecord. Defaults: source="agent_write", confidence=1.0. Provide provenance (EvidenceRef[] as JSON) when the claim is derived from authoritative records (CRM/ticket/policy doc) so downstream divergence checks can verify it.

Create a reusable eval dataset (a named collection of input/expected example rows used to drive experiments).

List eval datasets visible to the calling agent (paginated).

Get a single eval dataset by ID.

Append a single example row (input + expected output) to an existing dataset.

List example rows for a dataset (paginated).

One-call eval setup for agents: create a dataset, append rows, create a linked suite, create one case per row, and optionally start the eval run. This is the preferred MCP path for turning JSON examples into runnable evals.

Register a scorer (named scoring rule that maps an output+expected pair to a 0..1 score). Built-in scorer kinds: exact_match, contains, numeric_tolerance, json_match, levenshtein.

List scorers visible to the calling agent (paginated).

Create an eval suite (the legacy grouping for cases + runs). New work should generally prefer datasets; suites remain for back-compat and curated case sets.

List eval suites visible to the calling agent (paginated).

Get an eval suite by ID.

Add a case (input + expected) to an eval suite.

Snapshot an existing production run as a new eval case in a suite (captures the run's input + output as expected).

List cases for an eval suite (paginated).

Kick off an eval run: executes every case in the suite against a target (agent / recipe / inline override) and stores per-case results.

Get an eval run by ID (status, aggregate counts, timestamps, scorer specs).

List per-case results for an eval run (paginated). Each result has output, expected, scores (per-scorer 0..1), and pass/fail.

List the built-in scorer kinds available on the platform (name + config schema). Use this to discover what you can pass in scorer_specs to invariance_eval_experiment_run.

Execute an experiment against an existing eval run: applies a list of scorer specs to every case result and (optionally) records a baseline run for later compare. Populates eval_results.scores. Built-in scorer names: exact_match, contains, numeric_tolerance (config.tolerance: number), json_match, levenshtein.

Compare two scored eval runs case-by-case (CompareResponse: per-case ScoreDelta entries + aggregate deltas per scorer). Use to surface regressions vs. a baseline.

Show the operator identity associated with the current credentials. An "operator" is the unified actor model — every Claude Code session, autonomous agent, AND human teammate is an operator. Use this to confirm which operator context the MCP server is acting as (e.g. before recording session events, attaching runs, or writing notes to the company brain).

Create a new operator in one of the caller's projects. Operators are the actors whose work shows up in the company brain — create operator_type='agent' for an autonomous worker (Claude Code, a scripted agent, a coding bot) and operator_type='human' for a teammate whose screen recordings, microphone capture, meetings, and Granola notes you want to ingest. Requires a user-session JWT bearer.

List operators inside one of the caller's projects. Filter by operator_type to find all human teammates or all autonomous agents. Requires a user-session JWT bearer.

Fetch a single operator by ID. Requires a user-session JWT bearer.

Open a new agent-session — the canonical container for an operator's bounded chunk of work in the company brain. CALL THIS at the START of: a new Claude Code task (source='api'), a screen recording for a teammate (source='screen_recording'), a mic capture session (source='microphone'), a meeting (source='meeting'), ingestion of a Granola note (source='granola_note'), or a manual note-taking session (source='manual_note'). Events (transcript chunks, tool calls, screenshots, notes) are appended to this session via invariance_session_append_note or the events sub-route. Link a session to a run via agent_id+run_id (or call invariance_session_attach_run later).

List agent-sessions, optionally filtered by source, agent, run, or status. Use this to find all Claude Code work for an agent (source="api"), all meetings ingested today (source="meeting"), or all screen recordings for a human teammate.

Fetch a single agent-session by ID, including its source, timestamps, attached run/agent, and metadata.

Append a freeform text note to an existing session as a custom event with payload {text}. USE THIS WHEN: jotting a thought during a Claude Code task ("trying approach X next"), capturing a meeting takeaway, annotating a screen recording, or recording a partial transcript chunk from microphone capture. The note becomes part of the company brain timeline for that session.

Attach an existing run to an existing agent-session (PATCH). USE THIS when a Claude Code task that started a session later starts producing a run — call this to link the run's graph back to the session timeline so the brain can correlate transcript/notes with operational nodes.

Persist a summary of an agent-session as a knowledge-base page (so it becomes searchable, durable company brain content beyond the raw session timeline). USE THIS at the END of a Claude Code task, after a meeting wraps, or once a screen-recording has been reviewed — to capture the takeaways. The KB page is created under path 'sessions/' by default.

Create a workflow-instance Case. A case owns many runs across time, agents, and humans (one loan, one audit, one claim). Returns the case; use its id when starting runs with invariance_run_start to link them.

Get a case by id, including its linked runs (newest first, capped at 100). Use to inspect status, outcome, owner, custom_attrs, and the runs the case has accumulated.

Show normalized evidence for a case: the case, linked runs, nodes, workflow events, actors, and outcome. Use this when you need the full workflow execution record instead of only the case row.

List semantic workflow events attached to one case. These are the queryable facts over the run/node evidence layer.

Attach a semantic workflow event to a case, e.g. "support.customer.escalated", "approval.granted", or "docs.received". Prefer this for meaningful workflow facts; keep raw execution trace data in runs/nodes.

List cases visible to the calling agent (paginated). Filter by tenant_id, end_user_id, workflow_key, status ("open" | "closed"), outcome, or tags.

Update a case: change owner, merge custom_attrs (shallow), or transition status. Use invariance_case_close for the common "set outcome + close" path.

Close a case with an outcome — the common path. Equivalent to invariance_case_update with status="closed" + outcome + outcome_value_usd.

List workflow definitions: typed fields, expected steps, allowed outcomes, and custom metrics.

Get one workflow definition by workflow key.

Create a workflow definition with typed fields, expected steps, allowed outcomes, and custom metrics.

Patch a workflow definition. Existing cases/runs/events keep their workflow_key.

Delete a workflow definition. Existing cases/runs/events are retained.

List semantic workflow events across cases. Filter by case, workflow, tenant, actor, type, or time window.

Record a semantic workflow event on a case (e.g. "refund.issued", "approval.approved", "human.handoff"). Links case/run/node evidence + external refs and is bridged into DNA. Pass idempotency_key to make external retries safe.

Create a Capture — a standalone evidence record (session, conversation, trace). Captures don't need an execution upfront; link a capture to a run later with invariance_capture_link. Returns the capture session.

List captures (paginated). Captures are standalone evidence; they don't need an execution upfront. Filter by project_id, operator_id, session_type, source, run_id, or tags.

Get a capture by id. Captures are standalone evidence; they don't need an execution upfront; link a capture to a run later with invariance_capture_link.

Update a capture: change status, reassign run_id, or merge metadata. Captures are standalone evidence; they don't need an execution upfront; link a capture to a run later with invariance_capture_link.

Link a capture to an evidence-graph target (run/case/workflow_event/node). With only run_id this sets the capture's run_id (legacy, equivalent to invariance_capture_update). With target_id it creates a richer capture link; target_type defaults to "run". Captures are standalone evidence and don't need an execution upfront.

List every evidence link on a capture (case/run/workflow_event/node), returning { links }. Captures are standalone evidence; link a capture to a target with invariance_capture_link.

Detach a capture link. With link_id, deletes that specific evidence link. Without link_id, clears the capture's run_id (legacy). Captures are standalone evidence; they don't need an execution upfront.

Run a health check on this MCP server: verifies API key auth, API reachability, and reports server name/version. Mirrors inv doctor --json from the CLI. Returns {checks: [{name, status, message}], summary: {pass, fail, warn}}.

Enqueue a generic Cortex job (evals, counterfactuals, experiments, attributions). The actor is resolved server-side from the API key (a key bound to an agent_id runs as that agent; otherwise as the api_key actor). The platform ACL-filters input_refs and target access before prompt construction. Returns {job_id, status} plus, when a synchronous MVP runner completes the job inline, the validated result.

Convenience wrapper around cortex_run_job for job_kind="workflow_eval": checks whether a run/case/workflow met its criteria (e.g. SLA, policy compliance, action-item ownership). Returns the same job shape as cortex_run_job.

Convenience wrapper around cortex_run_job for job_kind="counterfactual_eval": estimates what MIGHT have happened under a hypothetical change. Result is a HYPOTHESIS, not fact — it carries assumptions, evidence_refs, confidence, and uncertainty. question is required.

Get a Cortex job's metadata and status (no artifacts). Returns the same safe-field projection as cortex_run_job: ids, status, target, actor, criteria, timestamps, error. Use cortex_get_result to fetch the structured result body.

Get a Cortex job's structured result. Returns {job_id, status, result?}. The result is validated against the known per-kind schemas (workflow_eval / counterfactual_eval / outcome_attribution / complex_query / divergence_error_tracking). Raw artifacts (prompt input, raw model output) are NOT returned by this tool — they remain private on the platform.

Ask the READ-ONLY Cortex analyst (complex_query) an operational question and get a cited answer. Use this for questions like "Were refund SLAs met last week?", "Why did this run diverge?", "Which agents touched case_123?". The analyst is governed and EVIDENCE-CITED: every id in evidence_refs / affected_entities was observed through a read tool, and the runtime FAILS CLOSED against fabricated or cross-project ids (no answer is invented and no other tenant's data can leak). It only reads — it never mutates state. Returns the validated ComplexQueryResult {short_answer, reasoning_plan, evidence_refs, affected_entities, confidence, restricted_evidence_count, recommended_action, follow_up_questions}. mode="sync" (default) blocks for the answer; mode="async" enqueues then polls until the job is terminal. Note: the analyst only executes when the platform CORTEX_TOOL_RUNTIME_ENABLED flag is on.

Launch a Cortex job through the GOVERNED launcher (POST /v1/cortex/jobs/launch) — the preferred path for the read-only complex_query analyst and divergence_error_tracking. The actor is resolved server-side from the API key and all evidence is ACL-filtered before prompt construction (fails closed against cross-project leak). mode="sync" runs now and embeds result/error; mode="async" enqueues — poll with cortex_get_result or cortex_job_runs. Returns {job_id, status, mode, deduplicated, result?, error?}. Idempotent when idempotency_key is supplied.

List Cortex jobs across accessible projects, newest first. Filter by status and/or kind. Read-only. Returns {data: CortexJob[], next_cursor}. Pass next_cursor back as cursor to page.

Re-queue a failed or dead Cortex job for one more attempt (POST /v1/cortex/jobs/:id/retry). Returns {job_id, status}.

List the attempt history (audit-trail runs) for a Cortex job — one row per execution attempt, with status, model, metrics, timings, and any error. Read-only. Raw prompt/model artifacts are NOT included. Returns {runs: CortexJobRun[]}.

List Company DNA objects — the canonical operational entities in a project's DNA graph (e.g. tickets, services, policies). Filter by kind or a free-text query q. Output: {data: DnaObject[], next_cursor}.

List Company DNA object mentions — extracted references (in events or chunks) that may resolve to a DNA object. Filter by event_id, chunk_id, object_id, or mention_type. Output: {data: DnaObjectMention[], next_cursor}.

List durable Company DNA edges — relationships between objects, e.g. the operational graph derived from a run (refund -[REQUIRED]-> policy). Filter by run_id, kind, or entity_id. Output: {data: DnaEdge[], next_cursor}.

List Company DNA edge candidates — discovered relationships between objects awaiting review. Filter by status (proposed/accepted/rejected/expired/promoted), object_id, or relation_kind. Output: {data: DnaEdgeCandidate[], next_cursor}.

Accept a proposed DNA edge candidate, making it eligible for promotion into a durable semantic link.

Reject a DNA edge candidate so it is never promoted.

Promote an accepted DNA edge candidate into a durable semantic link. The candidate must be accepted, carry a semantic_similarity signal, and have at least two evidence chunks (otherwise the API returns 422). Idempotent: re-promoting returns the existing link with already_promoted=true. Set dry_run=true to preview the would-be link without writing.

List workflow observability rollups (per workflow_key: execution/open/closed counts, evidence mix, cost & token totals).

Get the observability rollup for one workflow by key.

List per-execution health for a workflow (status, stale flag, health, reasons, evidence mix, cost/tokens).

List divergences (expected-vs-observed gaps) visible to the caller. Filter by run, kind, severity, status.

Get a divergence by ID.

Transition a divergence status: open | accepted | dismissed | converted_to_monitor.

List saved query views (name, source, spec, viz, visibility).

Get a saved view by ID.

Create a saved query view over executions/events/runs/nodes/captures.

Patch a saved view (partial; only included fields change).

Run a query and return the result. Pass EITHER saved_view_id OR source+spec (exactly one).

Delete a saved view by ID.

Record one external receipt (proof an external action happened). Requires an AGENT API key (operator tokens get 403).

Record many external receipts in one call. Requires an AGENT API key (operator tokens get 403).

List external receipts. Filter by run, node, source, kind, external_id, business object.

Get an external receipt by ID.

List per-agent guardrails. Filter by status or recipe_id.

Get a guardrail by ID.

Create a guardrail (from a recipe or finding). Required: title. Optional: recipe_id, finding_id, rule, mode, status.

Patch a guardrail (mode, status, monitor_id).

Promote a guardrail to a new lifecycle status: suggested → accepted → shadow → active_monitor → rejected.

List built-in operational-check recipes (registry of controls). Promote one into a guardrail via invariance_guardrail_create.

Get a recipe by ID or slug.

Patch a recipe (enabled, default_mode).

Alias of invariance_run_start

Alias of invariance_run_get

Alias of invariance_run_list

Alias of invariance_node_write

Alias of invariance_node_list

Alias of invariance_run_verify