Intelligenism Agent Framework

IAF is an open-source framework for building multi-agent collaboration modes. A running IAF instance is just a directory. You create a new collaboration pattern by copying a folder, you give an agent new abilities by dropping a *_tools.py file into it, and you reconfigure the whole system by editing plain JSON — no framework code changes required. Every extension point has an explicit contract and a machine-checkable validator, so an LLM can safely read the system, modify it, and verify its own work.

Why "AI Operability Edition"

Most agent frameworks are built for human developers to write code. This edition is tuned so that an AI agent can operate the framework end-to-end — the extension surface is small, declarative, contract-bound, and verifiable, which are exactly the properties an autonomous agent needs to modify a system safely.

• Explicit contracts. A tool contract specifies exactly how a new tool file must be written, so an LLM can author one correctly on the first try.
• Machine-checkable validation. validate.py reports OK or a precise list of FAIL reasons — an agent can self-check after editing.
• A machine-readable system map. generate_manifest.py emits a MANIFEST.json describing every dispatch, agent, and tool — an agent can discover the system without reading source.
• Config / engine separation. All edits happen in plain JSON and Markdown; the engine is a black box an agent cannot break by reconfiguring it.
• Copy-to-extend. New capability is a copied folder or a dropped-in file, never a patch to core code.

Core Concepts

The central idea: a dispatch is a copyable unit. To build a new kind of agent collaboration, you copy the prototype dispatch, adjust its config and prompts, and it runs. Dozens or hundreds of specialized dispatches can be spun off the same prototype.

The Shell: Four Zones

An IAF instance separates configuration, prompts, outputs, and the engine into four zones:

{iaf_instance}/
├── config_base/   ZONE 1 — CONFIG   (source of truth; humans/agents edit here)
├── prompt_base/   ZONE 2 — PROMPTS  (the only home for prompt/rule files)
├── workspace/     ZONE 3 — OUTPUTS  (run artifacts land here)
└── IAF_AI/        ZONE 4 — ENGINE   (runtime; never edited by hand)

The flow of truth is one-directional. Four rules make it work:

• config_base/ is the source of truth. Humans and agents only ever edit files here.
• prompt_base/ is the single home for prompts. Editing a prompt takes effect immediately — no sync needed.
• Engine-internal config is generated. sync_config.py writes it; never hand-edit it.
• The engine is never modified. The kernel and tool code stay untouched across every specialization.

The Theory Behind It

IAF is the first practical implementation of Intelligenism — a theory of how intelligence emerges in organisations, whether human, artificial, or hybrid.

From single neurons to complex neural networks, intelligence exhibits a bottom-up construction pattern. The complexity and intelligence potential of a network comes from the connections between individuals, not from making the individuals internally more complex. Maintaining the independence of individuals or small units, and expressing complexity outside the individual, is the essence of connectionism. — Thinking, Conception and Construction of Intelligenism

This principle directly shapes IAF's architecture: every agent is a complete, independent unit. Complexity lives in the connections between agents, not inside any single agent's code. Where most frameworks practice certainty management — hardcoding one collaboration paradigm and calling it flexible — IAF practices possibility management: each agent owns a complete copy of the engine, so you can change anything without risking the rest.

Get It