graph-os Capability Power Descriptors (generated)¶

GENERATED — do not edit by hand. Regenerate with python3 scripts/gen_capability_power.py --write; scripts/check_cpd.py gates drift in CI/pre-commit (CONCEPT:AU-KG.retrieval.capability-power-descriptor). Seam 8 Phase 1 — plans/program-design-2026-07-11-epistemic-tool-routing.md section 2b.

129 capabilities · generated 2026-10-08T20:38:47Z. Every field is derived from a live source (the MCP tool registry, the generated graph-os action manifest, the EG-P0-1 capability ledger, transcribed measured benchmarks) — an empty field means the source had no answer, never a fabricated one.

Index¶

Capability	Intent verbs	One-line power	Actions	REST
`act`	act	Run work, an operation or a fleet tool; previews first, then run with plan_ref.	1	`/intent/act`
`agent_library`	manage, find, ask	The Agent Library of built agents (system prompt, tools, skills, model profile, context policy,	4	`/graph/agent-library`
`ask`	ask	Read or answer from the Knowledge Graph. action='.' (see action='describe'), or leave it	1	`/intent/ask`
`ask_data`	ask	answer a DATA question over the Knowledge Graph with a DB-GPT-style, multi-step data-analysis agent	1	`/graph/ask-data`
`concept_registry`	find, ask	Coordinate canonical OKF-CIS concept ids for linked worktrees on one host	1	`/concept/registry`
`document_process`	write	Document → ontology processing (CONCEPT:AU-KG.ingest.chunk-overlap-stage): extract → chunk(overlap)	1	`/document/process`
`engine_admin`	manage	Low-level epistemic-graph engine surface for the 'admin' domain (ops/maintenance: online backup +	6	`/engine/admin`
`engine_analytics`	ask	Low-level epistemic-graph engine surface for the 'analytics' domain (centrality + (personalized)	5	`/engine/analytics`
`engine_blob`	write	Low-level epistemic-graph engine surface for the 'blob' domain (streamed content-addressed media	11	`/engine/blob`
`engine_broker`	act, manage, ask	Low-level epistemic-graph engine surface for the 'broker' domain (native message broker:	22	`/engine/broker`
`engine_channels`	act	Low-level epistemic-graph engine surface for the 'channels' domain (dynamic agent communication	8	`/engine/channels`
`engine_consensus`	act	Low-level epistemic-graph engine surface for the 'consensus' domain (zero-trust identity + multisig	5	`/engine/consensus`
`engine_datascience`	ask	Low-level epistemic-graph engine surface for the 'datascience' domain (estimators + primitives +	15	`/engine/datascience`
`engine_edges`	write	Low-level epistemic-graph engine surface for the 'edges' domain (edge CRUD, temporal	10	`/engine/edges`
`engine_finance`	ask, act	Low-level epistemic-graph engine surface for the 'finance' domain (quantitative finance	67	`/engine/finance`
`engine_graph`	ask, write	Low-level epistemic-graph engine surface for the 'graph' domain (graph algorithms, AST parse/index,	27	`/engine/graph`
`engine_graphlearn`	act, ask	Low-level epistemic-graph engine surface for the 'graphlearn' domain (KAN graph-learning:	2	`/engine/graphlearn`
`engine_ledger`	write, act	Low-level epistemic-graph engine surface for the 'ledger' domain (audit ledger get/clear/apply).	4	`/engine/ledger`
`engine_lifecycle`	manage, act	Low-level epistemic-graph engine surface for the 'lifecycle' domain (prune/decay/evict,	10	`/engine/lifecycle`
`engine_mining`	ask	Low-level epistemic-graph engine surface for the 'mining' domain (association-rule mining	18	`/engine/mining`
`engine_modalities`	write, ask	Low-level epistemic-graph engine surface for the 'modalities' domain (native	16	`/engine/modalities`
`engine_nodes`	write, ask	Low-level epistemic-graph engine surface for the 'nodes' domain (node CRUD, batch/union reads,	22	`/engine/nodes`
`engine_placement`	manage, ask	Low-level epistemic-graph engine surface for the 'placement' domain (DIST-P2-1 raft	4	`/engine/placement`
`engine_query`	ask	Low-level epistemic-graph engine surface for the 'query' domain (SQL / Cypher / GraphQL / UQL /	26	`/engine/query`
`engine_rbac`	manage	Low-level epistemic-graph engine surface for the 'rbac' domain (RBAC policy administration: roles +	5	`/engine/rbac`
`engine_rdf`	write, ask	Low-level epistemic-graph engine surface for the 'rdf' domain (RDF triples + SPARQL + OWL	14	`/engine/rdf`
`engine_reasoning`	why	Low-level epistemic-graph engine surface for the 'reasoning' domain (forward-chaining OWL/RDFS	1	`/engine/reasoning`
`engine_resharding`	manage	Low-level epistemic-graph engine surface for the 'resharding' domain (M3 catalog/reshard/rebalance	7	`/engine/resharding`
`engine_streaming`	act	Low-level epistemic-graph engine surface for the 'streaming' domain (CDC / continuous queries /	13	`/engine/streaming`
`engine_tenants`	manage	Low-level epistemic-graph engine surface for the 'tenants' domain (multi-tenant graph	3	`/engine/tenants`
`engine_timeseries`	write, ask	Low-level epistemic-graph engine surface for the 'timeseries' domain (native TSDB	10	`/engine/timeseries`
`engine_txn`	act	Low-level epistemic-graph engine surface for the 'txn' domain (server-side OCC ACID transactions).	18	`/engine/txn`
`engine_viz`	act, ask	Low-level epistemic-graph engine surface for the 'viz' domain (D-VZ-1 native visualization:	2	`/engine/viz`
`find`	find	Discover capabilities, operations, fleet tools and the fleet catalog.	1	`/intent/find`
`graph_agents`	act	Run graph-grounded agent collectives.	5	`/graph/agents`
`graph_analyze`	ask, why	Structural and operational KG analysis.	8	`/graph/analyze`
`graph_argument`	why, write, ask	AIF (Argument Interchange Format) argument maps: I-nodes (claims) linked through S-nodes — RA	4	`/graph/argument`
`graph_ask`	ask	ask the Knowledge Graph in plain English.	1	`/graph/ask`
`graph_audit`	why, ask	Tamper-evident audit ledger (G23): checks the engine's hash-chained durable-mutation audit log	3	`/audit`
`graph_broker`	act	the epistemic-graph engine message broker (AMQP-style exchanges + queues + streams), distinct from	1	`/graph/broker`
`graph_bus`	act	the agent-to-agent communication bus: let this session talk to other Claude/LLM sessions (any	1	`/graph/bus`
`graph_candidate_claims`	act, write	Track 4/5 of the universal-ingestion program: propose model-backed candidate claims from raw text,	2	`/graph/candidate-claims`
`graph_catalog`	find, ask	one capability-shaped call across every KG modality (graphs, sql, kv, vector, ontology, timeseries,	2	`/graph/catalog`
`graph_claims`	manage, act	Drive the X-3 epistemic mining flywheel's governed claim lifecycle	8	`/graph/claims`
`graph_code`	ask, act	Understand a CODEBASE via the ingested code graph — query this before grep.	11	`/graph/code`
`graph_code_nav`	ask	Navigate the resolved code graph (CONCEPT:AU-KG.backend.declared-columns-so-schema). action:	1	`/graph/code-nav`
`graph_compliance`	ask, why	Compliance posture rollup + redacted bulk export — an aggregation layer over primitives that	2	`/compliance`
`graph_config`	manage, ask	Inspect and govern this deployment's AgentConfig (CONCEPT:AU-OS.config.two-surfaces-by-default).	5	`/graph/config`
`graph_configure`	manage	Manage backend configurations, system credentials, and tool registration within the unified agent	38	`/graph/configure`
`graph_context`	ask	store/fetch curated context for invoker→spawned-agent handoff, persisted in the epistemic-graph so	4	`/graph/context`
`graph_data_prep`	ask, write	Governed Arrow data preparation over the NE-108 kernel.	4	`/data/prep`
`graph_document_tree`	ask, write	Reasoning-tree (vectorless) document retrieval over a per-document section tree	6	`/graph/document-tree`
`graph_domain_ops`	act	Run graph-native domain mutations.	3	`/graph/domain-ops`
`graph_durable`	act, ask	The unified durable-execution plane (durable-execution-native.md, supersedes restate natively).	7	`/graph/durable`
`graph_engineering`	ask, write	GraphRAG-style Graph Engineering surface: entity-neighborhood local search, community-report	3	`/graph/engineering`
`graph_epistemic`	why, ask	Purpose-named epistemic-answer surface over the engine's belief/provenance primitives	5	`/epistemic`
`graph_etl`	write	Unified ETL pipeline between systems over the canonical KG hub (CONCEPT:AU-KG.ontology.one-source).	2	`/graph/etl`
`graph_evaluate`	why	Evaluate agents/harnesses and reason over learned world models.	18	`/graph/evaluate`
`graph_evolution`	act	Improve the graph and its executable knowledge.	8	`/graph/evolution`
`graph_explain`	why	The UNIVERSAL context plane (CONCEPT:AU-KG.retrieval.route-question-its-domain): route a question	4	`/graph/explain`
`graph_federated_search`	ask	federated search fanned across registered external graph references.	1	`/graph/federated-search`
`graph_feedback`	why, write	Record a human correction so the brain learns: correction_type 'outcome' adjusts an entity's	1	`/graph/feedback`
`graph_feeds`	act, ask	Manage the unified RSS/Atom feed registry (CONCEPT:AU-KG.ingest.rss-feed-connector/2.122).	4	`/graph/feeds`
`graph_fork`	act	warm-fork fan-out over the ORCH-1.86..93 warm-fork primitive (LMCache KV / copy-on-write	1	`/graph/fork`
`graph_gis`	ask	the engine's GIS surface.	1	`/graph/gis`
`graph_goals`	act	Orchestrate background/autonomous loops (action in 'create', 'list', 'iterations', 'cancel').	4	`/graph/goals`
`graph_governance`	act, manage	Govern orchestration actions.	7	`/graph/governance`
`graph_incident`	ask, act	Incident Brain (CONCEPT:AU-KG.enrichment.cross-layer-incident-correlation): browse and drive the	7	`/incident`
`graph_ingest`	write, ask	Smart ingestion for codebases, documents, directories, and conversation logs.	44	`/graph/ingest`
`graph_jobs`	act, ask	Submit and inspect durable orchestration WorkItems.	6	`/graph/jobs`
`graph_kv_checkpoint`	write, act	checkpoint a KV-cache at a point of ideal understanding, then initialise a new agent from it or	8	`/graph/kv_checkpoint`
`graph_kvcache`	manage	the engine's shared, content-addressed KV-cache over the EG-187 HTTP surface, driven through the	5	`/graph/kvcache`
`graph_learn`	act, ask	a pure-Rust KAN (Kolmogorov-Arnold) link-predictor over the resident graph, whose learned	2	`/graphlearn/fit`
`graph_logs`	ask	query the engine's log stream. action='query' (default): filter by 'stream'/free-form 'query' over	1	`/graph/logs`
`graph_loops`	act	The single entrypoint for long-running objectives (CONCEPT:AU-KG.research.these-properties-carry).	13	`/graph/loops`
`graph_media_sidecar`	write, act	Delegate a media artifact (PDF, JPEG, audio, video) to a governed fleet sidecar for heavy decode	4	`/media/sidecar`
`graph_memory`	write, ask	the engine's EG-318 memory surface: episodic→semantic memory, the spatial scene graph, and RL	3	`/graph/memory`
`graph_message`	act	bidirectional, cross-process, ordered message channel between an invoking agent and a spawned	5	`/graph/message`
`graph_observe`	why, ask	Reason over the KG-native observability subgraph — traces, online-scores, assertion verdicts,	4	`/graph/observe`
`graph_ontology`	write, ask, manage	GraphSchema lifecycle control plane. load/update attach an explicit iri+version Turtle document	5	`/graph/ontology`
`graph_orchestrate`	act	Resolve an ingested skill/workflow for a task and run it on the local vLLM through the governed	1	`/graph/orchestrate`
`graph_pipeline`	act, ask	a composable train→eval→serve→predict ML pipeline over a VERSIONED ':Model' artifact that	1	`/pipeline/train`
`graph_projection`	ask	run the SAME query `graph_query` will and project the result into a stable node-link JSON shape:	1	`/graph/projection`
`graph_promql`	ask	query the engine's observability metrics with PromQL. action='instant' (a single evaluation at	2	`/graph/promql`
`graph_query`	ask	Run a read-only Cypher, bounded UQL, SQL, SPARQL, or federated graph query and return the sole	1	`/graph/query`
`graph_reach`	act	reach the user over a messaging backend (Telegram, Slack, Discord, ...).	5	`/graph/reach`
`graph_runvcs`	act	Agent-native run version-control (CONCEPT:AU-ORCH.runvcs.run-commit): fork, revert and review a	11	`/graph/runvcs`
`graph_sandbox`	act	Inspect and control the native warm-fork sandbox runtime	3	`/graph/sandbox`
`graph_schedules`	manage, act	Inspect and control the unified scheduler (CONCEPT:AU-OS.state.unified-scheduling-one-intelligent).	6	`/graph/schedules`
`graph_search`	ask	Search the Knowledge Graph using multiple strategies (hybrid, concept, analogy, memory, discover,	1	`/graph/search`
`graph_search_synthesis`	ask	Synthesize a shortcut-resistant deep-search task from the evidence graph, or diagnose realized	2	`/graph/search-synthesis`
`graph_secret`	manage	Manage secrets (CONCEPT:AU-OS.identity.encrypted-secret-store) in the durable, engine-encrypted	4	`/graph/secret`
`graph_sessions`	manage, ask	Manage durable sessions (action in 'list', 'get', 'remove', 'reply', 'cancel', 'health',	7	`/graph/sessions`
`graph_share`	write, manage	Share a private node (CONCEPT:AU-KG.compute.data-is-private-its).	7	`/graph/share`
`graph_table`	ask, write	mirror data into native engine SQL tables (DataFusion + pg-wire) and manage them.	6	`/graph/table`
`graph_traces`	ask, why	search or fetch distributed traces. action='search' (filter by 'service'/'operation'/free-form	3	`/graph/traces`
`graph_viz`	act, ask	GOC-88/D-VZ-1 V5: render native charts through the engine's LOD ColumnStore/export pipeline	4	`/graph/viz`
`graph_workflows`	act, ask, manage	Manage governed WorkflowDefinitions.	8	`/graph/workflows`
`graph_write`	write	Write nodes, relationships, or register external graphs to the Knowledge Graph.	14	`/graph/write`
`graph_writeback`	write	Backfeed KG-derived knowledge into an external system-of-record	1	`/graph/writeback`
`ingest_sessions`	write	Ingest AI agent chat/session history into the usage store + KG	3	`/usage/ingest-sessions`
`manage`	manage	Configure and govern graph-os and fleet loading; previews first, then run with plan_ref.	1	`/intent/manage`
`nl_query`	ask	ask the Knowledge Graph in plain English, planned by agent-utilities' OWN configured fleet LLM (the	1	`/graph/nl-query`
`object_edits`	write	Durable object-edit ledger (CONCEPT:AU-KG.ontology.edit-ledger-writeback): record a structured edit	4	`/object/edits`
`object_index`	ask, find	Object Index Lifecycle / Object Data Funnel (CONCEPT:AU-KG.ontology.batch-incremental-sync-live):	3	`/object/index`
`object_permissioning`	manage	Fine-grained object permissioning (CONCEPT:AU-KG.ontology.redact-object-materialize-restricted):	3	`/object/permissioning`
`object_set`	ask, write	Object Set Service (CONCEPT:AU-KG.ontology.link-type-pivot/2.38):	10	`/object/set`
`ontology_classification_claims`	write, ask	Typed, provenance-bearing multi-category classification claims (U-47,	11	`/ontology/classification-claims`
`ontology_derive`	write	Compute derived (function/cypher/sparql/embedding-backed) properties live at read time	5	`/ontology/derive`
`ontology_function`	act, write	Typed, versioned ontology functions: list or invoke through the governed runtime	2	`/ontology/function`
`ontology_interface`	manage, ask	Ontology interfaces: resolve implementers (targeting), check conformance, or emit OWL	8	`/ontology/interface`
`ontology_leanix_sync`	write	Discover the live LeanIX metamodel and mirror it natively as OWL/RDF: regenerates	1	`/ontology/leanix-sync`
`ontology_link_materialize`	write	Reify a multiple-to-multiple ontology link as a (junction_node, edge_a, edge_b) triple and write it	1	`/ontology/link-materialize`
`ontology_model_profile`	manage, ask	Model profiles as first-class graph resources	4	`/ontology/model-profiles`
`ontology_property_types`	manage, ask	List the ontology property-type registry and resolve/validate a Palantir-style type ref	4	`/ontology/property-types`
`ontology_repository_provenance`	write	Git identity and history anchors (U-47, CONCEPT:AU-KG.ontology.repository-provenance-snapshot),	4	`/ontology/repository-provenance`
`ontology_sampling_profile`	manage, ask	Task-aware LLM sampling profiles (CONCEPT:AU-ORCH.routing.sampling-profile-selection/KG-2.94):	6	`/ontology/sampling-profiles`
`ontology_value_types`	manage, ask	List/describe constrained ontology value types and validate or coerce a value	4	`/ontology/value-types`
`quant`	ask, act	The Ultimate Quant System Tool.	14	`/quant`
`research_artifact`	ask, write	Agent-Native Research Artifacts over the one ontology-driven KG	1	`/research/artifact`
`skill_classify`	write	Classify a skill (skill_id from /api/enhanced/tools' skills[]/skill_workflows[]/skill_graphs[] .id,	1	`/skill/classify`
`source_connector`	manage, write	Document-source connectors (CONCEPT:AU-ECO.connector.document-source-framework–4.29, KG-2.59): list	2	`/connector/source`
`source_drain`	write	Watch a chunked async drain started by source_sync(mode='full') on a LARGE corpus	1	`/source/drain`
`source_sync`	write	THE canonical connector→KG ingestion tool (CONCEPT:AU-KG.ingest.enterprise-source-extractor) — one	1	`/source/sync`
`spec_ticket`	write, ask	Link a KG SDD spec/feature to a Plane/Jira work item and make agents assignable	1	`/spec/ticket`
`tabular_query`	ask	Run a read-only SQL projection through the governed tabular query service and return its typed	1	`/query/tabular`
`usage_query`	ask	Query usage/cost/observability analytics (CONCEPT:AU-ECO.mcp.usage-cost-observability-surface):	12	`/usage/query`
`why`	why	Explain beliefs, decisions, provenance and changes. action='.' (see action='describe'),	1	`/intent/why`
`write`	write	Create or change graph data; previews first, then run with plan_ref. action='.' (see	1	`/intent/write`

Capabilities¶

`act`¶

act

Run work, an operation or a fleet tool. Previews first, then run with plan_ref. action='.' (see action='describe'), or leave it empty to route intent.

Intent verbs: act
REST route: /intent/act
MCP tags: intent
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

act → (no EG ledger match)

Typed input:

action (string): Operation id ('.' or '') or 'describe'; empty routes intent.
params (object): Operation arguments. With action='describe', {'action': ''} returns that operation's argument schema.
intent (string): Natural-language request, routed when action is empty.
execute (boolean): Run now; when false, return the resolved plan.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`agent_library`¶

agent library

The Agent Library of built agents (system prompt, tools, skills, model profile, context policy, role), stored in the knowledge graph.

Intent verbs: manage, find, ask
REST route: /graph/agent-library
MCP tags: agent-library, agent_execution, agents, granular, graph-os
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

get → (no EG ledger match)
list → (no EG ledger match)
save → (no EG ledger match)
seed_roles → (no EG ledger match)

Typed input:

action (string): list | get | save | seed_roles
agent_id (string): Agent id (action=get).
kind (string): list filter: local | role | agent_graph.
agent_json (string): JSON agent record (action=save).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ask`¶

ask

Read or answer from the Knowledge Graph. action='.' (see action='describe'), or leave it empty to route intent.

Intent verbs: ask
REST route: /intent/ask
MCP tags: intent
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

ask → (no EG ledger match)

Typed input:

action (string): Operation id ('.' or '') or 'describe'; empty routes intent.
params (object): Operation arguments. With action='describe', {'action': ''} returns that operation's argument schema.
intent (string): Natural-language request, routed when action is empty.
execute (boolean): Run now; when false, return the resolved plan.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ask_data`¶

ask data

answer a DATA question over the Knowledge Graph with a DB-GPT-style, multi-step data-analysis agent (distinct from the single-shot nl_query).

Intent verbs: ask
REST route: /graph/ask-data
MCP tags: data-analysis, granular, graph-os, nl, query
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

ask_data → (no EG ledger match)

Typed input:

question (string, required): The natural-language DATA question to answer.
dialect (string): 'auto' (planner chooses, prefers uql) or 'uql'|'cypher'|'sql'|'sparql'.
max_corrections (integer): Bounded self-correction retries after a failed query (0 disables).
limit (integer): Max result rows to return.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`concept_registry`¶

concept registry

Coordinate canonical OKF-CIS concept ids for linked worktrees on one host (CONCEPT:AU-OS.governance.atomic-concept-id-reservation).

Intent verbs: find, ask
REST route: /concept/registry
MCP tags: concept, governance, granular, graph-os, ontology
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

concept_registry → (no EG ledger match)

Typed input:

action (string): 'reserve', 'list', 'release', or 'reconcile'.
session_id (string): Optional claiming session value; only a digest is persisted.
design_doc (string): Optional design reference; only a digest is persisted.
concept_id (string): Canonical ID for reserve or release.
status (string): For 'list': filter by status (reserved/materialized/landed/released/expired/tombstoned).
ttl_seconds (integer): Reservation TTL before it is reclaimable.
repo (string): Repo root whose ledger to use (defaults to agent-utilities).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`document_process`¶

document process

Document → ontology processing (CONCEPT:AU-KG.ingest.chunk-overlap-stage): extract → chunk(overlap) → embed → materialize a Document + linked Chunk objects through the live graph write path.

Intent verbs: write
REST route: /document/process
MCP tags: granular, graph-os, ontology
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

document_process → (no EG ledger match)

Typed input:

document (string, required): A file path or raw text content to process.
text (string): Optional pre-extracted text (OCR/external).
source (string): Provenance label (path/URL).
chunk_size (integer): Target chunk size in characters.
overlap (integer): Overlap characters between chunks.
contextual (boolean): Enable contextual-retrieval enrichment (CONCEPT:AU-KG.enrichment.contextual-retrieval-enrichment): situate each chunk within the document and embed context+chunk for better recall.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_admin`¶

engine admin

Low-level epistemic-graph engine surface for the 'admin' domain (ops/maintenance: online backup + restore (ADMIN)).

Intent verbs: manage
REST route: /engine/admin
MCP tags: admin, engine, granular, graph-os
Side effects: 4/6 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'None']; txn=['Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

audit_append → (no EG ledger match)
audit_prove_inclusion → EG AuditProveInclusion (confidence 1.0)
audit_read_event → (no EG ledger match)
audit_verify → EG AuditVerify (confidence 1.0)
backup → EG Backup (confidence 1.0)
restore → EG Restore (confidence 1.0)

Typed input:

action (string): engine_admin method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_analytics`¶

engine analytics

Low-level epistemic-graph engine surface for the 'analytics' domain (centrality + (personalized) PageRank).

Intent verbs: ask
REST route: /engine/analytics
MCP tags: analytics, engine, granular, graph-os
Side effects: 3/5 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

betweenness_centrality → EG BetweennessCentrality (confidence 1.0)
degree_centrality → EG DegreeCentrality (confidence 1.0)
degree_centrality_all → EG DegreeCentrality (confidence 1.0)
pagerank → (no EG ledger match)
personalized_pagerank → (no EG ledger match)

Typed input:

action (string): engine_analytics method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_blob`¶

engine blob

Low-level epistemic-graph engine surface for the 'blob' domain (streamed content-addressed media blobs).

Intent verbs: write
REST route: /engine/blob
MCP tags: blob, engine, granular, graph-os
Side effects: 9/11 actions matched an EG ledger Method; any_mutates=True; durability=['BlobRedb', 'None']; txn=['Atomic', 'Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

begin → EG BlobBegin (confidence 1.0)
chunk_get → EG BlobChunkGet (confidence 1.0)
chunk_put → EG BlobChunkPut (confidence 1.0)
commit → EG BlobCommit (confidence 1.0)
fetch → EG BlobChunkGet (confidence 0.667)
fetch_begin → EG BlobBegin (confidence 1.0)
fetch_end → EG BlobFetchEnd (confidence 1.0)
gc → EG BlobGc (confidence 1.0)
incref → (no EG ledger match)
store → (no EG ledger match)
unref → EG BlobUnref (confidence 1.0)

Typed input:

action (string): engine_blob method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_broker`¶

engine broker

Low-level epistemic-graph engine surface for the 'broker' domain (native message broker: exchange/queue/stream admin + routed publish/consume).

Intent verbs: act, manage, ask
REST route: /engine/broker
MCP tags: broker, engine, granular, graph-os
Side effects: 22/22 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'None', 'Outbox']; txn=['Atomic', 'Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

ack → EG BrokerAck (confidence 1.0)
ack_tag → EG BrokerAck (confidence 1.0)
bind_queue → EG BindQueue (confidence 1.0)
consume → EG BrokerConsume (confidence 1.0)
declare_exchange → EG DeclareExchange (confidence 1.0)
declare_queue → EG DeclareQueue (confidence 1.0)
delete_exchange → EG DeleteExchange (confidence 1.0)
nack_tag → EG BrokerNackTag (confidence 1.0)
publish → EG Publish (confidence 1.0)
publish_confirmed → EG Publish (confidence 1.0)
publish_ex → EG Publish (confidence 1.0)
publish_idempotent → EG Publish (confidence 1.0)
reject → EG BrokerReject (confidence 1.0)
renew_tag → EG BrokerRenewTag (confidence 1.0)
stream_commit_offset → EG Commit (confidence 1.0)
stream_committed_offset → EG StreamCommittedOffset (confidence 1.0)
stream_declare → EG StreamDeclare (confidence 1.0)
stream_publish → EG Publish (confidence 1.0)
stream_read → EG StreamRead (confidence 1.0)
stream_trim → EG StreamTrim (confidence 1.0)
sweep_expired → EG SweepExpired (confidence 1.0)
unbind_queue → EG UnbindQueue (confidence 1.0)

Typed input:

action (string): engine_broker method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_channels`¶

engine channels

Low-level epistemic-graph engine surface for the 'channels' domain (dynamic agent communication channels).

Intent verbs: act
REST route: /engine/channels
MCP tags: channels, engine, granular, graph-os
Side effects: 8/8 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'None']; txn=['Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

close → EG CloseChannel (confidence 1.0)
create → EG CreateChannel (confidence 1.0)
get_members → EG GetChannelMembers (confidence 1.0)
get_messages → EG GetChannelMessages (confidence 1.0)
join → EG JoinChannel (confidence 1.0)
leave → EG LeaveChannel (confidence 1.0)
list → EG ListChannels (confidence 1.0)
send_message → EG SendMessage (confidence 1.0)

Typed input:

action (string): engine_channels method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_consensus`¶

engine consensus

Low-level epistemic-graph engine surface for the 'consensus' domain (zero-trust identity + multisig mutation).

Intent verbs: act
REST route: /engine/consensus
MCP tags: admin, consensus, engine, granular, graph-os
Side effects: 4/5 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'GraphRedb', 'None']; txn=['Atomic', 'Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

apply_multisig_mutation → EG ApplyMultisigMutation (confidence 1.0)
bootstrap_system_identity → EG GetIdentity (confidence 0.5)
check_access → (no EG ledger match)
get_identity → EG GetIdentity (confidence 1.0)
register_identity → EG RegisterIdentity (confidence 1.0)

Typed input:

action (string): engine_consensus method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_datascience`¶

engine datascience

Low-level epistemic-graph engine surface for the 'datascience' domain (estimators + primitives + training kernels).

Intent verbs: ask
REST route: /engine/datascience
MCP tags: datascience, engine, granular, graph-os
Side effects: 0/15 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

adam_step → (no EG ledger match)
compute_stats → (no EG ledger match)
cross_entropy → (no EG ledger match)
dpo_loss → (no EG ledger match)
fit_estimator → (no EG ledger match)
grpo_surrogate → (no EG ledger match)
kl_divergence → (no EG ledger match)
kmeans → (no EG ledger match)
linear_regression → (no EG ledger match)
log_softmax → (no EG ledger match)
pca → (no EG ledger match)
predict_estimator → (no EG ledger match)
sgd_step → (no EG ledger match)
softmax → (no EG ledger match)
train_test_split → (no EG ledger match)

Typed input:

action (string): engine_datascience method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_edges`¶

engine edges

Low-level epistemic-graph engine surface for the 'edges' domain (edge CRUD, temporal invalidate/supersede, batch reads).

Intent verbs: write
REST route: /engine/edges
MCP tags: edges, engine, granular, graph-os
Side effects: 9/10 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add → EG AddEdge (confidence 1.0)
count → EG EdgeCount (confidence 1.0)
has → EG HasEdge (confidence 1.0)
invalidate → EG InvalidateEdge (confidence 1.0)
list → (no EG ledger match)
list_page → EG GetEdgesPage (confidence 0.667)
properties → EG GetEdgeProperties (confidence 0.667)
properties_batch → EG GetEdgePropertiesBatch (confidence 0.75)
remove → EG RemoveEdge (confidence 1.0)
supersede → EG SupersedeEdge (confidence 1.0)

Typed input:

action (string): engine_edges method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_finance`¶

engine finance

Low-level epistemic-graph engine surface for the 'finance' domain (quantitative finance (optimize/risk/regime/signals/HFT/derivatives)).

Intent verbs: ask, act
REST route: /engine/finance
MCP tags: engine, finance, granular, graph-os
Side effects: 67/67 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['None']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

adf_test → EG FinanceAdfTest (confidence 1.0)
alpha_combination_engine → EG FinanceAlphaCombinationEngine (confidence 1.0)
avellaneda_stoikov → EG FinanceAvellanedaStoikov (confidence 1.0)
bayesian_kelly → EG FinanceBayesianKelly (confidence 1.0)
black_litterman → EG FinanceBlackLitterman (confidence 1.0)
breakeven_alpha → EG FinanceBreakevenAlpha (confidence 1.0)
brier_score → EG FinanceBrierScore (confidence 1.0)
combine_alphas → EG FinanceCombineAlphas (confidence 1.0)
convergence_gate → EG FinanceConvergenceGate (confidence 1.0)
cross_sectional_rank → EG FinanceCrossSectionalRank (confidence 1.0)
cvar → EG FinanceCvar (confidence 1.0)
deflated_sharpe → EG FinanceDeflatedSharpe (confidence 1.0)
detect_regimes → EG FinanceDetectRegimes (confidence 1.0)
diebold_mariano → EG FinanceDieboldMariano (confidence 1.0)
downside_deviation → EG FinanceDownsideDeviation (confidence 1.0)
drawdown_series → EG FinanceDrawdownSeries (confidence 1.0)
effective_independent_n → EG FinanceEffectiveIndependentN (confidence 1.0)
efficient_frontier → EG FinanceEfficientFrontier (confidence 1.0)
empirical_kelly → EG FinanceEmpiricalKelly (confidence 1.0)
expected_pnl_rate → EG FinanceExpectedPnlRate (confidence 1.0)
forensic_report → EG FinanceForensicReport (confidence 1.0)
glosten_milgrom_spread → EG FinanceGlostenMilgromSpread (confidence 1.0)
glt_quotes → EG FinanceGltQuotes (confidence 1.0)
hardiman_bouchaud → EG FinanceHardimanBouchaud (confidence 1.0)
hawkes_mle → EG FinanceHawkesMle (confidence 1.0)
information_coefficient → EG FinanceInformationCoefficient (confidence 1.0)
information_ratio → EG FinanceInformationRatio (confidence 1.0)
kalman_beta → EG FinanceKalmanBeta (confidence 1.0)
kalman_filter_1d → EG FinanceKalmanBeta (confidence 0.667)
kalman_volatility → EG FinanceKalmanVolatility (confidence 1.0)
kelly_fraction → EG FinanceKellyFraction (confidence 1.0)
kyle_lambda → EG FinanceKyleLambda (confidence 1.0)
logit_quotes → EG FinanceLogitQuotes (confidence 1.0)
market → EG FinanceMarketImpact (confidence 0.667)
market_impact → EG FinanceMarketImpact (confidence 1.0)
markov_transition_matrix → EG FinanceMarkovTransitionMatrix (confidence 1.0)
match_orders → EG FinanceMatchOrders (confidence 1.0)
max_drawdown → EG FinanceMaxDrawdown (confidence 1.0)
mean_reversion → EG FinanceMeanReversion (confidence 1.0)
microprice_series → EG FinanceMicropriceSeries (confidence 1.0)
momentum → EG FinanceMomentum (confidence 1.0)
monte_carlo_var → EG FinanceMonteCarloVar (confidence 1.0)
ofi_series → EG FinanceOfiSeries (confidence 1.0)
optimize_portfolio → EG FinanceOptimizePortfolio (confidence 1.0)
order_book_imbalance → EG FinanceOrderBookImbalance (confidence 1.0)
ou_calibrate → EG FinanceOuCalibrate (confidence 1.0)
ou_optimal_thresholds → EG FinanceOuOptimalThresholds (confidence 1.0)
pairs_trading → EG FinancePairsTrading (confidence 1.0)
posterior_credible_interval → EG FinancePosteriorCredibleInterval (confidence 1.0)
probability_backtest_overfit → EG FinanceProbabilityBacktestOverfit (confidence 1.0)
purged_cpcv → EG FinancePurgedCpcv (confidence 1.0)
queue_imbalance → EG FinanceQueueImbalance (confidence 1.0)
realized_vol_tick → EG FinanceRealizedVolTick (confidence 1.0)
risk_metrics → EG FinanceRiskMetrics (confidence 1.0)
risk_parity → EG FinanceRiskParity (confidence 1.0)
sabr_calibrate → EG FinanceSabrCalibrate (confidence 1.0)
sabr_implied_vol → EG FinanceSabrImpliedVol (confidence 1.0)
sabr_smile → EG FinanceSabrSmile (confidence 1.0)
signal_decay → EG FinanceSignalDecay (confidence 1.0)
signal_models → EG FinanceSignalDecay (confidence 0.667)
... and 7 more actions

Typed input:

action (string): engine_finance method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_graph`¶

engine graph

Low-level epistemic-graph engine surface for the 'graph' domain (graph algorithms, AST parse/index, semantic+embedding compute).

Intent verbs: ask, write
REST route: /engine/graph
MCP tags: engine, granular, graph, graph-os
Side effects: 25/27 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'None', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_embedding → EG AddEmbedding (confidence 1.0)
batch_l2_normalize → EG BatchL2Normalize (confidence 1.0)
blast_radius → (no EG ledger match)
clear → EG ClearGraph (confidence 1.0)
cluster_hierarchy_clusters → EG ClusterHierarchyClusters (confidence 1.0)
cluster_hierarchy_expand → EG ClusterHierarchyExpand (confidence 1.0)
cluster_hierarchy_refresh → EG ClusterHierarchyRefresh (confidence 1.0)
community_detect_ephemeral → EG CommunityDetectEphemeral (confidence 1.0)
community_detection → EG CommunityDetection (confidence 1.0)
compute_similarity_edges → EG ComputeSimilarityEdges (confidence 1.0)
connected_components → EG ConnectedComponents (confidence 1.0)
discover → EG Discover (confidence 1.0)
find_cycle → EG FindCycle (confidence 1.0)
get_subgraph → EG GetSubgraph (confidence 1.0)
graph_coloring → EG GraphColoring (confidence 1.0)
index_repository → EG IndexRepository (confidence 1.0)
match_ontology_terms → EG MatchOntologyTerms (confidence 1.0)
minimum_spanning_tree → EG MinimumSpanningTree (confidence 1.0)
observe_screen → EG ObserveScreen (confidence 1.0)
parse_file → EG ParseFile (confidence 1.0)
parse_files → EG ParseFiles (confidence 1.0)
resolve_candidates → EG ResolveCandidates (confidence 1.0)
semantic_search → EG SemanticSearch (confidence 1.0)
shortest_path → (no EG ledger match)
strongly_connected_components → EG ConnectedComponents (confidence 1.0)
topological_sort → EG TopologicalSort (confidence 1.0)
vf2_subgraph_match → EG Vf2SubgraphMatch (confidence 1.0)

Typed input:

action (string): engine_graph method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_graphlearn`¶

engine graphlearn

Low-level epistemic-graph engine surface for the 'graphlearn' domain (KAN graph-learning: fit/predict a learned per-feature edge-function link predictor).

Intent verbs: act, ask
REST route: /engine/graphlearn
MCP tags: engine, granular, graph-os, graphlearn
Side effects: 2/2 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb']; txn=['Atomic']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

fit → EG GraphLearnFit (confidence 1.0)
predict → EG GraphLearnPredict (confidence 1.0)

Typed input:

action (string): engine_graphlearn method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_ledger`¶

engine ledger

Low-level epistemic-graph engine surface for the 'ledger' domain (audit ledger get/clear/apply).

Intent verbs: write, act
REST route: /engine/ledger
MCP tags: engine, granular, graph-os, ledger
Side effects: 4/4 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

apply → EG ApplyLedger (confidence 1.0)
clear → EG ClearLedger (confidence 1.0)
get → EG GetLedger (confidence 1.0)
get_with_watermark → EG GetLedger (confidence 1.0)

Typed input:

action (string): engine_ledger method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_lifecycle`¶

engine lifecycle

Low-level epistemic-graph engine surface for the 'lifecycle' domain (prune/decay/evict, batch_update, context view, (de)serialize).

Intent verbs: manage, act
REST route: /engine/lifecycle
MCP tags: engine, granular, graph-os, lifecycle
Side effects: 10/10 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'None', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

batch_update → EG BatchUpdate (confidence 1.0)
decay_sweep → EG DecayNode (confidence 1.0)
evict_lru → EG EvictLRU (confidence 1.0)
from_msgpack → EG FromMsgpack (confidence 1.0)
get_context_view → EG GetContextView (confidence 1.0)
metrics → EG Metrics (confidence 1.0)
multi_graph_batch_update → EG BatchUpdate (confidence 1.0)
prune → EG PruneByLifecycle (confidence 0.667)
to_msgpack → EG ToMsgpack (confidence 1.0)
touch_nodes → EG TouchNodes (confidence 1.0)

Typed input:

action (string): engine_lifecycle method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_mining`¶

engine mining

Low-level epistemic-graph engine surface for the 'mining' domain (association-rule mining (Apriori/FP-Growth/Eclat: support/confidence/lift)).

Intent verbs: ask
REST route: /engine/mining
MCP tags: engine, granular, graph-os, mining
Side effects: 18/18 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

anomaly → EG MineAnomaly (confidence 1.0)
associate → EG MineAssociate (confidence 1.0)
causal_impact → EG MineCausalImpact (confidence 1.0)
classify_fit → EG MineClassifyFit (confidence 1.0)
classify_predict → EG MineClassifyPredict (confidence 1.0)
cluster → EG MineCluster (confidence 1.0)
community → EG MineCommunity (confidence 1.0)
entity_resolve → EG MineEntityResolve (confidence 1.0)
forecast → EG MineForecast (confidence 1.0)
ontology_gap → EG MineOntologyGap (confidence 1.0)
process → EG MineProcess (confidence 1.0)
reduce → EG MineReduce (confidence 1.0)
retrieval_quality → EG MineRetrievalQuality (confidence 1.0)
risk_propagation → EG MineRiskPropagation (confidence 1.0)
root_cause → EG MineRootCause (confidence 1.0)
sequence → EG MineSequence (confidence 1.0)
subgraph → EG MineSubgraph (confidence 1.0)
text → EG MineText (confidence 1.0)

Typed input:

action (string): engine_mining method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_modalities`¶

engine modalities

Low-level epistemic-graph engine surface for the 'modalities' domain (native document/image/audio/video ingest, typed region/window query, lifecycle (cold/restore/remove/tombstone), and events (B-12)).

Intent verbs: write, ask
REST route: /engine/modalities
MCP tags: engine, granular, graph-os, modalities
Side effects: 1/16 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb']; txn=['Saga']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

authority → (no EG ledger match)
capabilities → (no EG ledger match)
collect_tombstones → (no EG ledger match)
delete → (no EG ledger match)
events → (no EG ledger match)
ingest → (no EG ledger match)
ingest_stream → (no EG ledger match)
move_to_cold → (no EG ledger match)
query → (no EG ledger match)
query_audio_window → (no EG ledger match)
query_image_region → (no EG ledger match)
query_similar_images → (no EG ledger match)
query_video_window → (no EG ledger match)
restore → EG Restore (confidence 1.0)
search_documents → (no EG ledger match)
stats → (no EG ledger match)

Typed input:

action (string): engine_modalities method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_nodes`¶

engine nodes

Low-level epistemic-graph engine surface for the 'nodes' domain (node CRUD, batch/union reads, degree/neighbour queries).

Intent verbs: write, ask
REST route: /engine/nodes
MCP tags: engine, granular, graph-os, nodes
Side effects: 18/22 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'Snapshot']
Cost: (unmeasured)
Latency: {'add': {'eg_method': 'AddNode', 'p50_ms': 0.187, 'p99_ms': 0.223, 'source': 'epistemic-graph/docs/benchmarks.md#results (2026-06-01, UDS, in-memory graph)', 'kind': 'measured'}, 'claim_next': {'eg_method': 'ClaimNext', 'source': "epistemic-graph/docs/benchmarks-soak.md (queue/claim primitive is measured in the same soak run; approximates AgentBus queue latency per that doc's own caveat — see the doc for the current number, not duplicated here to avoid a second copy drifting from the source)", 'kind': 'measured'}, 'compare_and_set': {'eg_method': 'CompareAndSetNodeFields', 'p50_ms': 14.17, 'p95_ms': 43.72, 'p99_ms': 57.24, 'source': 'epistemic-graph/docs/benchmarks-soak.md#phase-a (2026-07-11 soak run, shared/contended box — upper bound per source doc)', 'kind': 'measured'}, 'properties': {'eg_method': 'GetNodeProperties', 'p50_ms': 0.179, 'p99_ms': 0.21, 'source': 'epistemic-graph/docs/benchmarks.md#results (2026-06-01, UDS, in-memory graph)', 'kind': 'measured'}}
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add → EG AddNode (confidence 1.0)
claim_next → EG ClaimNext (confidence 1.0)
compare_and_set → EG CompareAndSetNodeFields (confidence 0.8)
count → EG NodeCount (confidence 1.0)
create_if_absent → EG CreateNodeIfAbsent (confidence 1.0)
has → EG HasNode (confidence 1.0)
has_batch → EG HasNode (confidence 1.0)
ids → EG NodeIds (confidence 1.0)
in_degree → EG InDegree (confidence 1.0)
list → (no EG ledger match)
list_by_label → EG GetNodesByLabel (confidence 0.75)
list_by_label_union → EG UnionGetNodesByLabel (confidence 0.8)
neighbors → (no EG ledger match)
neighbors_batch → EG HasNodesBatch (confidence 0.667)
neighbors_union → EG UnionGetNodeProperties (confidence 0.5)
out_degree → EG OutDegree (confidence 1.0)
predecessors → (no EG ledger match)
properties → EG GetNodeProperties (confidence 0.667)
properties_batch → EG GetNodePropertiesBatch (confidence 0.75)
properties_union → EG UnionGetNodeProperties (confidence 0.75)
remove → EG RemoveNode (confidence 1.0)
successors → (no EG ledger match)

Typed input:

action (string): engine_nodes method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_placement`¶

engine placement

Low-level epistemic-graph engine surface for the 'placement' domain (DIST-P2-1 raft PlacementCatalog: route (read) + assign/move/abort_move admin (raft/cluster only)).

Intent verbs: manage, ask
REST route: /engine/placement
MCP tags: admin, engine, granular, graph-os, placement
Side effects: 1/4 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

abort_move → (no EG ledger match)
assign → (no EG ledger match)
move → (no EG ledger match)
route → EG PlacementRoute (confidence 1.0)

Typed input:

action (string): engine_placement method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_query`¶

engine query

Low-level epistemic-graph engine surface for the 'query' domain (SQL / Cypher / GraphQL / UQL / unified cross-modal query / federation).

Intent verbs: ask
REST route: /engine/query
MCP tags: engine, granular, graph-os, query
Side effects: 24/26 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'GraphRedb', 'None', 'ReasoningProjection']; txn=['Atomic', 'Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

causal_counterfactual → EG CausalCounterfactual (confidence 1.0)
causal_estimate → EG CausalEstimate (confidence 1.0)
cypher_read → EG CypherQuery (confidence 1.0)
cypher_write → EG CypherQuery (confidence 1.0)
epistemic_status → EG EpistemicStatus (confidence 1.0)
explain_belief → EG ExplainBelief (confidence 1.0)
explain_evidence → EG ExplainEvidence (confidence 1.0)
explain_plan → EG ExplainPlan (confidence 1.0)
explain_policy → EG ExplainPolicy (confidence 1.0)
explain_provenance → EG ExplainProvenance (confidence 1.0)
explain_provenance_by_ids → EG ExplainProvenance (confidence 1.0)
export_sqlite_file → EG ExportSqliteFile (confidence 1.0)
graphql → (no EG ledger match)
import_sqlite_file → EG ImportSqliteFile (confidence 1.0)
materialization_status → EG MaterializationStatus (confidence 1.0)
nl_query → EG NlQuery (confidence 1.0)
rank_by_provenance → EG RankByProvenance (confidence 1.0)
recompute_materialization → EG RecomputeMaterialization (confidence 1.0)
register_foreign_source → EG RegisterForeignSource (confidence 1.0)
resolve_conflict → EG ResolveConflict (confidence 1.0)
sql → EG Sql (confidence 1.0)
sql_source_batch → EG Sql (confidence 1.0)
stale_materializations → EG StaleMaterializations (confidence 1.0)
unified → EG UnifiedQuery (confidence 1.0)
uql → (no EG ledger match)
what_changed → EG WhatChanged (confidence 1.0)

Typed input:

action (string): engine_query method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_rbac`¶

engine rbac

Low-level epistemic-graph engine surface for the 'rbac' domain (RBAC policy administration: roles + resource/action grants (ADMIN)).

Intent verbs: manage
REST route: /engine/rbac
MCP tags: admin, engine, granular, graph-os, rbac
Side effects: 0/5 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_grant → (no EG ledger match)
add_role → (no EG ledger match)
list → (no EG ledger match)
remove_grant → (no EG ledger match)
remove_role → (no EG ledger match)

Typed input:

action (string): engine_rbac method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_rdf`¶

engine rdf

Low-level epistemic-graph engine surface for the 'rdf' domain (RDF triples + SPARQL + OWL reasoning).

Intent verbs: write, ask
REST route: /engine/rdf
MCP tags: engine, granular, graph-os, rdf
Side effects: 12/14 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['Atomic', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_triples → EG AddTriples (confidence 1.0)
drop_named_graph → EG DropNamedGraph (confidence 1.0)
explain → (no EG ledger match)
get_rdf → EG GetRdf (confidence 1.0)
icv_configure → EG IcvConfigure (confidence 1.0)
owl_reason → EG OwlReason (confidence 1.0)
owl_reason_distributed → EG OwlReason (confidence 1.0)
remove_triples → EG RemoveTriples (confidence 1.0)
sparql → EG Sparql (confidence 1.0)
sparql_explain → EG Sparql (confidence 1.0)
sparql_result → EG Sparql (confidence 1.0)
sparql_virtual → EG Sparql (confidence 1.0)
validate_committed → (no EG ledger match)
validate_shacl → EG ShaclValidate (confidence 1.0)

Typed input:

action (string): engine_rdf method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_reasoning`¶

engine reasoning

Low-level epistemic-graph engine surface for the 'reasoning' domain (forward-chaining OWL/RDFS Datalog closure).

Intent verbs: why
REST route: /engine/reasoning
MCP tags: engine, granular, graph-os, reasoning
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

reason → (no EG ledger match)

Typed input:

action (string): engine_reasoning method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_resharding`¶

engine resharding

Low-level epistemic-graph engine surface for the 'resharding' domain (M3 catalog/reshard/rebalance admin (redb)).

Intent verbs: manage
REST route: /engine/resharding
MCP tags: admin, engine, granular, graph-os, resharding
Side effects: 7/7 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'None']; txn=['Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

catalog_assign → EG CatalogAssign (confidence 1.0)
catalog_list → EG CatalogList (confidence 1.0)
catalog_reassign → EG CatalogReassign (confidence 1.0)
catalog_remove → EG CatalogRemove (confidence 1.0)
rebalance_execute → EG RebalanceExecute (confidence 1.0)
rebalance_plan → EG RebalancePlan (confidence 1.0)
reshard → EG Reshard (confidence 1.0)

Typed input:

action (string): engine_resharding method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_streaming`¶

engine streaming

Low-level epistemic-graph engine surface for the 'streaming' domain (CDC / continuous queries / watch / triggers).

Intent verbs: act
REST route: /engine/streaming
MCP tags: engine, granular, graph-os, streaming
Side effects: 13/13 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'None']; txn=['None', 'Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

cdc_read → EG CdcRead (confidence 1.0)
cdc_read_with_watermark → EG CdcRead (confidence 1.0)
cep_poll → EG CepPoll (confidence 1.0)
cep_subscribe → EG CepSubscribe (confidence 1.0)
cep_unsubscribe → EG CepUnsubscribe (confidence 1.0)
drop_continuous_query → EG DropContinuousQuery (confidence 1.0)
drop_trigger → EG DropTrigger (confidence 1.0)
fired_triggers → EG FiredTriggers (confidence 1.0)
list_triggers → EG ListTriggers (confidence 1.0)
read_continuous_query → EG ReadContinuousQuery (confidence 1.0)
register_continuous_query → EG RegisterContinuousQuery (confidence 1.0)
register_trigger → EG RegisterTrigger (confidence 1.0)
watch → EG Watch (confidence 1.0)

Typed input:

action (string): engine_streaming method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_tenants`¶

engine tenants

Low-level epistemic-graph engine surface for the 'tenants' domain (multi-tenant graph create/remove/list).

Intent verbs: manage
REST route: /engine/tenants
MCP tags: admin, engine, granular, graph-os, tenants
Side effects: 2/3 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb']; txn=['Atomic']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

create → EG CreateGraph (confidence 1.0)
delete → EG DeleteGraph (confidence 1.0)
list → (no EG ledger match)

Typed input:

action (string): engine_tenants method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_timeseries`¶

engine timeseries

Low-level epistemic-graph engine surface for the 'timeseries' domain (native TSDB append/range/window/asof/gapfill).

Intent verbs: write, ask
REST route: /engine/timeseries
MCP tags: engine, granular, graph-os, timeseries
Side effects: 0/10 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

append → (no EG ledger match)
asof_join → (no EG ledger match)
define_series → (no EG ledger match)
delete_series → (no EG ledger match)
evict_before → (no EG ledger match)
gap_fill → (no EG ledger match)
list_series → (no EG ledger match)
range → (no EG ledger match)
register_series → (no EG ledger match)
window → (no EG ledger match)

Typed input:

action (string): engine_timeseries method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_txn`¶

engine txn

Low-level epistemic-graph engine surface for the 'txn' domain (server-side OCC ACID transactions).

Intent verbs: act
REST route: /engine/txn
MCP tags: engine, granular, graph-os, txn
Side effects: 17/18 actions matched an EG ledger Method; any_mutates=True; durability=['BlobRedb', 'ControlRedb', 'GraphRedb', 'None']; txn=['Atomic', 'Saga']
Cost: (unmeasured)
Latency: {'add_node': {'eg_method': 'AddNode', 'p50_ms': 0.187, 'p99_ms': 0.223, 'source': 'epistemic-graph/docs/benchmarks.md#results (2026-06-01, UDS, in-memory graph)', 'kind': 'measured'}}
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_edge → EG AddEdge (confidence 1.0)
add_embedding → EG AddEmbedding (confidence 1.0)
add_measurement → EG TxnAddMeasurement (confidence 1.0)
add_node → EG AddNode (confidence 1.0)
axiom → EG TxnAxiom (confidence 1.0)
begin → EG BeginTxn (confidence 1.0)
blob_ref → EG BlobRef (confidence 1.0)
cas → EG TxnCas (confidence 1.0)
commit → EG Commit (confidence 1.0)
commit_with_outcome → EG Commit (confidence 1.0)
construct → EG TxnConstruct (confidence 1.0)
materialize_belief → EG TxnMaterializeBelief (confidence 1.0)
plan_writeback → EG TxnPlanWriteback (confidence 1.0)
remove_edge → EG RemoveEdge (confidence 1.0)
remove_node → EG RemoveNode (confidence 1.0)
rollback → EG Rollback (confidence 1.0)
unified_query_plan → EG TxnUnifiedQuery (confidence 1.0)
uql → (no EG ledger match)

Typed input:

action (string): engine_txn method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`engine_viz`¶

engine viz

Low-level epistemic-graph engine surface for the 'viz' domain (D-VZ-1 native visualization: render/capability_matrix over the eg-viz LOD ColumnStore/export pipeline).

Intent verbs: act, ask
REST route: /engine/viz
MCP tags: engine, granular, graph-os, viz
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

capability_matrix → (no EG ledger match)
render → (no EG ledger match)

Typed input:

action (string): engine_viz method to call (empty ⇒ list actions).
params_json (string): JSON object of keyword arguments for the method.
graph (string): Target graph name (empty ⇒ the deployment default graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`find`¶

find

Discover capabilities, operations, fleet tools and the fleet catalog.

Intent verbs: find
REST route: /intent/find
MCP tags: intent
Side effects: 1/1 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

find → EG FindCycle (confidence 0.5)

Typed input:

action (string): One of the listed actions; 'describe' explains each.
params (object): Operation arguments. With action='describe', {'action': ''} returns that operation's argument schema.
intent (string): Natural-language request, routed when action is empty.
execute (boolean): Run now; when false, return the resolved plan.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': 'FindCycle', 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_agents`¶

graph agents

Run graph-grounded agent collectives.

Intent verbs: act
REST route: /graph/agents
MCP tags: agent_execution, agents, computer-use, granular, graph-os, org, reasoning, swarm
Side effects: 0/5 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

computer_use → (no EG ledger match)
reason → (no EG ledger match)
run_org → (no EG ledger match)
swarm → (no EG ledger match)
synthesize_org → (no EG ledger match)

Typed input:

action (string): swarm | computer_use | synthesize_org | run_org | reason
task (string): Goal or GUI task.
context (string): Curated swarm context.
context_ref (string): Persisted ContextBlob id for the swarm.
max_fan_out (integer):
max_steps (integer):
host (string): Computer-use inventory host alias.
container_id (string): Existing GUI sandbox container id.
options_json (string): JSON options; org actions accept {domains:[...]}.
topology (string): reason only: 'cot' | 'self_consistent_cot' | 'tot_bfs' | 'tot_dfs'.
num_samples (integer): reason only: self_consistent_cot sample count.
branching_factor (integer): reason(tot_bfs|tot_dfs) only: candidate next-thoughts per expansion.
beam_width (integer): reason(tot_bfs|tot_dfs) only: frontier survivors kept per expansion.
max_depth (integer): reason(tot_bfs|tot_dfs) only: max thought-chain depth before giving up.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_analyze`¶

graph analyze

Structural and operational KG analysis.

Intent verbs: ask, why
REST route: /graph/analyze
MCP tags: analysis, analyze, granular, graph-os
Side effects: 0/8 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

distill_memory → (no EG ledger match)
enrichment_coverage → (no EG ledger match)
infra_sweep → (no EG ledger match)
inspect → (no EG ledger match)
placement_plan → (no EG ledger match)
process_writeback → (no EG ledger match)
readiness → (no EG ledger match)
security_scan → (no EG ledger match)

Typed input:

action (string): inspect | enrichment_coverage | process_writeback | placement_plan | infra_sweep | security_scan | distill_memory | readiness
query (string): Query or path for the analysis.
top_k (integer): Result or complexity bound.
node_id (string): Optional anchor node id.
depth (integer): Traversal depth.
target (string): Analysis target.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_argument`¶

graph argument

AIF (Argument Interchange Format) argument maps: I-nodes (claims) linked through S-nodes — RA (rule-of-inference application), CA (conflict application), PA (preference application), plus the AIF+ TA (transition)/YA (illocutionary) dialogue extensions.

Intent verbs: why, write, ask
REST route: /graph/argument
MCP tags: aif, argument, argumentation, engine, epistemic, granular, graph-os
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_scheme → (no EG ledger match)
evaluate → (no EG ledger match)
export_aif → (no EG ledger match)
import_aif → (no EG ledger match)

Typed input:

action (string): import_aif | export_aif | evaluate | add_scheme
argument_map_json (string): Inline AIFdb-shaped JSON: {"nodes": [{"nodeID","text","type"}, ...], "edges": [{"edgeID","fromID","toID"}, ...]} (import_aif, evaluate).
map_id (string): Argument-map id: required for export_aif, optional override for import_aif, optional scope for evaluate.
node_ids (string): JSON array of already-imported I-node ids to evaluate (evaluate; alternative/addition to argument_map_json).
semantics (string): Dung semantics for evaluate: grounded | preferred | stable.
scheme_name (string): Scheme display name (add_scheme).
scheme_kind (string): inference | conflict | preference (add_scheme).
description (string): Optional scheme description (add_scheme).
scheme_id (string): Optional explicit scheme id (add_scheme); defaults to a slug of scheme_name.
graph (string): Target graph name for evaluate's engine call (empty = deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_ask`¶

graph ask

ask the Knowledge Graph in plain English.

Intent verbs: ask
REST route: /graph/ask
MCP tags: granular, graph-os, nl, query
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_ask → (no EG ledger match)

Typed input:

question (string, required): The natural-language question to answer.
dialect (string): 'auto' (model chooses) or 'cypher'|'sql'|'sparql' to force one.
execute (boolean): When false, return only the generated query (preview/dry-run).
limit (integer): Max result rows to return.
include_epistemic (boolean): CONCEPT:AU-KB-CURRENCY — opt-in. Only takes effect when the generated (or forced) query resolves to the 'cypher' dialect (sql/sparql have no epistemic-envelope surface, so this is a silent no-op for those). When true and honored, results holds per-row epistemic envelopes (confidence, bitemporal valid/tx time, evidence provenance, policy labels) instead of plain rows, and citations degrades to an empty list.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_audit`¶

graph audit

Tamper-evident audit ledger (G23): checks the engine's hash-chained durable-mutation audit log (Rust epistemic-graph/src/audit.rs, SHA-256 per (graph, seq)) and reconstructs 'what happened to entity X' from the KG's own :ToolCall provenance.

Intent verbs: why, ask
REST route: /audit
MCP tags: audit, governance, granular, graph-os, provenance
Side effects: 1/3 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

for_target → (no EG ledger match)
lineage → (no EG ledger match)
verify → EG AuditVerify (confidence 1.0)

Typed input:

action (string): check | for_target | lineage
target_id (string): Entity id to reverse-index tool-call provenance for (required for for_target).
fragment_id (string): Cited fragment id to resolve lineage for (required for lineage).
claim (string): The claim/fact text this lineage is for (lineage only, carried through verbatim).
content_hash (string): The content hash the citation was made against (lineage only, sharpens moved/stale detection).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_broker`¶

graph broker

the epistemic-graph engine message broker (AMQP-style exchanges + queues + streams), distinct from the agent-to-agent 'graph_bus'.

Intent verbs: act
REST route: /graph/broker
MCP tags: , broker, engine, granular, graph-os, messaging
Side effects: 1/1 actions matched an EG ledger Method; any_mutates=True; durability=['Outbox']; txn=['Atomic']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_broker → EG BrokerAck (confidence 0.5)

Typed input:

action (string): Broker method: declare_exchange | declare_queue | bind | publish | consume | stats | list_queues | list_exchanges | ...
exchange (string): Exchange name.
queue (string): Queue name.
routing_key (string): Routing/binding key.
payload (string): Message body (publish).
exchange_type (string): Exchange type: direct | fanout | topic (declare).
params_json (string): JSON object of extra kwargs, e.g. {"max_messages":10,"ack":true,"durable":true}. Merged over the typed fields.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': 'BrokerAck', 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_bus`¶

graph bus

the agent-to-agent communication bus: let this session talk to other Claude/LLM sessions (any provider, any host) through the shared graph-os hub.

Intent verbs: act
REST route: /graph/bus
MCP tags: a2a, bus, granular, graph-os, messaging
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_bus → (no EG ledger match)

Typed input:

action (string): register | heartbeat | roster | send | receive | subscribe | unsubscribe | dispatch | leave | status
agent_id (string): This participant's id (most actions).
sender (string): Sender agent id (send/dispatch).
to (string): Recipient agent id (send, direct).
topic (string): Topic name (send/subscribe/unsubscribe).
payload (string): Message body (send).
objective (string): Work objective (dispatch).
kind (string): Loop kind for dispatch: develop|research|skill.
priority (string): Bucket 0-3 or critical|high|normal|background (dispatch).
provider (string): Provider label, e.g. anthropic|openai|google (register/roster).
host (string): Host this session runs on (register).
capabilities (string): Comma-separated capability tags (register); single tag filter (roster).
session_id (string): Originating session id (register).
since (integer): Cursor: messages already consumed (receive).
online_only (boolean): Roster: only online peers.
reason (string): Audit reason (send/dispatch).
url (string): Peer hub base URL (register_hub).
group (string): Message group to forward (federate).
origin (string): Origin hub id (federate_in).
scope (string): Marking scope for federation: commons|org|private (federate).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_candidate_claims`¶

graph candidate claims

Track 4/5 of the universal-ingestion program: propose model-backed candidate claims from raw text, and/or resolve entity-identity candidates across records — NEITHER action ever writes a fact or an identity assertion (structurally no write authority. See the module docstring). 'propose' (text, source_id, fragments_json, rounds, dedup) runs CandidateClaimExtractor.propose — a schema-constrained extraction pass citing EXACT evidence spans against the provided fragments, with an honest (never fabricated) model_confidence and a review_bucket (accepted|needs_review|rejected|quarantined). 'resolve_identities' (records_json, min_confidence, persist) runs resolve_identity_candidates — compares every record pair and returns AMBIGUITY-PRESERVING candidates (never a merge); persist=true also writes each as a POSSIBLE_SAME_AS hint edge (write_candidate), the one ungated write this pipeline makes.

Intent verbs: act, write
REST route: /graph/candidate-claims
MCP tags: candidate_claim, claims, entity-resolution, epistemic, extraction, granular, graph-os
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

propose → (no EG ledger match)
resolve_identities → (no EG ledger match)

Typed input:

action (string): propose|resolve_identities
text (string): 'propose' only: the source text to extract candidate claims from.
source_id (string): 'propose' only: identifies the source document/object these candidates came from.
fragments_json (string): 'propose' only: JSON array of {fragment_id, text} (or legacy {id, text}) objects — the addressable evidence-spine units an extracted evidence quote must be a genuine substring of to resolve to a real EvidenceSpan.
rounds (integer): 'propose' only: number of extraction passes (each a different sampling seed).
dedup (boolean): 'propose' only: suppress near-duplicate candidates found within this call.
records_json (string): 'resolve_identities' only: JSON array of {id, name, kind, identifiers} entity records to compare pairwise.
min_confidence (number): 'resolve_identities' only: floor below which a pair is not flagged as a candidate.
persist (boolean): 'resolve_identities' only: also persist each returned candidate as a POSSIBLE_SAME_AS edge (write_candidate) — never a merge, the one ungated write this module's sibling performs.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_catalog`¶

graph catalog

one capability-shaped call across every KG modality (graphs, sql, kv, vector, ontology, timeseries, blob, broker, saved_queries) instead of making a separate protocol-specific introspection call per modality.

Intent verbs: find, ask
REST route: /graph/catalog
MCP tags: granular, graph-os, introspection, query
Side effects: 1/2 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

list → EG CatalogList (confidence 1.0)
preview_sync → (no EG ledger match)

Typed input:

action (string): 'list' (default) returns modality and provider catalogues; 'preview_sync' validates one source_sync request without running it.
source (string): For preview_sync: exactly one neutral source identifier.
mode (string): For preview_sync: 'delta', 'full', or 'reconcile'.
ids_json (string): For preview_sync: JSON list of bounded source record ids.
connection (string): For preview_sync: one neutral named backend connection.
graph (string): For preview_sync: one neutral physical graph name.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_claims`¶

graph claims

Drive the X-3 epistemic mining flywheel's governed claim lifecycle (CONCEPT:AU-KG.evolution.mining-flywheel) directly: proposed -> validated -> accepted -> deprecated -> retracted (any pre-terminal state may also be retracted directly. RETRACTED is TERMINAL and STICKY — 'propose' refuses to reopen a retracted claim).

Intent verbs: manage, act
REST route: /graph/claims
MCP tags: claim, claims, epistemic, governance, granular, graph-os
Side effects: 0/8 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

accept → (no EG ledger match)
deprecate → (no EG ledger match)
evaluate → (no EG ledger match)
get → (no EG ledger match)
list → (no EG ledger match)
propose → (no EG ledger match)
retract → (no EG ledger match)
validate → (no EG ledger match)

Typed input:

action (string): propose|validate|accept|deprecate|retract|evaluate|get|list
claim_id (string): Target claim id (every action but 'list').
reason (string): Why this transition is happening — the audit trail.
valid (boolean): 'validate' only: the caller's ALREADY-COMPUTED governance verdict (e.g. from PromotionGovernanceValidator) — this tool never recomputes validity itself, it only records it. False HOLDS the claim at its current state (not a retraction — validate may be called again later once the hold clears).
state (string): 'list' only: filter to claims whose CURRENT state equals this (proposed|validated|accepted|deprecated|retracted).
limit (integer): 'list' only: max rows.
domain (string): 'evaluate' only: the domain/pack name governing this candidate claim's per-pack confidence threshold.
statement (string): 'evaluate' only: the candidate claim's text.
confidence (number): 'evaluate' only: the candidate claim's confidence.
envelope_json (string): 'evaluate' only: JSON ChangeEnvelope.as_dict()-shaped payload — the write this claim proposes if later accepted.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_code`¶

graph code

Understand a CODEBASE via the ingested code graph — query this before grep.

Intent verbs: ask, act
REST route: /graph/code
MCP tags: analyze_suite, code, granular, graph-os
Side effects: 1/11 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['None']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

adr → (no EG ledger match)
arch_report → (no EG ledger match)
blast_radius → (no EG ledger match)
call_graph → (no EG ledger match)
change_coupling → (no EG ledger match)
code_context → (no EG ledger match)
code_evolution → (no EG ledger match)
code_metrics → EG Metrics (confidence 1.0)
cross_repo_usages → (no EG ledger match)
routes → (no EG ledger match)
similar_code → (no EG ledger match)

Typed input:

action (string): code_context | cross_repo_usages | call_graph | similar_code | routes | change_coupling | code_evolution | blast_radius | code_metrics | arch_report | adr
query (string): Question / area / symbol name / repo path.
top_k (integer): Result count.
node_id (string): Symbol/:Code node id (call_graph, similar_code, blast_radius).
depth (integer): Traversal depth (blast_radius).
target (string): how|usage|impact (code_context) or callees|callers|inherits (call_graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_code_nav`¶

graph code nav

Navigate the resolved code graph (CONCEPT:AU-KG.backend.declared-columns-so-schema). action: 'find_definition' (locate a symbol's :Code node), 'find_references' (callers of a symbol), 'trace_call_graph' (transitive callees), 'impact_of_change' (transitive callers = blast radius), 'connects' (shortest path between TWO symbols — set symbol/node_id AND target_symbol/target_node_id — rendered hop-by-hop with each edge's relation + confidence, CONCEPT:EG-KG.compute.handled-outside-single-anchor).

Intent verbs: ask
REST route: /graph/code-nav
MCP tags: code, granular, graph-os, query
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

connects → (no EG ledger match)

Typed input:

action (string, required): find_definition | find_references | trace_call_graph | impact_of_change | connects
symbol (string): Symbol name to start from (function/class/method).
node_id (string): Exact :Code node id (overrides 'symbol' when set).
target_symbol (string): For action='connects': the destination symbol name.
target_node_id (string): For action='connects': the destination :Code node id.
source_system (string): Optional source_system filter, e.g. 'gitlab:gitlab.com'.
depth (integer): Max hops for trace_call_graph / impact_of_change (1-10).
limit (integer): Max rows to return.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_compliance`¶

graph compliance

Compliance posture rollup + redacted bulk export — an aggregation layer over primitives that already exist (no new compliance/redaction logic).

Intent verbs: ask, why
REST route: /compliance
MCP tags: audit, compliance, governance, granular, graph-os, redaction
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

export → (no EG ledger match)
posture → (no EG ledger match)

Typed input:

action (string): posture | export
cypher (string): Read-only Cypher selecting an 'id' column of nodes to export (export action; ignored when node_ids is non-empty). E.g. "MATCH (n:Control) RETURN n.id AS id LIMIT 100".
node_ids (string): JSON array of explicit node ids to export (export action).
disclosure_level (string): Full | Skeleton | ExistenceOnly — policy-aware redaction applied to every exported node (export action).
as_of (string): Optional ISO-8601 instant — bitemporal cutoff for the cypher id selection (export action).
limit (integer): Max nodes exported in one call (export action).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_config`¶

graph config

Inspect and govern this deployment's AgentConfig (CONCEPT:AU-OS.config.two-surfaces-by-default).

Intent verbs: manage, ask
REST route: /graph/config
MCP tags: config, configure, granular, graph-os
Side effects: 0/5 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

describe → (no EG ledger match)
diff → (no EG ledger match)
get → (no EG ledger match)
reload → (no EG ledger match)
set → (no EG ledger match)

Typed input:

action (string): describe | get | diff | reload | set
key (string): AgentConfig env alias (MCP_ALWAYS_LOAD) or field name (mcp_always_load). Required for get/set; optional for describe.
value (string): New value for 'set'. JSON is parsed (arrays/objects/booleans); anything else is taken as a string and validated against the field's declared type.
reason (string): Why this change is happening (audit trail, 'set').
contains (string): Substring filter for a keyless 'describe'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_configure`¶

graph configure

Manage backend configurations, system credentials, and tool registration within the unified agent ecosystem.

Intent verbs: manage
REST route: /graph/configure
MCP tags: analysis, configure, granular, graph-os
Side effects: 4/38 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb', 'None']; txn=['None', 'Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_connection → (no EG ledger match)
approve_connection_mapping → (no EG ledger match)
config_doctor → (no EG ledger match)
config_reference → (no EG ledger match)
connection_mapping_status → (no EG ledger match)
discover_connection_schema → EG Discover (confidence 1.0)
doctor → (no EG ledger match)
external_graph_doctor → (no EG ledger match)
frontend_contributions → (no EG ledger match)
generate_config → (no EG ledger match)
get_config → (no EG ledger match)
harness_fence → (no EG ledger match)
health → EG Health (confidence 1.0)
ingest_connection → (no EG ledger match)
install_hooks → (no EG ledger match)
list_config → (no EG ledger match)
list_connections → (no EG ledger match)
mirror_status → (no EG ledger match)
preflight → (no EG ledger match)
profile_connection → (no EG ledger match)
propose_connection_mapping → (no EG ledger match)
pull_from_stardog → (no EG ledger match)
push_to_stardog → (no EG ledger match)
reconcile → EG Reconcile (confidence 1.0)
register_mcp → (no EG ledger match)
remove_connection → (no EG ledger match)
schema_candidates → (no EG ledger match)
schema_pack → (no EG ledger match)
set_role_routing → (no EG ledger match)
set_secret → (no EG ledger match)
setup_databases → (no EG ledger match)
stardog_export_graph → (no EG ledger match)
stardog_import_graph → (no EG ledger match)
stardog_sparql → EG Sparql (confidence 1.0)
system_doctor → (no EG ledger match)
uninstall_hooks → (no EG ledger match)
vault_sync → (no EG ledger match)
verify_databases → (no EG ledger match)

Typed input:

action (string): Configuration operation. Core actions: set_secret, vault_sync, frontend_contributions, register_mcp, install_hooks, uninstall_hooks, harness_fence, schema_pack, schema_candidates, add_connection, remove_connection, list_connections, mirror_status, reconcile, generate_config, config_doctor, config_reference, get_config, list_config, system_doctor, health, preflight, and doctor (hook-installer self-check; distinct from config_doctor/system_doctor). set_role_routing persists a role's model registry routing entry (config_value is the JSON RoleSpec payload). Universal external-source lifecycle actions are discover_connection_schema, propose_connection_mapping, approve_connection_mapping, connection_mapping_status, external_graph_doctor, profile_connection, and ingest_connection. Durable connection declarations accept neutral aliases and runtime secret references only; endpoint, credential, identity, query, TLS material, and local-path literals are rejected. GraphQL sources use a read-only runtime adapter; their connection, mapping, auth, TLS, and variables documents remain separate refs, and every ingest rechecks the approved schema and mapping-policy digests. push_to_stardog, pull_from_stardog, stardog_sparql, stardog_export_graph, stardog_import_graph, setup_databases, and check_databases were retired with the legacy SPARQL backend and database-setup path; each name stays reachable and answers with a typed unavailable error.
config_key (string): The key or ID of the configuration/secret (for 'schema_pack', the pack name e.g. 'research-state'; for connection actions, the connection name).
config_value (string): JSON string containing the payload or secret value.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_context`¶

graph context

store/fetch curated context for invoker→spawned-agent handoff, persisted in the epistemic-graph so a SEPARATELY-spawned agent can read it by id.

Intent verbs: ask
REST route: /graph/context
MCP tags: context, granular, graph-os, orchestrate, query
Side effects: 1/4 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

get → EG GetContextView (confidence 0.667)
list → (no EG ledger match)
prune → (no EG ledger match)
put → (no EG ledger match)

Typed input:

action (string): put | get | list
content (string): Context text to store (action=put).
context_id (string): ContextBlob id (action=get).
session_id (string): Session scope key.
key (string): Optional sub-key within the session.
ttl_s (integer): Optional time-to-live in seconds (0 = persistent).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_data_prep`¶

graph data prep

Governed Arrow data preparation over the NE-108 kernel.

Intent verbs: ask, write
REST route: /data/prep
MCP tags: arrow, data-prep, data_prep, governance, granular, graph-os
Side effects: 1/4 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb']; txn=['Saga']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

clean_dataset → (no EG ledger match)
commit_prepared → EG Commit (confidence 1.0)
profile_dataset → (no EG ledger match)
validate_prepared → (no EG ledger match)

Typed input:

action (string): profile_dataset | clean_dataset | validate_prepared | commit_prepared
params_json (string): Bounded JSON object carrying the typed plan, immutable refs, artifact_ref or bounded scalar records, and resource budget.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_document_tree`¶

graph document tree

Reasoning-tree (vectorless) document retrieval over a per-document section tree (CONCEPT:AU-KG.retrieval.section-tree/tree-navigation. Distills PageIndex). action: 'build' (build + optionally persist the section tree from text or a stored document), 'structure' (return the text-free table-of-contents map = get_document_structure), 'content' (fetch section bodies for cited char ranges like '96..208,300..420' = get_page_content), 'fetch' (walk the tree by relevance and return sections with cited start..end ranges), 'fragments' (the addressable evidence spine — every citable Fragment of an artifact/document with its stable address + content hash; CONCEPT:AU-KG.ingest.stable-fragment-address), 'cite' (resolve a stored citation against the current artifact and report current | stale | moved | lost).

Intent verbs: ask, write
REST route: /graph/document-tree
MCP tags: document, granular, graph-os, query, retrieval, tree
Side effects: 0/6 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

build → (no EG ledger match)
cite → (no EG ledger match)
content → (no EG ledger match)
fragments → (no EG ledger match)
retrieve → (no EG ledger match)
structure → (no EG ledger match)

Typed input:

action (string, required): build | structure | content | fetch | fragments | cite
document_id (string): Target Document id (structure/content, and build/fetch when loading from the graph).
text (string): action=build/fetch — inline document text (markdown) to build the tree from, instead of loading a stored document.
query (string): action=fetch — the natural-language query to navigate the tree with.
ranges (string): action=content — char ranges to fetch, e.g. '96..208,300..420'.
top_k (integer): action=fetch — max sections to return.
persist (boolean): action=build — write the Section nodes/edges to the graph (requires document_id).
thin (boolean): action=build — collapse tiny sections into their parent (token-budget thinning).
summarize (boolean): action=build — compute per-node summaries for a text-free structure map.
use_llm (boolean): action=fetch — try LLM tree navigation before the lexical walk.
artifact_id (string): action=fragments/cite — the source Artifact to read the evidence spine of (alternative to document_id).
fragment_id (string): action=cite — the stable fragment address the citation stored.
content_hash (string): action=cite — the 'sha256:' content hash the citation stored, used to detect staleness and to relocate a moved fragment.
kinds (string): action=fragments — comma-separated fragment kinds to keep (heading,paragraph,table,table_row,list_item,code_block,quote).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_domain_ops`¶

graph domain ops

Run graph-native domain mutations.

Intent verbs: act
REST route: /graph/domain-ops
MCP tags: domain, domain_ops, enterprise, finance, granular, graph-os, ml
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

allocate_budget → (no EG ledger match)
fit_markov_regime → (no EG ledger match)
register_rlm_actor → (no EG ledger match)

Typed input:

action (string): allocate_budget | fit_markov_regime | register_rlm_actor
target_id (string): Business-unit, strategy, or actor name/id.
amount (number): Budget amount.
currency (string): Budget currency.
returns_json (string): JSON list of returns for fit_markov_regime.
asset_class (string): Regime asset class.
bull_threshold (any):
bear_threshold (any):
window (any):
method (string):
learning_rate (number):
discount_factor (number):

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_durable`¶

graph durable

The unified durable-execution plane (durable-execution-native.md, supersedes restate natively).

Intent verbs: act, ask
REST route: /graph/durable
MCP tags: durable, durable-execution, granular, graph-os, orchestration
Side effects: 0/7 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

call → (no EG ledger match)
checkpoint → (no EG ledger match)
run → (no EG ledger match)
sleep → (no EG ledger match)
state_get → (no EG ledger match)
state_set → (no EG ledger match)
status → (no EG ledger match)

Typed input:

action (string): run | checkpoint | sleep | status | state_get | state_set | call
session_id (string): Durable run session id (run|checkpoint|sleep|state_get|state_set|call).
name (string): Named step/state key (checkpoint|sleep|state_get|state_set|call).
wake_at_ms (integer): 'sleep' only: epoch-ms deadline to wake at.
value (string): 'state_set'/'checkpoint' only: JSON value to write/record.
definition_version (string): Optional DE5 version pin for 'run'|'checkpoint'|'sleep'.
kinds (string): 'status' only: JSON list of labels to filter to.
status (string): 'status' only: filter by durable_status.
limit (integer): 'status' only: max rows.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_engineering`¶

graph engineering

GraphRAG-style Graph Engineering surface: entity-neighborhood local search, community-report map-reduce global search, and on-demand community-report (re)building.

Intent verbs: ask, write
REST route: /graph/engineering
MCP tags: community, global-search, granular, graph-os, graph_engineering, graphrag, local-search, retrieval
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

build_community_reports → (no EG ledger match)
global_search → (no EG ledger match)
local_search → (no EG ledger match)

Typed input:

action (string): local_search | global_search | build_community_reports
query (string): Natural-language question (local_search, global_search).
node_id (string): Explicit seed node id for local_search, skipping seed resolution (semantic/graph-query lookup) entirely.
depth (integer): local_search neighborhood hops (bounded).
top_k (integer): local_search result cap.
level (integer): global_search community-report level: 0 = per-community reports, 1 = the single global rollup report.
max_communities (integer): global_search MAP-step fan-out bound, and build_community_reports' max communities to summarize (there default 50 when left at 8 has no special meaning -- pass explicitly for build_community_reports if the operator want a different cap).
token_budget (integer): ContextCompiler token budget. 0 (default) uses each action's own default (2000 for local_search, 4000 for global_search).
resolution (number): build_community_reports: Louvain resolution parameter.
min_size (integer): build_community_reports: minimum community size to summarize.
embed (boolean): build_community_reports: embed each report's theme+summary so global_search can rank it.
synthesize_answer (boolean): local_search: render the grounded-answer canonical prompt over the assembled bundle (best-effort).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_epistemic`¶

graph epistemic

Purpose-named epistemic-answer surface over the engine's belief/provenance primitives (CONCEPT:AU-KB-CURRENCY) — 'why do this repository believe this', 'why NOT', 'what will change my mind', 'what changed between two points in time', 'resolve this contradiction'.

Intent verbs: why, ask
REST route: /epistemic
MCP tags: belief, engine, epistemic, granular, graph-os, provenance
Side effects: 3/5 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

epistemic_status → EG EpistemicStatus (confidence 1.0)
explain_belief → EG ExplainBelief (confidence 1.0)
what_changed → EG WhatChanged (confidence 1.0)
what_would_invalidate → (no EG ledger match)
why_not → (no EG ledger match)

Typed input:

action (string): status | why | why_not | what_will_invalidate | what_changed | resolve_conflict
node_id (string): Claim/node id (status, why, why_not, what_will_invalidate).
node_ids (string): JSON array of contradicting node ids (resolve_conflict).
disclosure_level (string): Full | Skeleton | ExistenceOnly — policy-aware redaction (why). Empty = engine default (full disclosure).
tx_from (integer): Lower transaction-time bound (what_changed).
tx_to (integer): Upper transaction-time bound (what_changed).
semantics (string): Argumentation semantics for resolve_conflict (e.g. 'grounded').
graph (string): Target graph name (empty = deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_etl`¶

graph etl

Unified ETL pipeline between systems over the canonical KG hub (CONCEPT:AU-KG.ontology.one-source).

Intent verbs: write
REST route: /graph/etl
MCP tags: etl, granular, graph-os, ingestion, ontology
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

lineage → (no EG ledger match)
list → (no EG ledger match)

Typed input:

action (string): 'run' | 'list' | 'lineage'.
source (string): Ingestion source to pull into the KG (inbound).
sink (string): Write-back domain or graph-store/connection name (outbound).
mode (string): Inbound sync mode: delta|full|reconcile.
sources_json (string): JSON list of source systems to filter a graph-store push.
ids_json (string): JSON list of record ids to narrow the inbound sync.
ops_json (string): JSON write-back payload (inferences/enrichments/creations/…).
dry_run (boolean): Write-back dry-run (fail-closed default).
limit (integer): Max rows for action='lineage'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_evaluate`¶

graph evaluate

Evaluate agents/harnesses and reason over learned world models.

Intent verbs: why
REST route: /graph/evaluate
MCP tags: analyze_suite, evaluate, granular, graph-os
Side effects: 0/18 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

assimilation_benchmark → (no EG ledger match)
causal → (no EG ledger match)
check_constraints → (no EG ledger match)
evaluate → (no EG ledger match)
evaluate_harness → (no EG ledger match)
evolve_code → (no EG ledger match)
evolve_model → (no EG ledger match)
forecast → (no EG ledger match)
guard_corpus → (no EG ledger match)
harness_gate → (no EG ledger match)
invariant → (no EG ledger match)
latent_efficiency_benchmark → (no EG ledger match)
quant_crypto → (no EG ledger match)
quant_insider → (no EG ledger match)
quant_microstructure → (no EG ledger match)
quant_regime → (no EG ledger match)
specialize → (no EG ledger match)
world_model_rollout → (no EG ledger match)

Typed input:

action (string): evaluate | evaluate_harness | guard_corpus | harness_gate | check_constraints | specialize | world_model_rollout | latent_efficiency_benchmark | assimilation_benchmark | evolve_model | evolve_code | forecast | causal | invariant | quant_crypto | quant_microstructure | quant_regime | quant_insider
query (string): Subject of the evaluation (JSON / id / start state).
top_k (integer): Steps / result count.
node_id (string): Optional node id.
depth (integer): Optional depth.
target (string): Optional target.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_evolution`¶

graph evolution

Improve the graph and its executable knowledge.

Intent verbs: act
REST route: /graph/evolution
MCP tags: evolution, granular, graph-os, optimization, skills
Side effects: 1/8 actions matched an EG ledger Method; any_mutates=True; durability=['Outbox']; txn=['Atomic']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

assimilate → (no EG ledger match)
audit_scan → (no EG ledger match)
distill_skills → (no EG ledger match)
evidence_lineage → (no EG ledger match)
failure_ingest → (no EG ledger match)
optimize_component → (no EG ledger match)
publish_proposal → EG Publish (confidence 1.0)
standardize → (no EG ledger match)

Typed input:

action (string): assimilate | audit_scan | distill_skills | standardize | failure_ingest | optimize_component | publish_proposal | evidence_lineage
target (string): Proposal id, optimization component, distillation proposal id, or (for evidence_lineage) the :EvolutionEvidence node id. Use all/sweep for a full optimization sweep.
data_json (string): JSON input data for component optimization.
limit (integer): Bounded result/materialization limit.
synthesize (boolean): Synthesize synergy proposals during assimilation.
force (boolean): Re-run assimilation even when its watermark is unchanged.
draft (boolean): Render reviewable skill drafts while distilling.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_explain`¶

graph explain

The UNIVERSAL context plane (CONCEPT:AU-KG.retrieval.route-question-its-domain): route a question to its domain provider and return ONE grounded, cited answer. action='explain' with target='domain:intent' (e.g. 'ops:why', 'code:usage', 'deploy:status', 'entity:health') — or a bare intent with the domain inferred, or target='domains' to list providers. action='context' returns a synthesized context bundle. Action='executable_rag' runs the grounded multi-hop retriever.

Intent verbs: why
REST route: /graph/explain
MCP tags: analyze_suite, explain, granular, graph-os
Side effects: 1/4 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

context → (no EG ledger match)
executable_rag → (no EG ledger match)
explain → EG ExplainBelief (confidence 0.5)
recommend → (no EG ledger match)

Typed input:

action (string): explain | context | executable_rag | recommend
query (string): The question.
top_k (integer): Result count.
node_id (string): Optional anchor node id.
depth (integer): Optional depth.
target (string): 'domain:intent' | bare intent | 'domains'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_federated_search`¶

graph federated search

federated search fanned across registered external graph references.

Intent verbs: ask
REST route: /graph/federated-search
MCP tags: , engine, federated, granular, graph-os, search
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_federated_search → (no EG ledger match)

Typed input:

query (string, required): Search query (natural language or keywords).
references (string): Comma-separated external graph reference ids (empty ⇒ all).
top_k (integer): Max results to return.
params_json (string): JSON object of extra engine kwargs.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_feedback`¶

graph feedback

Record a human correction so the brain learns: correction_type 'outcome' adjusts an entity's reward, 'rule' persists a durable governance/voice/source rule consulted at retrieval time, 'eval' adds a regression case, 'reads_avoided' closes the code_context reads-avoided loop (target_id=capability_id, corrected_value=JSON {reads_avoided,files_read,correct,query}) (CONCEPT:AU-AHE.evaluation.reads-avoided-feedback), 'action_outcome' closes the loop on ANY autonomous action — a context answer, a deploy, a ticket close, a routing choice (target_id=action/capability id, corrected_value=JSON {success,reward?,expected?,observed?,query?}) so routing/playbooks prefer actions that achieve their goal (CONCEPT:AU-AHE.evaluation.action-outcome-feedback), 'gotcha' pins a hard-won trap to a file/module (target_id=path, corrected_value=the note) so code_context surfaces it when an agent next touches that area (CONCEPT:AU-KG.ingest.gotcha-feedback-capture), 'selective_erasure' forgets the learned reward for superseded designations (target_id + optional corrected_value list of ids) so the router re-learns them instead of carrying stale utility across a source/model regime change (CONCEPT:AU-KG.memory.generation-scoped-selective-reward).

Intent verbs: why, write
REST route: /graph/feedback
MCP tags: feedback, granular, graph-os, learning, write_ingest
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_feedback → (no EG ledger match)

Typed input:

correction_type (string, required): outcome | rule | eval | reads_avoided | action_outcome | gotcha | selective_erasure.
target_id (string, required): Entity/episode/query the correction is about.
corrected_value (string): The corrected value (reward, expected output, etc.).
reason (string): Why — the human's explanation.
rule_scope (string): For rule corrections: governance | voice | source | preference.
rule_kind (string): For rule corrections: forbid | prefer | demote.
actor_id (string): Who issued the correction.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_feeds`¶

graph feeds

Manage the unified RSS/Atom feed registry (CONCEPT:AU-KG.ingest.rss-feed-connector/2.122).

Intent verbs: act, ask
REST route: /graph/feeds
MCP tags: feeds, granular, graph-os, state
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add → (no EG ledger match)
list → (no EG ledger match)
remove → (no EG ledger match)
sync → (no EG ledger match)

Typed input:

action (string): list|add|remove|sync
url (string): Feed URL (single add/remove).
urls (string): BULK add/remove: multiple feed URLs in ONE call — a JSON array ('["https://a/feed","https://b/rss"]') or a comma/newline-separated string. Combined with url and deduped.
mode (string): delta|full (sync).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_fork`¶

graph fork

warm-fork fan-out over the ORCH-1.86..93 warm-fork primitive (LMCache KV / copy-on-write sandboxes): pay warm-up ONCE for a parent context, then fork N copy-on-write branches to run per-branch computations concurrently and return each branch's result.

Intent verbs: act
REST route: /graph/fork
MCP tags: , engine, fanout, fork, granular, graph-os, warm-fork
Side effects: 1/1 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_fork → EG Fork (confidence 1.0)

Typed input:

code (string): A single code snippet run on each of 'n' branches (ignored when 'branches_json' is provided).
n (integer): Fan-out count when using 'code' (branches to fork).
branches_json (string): JSON list of per-branch code snippets; overrides code/n.
vars_json (string): JSON object seeding the namespace forked into every branch.
sandbox (string): Preferred warm-fork rung name (empty ⇒ cheapest available).
context_query (string): Optional: fetch an engine cross-modal candidate set (vector+graph+text) for this query ONCE and fork it into every branch (reused, no recompute).
candidate_var (string): Namespace name the cross-modal candidate set is bound to in each branch (only used when context_query is set).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': 'Fork', 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_gis`¶

graph gis

the engine's GIS surface.

Intent verbs: ask
REST route: /graph/gis
MCP tags: , engine, geospatial, gis, granular, graph-os
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_gis → (no EG ledger match)

Typed input:

action (string): GIS method: route | tile | nearest | geo_task | ...
params_json (string): JSON object of kwargs for the GIS method (coordinates, profile, tile z/x/y, task name, ...).
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_goals`¶

graph goals

Orchestrate background/autonomous loops (action in 'create', 'list', 'iterations', 'cancel').

Intent verbs: act
REST route: /graph/goals
MCP tags: goals, granular, graph-os, state
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

cancel → (no EG ledger match)
create → (no EG ledger match)
iterations → (no EG ledger match)
list → (no EG ledger match)

Typed input:

action (string, required): Action: 'create', 'list', 'iterations', 'cancel'
goal_id (string): Target goal ID
goal (string): Goal description/instruction for 'create' action
max_iterations (integer): Max iterations for the autonomous loop

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_governance`¶

graph governance

Govern orchestration actions.

Intent verbs: act, manage
REST route: /graph/governance
MCP tags: approval, governance, granular, graph-os, policy
Side effects: 0/7 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

claim_ownership → (no EG ledger match)
grant_approval → (no EG ledger match)
ownership_apply → (no EG ledger match)
ownership_report → (no EG ledger match)
policy_status → (no EG ledger match)
submit_risk_veto → (no EG ledger match)
verify_action → (no EG ledger match)

Typed input:

action (string): grant_approval | submit_risk_veto | check_action | ownership_report | ownership_apply | claim_ownership | policy_status
approval_id (string): Pending action_approval:* id (grant_approval).
decision (string): approved | denied (grant_approval).
target_id (string): Existing target id for a risk veto or policy check.
reason (string): Risk-veto or policy reason.
kind (string): ActionPolicy action kind (check_action).
params_json (string): JSON object of ActionPolicy parameters.
source (string): Policy request source.
actor_id (string): Optional policy actor id.
node_types_json (string): claim_ownership: JSON list of node_type labels to claim (or preview) ownership over, e.g. '["RuntimeSignal","WorkItem"]'. At least one of node_types_json / node_ids_json is required — there is no blind full-graph mode.
node_ids_json (string): claim_ownership: JSON list of explicit node ids to claim (or preview) ownership over, as an alternative or addition to node_types_json.
owner_id (string): claim_ownership: REQUIRED (both preview and apply) — the new owner id to stamp. NEVER defaults to the calling admin actor; the caller must state explicitly whose data this is (e.g. the real human user for private conversational content, or a system/service identity for operational data) — silent self-assignment is refused.
shared_scope (string): claim_ownership: '_shared_scope' to stamp alongside the new owner — 'private' | 'org' | 'commons'. Defaults to 'org'.
apply (boolean): claim_ownership only: false (DEFAULT) = dry-run preview, grouped by node_type, mutates nothing. true = actually claim — required explicitly, never implied.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_incident`¶

graph incident

Incident Brain (CONCEPT:AU-KG.enrichment.cross-layer-incident-correlation): browse and drive the cross-layer :HealthAnomaly -> :Incident correlation the incidents CronJob already runs.

Intent verbs: ask, act
REST route: /incident
MCP tags: aiops, granular, graph-os, incident, observability
Side effects: 0/7 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

ack → (no EG ledger match)
correlate → (no EG ledger match)
get → (no EG ledger match)
list → (no EG ledger match)
related_claims → (no EG ledger match)
resolve → (no EG ledger match)
timeline → (no EG ledger match)

Typed input:

action (string): correlate | list | get | timeline | related_claims | ack | resolve
incident_id (string): Incident id (required for get/timeline/related_claims/ack/resolve).
window_s (integer): Correlation clustering window, seconds (correlate).
days (integer): Lookback window in days (correlate).
status (string): Filter by status, e.g. 'open' (list). Empty = no filter.
severity (string): Filter by severity, e.g. 'critical' (list). Empty = no filter.
limit (integer): Max incidents returned (list).
reason (string): Why this transition is happening — the audit trail (ack/resolve).
actor_id (string): Optional caller identity stamped onto the transition (ack/resolve).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_ingest`¶

graph ingest

Smart ingestion for codebases, documents, directories, and conversation logs.

Intent verbs: write, ask
REST route: /graph/ingest
MCP tags: granular, graph-os, ingest, write_ingest
Side effects: 0/44 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

agent_toolkit → (no EG ledger match)
archivebox_sync → (no EG ledger match)
backfill_platform_history → (no EG ledger match)
build_skill_graph → (no EG ledger match)
cancel → (no EG ledger match)
cdc_catchup → (no EG ledger match)
classify_topics → (no EG ledger match)
clear → (no EG ledger match)
cohort_create → (no EG ledger match)
cohort_status → (no EG ledger match)
corpus → (no EG ledger match)
curate_wiki → (no EG ledger match)
distill → (no EG ledger match)
enrich_pending_documents → (no EG ledger match)
extract_jobs → (no EG ledger match)
extract_jsonl → (no EG ledger match)
extract_pause → (no EG ledger match)
extract_resume → (no EG ledger match)
extract_status → (no EG ledger match)
extract_submit → (no EG ledger match)
fact_extract → (no EG ledger match)
fleet_relevance → (no EG ledger match)
gitlab_sync → (no EG ledger match)
gitlab_webhook → (no EG ledger match)
import_pack → (no EG ledger match)
ingest → (no EG ledger match)
ingest_knowledge_pack → (no EG ledger match)
ingest_url → (no EG ledger match)
job_status → (no EG ledger match)
jobs → (no EG ledger match)
materialize → (no EG ledger match)
materialize_source → (no EG ledger match)
observe → (no EG ledger match)
opensearch_reindex → (no EG ledger match)
prioritize → (no EG ledger match)
profile → (no EG ledger match)
rebuild_indexes → (no EG ledger match)
rebuild_skill_graph → (no EG ledger match)
reflect → (no EG ledger match)
skill_graph_status → (no EG ledger match)
skill_workflows → (no EG ledger match)
status → (no EG ledger match)
sync → (no EG ledger match)
sync_second_brain → (no EG ledger match)

Typed input:

target_path (string): Path or JSON list of paths to ingest.
max_depth (integer): Maximum directory depth for codebase ingestion.
agent_id (string): ID of the agent performing the ingestion.
action (string): Action to perform (ingest, ingest_url, backfill_platform_history, archivebox_sync, cdc_catchup, opensearch_reindex, skill_workflows, fact_extract, sync_second_brain, classify_topics, enrich_pending_documents, distill, import_pack, ingest_knowledge_pack, agent_toolkit, corpus, jobs, job_status, status, cancel, clear, prioritize, rebuild_indexes, observe, materialize, materialize_source, sync, reflect). For backfill_platform_history, pass corpus_name= and target_path=; it re-fetches retained history using the platform's existing credential and records idempotent backfilled InboundMessage nodes. 'enrich_pending_documents' sweeps :Document nodes a connector wrote via the native_ingest primitive (e.g. searxng-mcp results) from outside the hub process — raw text only, flagged needs_enrichment=true — and runs each through the SAME DocumentProcessor + central _enrich_text seam a direct ingest gets (chunk+contextual-enrich+concepts+facts+WorldView topic classification), clearing the flag. 'classify_topics' runs the WorldView subject/topic classifier ad hoc (CONCEPT:AU-KG.enrichment.topic-classification-topology): description=raw text (or target_path=file, or target_path=an existing Document node id to attach edges to) → classifies onto the canonical WorldView taxonomy (ontology_worldview.ttl) and mints/links the :Topic hierarchy (BROADER/NARROWER) + HAS_TOPIC/CLASSIFIED_AS edges with confidence; corpus_name=optional title. This is the SAME core every document ingestion runs by default — use this action to classify a document that already exists in the graph without re-ingesting it, or to preview a classification. 'ingest_url' content-aware single-URL ingest (CONCEPT:AU-KG.research.skill-graph-distillation): target_path=URL → fetch via the unified resolver (ArchiveBox→crawl4ai→requests) into a Document, and for a research roundup (auto-detected, or forced with description='extract_papers' / disabled with 'no_papers') download the cited papers via scholarx and ingest them too, linking page→paper; runs inline. 'archivebox_sync' pulls preserved ArchiveBox snapshots into the KG (corpus_name='full' = pull ALL, else delta; base_path=JSON list of snapshot ids to select). 'cdc_catchup' (CONCEPT:AU-KG.ingest.debezium-changeenvelope, CA-21) runs one bounded on-demand catch-up poll of the Debezium cdc.<db>.<schema>.<table> consumer — drains whatever is currently available (up to a batch cap), maps each row through debezium_envelope.map_debezium_event, and commits through the same ingest_envelope atomic boundary every other connector uses; returns counts (succeeded/skipped/quarantined/failed) and the last committed LSN watermark; never blocks waiting for more messages. 'opensearch_reindex' (CONCEPT:AU-KG.retrieval.opensearch-cdc-indexer, CA-24, DEC-CA-09) rebuilds the OpenSearch search-tier index for one eg graph/tenant by replaying eg.cdc. from offset 0 (or base_path=from_seq) into a freshly-dropped index (the P3 recovery mechanism — a full rebuild is always a valid recovery path, not an exceptional one): corpus_name=eg graph/tenant id (required), target_path=optional object_type to scope the rebuild to one index (default: every index this tenant owns). 'skill_workflows' ingests the universal-skills workflow corpus (workflows///SKILL.md) into the KG as dispatchable WorkflowDefinition DAGs (+WorkflowStep depends_on edges +USES_SKILL links) in the exact WorkflowStore shape run_workflow reads, so graph_orchestrate run_workflow can discover and fire them; ALSO sweeps the sibling atomic-skill corpus (skill_type: skill) into a CallableResource(AGENT_SKILL) each via the same reused ingest_runnable_skill primitive, so both legs of the corpus are classified by this one call; target_path optionally overrides the corpus root, default=installed universal_skills package; idempotent (content-addressed re-ingest is a no-op); runs as a BACKGROUND job (returns a job_id immediately — the full corpus takes ~150s, over the call ceiling — poll with action=job_status job_id=). 'materialize_source' runs an enterprise source extractor (corpus_name=category, e.g. 'camunda'/'aris'/'egeria'; description=optional JSON extractor config), persists its BusinessProcess/BusinessTask/FLOWS_TO batch into the graph via an in-process vendor client, then runs one OWL reasoning cycle so the new process structure folds into the cross-vendor crosswalk. 'fact_extract' turns a document (description=raw text, or target_path=file) into atomic (subject)-[predicate]->(object) fact edges with confidence/evidence/tags, dedups them, persists to the graph, and returns the facts + JSONL. 'sync_second_brain' (CONCEPT:AU-KG.enrichment.second-brain-note-sync) is the one-call personal-notes sync: target_path=notes directory or file (a markdown folder, an Obsidian vault, or a synced Nextcloud/Paperless export — see the second-brain-sync skill), corpus_name=corpus name, base_path=optional 'since' cursor (epoch seconds or an ISO-8601 timestamp) to only process notes changed since then. Per note: runs 'fact_extract' (evidence-spanned facts), extracts entities/claims and PROPOSES each new claim into the governed ClaimFlywheel lifecycle (graph_claims reads the same state — never silently accepted), then scans each new claim against existing graph content and persists any contradiction as a propose-only :BeliefRevisionProposal (the same node loop_controller's belief-revision pass writes, so existing review tooling picks it up with no new UI). Content-hash idempotent: re-running over an unchanged corpus mints zero new facts/claims/proposals. 'extract_submit'/'extract_jobs'/'extract_status'/'extract_pause'/'extract_resume'/'extract_jsonl' run extraction as a GPU-slot-scheduled job (preempt/backfill/resume on the single GPU) addressed by job_id; max_depth sets rounds. 'distill' exports a KG subgraph to a portable skill-graph (target_path=out dir; corpus_name=seed node id OR description=query; max_depth=hop depth). 'import_pack' re-ingests a distilled skill-graph dir back into the KG (target_path=dir; corpus_name='dedup' to merge duplicates). 'build_skill_graph' runs the UNIFIED skill-graph pipeline (CONCEPT:AU-KG.research.skill-graph-distillation): acquire from ANY source kind into one standardized skill-graph (corpus_name=name; target_path=output parent dir; base_path=JSON list of sources [{kind,uri,options}] OR 'kind=uri,kind=uri' shorthand over web/pdf/office/dir/url_reader/rest/database/mcp_tool/generated/kg_query; description=optional human description) — always writes the offline corpus + a sources.json provenance/freshness manifest, and ALSO ingests into the KG when the daemon is reachable (degrades cleanly otherwise). 'skill_graph_status' reports freshness of an existing skill-graph (target_path=dir; corpus_name='quick' to skip network sources). 'rebuild_skill_graph' re-acquires from the recorded sources and bumps the version (target_path=dir). Queue control: 'cancel' (job_id), 'clear' (target_path=status filter pending|running|completed|failed|cancelled|zombie|all, default completed), 'prioritize' (job_id, priority_bucket=0..3 — no named priority aliases are accepted). Research evolution (CONCEPT:AU-KG.ingest.batch-research-cohort): 'cohort_create' (base_path=JSON list of paper URLs, target_path=JSON list of repo paths, description=goal) batch-ingests a cohort of papers+repos whose self-polling barrier synthesizes the comparative feature/innovation matrix (KG-2.173) when every member drains; 'cohort_status' (job_id=cohort_id) returns per-member progress + the matrix counts; 'profile' (corpus_name=lane|type|tkind, CONCEPT:AU-OS.observability.per-lane-latency-metrics) returns per-lane/stage latency percentiles + token/cost + the parallelism factor.
job_id (string): ID of the job to check status for.
priority_bucket (integer): Integer WorkItem claim bucket used by prioritize.
corpus_name (string): Name of the corpus to add/update.
base_path (string): Base path for the corpus.
description (string): Description of the corpus.
content_type (string): Internal override only — leave empty. The content type (codebase, document, config, prompt, skill, mcp_server, kb, conversation, policy) is auto-detected from the path, and heavy types (codebase/document) always run on the async job queue. Only set this to force a specific category for an ambiguous path.
connection (string): CONCEPT:AU-KG.backend.multi-connection-registry — for action='ingest' codebase/document jobs: named BACKEND connection to submit to (default = primary). Selects WHICH BACKEND, never which physical graph — see graph. Fan-out ('all'/a list) is rejected: an ingest job always targets exactly one backend, never a union.
graph (string): CONCEPT:AU-KG.backend.explicit-graph-selection — for action='ingest' codebase/document jobs: explicit physical engine graph to ingest INTO (one of the names engine_tenants(action='list') returns), independent of connection. Empty = the caller's own bound graph (unchanged default behavior). An unknown graph, or a connection with no physical-graph concept, is a typed error — never a silent fallback or fan-out. The submitted job stays bound to this exact graph through async claim/run (persisted on the WorkItem), so it can never drift to a default/registry-wide graph.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_jobs`¶

graph jobs

Submit and inspect durable orchestration WorkItems.

Intent verbs: act, ask
REST route: /graph/jobs
MCP tags: granular, graph-os, job, jobs, orchestration
Side effects: 0/6 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

cancel → (no EG ledger match)
dead_letter → (no EG ledger match)
dispatch → (no EG ledger match)
drain → (no EG ledger match)
input → (no EG ledger match)
status → (no EG ledger match)

Typed input:

action (string): dispatch | status | cancel | input | dead_letter | drain
task (string): Task to dispatch.
job_id (string): Job/run/session id for status|cancel|input, or the dead-lettered WorkItem id for 'drain'.
agent_name (string): Optional agent hint for the queued turn.
dependencies (string): JSON list of prerequisite WorkItem ids.
input_responses (string): JSON object of client input responses for action='input' (the MCP Tasks extension's tasks/update inputResponses).
kind (string): 'dead_letter' only: filter to one WorkItem kind.
limit (integer): 'dead_letter' only: max rows.
reason (string): 'drain' only: why this item is being drained.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_kv_checkpoint`¶

graph kv checkpoint

checkpoint a KV-cache at a point of ideal understanding, then initialise a new agent from it or reset a conversation back to it.

Intent verbs: write, act
REST route: /graph/kv_checkpoint
MCP tags: , checkpoint, engine, granular, graph-os, kvcache, memory
Side effects: 1/8 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb']; txn=['Saga']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

checkpoint_now → (no EG ledger match)
create → (no EG ledger match)
explain → (no EG ledger match)
instantiate_agent → (no EG ledger match)
promote → (no EG ledger match)
ram_stats → (no EG ledger match)
recommend → (no EG ledger match)
restore_conversation → EG Restore (confidence 1.0)

Typed input:

action (string): create | instantiate_agent | restore_conversation
data_b64 (string): Base64 KV-cache blob bytes (create only).
model_identity (string): create: key component.
quantization (string): create: key component.
serving_engine (string): create: key component.
engine_version (string): create: key component.
prefix_digest (string): create: key component.
tenant (string): create: owning tenant (mandatory key component).
policy_version (string): create: key component (defaults to '').
run_id (string): create: the source run's id.
point (string): create: label for the checkpointed point.
provenance_json (string): create: free-form provenance JSON object.
checkpoint_id (string): instantiate_agent/restore_conversation: the checkpoint to load.
requesting_tenant (string): instantiate_agent/restore_conversation: the caller's tenant (checked against the checkpoint's stored tenant, fail-closed).
current_policy_version (string): instantiate_agent/restore_conversation: current policy version to validate against (empty ⇒ skip the staleness check).
new_run_id (string): instantiate_agent: the new run's id.
conversation_id (string): restore_conversation: the conversation to reset.
allow_cold_start (boolean): restore_conversation: on an invalid/foreign/stale checkpoint, return an explicit traced cold-start result instead of raising.
observation_json (string): recommend/checkpoint_now: a CheckpointObservation as JSON (rebuild cost, sibling/queued tasks, fetched/novel items, claim/evidence counts, contradictions, churn, phase, model_self_report). Every field is optional; an omitted field means NOT MEASURED and its scorer abstains rather than guessing.
evidence_bundle_json (string): recommend/checkpoint_now: an EvidenceBundle as JSON (as returned by graph_ask/graph_query). Its claims/evidence_spans/contradictions populate the grounding and contradiction axes directly, so a caller need not transcribe the counts. Explicit observation_json fields always win over anything derived here.
context_bundle_json (string): recommend/checkpoint_now: a ContextBundle as JSON. Its items/dropped_redundant/citations populate the retrieval-saturation (novelty) axis. Same precedence rule as evidence_bundle_json.
sources_json (string): checkpoint_now: the sources that contributed to this context, as a JSON list of either ref strings (resolved to their governance labels) or fully-labelled objects (source_id/classification/residency_regions/retention_days/markings). Usually unnecessary: citations carried on context_bundle_json already name them. An EMPTY source set refuses durable persistence — an unprovenanced checkpoint cannot be shown to permit data-at-rest.
trigger (string): checkpoint_now/promote: which path took this checkpoint — 'user', 'agent' or 'system'. PROVENANCE ONLY. It is recorded on the audit record and never read by the eligibility decision, which derives authority from the operator's checked session instead.
persist (boolean): checkpoint_now: also attempt durable (cross-session) persistence. Always subject to the eligibility gate; a refusal still leaves the RAM checkpoint in place.
graph (string): Target graph (default engine graph).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_kvcache`¶

graph kvcache

the engine's shared, content-addressed KV-cache over the EG-187 HTTP surface, driven through the KG-2.306 EpistemicGraphKVBackend connector.

Intent verbs: manage
REST route: /graph/kvcache
MCP tags: , engine, granular, graph-os, kvcache
Side effects: 0/5 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

contains → (no EG ledger match)
exists → (no EG ledger match)
get → (no EG ledger match)
put → (no EG ledger match)
stats → (no EG ledger match)

Typed input:

action (string): get | put | contains | exists | stats
key (string): Opaque block key (get/put/contains/exists).
value_b64 (string): Base64-encoded block bytes to store (put).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_learn`¶

graph learn

a pure-Rust KAN (Kolmogorov-Arnold) link-predictor over the resident graph, whose learned per-feature edge functions are THEMSELVES queryable KG nodes (interpretability, not raw accuracy).

Intent verbs: act, ask
REST route: /graphlearn/fit
MCP tags: , engine, granular, graph-os, graphlearn, kan, link-prediction, neuro-symbolic
Side effects: 2/2 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb']; txn=['Atomic']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

fit → EG GraphLearnFit (confidence 1.0)
predict → EG GraphLearnPredict (confidence 1.0)

Typed input:

action (string): Graph-learning action: 'fit' | 'predict'.
params_json (string): JSON object of graph-learning kwargs, e.g. {"node_label":"Person","direction":"any","degree":4,"epochs":200,"writeback":true} (fit); {"model":{...},"node_label":"Person","top_k":20,"writeback":true} or {"model":{...},"node_label":"Person","candidate_pairs":[["a","b"],["c","d"]]} (predict).
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_logs`¶

graph logs

query the engine's log stream. action='query' (default): filter by 'stream'/free-form 'query' over start..end, capped by 'limit'.

Intent verbs: ask
REST route: /graph/logs
MCP tags: , engine, granular, graph-os, logs, observability
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

query → (no EG ledger match)

Typed input:

action (string): query
stream (string): Log stream/source filter.
query (string): Free-form filter expression.
start (string): Range start, RFC3339/unix.
end (string): Range end, RFC3339/unix.
limit (integer): Max log lines to return.
params_json (string): JSON object of extra engine kwargs.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_loops`¶

graph loops

The single entrypoint for long-running objectives (CONCEPT:AU-KG.research.these-properties-carry).

Intent verbs: act
REST route: /graph/loops
MCP tags: granular, graph-os, loops, state
Side effects: 0/13 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

cancel → (no EG ledger match)
drive → (no EG ledger match)
gap → (no EG ledger match)
gaps → (no EG ledger match)
list → (no EG ledger match)
placement_control → (no EG ledger match)
prioritize → (no EG ledger match)
review → (no EG ledger match)
run → (no EG ledger match)
specs → (no EG ledger match)
state → (no EG ledger match)
submit → (no EG ledger match)
submit_gap → (no EG ledger match)

Typed input:

action (string): submit|list|run|drive|cancel|prioritize|state|specs|review|placement_control|gaps|submit_gap|gap
objective (string): Objective text (submit).
kind (string): research|develop|skill (submit).
loop_id (string): Loop id (submit/cancel).
validation_cmd (string): Shell command whose exit-0 completes a develop Loop.
end_state (string): Human end-state (develop).
skill_ref (string): Skill / skill-workflow name or id (skill Loop).
max_topics (integer): Loops to advance per run.
limit (integer): Max rows (list).
priority_bucket (integer): Integer WorkItem claim bucket 0-3 (submit/prioritize).
spec_id (string): SpecProposal id (review action).
decision (string): approve|edit|reject — spec-review decision (review action).
status (string): Filter SpecProposals by status (specs action): pending_review|approved|developing|published|reverted|rejected.
mine_discovery (any): 'run' only: gate the discovery-flywheel mining stage (CONCEPT:AU-KG.evolution.mining-flywheel). None (default) falls back to config.kg_loop_mine_discovery (default True); explicit true/false overrides.
placement_scan_limit (integer): 'placement_control' only: provenance row-scan cap for the placement mining pass.
placement_canary_tolerance (number): 'placement_control' only: fraction the canary metric may regress by and still be promoted (SLO noise tolerance).
data_json (string): 'submit_gap' only: JSON object {source, signature, statement, domain, severity, concept_ids}. source/signature/statement are required; severity (0..1, default 0.5) maps to the shared priority_bucket.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_media_sidecar`¶

graph media sidecar

Delegate a media artifact (PDF, JPEG, audio, video) to a governed fleet sidecar for heavy decode (OCR / image analysis / transcription / keyframe+shot detection) the pure-Rust engine deliberately does not do in-process, and write the result back as an ArtifactBundle + EvidenceLocus chain + embeddings through the EXISTING evidence-spine surfaces (reports/wave4/ADR-media-sidecar.md).

Intent verbs: write, act
REST route: /media/sidecar
MCP tags: delegation, evidence, granular, graph-os, media, media_sidecar
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

ingest_audio → (no EG ledger match)
ingest_jpeg → (no EG ledger match)
ingest_pdf → (no EG ledger match)
ingest_video → (no EG ledger match)

Typed input:

action (string): One of: ingest_audio, ingest_jpeg, ingest_pdf, ingest_video.
artifact_id (string): The document_id (PDF), image_id (JPEG), audio_id (audio), or video_id (video) this artifact is filed under.
data_b64 (string): Base64-encoded artifact bytes.
source (string): Provenance source tag.
provider (string): Optional non-default sidecar capability key (see sidecar_contract.SIDECAR_CAPABILITIES), e.g. 'pdf_documents' to route PDF ingest through paperless-ngx-mcp instead of the default stirlingpdf-mcp.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_memory`¶

graph memory

the engine's EG-318 memory surface: episodic→semantic memory, the spatial scene graph, and RL trajectories.

Intent verbs: write, ask
REST route: /graph/memory
MCP tags: , engine, granular, graph-os, memory, scene, trajectory
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

link → (no EG ledger match)
recall → (no EG ledger match)
store → (no EG ledger match)

Typed input:

action (string): Memory method: create_summary | consolidate | maintain | add_scene_object | world_transform | start_trajectory | append_step | discounted_return | get_* | ...
params_json (string): JSON object of kwargs for the memory method, e.g. {"node_ids":["n1","n2"]}, {"object_id":"o1","transform":[...]}, {"trajectory_id":"t1","step":{"state":...,"action":...,"reward":1.0}}, or {"trajectory_id":"t1","gamma":0.99}.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_message`¶

graph message

bidirectional, cross-process, ordered message channel between an invoking agent and a spawned agent, over the epistemic-graph native channels.

Intent verbs: act
REST route: /graph/message
MCP tags: granular, graph-os, messaging, orchestrate, query
Side effects: 1/5 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb']; txn=['Saga']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

close → (no EG ledger match)
history → (no EG ledger match)
open → (no EG ledger match)
receive → (no EG ledger match)
send → EG SendMessage (confidence 1.0)

Typed input:

action (string): open | send | receive | history | close
channel_id (string): Channel id (send/receive/history/close).
session_id (string): Session id (open).
run_id (string): Spawned run id (open).
sender (string): Sender label (send).
payload (string): Message text (send).
since (integer): Cursor: messages already consumed (receive).
durable (boolean): When True (send), also persist the message as a graph AgentMessage node so it survives engine restart and is replayable via action='history'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_observe`¶

graph observe

Reason over the KG-native observability subgraph — traces, online-scores, assertion verdicts, generations, prompt versions — queries an opaque trace store can't do (CONCEPT:AU-KG.ingest.observability-queries-opik-cannot).

Intent verbs: why, ask
REST route: /graph/observe
MCP tags: analyze_suite, eval, granular, graph-os, observe
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

error_detail → (no EG ledger match)
failure_cluster → (no EG ledger match)
prompt_regression → (no EG ledger match)
trace_rootcause → (no EG ledger match)

Typed input:

action (string): trace_rootcause | prompt_regression | failure_cluster | error_detail
query (string): Agent/capability filter (trace_rootcause) or a detail_ref (error_detail).
top_k (integer): Max rows/clusters.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_ontology`¶

graph ontology

GraphSchema lifecycle control plane. load/update attach an explicit iri+version Turtle document through EG. List/get return generated GraphSchema metadata; remove detaches the exact source.

Intent verbs: write, ask, manage
REST route: /graph/ontology
MCP tags: granular, graph-os, lifecycle, ontology
Side effects: 0/5 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

delete → (no EG ledger match)
get → (no EG ledger match)
list → (no EG ledger match)
load → (no EG ledger match)
update → (no EG ledger match)

Typed input:

action (string): load | list | get | update | remove
source (string): For load/update: a UTF-8 Turtle file path or raw Turtle text.
source_type (string): How to read source: 'file' | 'text' | 'auto' (sniff).
iri (string): Required stable ontology IRI for load/get/update/remove.
version (string): Required stable version for load/get/update/remove.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_orchestrate`¶

graph orchestrate

Resolve an ingested skill/workflow for a task and run it on the local vLLM through the governed graph-os delegation runtime.

Intent verbs: act
REST route: /graph/orchestrate
MCP tags: agent, analysis, granular, graph-os, orchestrate
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_orchestrate → (no EG ledger match)

Typed input:

task (string): Task for the delegated agent.
agent_name (string): Optional registered agent name. Empty resolves the best ingested skill/workflow/fleet-tool from the KG's unified capability ranking (CONCEPT:AU-KG.retrieval.unified-capability-contract) — a resolved Tool binds the default expert scoped to just that tool, exactly like passing skill_name+tool_server+allowed_tools explicitly.
skill_name (string): Exact ingested AGENT_SKILL name (in-loop OR a fleet-served skill:// resource). Mutually exclusive with agent_name and resolved fail-closed from the Knowledge Graph.
tool_server (string): Exact configured MCP server catalog to bind to skill_name, OR the server hosting a resolved/ranked fleet tool. The server transport comes from the live fleet configuration.
execution_mode (string): auto selects the leanest governed route; pydantic_graph requires skill_name, tool_server, and non-empty allowed_tools, then forces that contract through a real pydantic-graph graph.run.
max_steps (integer): Maximum delegated tool-loop steps.
context (string): Curated inline context injected into the delegated agent.
budget_tokens (integer): Hard total-token budget; zero uses the runtime default.
context_ref (string): Persisted ContextBlob id to resolve and inject.
allowed_tools (any): Least-privilege tool allow-list as a JSON list or comma-separated string.
required_tools (any): Tools that must each have recorded ToolCall provenance before the run can succeed. Must be a subset of allowed_tools.
cred_ref (string): Reference to an ephemeral credential in the secrets backend.
open_channel (boolean): Open a native bidirectional message channel for this run.
reasoning_effort (string): CONCEPT:AU-ORCH.execution.delegation-reasoning-off — reasoning is an OPT-IN capability (like RLM). A delegated agent runs with chain-of-thought OFF by default (deterministic tool loops don't need it and it stacks ~18x per-turn latency). Set an effort ('low'/'medium'/'high') to turn reasoning ON for an execution that genuinely needs deliberation (action='run_agent'). Empty = off / inherit the model's setting.
model_class (string): Required configured model class: economy | standard.
response_format (string): Response contract: text for ordinary prose or json for one Pydantic-validated JSON object.
grounding (string): CONCEPT:AU-KG.retrieval.fail-closed-grounding-contract — required (the default) fails this run closed if the mandatory evidence compilation times out, errors, or the retrieval-quality gate rejects every candidate, rather than silently answering ungrounded. best_effort/none explicitly opt into degraded operation, marked in the model messages, the RunTrace, and the OTel span, and never counted as a plain success.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_pipeline`¶

graph pipeline

a composable train→eval→serve→predict ML pipeline over a VERSIONED ':Model' artifact that GENERALIZES the KAN one-off: a spec of 'feature steps → split → a pluggable model family'.

Intent verbs: act, ask
REST route: /pipeline/train
MCP tags: , engine, granular, graph-os, ml-pipeline, model-registry, node-classification, pipeline
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_pipeline → (no EG ledger match)

Typed input:

action (string): Pipeline action: 'train' | 'eval' | 'serve' | 'predict' | 'compare'.
params_json (string): JSON object of pipeline kwargs, e.g. {"name":"community","spec":{"features":[{"step":"embedding","method":"fastrp","dim":32}],"split":{"test_ratio":0.3},"label_property":"label","model":{"family":"classify","algorithm":"logistic"}},"source":{"node_label":"Person"}} (train); {"name":"community","version":1} (serve); {"name":"community","version":0,"source":{"node_label":"Person"},"writeback":true} (predict); {"name":"community","version_a":1,"version_b":2} (compare).
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_projection`¶

graph projection

run the SAME query graph_query will and project the result into a stable node-link JSON shape: {nodes:[{id,label,properties}], links:[{source,target,label,properties}]} — the D3/force-graph convention every 2D/3D graph renderer already speaks.

Intent verbs: ask
REST route: /graph/projection
MCP tags: granular, graph-os, query, visualization
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_projection → (no EG ledger match)

Typed input:

request_json (string, required): JSON object: {query (required), params, scope, reference_id, as_of, connection, graph} — same fields/semantics as graph_query's individual arguments.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_promql`¶

graph promql

query the engine's observability metrics with PromQL. action='instant' (a single evaluation at 'time', default now) or 'range' (over start..end at 'step').

Intent verbs: ask
REST route: /graph/promql
MCP tags: , engine, granular, graph-os, metrics, observability
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

instant → (no EG ledger match)
range → (no EG ledger match)

Typed input:

query (string, required): A PromQL expression.
action (string): instant | range
time (string): Evaluation time (instant), RFC3339/unix.
start (string): Range start (range).
end (string): Range end (range).
step (string): Range step, e.g. '30s' (range).
params_json (string): JSON object of extra engine kwargs.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_query`¶

graph query

Run a read-only Cypher, bounded UQL, SQL, SPARQL, or federated graph query and return the sole typed EvidenceBundle response.

Intent verbs: ask
REST route: /graph/query
MCP tags: granular, graph-os, query
Side effects: 1/1 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb']; txn=['Atomic']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_query → EG CypherQuery (confidence 0.5)

Typed input:

query (string, required): A read-only query string; scope='local' expects Cypher and scope='uql' expects a bounded UQL pipeline ending in LIMIT 1..1000 with params='{}'.
params (string): JSON-encoded query parameters.
scope (string): local | uql | sql | sparql | federated
reference_id (string): ExternalGraphReference id required for federated queries.
as_of (string): Optional ISO-8601 bitemporal query instant; rejected for scope='uql' because the native UQL path cannot honor this top-level filter.
connection (string): Named BACKEND connection, 'all', or a connection list. Selects WHICH BACKEND, never which physical graph — see graph.
graph (string): CONCEPT:AU-KG.backend.explicit-graph-selection — explicit physical engine graph (see engine_tenants(action='list')), independent of connection. Empty = the caller's own bound graph. Fail-closed: an unknown graph or a connection/fan-out that has no physical-graph concept is a typed error, never a silent default/union. Echoed back in the response alongside connection.
include_epistemic (boolean): Resolve per-row epistemic data before building the bundle.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': 'CypherQuery', 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_reach`¶

graph reach

reach the user over a messaging backend (Telegram, Slack, Discord, ...).

Intent verbs: act
REST route: /graph/reach
MCP tags: granular, graph-os, messaging, reach
Side effects: 1/5 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

last_channel → (no EG ledger match)
list_channels → EG ListChannels (confidence 1.0)
reach_user → (no EG ledger match)
send → (no EG ledger match)
status → (no EG ledger match)

Typed input:

action (string): reach_user | send | list_channels | last_channel | status
text (string): Message text (reach_user/send).
platform (string): Backend id, e.g. 'telegram' (send/list_channels).
channel_id (string): Target channel/chat id (send).
user_id (string): User id for routing (reach_user/last_channel).
thread_id (string): Optional thread id (send).
reply_to_id (string): Optional message id to reply to (send).
reason (string): Why this message is being sent (audit trail).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_runvcs`¶

graph runvcs

Agent-native run version-control (CONCEPT:AU-ORCH.runvcs.run-commit): fork, revert and review a LIVE agent run as content-addressed commits that bind its conversation + filesystem + process/event frontier into ONE exact world. action in 'list' (live run sessions), 'status' (a run's event/commit/message counts + log digest), 'commit' (snapshot messages+fs+events into one RunCommit — pass label), 'revert' (restore a run's files+process+messages to a commit — pass commit_id), 'fork' (branch a NEW run from a commit into a fresh workspace, parent untouched — pass commit_id), 'discard' (drop the uncommitted event delta), 'replay' (deterministically replay the CURRENT live run's event log — a recorded exchange stands in for the model — and check reproduction).

Intent verbs: act
REST route: /graph/runvcs
MCP tags: fork, granular, graph-os, revert, runvcs, state, twin
Side effects: 2/11 actions matched an EG ledger Method; any_mutates=True; durability=['ControlRedb', 'None']; txn=['Saga', 'Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

commit → EG Commit (confidence 1.0)
discard → (no EG ledger match)
fork → EG Fork (confidence 1.0)
list → (no EG ledger match)
replay → (no EG ledger match)
revert → (no EG ledger match)
status → (no EG ledger match)
twin_capture → (no EG ledger match)
twin_counterfactual → (no EG ledger match)
twin_incident → (no EG ledger match)
twin_replay → (no EG ledger match)

Typed input:

action (string): list|status|commit|revert|fork|discard|replay|twin_capture|twin_replay|twin_counterfactual|twin_incident
run_id (string): Target run session id (live-run actions) or run id to hydrate a twin from (twin_capture).
commit_id (string): Target commit id (revert|fork).
label (string): Commit label (commit).
twin (string): JSON-serialized AgentDigitalTwin (CONCEPT:AU-ORCH.twin.agent-digital-twin) — the output of action='twin_capture'. Required by twin_replay/twin_counterfactual/twin_incident.
agent_name (string): Agent name to stamp on the twin (twin_capture).
task (string): Task description to stamp on the twin (twin_capture).
versions (string): JSON VersionPins fields (model_id, model_provider, prompt_version_id, tool_versions, skill_versions, policy_version, policy_digest, catalog_epoch). For twin_capture: the pins this run executed under. For twin_counterfactual: the swapped pins to diff against the twin's recorded pins (reporting only — pass policy_overrides/model_responses to actually change the replay outcome).
outcome (string): Outcome status to stamp on the twin (twin_capture; default 'succeeded').
persist (boolean): twin_capture: best-effort persist the twin as a durable :AgentDigitalTwin KG node (no-op without a live engine).
tool_calls (string): twin_capture EXPLICIT-DATA path: JSON array of {tool_name, args, result, error} records — the exact shape orchestration.tool_provenance.extract_tool_calls returns. Non-empty here (or in model_exchanges) makes twin_capture build the twin from this data directly (agent_digital_twin.capture_twin) instead of hydrating from the KG.
model_exchanges (string): twin_capture EXPLICIT-DATA path: JSON array of {request, response} model exchanges to mirror into the twin's event log.
policy_decisions (string): twin_capture (either path): JSON array of recorded ActionDecision dicts (request/decision/tier/reason/rule_origin/approval_id/audit_id) to attach to the twin. NEVER auto-discovered from the KG (today's AgentPolicyDecisionNode audit rows carry no edge back to the RunTrace that produced them) — pass them explicitly when known.
evidence (string): twin_capture (either path): JSON array of EvidenceBundle-shaped dicts backing the run's outcome.
budget (string): twin_capture EXPLICIT-DATA path only: JSON budget dict to stamp on the twin.
work_item_ids (string): twin_capture EXPLICIT-DATA path only: JSON array of WorkItem ids forming the run's DAG (auto-discovered from the KG instead on the hydration path).
policy_overrides (string): JSON policy ruleset {version, defaults, rules} for twin_counterfactual — recompute every recorded decision under this swapped policy version and diff against what was originally decided.
model_responses (string): JSON {request: alternate_response} for twin_counterfactual — substitute an alternate model/prompt response for a recorded model exchange and surface the resulting stream divergence.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_sandbox`¶

graph sandbox

Inspect and control the native warm-fork sandbox runtime (CONCEPT:AU-ORCH.sandbox.graph-sandbox-surface).

Intent verbs: act
REST route: /graph/sandbox
MCP tags: granular, graph-os, sandbox, state, warm-fork
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

reap → (no EG ledger match)
status → (no EG ledger match)
warm → (no EG ledger match)

Typed input:

action (string): status|reap|warm
rung (string): Approved confined warm-fork rung to warm.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_schedules`¶

graph schedules

Inspect and control the unified scheduler (CONCEPT:AU-OS.state.unified-scheduling-one-intelligent).

Intent verbs: manage, act
REST route: /graph/schedules
MCP tags: granular, graph-os, scheduler, state
Side effects: 0/6 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

disable → (no EG ledger match)
enable → (no EG ledger match)
list → (no EG ledger match)
prioritize → (no EG ledger match)
run_now → (no EG ledger match)
set_interval → (no EG ledger match)

Typed input:

action (string): list|enable|disable|prioritize|set_interval|run_now
name (string): Schedule name (all but list).
priority (integer): Integer claim bucket 0-3 (prioritize).
interval_s (number): New interval seconds (set_interval).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_search`¶

graph search

Search the Knowledge Graph using multiple strategies (hybrid, concept, analogy, memory, discover, dci).

Intent verbs: ask
REST route: /graph/search
MCP tags: granular, graph-os, query, search
Side effects: 1/1 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_search → EG SemanticSearch (confidence 0.5)

Typed input:

query (string, required): Natural language search query or concept ID.
mode (string): Search strategy:
'hybrid': Semantic + keyword weighted search (default).
'hyde': Memory-first HyDE multi-query plan + dual threshold (CONCEPT:AU-KG.retrieval.self-correcting-second-pass).
'deep': Wide-recall single query at the 0.28 deep threshold.
'concept': Look up a CONCEPT:ID (e.g. 'AU-KG.query.vendor-agnostic-traversal', 'AU-ORCH.execution.inject-signal-board-observations').
'analogy': Find structurally similar concepts.
'memory': Search tiered memory (episodic/semantic/procedural).
'discover': Cross-reference query against all ingested content.
'dci': Direct Corpus Interaction.
'latent': Latent-topology hierarchical routing (CONCEPT:AU-KG.memory.auto-similarity-memory-graph).
'sira': Single-shot SIRA sparsity-aligned context.
'hard_negatives': Mine hard negatives for the query (CONCEPT:AU-KG.memory.auto-similarity-memory-graph).
'rerank': Hybrid semantic+keyword re-scoring of candidates.
'adore': Iterative query expansion with retrieval-grounded graded relevance feedback + training-free stopping (CONCEPT:AU-KG.query.adore-concept-expansion/2.87).
'chrono_ids': Attach an explicit temporal semantic ID (+recency bucket) to each result for generative retrieval (CONCEPT:AU-KG.query.chronoid-fits-residual-quantization).
'compiled': Policy-aware ContextCompiler bundle (CONCEPT:AU-KG.retrieval.context-compiler) — MMR-diversified, evidence/freshness-weighted, token-budgeted, policy-filtered context with citations + a proof graph, instead of the plain relevance-sorted text the other modes return.
top_k (integer): Maximum results to return.
self_correct (boolean): CONCEPT:AU-KG.retrieval.self-correcting-second-pass — run a self-correcting second retrieval pass at the deep threshold when the quality gate fails.
as_of (string): Optional ISO-8601 instant. Pack-driven recency decay is measured relative to this time, enabling knowledge-state-as-of-date-D retrieval such as an academic literature state. Defaults to now (CONCEPT:EG-KG.compute.rust-native-training-loss).
connection (string): CONCEPT:AU-KG.backend.multi-connection-registry — named BACKEND connection to search (default = primary). Use a registered connection name, or 'all' (or a comma-separated list) to fan out and get per-connection labeled results. Selects WHICH BACKEND, never which physical graph — see graph.
graph (string): CONCEPT:AU-KG.backend.explicit-graph-selection — explicit physical engine graph, independent of connection. Empty = the caller's own bound graph. Requires exactly one resolved connection; fails closed (typed error, never a silent default/union) on an unknown graph or a fan-out/unsupported-connection combination. Echoed in the response.
token_budget (integer): mode='compiled' only: token budget the assembled bundle must fit inside (CONCEPT:AU-KG.retrieval.context-compiler). 0 uses the compiler's default budget.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': 'SemanticSearch', 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_search_synthesis`¶

graph search synthesis

Synthesize a shortcut-resistant deep-search task from the evidence graph, or diagnose realized search difficulty of solver trajectories (CONCEPT:AU-KG.retrieval.evidence-graph-workspace/2.71/2.72,

Intent verbs: ask
REST route: /graph/search-synthesis
MCP tags: granular, graph-os, query, search, synthesis, training-data
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

diagnose → (no EG ledger match)
synthesize → (no EG ledger match)

Typed input:

action (string): 'synthesize': build an evidence subgraph around an answer entity and formulate + adversarially refine a question that forces multi-hop search (no exposed constants / single-clue / co-coverage shortcuts). 'diagnose': score solver trajectories with the FORT signatures (solving cost, answer hit time, prior-shortcut rate) + a search-heavy verdict.
answer_id (string): action=synthesize — node id of the gold answer entity to build the task around.
hops (integer): action=synthesize — evidence-graph BFS depth.
fanout (integer): action=synthesize — max neighbors expanded per node.
min_trust (number): action=synthesize — drop facts whose source_trust is below this.
max_per_source (integer): action=synthesize — max clues allowed to share one evidence source before co-coverage trips.
root_popularity (number): action=synthesize — 0..1 familiarity of the answer entity (high → prior-binding risk).
trajectories (string): action=diagnose — JSON list of trajectories: [{"steps":[{"kind","observation","model_text"}],"answer_aliases":[...]}].

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_secret`¶

graph secret

Manage secrets (CONCEPT:AU-OS.identity.encrypted-secret-store) in the durable, engine-encrypted secrets store (secret VALUES are sealed by the engine's encryption-at-rest. Key NAMES + metadata stay queryable).

Intent verbs: manage
REST route: /graph/secret
MCP tags: granular, graph-os, secret, security
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

delete → (no EG ledger match)
get → (no EG ledger match)
list → (no EG ledger match)
set → (no EG ledger match)

Typed input:

action (string): set | get | list | remove
key (string): Secret key (set/get/remove).
value (string): Secret value (set).
metadata (any): Optional non-secret metadata (set).
reason (string): Why this mutation is happening (audit trail).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_sessions`¶

graph sessions

Manage durable sessions (action in 'list', 'get', 'remove', 'reply', 'cancel', 'health', 'topology').

Intent verbs: manage, ask
REST route: /graph/sessions
MCP tags: granular, graph-os, sessions, state
Side effects: 1/7 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['None']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

cancel → (no EG ledger match)
delete → (no EG ledger match)
get → (no EG ledger match)
health → EG Health (confidence 1.0)
list → (no EG ledger match)
reply → (no EG ledger match)
topology → (no EG ledger match)

Typed input:

action (string, required): Action: 'list', 'get', 'remove', 'reply', 'cancel', 'health', 'topology'
session_id (string): Target session ID
user_reply (string): Reply content for 'reply' action
limit (integer): Page size for 'topology'.
offset (integer): Page offset for 'topology'.
status (string): Optional session status filter for 'topology'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_share`¶

graph share

Share a private node (CONCEPT:AU-KG.compute.data-is-private-its).

Intent verbs: write, manage
REST route: /graph/share
MCP tags: granular, graph-os, ontology, tenancy
Side effects: 0/7 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

clear_parent → (no EG ledger match)
commons → (no EG ledger match)
hierarchy → (no EG ledger match)
mark → (no EG ledger match)
org → (no EG ledger match)
private → (no EG ledger match)
set_parent → (no EG ledger match)

Typed input:

action (string): 'org' share with my org | 'commons' promote to the shared commons graph | 'mark' attach a marking | 'private' restrict back to me | 'set_parent'/'clear_parent'/'hierarchy' manage the durable tenant hierarchy (kg:admin for the two writes).
node_id (string): Id of the node to share.
marking (string): Marking name (action='mark').
tenant_id (string): Tenant whose parent is being set/cleared/read (action='set_parent'|'clear_parent'|'hierarchy'). Defaults to the ambient actor's tenant for 'hierarchy'.
parent_tenant_id (string): Parent tenant to record (action='set_parent'). Refused on a cycle or past MAX_TENANT_DEPTH.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_table`¶

graph table

mirror data into native engine SQL tables (DataFusion + pg-wire) and manage them.

Intent verbs: ask, write
REST route: /graph/table
MCP tags: granular, graph-os, ingestion, query, table
Side effects: 0/6 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

create → (no EG ledger match)
drop → (no EG ledger match)
ingest → (no EG ledger match)
list → (no EG ledger match)
query → (no EG ledger match)
rows → (no EG ledger match)

Typed input:

action (string): 'ingest' | 'rows' | 'create' | 'list' | 'drop' | 'query'.
source (string): Registered connector key (action='ingest').
table (string): Target SQL table name.
config_json (string): JSON connector config (action='ingest').
columns_json (string): JSON list of column names (action='create').
rows_json (string): JSON list of row dicts (action='rows').
sql (string): A read-only SELECT statement (action='query').
limit (integer): Max rows to mirror (action='ingest').
replace (boolean): Drop+recreate the table first (ingest/rows).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_traces`¶

graph traces

search or fetch distributed traces. action='search' (filter by 'service'/'operation'/free-form 'query', capped by 'limit'), 'get' (a single 'trace_id'), or 'waterfall' (a single 'trace_id''s full Span/Generation subgraph, flattened for the trace-waterfall MCP App).

Intent verbs: ask, why
REST route: /graph/traces
MCP tags: , engine, granular, graph-os, observability, traces
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

get → (no EG ledger match)
search → (no EG ledger match)
waterfall → (no EG ledger match)

Typed input:

action (string): search | get | waterfall
trace_id (string): Trace id (action='get'/'waterfall').
service (string): Service name filter (search).
operation (string): Operation/span name filter (search).
query (string): Free-form filter expression (search).
limit (integer): Max traces to return (search).
params_json (string): JSON object of extra engine kwargs.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_viz`¶

graph viz

GOC-88/D-VZ-1 V5: render native charts through the engine's LOD ColumnStore/export pipeline (Method::Viz) — no matplotlib, no per-view chart code. action='plot_from_query' (the common path: 'query' [+'mark','x_field','y_field',+'color_field',+'size_field',+'title'] — runs the SQL query against the connected graph and renders the result. Answers {'unavailable': true} rather than an empty chart when the query returns no usable rows), 'export_chart' ('spec_json' + 'dataset_json' — an already-built ViewSpec/VizDatasetSource pair, thin pass-through), 'describe_chart' ('view_result_json' [+'spec_json'] — a plain-language, LLM-facing summary of what was actually drawn: mark, LOD tier, exact-vs-approximated, row count — no engine call), or 'capability_matrix' (which mark x surface pairs are real today). 'format' is png|svg|pdf; 'width_px'/'height_px' bound the canvas; 'max_primitives'/'max_bytes' bound the render budget — LOD selection is bounded by these, never by row count.

Intent verbs: act, ask
REST route: /graph/viz
MCP tags: , chart, engine, granular, graph-os, visualization, viz
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

capability_matrix → (no EG ledger match)
describe_chart → (no EG ledger match)
export_chart → (no EG ledger match)
plot_from_query → (no EG ledger match)

Typed input:

action (string): capability_matrix | export_chart | plot_from_query | describe_chart
query (string): Read-only SQL query (action='plot_from_query').
mark (string): line | scatter | bar | area | heatmap (action='plot_from_query').
x_field (string): Result column bound to x (action='plot_from_query').
y_field (string): Result column bound to y (action='plot_from_query').
color_field (string): Optional result column bound to color.
size_field (string): Optional result column bound to size.
title (string): Optional chart title.
spec_json (string): A full eg_viz_core::ViewSpec as JSON (action='export_chart').
dataset_json (string): A eg_types::viz::VizDatasetSource as JSON, externally tagged e.g. {'InlineColumns': {...}} (action='export_chart').
view_result_json (string): A prior render's 'view_result' as JSON (action='describe_chart').
format (string): png | svg | pdf.
width_px (integer): Canvas width in pixels.
height_px (integer): Canvas height in pixels.
max_primitives (integer): Frame primitive budget (bounds LOD tier).
max_bytes (integer): Frame byte budget (bounds LOD tier).
row_limit (integer): Max query rows fed inline into the render (action='plot_from_query'); the query itself should aggregate/LIMIT for anything larger — this is a safety cap on the wire payload, not the render budget (that's max_primitives/max_bytes, honored server-side in either case of row_limit).
dataset_ref (string): Dataset id for the render.
graph (string): Target graph (empty ⇒ deployment default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_workflows`¶

graph workflows

Manage governed WorkflowDefinitions.

Intent verbs: act, ask, manage
REST route: /graph/workflows
MCP tags: granular, graph-os, orchestration, workflow
Side effects: 0/8 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

compile → (no EG ledger match)
compile_process → (no EG ledger match)
dispatch → (no EG ledger match)
execute → (no EG ledger match)
execute_dynamic → (no EG ledger match)
export → (no EG ledger match)
list → (no EG ledger match)
status → (no EG ledger match)

Typed input:

action (string): compile | compile_process | list | run | run_dynamic | dispatch | status | export
workflow (string): Workflow name, process id, or run/session id.
task (string): Compilation description or workflow input task.
name (string): Optional compiled workflow name.
export_format (string): bpmn | json | skill (export).
max_steps (integer):
limit (integer):
max_agent_calls (integer):
max_concurrency (integer):
budget_tokens (any):
model_class (string): economy | standard
dynamic_fallback (string): run_dynamic only: error | stored_dag. Fallback applies only when the optional upstream runtime is unavailable.
workflow_run_id (string): run_dynamic only: RESUME a stopped run. Pass the workflow_run_id a previous run_dynamic reported to replay its already-completed steps instead of re-dispatching them (the response reports 'resumed' and 'replayed_step_ids'). Leave empty to start a brand-new run.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_write`¶

graph write

Write nodes, relationships, or register external graphs to the Knowledge Graph.

Intent verbs: write
REST route: /graph/write
MCP tags: granular, graph-os, mutation, write, write_ingest
Side effects: 4/14 actions matched an EG ledger Method; any_mutates=True; durability=['GraphRedb']; txn=['Atomic']
Cost: (unmeasured)
Latency: {'add_node': {'eg_method': 'AddNode', 'p50_ms': 0.187, 'p99_ms': 0.223, 'source': 'epistemic-graph/docs/benchmarks.md#results (2026-06-01, UDS, in-memory graph)', 'kind': 'measured'}}
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

add_edge → EG AddEdge (confidence 1.0)
add_node → EG AddNode (confidence 1.0)
bulk_ingest → (no EG ledger match)
check_loop → (no EG ledger match)
compare_and_set → (no EG ledger match)
delete_edge → EG RemoveEdge (confidence 1.0)
delete_node → EG RemoveNode (confidence 1.0)
log_chat → (no EG ledger match)
recall_media → (no EG ledger match)
recall_memory → (no EG ledger match)
register_execution → (no EG ledger match)
register_external_graph → (no EG ledger match)
store_memory → (no EG ledger match)
submit_sdd → (no EG ledger match)

Typed input:

action (string, required): Action to perform (add_node, add_edge, remove_node, remove_edge, register_external_graph, bulk_ingest, compare_and_set, store_memory, recall_memory, recall_media, log_chat, submit_sdd, register_execution, check_loop). Use 'compare_and_set' for an ATOMIC conditional update — optimistic concurrency / safe concurrent graph-shaping: it applies 'updates' only if every field in 'conditions' still equals the node's current value (missing field reads as null), so two agents mutating the same node never lose each other's write (conditional state transitions, atomic reservations).
node_id (string): The unique identifier for the node.
node_type (string): The type or label of the node.
properties (string): JSON-encoded dictionary of properties.
source_id (string): The source node ID for an edge.
target_id (string): The target node ID for an edge.
rel_type (string): The relationship type for an edge.
endpoint_url (string): URL for external graph registration.
graph_type (string): Type of external graph (e.g., 'sparql', 'graphql').
agent_id (string): ID of the agent performing the action.
nodes (string): JSON-encoded list of nodes or tags for bulk operations. For action='bulk_ingest' (CONCEPT:AU-KG.ingest.envelope-atomic-transaction, B-11): a list of node objects ({'id','type','properties'}, or {'kind':'node',...} explicitly) and/or edge objects ({'kind':'edge','source_id','target_id','rel_type','properties'} — 'source_id'+'target_id' alone also infers kind='edge'). Every element commits atomically in one native engine transaction (chunked deterministically at the engine's documented bounds — 32MiB / 50,000 ops / 500,000 items per chunk — never silently dropped; the response reports 'chunks').
idempotency_key (string): For action='bulk_ingest': a caller-owned idempotency key for this exact batch (CONCEPT:AU-KG.ingest.envelope-atomic-transaction). Non-empty (or a non-empty 'evidence') routes the batch onto the engine's atomic ApplyChangeEnvelopes path (durably idempotent, scoped by (tenant, graph, idempotency_key) — a replay reports 'status':'skipped', never silently re-reported as fresh 'success'). Empty ⇒ the lighter BatchUpdate path, which carries no per-call idempotency key at the wire level.
evidence (string): For action='bulk_ingest': JSON list of evidence records ({'object_id','modality','locus','content_digest'}) attached to the FIRST node in 'nodes' (CONCEPT:AU-KG.ingest.envelope-atomic-transaction). Non-empty routes the batch onto ApplyChangeEnvelopes (the only primitive carrying evidence/policy/lineage) instead of the lighter BatchUpdate.
upsert (boolean): For action='bulk_ingest' on the BatchUpdate (light) path: real engine insert-or-merge semantics (CONCEPT:AU-KG.ingest.envelope-atomic-transaction). True (default) MERGEs onto an existing id — idempotent re-application, matching every prior add_node-loop caller's behavior. False INSERTs (a repeated edge becomes an additional parallel edge rather than replacing the prior one).
connection (string): CONCEPT:AU-KG.backend.multi-connection-registry — named BACKEND connection to write to (default = primary). Use a registered connection name, or 'all' (or a comma-separated list) to mirror the SAME write to multiple backends. Fan-out requires an explicit multi-connection value; the default and a single named connection stay single-write. Selects WHICH BACKEND, never which physical graph — see graph.
graph (string): CONCEPT:AU-KG.backend.explicit-graph-selection — explicit physical engine graph to write to (one of the names engine_tenants(action='list')/the engine's own ListGraphs returns), independent of connection. Empty = the caller's own bound graph (unchanged default behavior). Requires exactly one resolved connection (the default one) — never combinable with connection='all'/a list. Authorization-checked by the engine's own RBAC/RLS on every call; an unknown graph, or a connection with no physical-graph concept, is a typed error — never a silent fallback to a default graph and never a union across graphs. Echoed back (as connection/graph) in the compare_and_set/recall_media JSON responses and appended to the plain-text outcome of the other write actions.
conditions (object): For action='compare_and_set': field→expected-value the node must currently match for the update to apply (a missing field reads as null). e.g. {'status': 'pending'}.
updates (object): For action='compare_and_set': field→new-value to merge into the node ONLY when every condition matches. e.g. {'status': 'claimed', 'owner': 'agent-7'}.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`graph_writeback`¶

graph writeback

Backfeed KG-derived knowledge into an external system-of-record (CONCEPT:EG-KG.storage.nonblocking-checkpoint/2.9). target='leanix'|'servicenow'|'erpnext'|'process'|'capability'. ops: inferences_json [{source,rel_type,target}] (relationships), enrichments_json [{node,patches,tag}], creations_json [{type,name}] (inventory CIs/items/fact sheets), retirements_json [{node}].

Intent verbs: write
REST route: /graph/writeback
MCP tags: granular, graph-os, ontology, writeback
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

graph_writeback → (no EG ledger match)

Typed input:

target (string): Write-back target: leanix | servicenow | erpnext | process | capability | (any registered sink).
action (string): 'write' (default), 'proposals' (list queued high-stakes proposals), or 'approve' (apply proposal_id).
proposal_id (string): For action='approve': the queued high-stakes proposal id to apply.
inferences_json (string): JSON list of inferred edges [{source,rel_type,target}] to write as upstream relations.
enrichments_json (string): JSON list of enrichments [{node, patches, tag}] onto existing records.
creations_json (string): JSON list of new records [{type,name,...}] to create upstream (inventory CIs/items).
retirements_json (string): JSON list [{node}] to retire/decommission upstream (highest risk).
process_ids_json (string): For target=process: JSON list of process ids to narrow to.
inventory (boolean): If true, collect the KG's reconciled inventory (infra/topology + LeanIX + TRM, deduped via ALIGNED_WITH) and create the items missing from the target CMDB/ERP.
asset_mirror (boolean): If true, fan ONE inventory pass out to EVERY enabled CMDB sink (ASSET_MIRROR_TARGETS ⊆ servicenow/erpnext/egeria/twenty) — the multi-SoR asset mirror. Each sink stays fail-closed (_ENABLE_WRITE) + dry-run-first. Ignores target.
findings (boolean): If true, file the KG's risk findings (TRM TechnologyRisk: EOL/vuln) as issues in the target tracker (gitlab/github/plane). Pass project context via creations_json[0] or the route.
dry_run (boolean): Preview proposed writes without mutating the system-of-record (default). Set false to apply.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ingest_sessions`¶

ingest sessions

Ingest AI agent chat/session history into the usage store + KG (CONCEPT:AU-ECO.mcp.client-side-chat-session). 'collect' auto-detects installed agents on THIS host and parses their local logs (use

Intent verbs: write
REST route: /usage/ingest-sessions
MCP tags: granular, graph-os, ingest, observability, write_ingest
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

collect → (no EG ledger match)
paths → (no EG ledger match)
upload → (no EG ledger match)

Typed input:

action (string): collect | upload | paths
bundles_json (string): For action=upload: JSON array of ParsedSessionBundle objects.
target_path (string): For action=paths: JSON list or comma paths.
tenant_id (string): Tenant scope for the rows.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`manage`¶

manage

Configure and govern graph-os and fleet loading. Previews first, then run with plan_ref. action='.' (see action='describe'), or leave it empty to route intent.

Intent verbs: manage
REST route: /intent/manage
MCP tags: intent
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

manage → (no EG ledger match)

Typed input:

action (string): Operation id ('.' or '') or 'describe'; empty routes intent.
params (object): Operation arguments. With action='describe', {'action': ''} returns that operation's argument schema.
intent (string): Natural-language request, routed when action is empty.
execute (boolean): Run now; when false, return the resolved plan.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`nl_query`¶

nl query

ask the Knowledge Graph in plain English, planned by agent-utilities' OWN configured fleet LLM (the local vLLM / provider the rest of AU uses) acting as the engine's NL planner.

Intent verbs: ask
REST route: /graph/nl-query
MCP tags: granular, graph-os, nl, query
Side effects: 1/1 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

nl_query → EG NlQuery (confidence 1.0)

Typed input:

text (string, required): The natural-language request to answer.
dialect (string): 'auto' (model chooses, prefers uql) or 'uql'|'cypher'|'sql'|'sparql'.
schema_hint (string): Optional extra schema/context hint to ground the planner.
execute (boolean): When false, return only the generated query (preview/dry-run).
limit (integer): Max result rows to return.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': 'NlQuery', 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`object_edits`¶

object edits

Durable object-edit ledger (CONCEPT:AU-KG.ontology.edit-ledger-writeback): record a structured edit (property_set/link_add/link_remove/object_create/object_remove), revert an edit, or read per-object history / as_of snapshot.

Intent verbs: write
REST route: /object/edits
MCP tags: granular, graph-os, ontology
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

as_of → (no EG ledger match)
history → (no EG ledger match)
record → (no EG ledger match)
revert → (no EG ledger match)

Typed input:

action (string): 'record' an edit | 'revert' an edit by id | 'history' per object | 'as_of' snapshot.
object_id (string): Target object id (record/history/as_of).
edit_type (string): property_set|link_add|link_remove|object_create|object_remove (for action='record').
properties_json (string): JSON property map (record property_set/object_create).
link_target (string): Link target id (record link_add/link_remove).
link_label (string): Link label (record link_add/link_remove).
edit_id (string): Edit id (action='revert').
ts (number): Unix timestamp (action='as_of').
actor (string): Acting principal recorded on the edit.
expect (object): For action='record' edit_type='property_set': field→expected current value the object must still match for the set to apply (missing field reads as null). When non-empty the set goes through an atomic compare-and-set (CONCEPT:AU-KG.ontology.optimistic-concurrency-object-property): the edit is recorded ONLY if it wins; an unapplied set returns {'applied': false} and records nothing. Empty (default) = unconditional set, identical to prior behavior. e.g. {'status': 'pending'}.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`object_index`¶

object index

Object Index Lifecycle / Object Data Funnel (CONCEPT:AU-KG.ontology.batch-incremental-sync-live): batch/incremental sync of the live search index from source nodes, report staleness, or reindex stale

Intent verbs: ask, find
REST route: /object/index
MCP tags: granular, graph-os, ontology
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

reindex → (no EG ledger match)
status → (no EG ledger match)
sync → (no EG ledger match)

Typed input:

action (string): 'sync' (batch rebuild) | 'reindex' (reconcile stale) | 'status' (live/tombstone counts).
nodes_json (string): JSON list of source node mappings (sync/reindex).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`object_permissioning`¶

object permissioning

Fine-grained object permissioning (CONCEPT:AU-KG.ontology.redact-object-materialize-restricted): redact an object, materialize a restricted view, or attach a mandatory marking.

Intent verbs: manage
REST route: /object/permissioning
MCP tags: granular, graph-os, ontology
Side effects: 0/3 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

mark → (no EG ledger match)
redact → (no EG ledger match)
restricted_view → (no EG ledger match)

Typed input:

action (string): 'redact' one object | 'restricted_view' an object set | 'mark' attach a marking.
objects_json (string): JSON list of object dicts (restricted_view).
object_json (string): JSON object dict (redact).
node_id (string): Node id (action='mark').
marking (string): Marking name (action='mark').
mask (boolean): Mask withheld properties instead of dropping them.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`object_set`¶

object set

Object Set Service (CONCEPT:AU-KG.ontology.link-type-pivot/2.38): search/filter/search_around/pivot/aggregate and union/intersect/subtract over Foundry-style object sets. action='path'

Intent verbs: ask, write
REST route: /object/set
MCP tags: granular, graph-os, ontology
Side effects: 0/10 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

aggregate → (no EG ledger match)
from_ids → (no EG ledger match)
intersect → (no EG ledger match)
of_type → (no EG ledger match)
path → (no EG ledger match)
pivot → (no EG ledger match)
search → (no EG ledger match)
search_around → (no EG ledger match)
subtract → (no EG ledger match)
union → (no EG ledger match)

Typed input:

action (string): of_type|from_ids|search|filter|search_around|pivot|aggregate|union|intersect|subtract|path.
type_or_interface (string): Object type / interface (of_type).
ids_json (string): JSON list of ids (from_ids / set algebra 'other').
query (string): Search query (search).
link_type (string): Link type (search_around/pivot); empty = any.
hops (integer): Hop count (search_around).
direction (string): out|in|both (search_around/pivot).
group_by (string): Group-by property (pivot/aggregate).
metric (string): count|sum|avg|min|max (aggregate).
field (string): Numeric field (aggregate sum/avg/min/max).
limit (integer): Result limit (search).
source_id (string): Source object id (action='path').
target_id (string): Target object id (action='path').

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_classification_claims`¶

ontology classification claims

Typed, provenance-bearing multi-category classification claims (U-47, CONCEPT:AU-KG.ontology.classification-claim-multi-category / classification-claim-promotion-lifecycle / cross-source-identity-proposal).

Intent verbs: write, ask
REST route: /ontology/classification-claims
MCP tags: classification, granular, graph-os, ontology
Side effects: 0/11 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

categories → (no EG ledger match)
history → (no EG ledger match)
lifecycle_history → (no EG ledger match)
promote → (no EG ledger match)
propose_identity → (no EG ledger match)
query → (no EG ledger match)
record → (no EG ledger match)
reject → (no EG ledger match)
resolve_evidence → (no EG ledger match)
review → (no EG ledger match)
supersede → (no EG ledger match)

Typed input:

action (string): record | query | categories | history | resolve_evidence | review | promote | reject | supersede | lifecycle_history | propose_identity.
subject_id (string): For query/categories/history.
category (string): For query/history.
status (string): For query: filter by status.
claim_json (string): For record: a raw claim record (subject_id/category/value/evidence_refs/method/source_snapshot/...) as JSON. For review/promote/reject/supersede/resolve_evidence: the FULL claim object (as returned by a prior record/query call) as JSON.
new_claim_json (string): For supersede: the successor claim, same shape as claim_json.
source_snapshot (string): For record/propose_identity.
policy_approved (boolean): For record: pre-cleared a candidate/generated claim through action_policy already.
reviewer (string): For promote/reject.
reason (string): For review/promote/reject/supersede.
viewer_clearance (string): For resolve_evidence.
claim_id (string): For lifecycle_history.
artifact_a_id (string): For propose_identity.
artifact_b_id (string): For propose_identity.
evidence_refs_json (string): For propose_identity: JSON array of Fragment ids.
extractor_ref (string): For record (via claim_json)/propose_identity.
confidence (number): For propose_identity: 0.0-1.0, or omit (-1.0 sentinel) for an explicit abstain.
tenant (string): For record/propose_identity.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_derive`¶

ontology derive

Compute derived (function/cypher/sparql/embedding-backed) properties live at read time (CONCEPT:AU-KG.ontology.derived-property-registry).

Intent verbs: write
REST route: /ontology/derive
MCP tags: granular, graph-os, ontology
Side effects: 1/5 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['Snapshot']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

compute → (no EG ledger match)
compute_all → (no EG ledger match)
discover_extensions → EG Discover (confidence 1.0)
generate → (no EG ledger match)
list → (no EG ledger match)

Typed input:

action (string): 'list' declarations, 'compute' one property, 'compute_all', 'discover_extensions' (propose ontology .ttl extensions from a text sample, CONCEPT:AU-KG.ontology.do-not-auto-merge), or 'generate' (from-scratch: propose a COMPLETE standalone Interface/LinkType ontology from a text sample against an EMPTY base — same schema-discovery LLM path, never a diff vs the live ontology, always a human-reviewed proposal).
object_json (string): JSON object dict the property is computed for.
name (string): Derived-property name for action='compute'.
object_type (string): Optional object type for declaration resolution; the content/source type for action='discover_extensions'/'generate' (a domain hint, e.g. 'clinical_trial').
sample_text (string): Representative document/business-scenario text for action='discover_extensions'/'generate'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_function`¶

ontology function

Typed, versioned ontology functions: list or invoke through the governed runtime (CONCEPT:AU-KG.ontology.default-runtime-bound-import).

Intent verbs: act, write
REST route: /ontology/function
MCP tags: granular, graph-os, ontology
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

invoke → (no EG ledger match)
list → (no EG ledger match)

Typed input:

action (string): 'list' registered functions or 'invoke' one.
name (string): Function name for action='invoke'.
params (string): JSON-encoded typed input params.
version (string): Optional pinned semver version.
actor (string): Invoking actor id (recorded in the audit entry).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_interface`¶

ontology interface

Ontology interfaces: resolve implementers (targeting), check conformance, or emit OWL (CONCEPT:AU-KG.ontology.conformance-check).

Intent verbs: manage, ask
REST route: /ontology/interface
MCP tags: granular, graph-os, ontology
Side effects: 0/8 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

conforms → (no EG ledger match)
explain_routing_eligibility → (no EG ledger match)
graph → (no EG ledger match)
implementers → (no EG ledger match)
lint → (no EG ledger match)
list → (no EG ledger match)
owl → (no EG ledger match)
summary → (no EG ledger match)

Typed input:

action (string): 'list' interfaces, 'implementers' (resolve an interface/type to concrete types), 'conforms' (check an object), 'owl', 'graph' (schema as a node/edge diagram), 'summary' (schema as Markdown), 'lint' (naming-style + typo check), or 'explain_routing_eligibility' (X-4 WHY-eligible routing explanation).
name (string): Interface or concrete type name.
object_json (string): JSON object dict for action='conforms'.
registry (string): Which interface registry: 'structural' (built-in shapes) or 'enterprise' (enterprise-standard contracts, CONCEPT:AU-KG.ontology.populated-at-import-real-3).
entity_id (string): Candidate tool/agent node id (action='explain_routing_eligibility').
required_capability_type (string): Required ontology capability type, e.g. 'TransportCapability' (action='explain_routing_eligibility').
tenant (string): Required tenant scope, if any (action='explain_routing_eligibility').
policy_tags (string): Comma-separated required policy tags, if any (action='explain_routing_eligibility').

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_leanix_sync`¶

ontology leanix sync

Discover the live LeanIX metamodel and mirror it natively as OWL/RDF: regenerates ontology_leanix.ttl (every fact sheet type, relation, field) and registers the types for OWL promotion

Intent verbs: write
REST route: /ontology/leanix-sync
MCP tags: granular, graph-os, ontology
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

ontology_leanix_sync → (no EG ledger match)

Typed input:

dry_run (boolean): Preview the generated ontology without writing (default). Set false to apply.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_link_materialize`¶

ontology link materialize

Reify a multiple-to-multiple ontology link as a (junction_node, edge_a, edge_b) triple and write it (CONCEPT:AU-KG.domains.trade-journal-bias-auditor).

Intent verbs: write
REST route: /ontology/link-materialize
MCP tags: granular, graph-os, ontology
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

types → (no EG ledger match)

Typed input:

action (string): 'types' to list link types, or 'materialize' a junction.
link_name (string): The junction link type name, e.g. 'agent_skill'.
source_id (string): Source endpoint node id.
target_id (string): Target endpoint node id.
properties (string): JSON-encoded junction (link) properties.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_model_profile`¶

ontology model profile

Model profiles as first-class graph resources (CONCEPT:AU-KG.ontology.model-profile-graph-resource): 'list' the configured registry's models as profile previews (no KG write), 'sync' upserts a

Intent verbs: manage, ask
REST route: /ontology/model-profiles
MCP tags: granular, graph-os, ontology
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

get → (no EG ledger match)
list → (no EG ledger match)
owl → (no EG ledger match)
sync → (no EG ledger match)

Typed input:

action (string): 'list' | 'sync' | 'get' | 'owl'.
model_id (string): Registry model id for action='get'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_property_types`¶

ontology property types

List the ontology property-type registry and resolve/validate a Palantir-style type ref (CONCEPT:AU-KG.ontology.ontology-property-types).

Intent verbs: manage, ask
REST route: /ontology/property-types
MCP tags: granular, graph-os, ontology
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

column_type → (no EG ledger match)
describe → (no EG ledger match)
list → (no EG ledger match)
validate → (no EG ledger match)

Typed input:

action (string): 'list' all type names, 'describe' a type, 'column_type' a type's column DDL string, or 'validate' a value.
type_ref (string): A type ref, e.g. 'array' or 'vector<768>'.
value (string): JSON-encoded value for action='validate'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_repository_provenance`¶

ontology repository provenance

Git identity and history anchors (U-47, CONCEPT:AU-KG.ontology.repository-provenance-snapshot), additive to the existing :Commit/:Author/:File model git_history already ingests.

Intent verbs: write
REST route: /ontology/repository-provenance
MCP tags: granular, graph-os, ontology, provenance
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

branch → (no EG ledger match)
change_event → (no EG ledger match)
snapshot → (no EG ledger match)
tag → (no EG ledger match)

Typed input:

action (string): snapshot | branch | tag | change_event.
repo_id (string): Required for every action.
commit_sha (string): Required for snapshot/branch/tag/change_event.
ref (string): For snapshot: the ref name captured.
name (string): For branch/tag: the pointer's name.
annotation (string): For tag: optional annotation.
kind (string): For change_event: commit | branch_move | tag_cut | ...
occurred_at (string): For change_event: ISO-8601 timestamp; defaults to now.
subject_id (string): For change_event: the file/entity this event concerns.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_sampling_profile`¶

ontology sampling profile

Task-aware LLM sampling profiles (CONCEPT:AU-ORCH.routing.sampling-profile-selection/KG-2.94): list/describe the per-task-class profiles, 'resolve' the profile that will be picked for a prompt/role,

Intent verbs: manage, ask
REST route: /ontology/sampling-profiles
MCP tags: granular, graph-os, ontology
Side effects: 0/6 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

describe → (no EG ledger match)
evolve → (no EG ledger match)
list → (no EG ledger match)
owl → (no EG ledger match)
resolve → (no EG ledger match)
set → (no EG ledger match)

Typed input:

action (string): 'list' | 'describe' | 'resolve' | 'set' | 'evolve' | 'owl'.
task_class (string): Task class for describe/set/evolve.
task_text (string): Free-text prompt for action='resolve'.
role (string): Functional role for action='resolve'.
profile_json (string): JSON SamplingProfile dict for action='set'.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`ontology_value_types`¶

ontology value types

List/describe constrained ontology value types and validate or coerce a value (CONCEPT:AU-KG.ontology.value-type-shacl-load).

Intent verbs: manage, ask
REST route: /ontology/value-types
MCP tags: granular, graph-os, ontology
Side effects: 0/4 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

coerce → (no EG ledger match)
describe → (no EG ledger match)
list → (no EG ledger match)
validate → (no EG ledger match)

Typed input:

action (string): 'list' | 'describe' | 'validate' | 'coerce'.
name (string): The value-type name, e.g. 'EmailAddress'.
value (string): JSON-encoded value for validate/coerce.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`quant`¶

quant

The Ultimate Quant System Tool.

Intent verbs: ask, act
REST route: /quant
MCP tags: gated, granular, ontology
Side effects: 1/14 actions matched an EG ledger Method; any_mutates=False; durability=['None']; txn=['None']
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

analyze → (no EG ledger match)
balances → (no EG ledger match)
cancel_order → (no EG ledger match)
debate → (no EG ledger match)
ensemble_predict → (no EG ledger match)
fundamentals → (no EG ledger match)
historical → (no EG ledger match)
optimize → (no EG ledger match)
order_book → (no EG ledger match)
positions → (no EG ledger match)
regime → (no EG ledger match)
risk_metrics → EG Metrics (confidence 1.0)
status → (no EG ledger match)
submit_order → (no EG ledger match)

Typed input:

domain (string, required):
action (string, required):
ticker (string):
asset_class (string):
period (string):
interval (string):
side (string):
quantity (number):
order_type (string):
price (number):
mode (string):
portfolio_id (string):
rounds (integer):

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`research_artifact`¶

research artifact

Agent-Native Research Artifacts over the one ontology-driven KG (CONCEPT:AU-KG.research.best-effort-lightweight-never/2.80). action in 'reason' (run OWL/RDF reasoning over the whole ecosystem and

Intent verbs: ask, write
REST route: /research/artifact
MCP tags: granular, graph-os, ontology, research, state
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

research_artifact → (no EG ledger match)

Typed input:

action (string): reason|compile|review|seal|capture|get|list|ask
topic (string): Topic to ask into (ask).
article_id (string): Paper/article id (compile/review/get).
query (string): Topic for 'reason' (reasoning is ecosystem-wide).
level (string): Seal level: L1|L2|L3 (review).
text (string): Event text (capture).
provenance (string): capture provenance: user|ai_suggested|ai_executed|user_revised.
actor (string): Originating actor id (capture).
event_type (string): Force event type (capture).
target_codebase (string): Codebase to ground claims against (compile).
limit (integer): Max rows (list).
materialize (boolean): Persist inquiry nodes (ask).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`skill_classify`¶

skill classify

Classify a skill (skill_id from /api/enhanced/tools' skills[]/skill_workflows[]/skill_graphs[] .id, or the fleet catalog's skills table) as skill_type='skill'|'workflow'|'graph', and persist the choice so it survives the next fleet-tool-schema-sync re-derive from the corpus.

Intent verbs: write
REST route: /skill/classify
MCP tags: granular, graph-os, ingest, skills, write_ingest
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

skill_classify → (no EG ledger match)

Typed input:

skill_id (string, required): The skill's catalog id (skills[].id from /api/enhanced/tools).
skill_type (string, required): skill | workflow | graph.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`source_connector`¶

source connector

Document-source connectors (CONCEPT:AU-ECO.connector.document-source-framework–4.29, KG-2.59): list registered connectors, or run one

Intent verbs: manage, write
REST route: /connector/source
MCP tags: connectors, ecosystem, granular, graph-os, ontology
Side effects: 0/2 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

list → (no EG ledger match)
run → (no EG ledger match)

Typed input:

action (string): One of: 'list' (registered connector types), 'run' (build + ingest a connector).
source_type (string): Connector type for 'run' (filesystem/web/rest/database/graphql_document/mcp:/mcp_tool).
config (object): Connector configuration dict for 'run' (e.g. {'root': '/docs'} or {'base_url': 'https://…'}).
connector_id (string): Stable id for incremental checkpoint storage (optional).
contextual (boolean): Enable contextual-retrieval enrichment (CONCEPT:AU-KG.enrichment.contextual-retrieval-enrichment).
incremental (boolean): Use the connector's resumable poll (CONCEPT:AU-ECO.connector.incremental-poll-watermark) vs a full load.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`source_drain`¶

source drain

Watch a chunked async drain started by source_sync(mode='full') on a LARGE corpus (CONCEPT:AU-KG.ontology.single-source-full-drain). action='status' + drain_id returns cumulative progress (pages_done / items_seen / items_ingested) plus a live per-status breakdown of the drain's connector_drain WorkItems. action='list' lists registered chunked-drain sources.

Intent verbs: write
REST route: /source/drain
MCP tags: granular, graph-os, ingestion, ontology
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

source_drain → (no EG ledger match)

Typed input:

action (string): 'status' (progress for a drain_id) or 'list' (registered chunked sources).
drain_id (string): The drain handle returned by source_sync(mode='full') (for action='status').

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`source_sync`¶

source sync

THE canonical connector→KG ingestion tool (CONCEPT:AU-KG.ingest.enterprise-source-extractor) — one entrypoint for every external source. source='leanix'|'camunda'|'servicenow'|'gitlab'|… (any registered hydration/materialize source), OR source='all' to sweep EVERY configured connector in one pass (the fleet-wide background-ingest sweep). mode='delta' (only changes since the watermark, default), 'full' (re-mirror all), or 'reconcile' (tombstone records removed upstream).

Intent verbs: write
REST route: /source/sync
MCP tags: granular, graph-os, ingestion, ontology
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

source_sync → (no EG ledger match)

Typed input:

source (string): Registered source to sync (e.g. 'leanix', 'camunda', 'servicenow').
mode (string): 'delta' (watermark poll), 'full' (re-mirror all), or 'reconcile' (tombstone deletions).
ids_json (string): JSON list of record ids to narrow the sync (webhook delta).
connection (string): CONCEPT:AU-KG.backend.multi-connection-registry — named BACKEND connection to sync into (default = primary). Selects WHICH BACKEND, never which physical graph — see graph. Fan-out ('all'/a list) is rejected: a source sync always targets exactly one backend, never a union — distinct from source='all', which fans out across CONNECTORS, not backends/graphs.
graph (string): CONCEPT:AU-KG.backend.explicit-graph-selection — explicit physical engine graph to sync THIS source into (one of the names engine_tenants(action='list') returns), independent of connection. U-37: gives each source its OWN isolated physical graph and watermark/checkpoint (the native ChangeEnvelope cursor is scoped to whatever graph this call narrows onto), so unbounded multi-source imports never share one bulk watermark across sources with different trust/change-detection boundaries. Empty = the caller's own bound graph (unchanged default behavior). An unknown graph, or a connection with no physical-graph concept, is a typed error — never a silent fallback or fan-out.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`spec_ticket`¶

spec ticket

Link a KG SDD spec/feature to a Plane/Jira work item and make agents assignable (CONCEPT:AU-KG.ingest.enterprise-source-extractor). action='link' (push spec content onto the item, link it, assign to user/agent/act-as-user, comment) or 'pull' (read items assigned to a user — 'what do I own?').

Intent verbs: write, ask
REST route: /spec/ticket
MCP tags: granular, graph-os, ontology, sdd, writeback
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

spec_ticket → (no EG ledger match)

Typed input:

action (string): 'link' or 'pull'.
target (string): 'plane' or 'jira'.
spec_json (string): For action='link': the spec dict {feature_id,title,user_stories,...}.
issue_id (string): The Plane work-item id / Jira issue key.
project_id (string): Plane project id (for plane).
assignee (string): Explicit user id to assign.
agent (string): Agent id to assign (maps via AGENT_USER_MAP).
comment (string): Optional comment to post.
user (string): For action='pull': user whose items to read.
dry_run (boolean): Preview without writing (default).

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`tabular_query`¶

tabular query

Run a read-only SQL projection through the governed tabular query service and return its typed evidence bundle.

Intent verbs: ask
REST route: /query/tabular
MCP tags: granular, graph-os, query, tabular
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

tabular_query → (no EG ledger match)

Typed input:

sql (string, required): A non-empty read-only SQL statement.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`usage_query`¶

usage query

Query usage/cost/observability analytics (CONCEPT:AU-ECO.mcp.usage-cost-observability-surface): token counts, cost, model/tool/skill/db-call usage, session browser, activity heatmap, full-text search, and Langfuse trace links.

Intent verbs: ask
REST route: /usage/query
MCP tags: granular, graph-os, observability, usage, write_ingest
Side effects: 0/12 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

activity → (no EG ledger match)
by_agent → (no EG ledger match)
by_model → (no EG ledger match)
by_project → (no EG ledger match)
search → (no EG ledger match)
series → (no EG ledger match)
session_detail → (no EG ledger match)
sessions → (no EG ledger match)
summary → (no EG ledger match)
tools → (no EG ledger match)
top_sessions → (no EG ledger match)
traces → (no EG ledger match)

Typed input:

action (string): summary | by_model | by_project | by_agent | tools | activity | sessions | session_detail | top_sessions | search | traces | series
from_date (string): ISO start (started_at >=).
to_date (string): ISO end (started_at <=).
project (string): Filter by project.
agent (string): Filter by agent type.
model (string): Filter by model.
origin (string): ingested | runtime (omit for both).
tenant_id (string): Tenant scope.
session_id (string): For action=session_detail.
query (string): For action=search (FTS).
limit (integer): Row cap for list actions.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`why`¶

why

Explain beliefs, decisions, provenance and changes. action='.' (see action='describe'), or leave it empty to route intent.

Intent verbs: why
REST route: /intent/why
MCP tags: intent
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

why → (no EG ledger match)

Typed input:

action (string): Operation id ('.' or '') or 'describe'; empty routes intent.
params (object): Operation arguments. With action='describe', {'action': ''} returns that operation's argument schema.
intent (string): Natural-language request, routed when action is empty.
execute (boolean): Run now; when false, return the resolved plan.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

`write`¶

write

Create or change graph data. Previews first, then run with plan_ref. action='.' (see action='describe'), or leave it empty to route intent.

Intent verbs: write
REST route: /intent/write
MCP tags: intent
Side effects: 0/1 actions matched an EG ledger Method; any_mutates=False; durability=[]; txn=[]
Cost/Latency: unmeasured for this capability (no benchmark source)
Reliability: (unmeasured — no live engine reward reachable at generation time)

Does:

write → (no EG ledger match)

Typed input:

action (string): Operation id ('.' or '') or 'describe'; empty routes intent.
params (object): Operation arguments. With action='describe', {'action': ''} returns that operation's argument schema.
intent (string): Natural-language request, routed when action is empty.
execute (boolean): Run now; when false, return the resolved plan.

Eligibility predicates: eligible(candidate, required) = ontology_subsumption(candidate.capability_type, required) AND tenant_match(candidate.tenant, caller.tenant) AND policy_tag_match(candidate.policy_tags, required.policy_tags), ranked by cosine(embedding) + reward_weight*(bandit_reward-0.5)

Calibrated outcomes: (empty — no live bandit reward reachable at generation time)

Provenance: {'generator_version': '1.0.0', 'source_repo_au': 'agent-utilities', 'source_module_au': 'agent_utilities.mcp.kg_server', 'source_method_eg': None, 'eg_ledger_path': 'repo://epistemic-graph/docs/capabilities.generated.md', 'eg_ledger_available': True, 'generated_at': '2026-10-08T20:38:47Z'}

graph-os Capability Power Descriptors (generated)¶

Index¶

Capabilities¶

act¶

agent_library¶

ask¶

ask_data¶

concept_registry¶

document_process¶

engine_admin¶

engine_analytics¶

engine_blob¶

engine_broker¶

engine_channels¶

engine_consensus¶

engine_datascience¶

engine_edges¶

engine_finance¶

engine_graph¶

engine_graphlearn¶

engine_ledger¶

engine_lifecycle¶

engine_mining¶

engine_modalities¶

engine_nodes¶

engine_placement¶

engine_query¶

engine_rbac¶

engine_rdf¶

engine_reasoning¶

engine_resharding¶

engine_streaming¶

engine_tenants¶

engine_timeseries¶

engine_txn¶

engine_viz¶

find¶

graph_agents¶

graph_analyze¶

graph_argument¶

graph_ask¶

graph_audit¶

graph_broker¶

graph_bus¶

graph_candidate_claims¶

graph_catalog¶

graph_claims¶

graph_code¶

graph_code_nav¶

graph_compliance¶

graph_config¶

graph_configure¶

graph_context¶

graph_data_prep¶

graph_document_tree¶

graph_domain_ops¶

graph_durable¶

graph_engineering¶

graph_epistemic¶

graph_etl¶

graph_evaluate¶

graph_evolution¶

graph_explain¶

graph_federated_search¶

graph_feedback¶

graph_feeds¶

graph_fork¶

graph_gis¶

graph_goals¶

graph_governance¶

graph_incident¶

graph_ingest¶

graph_jobs¶

graph_kv_checkpoint¶

graph_kvcache¶

graph_learn¶

graph_logs¶

graph_loops¶

graph_media_sidecar¶

graph_memory¶

`act`¶

`agent_library`¶

`ask`¶

`ask_data`¶

`concept_registry`¶

`document_process`¶

`engine_admin`¶

`engine_analytics`¶

`engine_blob`¶

`engine_broker`¶

`engine_channels`¶

`engine_consensus`¶

`engine_datascience`¶

`engine_edges`¶

`engine_finance`¶

`engine_graph`¶

`engine_graphlearn`¶

`engine_ledger`¶

`engine_lifecycle`¶

`engine_mining`¶

`engine_modalities`¶

`engine_nodes`¶

`engine_placement`¶

`engine_query`¶

`engine_rbac`¶

`engine_rdf`¶

`engine_reasoning`¶

`engine_resharding`¶

`engine_streaming`¶

`engine_tenants`¶

`engine_timeseries`¶

`engine_txn`¶

`engine_viz`¶

`find`¶

`graph_agents`¶

`graph_analyze`¶

`graph_argument`¶

`graph_ask`¶

`graph_audit`¶

`graph_broker`¶

`graph_bus`¶

`graph_candidate_claims`¶

`graph_catalog`¶

`graph_claims`¶

`graph_code`¶

`graph_code_nav`¶

`graph_compliance`¶

`graph_config`¶

`graph_configure`¶

`graph_context`¶

`graph_data_prep`¶

`graph_document_tree`¶

`graph_domain_ops`¶

`graph_durable`¶

`graph_engineering`¶

`graph_epistemic`¶

`graph_etl`¶

`graph_evaluate`¶

`graph_evolution`¶

`graph_explain`¶

`graph_federated_search`¶

`graph_feedback`¶

`graph_feeds`¶

`graph_fork`¶

`graph_gis`¶

`graph_goals`¶

`graph_governance`¶

`graph_incident`¶

`graph_ingest`¶

`graph_jobs`¶

`graph_kv_checkpoint`¶

`graph_kvcache`¶

`graph_learn`¶

`graph_logs`¶

`graph_loops`¶

`graph_media_sidecar`¶

`graph_memory`¶

`graph_message`¶

`graph_observe`¶

`graph_ontology`¶