<div align="center">

OpenAgents Control (OAC)

Control your AI patterns. Get repeatable results.

AI agents that learn YOUR coding patterns and generate matching code every time.

🎯 Pattern Control - Define your patterns once, AI uses them forever
✋ Approval Gates - Review and approve before execution
🔁 Repeatable Results - Same patterns = Same quality code
📝 Editable Agents - Full control over AI behavior
👥 Team-Ready - Everyone uses the same patterns

Multi-language: TypeScript • Python • Go • Rust • C# • Any language*
Model Agnostic: Claude • GPT • Gemini • MiniMax • Local models

🚀 Quick Start • 💻 Show Me Code • 🗺️ Roadmap • 💬 Community

</div>

---

Built on OpenCode - An open-source AI coding framework. OAC extends OpenCode with specialized agents, context management, and team workflows.

---

The Problem

Most AI agents are like hiring a developer who doesn't know your codebase. They write generic code. You spend hours rewriting, refactoring, and fixing inconsistencies. Tokens burned. Time wasted. No actual work done.

Example:

// What AI gives you (generic)
export async function POST(request: Request) {
  const data = await request.json();
  return Response.json({ success: true });
}

// What you actually need (your patterns)
export async function POST(request: Request) {
  const body = await request.json();
  const validated = UserSchema.parse(body);  // Your Zod validation
  const result = await db.users.create(validated);  // Your Drizzle ORM
  return Response.json(result, { status: 201 });  // Your response format
}

The Solution

OpenAgentsControl teaches agents your patterns upfront. They understand your coding standards, your architecture, your security requirements. They propose plans before implementing. They execute incrementally with validation.

The result: Production-ready code that ships without heavy rework.

What Makes OAC Different

🎯 Context-Aware (Your Secret Weapon)
Agents load YOUR patterns before generating code. Code matches your project from the start. No refactoring needed.

📝 Editable Agents (Not Baked-In Plugins)
Full control over agent behavior. Edit markdown files directly—no compilation, no vendor lock-in. Change workflows, add constraints, customize for your team.

✋ Approval Gates (Human-Guided AI)
Agents ALWAYS request approval before execution. Propose → Approve → Execute. You stay in control. No "oh no, what did the AI just do?" moments.

⚡ Token Efficient (MVI Principle)
Minimal Viable Information design. Only load what's needed, when it's needed. Context files <200 lines, lazy loading, faster responses.

👥 Team-Ready (Repeatable Patterns)
Store YOUR coding patterns once. Entire team uses same standards. Commit context to repo. New developers inherit team patterns automatically.

🔄 Model Agnostic
Use any AI model (Claude, GPT, Gemini, local). No vendor lock-in.

Full-stack development: OAC handles both frontend and backend work. The agents coordinate to build complete features from UI to database.

---

🆚 Quick Comparison

| Feature | OpenAgentsControl | Cursor/Copilot | Aider | Oh My OpenCode | |---------|-------------------|----------------|-------|----------------| | Learn Your Patterns | ✅ Built-in context system | ❌ No pattern learning | ❌ No pattern learning | ⚠️ Manual setup | | Approval Gates | ✅ Always required | ⚠️ Optional (default off) | ❌ Auto-executes | ❌ Fully autonomous | | Token Efficiency | ✅ MVI principle (80% reduction) | ❌ Full context loaded | ❌ Full context loaded | ❌ High token usage | | Team Standards | ✅ Shared context files | ❌ Per-user settings | ❌ No team support | ⚠️ Manual config per user | | Edit Agent Behavior | ✅ Markdown files you edit | ❌ Proprietary/baked-in | ⚠️ Limited prompts | ✅ Config files | | Model Choice | ✅ Any model, any provider | ⚠️ Limited options | ⚠️ OpenAI/Claude only | ✅ Multiple models | | Execution Speed | ⚠️ Sequential with approval | Fast | Fast | ✅ Parallel agents | | Error Recovery | ✅ Human-guided validation | ⚠️ Auto-retry (can loop) | ⚠️ Auto-retry | ✅ Self-correcting | | Best For | Production code, teams | Quick prototypes | Solo developers | Power users, complex projects |

Use OAC when:

• ✅ You have established coding patterns
• ✅ You want code that ships without refactoring
• ✅ You need approval gates for quality control
• ✅ You care about token efficiency and costs

Use others when:

• Cursor/Copilot: Quick prototypes, don't care about patterns
• Aider: Simple file edits, no team coordination
• Oh My OpenCode: Need autonomous execution with parallel agents (speed over control)

Full comparison: Read detailed analysis →

---

🚀 Quick Start

Prerequisites: OpenCode CLI (free, open-source) • Bash 3.2+ • Git

Step 1: Install

One command:

curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer

_{The installer will set up OpenCode CLI if you don't have it yet.}

Or interactive:

curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
bash install.sh

Keep Updated

curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/update.sh | bash

Use --install-dir PATH if you installed to a custom location (e.g. ~/.config/opencode).

Step 2: Start Building

opencode --agent OpenAgent
> "Create a user authentication system"

Step 3: Approve & Ship

What happens:

1. Agent analyzes your request
2. Proposes a plan (you approve)
3. Executes step-by-step with validation
4. Delegates to specialists when needed
5. Ships production-ready code

That's it. Works immediately with your default model. No configuration required.

---

Alternative: Claude Code Plugin (BETA)

Prefer Claude Code? OpenAgents Control is also available as a Claude Code plugin!

Installation:

1. Register the marketplace:

/plugin marketplace add darrenhinde/OpenAgentsControl

2. Install the plugin:

/plugin install oac

3. Download context files:

/oac:setup --core

4. Start building:

Add a login endpoint

Features:

• ✅ 6-stage workflow with approval gates
• ✅ Context-aware code generation
• ✅ 7 specialized subagents (task-manager, context-scout, context-manager, coder-agent, test-engineer, code-reviewer, external-scout)
• ✅ 9 workflow skills + 6 user commands
• ✅ Flexible context discovery (.oac config, .claude/context, context, .opencode/context)
• ✅ Add context from GitHub, worktrees, local files, or URLs
• ✅ Easy feature planning with /oac:plan

Documentation:

• Plugin README - Complete plugin documentation
• First-Time Setup - Step-by-step guide
• Quick Start - Quick reference

Status: BETA - Actively tested and ready for early adopters

---

💡 The Context System: Your Secret Weapon

The problem with AI code: It doesn't match your patterns. You spend hours refactoring.

The OAC solution: Teach your patterns once. Agents load them automatically. Code matches from the start.

How It Works

Your Request
    ↓
ContextScout discovers relevant patterns
    ↓
Agent loads YOUR standards
    ↓
Code generated using YOUR patterns
    ↓
Ships without refactoring ✅

Add Your Patterns (10-15 Minutes)

/add-context

Answer 6 simple questions:

1. What's your tech stack? (Next.js + TypeScript + PostgreSQL + Tailwind)
2. Show an API endpoint example (paste your code)
3. Show a component example (paste your code)
4. What naming conventions? (kebab-case, PascalCase, camelCase)
5. Any code standards? (TypeScript strict, Zod validation, etc.)
6. Any security requirements? (validate input, parameterized queries, etc.)

Result: Agents now generate code matching your exact patterns. No refactoring needed.

The MVI Advantage: Token Efficiency

MVI (Minimal Viable Information) = Only load what's needed, when it's needed.

Traditional approach:

• Loads entire codebase context
• Large token overhead per request
• Slow responses, high costs

OAC approach:

• Loads only relevant patterns
• Context files <200 lines (quick to load)
• Lazy loading (agents load what they need)
• 80% of tasks use isolation context (minimal overhead)

Real benefits:

• Efficiency: Lower token usage vs loading entire codebase
• Speed: Faster responses with smaller context
• Quality: Code matches your patterns (no refactoring)

For Teams: Repeatable Patterns

The team problem: Every developer writes code differently. Inconsistent patterns. Hard to maintain.

The OAC solution: Store team patterns in `.opencode/co