Brand promise
Adapt pi to your workflows, not the other way around.
The site repeatedly frames Pi as a harness you reshape with packages, modes, and extensions instead of a finished assistant with one approved method.
Clickable ecosystem map
Navigate Pi by layer
This diagram is a shortcut, not decoration. Click a tile to jump into the part of the ecosystem that matches how you want to work.
Core layer
Minimal harness
Start with the small terminal-first center: modes, context, sessions, and Pi’s anti-bloat philosophy.
Open pi-mono ↗
Distribution layer
Packages
See how skills, prompts, themes, and reusable behavior actually spread through the ecosystem.
Open pi-skills ↗
Scaling layer
Automation
Jump into worktrees, queues, headless runs, and the shell-native branch that makes Pi feel operational.
Open PiSwarm ↗
Surface layer
Interfaces
Explore canvases, notifications, web overlays, and alternate surfaces over the same programmable center.
Open pi-canvas ↗
Boundary layer
Safety
Inspect the containment tools that show up once users want to trust Pi with more power and less supervision.
Open nono ↗
Core → understand Pi itself
Packages → steal working behaviors
Automation → scale throughput
Interfaces → choose the surface
Safety → add containment
Artifacts
108
Seed items
106
Deep profiles
12
Discovered beyond seed
2
Pi thesis
What makes this ecosystem different
A brand-level reading of the ecosystem before you dive into the inventory.
Pi is not trying to be the most feature-complete coding agent. Its center of gravity is a minimal terminal harness with enough hooks, modes, and packaging primitives that people can build their own workflow instead of inheriting somebody else’s.
What to notice first
The ecosystem keeps repeating four moves
- Start from a small terminal-first loop.
- Package useful behavior into inspectable assets.
- Escalate into JSON/RPC/scripts, queues, or worktrees when scale demands it.
- Add safety and oversight explicitly rather than assuming it is built in.
This is closer to Unix-style agent composition than to a single polished IDE product.
Brand diagnosis / main site
What the Pi brand is actually signaling
Grounded in pi.dev and pi-mono: what the product seems to believe about tools, users, and control.
The main public surface, pi.dev, is not branded like a giant AI suite. It reads like a stubbornly minimal tool for people who want leverage without surrendering control.
Aesthetic
Minimal, dry, anti-bloat, builder-first.
The voice is plainspoken and a little defiant. The presentation emphasizes capabilities, modes, packages, and control surfaces over polished lifestyle marketing.
Emotional pitch
Sovereignty over convenience.
Pi is for users who would rather assemble a sharp workflow themselves than accept a thick product layer full of hidden assumptions.
Core tension
Power first, safety later.
A lot of the ecosystem energy goes into making Pi more powerful, more scriptable, and more automatable. Containment shows up, but usually as an added capability.
Who it flatters
Terminal-native tinkerers, package authors, and orchestration-minded power users.
The brand assumes its ideal user likes primitives, modes, files, and inspectable packages more than glossy defaults.
What it is not
Not a polished “trust us, we solved everything” IDE brand.
Pi skips some expected baked-in features and effectively says: if you want that workflow, build or install it. That choice is central to the brand.
Evidence from the main surfaces
- “There are many coding agents, but this one is mine.”
- “Adapt pi to your workflows, not the other way around.”
- Four modes: interactive, print/JSON, RPC, and SDK.
- Packages are first-class: skills, prompt templates, themes, extensions, and command bundles.
Sources: pi.dev · pi-mono repo
Layer explorer
Click into the ecosystem by role
Use the layer model as navigation: each cluster represents a different way to adopt or extend Pi.
Think of these as the five recurring Pi layers. Each one gives you a different way to enter the ecosystem: learn the core, steal a package pattern, scale into orchestration, choose an interface, or add containment.
Layer
Minimal harness, not a giant product surface
The official Pi surfaces keep pointing back to a small core: terminal-first interaction, multiple run modes, controllable context, and extension points instead of a long baked-in feature list.
What you can do here: Use this layer to understand Pi itself: modes, context controls, session model, and the small-core philosophy.
Representative projects
Explore
Layer
Packages as the real distribution layer
What actually spreads through the ecosystem is not one canonical workflow. It is packages: skills, prompt templates, themes, extensions, and command bundles that can be cloned, symlinked, versioned, and shared.
What you can do here: Use this layer to steal and remix working behaviors: skills, prompts, themes, and reusable package layouts.
Representative projects
Explore
Layer
Terminal-native automation branches outward
Once users trust the core loop, the ecosystem forks into automation patterns: queue-first orchestration, worktree swarms, JSON-mode scripting, RPC integrations, Slack bots, and web/TUI overlays.
What you can do here: Use this layer when you want throughput: queues, worktrees, headless runs, Slack loops, and scripted execution.
Representative projects
Explore
Layer
Interfaces are optional veneers over the same core
Pi is unusually explicit that TUI, print/json mode, RPC, SDK embedding, notifications, canvases, and browser-like overlays are alternate surfaces over the same programmable center.
What you can do here: Use this layer to choose how you want to touch the system: TUI, web overlays, notifications, canvases, or embedded surfaces.
Representative projects
Explore
Layer
Safety is added as a capability, not assumed by default
The Pi branch values power and composability first. Sandboxing, permission gates, redaction, and auditability tend to arrive as explicit add-ons once users leave the toy-demo phase.
What you can do here: Use this layer to decide where you need sandboxing, approval boundaries, redaction, or audit trails before scaling up.
Representative projects
Explore
Major projects
Projects that explain the ecosystem fastest
This ecosystem needs the right mix of explanation, importance, and usage so a deeper reader can choose where to click next.
Core runtime and package universe
pi-mono
What it is
Repository: badlogic/pi-mono
Why it matters
pi (pi-mono) matters because it defines the core surface other projects branch from.
How people use it
Most relevant if you want a web, cli, tui entry point into the ecosystem.
Start here if: Anyone who wants to understand what Pi itself exposes before installing community layers.
mixed 12.32depth deep-profileevidence 10
Cross-runtime skill catalog
pi-skills
What it is
Repository: badlogic/pi-skills
Why it matters
pi-skills matters because it behaves like a hub: multiple adjacent artifacts connect back to it.
How people use it
Portable reusable workflows instead of giant monolithic prompts
Start here if: Users who want the fastest route from “bare Pi” to practical reusable capability packs.
mixed 9.97depth deep-profileevidence 21
Expert customization pack
agent-stuff / mitsupi
What it is
agent-stuff is a public GitHub repository by mitsuhiko (Armin Ronacher) containing reusable skills, extensions, themes, distribution packages, and command wrappers for…
Why it matters
agent-stuff (mitsupi) matters because it is one of the more established, visible surfaces in the ecosystem.
How people use it
Portable reusable workflows instead of giant monolithic prompts
Start here if: Power users studying how serious practitioners structure their own package stacks.
mixed 9.79depth deep-profileevidence 11
Queue-first orchestration system
Task Factory
What it is
Tagline: “Agentic work orchestrator that respects your time”
Why it matters
task-factory matters because it explains a central ecosystem move better than many narrower artifacts do.
How people use it
Queue-first orchestration with human-review-aware throughput
Start here if: Teams or advanced solo users who need a review-aware lane system, not just more parallel sessions.
mixed 9.9depth deep-profileevidence 14
Worktree swarm toolkit
PiSwarm
What it is
PiSwarm is a Shell-based orchestration toolkit for parallel GitHub issue and PR processing using the pi agent and Git worktrees.
Why it matters
PiSwarm matters because it explains a central ecosystem move better than many narrower artifacts do.
How people use it
Parallel GitHub issue and PR execution via isolated worktrees
Start here if: Users who already think in shell scripts, git worktrees, and issue/PR pipelines.
mixed 8.91depth deep-profileevidence 13
Agent sandbox / capability boundary
nono
What it is
Description: “a capability-based, multiplexing sandbox tool, built for developers - lift'n'shift seamless path to prod.
Why it matters
nono matters because it explains a central ecosystem move better than many narrower artifacts do.
How people use it
Adding OS-level safety boundaries around agent workflows
Start here if: Anyone moving from local experimentation to more sensitive, less supervised runs.
mixed 8.4depth deep-profileevidence 10
Core platform
pi.dev
What it is
Pi is a minimal terminal coding harness designed to be adapted to your workflow rather than forcing one on you.
Why it matters
pi.dev matters because it defines the core surface other projects branch from.
How people use it
Most relevant if you want a web, cli, tui entry point into the ecosystem.
Start here if: you want the center of gravity before exploring the long tail.
mixed 7.75depth deep-profileevidence 5
Extension layer
pi-gui
What it is
pi-remote-web-ui is a minimal, secure web GUI for the pi coding agent.
Why it matters
pi-gui matters because it explains a central ecosystem move better than many narrower artifacts do.
How people use it
Most relevant if you want a gui, web, cli entry point into the ecosystem.
Start here if: you care about a gui-first entry point.
mixed 7.73depth deep-profileevidence 12
Discovery node
pi-share-hf
What it is
Purpose: Publish redacted pi coding agent sessions from one OSS project to a Hugging Face dataset.
Why it matters
pi-share-hf matters because it clarifies one meaningful branch of the ecosystem rather than acting as a one-off curiosity.
How people use it
Most relevant if you want a cli entry point into the ecosystem.
Start here if: you care about a cli-first entry point.
mixed 6.22depth deep-profileevidence 12
Workflow framework
brave-search
What it is
Web search and content extraction via Brave Search API
Why it matters
brave-search matters because it explains a central ecosystem move better than many narrower artifacts do.
How people use it
Useful when you are optimizing for context-management.
Start here if: you want reusable capability packs faster than building from scratch.
mixed 6.62depth source-skimevidence 10
Orientation principles
How to approach Pi without importing Claude assumptions
A few reading rules so the ecosystem feels legible instead of scattered.
- Think “programmable harness,” not “finished assistant”: Pi makes more sense once you stop asking what features it is missing and start asking what primitives it exposes: modes, context hooks, extensions, packaging, and session control.
- Learn the packaging story early: The ecosystem’s leverage comes from reusable skills, extensions, prompt templates, and npm/git-distributed packages. That packaging layer matters more than any one theme or slash command.
- Use JSON/RPC/SDK modes when you stop being a solo interactive user: A lot of the ecosystem’s more interesting work only makes sense once Pi is treated as infrastructure for scripts, queues, bots, worktrees, or embedded tooling rather than just a TUI session.
- Add containment on purpose: Pi-adjacent tools often assume local power first and approvals later. If you are moving toward unattended runs or sensitive repos, sandboxing and policy tooling should become part of the design, not an afterthought.
Next clicks
Good ways to explore from here
Browse all artifacts
See comparison slices
Read escalation patterns
Read best practices
Inspect sources
If you are new: start with the Brand section, then click the layer that matches how you want to work. If you already know Pi: jump straight to the layer explorer and use the representative project links as portals.