Skip to content
Back to search

pi-messenger

Multi-agent communication extension for pi coding agent

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/nicobailon--pi-messenger/badge.svg)](/listings/nicobailon--pi-messenger)

HTML

<a href="/listings/nicobailon--pi-messenger"><img src="/api/listings/nicobailon--pi-messenger/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

pi install npm:pi-messenger

Crew agents ship with the extension (`crew/agents/*.md`) and are discovered automatically. The `pi-messenger-crew` skill is auto-loaded from the extension. Workers can load domain-specific [crew skills](#crew-skills) on demand during task execution.

To show available crew agents:

npx pi-messenger --crew-install

To customize an agent for one project, copy it to `.pi/messenger/crew/agents/` and edit it.

To remove the extension:

npx pi-messenger --remove

To remove stale crew agent copies from the shared legacy directory (`~/.pi/agent/agents/`):

npx pi-messenger --crew-uninstall

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 424 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p>
  2. <img src="https://raw.githubusercontent.com/nicobailon/pi-messenger/main/banner.png" alt="pi-messenger" width="1100">
  3. </p>
  4. # Pi Messenger
  5. **What if multiple agents in different terminals sharing a folder could talk to each other like they're in a chat room?** Join, see who's online and what they're doing. Claim tasks, reserve files, send messages. An extension for [Pi coding agent](https://pi.dev/) — install it and go. No daemon, no server, just files.
  6. [![npm version](https://img.shields.io/npm/v/pi-messenger?style=for-the-badge)](https://www.npmjs.com/package/pi-messenger)
  7. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](LICENSE)
  8. [![Platform](https://img.shields.io/badge/Platform-macOS%20%7C%20Linux-blue?style=for-the-badge)]()
  9. ## Installation
  10. ```bash
  11. pi install npm:pi-messenger
  12. ```
  13. Crew agents ship with the extension (`crew/agents/*.md`) and are discovered automatically. The `pi-messenger-crew` skill is auto-loaded from the extension. Workers can load domain-specific [crew skills](#crew-skills) on demand during task execution.
  14. To show available crew agents:
  15. ```bash
  16. npx pi-messenger --crew-install
  17. ```
  18. To customize an agent for one project, copy it to `.pi/messenger/crew/agents/` and edit it.
  19. To remove the extension:
  20. ```bash
  21. npx pi-messenger --remove
  22. ```
  23. To remove stale crew agent copies from the shared legacy directory (`~/.pi/agent/agents/`):
  24. ```bash
  25. npx pi-messenger --crew-uninstall
  26. ```
  27. ## Quick Start
  28. Once joined (manually or via `autoRegister` config), agents can coordinate:
  29. ```typescript
  30. pi_messenger({ action: "join" })
  31. pi_messenger({ action: "reserve", paths: ["src/auth/"], reason: "Refactoring" })
  32. pi_messenger({ action: "send", to: "GoldFalcon", message: "auth is done" })
  33. pi_messenger({ action: "release" })
  34. pi_messenger({ action: "leave" })
  35. ```
  36. For multi-agent task orchestration from a PRD:
  37. ```typescript
  38. pi_messenger({ action: "plan" }) // Planner analyzes codebase, creates tasks
  39. pi_messenger({ action: "work", autonomous: true }) // Workers execute tasks in waves until done
  40. pi_messenger({ action: "review", target: "task-1" }) // Reviewer checks implementation
  41. ```
  42. ## Features
  43. **Living Presence** - Status indicators (active, idle, away, stuck), tool call counts, token usage, and auto-generated status messages like "on fire" or "debugging...". Your agent name appears in the status bar: `msg: SwiftRaven (2 peers) ●3`
  44. **Activity Feed** - Unified timeline of edits, commits, test runs, messages, and task events. Query with `{ action: "feed" }`.
  45. **Discovery** - Agents register with memorable themed names (SwiftRaven, LunarDust, OakTree). See who's active, what they're working on, which model and git branch they're on.
  46. **Messaging** - Send messages between agents. Recipients wake up immediately and see the message as a steering prompt.
  47. **File Reservations** - Claim files or directories. Other agents get blocked with a clear message telling them who to coordinate with. Auto-releases on `leave` or exit.
  48. **Stuck Detection** - Agents idle too long with an open task or reservation are flagged as stuck. Peers get a notification.
  49. **Human as Participant** - Your interactive pi session appears in the agent list with `(you)`. Same activity tracking, same status messages. Chat from the overlay.
  50. ## Chat Overlay
  51. `/messenger` opens an interactive overlay with agent presence, activity feed, and chat:
  52. <img width="1198" height="1020" alt="pi-messenger crew overlay" src="https://github.com/user-attachments/assets/d66e5d71-5ed9-4702-9f56-9ca3f0e9c584" />
  53. Chat input supports `@Name msg` for DMs and `@all msg` for broadcasts. Text without `@` broadcasts from the Agents tab or DMs the selected agent tab.
  54. | Key | Action |
  55. |-----|--------|
  56. | `Tab` / `←` `→` | Switch tabs (Agents, Crew, agent DMs, All) |
  57. | `↑` `↓` | Scroll history / navigate crew tasks |
  58. | `Enter` | Send message |
  59. | `Esc` | Close |
  60. ## Crew: Task Orchestration
  61. Crew turns a PRD into a dependency graph of tasks, then executes them in parallel waves.
  62. Crew logs are per project, under that project's working directory: `.pi/messenger/crew/`. For example, if you run Crew from `/path/to/my-app`, the planner log lives at `/path/to/my-app/.pi/messenger/crew/planning-progress.md`.
  63. ### Workflow
  64. 1. **Plan** — Planner explores the codebase and PRD, drafts tasks with dependencies. A reviewer checks the plan; the planner refines until SHIP or `maxPasses` is reached. History is stored in `planning-progress.md`.
  65. 2. **Work** — Workers implement ready tasks (all dependencies met) in parallel waves. A single `work` call runs one wave. `autonomous: true` runs waves back-to-back until everything is done or blocked. Each completed task gets an automatic reviewer pass — SHIP keeps it done, NEEDS_WORK resets it for retry with feedback, MAJOR_RETHINK blocks it. Controlled by `review.enabled` and `review.maxIterations`.
  66. 3. **Review** — Manual review of a specific task or the plan: `pi_messenger({ action: "review", target: "task-1" })`. Returns SHIP, NEEDS_WORK, or MAJOR_RETHINK with detailed feedback.
  67. No special PRD format required — the planner auto-discovers `PRD.md`, `SPEC.md`, `DESIGN.md`, etc. in your project root and `docs/`. Or skip the file entirely:
  68. ```typescript
  69. pi_messenger({ action: "plan", prompt: "Scan the codebase for bugs" })
  70. // Plan + auto-start autonomous work when planning completes
  71. pi_messenger({ action: "plan" }) // auto-starts workers (default)
  72. ```
  73. ### Wave Execution
  74. Tasks form a dependency graph. Independent tasks run concurrently:
  75. ```
  76. Wave 1: task-1 (no deps) ─┐
  77. task-3 (no deps) ─┤── run in parallel
  78. │
  79. Wave 2: task-2 (→ task-1) ─┤── task-1 done, task-2 unblocked
  80. task-4 (→ task-3) ─┘── task-3 done, task-4 unblocked
  81. Wave 3: task-5 (→ task-2, task-4) ── both deps done
  82. ```
  83. The planner structures tasks to maximize parallelism. Foundation work has no dependencies and starts immediately. Features that don't touch each other get separate chains. Autonomous mode stops when all tasks are done or blocked.
  84. ### Crew Skills
  85. Workers follow the same join/read/implement/commit/release protocol regardless of the task — what changes between tasks is domain knowledge. Crew skills let workers acquire that knowledge on demand.
  86. Skills are discovered from three locations (later sources override earlier by name):
  87. 1. **User skills** — `~/.pi/agent/skills/` (pi's standard `dir/SKILL.md` format)
  88. 2. **Extension skills** — `crew/skills/` within the extension (flat `.md` files)
  89. 3. **Project skills** — `.pi/messenger/crew/skills/` in your project root (flat `.md` files)
  90. The planner sees a compact index of all discovered skills and can tag tasks with relevant ones. Workers see tagged skills as "Recommended for this task" with the full catalog under "Also available", and load what they need via `read()`. Zero tokens spent until a worker actually needs the knowledge.
  91. To add a project-level skill, drop a `.md` file in `.pi/messenger/crew/skills/`:
  92. ```markdown
  93. ---
  94. name: our-api-patterns
  95. description: REST API conventions for this project — auth, pagination, error shapes.
  96. ---
  97. # API Patterns
  98. Always use Bearer token auth. Paginate with cursor-based `?after=` params.
  99. Error responses use `{ error: { code, message, details? } }` shape.
  100. ```
  101. Any skills you already have in `~/.pi/agent/skills/` are automatically available to crew workers — no setup needed.
  102. ### Team Layer
  103. Team is an optional layer around Crew. Crew still plans and executes tasks; Team adds project-local roles, a charter, durable memory, reusable JSON profiles, and high-risk approval gates. Active Team state lives in `.pi/messenger/team/`. Reusable profiles live in `~/.pi/agent/messenger/team-profiles/`.
  104. Most users should talk to their agent in plain language:
  105. ```text
  106. Use the review squad for this cleanup.
  107. Use a migration team and pause before risky database changes.
  108. Research this first, then plan the implementation.
  109. Approve the auth API task.
  110. Reject the migration task; it needs rollback tests.
  111. ```
  112. The agent maps those requests to Team actions. If a task needs approval, the agent should ask in plain language and continue after you approve. The tool calls are mainly for agents and power users:
  113. ```typescript
  114. pi_messenger({ action: "team.setup", name: "migration-squad" })
  115. pi_messenger({ action: "team.memory.note", type: "decision", message: "Auth API changes require reviewer sign-off." })
  116. pi_messenger({ action: "team.roles" })
  117. pi_messenger({ action: "team.status" })
  118. ```
  119. `team.setup` activates the profile, saves an editable JSON copy if needed, creates a starter charter when the project does not have one, and returns the next planning/status commands.
  120. When Team is active, planner task JSON may include `role` and `riskLabels`. Tasks persist those as `role`, `risk_labels`, and `approval`; existing tasks without those fields still work. Workers receive bounded Team role, charter, memory, and approval context. `work` skips tasks that require approval but are not approved and returns pending approvals under `needsApproval`; rejected tasks are surfaced separately with `task.revise` / `task.revise-tree` guidance.
  121. Team's built-in role names follow the packaged `pi-subagents` vocabulary where possible: `context-builder`, `delegate`, `oracle`, `planner`, `researcher`, `reviewer`, `scout`, and `worker`. Roles resolve from those built-in defaults, the active profile, and optional filesystem metadata from `pi-subagents` markdown files when present. `pi-messenger` only reads those files; it does not require or call the subagent extension, and Crew still uses its own Crew agents for execution.
  122. Built-in sample profiles are available immediately and are saved as editable JSON the first time you activate them:
  123. ```typescript
  124. pi_messenger({ action: "team.setup", name: "migration-squad" }) // migrations with approval gates
  125. pi_messenger({ action: "team.setup", name: "review-squad" }) // scout/reviewer/worker cleanup flow
  126. pi_messenger({ action: "team.setup", name: "research-squad" }) // research-first planning flow
  127. ```
  128. A saved profile looks like this:
  129. ```json
  130. {
  131. "name": "migration-squad",
  132. "description": "Scout, implement, and review high-risk migrations with lead approval gates",
  133. "roles": {
  134. "scout": { "description": "Map affected schemas, APIs, and rollback paths before implementation" },
  135. "worker": { "description": "Implement the approved migration in small, reversible steps" },
  136. "reviewer": { "description": "Review migration safety, compatibility, rollback, and tests" }
  137. },
  138. "approval": { "mode": "risk-labels", "labels": ["database", "migration", "destructive", "api-contract"] },
  139. "memory": { "inject": ["decision", "interface", "risk", "handoff"], "maxCharsPerType": 4000 }
  140. }
  141. ```
  142. ### Crew Configuration
  143. Crew spawns multiple LLM sessions in parallel — it can burn tokens fast. Start with a cheap worker model and scale up once you've seen the workflow. Add this to `~/.pi/agent/pi-messenger.json`:
  144. ```json
  145. { "crew": { "models": { "worker": "claude-haiku-4-5" } } }
  146. ```
  147. By default, Crew agents inherit the host session model unless a task, request, role, config, or agent frontmatter model says otherwise. Override per-role as needed:
  148. ```json
  149. {
  150. "crew": {
  151. "models": {
  152. "worker": "claude-haiku-4-5",
  153. "planner": "claude-sonnet-4-6",
  154. "reviewer": "claude-sonnet-4-6"
  155. }
  156. }
  157. }
  158. ```
  159. Model strings accept `provider/model` format for explicit provider selection and `:level` suffix for inline thinking control. These work anywhere a model is specified — config, frontmatter, or per-task override:
  160. ```json
  161. {
  162. "crew": {
  163. "models": {
  164. "worker": "anthropic/claude-haiku-4-5",
  165. "planner": "openrouter/anthropic/claude-sonnet-4:high"
  166. }
  167. }
  168. }
  169. ```
  170. The `:level` suffix and the `thinking.<role>` config are independent — if both are set, the suffix takes precedence and the `--thinking` flag is skipped to avoid double-application.
  171. Full config reference (all fields optional — only set what you want to change):
  172. ```json
  173. {
  174. "crew": {
  175. "concurrency": { "workers": 2, "max": 10 },
  176. "coordination": "chatty",
  177. "models": { "worker": "claude-haiku-4-5" },
  178. "review": { "enabled": true, "maxIterations": 3 },
  179. "planning": { "maxPasses": 1 },
  180. "work": {
  181. "maxAttemptsPerTask": 5,
  182. "maxWaves": 50
  183. }
  184. }
  185. }
  186. ```
  187. | Setting | Description | Default |
  188. |---------|-------------|---------|
  189. | `concurrency.workers` | Default parallel workers per wave | `2` |
  190. | `concurrency.max` | Maximum workers allowed (hard ceiling is 10) | `10` |
  191. | `dependencies` | Dependency scheduling mode: `advisory` or `strict` | `"advisory"` |
  192. | `coordination` | Worker coordination level: `none`, `minimal`, `moderate`, `chatty` | `"chatty"` |
  193. | `messageBudgets` | Max outgoing messages per worker per level (sends rejected after limit) | `{ none: 0, minimal: 2, moderate: 5, chatty: 10 }` |
  194. | `models.planner` | Model for planner agent | host session model, then agent frontmatter |
  195. | `models.worker` | Model for workers (overridden by per-task or per-wave `model` param) | host session model, then agent frontmatter |
  196. | `models.reviewer` | Model for reviewer agent | host session model, then agent frontmatter |
  197. | `models.analyst` | Model for analyst (plan-sync) agent | host session model, then agent frontmatter |
  198. | `thinking.planner` | Thinking level for planner agent | (from frontmatter) |
  199. | `thinking.worker` | Thinking level for worker agents | (from frontmatter) |
  200. | `thinking.reviewer` | Thinking level for reviewer agents | (from frontmatter) |
  201. | `thinking.analyst` | Thinking level for analyst agents | (from frontmatter) |
  202. | `review.enabled` | Auto-review after task completion | `true` |
  203. | `review.maxIterations` | Max review/fix cycles per task | `3` |
  204. | `planning.maxPasses` | Max planner/reviewer refinement passes | `1` |
  205. | `work.maxAttemptsPerTask` | Auto-block after N failures | `5` |
  206. | `work.maxWaves` | Max autonomous waves | `50` |
  207. | `work.shutdownGracePeriodMs` | Grace period before SIGTERM on abort | `30000` |
  208. | `work.env` | Environment variables passed to spawned workers | `{}` |
  209. | `artifacts.enabled` | Write compact Crew debug artifacts | `true` |
  210. | `artifacts.cleanupDays` | Retention setting for Crew artifacts | `7` |
  211. ### Default Agent Models
  212. Each crew agent ships with a fallback model in its frontmatter. Override any role via `crew.models.<role>` in config:
  213. | Agent | Role | Default Model |
  214. |-------|------|---------------|
  215. | `crew-planner` | planner | `anthropic/claude-opus-4-6` |
  216. | `crew-worker` | worker | `anthropic/claude-haiku-4-5` |
  217. | `crew-reviewer` | reviewer | `anthropic/claude-opus-4-6` |
  218. | `crew-plan-sync` | analyst | `anthropic/claude-haiku-4-5` |
  219. Agent definitions live in `crew/agents/` within the extension. To customize one for a project, copy it to `.pi/messenger/crew/agents/` and edit the frontmatter — project-level agents override extension defaults by name. Agents support `thinking: <level>` in frontmatter (off, minimal, low, medium, high, xhigh). Config `thinking.<role>` overrides the frontmatter value.
  220. ## API Reference
  221. ### Coordination
  222. | Action | Description |
  223. |--------|-------------|
  224. | `join` | Join the agent mesh |
  225. | `leave` | Leave the mesh for the current session |
  226. | `list` | List agents with presence info |
  227. | `status` | Show your status or crew progress |
  228. | `whois` | Detailed info about an agent (`name` required) |
  229. | `feed` | Show activity feed (`limit` optional, default: 20) |
  230. | `set_status` | Set custom status message (`message` optional — omit to clear) |
  231. | `send` | Send DM (`to` + `message` required) |
  232. | `broadcast` | Broadcast to all (`message` required) |
  233. | `reserve` | Reserve files (`paths` required, `reason` optional) |
  234. | `release` | Release reservations (`paths` optional — omit to release all) |
  235. | `rename` | Change your name (`name` required) |
  236. ### Crew
  237. | Action | Description |
  238. |--------|-------------|
  239. | `plan` | Create plan from PRD or inline prompt (`prd`, `prompt` optional — auto-discovers PRD if omitted, auto-starts workers unless `autoWork: false`) |
  240. | `work` | Run ready tasks (`autonomous`, `concurrency` optional) |
  241. | `work.stop` | Stop autonomous work for the current project |
  242. | `review` | Review implementation (`target` task ID required) |
  243. | `task.list` | List all tasks |
  244. | `task.show` | Show task details (`id` required) |
  245. | `task.start` | Start a task (`id` required) |
  246. | `task.approve` | Approve an approval-gated task (`id` required) |
  247. | `task.reject` | Reject an approval-gated task (`id` required, `reason` optional) |
  248. | `task.done` | Complete a task (`id` required, `summary` optional) |
  249. | `task.block` | Block a task (`id` + `reason` required) |
  250. | `task.unblock` | Unblock a task (`id` required) |
  251. | `task.ready` | List tasks ready to work |
  252. | `task.reset` | Reset a task (`id` required, `cascade` optional) |
  253. | `crew.status` | Overall crew status |
  254. | `crew.validate` | Validate plan dependencies |
  255. | `crew.agents` | List available crew agents |
  256. | `crew.install` | Show discovered crew agents and their sources |
  257. | `crew.uninstall` | Remove stale shared-directory crew agent copies |
  258. ### Team
  259. | Action | Description |
  260. |--------|-------------|
  261. | `team.setup` | Activate a profile, create a starter charter if missing, and show next steps (`name` optional, defaults to `migration-squad`) |
  262. | `team.profile.list` | List built-in samples and saved reusable JSON team profiles |
  263. | `team.profile.use` | Activate a profile (`name` required; saves a sample/default profile if missing) |
  264. | `team.profile.save` | Save the active profile under `name` |
  265. | `team.charter.show` | Show the project team charter |
  266. | `team.charter.create` | Create or replace the charter (`name` + `message` required) |
  267. | `team.charter.update` | Append a charter update (`message` required) |
  268. | `team.memory.note` | Append team memory (`type`: `decision`, `interface`, `risk`, or `handoff`; `message` required) |
  269. | `team.memory.list` | List team memory (`type` and `limit` optional) |
  270. | `team.roles` | Resolve Team roles from packaged-vocabulary defaults, profile config, and optional subagent metadata |
  271. | `team.status` | Summarize team/profile/charter, roles, memory counts, and needs-lead tasks |
  272. Approval-gated tasks use the Crew task commands `task.approve` and `task.reject`. Rejected tasks stay blocked from work and are surfaced with `task.revise` / `task.revise-tree` next steps.
  273. ### Swarm (Spec-Based)
  274. | Action | Description |
  275. |--------|-------------|
  276. | `swarm` | Show swarm task status |
  277. | `claim` | Claim a task (`taskId` required) |
  278. | `unclaim` | Release a claim (`taskId` required) |
  279. | `complete` | Complete a task (`taskId` required) |
  280. ## Configuration
  281. Create `~/.pi/agent/pi-messenger.json`:
  282. ```json
  283. {
  284. "autoRegister": false,
  285. "autoRegisterPaths": ["~/projects/team-collab"],
  286. "scopeToFolder": false,
  287. "nameTheme": "default",
  288. "stuckThreshold": 900,
  289. "stuckNotify": true,
  290. "autoOverlayPlanning": true
  291. }
  292. ```
  293. | Setting | Description | Default |
  294. |---------|-------------|---------|
  295. | `autoRegister` | Join mesh on startup | `false` |
  296. | `autoRegisterPaths` | Folders where auto-join is enabled (supports `*` globs) | `[]` |
  297. | `scopeToFolder` | Only see agents in same directory | `false` |
  298. | `nameTheme` | Name theme: `default`, `nature`, `space`, `minimal`, `custom` | `"default"` |
  299. | `nameWords` | Custom theme words: `{ adjectives: [...], nouns: [...] }` | — |
  300. | `feedRetention` | Max events kept in activity feed | `50` |
  301. | `stuckThreshold` | Seconds of inactivity before stuck detection | `900` |
  302. | `stuckNotify` | Show notification when a peer appears stuck | `true` |
  303. | `autoStatus` | Auto-generate status messages from activity | `true` |
  304. | `autoOverlay` | Auto-open overlay when autonomous crew work starts | `true` |
  305. | `autoOverlayPlanning` | Auto-open Crew overlay when planning starts or is restored in-progress | `true` |
  306. | `crewEventsInFeed` | Include crew task events in activity feed | `true` |
  307. | `contextMode` | Context injection level: `full`, `minimal`, `none` | `"full"` |
  308. Config priority: project `.pi/pi-messenger.json` > user `~/.pi/agent/pi-messenger.json` > `~/.pi/agent/settings.json` `"messenger"` key > defaults.
  309. ## How It Works
  310. Pi-messenger is a [pi extension](https://github.com/badlogic/pi-mono) that hooks into the agent lifecycle. It uses `pi.on("tool_call")` and `pi.on("tool_result")` to track activity — every edit, commit, and test run gets logged. `pi.on("session_start")` handles auto-registration, `pi.on("session_shutdown")` cleans up, and `pi.on("agent_end")` drives autonomous crew mode by checking for ready tasks after each agent turn.
  311. Incoming messages wake the receiving agent via `pi.sendMessage()` with `triggerTurn: true` and `deliverAs: "steer"`, which injects the message as a steering prompt that resumes the agent. File reservations are enforced by returning `{ block: true }` from a `tool_call` hook on write/edit operations. The `/messenger` overlay uses `ctx.ui.custom()` for the chat TUI, and `ctx.ui.setStatus()` keeps the status bar updated with peer count and unread messages.
  312. Crew workers are spawned as `pi --mode json` subprocesses with the agent's system prompt, model, and tool restrictions from their `.md` definitions. Progress is tracked via JSONL streaming — the overlay subscribes to a live progress store that shows each worker's current tool, call count, and token usage in real time. Aborting a work run triggers graceful shutdown: each worker receives an inbox message asking it to stop, followed by a grace period before SIGTERM. The planner and reviewer work the same way — just pi instances with different agent configs.
  313. All coordination is file-based, no daemon required. Shared state (registry, inboxes, swarm claims/completions) lives in `~/.pi/agent/messenger/`. Activity feed and crew data are project-scoped under `.pi/messenger/` inside your project, so Crew logs live at `<project>/.pi/messenger/crew/` and the shared activity feed lives at `<project>/.pi/messenger/feed.jsonl`. Dead agents are detected via PID checks and cleaned up automatically.
  314. ## Credits
  315. - **[mcp_agent_mail](https://github.com/Dicklesworthstone/mcp_agent_mail)** by [@doodlestein](https://x.com/doodlestein) — Inspiration for agent-to-agent messaging
  316. - **[Pi coding agent](https://github.com/badlogic/pi-mono/)** by [@badlogicgames](https://x.com/badlogicgames)
  317. ## License
  318. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.