An autonomous AI agent orchestrator that coordinates an entire software company within OpenCode.
This project aims to supercharge AI agents without burdening you as the user to prompt after each turn. Instead of manually managing multiple agents, You orchestrates a complete software company where AI agents act as Product Managers, Architects, Engineers, QA, DevOps, and more—all working together from a single user input.
- Status
- Features
- Requirements
- Installation
- Quick Start
- How It Works
- Architecture
- Agent Roles
- Professional Skills
- Usage Examples
- Design Notes
- Limitations
- Contributing
- License
- TECHNICAL_DETAILS.md - HTTP API integration and autonomous orchestration deep dive
- IMPLEMENTATION.md - Complete implementation summary and architecture overview
- QUICKSTART.md - 5-minute getting started guide
- CONTRIBUTING.md - Contribution guidelines
Current Version: 0.1.14
Note
This is an early beta release. The orchestrator can:
- Generate OpenCode agent configurations
- Set up workflow templates and professional skills
- Track artifacts and state in a Shared Certified Repository (SCR)
- Fully autonomous orchestration via HTTP API
- Real-time event streaming via Server-Sent Events
- Re-orchestration support with session isolation
- Fully Autonomous Operation: Zero human intervention required - agents make intelligent decisions automatically via HTTP API
- Workspace Organization (v0.1.14): Agents respect user-specified project folders and keep workspace clean
- Graceful Completion Detection (v0.1.12): CEO detects when work is done and outputs clear success message before ending session
- Anti-Scope-Creep Protocol: CEO and PM agents actively reject unrequested features to prevent over-engineering and budget overruns
- Real-time Event Streaming: Watch all agent activity, file changes, and decisions in real-time via Server-Sent Events
- Re-orchestration Support: Edit requirements and re-run for fresh start with session isolation
- Single-Prompt Orchestration: Describe your project once; agents handle the rest
- 10 Specialized Agents: CEO, Product Manager, Designer, Architect, Lead Engineer, SWE, QA, Security, DevOps, Technical Writer
- Professional Skills: Reusable workflows for PRD creation, code review, security audits, API design, deployment checklists
- Web Research Capabilities: All agents can browse the internet to verify documentation and latest syntax before writing code
- Smart Agent System: Agents research best practices and make autonomous decisions based on industry standards
- OpenCode HTTP Integration: Seamless integration with OpenCode's server API for programmatic control
- State Management: Tracks goals, tasks, artifacts, and communications in a centralized SCR
- Production-Ready Code: Clean architecture following SOLID principles
- Workflow Automation: Agents follow a structured workflow from requirements to deployment
- Go: 1.21 or higher
- OpenCode: Latest version (install here)
- GitHub Copilot Pro: Strongly recommended for unlimited
gpt-5-miniaccess- GitHub Copilot uses a multiplier system -
gpt-5-minihas 0x multiplier (unlimited) - Our config uses
gpt-5-miniexclusively:10 agents × 0 multiplier = 0 premium requests - Refer to GitMurf on OpenCode pricing for GitHub Copilot
- GitHub Copilot uses a multiplier system -
- Alternative: Any OpenCode-supported LLM provider (Anthropic, OpenAI, etc.)
# Clone the repository
git clone https://github.com/galpt/you.git
cd you
# Install dependencies
go mod download
# Build the binary
# Windows:
go build -o you.exe .
# Linux/Mac:
go build -o you .
# (Optional) Add to PATH for global access
# Windows: Copy you.exe to a directory in your PATH
# Linux/Mac: sudo mv you /usr/local/bin/Download the latest binary from the Releases page.
cd your-new-project
# Windows:
you.exe --presets
# Linux/Mac:
you --presetsThis creates:
USER_INPUT.md- Template for your project requirements.opencode/agents/*.md- 10 specialized agent definitions.opencode/opencode.json- OpenCode configuration.opencode/skills/*/SKILL.md- 5 professional skill definitions.you/- State management directory
Edit USER_INPUT.md with your project idea:
# User Input - Project Requirements
## What do you want to build?
Build a simple task management web application where users can create,
update, delete, and mark tasks as complete. The app should have user
authentication and a clean, modern UI using Next.js and Tailwind CSS.
### Key Features
- User registration and login
- Create/edit/delete tasks
- Mark tasks as complete
- Filter tasks (all, active, completed)
- Responsive design# Windows:
you.exe --orchestrate
# Linux/Mac:
you --orchestrateWhat happens:
- Creates a Goal from your USER_INPUT.md
- Initializes workflow state in
.you/ - Generates
ORCHESTRATION_GUIDE.md - Starts OpenCode server (headless HTTP API)
- Automatically sends initial prompt to CEO agent
- Streams all agent activity in real-time to your terminal
Fully Autonomous:
- No human interaction required
- Agents orchestrate themselves via CEO delegation
- Real-time event streaming shows progress
- Files appear as they're created
- Press
Ctrl+Canytime to stop
Example output:
🔧 Starting OpenCode server...
📝 Creating orchestration session...
✓ Session created: ses_414190ba65ffeRPG3382HKeVEZH
🎭 Sending initial message to session...
✓ Message queued! CEO agent will receive it and start orchestrating.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📡 Streaming real-time events (press Ctrl+C to stop):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💬 [assistant] ceo
Reading USER_INPUT.md...
👤 Delegating to: @product-manager
🔧 Tool: task (running...)
✓ Tool task: Delegated to product-manager
💬 [assistant] product-manager
Creating comprehensive Product Requirements Document...
📄 modified: requirements/PRD.md
✓ Tool write completed
👤 Delegating to: @product-designer
✓ Session completed!
If something goes wrong or you want to refine the requirements:
# 1. Stop the current session (Ctrl+C)
# 2. Edit USER_INPUT.md with updated requirements
# 3. Re-run orchestration
you.exe --orchestrateWhat happens:
- Creates a new goal with updated requirements
- Starts a fresh OpenCode session
- CEO agent receives the new prompt
- Team rebuilds with corrected specifications
Note
Each orchestration creates a new session. Previous sessions are preserved in .you/goals/ for audit trail.
The CEO agent orchestrates the entire team without human intervention:
@ceo→@product-manager- Create PRD@product-manager→@product-designer- UI/UX design@product-designer→@solution-architect- System architecture@solution-architect→@lead-engineer- Task breakdown@lead-engineer→@software-engineer- Implementation@software-engineer→@qa-engineer- Testing@qa-engineer→@security-engineer- Security audit@security-engineer→@devops-sre- Deployment setup@devops-sre→@technical-writer- Documentation@technical-writer→@ceo- Final approval
Note
- All delegation happens automatically via the
delegatetool. You just watch the stream! - All artifacts and state are tracked in the
.you/directory.
User Goal → CEO Agent
↓
Product Manager (PRD)
↓
Product Designer (UI/UX)
↓
Solution Architect (Architecture)
↓
Lead Engineer (Task Breakdown)
↓
Software Engineers (Implementation)
↓
QA Engineer (Testing) ←→ Bug Reports → Back to SWE
↓
Security Engineer (Audit)
↓
DevOps/SRE (Deployment)
↓
Technical Writer (Documentation)
↓
CEO (Final Review & Approval)
All artifacts are tracked in .you/:
.you/
├── artifacts/ # PRDs, code, test reports, docs
└── workflows/ # Goals and workflow state
Note
Task distribution and agent communication are managed internally by OpenCode.
You achieves full automation by:
-
Starting OpenCode Server (
opencode serve --port 4096)- Headless HTTP server running in background
- Exposes RESTful API for programmatic control
- No TUI interaction required
-
Creating a Session (
POST /session)- Each orchestration gets a new session ID
- Sessions are isolated and independent
- Multiple re-orchestrations = multiple sessions
-
Sending Message (
POST /session/:id/message)- Sends initial message to CEO agent
- Fire-and-forget in background goroutine
- CEO agent immediately starts orchestrating
-
Streaming Real-time Events (
GET /event- Server-Sent Events)- Subscribes to OpenCode event stream
- Receives updates in real-time:
message.updated- New agent messagemessage.part.updated- Streaming text chunks and tool callsfile.edited- File created/modifiedsession.status- Session state changes (idle, busy, retry)
- Formats and displays events in terminal
Result: Fully autonomous operation with complete visibility!
Re-orchestration Flow:
Error detected → User edits USER_INPUT.md → Ctrl+C to stop
↓
you.exe --orchestrate
↓
New session created → Fresh start → New goal ID
↓
Previous session preserved in .you/goals/{old-goal-id}/
Agents use OpenCode's delegate tool to pass work:
@ceo → invokes → @product-manager
@product-manager → invokes → @product-designer
@solution-architect → invokes → @lead-engineer
@lead-engineer → invokes → @software-engineer
All agents have access to the same built-in tools (write, edit, bash, webfetch) and permissions (delegate, skill) defined in .opencode/opencode.json. Role-specific behavior is guided by their system prompts.
you/
├── .github/
│ └── workflows/ # CI/CD automation
├── internal/
│ ├── agents/ # Agent templates and prompts
│ │ ├── templates.go # Agent configurations
│ │ └── prompts.go # Role-specific system prompts
│ ├── models/ # Data models (Goal, Artifact, Task, etc.)
│ ├── orchestrator/ # Core orchestration logic
│ └── state/ # SCR (Shared Certified Repository)
├── main.go # CLI entry point
├── go.mod # Go module definition
└── README.md
Design Principles:
- Separation of Concerns: Each package has a single responsibility
- Dependency Injection: Orchestrator depends on interfaces, not concrete types
- Clean Architecture: Business logic is independent of frameworks
- SOLID Principles: Single responsibility, open/closed, Liskov substitution, etc.
| Agent | Role | Type | Responsibilities |
|---|---|---|---|
| CEO | Orchestrator | Primary | High-level decision making, delegates to PM, final approval, enforces anti-scope-creep protocol |
| Product Manager | Requirements | Subagent | Creates PRDs, user stories, acceptance criteria |
| Product Designer | UI/UX | Subagent | User flows, design systems, component specifications |
| Solution Architect | Architecture | Subagent | Tech stack, data models, API design, system architecture |
| Lead Engineer | Task Management | Subagent | Breaks architecture into tasks, code review, releases |
| Software Engineer | Implementation | Subagent | Writes code, unit tests, implements features |
| QA Engineer | Quality Assurance | Subagent | Automated testing, validation, bug reporting |
| Security Engineer | Security | Subagent | Security audits, vulnerability scanning, compliance |
| DevOps/SRE | Infrastructure | Subagent | CI/CD, deployment, monitoring, observability |
| Technical Writer | Documentation | Subagent | READMEs, API docs, user guides, changelogs |
Note
- All agents have web browsing capabilities to research documentation, verify latest library syntax, and prevent outdated implementations. Before writing code for external dependencies, agents automatically use
webfetchto validate current best practices. - All agents can load professional skills via the
skilltool to access standardized workflows for their role-specific tasks (PRD creation, code reviews, security audits, etc.). - Each agent has a custom system prompt based on the fine-tuned prompts in copilot-agent-modes/chatmode-v3.1/.
The orchestrator includes 5 production-ready skills following industry standards and Software Engineering best practices (Roger Pressman):
| Skill | Description | Primary Users | Standards Applied |
|---|---|---|---|
| create-prd | Comprehensive PRD creation with user stories, acceptance criteria, and requirements | Product Manager | Requirements Engineering, Stakeholder Analysis |
| code-review | Systematic code review checklist covering correctness, security, and maintainability | Lead Engineer, SWE | Quality Assurance, Code Inspection, Best Practices |
| security-audit | Security assessment following OWASP Top 10, dependency scanning, and compliance checks | Security Engineer | Security Engineering, Risk Management |
| api-design | RESTful and GraphQL API design with versioning, documentation, and best practices | Solution Architect | Interface Design, Software Architecture |
| deployment-checklist | Pre-deployment validation covering testing, infrastructure, monitoring, and rollback | DevOps/SRE | Process Models, Configuration Management, Quality Control |
These skills mirror real software company workflows and are production-ready—not examples. Each follows established software engineering principles including:
- Process Discipline: Structured workflows with clear phases
- Quality Assurance: Built-in validation and verification steps
- Risk Management: Explicit consideration of dependencies and constraints
- Documentation Standards: Consistent format and completeness requirements
Tip
Skills are stored in .opencode/skills/<skill-name>/SKILL.md and can be extended with your organization's specific methodologies.
How Agents Use Skills:
@lead-engineer Review the user authentication code using the code-review skill
OpenCode presents available skills to agents, who load them on-demand for structured, professional guidance.
you --presets
# Edit USER_INPUT.md with: "Build a blog platform with user authentication"
you --orchestrate
# OpenCode launches automatically with CEO agent orchestrating the buildyou --presets
# Edit USER_INPUT.md with: "Build a CLI tool for managing TODO lists"
you --orchestrate
# OpenCode launches automatically with CEO agent orchestrating the buildyou --presets
# Edit USER_INPUT.md with: "Build a REST API for a book library"
you --orchestrate
# OpenCode launches automatically with CEO agent orchestrating the buildOpenCode provides:
- Native agent support with custom prompts
- Task delegation between agents
- File operations and terminal access
- LLM provider flexibility
Inspired by Kubernetes' etcd, the SCR is:
- Immutable: All changes create new versions
- Auditable: Every decision is logged
- State-driven: Agents react to state changes
Agents follow a "never stop until complete" protocol:
- Agent receives task
- Agent works autonomously
- Agent only stops when acceptance criteria met
- If blocked, agent researches or escalates
- One orchestration at a time (single OpenCode server instance)
- Terminal-only interface (no web UI)
- Fixed port 4096 for OpenCode server
- Long-running orchestrations may encounter rate limits (automatic retry with exponential backoff up to 5 attempts)
Contributions are welcome! This is a beta project looking for feedback.
- Fork the repository
- Create a feature branch:
git checkout -b feature/amazing-feature - Make your changes (follow Go best practices)
- Run tests:
go test ./... - Commit:
git commit -m 'Add amazing feature' - Push:
git push origin feature/amazing-feature - Open a Pull Request
- Follow Go idioms and conventions
- Use
gofmtandgolint - Add tests for new features
- Update documentation
Found a bug? Have a suggestion? Open an issue!
This project is licensed under the MIT License - see the LICENSE file for details.
- Inspired by MetaGPT and hierarchical agent systems
- Built for OpenCode
- Follows software engineering principles from Roger Pressman's Software Engineering textbook
- Agent personality fine-tuning inspired by Anthropic's prompt engineering guide
Built with ❤️ for developers who want AI agents to do the heavy lifting.