Architecture

Moltblock uses a multi-agent directed acyclic graph (DAG) where each role has a single responsibility. Artifacts flow through the graph and must pass verification before becoming authoritative.

The Agent Pipeline

Every task flows through four agents in sequence:

Generator

Produces the initial artifact from the task description using the configured LLM.

Critic

Reviews the draft and produces structured feedback on correctness, style, and risk.

Judge

Synthesizes the draft and critique into a final candidate artifact.

Verifier

Runs policy checks (regex-based deny rules) against the final candidate. Returns pass/fail with evidence.

Pipeline Flow

Task
 |
 v
Generator  -->  Draft artifact
 |
 v
Critic     -->  Structured critique
 |
 v
Judge      -->  Final candidate
 |
 v
Verifier   -->  Pass / Fail + evidence
 |
 v
Pass?  -->  Authoritative artifact (signed, stored)
Fail?  -->  Rejected (evidence returned)

Core Concepts

Entity

The primitive unit of intelligence. An Entity owns a multi-agent DAG and can evolve over time through molting.

Molt

An evolutionary step. When an Entity checkpoints and upgrades its strategy, it molts — shedding old behavior and adopting new capabilities.

Artifact

The output of an Entity run. Artifacts are signed for attribution and can be verified by other Entities in a handoff chain.

Governance

Rules that constrain Entity evolution. Governance policies determine when and how an Entity can molt, preventing unsafe strategy changes.

Memory

Persistent verified memory backed by SQLite (WAL mode). Entities remember past artifacts, verification results, and strategy checkpoints.

Verification Gating

The Verifier runs configurable policy rules against the final candidate. Built-in deny rules catch dangerous patterns:

✗Destructive operations: rm -rf, DROP TABLE
✗Privilege escalation: sudo, chmod 777
✗Credential access: .ssh/, id_rsa, .env
✗Dynamic code evaluation and unsafe runtime patterns

Add custom policy rules in moltblock.json to match your security requirements.

Entity Lifecycle

Entities evolve through a cycle of work and molting:

Birth  -->  Work (run tasks, verify artifacts)
  |                    |
  |              Checkpoint (save strategy + memory)
  |                    |
  |              Governance check (can we molt?)
  |                    |
  +--- Molt  <---------+
  |
  v
Work (evolved strategy, new capabilities)