@giladbarnea/pi-simple-team

A flat, live team of Pi agents.

Packages

Package details

extension

Install @giladbarnea/pi-simple-team from npm and Pi will load the resources declared by the package manifest.

$ pi install npm:@giladbarnea/pi-simple-team
Package
@giladbarnea/pi-simple-team
Version
1.0.16
Published
Aug 8, 2026
Downloads
1,789/mo · 1,166/wk
Author
giladbarnea
License
MIT
Types
extension
Size
2.3 MB
Dependencies
0 dependencies · 4 peers
Pi manifest JSON
{
  "extensions": [
    "./index.ts"
  ],
  "image": "https://raw.githubusercontent.com/giladbarnea/pi-simple-team/main/screenshots/pi-simple-team-banner.png"
}

Security note

Pi packages can execute code and influence agent behavior. Review the source before installing third-party packages.

README

pi-simple-team

The team extension with no features.

pi extension npm version tests license TypeScript tested with Bun

No roles. No org chart. No mailboxes. No routing rules.

pi-simple-team spawns a flat team of Pi agents that can all talk to each other, like the responsible adults they are, and then stays out of the way.


Why

I've always done my best work in a small room with a few capable people, building something together.

[shouts] Has anyone figured out how to set up auth yet?

Not filing a "request for assistance".

[taps shoulder] Dude can you grill me on this plan?

Not scheduling a meeting.

That's the whole design. Not a swarm, not a company. A room.

Using pi-simple-team

Tell your main agent:

Spawn a team.

Throw a team at something hard.

The team takes the shape of the mission.

Basic example: adversarial pair

You:

Create an implementer-reviewer team to complete PLAN.md.

Main agent:

Pair created. They'll loop through it together. They'll let me know when they're done.

Better example: build an agentic graph

You:

Team goal:

  1. map out all customer–product money streams in the database.
  2. Feed this knowledge into the harness.
  3. Then prove the data analysis agent passes the new evals.

Note:

  • #1 and #3 are loops. Call them 1-map and 3-eval.
  • 1-map and 3-eval each gets a teamate.
  • Each teammate spawns its own team to loop on its task.
flowchart LR
    subgraph map["1-map: map the money streams"]
        scout["`**Scout**
Runs repeatedly to clear
out the fog of war.`"] <--> advocate["`**Devil’s advocate**
Points out what we
still don’t know.`"]
    end

    harness["`**2: subagent dispatch**
Feeds new understanding
into the harness.`"]

    subgraph eval["3-eval: hill-climb the evals"]
        engineer["`**Engineer**
Improves the harness.`"] <--> watcher["`**Performance watcher**
Suggests a fresh approach
when stuck. `"]
    end

    map --> harness --> eval

Spawning a designer–adversary team, checking its status, and sending both teammates a shared instruction

The mechanics

🏋️ Woken up when needed. Works freely otherwise.

Tokens, intelligence and time are never wasted on busy-polling for messages.

Instead, pi-simple-team pushes messages to the receipients.

This is both efficient and effective:

  • ✔ No inbox to forget.
  • ✔ Context window stays lean.
  • ✔ Unlocks teams doing arbitrary workflows.

{screenshot of Codex filling up the entire visible chat with countless Waiting agents to finish...}

⚡ Messages arrive fast.

  • Sub-second, when the recipient is idle.
  • The moment the current bout of work ends, when busy.

🟢 Statuses everyone can see.

Teammates publish a one-liner:

implementer   Done, 89 tests green, awaiting review.

reviewer       Reading implementation, will finalize review in a few minutes"

Your main agent calls teamstatus and understands exactly what's going on. Main doesn't ask and clutter the teammates' context.

🌡️ Context window self-awareness

Teammates know how much free context they have left.

Main agent knows its own and everyone else's too.

📣 Interrupts, when justified.

Situation: Late afternoon. Team has finished a production hotfix and started to wrap up.

  • 17:32:00: Security scout spots a private SSH key not covered by .gitignore.
  • 17:32:01: Release teammate sets status: "Ran git add ., preparing commit and push."
  • 17:32:02: Scout immediately interrupts. Key never leaves the machine. Developer keeps their job.

📡 Complete observability by design.

The main agent can access one exhaustive, timestamped history of tool calls, messages, and lifecycle events, recorded by the harness itself.

Main can filter and page that shared timeline on demand.

Useful for tracing a failure across teammates—without asking anyone to reconstruct it from memory.

A live team status map above its timestamped event log

🪟 Herdr Mode

pi-simple-team can give each teammate a Pi session in its own Herdr pane. Just ask your main agent to do that.

  • Live view of the room.
  • Talk directly with teammates.

Install

pi install npm:@giladbarnea/pi-simple-team

Tools

Kept minimal:

Role For Tools
Main agent Team lifecycle team_spawn, team_shutdown
With team teamsend
On team teamstatus, teamlog
On everyone report_context_window
Teammates With team teamsend
With main teammain
On self report_context_window
Everyone For everyone teamstatus

Roadmap

User involvement track:

  • Herdr panes for teammates.

Slash commands for:

  • 💠 Live control panel.
  • 👋 Joining and steering teams.
  • 🪄 Spawning teams directly.

Functional:

  • Add new teammates after team has spawned.
  • Main forces /compact on select teammate.