⚡ Ultracode

A MAKER-based autonomous feature engineering system

Ultracode is a production-grade autonomous software engineering system that plans, implements, validates, and commits complete software features using a structured multi-agent architecture.

Ultracode is inspired by the MAKER architecture and implements a general-purpose agent harness for reliable, auditable, and cost-aware AI-driven development.

Ultracode is not a chatbot.
It is an engineering system.

---

⚠️ Status: Alpha Testing

Ultracode is actively being developed and tested. While core functionality works reliably, some features may change. Use in production at your own discretion.

---

🎯 Why Ultracode?

✅ Easy-to-Use Interface

Intuitive UI with project management, feature tracking, and real-time execution monitoring. See screenshots below.

🧠 Multi-Agent Architecture for Reliability

Based on MAKER (Cognizant AI Lab), Ultracode eliminates the "hallucination problem" that plagues modern LLMs:

• Separation of concerns: Planning, execution, and voting are independent
• Error decorrelation: Multiple agents generate diverse solutions
• Structured voting: Consensus replaces blind generation
• Near-zero failure rates on long-running projects

💰 Cost-Effective & Flexible

• Use expensive models only for planning (Example: gpt-5.2 or opus-4.5)
• Cheaper models for coding: GPT-4o Mini, Gemini 2, or your local models
• Local model support: Run open models via LM Studio (GLM, Mistral, etc.) — zero API costs
• Full cost transparency: Real-time token breakdown per project

🔒 Reliable & Auditable

• Every decision is logged (event sourcing)
• Human-in-the-loop for risky operations
• Filesystem sandbox prevents accidental damage
• Git commits with full feature history

🚀 Feature-Based Development

• Organize work as features with dependencies
• Automatic task decomposition and prioritization
• Resume paused work without losing context

---

🔬 Research Background

Ultracode is directly inspired by:

MAKER: Multi-Agent Architecture for Knowledge-Driven Reasoning
Cognizant AI Lab (2024)
https://www.cognizant.com/us/en/ai-lab/blog/maker

From the MAKER paper, Ultracode adopts:

• Separation of planning, execution, and validation
• Explicit intermediate representations
• Error decorrelation via multiple samples
• Structured voting instead of blind generation
• Human-in-the-loop safety boundaries

Ultracode extends MAKER from task execution to a complete feature-based software engineering pipeline.

---

🧠 What Ultracode Is

Ultracode turns large language models into reliable engineering agents by embedding them inside a deterministic system with memory, validation, and control.

Core Idea

Project → Features (prioritized, dependency-aware) → Subtasks (atomic, executable) → Voting-based execution → Validation → Git commits

---

✨ Key Capabilities

🎯 Feature-Based Development

• Work is organized as features, not prompts
• Priorities: A / B / C
• Explicit dependencies and blocking rules

🧠 Structured Agent Roles

• Planner Agent — decomposes features into subtasks
• Executor Agent — generates concrete code and actions
• Voting / Verification Agent — selects safe, correct outputs

🗳 Voting & Quality Control

• Multi-sample generation with adaptive temperature
• First-to-lead-by-k voting strategy
• Prompt paraphrasing for error decorrelation
• Red-flag detection before execution

📊 Persistent System State

• SQLite (WAL mode) as single source of truth
• Projects, features, subtasks, events
• Full audit trail (event sourcing)

🔒 Safety by Design

• Filesystem sandboxing
• Command risk classification
• Human approval for risky actions
• No arbitrary code execution

🧪 Optional Automated Verification

• Auto-start dev servers (Node, PHP, static)
• Screenshot-based UI testing (Puppeteer)
• LLM-based verification against Definition of Done

📈 Cost & Token Transparency

• Token estimation and pricing per model
• Real-time project cost breakdown
• Zero cost for local models

---

🧩 Architecture Overview

┌────────────┐ │ Web UI │ (live SSE updates) └─────┬──────┘ ▼ ┌────────────┐ │ HTTP API │ └─────┬──────┘ ▼ ┌────────────┐ │ Feature │ │ Manager │ └─────┬──────┘ ▼ ┌────────────┐ │ Orchestrator│ │ (MAKER) │ └─────┬──────┘ ▼ ┌────────────┐ │ Voting │ │ Engine │ │ + RedFlags │ └─────┬──────┘ ▼ ┌────────────┐ │ LLM │ │ Registry │ └─────┬──────┘ ▼ ┌─────────────────────────────┐ │ OpenAI · Claude · Gemini │ │ Local Models (LM Studio) │ └─────────────────────────────┘

---

🗳 Voting & Verification Agents

Ultracode applies targeted voting at deterministic decision gates, following the MAKER philosophy.

Why Voting?

LLMs fail in correlated ways.
Voting combined with prompt paraphrasing breaks that correlation and improves reliability.

Decision Flow

Executor Outputs ↓ Red-Flag Filtering ↓ Vote Tally ↓ [ Approve | Retry | Fail | Human Review ]

Voting is applied to:

• Subtask execution
• Structured JSON outputs
• Ambiguous or risky operations

---

🧱 Core Components

• FeatureStore — SQLite persistence & event sourcing
• FeatureManager — dependency resolution & execution queue
• FeaturePlanner — LLM-based feature decomposition
• ContextBuilder — intelligent prompt assembly
• Orchestrator — MAKER-style execution engine
• VotingEngine — consensus selection & error filtering
• ProjectGuard — filesystem sandbox
• ExecutionGuard — command safety
• ResourceMonitor — token & cost tracking

---

🧙 Project Creation Wizard

Ultracode includes a structured 3-step project wizard:

1. Project Basics

   • Name and description
   • Folder creation & git init

2. AI-Guided Clarification

   • Architecture & stack
   • Data models & authentication
   • Non-functional requirements
   • Optional web research

3. Model Assignment

   • Planner model
   • Executor model
   • Voting model

Outputs:

• project.md (engineering specification)
• Feature list with Definition of Done
• init.sh for automated bootstrapping

---

🚀 Quick Start

Requirements

• Node.js ≥ 18
• At least one LLM provider (or LM Studio for local models)

Install

git clone https://github.com/tomgoeck/Ultracode.git
cd Ultracode
npm install

Configure

cp config.json.example data/config.json
# or
Run the application below and click on the settings button in the top right

Add API keys (the data/ directory is gitignored).

Run

node src/server.js
# or
PORT=4173 npm start

Open: http://localhost:4173

---

📸 Screenshots

Projects Dashboard

Feature Details & Execution

Terminal Output

Files Browser

Project Models Configuration

API Keys Settings

⸻

🧪 Feature Lifecycle

pending → running → completed → verified ↓ ↓ paused failed ↓ blocked (dependency)

Ultracode always knows what can run next — and why.

⸻

🧠 Why Ultracode Exists

Ultracode demonstrates that: • LLMs become reliable inside systems • Autonomous coding requires memory, structure, and validation • Voting beats prompt cleverness • MAKER-style architectures scale beyond research prototypes

This repository is both: • a usable engineering tool • a reference implementation of modern agent research

⸻

📜 License

MIT License

⸻

🙏 Acknowledgements • Cognizant AI Lab — MAKER architecture • OpenAI, Anthropic, Google • The autonomous agents research community

⸻

Ultracode — Autonomous engineering, grounded in systems, not prompts.