███╗   ██╗███████╗ ██████╗    ██████╗ ██████╗ ██████╗ ███████╗██████╗ 
 ████╗  ██║██╔════╝██╔═══██╗  ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
 ██╔██╗ ██║█████╗  ██║   ██║  ██║     ██║   ██║██║  ██║█████╗  ██████╔╝
 ██║╚██╗██║██╔══╝  ██║   ██║  ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗
 ██║ ╚████║███████╗╚██████╔╝  ╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║
 ╚═╝  ╚═══╝╚══════╝ ╚═════╝    ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝

** AI-Native Engineering Agent for Enterprise-Scale Codebase**

Installation • Quick Start • Features • Workflow Mode • Code Review • Configuration • MCP Server • LiveBench Leaderboard

Source: EPAM AI/RUN Engineering Benchmark

neoCoder supports multiple ways to connect to LLM APIs.

Direct connection to the official Anthropic API.

• Uses the ANTHROPIC_API_KEY environment variable
• Suitable for working with Claude models through the official endpoint

Connection through ZenMux — a unified API gateway that provides access to multiple LLM providers.

• Uses the ZENMUX_API_KEY environment variable
• Provides unified access to multiple LLM providers
• Acts as the default provider

You can also use your own compatible API endpoint.

You can also use your own compatible API endpoint.

neoCoder uses a multi-layer memory architecture instead of a flat chat history.

• Working Memory — active session context for the current task
• Adaptive Memory — dynamically tunes compression threshold and rolling window based on task type
• Context Compression — summarizes older turns when token pressure grows
• Hierarchical Memory — persistent cross-session storage of task results and artifacts
• Episodic Memory — stores completed tasks as reusable execution episodes
• Procedural Memory — learns reusable workflows and successful patterns
• Notes Storage — project notes and detailed markdown knowledge
• xMemory — hierarchical semantic memory with facts and themes
• Session Context — persists tech stack, brainstorming, plan, and progress in .neoCoder/context.md

1. On task start, neoCoder can retrieve relevant episodes, procedures, notes, and semantic knowledge.
2. During execution, it keeps active context in working memory.
3. When the context grows too large, it compresses older messages into structured summaries.
4. After completion, it stores outcomes in persistent memory and creates reusable episodes.

This architecture makes neoCoder better at:

• long-horizon engineering tasks,
• cross-session continuity,
• token-efficient context management,
• reusing prior project experience,
• structured planning and workflow persistence.

pipx install neocoder

uv tool install neocoder

# Clone and install
cd neoCoder
pip install -e .

# With development dependencies
pip install -e ".[dev]"

# With MCP server support
pip install -e ".[mcp]"

neocoder \init-config          # Create example configuration

set ANTHROPIC_API_KEY=your-key
set ZENMUX_API_KEY=your-key

$env:ANTHROPIC_API_KEY="your-key"
$env:ZENMUX_API_KEY="your-key"

export ANTHROPIC_API_KEY=your-key
export ZENMUX_API_KEY=your-key

# Interactive mode
neocoder

# Single task
neocoder "Create a Python hello world script"

# With options
neocoder --mode debug "Fix test_api.py"
neocoder --preset thorough "Refactor auth module"

The workflow preset is a production-grade, 8-stage development process with brainstorming, detailed planning, testing, and code review - designed for complex engineering tasks.

neocoder --preset workflow "your complex task"

8-Stage Engineering Pipeline:

Key Features:

• 🔄 Stateful execution - Resume interrupted workflows
• 📊 Extended context - 16K tokens, 250 iterations
• 🎯 Deterministic - Temperature 0.0 for consistency
• 🔍 Quality gates - Automatic testing and code review
• 📝 Conventional commits - Auto-generated commit messages

Example Usage:

# Start a complex feature
neocoder --preset workflow "Add OAuth2 authentication with JWT tokens"

# Resume if interrupted (state is saved)
neocoder --preset workflow "Add OAuth2 authentication with JWT tokens"
# Prompt: Continue from previous state? (y/n)

# Reset workflow state
neocoder workflow reset

neocoder "Design a full-stack web application for a cryptocurrency trading bot dashboard.
The application should allow users to monitor their bot's performance in real-time, including current holdings, profit/loss, open trades, and historical performance data visualized through interactive charts.
Users should be able to configure trading parameters, such as risk tolerance, stop-loss levels, and take-profit targets, through an intuitive interface.
The application should feature secure authentication and authorization, protecting user data and trading credentials.
The backend should be built using Node.js with Express.js, utilizing a PostgreSQL database for data persistence.
The frontend should be built using React, with a clean and modern design emphasizing data visualization and ease of use.
The application should include robust error handling and logging capabilities.
The deployment should be considered, suggesting a suitable cloud platform and deployment strategy.
Provide the complete codebase, including frontend, backend, and database schema, ready for deployment.
The application should be named 'LovableBotDashboard'"

When to use Workflow Preset:

• ✅ Complex features requiring multiple files
• ✅ Refactoring with extensive testing
• ✅ Production-critical changes
• ✅ Team projects with code review requirements
• ❌ Quick fixes or single-file changes (use default mode)

# Fast mode - Quick iterations
neocoder --preset fast "Fix the login bug"

# Thorough mode - Extended analysis
neocoder --preset thorough "Refactor auth module"

neocoder --preset workflow "your task"    # Run with workflow preset
neocoder workflow status                   # Check workflow status
neocoder workflow reset                    # Reset workflow state

💡 Use backslash \ for system commands

neocoder \init-config    # Create configuration
neocoder \help           # Show system commands  
neocoder \version        # Show version

Use --confirm (-c) flag to require manual approval before each file modification:

neocoder --confirm "create a new module"
neocoder -c "refactor auth system"

Confirmation dialog options:

In interactive mode, use :: commands for quick actions:

Built-in commands:

Configuration files are stored in ~/.neoCoder/:

~/.neoCoder/
├── 📄 settings.json        # Agent configuration
├── 📄 models.json          # Model definitions
├── 📄 tool_selection.json  # Tool selection settings
└── 📁 notes/               # Persistent notes from sessions

• 🔒 Security: Hardcoded secrets, SQL injection, eval/exec, insecure YAML, debug flags
• 🐛 Syntax: Parse errors (Python AST), brace/bracket balance (JS/TS)
• 📊 Complexity: Cyclomatic complexity, nesting depth
• 🎨 Style: Code duplication, dead code / unused imports
• 🏷️ Types: Missing type hints (Python), any usage (TypeScript)

Example Output:

✓ Code Review: Score 85/100, 2 issue(s)
[critical] No Anti-Patterns (line 45): God Object: Class 'UserManager' has 25 methods (>20)
  → Fix: Split into smaller, focused classes (Single Responsibility Principle)

Configuration: Code review rules can be customized in .neoCoder/code_review_config.json

Run neoCoder as an MCP server for Claude Code:

neocoder-mcp
# or
python -m neoCoder.mcp.server

Add to your Claude Code MCP settings (claude_desktop_config.json or via claude mcp add):

{
  "mcpServers": {
    "neocoder": {
      "command": "python",
      "args": [
        "-m",
        "neoCoder.mcp.server"
      ],
      "env": {}
    }
  }
}

Or using the CLI:

claude mcp add neocoder -- python -m neoCoder.mcp.server

With uv (recommended):

claude mcp add neocoder -- uv run --directory /path/to/neoCoder python -m neoCoder.mcp.server

**Made with ❤️ for developers**