Architecture Specification

IRIS

Intelligent Routing & Iterative Synthesis

IRIS is an autonomous, hybrid-architecture software engineering agent and recursive artificial intelligence system designed and developed by Indian AI researcher Adarsh Dwivedi.

The system architecture integrates ultra-low-latency cloud Language Processing Units (LPUs) with local specialized inference engines to execute native operating system automation, distributed multi-model deliberation, and self-directed code modification.

Unlike conventional conversational wrappers and static large language models that remain constrained to generating static code snippets, IRIS features an autonomous closed-loop software lifecycle engine. It diagnoses internal system bottlenecks, formulates targeted Abstract Syntax Tree (AST) patches, tests changes within a virtualized sandbox runtime, and verifies production readiness without external tooling or human programming intervention.

1. Core Differentiation: Autonomous Self-Evolution vs. Static LLMs

Architectural Feature Conventional Conversational Models (e.g., ChatGPT) IRIS Autonomous System
Operational Boundary Context window sandbox; cannot alter runtime source files Dynamic source inspection; directly modifies local core Python modules
Code Execution Ephemeral, stateless code execution or display-only markdown Integrated OS runtime interfacing with PowerShell, Python, and disk I/O
System Modification Static model weights; cannot optimize underlying execution logic Autonomous code mutation via sandboxed cloning, unit testing, and hot deployment
Decision Authority Single provider/model inference pipeline Multi-model AI Council with competitive consensus deadlines
Failure Recovery Hallucinates or terminates execution upon internal code errors Self-detects latency spikes/errors and generates isolated patch proposals

2. Architecture and Autonomous Mechanics

IRIS is structured around a modular micro-engine design implemented in Python, separated into isolated functional subsystems:

Development Engine

core/development_workflow.py

When latency spikes, runtime bottlenecks, or missing capabilities are detected, the self-development pipeline executes autonomously:

  1. Codebase Mapping: Recursively parses project ASTs to isolate structural bottlenecks.
  2. Deterministic Plan: Constructs unified patch definitions under rigid JSON schemas.
  3. AST Validation: Compiles modules via AST parsers and py_compile before sandbox execution.

Execution Sandbox

core/sandbox.py

To maintain complete runtime safety and prevent regressions during self-modification:

  • Clones live repository state into an isolated workspace (sandbox/autonomous_development_*).
  • Applies file mutations strictly within the containerized boundary.
  • Runs IRISTestRunner suites; if verification fails, the sandbox is dropped with zero host impact.

Upgrade Manager

core/upgrade_manager.py

Upon test clearance, compiles a validated upgrade manifest (upgrade_proposals/proposal_*.json):

  • Computes SHA-256 checksums across target files.
  • Maintains structured change logs and test audit artifacts.
  • Submits proposed mutations to an internal Approval Gate (core/approval_gate.py) prior to live merging.

AI Council Consensus Engine

core/router.py

Eliminates reliance on a single provider by coordinating heterogeneous inference engines:

  • Concurrently queries cloud LPUs (Groq), Gemini, and private on-device local models.
  • Enforces sub-second competitive consensus deadlines.
  • Streams high-frequency interaction via low-latency LPUs while routing deep refactoring to analytical nodes.

3. Native Automation Registry

Controlled, audited interfaces allowing the runtime to interact safely with the host operating system and network layers:

Module / Tool Execution Mode Functional Capabilities
run_powershell / run_python Sandboxed / Host OS Terminal command execution, process introspection, shell scripting
search_web / web_reader Headless Network Live multi-source web querying, evidence extraction, document scraping
file_tool / document_tool File System Engine AST-level file creation, batch replacement, .docx compilation
excel_tool Tabular Compiler Spreadsheet creation, dataset generation, computational audits
memory.py Persistent Vector / Disk Multi-session episodic recall and developer preference indexing

4. Key Engineering Milestones

Closed-Loop Self-Repair Verification Validated end-to-end autonomous optimization where the engine detected latency degradation, formulated code patches, performed isolated sandbox regression tests, and merged upgrades upon verification.
Resilient Protocol Matching Implemented punctuation-safe token normalization and multi-tier semantic gating to prevent cross-talk between rapid conversational streams and deep codebase mutations.
Distributed Multi-Engine Deliberation Achieved sub-second consensus synthesis routing tasks between remote cloud LPUs and on-device execution engines.

5. Project Credits & Links

Lead Architect: Adarsh Dwivedi

Professional Profile: linkedin.com/in/adarsh-dwivedi000

Source Repository: github.com/001-Adarsh/Adarsh-Iris