The Mcp-Omega-Brain server is a local, governance-first MCP control plane for AI agents, enforcing policy, auditing operations, and managing context with no external dependencies or cloud services.
🧠 Cross-Session Episodic Memory
omega_preload_context — Load RAG + vault history + sealed handoff for full continuity at task start
omega_rag_query / omega_ingest — Semantic similarity search and storage with evidence tier metadata (A/B/C/D)
omega_vault_search — Exact keyword search via SQLite FTS5
omega_log_session — Persist complete session records (decisions, files modified)
omega_write_handoff — Create SHA-256 sealed cross-session handoff documents that auto-load on restart
🔐 Cortex Alignment & Governance
omega_cortex_check — Read-only gate: checks if a proposed tool call aligns with the declared baseline (approved/blocked)
omega_cortex_steer — Auto-corrects drifting arguments: hard-blocks below 0.45 similarity, steers between 0.45–0.65, passes above 0.65
omega_execute — Cortex-governed execution wrapper: checks alignment, steers if needed, executes, and auto-logs to the audit ledger
📜 Cryptographic Audit Ledger (S.E.A.L.)
omega_seal_run — Append tamper-proof SHA-3-256 hash-chained entries to the immutable audit ledger
omega_brain_report — Generate human-readable audit reports (SEAL chain, Cortex verdicts, vault stats)
omega_brain_status — Quick health summary of all subsystems
🏗️ VERITAS 10-Gate Build Pipeline
veritas_run_pipeline — Full deterministic evaluation returning a verdict: PASS / MODEL_BOUND / INCONCLUSIVE / VIOLATION
Individual gates: Intake (parse/canonicalize), Type (type correctness), Dependency (SBOM/CVE/license), Evidence (sufficiency via MIS_GREEDY), Math (interval arithmetic), Cost (resource budgets), Incentive (evidence monoculture bias), Security (SAST/secrets/injection/TLS), Adversary (stress-test via attack transforms), Seal (final cryptographic seal)
🔬 VERITAS Utility & State Machine Tools
veritas_nafe_scan — Detect AI narrative failure signatures (Narrative Rescue, Moral Override, Authority Drift, Intent Inference)
veritas_claeg_resolve / veritas_claeg_transition — Map verdicts to CLAEG states (STABLE_CONTINUATION, ISOLATED_CONTAINMENT, TERMINAL_SHUTDOWN) and validate permitted transitions
veritas_compute_quality / veritas_mis_greedy — Evidence quality scoring and maximum independent set computation
All operations run entirely on-device with no API keys or network egress, ensuring full data sovereignty.
Integrates with CrewAI as an MCP host, allowing CrewAI agents to utilize Omega Brain's governance, memory, and audit tools.
Integrates with VS Code Copilot as an MCP client, allowing AI agents to use Omega Brain's governance, memory, and audit tools.
Integrates with LangChain as an MCP host, enabling LangChain-based agents to access Omega Brain's governance, memory, and audit resources.
Omega Brain provides task-scoped memory retrieval, explicit claim evaluation and local audit records for MCP clients.
The standalone 2.3 release replaces unsafe argument steering and uncalibrated approval scores with advisory alignment. SSWP can enforce Brain's operator-policy receipts at its witness entry point. Retrieval uses indexed lexical candidates with stable features; it does not claim dense semantic recall.
Install with python -m pip install ., then run omega-brain-mcp or python omega_brain_mcp_standalone.py. Add that command to your MCP client's persistent user configuration. Data defaults to ~/.omega-brain; use absolute paths for a portable desktop setup.
Call omega_preload_context with task and task_id, then use the same ID on omega_rag_query and omega_ingest. omega_integrity_status, omega_brain_report and omega_ecosystem_status expose current health and historical verification limits. omega_write_handoff requires conversation_id equal to the task ID.
The supplied Python client performs the MCP initialization handshake, bounds requests, drains diagnostics and raises server errors. omega_call("omega_rag_query", query="deployment decision", task_id="example-task") performs a scoped lookup.
The companion Stenographer preserves conversations; SSWP runs software checks. Their shared state directory and task IDs must agree.
See current operating contract for migration, permissions, evidence semantics and recovery. Historical manuals and examples describe older contracts; this document and the current MCP schemas take precedence. Legacy network mode is outside the standalone deployment's tested guarantees.
Run python -m unittest discover -s tests -p "test_contracts.py" and python -m pytest tests/test_build_gates.py. The integration suite lives in integration-tests/ and uses OMEGA_SUITE_ROOT pointing to sibling omega-brain, omega-stenographer, sswp checkouts and a shared .venv.
Generates a human-readable audit report showing SEAL chain entries, Cortex verdicts, and vault statistics. Use this to inspect the trust and governance layer; use omega_brain_status for a quick health summary instead. Returns formatted text report with sections: seal_tail, cortex_verdicts, vault_stats, session_health.
Inputs: lines.
Returns a quick health summary of all Omega Brain subsystems as structured JSON. Use this for a fast status check; use omega_brain_report for a detailed audit report instead. Returns JSON with fields: vault_sessions (int), vault_entries (int), rag_fragments (int), seal_entries (int), session_id (string), uptime_seconds (float), call_count (int).
Inputs: no named parameters.
Read-only alignment gate that measures semantic similarity between a proposed action and the task baseline. Use this to check alignment before high-impact operations without modifying any arguments; use omega_cortex_steer instead if you want automatic argument correction. Returns JSON with fields: approved (boolean), similarity (float 0-1), verdict (APPROVED | BLOCKED).
Inputs: tool (required), args (required), baseline_prompt (required).
Alignment gate with automatic argument correction for drifting tool calls. Use this instead of omega_cortex_check when you want arguments auto-corrected toward the baseline; blocks hard if similarity < 0.45, steers if 0.45-0.65, passes unchanged if > 0.65. Returns JSON with fields: similarity (float), steered_args (object), corrections (array), verdict (PASSED | STEERED | BLOCKED).
Inputs: tool (required), args (required), baseline_prompt (required).
Cortex-governed execution wrapper that checks alignment, steers if needed, executes, and auto-logs to the SEAL chain. Use this as the default way to invoke any Omega Brain tool with full governance; only wraps Omega Brain tools — external tools are returned with steered_args for manual invocation. Returns JSON with fields: result (object), cortex_verdict (string), seal_hash (hex string).
Inputs: tool (required), args (required), baseline (required).
Stores a new knowledge fragment in the provenance RAG store with source and evidence tier metadata. Use this to persist decisions, patterns, or findings for future retrieval via omega_rag_query. Returns JSON with fields: fragment_id, stored (boolean), timestamp.
Inputs: content (required), source, tier.
Writes a complete session record to the vault for cross-session persistence. Use this at the end of a work session to record what was done; data is retrievable via omega_vault_search. Returns JSON with fields: session_id, stored (boolean), entry_count (integer).
Inputs: task (required), session_id, decisions, files_modified.
Loads episodic context for a new task by querying the RAG store, vault history, and any sealed handoff. Call this once at the start of every new task before doing any work. Returns JSON with fields: rag_matches, vault_history, handoff, continuity_type (CONTINUATION | CONTEXT_SWITCH | FRESH_START).
Inputs: task (required).
Searches the provenance RAG store using semantic similarity and returns ranked text fragments. Use this for meaning-based search; use omega_vault_search instead for exact keyword matching. Returns JSON array of {fragment, similarity_score, quality_score, source, tier}.
Inputs: query (required), top_k.
Appends a tamper-proof entry to the SEAL (Secure Evidence Audit Ledger) SHA-256 hash chain. Use this to create an immutable audit record of significant events, decisions, or state changes. Returns JSON with fields: seal_hash (hex string), chain_position (integer), timestamp (ISO 8601).
Inputs: context (required), response (required).
Searches the vault database using exact keyword matching via SQLite FTS5. Use this for precise keyword lookups; use omega_rag_query instead for semantic/meaning-based search. Returns JSON array of matching vault entries with timestamps and session context.
Inputs: query (required).
Creates a SHA-256 sealed handoff document that auto-loads on the next server restart via omega://session/preload. Use this at the end of a session to ensure seamless context continuity for the next session. Returns JSON with fields: handoff_hash (hex string), file_path (string).
Inputs: task (required), summary (required), decisions, files_modified, +2 more.
Gate 9/10: Stress-tests the claim against attack transforms (bound inflation, evidence removal, parameter/evidence perturbation). Use this as the final robustness check; fragility > 25% triggers MODEL_BOUND (ADVERSARY_FRAGILE). Returns JSON with verdict (PASS | MODEL_BOUND), fragility (float), attacks_tested (int), attacks_degraded (int).
Inputs: claim (required).
Maps a VERITAS verdict to a CLAEG terminal state: PASS→STABLE_CONTINUATION, MODEL_BOUND/INCONCLUSIVE→ISOLATED_CONTAINMENT, VIOLATION→TERMINAL_SHUTDOWN. Use this after a pipeline run to determine the system's required operational state. Returns JSON with fields: verdict (string), terminal_state (string), invariant (string).
Inputs: verdict (required).
Validates whether a CLAEG state transition is permitted under closed-world rules (absence of explicit permission = prohibition). Use this before changing system operational state; TERMINAL_SHUTDOWN is absorbing (no outbound transitions). Returns JSON with fields: allowed (boolean), reason (string).
Inputs: current_state (required), target_state (required).
Computes the VERITAS Quality(e) score for a single evidence item using: clamp01(0.50provenance + 0.30uncertainty + 0.20*method). Use this to evaluate individual evidence quality before submitting to the evidence gate. Returns JSON with fields: quality (float 0.0-1.0).
Inputs: evidence_item (required), policy_env.
Gate 6/10: Computes resource utilization as max(cost_i / bound_i) and checks against redline thresholds. Use this to verify cost budgets are within limits; skipped automatically if no cost vector is declared. Returns JSON with verdict (PASS | MODEL_BOUND | INCONCLUSIVE), utilization (float), and reason_code: COST_OK, COST_REDLINING, COST_NOT_APPLICABLE, or UNDECLARED_COST_BOUND.
Inputs: claim (required).
Gate 3/10: Analyzes supply-chain security via SBOM scan, CVE check, integrity verification, license compatibility, and dependency depth. Use this to assess third-party dependency risk before deploying or releasing. Returns JSON with verdict (PASS | MODEL_BOUND | VIOLATION) and per-dependency findings array.
Inputs: claim (required).
Gate 4/10: Evaluates evidence sufficiency for critical variables by computing independence (MIS_GREEDY), agreement, and quality scores. Use this to verify that evidence meets K_min, A_min, Q_min thresholds; use veritas_compute_quality or veritas_mis_greedy for individual calculations. Returns JSON with verdict (PASS | INCONCLUSIVE) and reason_code: EVIDENCE_OK, INSUFFICIENT_INDEPENDENCE, LOW_AGREEMENT, or LOW_QUALITY.
Inputs: claim (required), regime.
Gate 7/10: Detects evidence monoculture by measuring source dominance (max_count_from_single_source / independent_set_size). Use this to guard against single-source bias in evidence; dominance > 0.50 triggers MODEL_BOUND. Returns JSON with verdict (PASS | MODEL_BOUND), dominance (float), and reason_code: INCENTIVE_OK or DOMINANCE_DETECTED.
Inputs: claim (required).
Gate 1/10: Parses, canonicalizes, and validates a BuildClaim's structure and computes SHA-256 IDs. Use this first to validate claim structure before running any downstream gates. Returns JSON with fields: verdict (PASS | VIOLATION), claim_id (hex), primitive_count (int), evidence_count (int).
Inputs: claim (required).
Gate 5/10: Translates boundary constraints into interval arithmetic or SMT formulas and checks satisfiability with evidence values. Use this after evidence gate to verify that measured values satisfy all declared constraints. Returns JSON with verdict (PASS | VIOLATION | INCONCLUSIVE) and reason_code: MATH_OK, UNSAT_CONSTRAINT, or DECIDABILITY_TIMEOUT.
Inputs: claim (required).
Runs the MIS_GREEDY algorithm to find the maximum independent set of evidence items with no shared source, chain, dependency, or same-protocol-within-24h. Use this to check evidence independence before submitting to the evidence gate; use veritas_compute_quality for individual quality scores. Returns JSON with fields: independent_set (array), independent_count (int), total_items (int), agreement (float 0.0-1.0).
Inputs: evidence_items (required).
Scans text for NAFE failure signatures: Narrative Rescue, Moral Override, Authority Drift, and Intent Inference. Use this on commit messages, PR descriptions, or incident reports to detect narrative bypasses of deterministic gates. Returns JSON with fields: clean (boolean), flags (array of detected signatures), scan_metadata (object). Violations auto-seal to the audit ledger.
Inputs: text (required).
Runs the full 10-gate VERITAS pipeline: INTAKE → TYPE → DEPENDENCY → EVIDENCE → MATH → COST → INCENTIVE → SECURITY → ADVERSARY → TRACE/SEAL. Use this for complete end-to-end evaluation of a BuildClaim; use individual gates for targeted checks. Returns JSON with fields: final_verdict (PASS | MODEL_BOUND | INCONCLUSIVE | VIOLATION), gate_results (array), reason_codes (array), seal_hash (hex string).
Inputs: claim (required), fail_fast.
Gate 8/10: Evaluates security posture from SAST, secret detection, injection surfaces, auth boundaries, and TLS config. Use this to enforce zero-tolerance security policy — any CRITICAL finding or exposed secret causes VIOLATION. Returns JSON with verdict (PASS | MODEL_BOUND | VIOLATION) and findings array with severity levels.
Inputs: claim (required).
Gate 2/10: Enforces type-level correctness — unique primitives, non-empty domains, operator arity, symbol resolution, and unit consistency. Use this after intake to catch structural errors before evidence evaluation. Returns JSON with verdict (PASS | VIOLATION) and reason_code: TYPE_OK, TYPE_DUPLICATE_PRIMITIVE, TYPE_EMPTY_DOMAIN, TYPE_OPERATOR_ARITY, UNDEFINED_SYMBOL, or UNIT_MISMATCH.
Inputs: claim (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 27 tools
Every tool has a clearly defined role: omega_* tools handle context, storage, alignment, execution, and reporting, while veritas_* tools are specialized gates with discreet purposes and explicit cross-references (e.g., omega_rag_query vs omega_vault_search, omega_cortex_check vs omega_cortex_steer, veritas_evidence_gate vs veritas_compute_quality). The descriptions carefully disambiguate overlapping-sounding tools, so an agent can accurately select the right tool for a given task.
All names follow a consistent snake_case convention with a clear two-part prefix taxonomy: omega_* for brain/memory/governance operations and veritas_* for verification pipeline operations. Verbs and nouns are consistently separated and meaningful (e.g., ingest, search, check, steer, run_pipeline, resolve, transition), making the toolset predictable and scannable.
With 27 tools, the server exceeds the 25-tool threshold that marks an heavily oversized set. While each tool individually has a purpose, the sheer number places a significant cognitive burden on an agent and requires the agent to parse many near-similar gates and helpers; a more consolidated surface (e.g., merging that run_pipeline already wraps individual gates) might be more appropriate.
The toolset covers the full lifecycle of the domain: context loading, semantic storage/retrieval, alignment checking, audit sealing, session persistence, handoffs, and the total VERITAS 10-gate pipeline. Missing pieces are minor (e.g., no individual trace gate, no deletion/update operations for stored fragments), but the does not create blocking gaps for the can be worked around via the pipeline and report tools.
Pre-execution governance for AI agents. Deterministic PASS/FAIL/REVIEW verdicts, replayable proof.
Trust gate for AI agents: multi-model adversarial consensus, signed and verifiable verdicts.
Agent-native security, trust, reliability, data and procurement tools for AI workflows.
AI-agent trust infrastructure for discovery, authority, execution, verification, and receipts.
