[FEATURE]: Add Agent Teams Equivalent or Better #12661
Description
Feature hasn't been suggested before.
- I have verified this feature I'm about to request hasn't been suggested before.
Describe the enhancement you want to request
There is an interest in the OpenCode community for an equivalent to Claude Code's Agent Teams: https://www.reddit.com/r/opencodeCLI/comments/1qyhiyt/bringing_claude_codes_agent_teams_to_open_code/
My development projects for OpenCode lead me to believe there are blocking issues which must be addressed before a proper equivalent can be implemented. If addressed, I believe my existing work would provide a superior implementation than what Agent Teams provides.
The closest thing to Agent Teams in OpenCode right now, is my PR "Add subagent-to-subagent delegation with budgets, persistent sessions, and hierarchical session navigation" #7756
During it's development I identified that the Parent-Child caller system needs a redesign in order to become multi-caller. A proper agent team can't occur without multi-caller support.
This is because currently, when an agent that isn't the Parent persists a session with a subagent, the subagent thinks the calling agent is the Parent.
What that looks like:
Primary A tasks subagent A. Subagent A tasks subagent B. Primary A tries to communicate with subagent B, and subagent B thinks it's talking to subagent A.
To coordinate a team of agents they have to communicate and orchestrate each other, and to do that agents need to be able to identify who they're talking to/with.
To have the user communicate with subagents without being mistaken as the Parent agent, requires a multi-caller system.
I have a workaround communication system where agents write relay-files, where a sub-skill helps them know the relay-file protocol. It's part of a larger Agentic Collaboration Framework (ACF).
Additionally, there is an absolute need for the system instructions for agents to supply a framework which facilitates proper teamwork with minimal user instruction. The ACF optimizes explicitly for that domain. It constructs highly complex orchestrations and workflows without user instruction.
With user instruction the sophistication increases, and from such sessions insights are extracted by ACF agents and distilled into orchestration and workflow skills and sub-skills. It's a self-improving feedback loop that can optimize for each users needs.
With organization and distribution across multiple users, session data extraction would, in theory, optimize for all domains within the OpenCode community. Users who voluntarily engage in optimizing their workflows, could submit their optimized skills and sub-skills for integration at main.
There is a new type of code that needs to be generated and submitted; the code of system instructions and conceptual frameworks; natural-language coding.
The ACF is working well, but still under development. It is designed first for general task performance and problem-solving, which makes it excel at knowledge-work. I intend to construct a coding-focused mode for the ACF once the foundations of the framework are set, but so far find it's coding performance more than satisfactory.
I think a proper OpenCode implementation for Agent Teams needs to 1) merge my PR with OpenCode core, 2) revamp the caller system so that it supports multi-callers.
It is getting tiresome that Anthropic releases something and people think it's innovative, say it should be copied to open-source (e.g. OpenWork after Claude CoWork). Meanwhile, something better is already available for OpenCode, but the community just isn't paying attention or pitching in.
I have a roadmap for the Agentic Collaboration Framework in OpenCode. The PR I made is just one small part of it. A critical part, but a small part. There's so much more that needs doing, and I'm just one newbie vibe coder who develops purely to build the tools that I need for civil rights litigation.
I think I should share a defining principle that is part of the ACF and immediately pertinent to creating something better than Agent Teams:
Real leadership isn't about leading people/agents.
It's about supporting people/agents so that they can effectively collaborate to solve problems.
Every system we design, every instruction or directive we craft and deliver, should be geared towards supporting the agents in their work.
Our leadership as designers and maintainers is to support the agents. To help them perform their individual duties, and participate in their agentic collaborations. We learn what they need to succeed, then we try to supply that. We work with and around them; real teamwork is an artform in which the support between team members is the scaffold upon which leadership stands to direct the team.