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.

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.

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[]}.

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}.

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.

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.

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.

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.

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

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

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).

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

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.

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.

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.

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.

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.

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.

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

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.

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 semantic workflow events attached to one case. These are the queryable facts over the run/node evidence layer.

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.

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.

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.

Alias of invariance_run_start

Get a divergence by ID.

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

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

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

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}.

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 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 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}.

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.

Reject a DNA edge candidate so it is never promoted.

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}}.

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).

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

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

List example rows for a dataset (paginated).

Get a single eval dataset by ID.

List eval datasets visible to the calling agent (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.

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

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.

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.

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).

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.

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.

Get an eval suite by ID.

List eval suites visible to the calling agent (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 a finding by ID.

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

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).

Alias of invariance_run_get

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

Get a guardrail by ID.

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

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

Patch a guardrail (mode, status, monitor_id).

Create a knowledge-base page

Delete a knowledge-base page

Get a knowledge-base page by ID

List knowledge-base pages

Update fields on a knowledge-base page

Append a message to a KB ask session

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

Alias of invariance_node_list

Alias of invariance_run_list

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.

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

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.

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

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.

Get a monitor by ID

List monitors visible to the calling agent (paginated).

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

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?}]}.

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}.

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

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

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

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

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.

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.

Fetch a single operator by ID. 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.

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).

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

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

Get an external receipt by ID.

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

Get a recipe by ID or slug.

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

Patch a recipe (enabled, default_mode).

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.

Get a review by ID.

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

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).

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 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.

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.

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.

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

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.

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

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

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.

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

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.

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.

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).

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}.

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

Delete a saved view by ID.

Get a saved view by ID.

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

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

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

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.

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).

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

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.

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/<session_id>' by default.

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

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.

Get a signal by ID.

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

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

Alias of invariance_run_verify

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

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

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.

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

Get one workflow definition by workflow key.

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

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

Get the observability rollup for one workflow by key.

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

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

Alias of invariance_node_write