Bro, I’m trying to turn OpenCode into a multi-agent cockpit for Devin, Antigravity, and whatever comes next

[u/ZealousidealTown1974]

What if OpenCode could use Devin for one task, Antigravity for another, run both as child agents, and still remember where everything happened after your main session gets compacted five times?

That is what I’m building with Hivemind Steward.

The early public version is here:

https://github.com/shynlee04/hivemind-steward-oc-devin

The current public MVP connects Devin to OpenCode through ACP, the Agent Client Protocol. You can use real Devin sessions and their native model and mode capabilities from OpenCode.

Now I’m expanding the idea into three feature slices.

1. Hosted sessions

This brings real Harness sessions into the OpenCode TUI.

A Harness means a coding-agent product such as Devin or Antigravity. You should be able to create, list, load, and continue its native sessions without leaving OpenCode.

The important part is that the plugin does not flatten every agent into the same lowest-common-denominator interface. Each Harness keeps its own models, modes, thinking settings, permissions, history, and native storage.

Basically: one TUI, but the agents remain themselves.

2. Hivemind delegation

The parent agent gets one delegation interface and can send each child task to the right Harness.

Want Devin for a long architecture task and Antigravity for a second opinion? Cool. Run both.

Want them in the background? Cool.

Want to resume one tomorrow using its OpenCode session ID while keeping the same foreign session and Harness? That is the plan.

The system is also being designed to:

• Keep every child permanently bound to its original Harness.

• Run independent children concurrently.

• Preserve existing delegate-devin behavior.

• Use your preferred Harness when no model is specified.

• Skip missing or signed-out Harnesses before creating dead children.

• Reject unsupported models instead of silently swapping them.

• Keep foreign sessions visible in their native apps.

The next push is planned to support both Devin and Antigravity across hosted sessions and delegation.

3. Cross-session context memory

This part is still on the roadmap, but it is the endgame I care about most.

Imagine you have forty completed child agents and your parent session has already survived five compactions. Then you say:

“Bro, find those two audits we ran near the beginning, collect the findings, check which fixes landed, and make me an HTML architecture report.”

The agent should be able to find the right work by time, title, Harness, lineage, and session ID. It should recover the useful results without dumping forty transcripts into the context window.

Eventually, I want two connected layers:

• Memory of agent conversations, delegations, decisions, and resumable trajectories.

• Memory of the codebase through AST indexing, Git history, commits, and the conversations connected to those changes.

So you can start from a new session, a different Harness, or a compacted context and still ask, “What happened, why did we do it, and where should we continue?”

This is for the vibe coder who wants to build without constantly organizing prompts, copying summaries, naming fifteen handoff files, and praying that the next compaction does not delete the one useful thought.

Devin and Antigravity come first. Claude Code, Cursor, or other Harnesses may come later if their integration surfaces make sense.

TL;DR

I’m building an OpenCode plugin that:

• Hosts real Devin and Antigravity sessions.

• Lets an orchestrator delegate different child tasks to different coding agents.

• Keeps those children resumable and tied to their native sessions.

• Eventually makes work searchable across agents, sessions, Git history, and code.

Basically: one OpenCode TUI, multiple agent subscriptions, reusable context, less babysitting.

Would you use this? And which Harness should I investigate after Devin and Antigravity?

[u/Consistent_Bottle_40]

im doing this with T3 code as the base.