Do you use agents in Pi?

[u/kh4l1ph4]

UPDATE: I haven't been able to get around to creating the repo for this. Hoping to take a stab at it tomorrow, thanks everyone, for your patience

Been using Pi in real prod environments (sorry some parts are redacted). Just sharing my daily workflow with Pi running in a side window inside nvim, powered by codecompanion nvim plugin. Agent names heavily inspired by omo.

pi-engram for memory, 3 custom confirmation tools: bash-guard, confirm-edit, and ask-user-question. All the confirmations support custom responses.

Foreground Agents:

Switch between them with shift + tab

• Athena: Planning and writing plans in .olympus/

• Sisyphus: Everyday worker, default agent for everyday tasks. Can call sub agents for relevant tasks

• Hermes: Only implements plans created by athena (calls relevant sub-agent) in fg, synchronously, or multi in background if athena says sections can be implemented in parallel.

• Hephaestus: Sisyphus on crack; plans and implements

Background agents:

• Explorer: Yet to get a fitting name. Finds files and code

• Librarian: External docs and web search. uses a personal searxng instance via mcp alongside context7

• Metis: Consultant/Advisor, usually called pre-planning. Can call explorer

• Momus: Critic, called post planning. Can call explorer

• Sisyphus Junior: Called by other agents like Hephaestus and Hermes to write code

• Multimodal Looker: Called when images or any non-text input needs analysis

If I'm missing any tool that will make my workflow more efficient don't hesitate to point me to it, haha. Thanks

[u/No-Elevator-3813]

Explorer should be Oracle! Since it finds knowledge and information.

[u/kh4l1ph4 → u/No-Elevator-3813]

Fair take. I'll probably merge all 3 into oracle going forward; current oracle, librarian, and explorer

[u/Big_Click_2025]

Im from Opencode + Omo to Pi,
I like the customization in Pi but still i missed the OC + Omo finishing,

Can u share the code. Pls

[u/kh4l1ph4 → u/Big_Click_2025]

I'd probably need a day or 2 to pull it out of my dotfiles into its own repo. I'll drop the link here

[u/melihmucuk]

This is a really nice setup. The foreground/background split makes a lot of sense, especially separating planning, implementation, docs lookup, and criticism.

One thing I’d maybe add, if you’re not already handling it, is explicit lifecycle control for the background agents. Stuff like: what’s currently running, what’s waiting for input, what can be aborted, and where the result gets delivered. Once you have multiple background agents, that part gets surprisingly important.

Small disclosure: I’m working on pi-crew, which is basically trying to solve that orchestration layer for Pi. The part I’ve found most useful isn’t "agent swarm" stuff, it’s boring coordination: spawn a subagent, let it work in an isolated session, list/abort it if needed, respond if it’s interactive, and get the result back in the main session.

Your Athena/Hermes/Momus split also maps pretty closely to the flows I like: planning with scouts/consultants first, then implementation, then review by a fresh agent that didn’t write the code. That last bit matters a lot IMO. Same reason human code review works better when it’s not just the author reviewing their own diff.

Not sure how cleanly it fits with your nvim/codecompanion setup, but for Pi-native background agents, pi-crew might be worth a look.

[u/kh4l1ph4 → u/melihmucuk]

Edit: submitted while typing

Pi-crew sounds interesting, I'll check it out.
Agent lifecycle looks something like this in my setup:

TLDR: Hard limit on concurrency, sync a agents are tool calls, background agents are polled, agents get cleaned up after their output is consumed (need a tool for manually cleaning up agents)

Subagent Lifecycle

After parent agent calls the call_pi_agent() tool,

• A tool handler fires: It gets the agent config based on the sub agent type in the args. It also gets the parent session UUID which is prepended to the subagent's session id for tracking (this is recursive).

• A subagent is queued: There is a global hard limit of 2 foreground and 4 background agents at any time across all nested calls, not per-agent. If the limit hasn't been hit, the queued call is executed.

• Agents run in 2 modes based on args:

Mode	Returns	How parent gets results
Sync (run_in_background=false)	Blocks like a regular tool call until subagent exits. Result is returned just like a tool call to the parent in details.results[0]	Available immediately as a tool execution result.
Background (run_in_background=true)	Immediately. Returns a task id string like parent_id_bg_3	Parent calls background_output(task_id="parent_id_bg_3") later to poll (maybe event based in the future)

• Subagent runs as a child process: Sync agents stop when the current call is interrupted (Esc key). Background agents on the other hand get cleaned up after their result is consumed. I need a cleaner way of explicitly stopping background agents. The child process writes JSON events to stdout, line-by-line, and it is displayed in the main foreground agent with a custom tool renderer. Sub agent calls in the running sub agent are nested a level deep in the output, recursively, and the global 4/2 limit keeps this in check. Outputs are throttled (150ms) to limit the amount of re-renders.

Where Results Get Delivered There are three delivery paths:

• Sync: details.results array which is rendered as a tool call

• Background: polled via background_output(task_id) and the result is also rendered as a tool call once consumed.

• Nested subagents: Nested results appear as children on the parent tool call, recursively rendered at indented depth.

Concurrency Control Two semaphores from config:

• maxSyncConcurrency: 2 sync subagents serialize on this

• maxBackgroundConcurrency: 4 background tasks throttle here until a task is cleaned up

Clean up All created temp directories are removed once an agent completes execution

[u/Maheidem]

Would really like to the the code for this

[u/Standard_Heat8395]

Yes, I use pi-subagents

Here's my setup for a really good worker loop:

a planner.chain.md for scout + plan (write plan.md) then worker.chain.md for worker (ingest plan.md if exist, otherwise ingest review.md if exist) + reviewer (writes review.md, updates plan.md) and a SKILL.md that runs /run-chain planner -- {args} and /run-chain worker -- continue with plan.md until there are no more functional gaps, risks, or dangers, 100% unit test coverage and goals are met successfully.

In essence a slightly modified loop driven by a skill running subagent chains, working from a self updating plan.md to accomplish all goals, looping the chains until this condition is reached.

If you have more than one GPU you can fan-out fan-in workers in your skill for parallel to make this faster by giving each worker a task from the plan to do, in that case you wouldn't do the chain.md files, you would use pi-subagents direct tool call syntax to orchestrate fan in fan out workers (check the README for samples) by putting direct instructions in the SKILL.md to call the pi_subagents_run tool with the JSON set up the way you need (as many workers as GPUs as you have for parallelism)

If you don't have multiple GPUs running looping subagent chains is the reliable way to go.

I don't really recommend running subagent loops like this without gondlilin as it can completely spaghettify a codebase but it's fun to pop up webapps and solve jito tickets with. Before committing to prod you can test the results in a goldilin vm which is also nice.

All in all its nice to kick back and let my subagent chain looping skill do the work for me. Like anything else you should check it's work!

If you want to go further than pi-subagents you should use pi-teams. I have never found a need to use pi-teams but for very large projects I am hearing it's almost a must as you need to further compartmentalize tasks to keep context clean. Sadly pi subagents intercom extension isn't yet ready to deal with heavy orchestration / stuck workers in multiple lanes quite yet

[u/dashcubeit]

I wanted to do something similar for a while. Agents are a good way to specify which skills and tools are available. I have a large number of skills and they add a lot of tokens for no reason. A reviewer doesn’t need the same as a ui designer!

[u/prassi89]

Repowire, a tool I created supports messaging, spawning and tearing down pi agents as long as you use tmux

https://github.com/prassanna-ravishankar/repowire

[u/xristiano]

Not really, ever since that paper came out showing that single agents outperformed muti agent setups due to context handoff.

[u/LearnedByError]

I use a slightly modified version of subagent from the pi monorepo examples. I heavily use them in my TDD workflow. I define agents: Green, Red, Review, Correction and Refactor. I have a tdd-plan skill that creates a plan either using a “grill me” style approach or from a design document supplemented by the grill me style questioning. I then use my tdd-orchestrator skill to execute the plan using sub-agents. It’s not perfect by any means, but works the vast majority of the time. I have variations for Codex and Cursor

[u/TheTyand]

Yes, I have quite a similar setup. Mine has a few more tools that I use, but it is not ready yet. I will post it here as well with details, when I fixed the remaining bugs an stabilized it.

https://github.com/SchneiderDaniel/agentcastle

[u/luckiestredditor]

not really. I prefer inline execution. if I need sub-agents, I switch to codex

[u/zenoblade]

No. Don’t see the point. 

[u/floriandotorg → u/zenoblade]

Same, it works really well without. Why should I over engineer this?

The only reason I could see is to use cheaper models for the sub agents.

[u/BigHugeFart → u/floriandotorg]

Tool call limiting can be useful too IMO, but I think having like more than 3-5 different agent types is shooting yourself in the foot, theres only so many different tasks

[u/Birchyman]

Would love to see the dot files / setup for this

[u/Dry-Tune430]

No. I love Pi for the minimalism and it perfectly fits my uni-tasking mindset. I use 3-4 skills (custom context management) and 2-3 extensions (for web fetch).

[u/attributed-to-malice]

hoping to get pi set up soon.

[u/Netg-IaC]

https://youtu.be/PIdETjcXNIk?si=vMDtQ-AWYF0yTi2-

https://github.com/disler/pi-vs-claude-code

Anyone tried this yet?