A distributed cognition system for mission-driven, Zero-Trust-Inspired AI orchestration.
AI systems should propose.
Evidence should shape belief.
Beliefs should remain revisable.
Deterministic systems should govern execution.
IronGhost is an experimental distributed cognition architecture built around specialized cognitive roles, explicit mission knowledge, independent verification and deterministic execution boundaries.
Rather than asking one model to perceive, remember, reason, verify and decide simultaneously, IronGhost decomposes cognition into narrow state transformations. Persistent mission state, evidence and evolving beliefs are maintained outside individual LLM contexts.
Raw observations are not treated as mission memory. They are consolidated into explicit Knowledge Cards containing claims, epistemic status and evidence provenance. As new evidence arrives, existing knowledge can be reinforced, refined, weakened or refuted.
The Strategist operates on this evolving knowledge state to maintain a compact Mission Assessment and decide which information is worth acquiring next.
Sources
β
βΌ
Observer
Local Perception
β
βΌ
Observer Artifact
β
βΌ
Knowledge Manager
Consolidation / Revision
β
βΌ
Mission Knowledge
Cards / Claims / Evidence
β β
β ββββββββββββββββ
βΌ βΌ
Knowledge Graph Strategist
Belief Topology Assessment / Attention
β
βββββββββββ΄βββββββββββ
βΌ β
Next Observation β
β β
βββ knowledge loop βββ
β
βΌ
Mission Graph
Proposed Operations
β
βΌ
Human Approval
β
βΌ
Execution DAG
β
βΌ
Deterministic Execution
Cognition is distributed across specialized components rather than concentrated inside a single long-lived agent. LLM contexts remain bounded and disposable; continuity is carried by explicit system state.
IronGhost_short_demo_20261001_01.mp4
IronGhost treats LLMs as untrusted cognitive components. They may propose plans, code and assessments, but mission continuity and execution authority remain outside individual model contexts.
The architecture separates evidence, belief, decision and execution into explicit state transitions with distinct validation boundaries.
IronGhost deliberately separates four stages that are often collapsed into a single agent context:
DATA
Source files, documents, tool results
β
βΌ
OBSERVATION
Source-grounded local information
β
βΌ
KNOWLEDGE
Consolidated claims, epistemic state and provenance
β
βΌ
ASSESSMENT
Current mission understanding and attention
β
βΌ
ACTION
Proposed Mission Graph and approved execution
A source is not a belief.
An observation is not automatically knowledge.
Knowledge is not automatically a decision.
A decision is not automatically authorized execution.
Each boundary is explicit.
IronGhost does not rely on LLM context as the authoritative memory of a mission.
Persistent mission state is represented explicitly through several complementary structures:
- Assessment β compact working memory and global decision state;
- Mission Knowledge β durable consolidated mission knowledge outside individual model contexts;
- Knowledge Cards β concept-level belief state;
- Knowledge Claims β atomic propositions with epistemic status and evidence provenance;
- Mission Knowledge Graph (shown as Knowledge Graph in the Tactical Board) β deterministic projection of concepts, claims and evidence relationships;
- Mission Graph β structured operational plan proposed by the cognitive layer;
- Execution DAG β deterministic projection of approved operational work.
Agents are transient.
Contexts are disposable.
Messages are ephemeral.
Mission continuity belongs to explicit system state, not to any individual LLM or conversation history.
IronGhost distinguishes data acquisition, knowledge consolidation, mission understanding and operational planning.
Observations extracted from sources are not automatically promoted to durable mission knowledge. They first pass through a dedicated knowledge-maintenance pipeline that organizes information around stable Knowledge Concepts.
Each Knowledge Card represents the current consolidated state of one concept and contains:
- a compact summary;
- atomic Knowledge Claims;
- an epistemic status for each claim;
- explicit evidence provenance;
- the current state of investigation for the concept.
Knowledge is therefore represented not only as information to retrieve, but as an evolving set of evidence-backed beliefs.
Source
β
βΌ
Observation
β
βΌ
Knowledge Claim
β
βββ Hypothesis
βββ Supported
βββ Confirmed
βββ Weakened
βββ Refuted
βββ Undetermined
β
βΌ
Knowledge Card
β
βΌ
Mission Knowledge
The goal is not to preserve everything agents have ever said.
The goal is to preserve the best current mission knowledge, together with enough provenance to understand why the system currently believes it.
Long-running investigations accumulate contradictory, incomplete and superseded information.
IronGhost treats this as a knowledge-management problem rather than only a retrieval problem.
A claim does not become stronger merely because it is repeated or survives multiple assessment rounds. When new evidence arrives, the knowledge-maintenance layer compares it with the current Knowledge Card and may:
- reinforce an existing claim;
- refine its scope;
- weaken it;
- refute it;
- preserve a conflict as unresolved;
- introduce a genuinely new claim.
This allows mission knowledge to evolve without treating the complete interaction history as authoritative memory.
For example:
βββββββΊ Confirmed
β
Hypothesis βββΊ Supported βββΊ Weakened
β β
β βββββββΊ Refuted
β
βββββββββββββββββββββββΊ Undetermined
This mechanism is intentionally separate from the Strategist.
The Knowledge System maintains detailed beliefs and provenance. The Strategist consumes their current mission-level significance to decide where investigation attention should move next.
IronGhost maintains two graph representations with deliberately different semantics.
The Mission Knowledge Graph is derived deterministically from the current Mission Knowledge.
It connects:
Concept
β
βΌ
Claim
β
βΌ
Evidence
It answers:
What does the mission currently believe, and what evidence supports those beliefs?
Nodes expose the current epistemic state of concepts and claims, while evidence nodes preserve provenance back to reviewed sources.
The Knowledge Graph is a projection of Mission Knowledge. It does not independently own mission knowledge; it is a derived projection of it.
The Mission Graph represents proposed operational work.
It connects goals, subgoals, risks, assets and executable tasks:
Goal
β
βββ Subgoal
β β
β βββ Risk
β β
β βββ Task
β
βββ Task
It answers:
Given what the mission currently understands, what should happen next?
The distinction is intentional:
Knowledge Graph
"What do we believe?"
β informs
Mission Graph
"What should we do?"
β approval
Execution DAG
"What will actually run?"
Cognitive models may propose knowledge updates and operational plans, but deterministic system components retain state and execution authority.
The Strategist maintains a compact, disposable assessment of the current mission state.
Rather than following a fixed investigation workflow, it repeatedly decides whether the highest-value next step is to:
- request another focused observation;
- refine the current assessment from new evidence; or
- stop assessment early and emit a Mission Graph for distributed operational investigation.
The assessment budget is therefore a maximum cognitive budget, not a required number of reasoning iterations.
This allows IronGhost to alternate between sequential investigation and graph-based delegation depending on expected information gain.
Traditional AI frameworks are agent-centric:
Agent
β
Tool
β
Action
IronGhost is mission-centric:
Mission
β
βββββββββ΄βββββββββ
βΌ βΌ
Mission Knowledge Assessment
β β
βββββββββ¬βββββββββ
βΌ
Mission Graph
β
βΌ
Execution DAG
β
βΌ
Executors
Agents contribute cognitive transformations to mission state. They do not individually own mission continuity.
Agents do not own mission state. Mission state is externalized into explicit knowledge, assessment and operational structures.
IronGhost distinguishes several cognitive and operational roles:
-
Agents are higher-level cognitive actors such as the Strategist. They may maintain mission-level reasoning loops and communicate through the Board.
-
Workers are specialized, task-bounded LLM agents. A Worker performs one narrow cognitive transformation such as source observation or knowledge consolidation. Workers do not communicate freely through the Board.
-
Sentinels independently evaluate Worker outputs before those outputs are accepted by the surrounding cognitive pipeline. Worker + Sentinel pairs are orchestrated through the Dispatcher.
-
Executors are deterministic, non-LLM components responsible for carrying out approved operational actions in controlled environments.
This separation keeps cognition, verification, orchestration and execution as distinct responsibilities.
IronGhost is built around a core architectural principle: The Separation of Powers, inspired by a Zero-Trust approach.
IronGhost borrows from zero-trust thinking without claiming to implement a complete Zero Trust security architecture.
No cognitive component is treated as inherently authoritative merely because it is an LLM, a specialized agent, or the output of a previous trusted workflow. Trust is attached to state transitions and validation boundaries rather than to model identity.
IronGhost assumes that every LLM can:
- hallucinate
- drift
- be manipulated
- produce unsafe code
- misunderstand mission context
Therefore:
- agents are isolated
- specialized Workers use an amnesia protocol
- Worker outputs are independently evaluated by Sentinels
- persistent knowledge is stored outside individual LLM contexts
- deterministic Executors retain operational authority
- execution authority remains outside the cognitive AI layer
IronGhost deliberately separates cognitive continuity from model context.
Specialized Workers:
- receive a bounded task and explicit context;
- perform one narrow cognitive operation;
- produce a structured artifact;
- are independently evaluated by a Sentinel;
- discard their inference context after completion.
Long-term continuity is externalized into explicit mission structures such as Assessments, Mission Knowledge, Knowledge Cards, Claims, Knowledge Graphs and Mission Graphs.
This architecture reduces:
- cognitive drift;
- hidden state accumulation;
- context poisoning;
- accidental dependence on conversation history;
- non-reproducible implicit memory.
The goal is not to eliminate memory. It is to separate model context from mission memory.
An individual LLM invocation may forget. The mission must not.
Mission continuity is therefore reconstructed from explicit assessments, consolidated Knowledge Cards, evidence provenance and operational state rather than from a growing conversational context.
IronGhost treats external sources as untrusted input.
Documents, repositories and other external material are inspected by specialized, task-bounded Workers rather than being injected directly into persistent mission cognition.
Untrusted Source
β
βΌ
Bounded Observer Worker
β
βΌ
Structured Artifact
β
βΌ
Independent Sentinel
ββββββββ΄βββββββ
reject accept
β β
βΌ βΌ
bounded Knowledge
retry Pipeline
β
βΌ
Mission Knowledge
Workers operate under the Amnesia Protocol: their inference context is bounded to the assigned transformation and discarded after completion.
Their outputs are independently evaluated by Sentinels before being admitted into downstream cognitive state. Rejected artifacts may be regenerated within a bounded retry budget.
This does not make prompt injection impossible. It is intended to reduce the authority, persistence and propagation of potentially manipulated model outputs.
In particular, external content does not directly become:
- persistent mission knowledge;
- authoritative mission assessment;
- an operational Mission Graph;
- executable action.
Each transition crosses an explicit cognitive or deterministic validation boundary.
While traditional AI agent frameworks often grant Large Language Models (LLMs) direct code execution capabilitiesβcreating security and reliability risks, providing agents with more memory and autonomy, IronGhost decouples cognition, orchestration, and execution into strict, isolated boundaries, and follows a "minimal" trust philosophy:
- Dual-Channel Governance:
- Cognitive Cooperative Channel (Blackboard): A shared forum where cognitive AI agents collaborate, propose strategies, and propose a Mission Graph.
- Hierarchical Command & Control (C2): A strict command chain. Human Operators hold the highest authority and validate actions before execution. The Mission Graph is rendered in real time, and is translated into an execution graph (deterministic) under strict automated (sentinels) and human supervision.
- Strict Isolation & Execution Safety:
- No Direct AI Execution: LLMs cannot execute code. They are either cognitive advisors, specialized agents or sentinels (with amnesia protocol) with no execution runtimes.
- Deterministic Executors: Operational execution is offloaded to isolated, non-AI environments (e.g. dedicated Kali Linux VMs) running controlled execution logic.
- Safe Orchestration: A central Rust Orchestrator manages message routing, state transitions, human validations, and alert escalations without using any internal LLM logic.
- Sentinel Filtering: Specialized Workers are paired with independent Sentinels that evaluate their structured outputs before acceptance by the cognitive pipeline. Higher-level cognitive Agents may use different governance mechanisms.
Example of action process:
+-------------------------------------------------------------------+
| Mission Graph State |
| |
| [Node 1: Recon] ----> [Node 2: Vuln Scan] |
| (Status: SUCCESS) (Status: PROPOSED) |
| | |
| v (Human Approved) |
| [Node 3: Exploitation] |
| (Status: PENDING_EXECUTION) |
+---------------------------------+---------------------------------+
|
(Rust Engine Dispatch)
v
+---------------+---------------+
| Sentinel Filter & Validation |
+---------------+---------------+
|
v
+---------------+---------------+
| Deterministic Worker (Kali) |
+-------------------------------+
IronGhost explores an architecture in which:
- model contexts are disposable;
- observations are separated from durable beliefs;
- durable beliefs retain epistemic state and evidence provenance;
- knowledge consolidation is performed by a dedicated cognitive role;
- strategic reasoning consumes consolidated knowledge rather than raw history;
- operational plans remain distinct from knowledge state;
- LLM-generated artifacts are independently evaluated;
- execution authority remains outside the cognitive model layer.
These choices are not claims that alternative agent frameworks cannot implement similar mechanisms. They define the particular architectural trade-offs IronGhost is exploring.
IronGhost is not:
- an autonomous offensive AI
- a self-executing agent framework
- a direct Tool-Use runtime
- an AGI experimentation platform
IronGhost is a distributed cognition and mission orchestration architecture where specialized AI components perceive, consolidate, verify and plan, while explicit system state preserves continuity and deterministic systems retain execution authority.
The repository currently exposes the core infrastructure modules:
+-----------------------------------------------------------------------+
| Human Operator / Tauri UI |
| |
| Mission Graph Knowledge Graph |
+-----------------------------------+-----------------------------------+
|
v
+-----------------------------------------------------------------------+
| IronGhost Overwatch (Rust) |
| |
| Assessment Mission Knowledge Operational State |
| | | | |
| v v v |
| Strategist Knowledge Manager Mission Graph |
| | Cards / Claims | |
| | / Evidence v |
| | | Execution DAG |
| +---------+----------+ | |
| | | |
| Observer / Dispatcher | |
+----------------+-------------------------------------+-----------------+
| |
v v
+----------------+----------------+ +------------+----------------+
| ironghost-services | | ironghost-executor |
| LLM inference layer | | deterministic execution |
+---------------------------------+ +-----------------------------+
-
ironghost-overwatch(Rust / Tauri / Svelte)- Mission-centric orchestration engine.
- Manages Mission Graph lifecycle, agent coordination, validation workflows and human-in-the-loop governance.
-
ironghost-services(C++ / Native)- High-performance local LLM services.
- Binary IPC over Unix Domain Sockets.
- Grammar-constrained outputs with GBNF.
-
ironghost-executor(Rust)- Environment-agnostic execution layer.
- Decouples execution environments from runtime implementations.
- Supports isolated execution targets (currently Local and Kali).
- Designed to evolve toward VM provisioning, disposable environments and stronger isolation.
- See
ironghost-executor/README.mdfor details.
- Lightweight Local IPC: Native framed IPC over Unix Domain Sockets provides a small transport surface for local LLM services without requiring an HTTP or gRPC stack.
- Grammar-Constrained Output: Structured generation paths can be constrained at decoding time using GBNF grammars.
- Memory-Safe Control Plane: Core orchestration is implemented primarily in Rust, using its ownership and type system to reduce memory-safety risk in the control layer.
- Rust toolchain (
cargo,rustc) - C++17 compliant compiler (
clang++org++) - Node (used by
Tauriin dev mode for the desktop app) - macOS (Apple Silicon optimized) or Linux
Install llama.cpp in project root (or adapt LLAMA_DIR in
ironghost-services/llm-services/CMakeLists.txt):
git clone https://github.com/ggml-org/llama.cppCreate a models directory for your GGUF models:
cd ironghost-services
mkdir modelsPlace the models you want to use in this directory.
cd ironghost-services/llm-services
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -jAll cognitive LLM services share the same compiled binary.
Configure ironghost-services/llm-services/services.yaml. An example is provided (services.yaml.example).
Each service configuration defines its runtime identity, including its model, Unix Domain Socket, system prompt, GBNF grammar, inference parameters and amnesia policy.
System prompts and grammars are stored under llm-services/config/.
Services can be launched individually (e.g. during development or for monitoring):
./build/ironghost_llm_service \
services.yaml \
<service_name>For example:
./build/ironghost_llm_service \
services.yaml \
strategistTODO: future implementations will integrate service deployment, supervision and lifecycle automation.
The ironghost.yaml file in the root directory contains IronGhost's global orchestration configuration.
Note: Configuration is currently split along runtime boundaries:
ironghost.yamldescribes mission orchestration, stores, agents and execution infrastructure, whileservices.yamldescribes independently deployed LLM inference services. This separation may evolve as deployment automation is introduced.
Optional: Use of Websearching tool may require an API key, which can be set in ironghost-overwatch/src-backend/.env (example provided in ironghost-overwatch/src-backend/.env.example).
Create your stores for external sources and internal artifacts:
cd ironghost-overwatch
mkdir data/artifacts/
mkdir data/sources/cd ironghost-overwatch/src-backend
cargo run -p backend --bin main cd ironghost-overwatch
npm run tauri:dev Place relevant mission resources in the source store (located at data/sources/ by default).
Note: currently, IronGhost can only read plain text documents such as codebases. For example, you can git clone a repository in your source store, for IronGhost to analyse it.
Launch a mission in the interface with the keyword !Initiate_Mission followed by your objective. For example:
!Initiate_Mission find potential vulnerabilities in the given repository
This will trigger a mission assessment phase (recursive assessment) based on provided documents, followed by an operational phase (DAG execution).
IronGhost can therefore use two complementary investigation modes:
-
Recursive assessment β the Strategist selects one high-value information need, delegates observation, updates mission understanding and iterates.
-
Graph delegation β once assessment is sufficient, or when remaining sequential assessment has lower expected value, the Strategist emits a Mission Graph whose tasks can be executed through the operational pipeline.
Note: The assessment budget defines the maximum number of Strategist iterations, not a number of iterations that must be consumed.
The Strategist may terminate assessment early when further sequential investigation has lower expected value than delegation. With a small budget, it may therefore emit a Mission Graph containing investigation tasks rather than consume the remaining budget through recursive observation.
You can also summon a cognitive agent directly by tagging it with !@. For example:
!@strategist propose a mission graph for a vulnerabily test
The tagged cognitive Agent receives the Board context currently available to its communication buffer and can answer outside the structured mission assessment workflow.
For development and Runner testing, a Mission Graph can currently be injected directly through the Board using the legacy <mission_state> envelope:
<mission_state>
{
"nodes": [
{
"id": "goal_01",
"kind": "goal",
"title": "Assess the target repository"
},
{
"id": "sub_review",
"kind": "subgoal",
"title": "Review security-relevant components"
},
{
"id": "task_inspect",
"kind": "task",
"title": "Inspect input-processing boundaries",
"description": "Review the relevant source components and report evidence-grounded findings.",
"worker": "code_inspector"
},
{
"id": "task_validate",
"kind": "task",
"title": "Validate supported findings",
"description": "Create controlled tests for findings that have sufficient supporting evidence.",
"worker": "coder"
}
],
"edges": [
{
"from": "task_inspect",
"to": "sub_review",
"relation": "investigates"
},
{
"from": "task_validate",
"to": "sub_review",
"relation": "verifies"
},
{
"from": "sub_review",
"to": "goal_01",
"relation": "enables"
}
]
}
</mission_state>
This bypasses the normal Strategist assessment path and is intended primarily for development and pipeline testing.
- Lean C++ Binary LLM IPC Service over Unix Domain Sockets
- Asynchronous Rust Board Orchestrator & Event Pipeline
- Real-time Svelte/Tauri Tactical Overwatch Dashboard
- Structured Mission Graph Generation (GBNF-constrained JSON)
- Recursive Strategist assessment loop
- Specialized Observer + Sentinel perception pipeline
- Concept-routed Knowledge Cards
- Atomic Knowledge Claims with evidence provenance
- Epistemic claim states (Hypothesis / Supported / Confirmed / Weakened / Refuted / Undetermined)
- Knowledge Worker + Sentinel consolidation pipeline
- Mission Knowledge Graph projection
- Real-time Knowledge Graph visualization
- Explicit Knowledge Events
- Cross-card contradiction detection
- Belief-revision history / predecessor tracking
- Knowledge aging and supersession policies
- Method / cross-mission knowledge
- Frontier-level epistemic audit
- Strategist auditing / governance
- Implementation of Mission Graph runner with parallel execution (execution DiGraph)
- Introduction of ironghost-executor service
- Environment / Runtime execution abstraction
- Local and Kali execution environments
- Automatic VM provisioning
- Disposable VM environments
- Formalized worker execution protocol
- Formalized C2 Protocol for Sandboxed Worker Execution
- Sentinel policy engine
- Mission Graph validator
- Worker cancellation propagation
- Mission versioning
- Mission graph signatures
- RBAC and operator workflow
- Formal Mission DSL
- Mission Graph persistence
- Mission replay & audit trail
- Deterministic policy engine
Distributed under the MIT License. See LICENSE for more information.