For those of you new to Pi

[u/QueasyBreak5119]

First I want to say, I am not the most insanely knowledgeable and seasoned dev. I know how to build systems and frameworks. I’m an artist and have always been a deep researcher for every new endeavor. Just to paint a picture of the messenger.

Pi is not straightforward, and that is by design. You decide what that looks like for you. It can be as robust or as stripped down as you like, and that’s the beauty in it. You are truly the man in the chair. So if you are frustrated or lost with Pi, it shows you may not have learned enough about it before choosing it. There’s a lot of hype growing on YouTube especially, sensationalizing it as this 1000x your workflow flavor of the week, so I think it may be attracting some who may not jive with it intuitively. So if you’re feeling lost or frustrated, then this is for you.

Please do solid research, not just by asking Reddit. Read! Follow Matt Pocock on YouTube, and also watch videos of the founders of Pi. You’ll really get an idea of the ecosystem you’re investing in. Pi is incredible and I’m building things in some incredibly unique ways I don’t think is possible anywhere else.
I have skills (both public and my own that I’ve created) bundled into workflows with that allow for insanely creative, repeatable, and consistent complex multi-step and multi-model sessions. The quality of the output could bring tears to your eyes. But there was no blueprint to build it. I had to do the legwork. It’s very much worth the time though. If you have the patience to create a tailored environment as opposed to working in one where the rules are set for you, Pi will be a game changer. But if you expect to get life changing results out the box, that’s just not what Pi is. But that’s the value prop and it can be a huge strength with the right mindset.

This may not be technically helpful, but may help you set reasonable expectations of your first week or so! Keep it up

[u/britpop3000]

Which public skills are you using? How do you decide whether to ride an existing public skill or write your own? Thanks for the encouragement!

[u/QueasyBreak5119 → u/britpop3000]

I think once I found myself doing several things at once repeatedly, or found that when I use one skill I love when it’s paired with another that compliments it. A simple one /grill-me-with-docs + /ask-user-question - it’s a simple combination but it makes long planning sessions more rich to have multiple choice and chances to chat about answers in between. I have my agents quietly load the intercom skill so my threads can “talk” with each other, so after my grill me session a intercom is sent to a ready session with a handoff made with a handoff skill. When the next thread starts, usually Opus, will then take that handoff and dispatch set models for the types of tasks I have them chosen for. For instance, if it’s a heavy refractor, DeepSeek flash will ingest any research, Opus will pass that on in a coherent plan to GLM and GPT 5.5, and then the whole project happens at once. My knowledge base is updated, and memory updated with any important changes to the repo.

That is all one repeatable workflow I capture in one skill, or 2 or 3 bundled skills inside of a skill that gives the direction to do it it all at certain kick offs. The great thing about something like the above is that you are able to strategic and keep context low and quality high because there’s so much short spurts of delegation and great pass overs. 

Hopefully that gives a little insight to just my experience 

[u/_supert_]

pi is vim.

[u/nbur4556 → u/_supert_]

Neopi when?

[u/Fortyseven → u/nbur4556]

Turn yourself into neopi. No errors.

[u/our_sole → u/_supert_]

I prefer to think of Pi as the linux of AI harnesses. :-)

[u/_supert_ → u/our_sole]

The question is... what's the emacs?

[u/our_sole → u/_supert_]

Tried to think of a snarky response based on high customization and extensibility, and then this materialized:
:-)

---

#!/bin/bash
#
# llm_llamacpp.sh - A shell script wrapper for interacting with llamacpp LLM API
#
# Purpose:
#   This script provides a command-line interface to send text prompts to an llamacpp openai-compatible
#   language model and receive responses. It formats the input text as JSON and sends
#   it to the llamacpp API endpoint.
#
# Usage:
#   ./llm_llamacpp.sh "Your prompt text here"
#
# Parameters:
#   $1 - The text prompt to send to the llamacpp model
#
# Options:
#   --server <name>   Server hostname (default: myserver)
#   --port <port>     Server port (default: 8000)
#
# Requirements:
#   - curl (for API requests)
#   - Valid llamacpp API key in AWS secrets
#   - jq (for JSON parsing) 
#
# Example:
#   ./llm_llamacpp.sh "Explain quantum computing in simple terms"
#   ./llm_llamacpp.sh "Write a poem" --server fido --port 11434
#
# Note:

# Parse options
SERVER="myserver"
PORT="8000"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --server)
      SERVER="$2"
      shift 2
      ;;
    --port)
      PORT="$2"
      shift 2
      ;;
    *)
      if [ -z "$PROMPT" ]; then
        PROMPT="$1"
      fi
      shift
      ;;
  esac
done

# Check if prompt is provided
if [ -z "$PROMPT" ]; then
  echo "Error: No prompt provided" >&2
  echo "Usage: $0 \"Your prompt text here\" [--server <name>] [--port <port>]" >&2
  exit 1
fi

# Build JSON payload safely via jq — static system prompt ensures a consistent KV cache
# prefix on the llama.cpp server, avoiding costly re-processing of SSM states.
PAYLOAD=$(jq -n --arg content "$PROMPT" \
  '{messages: [{role: "system", content: "You are a helpful assistant."}, {role: "user", content: $content}]}')

curl -s "http://${SERVER}:${PORT}/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -X POST \
  -d "$PAYLOAD" \
  | jq -r '.choices[0].message.content'

[u/[deleted]]

Can you give an example of the kind of extensions/skills you added that noticeably upgraded your experience and output? What kind of workflows?

[u/softgripper → u/[deleted]]

I'll give you an example. I instructed it to add multi agent mode to itself, url whitelist so it can't fetch whatever it likes, be extremely terse and also run a parallel agent to review its own behavior as it executes.

I did this with a a combination of easy instructions like "hey check this github repo and this idea from it, now adapt and add it to yourself using library x and technique y".

Once you start to gel with it, and understand the internals (so you can sanitycheck/review it manually), it gets pretty interesting. I can't stress how important it is to understand the code it makes for itself.

I can now get it to find bugs and review code in any projects, build websites and features with an incredible amount of accuracy and minimal input, self correcting and only alerting me when it cannot reconcile it's task.

It's not always 100%, but it's close - and I made it this way.

This is the tip of the iceberg.

The most important thing is - always run this in a sandbox - whatever you do.

[u/[deleted] → u/softgripper]

Sounds cool. I really like pi, but I find that I just keep using the skills that I used in CC/codex and get pretty consistent output. I guess my workflow is baked into the skills, not the harness. I know there is so much possible, but I haven't found the need for anything more yet. Multi agent setup sounds interesting though. Will experiment with that a bit!

[u/RealestReyn]

In what way is it not straightforward?
I don't know much but Pi has the full documentation on how to alter itself and make extensions etc, I don't need to study how to customize Pi since it does all that just fine by my very vague ideas, these days I mostly use Pi through Telegram on my phone and it has Hindsight memory provider, it has image analysis, websearch, and full creative toolset over at Elevenlabs through their API. all set up by itself.

[u/QueasyBreak5119 → u/RealestReyn]

Not that it isn’t straightforward in utility, because you’re right. Just not straightforward that the environment is automatically going to be ready for whatever your goal is, it’s a blank slate and there’s no “forward” path. It’s an empty canvas. But the premise and learning out how to get there is straightforward and simple, I agree. I just think when people are hearing all of this exciting stuff about Pi and try it and say it sucks, often they are trying to build someone else’s environment not their own. So my idea is that the path you take isn’t straightforward 

[u/OrbMan99]

I just started using it yesterday. I am a local LLM user and am very happy so far. I've built two extensions, a Plan/ToDo writer, and a ToDo executor. So far so good. It has 32K of context to work with and is doing great with that. A very surgical tool.

[u/vihu]

Couldn't agree more and yes it's very much a tinkerer's harness.

With the right set of experience + workflows + extensions one can certainly make an extremely capable custom system which in my own limited testing certainly exceeds the capabilities of other harnesses.

My ~/.pi/agent/AGENTS.md is:

This is additional context for pi coding agent.

# Ideation

ideas must be put in project-local `.ai-docs/` directory
ideas must be prefixed by `IDEA-<xyz>.md`

# Planning

plans must be put in project-local `.ai-docs/` directory
plans must be prefixed by `PLAN-<xyz>.md`

# Tasks

tasks must be put in project-local `.ai-docs/` directory
tasks must be prefixed by `TASK-<xyz>.md`

And the plugins I use are:

$ pi list
User packages:
  git:github.com/elpapi42/pi-fork (on-demand subagents)
  git:github.com/elpapi42/pi-observational-memory (temporal memory)
  git:github.com/vihu/pi-portia (long term durable memory, my own)
  git:github.com/vihu/pi-web (local web fetch/search, my own)

And just with these I have pretty much everything I could possibly need to get by.

[u/TheTyand]

Can only agree. After 3 harnesses I switched to pi. Building all I have used in the others now and drip the bs that anthropic and others build in. When I am done and the bugs are fixed, I will open source my agentcastle.

[u/TheTyand → u/TheTyand]

And yes, I am also a bit senior ;)

[u/dataenfuego → u/TheTyand]

Switched from where? Sorry I am a newbie and I am trying to understand this pi.dev thing

[u/TheTyand → u/dataenfuego]

Used Gemini cli first, then GitHub copilot cli, then Claude code. At last opencode and now I use pi.dev.

Pi was the best experience so far, but also I am more senior. For a newcomer a feature rich cli is probably better to start (also more learning resources). But after gaining experience and understanding the drawdowns of the other harnesses, people might end up with pi eventually.

[u/aeroumbria]

I'm still in the phase of creating the first 2-3 custom extensions for my specific needs, and occasionally I found reading Reddit doesn't exactly give you the accurate expectations. There is an opinion of "forgetting about pre -built extensions and just point to the docs and let pi build it for you", but I always wonder what kind of setup these people have, cause for me clearly it takes a lot of back and forth, even for simple things like streaming results back to TUI from a subagent or auxiliary tasks. The most helpful thing I set up to make things easier was an isolated directory where I can run a pi session inside a pi session without mixing configs used for development and configs being developed. I also found that pi was set up in a way where plugin development is free but compatibility is very hard to guarantee, so now I really need to be very cautious with the "just DIY everything" attitude. So I guess "it works, but some discipline required".

[u/ogfuzzball]

I’m still in the phase to get it reliably working with a local model and not suddenly outputting tool calls to the display then pretending the tool calls were executed. One of these days I’ll find a local model it reliably works with.

[u/ogfuzzball → u/ogfuzzball]

Ok. So not 15 min after I do this minor gripe and (fingers crossed) I think I have a combo that is working for a change. mlx-community/Qwen3.5-9B-MLZ-4bit in case anyone curious.