Show HN: A lightweight way to make agents talk without paying for API usage

For the past few weeks I have been testing a simple workflow for making coding agents interact with each other without using APIs, SDKs, or extra dependencies.

The main constraint is this: use the subscription plans you already have, avoid paying for API usage, and keep the setup simple enough that you can try it in a few minutes.

This became useful to me for two reasons:

• I sometimes want to extend a Claude session by asking Codex or Gemini to review or continue part of the work.
• I also want to delegate work and get different model perspectives on the same draft, spec, or implementation, instead of relying on a single vendor’s subagents.

This is not a polished framework. It is just a practical pattern that works well enough to test multi-agent workflows with very little setup.

The basic idea

Instead of integrating models through APIs, you let one agent invoke another through the CLI in a way that preserves the previous conversation.

For the non-interactive pattern, the key is to resume the previous session instead of starting a new one every time. The commands the agent should use are:

codex exec resume --last "prompt"
gemini -r latest -p "prompt"

The important part is that the agent resumes the previous interaction so it can keep iterating on the same topic instead of starting from zero on every call.

The more visible pattern: tmux

If you want better visibility, tmux is the better option. This version depends on having tmux installed, but in exchange you can see what each agent is doing in separate panes or sessions and capture their output more easily.

This pattern is better when:

• you want to watch the interaction as it happens
• you want to run two or more agents in parallel
• you want easier debugging when the workflow becomes messy

The main caveat

I think there is real value in getting multiple perspectives from different models, but I am still not fully convinced that more agent-to-agent interaction always pays off. LLMs are very good at producing plausible, well-written text. When they start talking to each other, they can produce a lot of it.

The harder question is whether the final result is actually better, or whether it is just a more polished hallucination produced after a longer chain of interactions.

In summary

If you already use subscription-based coding agents, the simplest way I have found to make them collaborate without paying for API usage is:

• use non-interactive calls with resume when you want simplicity
• use tmux when you want visibility and tighter control