IACT: A Self-Organizing Recursive Model for General AI Agents: A Technical White Paper on the Architecture Behind kragent.ai¶

🕒 Published (v1): 2025-12-02 10:10 UTC · Source: Arxiv · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

TL;DR¶

IACT (Interactive Agents Call Tree) is a runtime-adaptive multi-agent architecture that replaces static DAG/SOP workflows with a dynamically grown recursive tree of LLM agents communicating via bidirectional stateful dialogues. Each agent node maintains contextual isolation while the tree topology enforces a single source of truth, enabling open-ended task execution without pre-coded workflow graphs. The system is deployed in production at kragent.ai and described here as an architecture/experience report rather than a benchmarked contribution.

Problem¶

Static agent workflow paradigms—CoT/ReAct chains, multi-agent group chat, and DAG/SOP graphs—all share the same fundamental flaw: topology must be predetermined by the developer. This makes them brittle on open-ended tasks where solution complexity is emergent. Additionally, unidirectional function calls propagate errors without correction, and flat/shared contexts suffer "Lost in the Middle" cognitive degradation as history grows. There is no existing general model that allows an agent system to autonomously grow its own organizational structure at runtime.

Method¶

IACT maps a traditional recursive function call tree onto an agentic system: agents ↔ functions, context windows ↔ call stack registers, LLM ↔ CPU. The key departure is replacing instantaneous function calls with bidirectional stateful dialogues between parent and child agents, introducing interactional redundancy analogous to data redundancy in noisy-channel communication.

The agent loop is formalized as: $$C_t = (P_{sys},\ H_{seq},\ I_{in},\ M_{dynamic})$$ $$A_t = \text{LLM}(C_t), \quad I'_{in} = \text{Interpreter}(A_t)$$

where $M_{dynamic} = f_{state}(S_{internal}, S_{external})$ injects live system state (file listings, context-overflow warnings, stack traces) rather than encoding behavior in static prompts.

A Hybrid Language Interpreter parses agent outputs for registered syntax patterns (CALL, BASH, variable definitions) and dispatches them as RPC calls to external modules (Ext-Modules). The CALL primitive both instantiates new child agents (first invocation) and routes messages to existing ones (subsequent invocations), growing the tree strictly on-demand. Context isolation is enforced by design: child agents operate in fresh windows, returning only distilled results to parents, preventing context saturation from propagating upward.

Supporting mechanisms include: dynamic capability loading (just-in-time tool injection via keyword-matched context analysis), symbolic variable passing (bypassing JSON-escaping failures for multimodal/structured data), KV cache-aware context layout (static prefix first, dynamic suffix appended), and active context compression triggered by threshold injection.

Key Contributions¶

IACT topology derivation: formal argument that recursive tree is the uniquely appropriate non-trivial topology for probabilistic multi-agent systems (cyclic graphs and linear chains are rejected on coherence grounds)
Interactional redundancy: bidirectional stateful parent-child dialogues as a correction-based alternative to retry-based error handling
Dynamic context construction: behavioral guidance via live injection into $M_{dynamic}$ rather than static system prompts, preserving KV cache compatibility
Symbolic variable mechanism: reference-based data transport that handles multimodal content and cross-process (distributed) data passing without serialization into function-call strings
State-machine tooling paradigm: tools expose only contextually valid action subsets, reducing hallucination and cognitive load
Control flow patterns: Vertical Escalation (human-in-the-loop bubbling), Dynamic Sibling Delegation, Lazy Evaluation (yield-and-process for infinite outputs), and Task Re-entrancy
Observability by design: sequential execution produces a single reconstructible log; the tree can be programmatically recovered from CALL relationships for audit/intervention

Results¶

The paper explicitly provides no quantitative benchmarks. Evidence is qualitative, drawn from production deployment of kragent.ai. No comparison against baseline systems (AutoGen, LangGraph, CrewAI, etc.) is presented with numbers. The authors frame this as an architecture/experience report.

Limitations¶

No quantitative evaluation; all claims are qualitative or argued from first principles
Sequential execution model is acknowledged as a simplification; async/parallel execution is described as future work (CALL ASYNC)
Decoherence mitigation relies on the LLM's own planning discipline ("Principle of Exclusive Ownership" is maintained by the agent's autonomous scheduling, not enforced mechanically)
Principle of Cohesive Decomposition assumes the orchestrating LLM adheres to high-cohesion/low-coupling decomposition; failure modes under adversarial or ambiguous decompositions are not analyzed
No formal security model for RPC-connected Ext-Modules or runtime-synthesized tools
Context compression is agent-triggered (the agent decides when/what to summarize), introducing a potential single point of failure if the agent mis-compresses

Relevance to Harnesses / Meta-Harnesses¶

IACT is directly an instance of a meta-harness: a general-purpose execution substrate that itself orchestrates the creation, routing, and lifecycle management of specialized sub-agents rather than implementing any single task. The dynamic capability loading and just-in-time tool synthesis mechanisms are precisely the kind of self-extending harness infrastructure that a researcher tracking meta-harness architectures should study. The KV-cache-aware context layout, dynamic instruction injection, and context compression loop are engineering solutions to harness-level concerns (token economy, reliability, observability) that recur across harness implementations. The "Observe-Supervise-Intervene" loop and runtime intervention model represent a practical design pattern for human-in-the-loop harness control.