Open source, self-hosted, extensible like Pi

Your Pi agents, on your machines, open from anywhere.

Pipoca is a self-hosted home for Pi coding agents, for you and your team. Sessions run on your laptop, a VM or Kubernetes with your own Pi setup, and every feature is a plugin you can turn off, swap or write.

$brew install pedroklein/pipoca/pipocaRead the docs

Then run pipoca up in the folder with your code. macOS and Linux, plus a desktop app.

pipoca.example.com

Coupon field at checkoutlaptop · acme-shop · pipoca/3f9c2a1dWorkingDone

Add a coupon field to checkout, cover it with tests and open a pull request.

Working…Read src/checkout/cart.tsEdited src/checkout/coupon.ts +38 −4Ran bun test 42 passed

› Worked for 2m 14s · 9 steps

Checkout now takes a coupon code. Unknown and expired codes show an inline error, and the total updates as you type. I added 6 tests, and all 42 pass.

Opened pull request #128

Reply, or ask for changes…coder-large

Changes 2 files

src/checkout/coupon.ts
+ export function applyCoupon(
+   cart: Cart, code: string,
+ ): Result<Cart> {
-   return cart.total;
+   const c = coupons.find(code);
+   if (!c) return err("unknown");

Create PR

Coupon field at checkout is doneOpened pull request #128.

Extensible like PiA small core. Everything else is a plugin.19 built-in plugins on the same SDK yours would use.Built for teamsOne hub where your team and Pi work together.Shared Sessions, Profiles, model keys and budgets.ProfilesYour Pi setup, on every machine.Packages, skills and MCP servers, layered and visible.

Extensible like Pi

A small core.
Everything else is a plugin.

Pi keeps its core small and lets extensions do the rest. Pipoca does the same for the server and the web app: Projects, the diff view, routines, team usage and single sign-on are all plugins. Turn off what you don't need, install more from a git repository, or ask the assistant to write one.

Work with Pi

projectsProjects with a coordinator and threads, and the assistant.

changesThe diff, line comments and pull requests.

subagentsHelpers Pi starts, workflows and missions.

checklistA live task list in every Session.

diagramsMermaid diagrams drawn right in the chat.

askPi's questions to you, and votes in team work.

Automate and share

routinesSchedules, events, webhooks and wake-ups.

artifactsPages Pi publishes, with versions and comments.

filesSession outputs and uploads, kept on the server.

slackSlack messages as triggers, and posts from Sessions.

emailMail as triggers, and mail from Sessions.

Models and people

modelsModel aliases per Environment, with fallbacks when a model fails.

loginsModel and MCP logins kept on the server, and the team's key proxy.

usageTokens and cost, team budgets and the audit log.

oidcSingle sign-on with OpenID Connect providers.

Where it runs

localRunners on the server's own machine.

kubernetesRunner pods on demand, deleted when idle.

git-hostsGit host accounts, technical users and GitHub Apps.

pushNotifications on phones and desktops.

Write your own in one folder

Server part. Routes, tools, schedules, events and its own tables.
Web part. Pages, panels for the team hub, setup steps and settings, built from Pipoca's own components.
Session part. Pi extensions, commands and tools in every Session.

Write your first plugin

src/session.tssrc/server.tsweb/index.tsx

export const session = defineSession(greeter, (s) => {
  s.extension((pi) => {
    pi.registerCommand("greet", {
      description: "Say the greeting from config",
      handler: async (_args, ctx) => {
        const { greeting } = await s.api.get("greeting");
        ctx.ui.notify(greeting, "info");
      },
    });
  });
});

Built for teams

One hub where your team and Pi work together

Team work is open to everyone on the server by default. Anyone can start it, follow it or step in, and Pi reads the team's conversation, not just the last message. It runs on the team's Profiles, Environments and keys, so nobody lends their own.

TeamStart team work

Needs someone

Migrate billing webhooks to v2Pi asks Ana which retry policy to keep

Fix flaky checkout testA pull request waits for a reviewer

RunningRelease notes for 3.2Carla steeringNightly dependency bumpsRoutineTriage new issuesRoutine

Team usage this month$412 of $600

Migrate billing webhooks to v2Needs Ana

Bruno to Pi

Move the Stripe webhooks to the v2 events and keep the old ones until Friday.

Diego to the team

Careful, the refund handler retries on its own.

Diego is right: refunds retry three times with backoff, and Stripe's v2 events retry too.

Question for AnaWhich retry policy should we keep?

Stripe's retries onlyOurs, with Stripe's offAnswer for Ana

Write to the team, or @pipoca…

Open by defaultAnyone on the team can start team work and step in. Whoever started it can make it view-only or limit it to named people.

Pi joins the conversationWrite to Pi, to the team, or off the record. Pi addresses questions to named people, and anyone can open a vote.

Shared, not borrowedTeam Profiles, Environments and API keys, run by admins. Keys stay on the server behind a proxy.

Usage in moneySpend per person and for the team, with budgets that warn at 80% and 100%.

How team work works

Profiles

Your Pi setup, on every machine

A Profile is a Pi agent folder, like your ~/.pi/agent: packages, skills, prompts, instructions, MCP servers and settings. Import yours from a folder, a tarball or a git repository, and every Session runs with it, wherever it runs. Keep one for reviews, one for docs, one for the team.

AdminsServer base

company skillsan MCP serverAGENTS.md

YouMy defaults

your packagesyour logins

This ProfileReviewer

a review skillits own prompt

Every SessionWhat Pi gets

all of it, with sourcesminus what you turned off

Layers add upAdmins set a Server base for everyone, you keep your own defaults, and each Profile adds what it needs.

See exactly what Pi getsEvery inherited item shows where it came from, with a switch to turn it off for this Profile.

Logins stay on the serverModel and MCP logins are sealed on the server and reach a runner only for the Sessions that use them.

More about Profiles

Day to day

Hand off the work. Come back to it from anywhere.

Sessions

Sessions that keep going when you close the tab

Each Session gets its own worktree or clone on its own branch, so several can work in one repository at once. Pi's steps fold into one line, and the header shows context use and cost.

A Pipoca Session with the task, Pi's steps folded into one line, and its answer

Changes

Review the diff, comment on lines, open the pull request

Comment on any line and send every comment back to Pi as one message. Pipoca watches the pull requests your Sessions open and can fix failing checks.

The Changes panel with a Session's diff and a Create PR button

Pi stays Pi

Pi's own terminal UI, one click away

The Pi tab runs Pi's terminal UI for the same Session, so extensions that only work in a terminal still work. Terminals open shells in the Session's folder and survive reloads.

Projects

Split bigger work across threads

Talk to a Project's coordinator. It starts a thread for each piece of work, shares memory and a folder of files with them, and puts the ones that need you first.

A Project coordinator that started two threads

The assistantStarts Sessions and sets things up from the home screen. Its tools are also served over MCP.

Routines and wake-upsRun work on a schedule, on events such as a new pull request, or from a webhook.

SubagentsPi splits a task across helpers that report back, with a live checklist.

Artifacts and filesPages Pi publishes get their own link, versions and comments.

Slack and emailRoutines start from messages and mail, and Sessions answer there.

On your phoneThe whole UI, terminal included, with push notifications when Pi needs you.

Ways to run

Runs where your work is

Start on your laptop. Move the server to a VM when you want it always on. Bring your team, or run it in Kubernetes.

Your laptopBrowserOr the Mac app, or your phone over your own private network

localhost

Your laptopPipoca serverWeb UI, Sessions, Profiles, logins

starts

Your laptopRunnerPi Sessions in your folders

One person, one machinepipoca up starts a server just for you and opens the browser signed in. A runner starts when a Session needs one and stops after five idle minutes.Set it up

brew install pedroklein/pipoca/pipoca
cd ~/code && pipoca up

Start in a minute

On your laptopJust you. The browser opens signed in.

pipoca up

Solo setup

On a VMAlways on. Your laptop joins as a runner over SSH.

pipoca connect me@my-vm

VM setup

In KubernetesFor a team. Runner pods start on demand.

helm install pipoca deploy/helm/pipoca

Kubernetes setup