agent-utilities

Turns the manual "validate a fleet package/skill, run its tests, delegate a grounded task to it, hunt for known bug-classes, and feed findings back into the KG" process into a SELF-HOSTED, delegation-ready capability the local LLM runs against ANY target — a fleet agent under agent-packages/agents/*, the agent-utilities package itself, or a universal-skill / agent-utilities skill. Composes existing primitives (graph_orchestrate execute_agent, graph_write, graph_feedback, pytest via the tier4 pattern, deterministic structural/bug-class scans) rather than re-implementing them. Use when asked to "validate <target>", "test this agent/skill end to end", "bug-hunt the fleet", "run ecosystem validation", or to set up continuous automated fleet validation via the loop engine or the scheduler.

Evolve the agent-utilities repository by implementing the latest research concepts against it. Orchestrates research-scanner → kg-ingest → comparative-analysis → SDD implementer into a unified pipeline. Queries the KG for hot topics, finds relevant papers, ingests them, runs comparative analysis, and generates SDD plans with constitution-mandated artifact requirements baked in. Can run as a background daemon (every 60 minutes) via the KG engine's evolution cycle. Triggers on "evolve agent-utilities", "run evolution pipeline", "find and implement research", "research-driven development", "auto-evolve", "evolution scan". Also includes AST-based wiring sweep for concept traceability, dead code detection, and import graph analysis. Triggers on "wiring sweep", "concept audit", "dead code analysis", "traceability check", "code health".

Runs UQL — the epistemic-graph engine's native cross-modal Unified Query Language — a single pipelined text query that composes graph traversal, vector/ANN ranking, BM25 text search, relational (DataFusion) filtering, bi-temporal AS-OF/WINDOW, OWL reasoning, federation, and epistemic belief/evidence ops over ONE snapshot with no impedance mismatch between modalities. Use when a question spans more than one modality in one breath — "find docs about X, then rank by similarity to this vector, then only the ones live as of last month", "traverse citations then diversify the top results", "what supports this claim, discounted by our confidence at the time" — or whenever you'd otherwise chain several separate Cypher/SQL/vector calls by hand.

Tamper-evident audit ledger (G23): verifies the engine's hash-chained durable-mutation audit log and reconstructs "what happened to entity X" from the KG's own :ToolCall provenance. Use for "verify the audit chain", "is our audit log tamper-evident", "has anything mutated entity X and in what order", "reverse-index the tool calls that touched this node".

Compliance posture rollup + redacted bulk export — joins the tamper-evident hash-chained audit ledger with governance node counts (Control/Policy/Risk/ ComplianceRequirement/ComplianceGate/Regulation/Assessment/Incident/Finding/... already ingested from CISO Assistant + the TRM portfolio-intelligence engine) into one auditor-facing view, and bulk-exports a redacted subgraph via the engine's own disclosure_level (Full/Skeleton/ExistenceOnly) redaction. Use for "what's our compliance posture", "is the audit chain intact", "export these controls redacted for an auditor", "how many open compliance gaps do we have".

Answers a question and returns its full epistemic justification, not just the row — calibrated confidence + provenance/evidence refs + bitemporal valid/tx time (the KnowledgeBatch "currency upgrade"), the belief's justification tree (Asserted / DerivedSupport / DerivedContradiction / BayesianUpdate), the acceptance capstone (believed? since when? on what evidence? what would flip it?), a bitemporal what-changed diff between two transaction times, and — when policy hid something — which rows were denied and why. Use when an answer alone isn't enough — "why do we believe this", "how confident are we and why", "what would invalidate this", "what changed between these two points in time", "why was this row filtered out".

Browse the cross-layer Incident Brain: correlate recent hardware/os/orchestration/ service/network :HealthAnomaly rows into deduplicated :Incident nodes, list open incidents, and pull one incident's full detail. Read-only — proposes and executes no remediation. Use for "what's broken right now", "show me open incidents", "run a correlation pass", "what's the root-cause layer for this incident".

Runs residual ops/structural analysis across the KG — inspect, enrichment coverage, process write-back (Camunda/ARIS), workload placement plan, infra sweep, security scan. Use for structural/ops analysis — "inspect this subgraph", "placement plan", "security scan". (Code→kg-code, research→kg-research, eval→kg-evaluate, Q&A→kg-explain.)

Answers a natural-language question over the Knowledge Graph by generating and executing a query (Cypher/SQL/SPARQL) for you. Use when you want KG data but would rather ask in plain English — "ask the graph…", "how many…", "list the… " without writing Cypher.

Thin verb over the engine's AMQP-style message broker — declare exchanges/queues, bind, publish, consume, and inspect stats. Use for engine-level queue/stream messaging (distinct from the agent bus) — "publish to this exchange", "consume the queue", "declare a queue".

The federated agent-to-agent bus — let this session discover and message other Claude/LLM sessions (any provider/host) and dispatch objectives to the fleet through one graph-os hub. Use for cross-session/host coordination — "who's online", "message that agent", "dispatch this to the fleet", "subscribe to a topic".

Code intelligence over the ingested code graph — cited how/usage/impact answers, cross- repo usages, call graphs, similar code, blast radius, metrics, arch reports — plus templated symbol navigation. Use to understand code via the KG instead of grepping — "how does X work", "who calls this", "impact of changing this", "find the definition".

Manages graph-os backend configuration and credentials — register MCP servers, secrets/vault sync, named graph connections, schema packs, harness fences, doctors and DB provisioning. Use for platform config — "register this MCP", "add a graph connection", "run config doctor", "vault sync".

Stores and retrieves session-scoped context blobs in the KG so work survives across turns/agents. Use to persist or recall working context — "remember this for the session", "store/get context", "list session context".

Vectorless reasoning-tree retrieval over a single document's section tree (PageIndex-style map-then-fetch). Build the per-document table-of-contents tree, view the text-free structure, fetch cited char/page ranges, or navigate the tree by relevance. Use for long single documents — "find the section about…", "give me the structure of this doc", "fetch that range", "which section covers…" — where similar != relevant and an embedder's recall ceiling hurts. Complements kg-search's vector/community retrieval, does not replace it.

Runs a unified source→(ontological transform)→sink ETL flow over the KG hub — pull any connector in and/or load a write-back SoR, graph store, or engine SQL table out, with lineage. Use for cross-system data movement — "ETL servicenow into stardog", "list ETL sources/sinks", "show ETL lineage".

Evaluates agents/harnesses and reasons over learned world models — scoring, harness gates, world-model rollouts, forecasting, causal/invariant analysis, specialization cycles. Use for eval & simulation — "score these outputs", "run the harness gate", "forecast", "world-model rollout".

The universal context plane — routes a question to its domain provider and returns ONE grounded, cited answer (code, ops, deploy, entity/tickets/process). Use to ask "why/how/status" about the system — "why is the ops queue backing up", "is my change live", "explain this entity".

Knowledge Graph concept extraction atomic skill. Parses text and structures definitions and relations for Graph-OS.

Records a human/agent correction so the system learns durably — reward adjustments, governance rules, eval cases, reads-avoided and action-outcome loops, and pinned gotchas. Use to teach or correct the KG — "record this correction", "pin a gotcha", "log the outcome of this action".

Manages the unified RSS/Atom feed registry — list, bulk add/remove feed sources, and run the world-model-gated feed sweep. Use for feed ingestion — "add these RSS feeds", "list feeds", "sync feeds now".

Warm-fork fan-out — pay warm-up once for a parent context, then fork N copy-on-write branches to run per-branch computations concurrently and collect each result. Use for cheap concurrent fan-out — "fork N branches", "run this snippet across n copies", "warm- fork fan-out".

Thin verb over the engine's geospatial (GIS) surface — routing, tiles, nearest- neighbour, and named geo-tasks. Use for geospatial ops — "route between these points", "nearest to this coordinate", "fetch a tile".

Creates and manages background/autonomous goal loops that iterate toward an objective. Use for long-running autonomous objectives — "kick off a goal", "list goals", "show iterations", "cancel this goal".

Full-hydrates the KG from an external source (or all configured sources) — a thin alias of source_sync with mode=full. Use to (re)mirror a connector's data — "hydrate leanix", "full sync all sources", "rebuild from the source".

Bulk ingests the workspace projects, ScholarX documents, and conversation logs into the Knowledge Graph, AND fans a single "full ingest" trigger across every ingestion path at once — workspace codebase + documents PLUS the native 'rss' and 'freshrss' feed connectors AND every agent-packages/agents/* connector (the fleet sweep). Use when the user wants to "ingest the workspace", "bulk ingest", "full ingest", "ingest everything", "ingest all sources", "ingest these git urls", "ingest conversations", "backup the kg", or "wipe the kg". Automatically handles finding all workspace paths natively via the repository-manager MCP, cloning parallel git URLs if requested, and firing off the ingestion pipeline across all sources/lanes. Also documents the fleet's NATIVE package-side push (every agents/* connector ingests its own data into epistemic-graph in three modalities — typed OWL nodes, documents, and raw BLOBS/attachments — via the shared native_ingest primitive), so the KG stores the data itself, not just metadata.

The graph-os intent surface — six verb-tools (ask/find/write/act/manage/why) that collapse the ~95-tool condensed graph-os surface behind a small, fixed schema for small/cheap-LLM profiles. Use when MCP_TOOL_MODE=intent is active, when a caller/model should route by natural-language INTENT rather than naming a granular tool directly, when asked "what's the intent surface", "how do ask/find/write/act/manage/why work", "when should I use condensed vs intent mode", or "reclaim/load a tool from the intent surface".

Thin verb over the engine's shared, content-addressed KV-cache — get/put opaque blocks, check membership, and read occupancy/dedup stats. Use for the shared block cache — "cache this block", "is this key cached", "kvcache stats".

The single entrypoint for long-running objectives (research/develop/skill Loops) plus observing and steering the self-evolution flywheel. Use to run or steer Loops and evolution — "submit a Loop", "drive this Loop", "show evolution state", "review a spec proposal".

Thin verb over the engine's EG-KG.memory.eg-batch-decay-caller memory surface — episodic→semantic consolidation, the spatial scene graph, RL trajectories, plus unified store/recall/link memory-CRUD. Use for agent memory ops — "consolidate memory", "store/recall a memory", "append a trajectory step", "scene transform".

Opens ephemeral (optionally durable) agent-to-agent message channels for a run — send, receive, replay history, close. Use for intra-run coordination between a session and its spawned agents — "open a channel", "send/receive on the channel". (For cross- session/host fleet messaging use kg-bus.)

Run graph analytics, data-science kernels, and KAN graph-learning on the epistemic-graph engine — centrality, (personalized) PageRank, estimators, numeric primitives, training kernels, and a learned per-feature edge-function link predictor. Use when you need graph algorithms, in-engine ML/stats, or link prediction ("rank the most central nodes", "run PageRank", "fit an estimator", "fit/predict a graph-learning model", "compute on the graph without exporting to numpy").

Store, fetch, and stream content-addressed binary objects (media, files, large payloads) in the epistemic-graph engine's blob store. Use when you need a binary object store keyed by content hash — uploading/downloading media or large attachments, deduplicating blobs, or attaching binary payloads to graph nodes ("store this file", "get blob by hash", "stream this media").

Create and use dynamic pub/sub communication channels AND the native message-broker (exchanges/queues/streams) in the epistemic-graph engine — publish, subscribe, route messages between agents, and declare/bind/consume broker exchanges and queues at the engine layer. Use when you need low-level pub/sub or agent messaging fabric ("open a channel", "publish/subscribe", "route a message between agents at the engine", "declare a queue", "publish to an exchange").

Run quantitative-finance operations in the epistemic-graph engine — portfolio optimization, risk, regime detection, trading signals, HFT primitives, and derivatives pricing. Use when you need in-engine quant compute ("optimize a portfolio", "compute risk/VaR", "detect market regime", "price a derivative", "generate trading signals").

Read and manage the epistemic-graph engine's append-only audit ledger — get/apply/clear ledger entries for tamper-evident change history. Use when you need an audit trail or provenance log ("show the audit ledger", "what changed and when", "append-only history", "apply a ledger record").

Run data-mining over the epistemic-graph engine — association-rule mining (Apriori/FP-Growth/Eclat), clustering (DBSCAN/hierarchical/GMM/k-medoids), and anomaly detection (z-score/isolation-forest/LOF/one-class-SVM), compute-near-data, plus the deep-learning family (LSTM forecast, MLP classify, autoencoder anomaly, gradient-boosting, neural embedding) delegated to data-science-mcp. Use for "find frequent itemsets", "mine association rules", "cluster these nodes/ vectors", "detect anomalies/outliers in this series or graph", "forecast this series with a neural model", "deep-classify these rows".

Low-level core graph CRUD on the epistemic-graph engine — nodes, edges, graph operations, and lifecycle (prune/decay/evict, batch update, context views, (de)serialize). Use when you need byte-level graph mutation/read below the curated graph_* verbs ("add/get/batch nodes", "temporal edge invalidate", "AST parse/index", "prune or evict the graph", "raw graph CRUD").

Subscribe to change-data-capture and continuous queries on the epistemic-graph engine — streams, watches, and triggers that fire as the graph changes. Use when you need push/reactive data ("watch for changes", "CDC feed", "continuous query", "fire a trigger when X is written", "tail the graph").

Append and query native time-series data in the epistemic-graph engine's TSDB — append points, range/window scans, as-of lookups, and gap-filling. Use when you need time-series storage or analytics next to the graph ("record metric points", "query a time range", "as-of value at time T", "gap-fill a series").