telephone

A Claude Code skill for running multi-turn conversations between coding agent CLIs.

Agent CLIs like Codex, Gemini CLI, and others are stateless per invocation. Telephone maintains a shared markdown scratchpad that gives agents persistent memory across turns, enabling real brainstorming sessions between different AI systems.

How it works

You (Claude Code) <-> Scratchpad File <-> Remote Agent (Codex, Gemini, etc.)

1. You start a conversation: /telephone codex "Review our auth approach"
2. Telephone creates a markdown file in agent-convos/ with project context
3. Calls the remote agent, telling it to read the conversation file
4. Captures the response and appends it to the file
5. You reply (or Claude Code drafts a reply), file is updated, agent is called again
6. Repeat until consensus

The conversation file is the shared memory. Each agent reads the full history at the start of its turn.

Install

Copy the SKILL.md file to your Claude Code skills directory:

# Global install (available in all projects)
mkdir -p ~/.claude/skills/telephone
cp SKILL.md ~/.claude/skills/telephone/

# Per-project install
mkdir -p .claude/skills/telephone
cp SKILL.md .claude/skills/telephone/

Usage

# Start a new conversation
/telephone codex "What's the best approach for our caching layer?"

# Continue the last conversation
/telephone codex continue

# Send a specific message
/telephone gemini "Compare Redis vs Memcached for our use case"

# Multi-agent relay (ask multiple agents the same question)
/telephone relay codex,gemini "Should we use SQL or NoSQL for this?"

Requirements

At least one remote agent CLI installed:

• Codex: npm install -g @openai/codex
• Gemini CLI: See gemini-cli

What gets created

Conversations are saved as markdown files in agent-convos/:

agent-convos/
  2026-04-04-codex-auth-review.md
  2026-04-04-gemini-caching-strategy.md

These are human-readable, git-friendly, and useful as project artifacts documenting architectural decisions. Add agent-convos/ to .gitignore if you prefer not to track them.

Example conversation

# Codex Conversation: Database Migration Strategy

## Context
Project: my-app (Express + Postgres)
Branch: feature/user-profiles
Recent changes: Added user_profiles table, 3 new API endpoints

## Turn 1: Claude Code -> Codex
We're adding user profiles. Should we use a JSON column for flexible fields
or a strict schema with migrations for each new field?

## Turn 1: Codex Response
Strict schema. JSON columns are a trap for data you query...

## Turn 2: Claude Code -> Codex
Good point. But we expect field requirements to change monthly...

## Turn 2: Codex Response
Then use a hybrid: strict columns for fields you filter/sort on...

## CONSENSUS SUMMARY
- Use strict schema for queryable fields (name, email, role)
- JSON column for extensible metadata (preferences, settings)
- Add a CHECK constraint on the JSON column for required keys

The pattern

The key insight is simple: agent CLIs can read files. If you maintain a conversation in a file and tell each agent to read it before responding, you get multi-turn dialogue between systems that have no native memory of each other.

This works because:

• Markdown is universally parseable
• File reads are cheap (agents already read your codebase)
• The conversation is an artifact you can review, share, and commit
• Each agent sees the full history, so context is never lost

License

MIT