Knuckles-Team

Scaffold a complete agent-package project with all config files, Docker infrastructure, MCP server, A2A agent, and API client stubs. Use when creating a brand-new agent-package from scratch, bootstrapping a new MCP/agent/api-client project, or when the user says "create a new agent package". This delegates domain-specific implementation to existing skills (api-client-builder, mcp- builder, agent-builder, skill-graph-builder). Do NOT use for modifying an existing agent package — use the individual skills directly.

Browser automation CLI for AI agents using the agent-browser tool. Use when the user needs to interact with websites including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.

Guide for building scalable Pydantic AI agents. Use this skill when the user wants to create a new agent package or modify an existing agent's architecture, to ensure it follows the standardized agent patterns using `agent-utilities`.

The `agent-spawner` skill provides the ability to dynamically create a new Pydantic AI agent configured with an external MCP server toolkit. This is extremely useful when an agent wants to spin up a sub-agent with specialized tools defined in an `mcp_config.json`, and interact with that agent immediately without modifying the parent agent's state or toolset.

Consolidated skill for managing, dispatching, and orchestrating other agents via the agent-manager CLI, as well as workflows for A2A communication, orchestration, and parallel subagent dispatch.

Use when executing implementation plans with independent tasks in the current session

Generate or update a robust AGENTS.md file (the "README for AI coding agents") for a project. This skill ensures your repository is optimized for AI tools (like Copilot, Cursor, and Windsurf) by providing structured context, commands, architecture diagrams, and coding standards. It automatically detects project metadata from pyproject.toml and generates a project tree view.

Guide for creating API clients using the established patterns in the agent- packages repository (like servicenow-api and gitlab-api). Use this when tasked with building a new API integration or creating client classes for REST or GraphQL APIs from OpenAPI specs or documentation.

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

Comprehensive reference documentation for Quant Career career-planning material.

Comprehensive reference documentation for Langchain Docs.

Comprehensive reference documentation for Couchbase Docs.

Comprehensive reference documentation for Mariadb Docs.

Comprehensive reference documentation for Mssql Docs.

Comprehensive reference documentation for Qdrant Docs.

Home Assistant REST API documentation

Postiz Public API documentation

Build scoped ServiceNow applications as metadata-as-code — the scope/`x_` prefix/now.config.json anatomy, how Fluent artifacts assemble into a whole app (table + business rule + ACL + menu + catalog), and how that reconciles with App Engine Studio / Application Studio. Use when the agent must design a scoped app's structure, map an App Engine Studio artifact to its Fluent API and sample, assemble a multi-artifact app, or package/publish a scoped app. Do NOT use for the now-sdk build/deploy/ATF lifecycle mechanics (use servicenow-sdk-lifecycle), for authoring Flow Designer flows/subflows (use servicenow-workflow-studio), for the raw bundled Fluent samples (use servicenow-sdk-docs), or for ad-hoc record CRUD against a live instance (use servicenow-table-api).

ITSM change-management operations on the ServiceNow Change API via the servicenow-api MCP server — the full change-request lifecycle: query changes, tasks, schedules, CIs, models and standard-change templates; create/update changes and change-tasks; run risk calculation and conflict checks; approve; and delete. Use when the agent must open a normal/standard change, drive it through CAB (conflict check → approve), or inspect change schedules and impacted services. Do NOT use for incidents (servicenow-incident-management), CMDB CI data (servicenow-cmdb), or generic table CRUD (servicenow-table-api); prefer those.

ServiceNow release-engineering surface — CI/CD app install/scan/rollback, DevOps change-control & artifact registration, update-set create/preview/commit/back-out, source-control apply/import, plugin activate/rollback, and ATF test-suite runs via the servicenow-api MCP server. Use when the agent must deploy or roll back a scoped app, publish/install from an app repo, run a code/instance scan, move changes with update sets, pull remote source-control changes, activate a plugin, or execute an Automated Test Framework suite. This is where the dev-tooling skill servicenow-sdk-lifecycle defers for remote deploy/publish/test. Do NOT use for generic record CRUD (servicenow-table-api), data ingest/attachments/batch (servicenow-import-attachment-batch), or flow rendering & email (servicenow-platform-utilities).

ITOM CMDB operations on the ServiceNow CMDB + CI Lifecycle Management APIs via the servicenow-api MCP server — query configuration items by class, read a CI with its attributes and relations, create/update/patch CI instances, manage CI relationships, and drive the CI lifecycle (status, actions, leases, operators). Use when the agent must inspect or maintain the CMDB graph or govern a CI's lifecycle state. Do NOT use for incidents (servicenow-incident-management), change requests (servicenow-change-management), or generic non-CMDB table CRUD (servicenow-table-api); prefer those.

ServiceNow HR Service Delivery and Project Portfolio Management surface — fetch an employee HR profile and insert PPM cost plans and project tasks via the servicenow-api MCP server. Use when the agent must read a worker's HR profile or seed project financials (cost plans) and project task breakdowns through the dedicated HR/PPM endpoints. Do NOT use for generic table CRUD (servicenow-table-api), release/CI-CD (servicenow-cicd-devops), data ingest/attachments (servicenow-import-attachment-batch), or email/flows/metricbase (servicenow-platform-utilities).

ServiceNow data-ingest, file, and batched-REST surface — push rows through Import Sets (single & bulk), upload/get/delete record attachments, and bundle many REST calls into one batch request via the servicenow-api MCP server. Use when the agent must load external data through a transform-mapped import set, attach or fetch a file on a record, or minimize round-trips by batching multiple operations. Do NOT use for direct table CRUD without a transform map (servicenow-table-api), release/CI-CD or update-set promotion (servicenow-cicd-devops), or HR/PPM inserts (servicenow-hr-ppm).

ITSM incident operations on the ServiceNow Incident API via the servicenow-api MCP server — list, read, and create incident records with the domain-typed tool (not raw table calls). Use when the agent must triage active incidents, fetch one incident by sys_id, or open a new incident with fields like short_description, urgency, impact, and caller_id. Do NOT use for generic record CRUD on arbitrary tables (use servicenow-table-api), change requests (servicenow-change-management), CMDB CIs (servicenow-cmdb), or knowledge articles (servicenow-knowledge); prefer those.

ServiceNow Integrated Risk Management / GRC — the ServiceNow equivalent of RSA Archer (GRC) and OneTrust (privacy). Covers Risk Management, Policy & Compliance, Audit Management, Vendor / Third-Party Risk (TPRM), and Privacy Management. Use when the agent must list open risks, roll up compliance by control state, list open audit findings, work the vendor-risk assessment queue, or handle privacy data-subject / processing-activity records. IRM/GRC has no dedicated REST family, so it is driven table-first via servicenow_table_api / servicenow_aggregate / servicenow_custom_api against scoped sn_risk_* / sn_compliance_* / sn_audit_* / sn_vdr_* tables that vary by instance and plugin version. Do NOT use for generic table CRUD (use servicenow-table-api), security incidents/vulnerabilities (servicenow-secops), or the technology portfolio (servicenow-trm); prefer those.

Snapshot a host's Docker/Podman/Swarm inventory into the epistemic-graph knowledge graph as typed OWL nodes via the container-manager-mcp MCP server — containers, images, volumes, networks, swarm services and nodes, with their :usesImage / :runsOn / :builtFrom links. Use when the agent must record live container state into the KG for cross-source reasoning, drift detection, or provenance. Do NOT use for operating containers (use container-manager-lifecycle) or managing swarm services (use container-manager-swarm).

End-user setup guide for the container-manager-mcp MCP server — choosing CONTAINER_MANAGER_TYPE (docker/podman/kubernetes/multi), wiring .env / mcp_config toggles, connecting remote Docker/Podman hosts via the tunnel-manager inventory versus remote Kubernetes clusters via kubeconfig contexts, and a first-run verification checklist. Use when the agent is onboarding a new environment or troubleshooting "which skill do I even use" before touching any other container-manager-mcp skill. Do NOT use for actually operating containers/clusters once configured — use the operational skills.

Full operational Kubernetes surface via the container-manager-mcp MCP server — workloads (pods/rollouts/StatefulSets/DaemonSets/ReplicaSets/Jobs/CronJobs), config (ConfigMaps/Secrets/Namespaces/CRDs/patch), networking (Ingress/native Services/NetworkPolicy/DNS), storage (PV/PVC/StorageClass/snapshots/CSI), RBAC (roles/bindings/tokens/access reviews/pod security), cluster (nodes/contexts/ CSRs/admission plugins), governance (quotas/limits/PDB/HPA), and observability (metrics/watch/debug). Use when the agent must drive real k8s migrations, sustain, or ops work on a cluster. Do NOT use for Docker/Podman single-host lifecycle (container-manager-lifecycle), Docker Swarm (container-manager-swarm), or rootless Podman pods (container-manager-podman-operations).

Operate several container backends and contexts at once — Kubernetes, Docker, Podman, and Swarm — via the container-manager-mcp MCP server's cm_multi_context tool, with per-call backend/context selection and parallel fan-out across a configured pool of contexts. Use when the agent must compare, migrate between, or simultaneously act on multiple clusters/engines/hosts. Do NOT use for single-backend operations, which are cheaper via the themed skills (container-manager-lifecycle / -swarm / -kubernetes-operations / -podman-operations).

Rootless Podman pod/kube operations via the container-manager-mcp MCP server — pods (create/list/stats/top/inspect/logs/stop/rm), Kubernetes YAML interop (generate/play kube), checkpoint/restore, pod-scoped networks and volumes, health checks, and system prune. Use when the agent must drive Podman pod-level workloads beyond single containers. Do NOT use for single-container Docker/Podman lifecycle (container-manager-lifecycle) or for a real Kubernetes cluster (container-manager-kubernetes-operations).

Kubernetes Mesh Provisioner atomic skill. Stands up an RKE2 cluster (server + agents) with Cilium CNI and the NVIDIA GPU device plugin, the Kubernetes parallel of swarm-mesh-provisioner. Idempotent — re-runnable.

Podman Mesh Provisioner atomic skill. Provisions a Podman container control plane — rootful OR rootless — enabling the Podman API socket, wiring podman-compose, and registering remote hosts as Podman system connections over SSH, using container-manager-mcp. The Podman peer of swarm-mesh-provisioner and kubernetes-mesh-provisioner. Triggers on "provision podman", "rootless podman", "podman-compose cluster", "set up podman hosts".

Swarm Mesh Provisioner atomic skill. Initializes Docker Swarm Mode, manages manager/worker nodes join processes, and provisions global Swarm Overlay networks using container-manager-mcp.

Analyze meeting notes to find action items and create Jira tasks for assigned work. When an agent needs to: (1) Create Jira tasks or tickets from meeting notes, (2) Extract or find action items from notes or Confluence pages, (3) Parse meeting notes for assigned tasks, or (4) Analyze notes and generate tasks for team members. Identifies assignees, looks up account IDs, and creates tasks with proper context.

Create a Jira issue after discovering, from the live instance, exactly which fields the chosen project + issue type support — including which are required and which are custom fields (customfield_xxxxx) — then populate and submit it. Use when the agent must open a Jira issue/bug/story/task and needs to know the correct, possibly custom, field schema instead of guessing. Do NOT use for listing the user's own work (use atlassian-my-priority-queue), bulk spec breakdowns (use atlassian-spec-to-backlog), or Plane work items (use plane-create-work-item-guided).

Generate project status reports from Jira issues and publish to Confluence. When an agent needs to: (1) Create a status report for a project, (2) Summarize project progress or updates, (3) Generate weekly/daily reports from Jira, (4) Publish status summaries to Confluence, or (5) Analyze project blockers and completion. Queries Jira issues, categorizes by status/priority, and creates formatted reports for delivery managers and executives.

Manage Jira saved filters (saved JQL searches) end to end — create, get, search, update, delete, run/use them, star them as favourites, manage their columns, change owner, and administer their share/edit permissions (add, get, delete) and the instance default share scope. Use when the agent must create or curate reusable JQL filters, share a filter with a group/project/user, audit who a filter is shared with, or run a saved filter's results. Do NOT use for one-off ad-hoc JQL queries (just run the search directly), listing the user's own issues (use atlassian-my-priority-queue), or Plane — Plane's public API exposes no saved-views/filters equivalent.

Surface the Jira issues assigned to the current user, rank them by a combined priority + staleness score (highest priority at the top, items untouched for more than 7 days flagged and boosted), and suggest updates to those issues from the current session's context. Use when the agent must answer "what should I work on", "what's assigned to me", "what's gone stale", or wants to push conversation findings back onto the user's open tickets. Do NOT use for creating new issues (use atlassian-create-issue-guided), full project status reports (use atlassian-generate-status-report), or Plane work items (use plane-my-priority-queue).

Search across company knowledge bases (Confluence, Jira, internal docs) to find and explain internal concepts, processes, and technical details. When an agent needs to: (1) Find or search for information about systems, terminology, processes, deployment, authentication, infrastructure, architecture, or technical concepts, (2) Search internal documentation, knowledge base, company docs, or our docs, (3) Explain what something is, how it works, or look up information, or (4) Synthesize information from multiple sources. Searches in parallel and provides cited answers.

Automatically convert Confluence specification documents into structured Jira backlogs with Epics and implementation tickets. When an agent needs to: (1) Create Jira tickets from a Confluence page, (2) Generate a backlog from a specification, (3) Break down a spec into implementation tasks, or (4) Convert requirements into Jira issues. Handles reading Confluence pages, analyzing specifications, creating Epics with proper structure, and generating detailed implementation tickets linked to the Epic.

Intelligently triage bug reports and error messages by searching for duplicates in Jira and offering to create new issues or add comments to existing ones. When an agent needs to: (1) Triage a bug report or error message, (2) Check if an issue is a duplicate, (3) Find similar past issues, (4) Create a new bug ticket with proper context, or (5) Add information to an existing ticket. Searches Jira for similar issues, identifies duplicates, checks fix history, and helps create well-structured bug reports.

The agent-webui document / entity extraction surface — submit text or a URL for GPU-slot fact extraction, watch jobs stream facts live, pause/resume, and export results. Use when you want to extract entities/facts from a document in the UI, monitor an extraction job, or download extracted facts as JSONL.

The agent-webui software-engineering surface — the developer-workspace runtime (create a session, act, stream events, inspect KG provenance), SWE-bench runs, and the code call-graph views. Use when you want to drive a coding session in the UI, run SWE-bench, or explore the code graph / symbol navigation.

The agent-webui admin / fleet console — tenants, shards, RBAC, backup/PITR and the swarm supervisory plane (health, topology, pause/kill, approvals). Use when you want to inspect or operate the fleet from the UI, manage engine tenants or shards, review the mutation/risk approval queue, or check service health.

The agent-webui dashboards & analytics surface — composable live panels (PromQL metrics, logs, traces) plus usage/cost observability. Use when you want to build a metrics dashboard in the UI, chart PromQL, view traces/logs panels, or analyze token usage and cost by model/project/agent.

The agent-webui graph-visualization surface — GraphView, TemporalGraphView, CodeGraphView and the single-vertex explorer. Use when you want to visualize the Knowledge Graph, render a vertex neighborhood, browse temporal/as-of graph state, or draw the code call-graph in the web UI.

The agent-webui ontology operator surface — Object Explorer and Object View for browsing, filtering, editing and acting on ontology objects, types, interfaces, functions and actions. Use when you want to edit ontology object types/links in the UI, run a governed bulk action over an object set, or inspect an object's properties, derived values, links and edit history.

Dependency & security-vulnerability review on GitLab via the gitlab-api MCP server — the GitLab counterpart to GitHub Dependabot. Read a project's Dependency List, review a project's or group's security vulnerabilities/findings, and fetch a single vulnerability by ID. Use when the agent must audit a project's dependencies for known vulnerabilities, review the security posture of a project or group, or inspect one vulnerability. Do NOT use for package publishing or registry reads (gitlab-packages), pipelines/CI (gitlab-pipelines), or issues (gitlab-issues); prefer those.

Issue review and tracking on GitLab via the gitlab-api MCP server — review a project's issues, review issues across a whole group/organization, and read, create, update, or close an issue with the domain-typed tool. Use when the agent must triage a project's issues, see every issue affecting a group, open a new issue, update labels/assignee/state, or delete one. Do NOT use for merge requests (gitlab-merge-request-review / gitlab-merge-request-create), pipelines (gitlab-pipelines), or repo/branch reads (gitlab-repositories); prefer those.

Open a new GitLab merge request against a project via the gitlab-api MCP server — from a source branch into a target branch, with title, description, assignees, reviewers, labels, and remove-source-branch/squash options. Use when the agent must create/open an MR for a project. Do NOT use to review, approve, or merge an existing MR (gitlab-merge-request-review), to triage issues (gitlab-issues), or to review pipelines (gitlab-pipelines).

Review and merge GitLab merge requests via the gitlab-api MCP server — by default the MRs assigned to you or where you are a reviewer, optionally scoped to a project, group, or the whole instance. Read an MR, gate it on a green pipeline (pipeline → jobs → job log), then approve, accept/merge, or set merge-when-pipeline-succeeds (auto-merge) — writes are confirmed with the user and CI-gated. Use when the agent must review open MRs, verify CI, approve, merge, or set auto-merge. Do NOT use to open an MR (gitlab-merge-request-create), review issues (gitlab-issues), or review pipelines broadly (gitlab-pipelines).

CI/CD pipeline review on GitLab via the gitlab-api MCP server — review pipeline results for a project, a group, or the whole instance, drill into the CI jobs of a pipeline, and read a job's log; also trigger a pipeline on a ref. Use when the agent must review CI results across a project/group/organization, check whether a branch is green, inspect a pipeline's jobs, or read job logs. Do NOT use for merge-request review/merge (gitlab-merge-request-review), issues (gitlab-issues), or repo/branch reads (gitlab-repositories); prefer those.

Inspect and edit the EMBEDDED SearXNG instance's settings.yml (the private, loopback-only, zero-config search fallback the searxng-mcp server can own end to end when no external SEARXNG_URL is configured). Use when the agent or operator wants to change what the embedded instance does — enable/ disable formats, flip privacy knobs (image_proxy, enable_metrics), route outgoing requests through a proxy, or diagnose why embedded mode isn't activating. Do NOT use this for an externally-configured instance (SEARXNG_URL set) — that instance's settings.yml lives on its own host and isn't managed by this server; use `searxng-web-search` for plain queries.

Privacy-respecting web metasearch via the searxng-mcp MCP server. Use when the agent needs current, open-web results for a query and must NOT leak the query to a single tracking engine — SearXNG aggregates many engines (Google, Bing, DuckDuckGo, Wikipedia, …) behind one JSON tool. Use for general lookups, fact-finding, and pulling candidate source URLs to read next. Do NOT use for academic papers (use scholarx), for reading one already-known URL's full content (use web-fetch / web-crawler), or for keyless social/forum research (use pulselink-mcp).

Persist SearXNG search results into the epistemic-graph knowledge graph via the searxng-mcp MCP server. Use when the agent must turn a web search into durable, semantically-searchable KG memory — each result becomes a :Document (plus :SearchQuery and :SearchEngine typed nodes with :resultOf / :fromEngine links) so later reasoning can recall and cite it. Do NOT use for one-off reads you don't need to remember (use searxng-web-search) or to ingest a specific page's full text (use web-crawler).

Time-sensitive news and topic monitoring via the searxng-mcp MCP server. Use when the agent must gather what multiple news/social engines are currently reporting on a topic — breaking events, product/security announcements, or ongoing coverage — by scoping `web_search` to the `news`/`social_media` categories and paging for breadth. Do NOT use for evergreen reference facts (use searxng-web-search), academic sources (scholarx), or deep single-source reads (web-fetch).

Select and connect the right vector-store backend for the vector-mcp MCP server — chromadb, postgres/pgvector, qdrant, couchbase, or mongodb — and supply the correct db_type/connection parameters that every collection and search call needs. Use when the agent must decide which engine to target, wire up host/port/path/credentials, or move a workload between embedded and networked backends. Do NOT use for collection lifecycle (use vector-collection-management) or for running queries (use vector-hybrid-search).

Create, populate, list, and delete vector-store collections through the vector-mcp MCP server's vector_collection_management tool. Use when the agent must stand up a new RAG collection, ingest documents (from a directory, file paths/URLs, or raw text) into an existing collection, enumerate collections, or drop one — across any supported backend (chromadb, postgres/pgvector, qdrant, couchbase, mongodb). Do NOT use for running queries against a collection (use vector-hybrid-search) or for choosing/tuning a backend connection (vector-backend-operations).

Retrieve knowledge from a vector-store collection via the vector-mcp MCP server's vector_search tool — semantic (ANN) search, lexical BM25 search, or a hybrid of the two fused with Reciprocal Rank Fusion. Use when the agent must answer a question from an indexed corpus, pull top-k relevant chunks for RAG context, or tune the semantic-vs-lexical balance of retrieval. Do NOT use for creating collections or ingesting documents (use vector-collection-management) or for backend connection setup (vector-backend-operations).

Email-campaign operations on Listmonk via the listmonk-api MCP server — list, read, preview, create, schedule/run, and stat campaigns with the domain-typed tool (not raw HTTP). Use when the agent must build a newsletter campaign against explicit list_ids, transition a campaign's status (draft → scheduled → running → paused/cancelled), preview rendered content, or read running stats. Do NOT use for managing subscribers or lists (use listmonk-subscriber-lists) or for one-off per-recipient mail (use listmonk-transactional-messaging).

Audience management on Listmonk via the listmonk-api MCP server — manage subscription lists and the subscribers on them with the domain-typed tools (not raw HTTP). Use when the agent must create/read/edit a mailing list, read or create subscribers, read the subscribers of a list, or bulk-import subscribers from a file. Do NOT use for building/sending campaigns (use listmonk-campaign-management) or one-off transactional mail (use listmonk-transactional-messaging).

Transactional email + template operations on Listmonk via the listmonk-api MCP server — send a one-off, per-recipient message rendered from a template, and manage the email templates it uses, with the domain-typed tools (not raw HTTP). Use when the agent must send a receipt/notification/password-reset style mail to a single subscriber, or list/read/preview/set-default/delete templates. Do NOT use for bulk newsletters (use listmonk-campaign-management) or for managing the audience (use listmonk-subscriber-lists).

Natively ingest Genius Agent web-search hits and crawled pages into the epistemic-graph knowledge graph — search results become :SearchQuery / :SearchResult / :SearchProvider / :WebPage typed nodes plus shared :Document text for semantic search. Use when the agent must persist what it searched or crawled into the KG so it becomes durable, queryable agent memory. Do NOT use just to view results (use genius-web-search) or to read a page body without saving it (use genius-web-crawl).

Crawl web pages, whole sites, or sitemaps to clean markdown via Genius Agent — single page, chunked-by-heading, recursive link-following, or sitemap sequential/parallel. Use when the agent must read the full body of a page, harvest online documentation, or bulk-extract a site into markdown for analysis or KG ingestion. Do NOT use to get a ranked list of links for a query (use genius-web-search) or for a single quick JSON API fetch.

Multi-provider web search via Genius Agent — get ranked titles, snippets, and URLs for a query from DuckDuckGo, Google, Bing, or Searxng. Use when the agent needs current, real-time information from the open web, references/links to authoritative pages, or a candidate set of URLs to then crawl. Do NOT use to read the full body of a page (use genius-web-crawl) or to persist results into the knowledge graph (use genius-search-ingest).