Parley: cross-session peer agents for Claude Code — Building Products [Mischa Sigtermans](https://mischa.sigtermans.me) [ Thoughts ](https://mischa.sigtermans.me/thoughts) [ Books ](https://mischa.sigtermans.me/books) [ About ](https://mischa.sigtermans.me/about) [← Thoughts](https://mischa.sigtermans.me/thoughts) May 5, 2026 · AI Open Source How I made my Claude Code projects call each other ================================================== Cross-session peer agents for Claude Code. Parley lets one project ask another what it knows, with full context and memory across turns. This morning I asked [Stagent](https://stagent.com) for its OG image generator. From a Claude Code session in a completely different project. No new session, no new window. The Stagent agent read its own current code and came back with the generator class, the Blade template, and the Browsershot config. Thirty seconds. I never left the session I was working in. That's the [Parley Plugin for Claude Code](https://github.com/mischasigtermans/claude-parley). A cross-session bridge. Every project I've built becomes a peer agent. From any session, I can ask another project how it solved something, lift a component out of it, get a review from the project that's actually shipped that kind of code at scale, or hand it work to run on its end. All without leaving the project I'm in. Until last week, my projects couldn't talk to each other -------------------------------------------------------- I've got ten or so active projects on this laptop. Each one is its own loaded environment when I open it in Claude Code. Project CLAUDE.md. Skills directory. MCP servers wired up to Linear, Sentry, the database. Months of conventions encoded in `.claude/rules/`. All of it boots when I launch Claude Code. Each project also knows things the others don't. Cases I'd lose twenty minutes to: - 'How did I solve this last time?' Building a feature in a new project, I half-remember solving it in another one. I'd open that project, grep around, find one file, miss the related migration, copy something incomplete, debug for an hour. - 'Lift that component'. I want the rate-limiting middleware from onoma running in my new app. I'd open onoma, hunt for the middleware, the config, the test, copy each across, then realise halfway through that half of it depended on project-specific helpers I'd forgotten about. - 'Review what I just wrote, with your project's eyes'. Writing a webhook controller in a new project. Stagent has accumulated months of opinion on exactly this kind of code. I want Stagent's perspective on the file I just wrote, not a generic take from a session that's never seen Stagent. - 'Just go do this for me'. Run the migration in onoma. Open a PR on the blog with the draft I just finished. Push the staging build of stagent. Different project, different tools, work I want kicked off without leaving the one I'm in. You can fudge most of these by pointing the current session at the other project's directory. That works. Two problems with it. The current session burns thousands of tokens reading code unrelated to what you're building. And the agent doing the reading doesn't know that project the way the project's own agent does. No CLAUDE.md, no conventions, no months of accumulated context. You get a generic read of unfamiliar code, not an answer in the project's voice. You want the agent that lives there, not the one you brought. Every project becomes a peer ---------------------------- Parley turns each registered project into a peer agent. From any Claude Code or Cowork session, I ask a peer in plain English: > ask stagent how it handles webhook retries The `parley` skill picks up the alias and routes the call. Behind the scenes, Parley picks one of three tiers automatically: - **Live**. If the peer has Claude Code open in `/parley listen` mode, the question lands in their inbox. Their agent answers in their own window. I can watch it happen and intervene. - **Headless resumed**. No live listener, but Parley has a cached session for this peer. It runs the resume command in the peer's directory. The agent has memory of prior parley turns. - **Headless fresh**. First time I've asked, or the cache was reset. Parley spawns a fresh `claude -p` in the project directory and caches the new session ID for next time. The peer always runs from inside its own directory, with its CLAUDE.md, skills, and MCP servers already loaded. That's the whole point. I'm not asking Claude what it remembers about my Stagent codebase. I'm asking Stagent's agent to read Stagent's actual code and report back. Answers come with real file paths and real line numbers, because the agent looked. And when I ask it to do something instead of just explain something, run a script, kick off a deploy, open a PR, the same agent does the work with the same tools it'd use if I were sitting there myself. Every turn appends to a transcript at `~/.claude/parley/logs/.md`. So even when the answer came from a headless agent I never saw, I have the receipts. The remote-control angle I didn't expect ---------------------------------------- The use case that snuck up on me: running Parley from your home directory turns your whole laptop into a phone-controllable workspace. Here's what that looks like. Open one Claude Code session in `~`. Install Parley plus a Telegram MCP. Register your projects as peers. Now from my phone, on a train, on the couch, away from my desk: > how is the Stripe webhook fix going in stagent? The home session reads the message, routes it to Stagent's agent, which reads the actual code and replies. Stagent reports back. The home session forwards me the answer. > ask onoma to summarise yesterday's design doc Done. This isn't a chatbot. Each peer is the actual agent for that project, running with full tool access and its MCP servers wired up. From a phone, no laptop required, no tab-switching, no new sessions. It started as a side effect of the cross-project routing. It became the thing I check most. Registering peers in plain language ----------------------------------- `/parley discover` scans `~/.claude/projects` for projects you've used recently and aren't yet registered. It prints the candidates and waits. > add the first three as peers register that one as docs and that one as api add ~/Github/example as my-project The `parley` skill reads the names and calls `parley_add` for each. From then on, any session can reach them by alias. No JSON wrangling unless you want to. The peers list lives at `~/.claude/parley/peers.json`. Hand-editable. Every alias gets a path and an optional description. Headless spawns pass `--dangerously-skip-permissions` by default so they don't block on tool prompts. You can opt out per peer if you'd rather lock down what an agent does unattended. Day to day, the slash commands are escape hatches. Most of the time the `parley` skill handles routing when I reference another project in plain language. What Parley used to do, and doesn't anymore ------------------------------------------- The first version of Parley was also the way I gave the `*-says` personas (taylor, raymond, david, steve) durable memory. If you asked [Taylor](/thought/taylor-otwell-is-immortal-and-costs-200-month) to review some Laravel code, you wanted Taylor to remember last week's review. Parley made that work by treating each persona as a peer with a persistent headless session. That's now handled natively by [Personas](/thought/taylor-is-still-immortal-but-now-he-remembers). Personas-as-data, project-scoped threads, per-persona memory. No headless session juggling required. Parley is the cross-project consultation tool now. Personas have their own home. Both ship through the [Ryde Ventures plugin marketplace](https://github.com/rydeventures/claude-plugins). Installing it ------------- ``` /plugin marketplace add rydeventures/claude-plugins /plugin install claude-parley@rydeventures-claude-plugins ``` Works in both Claude Code and Cowork. The MCP server ships as a self-contained bundle. The only external dependency is `jq` for the session hooks. `brew install jq` on macOS, `apt install jq` on Linux. After install, run `/parley discover`, register the projects you want reachable, and start asking. The fleet talks now ------------------- My fleet of projects has gotten harder to manage as it's grown. Stagent. Onoma. Tiller. The blog. Half a dozen plugins. Each one carries its own context, its own conventions, its own accumulated knowledge. Each one used to live behind a `cd`. Parley is what it took for that fleet to start working together instead of sitting in separate windows. Every project is now a peer I can ask, lift from, or hand work to. Without leaving the one I'm in. And from my phone, the whole thing is one message away. Multiple projects open at the same time, one terminal in front of me. I haven't context-switched all week. *thanks for reading* Hi, I'm [Mischa](https://mischa.sigtermans.me/about). I've been *shipping products* and *building ventures* for over a decade. First exit at 25, second at 30. Now Partner & CPO at [Ryde Ventures](https://ryde.ventures), an AI venture studio in Amsterdam. Currently shipping [Stagent](https://stagent.com) and [Onoma](https://askonoma.com). Based in Hong Kong. I [write](https://mischa.sigtermans.me/thoughts) about what I learn along the way. [More about me](https://mischa.sigtermans.me/about). Keep reading: [Nightshift: why Friday's gig is on Saturday](https://mischa.sigtermans.me/thought/nightshift-why-fridays-gig-is-on-saturday). [← Thoughts](https://mischa.sigtermans.me/thoughts) Connect ------- [X](https://x.com/mischamartijn) [LinkedIn](https://linkedin.com/in/mischasigtermans) [GitHub](https://github.com/mischasigtermans) © 2026 · [RSS](feed:https://mischa.sigtermans.me/feed)