现在的 OpenCode 已经具备 Agents、Subagents、MCP、Skills、Commands、Plugins、CLI、GitHub Agent、Model/Provider 管理等能力，因此它已经明显超出了早期“开源版 AI 编程 CLI”的定位。(开源代码)
一、OpenCode 到底是什么？
一句话：
OpenCode 是一个开源的 Agentic Coding Runtime。
如果把 GitHub Copilot 理解成：
GitHub
+
Copilot
+
Agent
+
GitHub Workflow那么 OpenCode 更接近：
LLM
+
Coding Agent Runtime
+
Tools
+
MCP
+
Skills
+
Custom Agents
+
Commands
+
Plugins
+
Git它的核心思想是：
让开发者可以自由选择模型，同时自己控制 Agent、Tools、Context、Skills 和工程工作流。
官方文档目前明确支持多种模型 Provider，并且可以通过 /connect 连接模型；也支持自定义 Provider。(开源代码)
二、OpenCode 与 Copilot 最大的区别
这是理解 OpenCode 最关键的一点。
GitHub Copilot
GitHub
│
├── Copilot
├── GitHub Repository
├── GitHub Actions
├── Pull Request
└── Cloud Agent它是：
GitHub-centric AI Software Engineering Platform
而 OpenCode：
OpenCode
│
┌───────────┼───────────┐
↓ ↓ ↓
Model Agent Tools
│ │ │
Claude/GPT Build/Plan Bash
Qwen/Gemini General Read
DeepSeek Explore Edit
... Custom Git
MCP它更像：
Model-agnostic Coding Agent Runtime
这也是为什么 OpenCode 对你这种希望研究：
-
OpenCode
-
OpenClaw
-
Harness
-
Agent
-
MCP
-
AI Software Factory
的人非常有价值。
三、OpenCode 的核心架构
可以把 OpenCode 简化成：
User
│
▼
OpenCode CLI
│
▼
Agent Runtime
│
┌────────────┼────────────┐
↓ ↓ ↓
Context Model Tools
│ │ │
Files Claude Read
Git GPT Edit
Rules Qwen Bash
Skills Gemini Git
History DeepSeek MCP
│ │ │
└────────────┼────────────┘
↓
Agent Loop
│
┌─────┴─────┐
↓ ↓
Reason Action
│ │
└─────┬─────┘
↓
Observe
↓
Verify
↓
Result这和刚才 Copilot 的架构非常类似。
真正不同的是：
OpenCode 把这个 Agent Runtime 更开放地暴露给开发者。
四、OpenCode 的 Agent Loop
OpenCode 最核心的其实不是 UI。
而是：
Goal
↓
Understand
↓
Explore
↓
Plan
↓
Tool Call
↓
Execute
↓
Observe
↓
Reason
↓
Modify
↓
Test
↓
Verify
↓
Complete例如：
用户：
Add Redis caching to UserServiceOpenCode Agent 可能执行：
1. search UserService
2. read UserService
3. search Redis configuration
4. inspect pom.xml
5. inspect existing cache usage
6. design implementation
7. edit files
8. run tests
9. observe failure
10. fix
11. rerun tests
12. verify这就是：
Agentic Coding
五、OpenCode 的 Agent 类型
OpenCode 当前包含多个内置 Agent，例如：
build
plan
general
explore官方源码/文档显示，build 是主要的开发 Agent，plan 用于只读分析和规划，general 和 explore 用于复杂搜索和多步骤任务。(GitHub)
可以理解成：
OpenCode
│
┌────────────┼────────────┐
↓ ↓ ↓
build plan subagents
│ │ │
Coding Analysis Research
Editing Planning Exploration
Testing六、Build Agent
这是最常用的。
build主要负责：
Read
Edit
Bash
Search
Test
Git例如：
Implement Redis caching for UserService.它可以真正修改项目。
所以：
build = Developer Agent七、Plan Agent
Plan Agent 非常重要。
它主要解决：
先理解，再修改。
例如：
plan
Analyze how authentication works in this project.
Do not modify files.它可以：
Repository
↓
Explore
↓
Architecture
↓
Dependencies
↓
Call Graph
↓
Plan然后你再切换：
plan
↓
review
↓
build这其实是非常好的 Agentic Coding 实践。
八、Explore Agent
Explore 更适合：
Search
Analyze
Understand例如：
Find all places where UserRepository is used.它可以快速：
Repository
↓
Search
↓
Relevant Files
↓
Relationships而不需要马上修改代码。
九、Sub-Agent
这是 OpenCode 很值得研究的能力。
可以形成：
Main Agent
│
┌──────────┼──────────┐
↓ ↓ ↓
Explore General Custom
Agent Agent Agent
│ │ │
↓ ↓ ↓
Search Research Specialized例如：
Main Agent
"Modernize this Spring Boot project"可以拆：
Agent A → Analyze dependencies
Agent B → Analyze database
Agent C → Analyze tests
Agent D → Analyze security然后 Main Agent 汇总。
这就是：
Multi-Agent Coding
十、Tools 是 OpenCode 的核心
OpenCode Agent 不是单纯调用 LLM。
它需要 Tools。
可以抽象成：
Agent
│
├── read
├── edit
├── glob
├── grep
├── bash
├── webfetch
├── websearch
├── lsp
├── task
├── todowrite
└── skill因此：
LLM
+
Tools
+
Agent Loop
=
Coding Agent这是 OpenCode 最重要的原理。
十一、Context Engineering
OpenCode 的效果很大程度取决于 Context。
可以理解为：
Context
│
┌────────────┼────────────┐
↓ ↓ ↓
Code Git Instructions
│ │ │
↓ ↓ ↓
Files History Rules
│ │
└────────────┬────────────┘
↓
LLM例如：
用户：
Fix authentication bug真正给模型的东西可能是：
System Prompt
+
User Request
+
Relevant Java Files
+
SecurityConfig
+
JWT Service
+
Tests
+
Git Diff
+
Project Rules
+
Skills
+
Available Tools所以 Agentic Coding 的一个核心技术实际上是：
Context Engineering
十二、OpenCode Skills
这是 OpenCode 非常值得你重点研究的功能。
官方当前支持：
.opencode/skills/<name>/SKILL.md以及全局：
~/.config/opencode/skills/<name>/SKILL.md也兼容一些其他 Agent Skills 目录。(开源代码)
例如：
.opencode/
└── skills/
└── oracle-migration/
└── SKILL.md里面可以写：
# Oracle Migration Skill
Use this skill when migrating Oracle
database schemas to PostgreSQL.
Rules:
1. Analyze Oracle schema first.
2. Preserve business semantics.
3. Convert NUMBER carefully.
4. Convert sequences.
5. Convert procedures.
6. Generate migration SQL.
7. Generate validation SQL.
8. Generate rollback strategy.这样 Agent 遇到：
Migrate CUSTOMER table可以根据 Skill 描述决定是否加载它。
十三、Skill 和 Command 的区别
这是一个非常重要的设计区别。
Command
用户主动调用：
/review适合：
我明确要求执行某个工作流。
Skill
Agent 根据任务自动判断：
"我现在需要 Oracle Migration Skill"适合：
当某种任务出现时自动加载专业知识。
所以：
Command
=
User-driven workflow
Skill
=
Agent-discovered expertiseOpenCode 当前文档和生态中也明确区分了这两种机制。(GitHub)
十四、Commands
OpenCode 可以定义自己的：
.opencode/command/例如：
.opencode/
└── command/
├── review.md
├── test.md
├── deploy.md
└── migrate.md比如：
/review实际执行一个预定义 Prompt。
官方当前 Command 文件支持 description、agent、model 等 frontmatter，并支持 $ARGUMENTS 参数。(GitHub)
例如：
---
description: Review current code changes
agent: build
---
Review the current changes.
Check:
- bugs
- security
- performance
- tests
- backward compatibility
$ARGUMENTS然后：
/review authentication十五、Custom Agent
OpenCode 可以创建自己的 Agent。
例如：
.opencode/
└── agent/
├── architect.md
├── developer.md
├── tester.md
├── security.md
└── reviewer.md于是可以建立：
AI Team
│
┌───────────────┼───────────────┐
↓ ↓ ↓
Architect Developer Tester
│ │ │
└───────────────┼───────────────┘
↓
Reviewer这就是你之前研究的：
AI Software Development Team
十六、MCP
OpenCode 对 MCP 支持非常重要。
官方当前支持：
opencode mcp add
opencode mcp list
opencode mcp auth
opencode mcp debug也支持 Remote MCP 和 Local MCP。(开源代码)
例如：
opencode mcp add context7 \
--url https://mcp.context7.com/mcp然后：
opencode mcp list你可以得到：
context7 connected十七、OpenCode + MCP 的真正价值
例如你做企业 Java 项目：
OpenCode
│
┌────────────────┼────────────────┐
↓ ↓ ↓
GitHub Jira GCP
MCP MCP MCP
│ │ │
↓ ↓ ↓
Repository Issues Cloud然后：
Jira Issue
↓
OpenCode
↓
读取需求
↓
GitHub MCP
↓
读取代码
↓
GCP MCP
↓
查询部署信息
↓
修改代码
↓
测试
↓
PR这已经不是简单的 AI Coding。
而是：
AI Software Engineer
十八、Model-Agnostic 是 OpenCode 的重要优势
OpenCode 最大的一个设计思想：
Agent 和 Model 解耦。
例如：
OpenCode
│
├── OpenAI
├── Anthropic
├── Google
├── Alibaba
├── DeepSeek
├── OpenRouter
└── Custom Provider你可以：
Agent
↓
Model Provider
↓
Model例如：
opencode
↓
anthropic/claude...或者：
opencode
↓
openai/...或者：
opencode
↓
modelstudio/qwen...对于你之前研究的 阿里百炼 + Qwen + OpenCode，这点尤其重要。
官方目前支持：
opencode models查看模型，也可以：
opencode models --refresh刷新模型列表。(GitHub)
十九、OpenCode 的 CLI
最基本：
opencode启动 TUI。官方 CLI 目前也支持直接运行 Prompt：(GitHub)
opencode run "Explain this project"所以：
Interactive Mode和：
Automation Mode都可以。
二十、OpenCode 常用命令
建议你重点记下面这些。
启动
opencode指定项目
opencode /path/to/project直接执行
opencode run "Explain this project"指定 Model
opencode -m provider/model查看模型
opencode models刷新模型
opencode models --refreshMCP
opencode mcp listopencode mcp addopencode mcp authopencode mcp debug <name>Agent
opencode agent创建：
opencode agent create当前 CLI 可以在创建 Agent 时指定：
description
mode
permissions
model以及 bash/read/edit/glob/grep/webfetch/task/todowrite/websearch/lsp/skill 等权限。(GitHub)
二十一、OpenCode Session
OpenCode 的一个重要概念是：
Session可以理解为：
Session
│
├── User Messages
├── Agent Messages
├── Tool Calls
├── Tool Results
├── Context
├── Files
└── Changes所以：
Task
↓
Session
↓
Agent Loop
↓
Result这也是 Agent Runtime 非常重要的一层。
二十二、OpenCode 与 Git
OpenCode 很适合直接工作在 Git Repository。
典型流程：
git checkout -b feature/xxx
↓
opencode
↓
Explore
↓
Plan
↓
Implement
↓
Test
↓
git diff
↓
Code Review
↓
git commit
↓
git push
↓
Pull Request因此我建议：
永远让 Agent 工作在 Git Branch 中。
不要直接让 Agent 在生产代码上大规模修改。
二十三、OpenCode 的一个典型项目架构
如果你真正准备长期使用 OpenCode，我建议：
my-project/
│
├── .opencode/
│ │
│ ├── agent/
│ │ ├── architect.md
│ │ ├── developer.md
│ │ ├── tester.md
│ │ └── reviewer.md
│ │
│ ├── skills/
│ │ ├── java-development/
│ │ │ └── SKILL.md
│ │ │
│ │ ├── oracle-migration/
│ │ │ └── SKILL.md
│ │ │
│ │ ├── spring-boot/
│ │ │ └── SKILL.md
│ │ │
│ │ └── security/
│ │ └── SKILL.md
│ │
│ ├── command/
│ │ ├── review.md
│ │ ├── test.md
│ │ ├── migrate.md
│ │ └── release.md
│ │
│ └── plugins/
│
├── src/
├── tests/
├── AGENTS.md
├── README.md
└── opencode.json这个结构已经非常接近：
AI Software Factory Repository
二十四、OpenCode + AGENTS.md
我特别建议你建立：
AGENTS.md里面描述：
# Project Engineering Rules
## Architecture
Spring Boot 3
Java 21
PostgreSQL
Redis
## Coding
Use constructor injection.
Do not use field injection.
## Testing
JUnit 5
Mockito
Every service requires unit tests.
## Database
Never modify schema manually.
All schema changes must have migration scripts.
## Git
Use feature branches.
Never commit directly to main.这样：
User
↓
OpenCode
↓
AGENTS.md
↓
AgentAgent 才会真正知道：
这个项目应该怎么开发。
二十五、OpenCode 的完整 Agent Architecture
把前面所有东西组合起来：
User
│
▼
OpenCode CLI
│
▼
Agent Runtime
│
┌─────────────────┼─────────────────┐
↓ ↓ ↓
Context Model Tools
│ │ │
AGENTS.md Claude Read
Source Code GPT Edit
Git Qwen Bash
Skills Gemini Git
Session DeepSeek LSP
│ │ MCP
└─────────────────┼─────────────────┘
↓
Agent Loop
│
┌───────────┴───────────┐
↓ ↓
Planning Acting
│ │
└───────────┬───────────┘
↓
Observe
↓
Test
↓
Verify
↓
Git / PR二十六、OpenCode 与 Copilot 的架构对比
| 能力 | GitHub Copilot | OpenCode |
|---|---|---|
| Code Completion | ✅ | 核心不是这个 |
| Chat | ✅ | ✅ |
| Agent | ✅ | ✅ |
| CLI | ✅ | ✅ |
| Plan | ✅ | ✅ |
| Sub-Agent | ✅ | ✅ |
| MCP | ✅ | ✅ |
| Skills | ✅ | ✅ |
| Custom Agent | ✅ | ✅ |
| Git | 深度集成 | 深度集成 |
| GitHub | 极强 | 支持 |
| Cloud Agent | 强 | 有 GitHub Agent 能力 |
| Model Choice | 相对受平台约束 | 非常开放 |
| Open Source | ❌ | ✅ |
| Agent Runtime 可研究性 | 中 | 高 |
| 企业内部定制 | 强 | 非常适合自行定制 |
这里最值得你注意的是：
Copilot 更像完整的商业软件工程平台；OpenCode 更像可以自己改造的 Agent Runtime。
二十七、OpenCode 和你之前的 OpenClaw 有什么区别？
这个问题其实非常关键。
我会这样划分：
AI Agent Ecosystem
Agent
│
┌────────────┴────────────┐
↓ ↓
Coding Agent General Agent
│ │
OpenCode OpenClaw
│ │
┌────┼────┐ ┌────┼────┐
↓ ↓ ↓ ↓ ↓ ↓
Code Git Test Feishu Email Web所以：
OpenCode
主要目标：
Software Engineering Agent
重点：
Code
Git
Terminal
LSP
MCP
Test
Build
PROpenClaw
更接近：
General Purpose Personal / Business Agent
重点：
Messaging
Browser
Tools
Skills
Memory
Scheduling
External Systems二十八、OpenCode + OpenClaw
真正有意思的是把两个组合起来：
OpenClaw
│
Business Agent
│
┌─────────┴─────────┐
↓ ↓
Jira Feishu
│ │
└─────────┬─────────┘
↓
Coding Task
↓
OpenCode
│
┌────────┼────────┐
↓ ↓ ↓
Plan Code Test
│ │ │
└────────┼────────┘
↓
PR
↓
Human Review这就非常接近你之前想做的：
AI Software Factory
二十九、OpenCode + Harness
如果进一步加入 Harness：
Harness
│
▼
Engineering Loop
│
┌──────────────┼──────────────┐
↓ ↓ ↓
Context Rules Tools
│ │ │
└──────────────┼──────────────┘
↓
OpenCode
│
┌────────┼────────┐
↓ ↓ ↓
Agent Skills MCP
│ │ │
└────────┼────────┘
↓
Repository
↓
Test
↓
PR所以：
OpenCode 是 Coding Agent Runtime；Harness 是让 Agent 在工程规则下可靠工作的控制框架。
三十、如果做你的 AI Software Factory，我会这样设计
结合你之前提到的：
-
Spring / Spring Boot / Spring Cloud
-
150+ 微服务
-
Oracle → PostgreSQL
-
GCP
-
Redis
-
Jira
-
Jenkins
-
GitHub
-
OpenCode
-
OpenClaw
可以设计：
OpenClaw
Business Agent
│
↓
Jira
│
↓
Requirement Agent
│
↓
Architecture Agent
│
↓
OpenCode
│
┌───────────────┼───────────────┐
↓ ↓ ↓
Developer Database Test
Agent Agent Agent
│ │ │
└───────────────┼───────────────┘
↓
Security Agent
↓
Review Agent
↓
GitHub
↓
PR
↓
Jenkins
↓
Deploy
↓
GCP而：
Skills
MCP
AGENTS.md
Commands
Rules
Plugins构成整个 Factory 的：
Engineering Knowledge Layer
三十一、我建议你这样学习 OpenCode
不要从：
怎么安装 OpenCode开始学。
应该按照：
Level 1
OpenCode CLI
↓
Level 2
Agent
↓
Level 3
Tool Calling
↓
Level 4
Context Engineering
↓
Level 5
AGENTS.md
↓
Level 6
Commands
↓
Level 7
Skills
↓
Level 8
Sub-Agent
↓
Level 9
MCP
↓
Level 10
Plugins
↓
Level 11
Git / PR / CI
↓
Level 12
AI Software Factory其中最重要的三个阶段：
第一阶段
Agent + Tools理解：
Agent 为什么能写代码。
第二阶段
Context + Skills + MCP理解：
Agent 为什么能做专业的软件工程。
第三阶段
Multi-Agent + Git + CI/CD + Human理解：
Agent 如何从“编程助手”变成“软件工程团队”。
三十二、最终理解模型
如果让我用一句公式总结 OpenCode：
OpenCode
LLM
+
Context
+
Tools
+
Agent
+
Skills
+
MCP
+
Commands
+
Plugins
+
Git
+
Verification
↓
┌───────────────────┐
│ Coding Agent │
└─────────┬─────────┘
↓
Software Engineering
↓
AI Software Factory所以，OpenCode 真正值得研究的不是“如何让 AI 帮我写一段 Java”，而是：
如何把一个 LLM 变成一个可以理解大型代码库、使用工具、遵守工程规范、调用外部系统、拆分子任务、执行测试并通过 Git/PR 完成软件交付的软件工程 Agent。
这也是为什么我认为你之前研究的 OpenCode + OpenClaw + Harness + MCP + Skills + AGENTS.md + Jenkins + Jira，实际上可以统一到一张架构图里：
AI SOFTWARE FACTORY
│
┌────────────────────┼────────────────────┐
↓ ↓ ↓
Business Agent Engineering Agent Knowledge
OpenClaw OpenCode Skills
│ │ │
Jira/Feishu Code/Git/Test Rules/Docs
│ │ │
└────────────────────┼────────────────────┘
↓
Agent Runtime
│
┌────────────┼────────────┐
↓ ↓ ↓
MCP Tools Subagents
│ │ │
└────────────┼────────────┘
↓
Verification
│
Git / PR / CI
│
Jenkins/GCP这张图其实就是你后面研究 “OpenCode 源码 + Agent Harness + AI Software Factory” 时最重要的总纲。OpenCode 官方目前已经把 Agents、MCP、Skills、Commands、Plugins 和 GitHub Agent 等能力逐渐组合成了一个相对完整的 Agent 开发平台。(开源代码)
官方资料
如果把 Copilot 和 OpenCode 放在一起学习，我下一步最建议直接做一篇《Copilot vs OpenCode：源码级 Agent 架构对比》，把 Agent Loop → Context → Tool Calling → MCP → Skills → SubAgent → Memory → Git → CI/CD 一层层对应起来；这样会非常适合你后面继续研究 AI Software Factory。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
