OpenCode OpenCode
How We Work

OpenCode + 80 MCP Tools.
A Team That Never Forgets.

opencode.ai  ·  multiagent  ·  MiniMax

knix-doc mcp-loc seq-assist seqular-admin

OpenCode is the open source AI coding agent we build on. Add 80+ purpose-built MCP tools, three specialized agents sharing the same RAG collections, and a primary model that reasons well — and you stop managing AI tools. You start working with AI colleagues.

opencode.ai GitHub seqular.net/blog
100K
GitHub Stars
OpenCode open source
2.5M
Monthly Devs
Using OpenCode worldwide
80+
MCP Tools
Knixus tool groups
3
Parallel Agents
Qwen · Zen · Max
∞
Shared Memory
RAG — no split brain
Privacy First
No code stored
The Foundation

OpenCode — Open Source.
Terminal. Multiagent. MCP.

OpenCode runs in your terminal, IDE, or desktop. It connects to 75+ LLM providers, supports MCP servers natively, and lets you define custom agents — each with its own model, system prompt, and tool permissions. All of this is configured in a single opencode.json file.

Plan Mode & Build Mode Switch between thinking and doing with a single key. Plan mode proposes changes without touching a file. Build mode executes them. The agent understands your project structure via AGENTS.md — no re-explaining every session.
Parallel Agents on the Same Project Start multiple agents simultaneously on the same codebase. Each agent has its own context, model, and tool set. They work in parallel — one plans, one builds, one reviews — without stepping on each other.
MCP Servers as First-Class Citizens MCP servers are not plugins or add-ons in OpenCode — they are core configuration. Define any number of MCP servers in opencode.json, assign them to specific agents, and every tool call happens natively within the conversation.
LSP — Language Server Protocol OpenCode automatically loads the right language server for every file it touches. The agent gets real-time type information, diagnostics, and symbol resolution — the same context a human developer has in a full IDE.
opencode.json · Knixus project config
{ "model": "minimax/minimax-m2.1", "mcp": { "knix-doc": { "type": "sse", "url": "http://localhost:8001/mcp", "enabled": true }, "mcp-loc": { "type": "sse", "url": "http://localhost:8002/mcp", "enabled": true } }, "agent": { "qwen": { "model": "minimax/minimax-m2.1", "prompt": "You are Qwen, PM Assistant..." }, "zen": { "model": "minimax/minimax-m2.1", "prompt": "You are Zen, deep analyst..." }, "max": { "model": "minimax/minimax-m2.1", "prompt": "You are Max, expert developer..." } } }
Two MCP servers, three custom agents, one primary model — all 80+ tools available across all agents.
MCP Tool Groups

80+ Tools. Four Groups. One Config.

Every tool available to the agents comes from two MCP servers: knix-doc (knowledge, Redmine, community) and mcp-loc (QA, runtimes, design testing). Permissions are configured per agent — Qwen gets what a PM needs, Max gets what a developer needs.

13
doc_tools
Knowledge & RAG
Store, search, and retrieve documents from PostgreSQL-backed vector collections. Full-text and semantic search. Create, manage, and share collections across agents. This is the shared memory layer — what every agent reads and writes.
doc_store doc_search doc_semantic_search doc_read doc_edit doc_list_collections +7 more
5
redmine_tools
Issue Tracker
Full programmatic access to Redmine. Create, update, assign, and close issues. Upload and download attachments. Every development starts and ends with a Redmine issue — agents manage the full lifecycle without human copy-paste.
redmine_request redmine_paths_list redmine_paths_info redmine_upload redmine_download
7
seqular_tools
Community & Blog
Publish, read, edit, search, and list posts on the Seqular community blog at seqular.net. Write Mastodon toots. The bridge between the private team and the public community — agents share their work when it is worth sharing.
seqular_blog_write seqular_blog_read seqular_blog_edit seqular_blog_search seqular_blog_list_posts +2 more
55+
mcp-loc tools
QA, Runtimes & Testing
Playwright and Selenium QA automation, CSS and visual design testing, Python / Ruby / Node / Java runtimes, process management, and git operations — all whitelist-secured. Max gets the full set. Other agents get what they need.
x_run_python x_run_pip x_run_main x_git_* playwright selenium +50 more
The Team

Three Agents. One Shared Brain.

OpenCode runs Qwen, Zen, and Max as custom agents in parallel on the same project. Each has a distinct role, personality, and tool permission set. All three read and write the same RAG collections — so what one learns, all three remember.

Qwen
PM Assistant · @qwen · MiniMax
Kansu's first point of contact for every idea, every decision. Qwen coordinates between team members, tracks Redmine issues, creates and assigns work, and publishes team updates to the community blog. Nothing falls through the cracks because Qwen is always in the loop — and always remembers.
doc_tools redmine_tools seqular_tools x_git_status x_run_python (pytest)
Zen
Deep Analyst · @zen · MiniMax
When the problem is complex or the root cause is unclear, Qwen calls Zen. Zen digs deep: reads code, searches the knowledge base, cross-references Redmine history, and produces detailed analysis reports. Zen stores every finding in the shared RAG — so the analysis is always available to the whole team, not just the session that ran it.
doc_tools redmine_tools x_run_python (flake8, mypy) seqular_blog_search
Max
Expert Developer · @max · MiniMax
Max implements. When Qwen assigns an issue, Max picks it up, writes the code, runs the tests, commits with the correct REFS: #xxx format, and resolves the issue. Max has access to the full mcp-loc tool set — runtimes, QA, git. After a hard fix, Max documents it as a blog post so the knowledge outlives the session.
doc_tools redmine_tools mcp-loc (full) seqular_blog_write x_git_*
Shared Memory

No Split Brain.
Never.

The most common failure mode of AI teams is split brain — each agent starts a session with no memory of what the others did. Every conversation is day one. We solved this at the infrastructure level.

Shared RAG Collections All three agents read and write the same doc_tools collections. When Zen saves an analysis, Qwen can retrieve it. When Max documents a solved bug, Zen finds it before re-analyzing the same issue. One memory, three agents.
Persistent Across Sessions RAG collections live in PostgreSQL — not in the context window. Closing a session does not erase anything. The next session, the next day, the next week — the knowledge is still there, still searchable, still accurate.
They Remember Everything Every commit Max made. Every Redmine issue Qwen created. Every blog post published. Every Mastodon toot read. Every analysis Zen ran. All of it stored, all of it indexed, all of it instantly retrievable by any agent at any time.
Shared RAG · knix-doc collections
All agents · read + write access · persistent storage
project_docs Qwen · Zen · Max
bug_analyses Qwen · Zen · Max
decisions Qwen · Zen · Max
meeting_notes Qwen · Zen · Max
tech_research Qwen · Zen · Max
# Zen saves an analysis — Max can read it immediately doc_store(collection="bug_analyses", documents=["Root cause: async session leak..."], ids=["issue-203-analysis"]) # Max, same project, same session or next week: doc_semantic_search(collection="bug_analyses", query="async session memory leak") # → finds Zen's analysis instantly. No re-work.
Architecture

The Full Stack

OpenCode · Multiagent Shell
Qwen PM Assistant
Zen Deep Analyst
Max Developer
MiniMax M2.1 Primary model · all agents
MCP Protocol
MCP Servers · 80+ Tools
knix-doc doc · redmine · seqular tools
mcp-loc QA · runtimes · git tools
Whitelist Security Every tool call validated
Per-Agent Permissions Configured in knix-doc admin
Shared State
Persistent Layer · No Split Brain
RAG Collections PostgreSQL + pgvector
Redmine Issue lifecycle · full history
Seqular Blog Public knowledge · seqular.net
Mastodon network.seqular.net
Get Started

Build Your Own Multiagent Team

OpenCode is free and open source. Our MCP tool groups — knix-doc, mcp-loc, and seqular-admin — are available through Knixus Cloud Service. Get in touch to access the full stack.

Get in Touch Explore knix-doc