AIDOCS

The orchestration layer for AI coding agents — persistent memory, conductor, dashboard, and multi-agent workflows.

A CodeNexus project

Supported Agents

Hooks + MCP + Dashboard Full orchestration

Plugin + MCP + Serve mode Full orchestration

MCP + CLI conductor Full orchestration

Via .mcp.json Tools + memory

What It Does

AIDOCS is the orchestration layer that makes AI coding agents smarter without replacing them. It works with Claude Code, Codex, OpenCode, Cursor, and any MCP-compatible host.

• Persistent memory — agents resume work instead of rediscovering your repo every time
• Conductor — long-lived orchestrator that dispatches tasks, manages lane agents, resolves conflicts
• Dashboard — desktop app to monitor, control, and configure everything (no terminal needed)
• Indexed retrieval — code search by symbol, meaning, or relationship instead of blind grep
• Security gates — heuristic judge, output guard, tool policies, RBAC
• Multi-agent routing — assign the right model to the right task (Claude for code, GPT for refactoring, Gemini for docs)
• Zero migration — works as an overlay on your existing tools, no framework lock-in

Product Surfaces

• MCP Runtime — 120+ tools: indexing, retrieval, orchestration, conductor, security gates
• Dashboard — Tauri desktop app: conductor chat, monitoring, settings, task routing, setup wizard
• CLI — aidocs setup, doctor, init, status, sync, benchmark
• Host Adapters — Claude Code hooks, OpenCode plugin, Codex CLI, generic MCP

Key Capabilities

• Conductor — long-lived agent that manages tasks, dispatches lane agents, routes models per task type
• Dashboard control — start/stop/pause agents, send tasks, see live output, no terminal needed
• Persistent memory — routed session startup, journal, plans, handoffs across conversations
• Semantic search — embedding-based code search (local model, no API) + symbol/text search
• Security gates — heuristic judge, output guard, tool policies, RBAC, lane isolation
• Task routing — assign Claude for implementation, GPT for refactoring, Gemini for docs
• Conductor comms — agents ask conductor questions, auto-resolve scope conflicts, pause/resume lanes
• Edit history — diff-based rollback with agent/lane attribution

Quick Start

Windows

Download AIDOCS-Setup.exe from Releases. Includes Python, setup wizard, and dashboard. Double-click and go.

Linux/macOS

One command, installs Python + AIDOCS:

curl -fsSL https://raw.githubusercontent.com/cristian1991/AIDOCS/main/core/scripts/install.sh | bash

Already have Python 3.11+?

pip install aidocs-mcp        # install the package
aidocs setup                  # configures everything: MCP, hooks, project init
aidocs doctor                 # verify the install

Then

Open your project in any supported IDE and type /aidocs to activate managed mode.

Project Layout

aidocs.toml                  # Runtime configuration (static definitions)
action_tokens/               # Prompt-classification language files (en, it, ...)

core/
  .commands/                  # Slash commands (/aidocs, /reingest, /archive, etc.)
  hooks/                      # Hook definitions (hooks.json)
  plugins/                    # OpenCode plugin (aidocs.js)
  scripts/                    # Install scripts (install.sh, install.ps1)

mcp/
  server/aidocs_mcp/          # Python MCP server, CLI, and all runtime services
    tests/                      # 1308 tests

apps/aidocs-dashboard/
  src/                        # React frontend (TypeScript)
  src-tauri/                  # Rust backend (Tauri)

Memory Model

Inside initialized projects, memory lives in /.MEMORY/:

/.MEMORY/
  .aidocs/index.aidocs       -> session-start router
  INDEX.md                    -> durable-memory router
  sessions/<id>/
    SESSION.md                -> session state + scope
    context.md                -> session-local context
    journal.md                -> rolling decision log (auto-evicts to archive)
    plans/                    -> implementation plans
    agents/                   -> spawned agent artifacts
  rules/                      -> workflow, coding, communication rules
  domains/                    -> domain knowledge
  archive/                    -> evicted journal entries, completed sessions

Commands

Configuration

Advanced Features

Beyond the quick-start flow, AIDOCS ships:

• Conductor modes — inline (single agent) or parallel (multi-agent with lane isolation)
• Conductor comms — agents ask questions, conductor auto-resolves scope conflicts, operators inject guidance via dashboard
• Task routing — per-task-type model assignment (configurable from dashboard)
• Session handoffs — resume bundles for continuing work across conversations
• Plan execution — deterministic plan creation, dispatch, verification, completion tracking
• Semantic search — embedding-based code search with local model (optional: pip install sentence-transformers)
• Skills — bundled behavior packs (deep-retrieval, test-driven-validation, systematic-debugging, brainstorming, caveman)
• Deferred tool loading — 50 eager tools, 70+ discovered on demand via keywords
• Extensible indexing — custom language descriptors for any file format
• Related-project search — cross-repo comparison when configured

Host Support

Documentation

• Developer README — deeper architecture, settings, host boundaries, and flaw-finding guide
• Install Guide — global routing, plugin, hook, MCP, and dashboard install paths
• MCP Runtime — runtime model, tool model, host caveats, CLI usage
• Host Integration — Claude/OpenCode contract and routing behavior
• Index Language Descriptors — TOML schema for built-in and project-local indexing descriptors
• Public Roadmap — what's coming in future versions
• Contributing — how to contribute language descriptors, host integrations, and more

Releases

| Version | Highlights |

Download from Releases.

License

Apache 2.0. See LICENSE and NOTICE.