There are already many agent workflows today, and the coding agents on different platforms are getting quite strong. They already come with memory, tool calling, and all sorts of useful capabilities. In practice, we often use tools from multiple platforms, such as Claude Code, Copilot, OpenCode, and others. Each one is strong in its own way, with its own strengths and tradeoffs. But getting these CLI tools to interact with each other, and to keep interacting over time, is still not easy.

Under the openclaw project, there is something called acpx, which goes in a different direction. It requires customization for each agent, and the project describes itself with the line: “AI agents and orchestrators can talk to coding agents over a structured protocol instead of PTY scraping.” In the end, acpx itself is still a CLI.

What I wanted to test in this experiment was something simpler: with https://github.com/slaveoftime/open-relay, can we use a plain CLI approach to let one agent interact with any other CLI or agent CLI, including ones with multi-turn or even complex interactive flows? No special customization required. Large models are already quite good at understanding text. If they can understand the intent of a TUI and send the right instructions, this should be possible, right?

Letting Copilot Manage Qwen

Using oly, I put GitHub Copilot in the role of “manager / supervisor” and had it direct the qwen CLI to do the actual work inside the project directory. Copilot was responsible for understanding the goal, breaking down tasks, tracking progress, and pushing for delivery. Qwen was responsible for entering the directory, changing code, cleaning up the project, and writing documentation.

The project I used for the experiment was a real subproject related to open-relay: open-relay-wechat-hook.

• Clean up a WeChat hook .NET CLI program
• Tidy the project structure
• Write documentation
• Add a very integration-test-friendly feature: automatically open the browser so the user can scan the QR code for authentication

The Initial Prompt I Gave Copilot

This was roughly the prompt I gave Copilot at the beginning (without much prompt optimization in the initial experiment):

Run `oly skill` to learn its usage, and run `oly start -d qwen` appropriately to
work on project `C:\Users\woo\Documents\Code\Slaveoftime\open-relay-wechat-hook`.
You are the manager who are supposed to make decisions instead of do the actual work,
anything need to be done in that folder, you ask qwen to do it.
Push qwen to work, clean project, write docs.
Add a feature to automatically open browser to let user scan the QRCode for integration test.

In this prompt, I deliberately emphasized a few things.

First, Copilot should learn how to use oly first, instead of making assumptions.

Second, Copilot is not the one doing the coding itself. It is the manager, and its main job is to make decisions, assign work, and supervise execution.

Third, the goal is not something vague like “improve this a bit,” but a very concrete set of deliverables: clean up the project, write docs, and add the browser auto-open QR authentication flow.

Even though I told Copilot not to do the actual work, at the beginning it still wanted to analyze the project itself 😅. I had to hit ESC a bit to stop it.

open-relay

At its core, it is a CLI proxy that provides a more general, simple, and open way to connect and coordinate things:

• Connect agents with different strengths
• Forward, supervise, and resume tasks
• Make command-line workflows feel more like an orchestrated system
• Make “humans supervise AI, and AI supervises AI” actually practical
• Make any long-running CLI with multi-turn interaction easier for both humans and AI to use
• Stop you from having to sit in front of the screen waiting for servants like Claude Code to finish their performance

Final Thoughts

Once these roles are placed correctly, the whole development experience suddenly shifts from “I’m using tools” to “I’m leading a team.”

Overall, this was genuinely interesting. With a bit more prompt tuning for each role, a real team starts to emerge. No need for openclaw, no need for too much fancy machinery, and no need to over-engineer everything. Just stay close to the tools the major vendors already provide, combine them, and orchestrate them. Use a more expensive agent to manage cheaper agents, and reduce cost in a very straightforward way.