hkuds/openopc

OpenOPC: Build Your Personal AI-Native Company — Self-Built, Self-Run, Self-Grown

English | 简体中文

🏗️ Self-Built — Fully automated to recruit role-specific AI employees and build the org.

⚙️ Self-Run — Fully automated to assign tasks, drive handoffs, and keep moving toward your goal.

🌱 Self-Grown — Learns from every task, builds organizational memory, always delivers smarter.

News

• Jul 14, 2026 — More resilient company runs: Company-mode sessions now recover and resume more seamlessly while preserving agent identity, shared role context, delegation, and review progress.
• Jul 13, 2026 — Smoother Office UI: Faster live updates and chat scrolling improve long-running projects.
• Jul 8, 2026 — Smarter approvals: Session grants persist, low-risk actions flow automatically, and deferred decisions stay available.

Table Of Contents

• When To Use OpenOPC
• Demos
• How OpenOPC Works
• Quick Start
• Office UI Guide
• CLI Guide
• Configuration
• Ecosystem And Sharing
• Roadmap
• Acknowledgements

When to Use OpenOPC

OpenOPC covers nine core verticals — from AI development and software engineering to finance, sales, media, e-commerce, and education. Whatever the industry, OpenOPC assembles the right team and delivers end-to-end.

Demos

How OpenOPC Works

OpenOPC assembles a AI company around complex, real-world tasks — through three tightly coupled mechanisms: Self-Built staffs the organisation, Self-Run executes the work, and Self-Grown learns from the outcome.

1. Self-Built — Staffing the Organisation

Before any work begins, the right people must be in place. Given a goal, OpenOPC:

• 🌿 Drafts the org chart — deriving the roles and reporting structure the task demands.
• 🎯 Fills each role — a recruiter agent chooses between reusing an existing employee (shaped by prior projects) and onboarding a fresh hire from the talent pool.

💡 Experienced employees carry accumulated context; fresh hires offer a clean slate when a role demands it.

⚙️ 2. Self-Run — Executing the Work

With the team assembled, Self-Run orchestrates its members toward a finished deliverable. The central challenge is not raw execution but efficient collaboration under uncertainty, which manifests in two distinct problems.

🔀 Dynamic collaboration orchestration. Real work cannot be fully planned upfront. OpenOPC addresses this through a work-item state machine, where each item’s phase determines:

• 📋 Its kanban column — where it stands in the workflow.
• 👑 Its owner — the role responsible at that phase.
• ✅ Its runnability — whether it is ready to proceed.

A manager decomposes items, assigns, and reviews results — accepting, reworking, or escalating — across five modes: execute, delegate, review, integrate, and rework. Decomposition defines a dependency DAG, so:

• ⚡ Independent items proceed in parallel.
• ⏳ Dependent items wait until prerequisites are resolved.

🔗 Dependency resolution and rejection propagate as structured phase transitions, eliminating ad-hoc coordination.

🛡️ Handling blockers surfacing mid-run. Not all obstacles are visible upfront. OpenOPC resolves them at two levels:

• 💬 Within the team — a blocking message pauses the sender, activating the role best positioned to resolve it.
• 📡 Beyond the team — when a blocker exceeds the team’s authority, the runtime escalates to the human owner, invoking human judgment precisely when needed.

🖥️ The kanban and office views render this orchestration in real time.

🌱 3. Self-Grown — Learning from the Run

Execution generates raw experience; Self-Grown turns it into lasting improvement, guided by two principles.

🏅 Attributing outcomes to the right roles. Crediting the whole company teaches nothing. Instead, OpenOPC:

• 🔍 Resolves user feedback into per-employee evaluations.
• 🎯 Updates only roles that owned the relevant work items — credit and blame land where they were earned.

📖 Distilling trajectories into knowledge. Execution traces are too noisy to learn from. OpenOPC therefore:

• 💡 Distils each role’s tasks into high-signal lessons, stored in its private experience profile.
• 📚 Promotes recurring lessons into shared playbooks, which new hires inherit from the outset — compounding organisational knowledge over time.

Quick Start

uv is the recommended setup path for OpenOPC. It can install/manage Python, create the project virtualenv, and run commands against that environment without mixing OpenOPC dependencies into your global Python.

OpenOPC requires Python >=3.10; the examples below use Python 3.12.

For direct one-off work, OpenOPC also includes Task Mode, a LobeChat-like single-agent workspace using OpenOPC Native, Codex, Claude Code, Cursor, or OpenCode.

# Install OpenOPC into the uv-managed environment
uv pip install -e .

# Optional but recommended for browser tools
uv run python -m playwright install chromium

# Initialize local config, memory, skills, projects, and workspace folders
uv run opc init

# Add an API key in .opc/config/llm_config.yaml
# or configure the env var named by llm.api_key_env.

# Launch the browser UI
uv run opc ui

Open http://localhost:8765 by default.

# Interactive CLI
uv run opc chat -p demo

# One-shot task mode
uv run opc chat -p demo --mode task --agent codex "Refactor this module and run focused tests"

# Company mode with the built-in Corporate architecture
uv run opc chat -p demo --mode company --company-profile corporate "Plan, implement, review, and document this feature"

# Non-interactive scripting / CI style usage
uv run opc exec -p demo --mode task --agent native --json "Summarize the current repo status"

Office UI Guide

CLI Guide

Configuration

Run opc init once from the repo root. It creates .opc/, copies the template config from config/, creates memory/skills/log folders, and optionally creates the first project.

Troubleshooting

Ecosystem And Sharing

Everything OpenOPC builds is yours to keep, reuse, and share — organizations, employees, talent templates, skills, and channels are just files. Import a popular talent library, reuse a team across projects, or package a whole company as a shareable .opcpkg.

# Hire from a talent library (e.g. agency-agents) into a role
opc talent import /path/to/agency-agents
opc talent hire   -p demo

# Reuse or share a whole organization
opc org export --json > my-org.yaml
opc market export --id hku_lab --name "HKU Lab" --output-dir packages
opc market install packages/hku_lab.opcpkg

Roadmap

OpenOPC is moving quickly. The areas below reflect active development priorities — each grounded in real gaps identified during early usage.

Acknowledgements

OpenOPC is built with gratitude for several open-source projects that helped shape its agent design, skill structure, and talent template ecosystem:

• openai/codex for inspiring practical coding-agent workflows and execution patterns.
• BloopAI/vibe-kanban for inspiration around kanban-centered agent work management and task visibility.
• msitarzewski/agency-agents for the talent-template foundation. All talent templates included in this repository are imported from agency-agents.
• HKUDS/nanobot for inspiration around skill-oriented agent design and SKILL.md-style organization.
• pixel-agents-hq/pixel-agents for inspiration around the animated pixel-art office visualization of agent activity.

---

❤️ Thanks for visiting ✨ OpenOPC!