Architecture & System Overview

About 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.

IRIS integrates ultra-low-latency cloud Language Processing Units (LPUs), private on-device inference engines, native operating-system automation, distributed multi-model deliberation, and self-directed code modification.

Unlike conventional conversational AI systems, IRIS operates as a closed-loop software lifecycle engine. It can diagnose system bottlenecks, create targeted Abstract Syntax Tree (AST) patches, test changes in an isolated sandbox, and verify production readiness before deployment.

Our Vision

IRIS is built on the belief that next-generation AI should not only generate code, but understand software systems, identify weaknesses, and safely improve them.

IRIS acts as an autonomous engineering partner capable of inspecting live source code, planning precise modifications, validating them in isolation, and deploying only verified changes.

What Makes IRIS Different

Feature Conventional Conversational Models IRIS Autonomous System
Operational Boundary Conventional models remain limited to a context-window sandbox and cannot alter runtime source files. IRIS performs dynamic source inspection and can directly modify local core Python modules.
Code Execution Conventional models use ephemeral, stateless execution or display-only Markdown. IRIS provides integrated OS runtime interfacing with PowerShell, Python, and disk I/O.
System Modification Conventional models have static weights and cannot optimize their execution logic. IRIS performs autonomous code mutation through sandboxed cloning, unit testing, and controlled hot deployment.
Decision Authority Conventional models rely on a single provider/model inference pipeline. IRIS uses a Multi-model AI Council with competitive consensus deadlines.
Failure Recovery Conventional models may hallucinate or terminate execution after internal code errors. IRIS detects latency spikes and errors, then generates isolated patch proposals.

Core Architecture

IRIS uses 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, IRIS executes its self-development pipeline:

  • Codebase Mapping: Recursively parses project ASTs to identify structural bottlenecks.
  • Deterministic Plan: Builds unified patch definitions using strict JSON schemas.
  • AST Validation: Compiles modules using AST parsers and py_compile before sandbox execution.

Execution Sandbox

core/sandbox.py

IRIS maintains runtime safety during self-modification:

  • Clones live repository state into an isolated workspace.
  • Applies file mutations only inside the sandbox boundary.
  • Runs IRISTestRunner test suites.
  • Drops the sandbox if verification fails, ensuring zero host impact.

Upgrade Manager

core/upgrade_manager.py

After successful testing, IRIS prepares a validated upgrade manifest:

  • Computes SHA-256 checksums for target files.
  • Maintains structured change logs and test audit artifacts.
  • Saves proposals under upgrade_proposals/proposal_*.json.
  • Sends mutations to the internal Approval Gate before live merging.

AI Council Consensus Engine

core/router.py

IRIS avoids dependence on a single AI provider:

  • Concurrently queries cloud LPUs such as Groq, Gemini, and private on-device local models.
  • Enforces sub-second competitive consensus deadlines.
  • Routes high-frequency interactions through low-latency LPUs.
  • Sends deep refactoring and complex analysis to analytical inference nodes.

Native Automation Registry

run_powershell / run_python

Sandboxed and host OS terminal command execution, process introspection, and shell scripting.

search_web / web_reader

Headless network access for live multi-source web querying, evidence extraction, and document scraping.

file_tool / document_tool

File-system engine for AST-level file creation, batch replacement, and .docx compilation.

excel_tool

Tabular compiler for spreadsheet creation, dataset generation, and computational audits.

memory.py

Persistent vector and disk-based multi-session episodic recall and developer preference indexing.

Key Engineering Milestones

Milestone 01

Closed-Loop Self-Repair Verification

IRIS has validated end-to-end autonomous optimization: detecting latency degradation, generating code patches, running isolated sandbox regression tests, and merging verified upgrades.

Milestone 02

Resilient Protocol Matching

IRIS uses punctuation-safe token normalization and multi-tier semantic gating to prevent cross-talk between rapid conversational streams and deep codebase mutations.

Milestone 03

Distributed Multi-Engine Deliberation

IRIS achieves sub-second consensus synthesis by routing tasks between remote cloud LPUs and on-device execution engines.

Project Credits

Lead Architect: Adarsh Dwivedi

AI Researcher & Software Systems Engineer behind IRIS architecture and development.