@nextsystems/oac
Advanced tools
AI agent framework for plan-first development workflows with approval-based execution. Multi-language support for TypeScript, Python, Go, Rust and more.
Multi-language support: TypeScript • Python • Go • Rust
Features: Automatic testing • Code review • Validation
🚀 Quick Start • 📖 Documentation • 🎥 Demo Video • 💬 Community
AI agents burn through thousands of tokens generating code that doesn't match your project, doesn't follow your patterns, and doesn't actually work without heavy refactoring.
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.
The solution: AOC 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: code that actually ships to production without heavy rework.
This isn't a gimmick project. It's built for shipping real production code. It works because it respects two things:
The result: Production-ready code, not throwaway prototypes. No rework. No refactoring. Just ship.
Full-stack development: AOC handles both frontend and backend work. No need for separate developers—the agents coordinate to build complete features from UI to database.
AOC is a framework for AI-assisted development that puts you in control through editable agent behavior and approval-based workflows.
Core Philosophy:
The Key Difference: Unlike plugin-based systems where agent behavior is baked into code, AOC agents are transparent markdown files you can edit. Change how they think, add project rules, customize for your workflow.
Comparing with Oh My OpenCode? Read the detailed comparison →
How it works: Agents load your patterns from .opencode/context/, propose plans, wait for approval, then execute incrementally with validation at each step.
~/.opencode/agent/)~/.opencode/context/ (your secret weapon!)One command. That's it.
# Quick install (developer profile)
curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer
Or use interactive installer:
# Download the installer
curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
# Run interactively
bash install.sh
Then start building:
opencode --agent OpenAgent
> "Create a user authentication system"
What happens:
That's the entire workflow. No complex setup. No configuration. Just ship code.
Out of the box, OpenAgentsControl uses your OpenCode default model for all agents.
Want to customize? You can configure different models per agent. See Model Configuration below.
Start with OpenAgent - a lightweight, versatile agent perfect for getting started. It handles multiple task types and is ideal for learning the system.
opencode --agent OpenAgent
> "Create a user authentication system" # Building features
> "How do I implement authentication in Next.js?" # Questions
> "Create a README for this project" # Documentation
> "Explain the architecture of this codebase" # Analysis
OpenAgent is a streamlined version that can handle most tasks while you learn the workflow. It automatically delegates to specialists when needed.
Ready for advanced workflows? Upgrade to OpenCoder:
opencode --agent OpenCoder
> "Create a user authentication system" # Full-stack features
> "Refactor this codebase to use dependency injection" # Multi-file refactoring
> "Add real-time notifications with WebSockets" # Complex implementations
OpenCoder is the full-featured development agent with rigorous workflows: Discover context → Propose plan → Get approval → Execute incrementally → Validate → Ship. It provides deeper context management, session tracking, and more sophisticated delegation to specialists (TaskManager, TestEngineer, CodeReviewer).
Learn more:
After installation, follow these steps to get the most out of AOC:
opencode --agent OpenAgent and try a simple task~/.opencode/context/project/project-context.md (created during installation) with your coding standardsopencode --agent OpenCoder~/.opencode/agent/core/opencoder.md to add project rulesMost users only need steps 1-3 to be productive.
Recommended: One-line install
curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer
Alternative: Interactive installer
curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
bash install.sh
Manual install
git clone https://github.com/darrenhinde/OpenAgentsControl.git
cd OpenAgentsControl
mkdir -p ~/.opencode
cp -r .opencode/agent ~/.opencode/
cp -r .opencode/command ~/.opencode/
cp -r .opencode/context ~/.opencode/
opencode --agent OpenAgent
> "Create a user authentication system"
Join the community and stay updated with the latest AI development workflows!
📺 Tutorials & Demos • 💬 Join Waitlist • 🐦 Latest Updates • ☕ Support Development
Your support helps keep this project free and open-source!
Q: Does this work on Windows?
A: Yes! Use Git Bash (recommended) or WSL. See Platform Compatibility Guide for details.
Q: What bash version do I need?
A: Bash 3.2+ (works on macOS default bash). Run bash scripts/tests/test-compatibility.sh to check your system.
Q: Do I need to install plugins/tools?
A: No, they're optional. Only install if you want Telegram notifications or Gemini AI features.
Q: Where should I install - globally or per-project?
A: Global (~/.opencode/) works for most. Project-specific (.opencode/) if you need different configs per project.
Q: How do I add my own coding patterns?
A: Edit ~/.opencode/context/project/project-context.md - agents automatically load this file.
Q: What languages are supported?
A: The agents work with any language (TypeScript, Python, Go, Rust, etc.) and adapt based on your project files.
By default, all agents use your OpenCode default model. Configure models per agent only if you want different agents to use different models.
OpenAgentsControl is model-agnostic - you can use any AI model from any provider. Configure models using the model: tag in agent files.
You DON'T need to configure if:
Configure models when:
Use the format: provider/model-id
---
model: anthropic/claude-sonnet-4-5
---
Browse all available models at models.dev - search for "open" to see OpenCode-compatible models.
| Provider | Example Model ID | Format |
|---|---|---|
| Anthropic | claude-sonnet-4-5 | anthropic/claude-sonnet-4-5 |
| OpenAI | gpt-5.2 | openai/gpt-5.2 |
gemini-2.0-flash | google/gemini-2.0-flash | |
| OpenRouter | claude-opus-4 | openrouter/anthropic/claude-opus-4 |
| OpenCode | gpt-5-nano | opencode/gpt-5-nano |
| Ollama | qwen3 | ollama/qwen3 |
Option 1: Edit Agent Files Directly
# Edit the main agent
nano ~/.opencode/agent/core/opencoder.md
Change the model in the frontmatter:
---
description: "Development specialist"
model: anthropic/claude-sonnet-4-5 # Change this line
---
Option 2: Per-Project Configuration
Create a project-specific agent override:
# Create project .opencode directory
mkdir -p .opencode/agent/core
# Copy and modify agent
cp ~/.opencode/agent/core/opencoder.md .opencode/agent/core/opencoder.md
nano .opencode/agent/core/opencoder.md
Option 3: Global Default (OpenCode Config)
Set your default model in OpenCode's config:
nano ~/.config/opencode/opencode.json
{
"model": "anthropic/claude-sonnet-4-5"
}
Use Claude Sonnet for main agent:
---
model: anthropic/claude-sonnet-4-5
---
Use OpenAI GPT for main agent:
---
model: openai/gpt-5.2
---
Use Gemini Flash for fast tasks:
---
model: google/gemini-2.0-flash
---
Use OpenRouter for Claude Opus:
---
model: openrouter/anthropic/claude-opus-4
---
Use local Ollama model:
---
model: ollama/qwen3
---
Quick Recommendations:
Advanced: Subagents can use lighter models (Haiku/Flash) for speed, except TestEngineer and CodeReviewer which need reasoning models.
Run this command to see all models available in your environment:
opencode models
OpenAgentsControl supports model-specific prompt variants for optimal performance:
.opencode/agent/core/
├── opencoder.md # Default prompt
├── opencoder.gemini.md # Gemini-optimized
├── opencoder.grok.md # Grok-optimized
└── opencoder.llama.md # Llama-optimized
Create a variant by copying the base agent and adding .{model}.md:
cp ~/.opencode/agent/core/opencoder.md ~/.opencode/agent/core/opencoder.gemini.md
nano ~/.opencode/agent/core/opencoder.gemini.md
# Optimize prompt for Gemini's strengths
Q: Model not found error?
A: Run opencode models to see all 226+ available models. Make sure you're using the correct provider/model-id format.
Q: How do I use OpenRouter models?
A: Use format openrouter/provider/model-id, e.g., openrouter/anthropic/claude-opus-4
Q: Can I use different models for different agents?
A: Yes! Each agent file can specify its own model. Edit the model: tag in each agent's frontmatter.
Q: What if I don't specify a model?
A: OpenCode uses your default model from ~/.config/opencode/opencode.json
Q: Where can I see all available models?
A: Visit models.dev or run opencode models in your terminal
Agents are markdown files with YAML frontmatter. Edit them to change behavior, add project rules, or customize for your workflow.
Edit an agent:
nano ~/.opencode/agent/core/opencoder.md
Add project-specific rules:
## Project Rules
- Always use TypeScript strict mode
- Prefer functional components in React
- Use Tailwind for styling (no CSS modules)
Customize tech stack:
## Tech Stack
- Framework: Next.js 14 (App Router)
- Database: PostgreSQL with Drizzle ORM
- Auth: Better Auth
- Styling: Tailwind + shadcn/ui
Change communication style:
## Communication Style
- Be concise and direct
- Focus on practical solutions
- Always explain trade-offs
Override agents for specific projects:
# Create project-specific agent
mkdir -p .opencode/agent/core
cp ~/.opencode/agent/core/opencoder.md .opencode/agent/core/opencoder.md
nano .opencode/agent/core/opencoder.md
Project agents override global agents automatically.
User Request
↓
┌───────────────────────────────────────┐
│ Main Agents (User-Facing) │
├───────────────────────────────────────┤
│ openagent │ General tasks │
│ opencoder │ Complex coding │
│ system-builder│ AI system generation │
└───────────────────────────────────────┘
↓
┌───────────────────────────────────────┐
│ Specialized Subagents │
├───────────────────────────────────────┤
│ Core: task-manager, docs │
│ Code: coder, tester, reviewer│
│ Utils: image-specialist │
│ Meta: domain-analyzer, etc. │
└───────────────────────────────────────┘
The workflow:
Context-aware: Agents automatically load patterns from .opencode/context/ to follow your coding standards.
Smart discovery: ContextScout finds relevant standards, ExternalScout fetches current library docs (preventing outdated training data issues). ExternalScout supports 18+ libraries including Drizzle, Better Auth, Next.js, TanStack, Cloudflare Workers, AWS Lambda, and more.
Context files are your project's coding standards and patterns. They tell agents how you write code, what libraries you use, your security requirements, and your design system.
Think of it as a style guide for AI agents.
Your Request
↓
Agent receives request
↓
ContextScout discovers relevant context files
↓
Agent loads context files
↓
Agent follows patterns from context
↓
Code matches your standards automatically
Without context: You ask for a component → Agent creates it in its own style → Doesn't match your project ❌
With context: You ask for a component → Agent loads your patterns → Creates component matching your style → Perfectly matches your project ✅
~/.opencode/context/project/project-context.mdFor a complete guide including real-world examples and best practices, see The Context System Guide.
/commit - Smart git commits with conventional format/test - Testing workflows/optimize - Code optimization/context - Context managementYour coding standards automatically loaded by agents:
opencode --agent OpenCoder
> "Create a user dashboard with authentication and profile settings"
# OpenCoder will:
# 1. Discover context (loads your auth patterns, code standards)
# 2. Propose detailed implementation plan
# 3. Wait for your approval
# 4. Initialize session and persist context
# 5. Delegate to task-manager (creates atomic task breakdown)
# - task-manager identifies UI and backend tasks
# - Suggests frontend-specialist for UI work
# - Includes design standards in context
# 6. Frontend specialist executes 4-stage workflow:
# - Stage 1: Layout (ASCII wireframe, responsive structure)
# - Stage 2: Theme (design system, CSS theme file)
# - Stage 3: Animation (micro-interactions, timing)
# - Stage 4: Implementation (single HTML file, design_iterations/)
# 7. Execute full-stack implementation (frontend + backend)
# 8. Delegate to tester for tests and reviewer for security
# 9. Validate and handoff production-ready code
opencode --agent OpenCoder
> "Create a user authentication system with email/password"
# OpenCoder will:
# 1. Discover context (loads auth-patterns.md, code-quality.md)
# 2. Propose implementation plan with component breakdown
# 3. Wait for your approval
# 4. Initialize session (.tmp/sessions/YYYY-MM-DD-auth-system/)
# 5. Delegate to task-manager for atomic task breakdown
# 6. Execute incrementally (one component at a time)
# 7. Validate after each step (type check, lint, test)
# 8. Delegate to tester and reviewer
# 9. Ship production-ready code
# Make your changes
git add .
# Use the commit command
/commit
# Auto-generates: ✨ feat: add user authentication system
# Edit your project context
nano ~/.opencode/context/project/project-context.md
# Add your patterns:
# **API Endpoint Pattern:**
# ```typescript
# export async function POST(request: Request) {
# // Your standard pattern
# }
# ```
# Agents will automatically use these patterns!
The following sections provide detailed information about advanced features. New users can skip to Advanced Features FAQ and return to these as needed.
The OpenFrontendSpecialist follows a structured 4-stage design workflow for UI-heavy features:
4-Stage Process:
design_iterations/Key Features:
design_1.html, design_1_1.html, design_2.html)Learn more: Frontend Design Workflow Guide
The TaskManager breaks complex features into atomic, verifiable subtasks with smart agent suggestions and parallel execution support.
Key Capabilities:
depends_onWorkflow:
Learn more: Task Management Guide
Build complete custom AI systems tailored to your domain in minutes.
The System Builder is an interactive tool that generates complete .opencode architectures customized to your needs.
# Install advanced profile (includes system builder)
curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s advanced
# Run the interactive builder
/build-context-system
$ /build-context-system
Domain: E-commerce Operations
Purpose: Automate order processing and customer support
# After answering questions, generates:
# - ecommerce-orchestrator (main agent)
# - order-processor, ticket-router, report-generator (subagents)
# - 12 context files (domain knowledge, processes, standards)
# - 5 workflows (process-order, route-ticket, etc.)
# - 5 custom commands (/process-order, /route-ticket, etc.)
# - Complete documentation
Learn more: System Builder Documentation
Q: What's the main way to use this?
A: Use opencode --agent OpenCoder for building features and production code. For general questions, documentation, or simple tasks, use opencode --agent OpenAgent. Both coordinate with specialists as needed.
Q: How does OpenAgentsControl compare to Oh My OpenCode?
A: Read the detailed comparison →
| Feature | AOC | Oh My OpenCode |
|---|---|---|
| Agent Behavior | Editable markdown files | Baked into code |
| Execution | Approval gates | Autonomous loops |
| Token Efficiency | High (context-aware) | Lower (more exploration) |
| Best For | Control & repeatability | Autonomy & parallelization |
Choose based on your workflow: control & repeatability (AOC) vs. autonomy & parallelization (Oh My OpenCode).
Q: What's the Agent System Blueprint for?
A: It's a teaching document explaining architecture patterns and how to extend the system. See docs/features/agent-system-blueprint.md
Q: How does the frontend design workflow work?
A: The frontend-specialist agent follows a 4-stage workflow: Layout (wireframe) → Theme (design system) → Animation (micro-interactions) → Implementation (HTML). Each stage has approval gates. See the Frontend Design Workflow section above.
Q: What's ExternalScout?
A: ExternalScout fetches current documentation for external libraries (Tailwind, React, etc.) to prevent outdated training data issues. ContextScout uses it automatically when needed.
Q: How does task-manager suggest agents?
A: The task-manager analyzes each task and sets a suggested_agent field. For UI tasks, it suggests frontend-specialist and includes design context files automatically.
Q: Can I use just one command or agent?
A: Yes! Use the installer's list feature to see all components:
./install.sh --list
Or cherry-pick individual files with curl:
# Create category directory first
mkdir -p ~/.opencode/agent/core
# Download specific agent
curl -o ~/.opencode/agent/core/opencoder.md \
https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/.opencode/agent/core/opencoder.md
We welcome contributions! Please see our Contributing Guide for details.
See also: Code of Conduct
This project is licensed under the MIT License.
Made with ❤️ by developers, for developers. Star the repo if this helped you ship better code!
FAQs
AI agent framework for plan-first development workflows with approval-based execution. Multi-language support for TypeScript, Python, Go, Rust and more.
We found that @nextsystems/oac demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
TC39’s March 2026 meeting advanced eight ECMAScript proposals, including Temporal reaching Stage 4 and securing its place in the ECMAScript 2026 specification.
Research
/Security News
Since January 31, 2026, we identified at least 72 additional malicious Open VSX extensions, including transitive GlassWorm loader extensions targeting developers.
Research
Six malicious Packagist packages posing as OphimCMS themes contain trojanized jQuery that exfiltrates URLs, injects ads, and loads FUNNULL-linked redirects.