Skip to content
Back to search

oac-marketplace

MarketplaceWorks with Claude CodeGitHub

AI-powered development workflow automation - code review, testing, documentation, and task management for Claude Code

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/darrenhinde--openagentscontrol/badge.svg)](/listings/darrenhinde--openagentscontrol)

HTML

<a href="/listings/darrenhinde--openagentscontrol"><img src="/api/listings/darrenhinde--openagentscontrol/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

**Prerequisites:** [OpenCode CLI](https://opencode.ai/docs) (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

<sub>The installer will set up OpenCode CLI if you don't have it yet.</sub>

**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](./plugins/claude-code/README.md) - Complete plugin documentation - [First-Time Setup](./plugins/claude-code/FIRST-TIME-SETUP.md) - Step-by-step guide - [Quick Start](./plugins/claude-code/QUICK-START.md) - Quick reference

**Status:** BETA - Actively tested and ready for early adopters

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 29 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "oac-marketplace",
  3. "description": "AI-powered development workflow automation - code review, testing, documentation, and task management for Claude Code",
  4. "owner": {
  5. "name": "darrenhinde",
  6. "url": "https://github.com/darrenhinde/OpenAgentsControl"
  7. },
  8. "plugins": [
  9. {
  10. "name": "oac",
  11. "source": "./plugins/claude-code",
  12. "description": "Ship faster with AI-powered development workflows. Automates code review, test generation, documentation, and task breakdown. Context-aware agents understand your codebase and enforce your team's standards.",
  13. "version": "1.0.0",
  14. "author": {
  15. "name": "darrenhinde",
  16. "url": "https://github.com/darrenhinde"
  17. },
  18. "license": "MIT",
  19. "repository": "https://github.com/darrenhinde/OpenAgentsControl"
  20. }
  21. ],
  22. "categories": [
  23. {
  24. "name": "Development Tools",
  25. "description": "Tools for software development and automation",
  26. "plugins": ["oac"]
  27. }
  28. ]
  29. }
README.md · README · 826 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. > [!IMPORTANT]
  2. > **A full sweep of changes is coming soon.** Expect a new system. This version of OAC targets **OpenCode v1**; the upcoming release will replace much of what is here.
  3. <div align="center">
  4. ![OpenAgents Control Hero](docs/images/hero-image.png)
  5. # OpenAgents Control (OAC)
  6. ### Control your AI patterns. Get repeatable results.
  7. **AI agents that learn YOUR coding patterns and generate matching code every time.**
  8. 🎯 **Pattern Control** - Define your patterns once, AI uses them forever
  9. ✋ **Approval Gates** - Review and approve before execution
  10. 🔁 **Repeatable Results** - Same patterns = Same quality code
  11. 📝 **Editable Agents** - Full control over AI behavior
  12. 👥 **Team-Ready** - Everyone uses the same patterns
  13. **Multi-language:** TypeScript • Python • Go • Rust • C# • Any language*
  14. **Model Agnostic:** Claude • GPT • Gemini • MiniMax • Local models
  15. [![GitHub stars](https://img.shields.io/github/stars/darrenhinde/OpenAgentsControl?style=flat-square&logo=github&labelColor=black&color=ffcb47)](https://github.com/darrenhinde/OpenAgentsControl/stargazers)
  16. [![X Follow](https://img.shields.io/twitter/follow/DarrenBuildsAI?style=flat-square&logo=x&labelColor=black&color=1DA1F2)](https://x.com/DarrenBuildsAI)
  17. [![License: MIT](https://img.shields.io/badge/License-MIT-3fb950?style=flat-square&labelColor=black)](https://opensource.org/licenses/MIT)
  18. [![Last Commit](https://img.shields.io/github/last-commit/darrenhinde/OpenAgentsControl?style=flat-square&labelColor=black&color=8957e5)](https://github.com/darrenhinde/OpenAgentsControl/commits/main)
  19. [🚀 Quick Start](#-quick-start) • [💻 Show Me Code](#-example-workflow) • [🗺️ Roadmap](https://github.com/darrenhinde/OpenAgentsControl/projects) • [💬 Community](https://nextsystems.ai)
  20. </div>
  21. ---
  22. > **Built on [OpenCode](https://opencode.ai)** - An open-source AI coding framework. OAC extends OpenCode with specialized agents, context management, and team workflows.
  23. ---
  24. ## The Problem
  25. 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.
  26. **Example:**
  27. ```typescript
  28. // What AI gives you (generic)
  29. export async function POST(request: Request) {
  30. const data = await request.json();
  31. return Response.json({ success: true });
  32. }
  33. // What you actually need (your patterns)
  34. export async function POST(request: Request) {
  35. const body = await request.json();
  36. const validated = UserSchema.parse(body); // Your Zod validation
  37. const result = await db.users.create(validated); // Your Drizzle ORM
  38. return Response.json(result, { status: 201 }); // Your response format
  39. }
  40. ```
  41. ## The Solution
  42. **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.
  43. **The result:** Production-ready code that ships without heavy rework.
  44. ### What Makes OAC Different
  45. **🎯 Context-Aware (Your Secret Weapon)**
  46. Agents load YOUR patterns before generating code. Code matches your project from the start. No refactoring needed.
  47. **📝 Editable Agents (Not Baked-In Plugins)**
  48. Full control over agent behavior. Edit markdown files directly—no compilation, no vendor lock-in. Change workflows, add constraints, customize for your team.
  49. **✋ Approval Gates (Human-Guided AI)**
  50. Agents ALWAYS request approval before execution. Propose → Approve → Execute. You stay in control. No "oh no, what did the AI just do?" moments.
  51. **⚡ Token Efficient (MVI Principle)**
  52. Minimal Viable Information design. Only load what's needed, when it's needed. Context files <200 lines, lazy loading, faster responses.
  53. **👥 Team-Ready (Repeatable Patterns)**
  54. Store YOUR coding patterns once. Entire team uses same standards. Commit context to repo. New developers inherit team patterns automatically.
  55. **🔄 Model Agnostic**
  56. Use any AI model (Claude, GPT, Gemini, local). No vendor lock-in.
  57. **Full-stack development:** OAC handles both frontend and backend work. The agents coordinate to build complete features from UI to database.
  58. ---
  59. ## 🆚 Quick Comparison
  60. | Feature | OpenAgentsControl | Cursor/Copilot | Aider | Oh My OpenCode |
  61. |---------|-------------------|----------------|-------|----------------|
  62. | **Learn Your Patterns** | ✅ Built-in context system | ❌ No pattern learning | ❌ No pattern learning | ⚠️ Manual setup |
  63. | **Approval Gates** | ✅ Always required | ⚠️ Optional (default off) | ❌ Auto-executes | ❌ Fully autonomous |
  64. | **Token Efficiency** | ✅ MVI principle (80% reduction) | ❌ Full context loaded | ❌ Full context loaded | ❌ High token usage |
  65. | **Team Standards** | ✅ Shared context files | ❌ Per-user settings | ❌ No team support | ⚠️ Manual config per user |
  66. | **Edit Agent Behavior** | ✅ Markdown files you edit | ❌ Proprietary/baked-in | ⚠️ Limited prompts | ✅ Config files |
  67. | **Model Choice** | ✅ Any model, any provider | ⚠️ Limited options | ⚠️ OpenAI/Claude only | ✅ Multiple models |
  68. | **Execution Speed** | ⚠️ Sequential with approval | Fast | Fast | ✅ Parallel agents |
  69. | **Error Recovery** | ✅ Human-guided validation | ⚠️ Auto-retry (can loop) | ⚠️ Auto-retry | ✅ Self-correcting |
  70. | **Best For** | Production code, teams | Quick prototypes | Solo developers | Power users, complex projects |
  71. **Use OAC when:**
  72. - ✅ You have established coding patterns
  73. - ✅ You want code that ships without refactoring
  74. - ✅ You need approval gates for quality control
  75. - ✅ You care about token efficiency and costs
  76. **Use others when:**
  77. - **Cursor/Copilot:** Quick prototypes, don't care about patterns
  78. - **Aider:** Simple file edits, no team coordination
  79. - **Oh My OpenCode:** Need autonomous execution with parallel agents (speed over control)
  80. > **Full comparison:** [Read detailed analysis →](https://github.com/darrenhinde/OpenAgentsControl/discussions/116)
  81. ---
  82. ## 🚀 Quick Start
  83. **Prerequisites:** [OpenCode CLI](https://opencode.ai/docs) (free, open-source) • Bash 3.2+ • Git
  84. ### Step 1: Install
  85. **One command:**
  86. ```bash
  87. curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer
  88. ```
  89. <sub>The installer will set up OpenCode CLI if you don't have it yet.</sub>
  90. **Or interactive:**
  91. ```bash
  92. curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
  93. bash install.sh
  94. ```
  95. ### Keep Updated
  96. ```bash
  97. curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/update.sh | bash
  98. ```
  99. > Use `--install-dir PATH` if you installed to a custom location (e.g. `~/.config/opencode`).
  100. ### Step 2: Start Building
  101. ```bash
  102. opencode --agent OpenAgent
  103. > "Create a user authentication system"
  104. ```
  105. ### Step 3: Approve & Ship
  106. **What happens:**
  107. 1. Agent analyzes your request
  108. 2. Proposes a plan (you approve)
  109. 3. Executes step-by-step with validation
  110. 4. Delegates to specialists when needed
  111. 5. Ships production-ready code
  112. **That's it.** Works immediately with your default model. No configuration required.
  113. ---
  114. ### Alternative: Claude Code Plugin (BETA)
  115. **Prefer Claude Code?** OpenAgents Control is also available as a Claude Code plugin!
  116. **Installation:**
  117. 1. Register the marketplace:
  118. ```bash
  119. /plugin marketplace add darrenhinde/OpenAgentsControl
  120. ```
  121. 2. Install the plugin:
  122. ```bash
  123. /plugin install oac
  124. ```
  125. 3. Download context files:
  126. ```bash
  127. /oac:setup --core
  128. ```
  129. 4. Start building:
  130. ```
  131. Add a login endpoint
  132. ```
  133. **Features:**
  134. - ✅ 6-stage workflow with approval gates
  135. - ✅ Context-aware code generation
  136. - ✅ 7 specialized subagents (task-manager, context-scout, context-manager, coder-agent, test-engineer, code-reviewer, external-scout)
  137. - ✅ 9 workflow skills + 6 user commands
  138. - ✅ Flexible context discovery (.oac config, .claude/context, context, .opencode/context)
  139. - ✅ Add context from GitHub, worktrees, local files, or URLs
  140. - ✅ Easy feature planning with `/oac:plan`
  141. **Documentation:**
  142. - [Plugin README](./plugins/claude-code/README.md) - Complete plugin documentation
  143. - [First-Time Setup](./plugins/claude-code/FIRST-TIME-SETUP.md) - Step-by-step guide
  144. - [Quick Start](./plugins/claude-code/QUICK-START.md) - Quick reference
  145. **Status:** BETA - Actively tested and ready for early adopters
  146. ---
  147. ## 💡 The Context System: Your Secret Weapon
  148. **The problem with AI code:** It doesn't match your patterns. You spend hours refactoring.
  149. **The OAC solution:** Teach your patterns once. Agents load them automatically. Code matches from the start.
  150. ### How It Works
  151. ```
  152. Your Request
  153. ↓
  154. ContextScout discovers relevant patterns
  155. ↓
  156. Agent loads YOUR standards
  157. ↓
  158. Code generated using YOUR patterns
  159. ↓
  160. Ships without refactoring ✅
  161. ```
  162. ### Add Your Patterns (10-15 Minutes)
  163. ```bash
  164. /add-context
  165. ```
  166. **Answer 6 simple questions:**
  167. 1. What's your tech stack? (Next.js + TypeScript + PostgreSQL + Tailwind)
  168. 2. Show an API endpoint example (paste your code)
  169. 3. Show a component example (paste your code)
  170. 4. What naming conventions? (kebab-case, PascalCase, camelCase)
  171. 5. Any code standards? (TypeScript strict, Zod validation, etc.)
  172. 6. Any security requirements? (validate input, parameterized queries, etc.)
  173. **Result:** Agents now generate code matching your exact patterns. No refactoring needed.
  174. ### The MVI Advantage: Token Efficiency
  175. **MVI (Minimal Viable Information)** = Only load what's needed, when it's needed.
  176. **Traditional approach:**
  177. - Loads entire codebase context
  178. - Large token overhead per request
  179. - Slow responses, high costs
  180. **OAC approach:**
  181. - Loads only relevant patterns
  182. - Context files <200 lines (quick to load)
  183. - Lazy loading (agents load what they need)
  184. - 80% of tasks use isolation context (minimal overhead)
  185. **Real benefits:**
  186. - **Efficiency:** Lower token usage vs loading entire codebase
  187. - **Speed:** Faster responses with smaller context
  188. - **Quality:** Code matches your patterns (no refactoring)
  189. ### For Teams: Repeatable Patterns
  190. **The team problem:** Every developer writes code differently. Inconsistent patterns. Hard to maintain.
  191. **The OAC solution:** Store team patterns in `.opencode/context/project/`. Commit to repo. Everyone uses same standards.
  192. **Example workflow:**
  193. ```bash
  194. # Team lead adds patterns once
  195. /add-context
  196. # Answers questions with team standards
  197. # Commit to repo
  198. git add .opencode/context/
  199. git commit -m "Add team coding standards"
  200. git push
  201. # All team members now use same patterns automatically
  202. # New developers inherit standards on day 1
  203. ```
  204. **Result:** Consistent code across entire team. No style debates. No refactoring PRs.
  205. ---
  206. ## 📖 How It Works
  207. ### The Core Idea
  208. **Most AI tools:** Generic code → You refactor
  209. **OpenAgentsControl:** Your patterns → AI generates matching code
  210. ### The Workflow
  211. ```
  212. 1. Add Your Context (one time)
  213. ↓
  214. 2. ContextScout discovers relevant patterns
  215. ↓
  216. 3. Agent loads YOUR standards
  217. ↓
  218. 4. Agent proposes plan (using your patterns)
  219. ↓
  220. 5. You approve
  221. ↓
  222. 6. Agent implements (matches your project)
  223. ↓
  224. 7. Code ships (no refactoring needed)
  225. ```
  226. ### Key Benefits
  227. **🎯 Context-Aware**
  228. ContextScout discovers relevant patterns. Agents load YOUR standards before generating code. Code matches your project from the start.
  229. **🔁 Repeatable**
  230. Same patterns → Same results. Configure once, use forever. Perfect for teams.
  231. **⚡ Token Efficient (80% Reduction)**
  232. MVI principle: Only load what's needed. 8,000 tokens → 750 tokens. Massive cost savings.
  233. **✋ Human-Guided**
  234. Agents propose plans, you approve before execution. Quality gates prevent mistakes. No auto-execution surprises.
  235. **📝 Transparent & Editable**
  236. Agents are markdown files you can edit. Change workflows, add constraints, customize behavior. No vendor lock-in.
  237. ### What Makes This Special
  238. **1. ContextScout - Smart Pattern Discovery**
  239. Before generating code, ContextScout discovers relevant patterns from your context files. Ranks by priority (Critical → High → Medium). Prevents wasted work.
  240. **2. Editable Agents - Full Control**
  241. Unlike Cursor/Copilot where behavior is baked into plugins, OAC agents are markdown files. Edit them directly:
  242. ```bash
  243. nano .opencode/agent/core/opencoder.md # local project install
  244. # Or: nano ~/.config/opencode/agent/core/opencoder.md # global install
  245. # Add project rules, change workflows, customize behavior
  246. ```
  247. **3. ExternalScout - Live Documentation** 🆕
  248. Working with external libraries? ExternalScout fetches current documentation:
  249. - Gets live docs from official sources (npm, GitHub, docs sites)
  250. - No outdated training data - always current
  251. - Automatically triggered when agents detect external dependencies
  252. - Supports frameworks, APIs, libraries, and more
  253. **4. Approval Gates - No Surprises**
  254. Agents ALWAYS request approval before:
  255. - Writing/editing files
  256. - Running bash commands
  257. - Delegating to subagents
  258. - Making any changes
  259. You stay in control. Review plans before execution.
  260. **5. MVI Principle - Token Efficiency**
  261. Files designed for quick loading:
  262. - Concepts: <100 lines
  263. - Guides: <150 lines
  264. - Examples: <80 lines
  265. Result: Lower token usage vs loading entire codebase.
  266. **6. Team Patterns - Repeatable Results**
  267. Store patterns in `.opencode/context/project/`. Commit to repo. Entire team uses same standards. New developers inherit patterns automatically.
  268. ---
  269. ## 🎯 Which Agent Should I Use?
  270. ### OpenAgent (Start Here)
  271. **Best for:** Learning the system, general tasks, quick implementations
  272. ```bash
  273. opencode --agent OpenAgent
  274. > "Create a user authentication system" # Building features
  275. > "How do I implement authentication in Next.js?" # Questions
  276. > "Create a README for this project" # Documentation
  277. > "Explain the architecture of this codebase" # Analysis
  278. ```
  279. **What it does:**
  280. - Loads your patterns via ContextScout
  281. - Proposes plan (you approve)
  282. - Executes with validation
  283. - Delegates to specialists when needed
  284. **Perfect for:** First-time users, simple features, learning the workflow
  285. ### OpenCoder (Production Development)
  286. **Best for:** Complex features, multi-file refactoring, production systems
  287. ```bash
  288. opencode --agent OpenCoder
  289. > "Create a user authentication system" # Full-stack features
  290. > "Refactor this codebase to use dependency injection" # Multi-file refactoring
  291. > "Add real-time notifications with WebSockets" # Complex implementations
  292. ```
  293. **What it does:**
  294. - **Discover:** ContextScout finds relevant patterns
  295. - **Propose:** Detailed implementation plan
  296. - **Approve:** You review and approve
  297. - **Execute:** Incremental implementation with validation
  298. - **Validate:** Tests, type checking, code review
  299. - **Ship:** Production-ready code
  300. **Perfect for:** Production code, complex features, team development
  301. ### SystemBuilder (Custom AI Systems)
  302. **Best for:** Building complete custom AI systems tailored to your domain
  303. ```bash
  304. opencode --agent SystemBuilder
  305. > "Create a customer support AI system"
  306. ```
  307. Interactive wizard generates orchestrators, subagents, context files, workflows, and commands.
  308. **Perfect for:** Creating domain-specific AI systems
  309. ---
  310. ## 🛠️ What's Included
  311. ### 🤖 Main Agents
  312. - **OpenAgent** - General tasks, questions, learning (start here)
  313. - **OpenCoder** - Production development, complex features
  314. - **SystemBuilder** - Generate custom AI systems
  315. ### 🔧 Specialized Subagents (Auto-delegated)
  316. - **ContextScout** - Smart pattern discovery (your secret weapon)
  317. - **TaskManager** - Breaks complex features into atomic subtasks
  318. - **CoderAgent** - Focused code implementations
  319. - **TestEngineer** - Test authoring and TDD
  320. - **CodeReviewer** - Code review and security analysis
  321. - **BuildAgent** - Type checking and build validation
  322. - **DocWriter** - Documentation generation
  323. - **ExternalScout** - Fetches live docs for external libraries (no outdated training data) **NEW!**
  324. - Plus category specialists: frontend, devops, copywriter, technical-writer, data-analyst
  325. ### ⚡ Productivity Commands
  326. - `/add-context` - Interactive wizard to add your patterns
  327. - `/commit` - Smart git commits with conventional format
  328. - `/test` - Testing workflows
  329. - `/optimize` - Code optimization
  330. - `/context` - Context management
  331. - And 7+ more productivity commands
  332. ### 📚 Context System (MVI Principle)
  333. Your coding standards automatically loaded by agents:
  334. - **Code quality** - Your patterns, security, standards
  335. - **UI/design** - Design system, component patterns
  336. - **Task management** - Workflow definitions
  337. - **External libraries** - Integration guides (18+ libraries supported)
  338. - **Project-specific** - Your team's patterns
  339. **Key features:**
  340. - 80% token reduction via MVI
  341. - Smart discovery via ContextScout
  342. - Lazy loading (only what's needed)
  343. - Team-ready (commit to repo)
  344. - Version controlled (track changes)
  345. ### How Context Resolution Works
  346. ContextScout discovers context files using a **local-first** approach:
  347. ```
  348. 1. Check local: .opencode/context/core/navigation.md
  349. ↓ Found? → Use local for everything. Done.
  350. ↓ Not found?
  351. 2. Check global: ~/.config/opencode/context/core/navigation.md
  352. ↓ Found? → Use global for core/ files only.
  353. ↓ Not found? → Proceed without core context.
  354. ```
  355. **Key rules:**
  356. - **Local always wins** — if you installed locally, global is never checked
  357. - **Global fallback is only for `core/`** (standards, workflows, guides) — universal files that are the same across projects
  358. - **Project intelligence is always local** — your tech stack, patterns, and naming conventions live in `.opencode/context/project-intelligence/` and are never loaded from global
  359. - **One-time check** — ContextScout resolves the core location once at startup (max 2 glob checks), not per-file
  360. **Common setups:**
  361. | Setup | Core files from | Project intelligence from |
  362. |-------|----------------|--------------------------|
  363. | Local install (`bash install.sh developer`) | `.opencode/context/core/` | `.opencode/context/project-intelligence/` |
  364. | Global install + `/add-context` | `~/.config/opencode/context/core/` | `.opencode/context/project-intelligence/` |
  365. | Both local and global | `.opencode/context/core/` (local wins) | `.opencode/context/project-intelligence/` |
  366. ---
  367. ## 💻 Example Workflow
  368. ```bash
  369. opencode --agent OpenCoder
  370. > "Create a user dashboard with authentication and profile settings"
  371. ```
  372. **What happens:**
  373. **1. Discover (~1-2 min)** - ContextScout finds relevant patterns
  374. - Your tech stack (Next.js + TypeScript + PostgreSQL)
  375. - Your API pattern (Zod validation, error handling)
  376. - Your component pattern (functional, TypeScript, Tailwind)
  377. - Your naming conventions (kebab-case files, PascalCase components)
  378. **2. Propose (~2-3 min)** - Agent creates detailed implementation plan
  379. ```
  380. ## Proposed Implementation
  381. **Components:**
  382. - user-dashboard.tsx (main page)
  383. - profile-settings.tsx (settings component)
  384. - auth-guard.tsx (authentication wrapper)
  385. **API Endpoints:**
  386. - /api/user/profile (GET, POST)
  387. - /api/auth/session (GET)
  388. **Database:**
  389. - users table (Drizzle schema)
  390. - sessions table (Drizzle schema)
  391. All code will follow YOUR patterns from context.
  392. Approve? [y/n]
  393. ```
  394. **3. Approve** - You review and approve the plan (human-guided)
  395. **4. Execute (~10-15 min)** - Incremental implementation with validation
  396. - Implements one component at a time
  397. - Uses YOUR patterns for every file
  398. - Validates after each step (type check, lint)
  399. - *This is the longest step - generating quality code takes time*
  400. **5. Validate (~2-3 min)** - Tests, type checking, code review
  401. - Delegates to TestEngineer for tests
  402. - Delegates to CodeReviewer for security check
  403. - Ensures production quality
  404. **6. Ship** - Production-ready code
  405. - Code matches your project exactly
  406. - No refactoring needed
  407. - Ready to commit and deploy
  408. **Total time: ~15-25 minutes** for a complete feature (guided, with approval gates)
  409. ### 💡 Pro Tips
  410. **After finishing a feature:**
  411. - Run `/add-context --update` to add new patterns you discovered
  412. - Update your context with new libraries, conventions, or standards
  413. - Keep your patterns fresh as your project evolves
  414. **Working with external libraries?**
  415. - **ExternalScout** automatically fetches current documentation
  416. - No more outdated training data - gets live docs from official sources
  417. - Works with npm packages, APIs, frameworks, and more
  418. ---
  419. ## ⚙️ Advanced Configuration
  420. ### Model Configuration (Optional)
  421. **By default, all agents use your OpenCode default model.** Configure models per agent only if you want different agents to use different models.
  422. **When to configure:**
  423. - You want faster agents to use cheaper models (e.g., Haiku/Flash)
  424. - You want complex agents to use smarter models (e.g., Opus/GPT-5)
  425. - You want to test different models for different tasks
  426. **How to configure:**
  427. Edit agent files directly:
  428. ```bash
  429. nano .opencode/agent/core/opencoder.md # local project install
  430. # Or: nano ~/.config/opencode/agent/core/opencoder.md # global install
  431. ```
  432. Change the model in the frontmatter:
  433. ```yaml
  434. ---
  435. description: "Development specialist"
  436. model: anthropic/claude-sonnet-4-5 # Change this line
  437. ---
  438. ```
  439. Browse available models at [models.dev](https://models.dev/?search=open) or run `opencode models`.
  440. ### Update Context as You Go
  441. Your project evolves. Your context should too.
  442. ```bash
  443. /add-context --update
  444. ```
  445. **What gets updated:**
  446. - Tech stack, patterns, standards
  447. - Version incremented (1.0 → 1.1)
  448. - Updated date refreshed
  449. **Example updates:**
  450. - Add new library (Stripe, Twilio, etc.)
  451. - Change patterns (new API format, component structure)
  452. - Migrate tech stack (Prisma → Drizzle)
  453. - Update security requirements
  454. Agents automatically use updated patterns.
  455. ---
  456. ## 🎯 Is This For You?
  457. ### ✅ Use OAC if you:
  458. - Build production code that ships without heavy rework
  459. - Work in a team with established coding standards
  460. - Want control over agent behavior (not black-box plugins)
  461. - Care about token efficiency and cost savings
  462. - Need approval gates for quality assurance
  463. - Want repeatable, consistent results
  464. - Use multiple AI models (no vendor lock-in)
  465. ### ⚠️ Skip OAC if you:
  466. - Want fully autonomous execution without approval gates
  467. - Prefer "just do it" mode over human-guided workflows
  468. - Don't have established coding patterns yet
  469. - Need multi-agent parallelization (use Oh My OpenCode instead)
  470. - Want plug-and-play with zero configuration
  471. ### 🤔 Not Sure?
  472. **Try this test:**
  473. 1. Ask your current AI tool to generate an API endpoint
  474. 2. Count how many minutes you spend refactoring it to match your patterns
  475. 3. If you're spending time on refactoring, OAC will save you that time
  476. **Or ask yourself:**
  477. - Do you have coding standards your team follows?
  478. - Do you spend time refactoring AI-generated code?
  479. - Do you want AI to follow YOUR patterns, not generic ones?
  480. If you answered "yes" to any of these, OAC is for you.
  481. ---
  482. ## 🚀 Advanced Features
  483. ### Frontend Design Workflow
  484. The **OpenFrontendSpecialist** follows a structured 4-stage design workflow:
  485. 1. **Layout** - ASCII wireframe, responsive structure planning
  486. 2. **Theme** - Design system selection, OKLCH colors, typography
  487. 3. **Animation** - Micro-interactions, timing, accessibility
  488. 4. **Implementation** - Single HTML file, semantic markup
  489. ### Task Management & Breakdown
  490. The **TaskManager** breaks complex features into atomic, verifiable subtasks with smart agent suggestions and parallel execution support.
  491. ### System Builder
  492. Build complete custom AI systems tailored to your domain in minutes. Interactive wizard generates orchestrators, subagents, context files, workflows, and commands.
  493. ---
  494. ## ❓ FAQ
  495. ### Getting Started
  496. **Q: Does this work on Windows?**
  497. A: Yes! Use Git Bash (recommended) or WSL.
  498. **Q: What languages are supported?**
  499. A: Agents are language-agnostic and adapt based on your project files. Primarily tested with TypeScript/Node.js. C# / .NET is now supported with dedicated context files. Python, Go, Rust, and other languages are supported but less battle-tested. The context system works with any language.
  500. **Q: Do I need to add context?**
  501. A: No, but it's highly recommended. Without context, agents write generic code. With context, they write YOUR code.
  502. **Q: Can I use this without customization?**
  503. A: Yes, it works out of the box. But you'll get the most value after adding your patterns (10-15 minutes with `/add-context`).
  504. **Q: What models are supported?**
  505. A: Any model from any provider (Claude, GPT, Gemini, MiniMax, local models). No vendor lock-in.
  506. ### For Teams
  507. **Q: How do I share context with my team?**
  508. A: Commit `.opencode/context/project/` to your repo. Team members automatically use same patterns.
  509. **Q: How do we ensure everyone follows the same standards?**
  510. A: Add team patterns to context once. All agents load them automatically. Consistent code across entire team.
  511. **Q: Can different projects have different patterns?**
  512. A: Yes! Use project-specific context (`.opencode/` in project root) to override global patterns.
  513. ### Technical
  514. **Q: How does token efficiency work?**
  515. A: MVI principle: Only load what's needed, when it's needed. Context files <200 lines (scannable in 30s). ContextScout discovers relevant patterns. Lazy loading prevents context bloat. 80% of tasks use isolation context (minimal overhead).
  516. **Q: What's ContextScout?**
  517. A: Smart pattern discovery agent. Finds relevant context files before code generation. Ranks by priority. Prevents wasted work.
  518. **Q: Can I edit agent behavior?**
  519. A: Yes! Agents are markdown files. Edit them directly: `nano .opencode/agent/core/opencoder.md` (local) or `nano ~/.config/opencode/agent/core/opencoder.md` (global)
  520. **Q: How do approval gates work?**
  521. A: Agents ALWAYS request approval before execution (write/edit/bash). You review plans before implementation. No surprises.
  522. **Q: How do I update my context?**
  523. A: Run `/add-context --update` anytime your patterns change. Agents automatically use updated patterns.
  524. ### Comparison
  525. **Q: How is this different from Cursor/Copilot?**
  526. A: OAC has editable agents (not baked-in), approval gates (not auto-execute), context system (YOUR patterns), and MVI token efficiency.
  527. **Q: How is this different from Aider?**
  528. A: OAC has team patterns, context system, approval workflow, and smart pattern discovery. Aider is file-based only.
  529. **Q: How does this compare to Oh My OpenCode?**
  530. A: Both are built on OpenCode. OAC focuses on **control & repeatability** (approval gates, pattern control, team standards). Oh My OpenCode focuses on **autonomy & speed** (parallel agents, auto-execution). [Read detailed comparison →](https://github.com/darrenhinde/OpenAgentsControl/discussions/116)
  531. **Q: When should I NOT use OAC?**
  532. A: If you want fully autonomous execution without approval gates, or if you don't have established coding patterns yet.
  533. ### Setup
  534. **Q: What bash version do I need?**
  535. A: Bash 3.2+ (macOS default works). Run `bash scripts/tests/test-compatibility.sh` to check.
  536. **Q: Do I need to install plugins/tools?**
  537. A: No, they're optional. Only install if you want Telegram notifications or Gemini AI features.
  538. **Q: Where should I install - globally or per-project?**
  539. A: Local (`.opencode/` in your project) is recommended — patterns are committed to git and shared with your team. Global (`~/.config/opencode/`) is good for personal defaults across all projects. The installer asks you to choose. See [OpenCode Config Docs](https://opencode.ai/docs/config/) for how configs merge.
  540. ---
  541. ## 🗺️ Roadmap & What's Coming
  542. **This is only the beginning!** We're actively developing new features and improvements every day.
  543. ### 🚀 See What's Coming Next
  544. Check out our [**Project Board**](https://github.com/darrenhinde/OpenAgentsControl/projects) to see:
  545. - 🔨 **In Progress** - Features being built right now
  546. - 📋 **Planned** - What's coming soon
  547. - 💡 **Ideas** - Future enhancements under consideration
  548. - ✅ **Recently Shipped** - Latest improvements
  549. ### 🎯 Current Focus Areas
  550. - **Plugin System** - npm-based plugin architecture for easy distribution
  551. - **Performance Improvements** - Faster agent execution and context loading
  552. - **Enhanced Context Discovery** - Smarter pattern recognition
  553. - **Multi-language Support** - Better Python, Go, Rust, C# / .NET support
  554. - **Team Collaboration** - Shared context and team workflows
  555. - **Documentation** - More examples, tutorials, and guides
  556. ### 💬 Have Ideas?
  557. We'd love to hear from you!
  558. - 💡 [**Submit Feature Requests**](https://github.com/darrenhinde/OpenAgentsControl/issues/new?labels=enhancement)
  559. - 🐛 [**Report Bugs**](https://github.com/darrenhinde/OpenAgentsControl/issues/new?labels=bug)
  560. - 💬 [**Join Discussions**](https://github.com/darrenhinde/OpenAgentsControl/discussions)
  561. **Star the repo** ⭐ to stay updated with new releases!
  562. ---
  563. ## 🤝 Contributing
  564. We welcome contributions!
  565. 1. Follow the established naming conventions and coding standards
  566. 2. Write comprehensive tests for new features
  567. 3. Update documentation for any changes
  568. 4. Ensure security best practices are followed
  569. See: [Contributing Guide](docs/contributing/CONTRIBUTING.md) • [Code of Conduct](docs/contributing/CODE_OF_CONDUCT.md)
  570. ---
  571. ## 💬 Community & Support
  572. <div align="center">
  573. **Join the community and stay updated with the latest AI development workflows!**
  574. [![YouTube](https://img.shields.io/badge/YouTube-Darren_Builds_AI-red?style=for-the-badge&logo=youtube&logoColor=white)](https://youtube.com/@DarrenBuildsAI)
  575. [![Community](https://img.shields.io/badge/Community-NextSystems.ai-blue?style=for-the-badge&logo=discourse&logoColor=white)](https://nextsystems.ai)
  576. [![X/Twitter](https://img.shields.io/badge/Follow-@DarrenBuildsAI-1DA1F2?style=for-the-badge&logo=x&logoColor=white)](https://x.com/DarrenBuildsAI)
  577. [![Buy Me A Coffee](https://img.shields.io/badge/Support-Buy_Me_A_Coffee-FFDD00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://buymeacoffee.com/darrenhinde)
  578. **📺 Tutorials & Demos** • **💬 Join Waitlist** • **🐦 Latest Updates** • **☕ Support Development**
  579. *Your support helps keep this project free and open-source!*
  580. </div>
  581. ---
  582. ## License
  583. This project is licensed under the MIT License.
  584. ---
  585. **Made with ❤️ by developers, for developers. Star the repo if this saves you refactoring time!**

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.