AI Development Platform

The intelligence layer between you and your AI coding tools

Give it a task. It picks the best AI model, validates the output, and remembers what worked. Next time, it's smarter. Connect Claude, Codex, Gemini, and OpenCode through one MCP server that learns from every interaction.

Get Started → View on GitHub ↗

29MCP Tools

11Expert Types

5CLI Adapters

8Memory Backends

12Routing Stages

176+Papers Tracked

How It Works

Every task flows through analysis, intelligent routing, quality validation, and outcome recording. The system learns from each execution and improves over time.

Intelligent Routing

A 12-stage pipeline analyzes your task and picks the best AI model. LinUCB contextual bandits learn from real outcomes — routing gets smarter with every task you run.

Dynamic Expert Creation

11 expert types are created on demand based on task analysis. Each gets a specialized system prompt, routed to the best CLI, and coordinated by TechLead and Orchestrator agents.

Consensus Quality Gates

5 voting algorithms — including higher-order Bayesian aggregation — validate outputs before they ship. Agents vote, disagree, and iterate until quality passes.

Continuous Learning

8 memory backends persist what works across sessions. Outcomes feed routing decisions, failed approaches are avoided, and successful patterns are reinforced automatically.

Development Pipeline

Full workflow: research papers, plan architecture, vote on proposals, decompose into tasks, implement in parallel, QA review with iteration, security scan. Three modes: autonomous, harness, and dry-run.

Research Discovery

176+ papers tracked across 9 sources (arXiv, GitHub, Semantic Scholar). New discoveries auto-trigger pipeline assessments. Quality scoring and topic synthesis built in.

The Learning Loop

This is the core differentiator. Every execution makes the next one better.

  You give a task
       |
  Task Analysis → picks best model from 5 CLIs
       |
  Expert executes → 11 specialized types, created on demand
       |
  Consensus validates → multi-model voting catches errors
       |
  Outcome recorded → success/failure feeds 8 memory backends
       |
  Next task → routing is smarter, memory recalls what worked
       |
  Repeat → system improves continuously

Quick Start

Install and connect to your editor in under 5 minutes.

1. Install

# Install globally
pnpm install -g nexus-agents

# Verify
nexus-agents doctor

2. Connect to Claude Code

# Auto-configure MCP server
nexus-agents setup

# Or manually: ~/.claude/mcp.json
{
  "mcpServers": {
    "nexus-agents": {
      "command": "nexus-agents",
      "args": ["--mode=server"]
    }
  }
}

Architecture

MCP Protocol (29 tools, rate-limited, auth)
    |
Orchestrator (task analysis, dynamic expert creation)
    |
+--------+--------+--------+-----------+----------+
| Claude | Gemini | Codex  | Codex-MCP | OpenCode |
+--------+--------+--------+-----------+----------+
    |
Composite Router (12 stages)
  Budget → Capability → Preference → TOPSIS → LinUCB → Latency
    |                                                        |
+----------+-----------+----------+----------+    Outcome Store
| Consensus| Memory    | Pipeline | Security |    (feeds back)
| (5 algos) | (8 backends)| (3 modes)| (sandbox) |
+----------+-----------+----------+----------+