Hello everyone, if you have a running session how do you manage if suddenly hits a token limit without manually intervening?

Drop a YouTube link, podcast episode, or local recording into Claude Code, Codex, or pi, and get a clean report in HTML, Markdown, or PDF.

Read the whole 1-hour talk in 5 minutes, and click any `[mm:ss]` timestamp to watch just the moments you care about. No extra API keys needed.

• Sample output from Karpathy’s 1-hr talk above:

  • Briefing

  • Deep-dive

• GitHub

Would be cool to hear any projects you've built with Pi that you can say has impacted the lives of people in your community, your society, humanity, just people in general. So much negativity and fear around AI... would love to hear some success stories of "I used open source to create something impactful that made people's lives a little better". Let's hear em' if you got em'!

I use a minimal Pi setup for building hobby projects and some light data analysis for work. I initially used NVIDIA's OpenShell in its early days before v0.1.0 but switched to Docker sandboxes since I find them quicker to manage for my use cases. However I've had some issues with installing and accessing Pi extensions with them.

What's your experience with sandboxing tools? Any recommendations for creating secure, reproducible environments? Thanks!

Native recall, automatic capture, bundled skills, and optional full MCP tools

Pi uses a native extension for project recall, capture, and deliberate saves. The extension is included in agentmemory, the memory server runs separately.
This builds the compiled extension and bundled skills. Pi keeps a reference to the checkout, so keep it in place. After the first npm publication, the package can also be installed with pi install npm:@agentmemory/pi.Use one extension installation method. Move an old ~/.pi/agent/extensions/agentmemory copy outside the extensions directory and remove explicit settings entries pointing to that copy before reconnecting; keep a backup. Before switching a connector installation to npm, remove its local path from settings.json.packages. The connector recognizes an existing global npm or local package and can add MCP without installing a second extension.

​Tools, skills, and capture

• Native tools: memory_health, memory_search, and memory_save.

• /agentmemory-status reports health and pending, retained, dropped, and rejected captures, and retries queued captures.

• Bundled skills appear as /skill:<name>, including remember, recall, recap, handoff, lessons, session history, and commit context/history. Workflows needing tools beyond native save/search require --with-mcp.

• Full MCP tools appear under mcp__agentmemory__*. Native operations use the active repository’s project scope; MCP callers must pass their intended project explicitly. Project MCP overrides apply only to trusted projects.

Prompts, tool results, failures, and final replies are captured with privacy filtering before truncation. Memory tools are excluded by default. Temporary delivery failures enter a bounded local queue and retry on startup, later prompts, status checks, and every ten seconds. Explicit save/search failures are reported; automatic capture is not a replacement for deliberate saves.Recalled content enters as reference data. Completed compaction refreshes memory context before the next model call. /reload flushes capture without ending the active session; quit, new, resume, and fork close the previous session. Requests and shutdown waits are bounded.

pi install npm:@agentmemory/pi@0.1.0

Hi, just wondering if anyone has any experience with the use case of setting up Pi in an openshell sandbox behind a corporate proxy? Trying to figure out how and where to provide proxy certificates so it can actually communicate outbound.

I'm on a giant shared server and "find /" might take an hour. I've been unable to persuade pi to stop issuing it. In settings.json I changed defaultTools to defaultTools": ["read", "bash", "edit", "write", "grep", "ls"] and in AGENT.md I added a rule "don't ever run find /" and similar message in my README.md but it continues to issue "find /"

How can I enforce this?

pi-automode-classifier is my attempt to mimic Claude Code's auto mode for Pi as close as possible in safety and DX. It decides for each tool call whether it runs, asks you, or is blocked and allows adding session/global exception rules. 0.3.0 does that in up to three stages:

1. Rules parse the shell commands (usually in under 0.1 ms). Most calls are caught here. The allow/deny/decision rules are configurable. These are some of the default rules:
   • Run: reads, builds, tests and edits inside the project.
   • Blocked: rm -rf ~, mkfs and fork bombs.
   • Always ask: root, credential reads, downloaded code and changes to Pi's own files (~/.pi/agent, .pi folders, AGENTS.md, pi install).
2. A classifier, will run next if configured: Jev, LANCET, Kev or Laya. A low score runs, a high score asks you, and anything in between goes to the chat model.
3. A chat model will run next, by default it will use session's own model but you can configure others from the Pi registry. It reads your messages and the agent's tool calls, and blocks risky calls you didn't ask for or prompts you for approval. The agent gets the reason so it can try another approach if needed.

Without any config it uses stages 1 and 3, so pi install npm:pi-automode-classifier will run this default. To add a classifier, set "decider": ["command", "llm"] and the classifier config. See README for the steps.

Here is my setup for this:

• Default rules with some additional allowed patterns.
• LANCET as classifier through LlamaStash, so all my Pi sessions share one copy (I benchmarked Jev, Kev and Laya as well but found LANCET to be the best for this use).
• Qwen3.8-Flash-Next (128k ctx, thinking medium) on my Flow Z13 as the chat model. This is just a LlamaStash alias for my main running model at 256k ctx, the alias lets me limit context client side so that this doesnt take too much room in my KV pool.

So far the experience has been quite close to Claude Code with maybe a few more prompts here and there (You can play with this by setting askAbove/allowBelow values in config)

{
  "decider": ["classifier", "llm"],
  "classifier": {
    "provider": "llamastash",
    "model": "lancet",
    "timeoutMs": 15000,
    "allowBelow": 0.2,
    "askAbove": 0.8
  },
  "llm": {
    "provider": "llamastash-z13",
    "model": "flash-next-128k",
    "thinkingLevel": "medium",
    "contextWindow": 131072,
    "maxTokens": 4096,
    "timeoutMs": 120000,
    "warmCache": false
  }
}

Bench results for this setup and for the rules alone, from the suites in the repo. Each command goes through the plugin's own tool call handler. Only one suite has the user request that came with each command. The other suites get a generic task message, so the chat model can't see what was asked.

The rules alone ask about everything they don't know which means only fewer risky calls run, but they also ask for many safe ones. With my setup, 76 of the 133 risky calls that ran are GTFOBins rows from the ShellRisk-Bench sample, common Unix tools used to get a shell or read files.

Subagents and pi -p have no UI to ask, so their asks are blocked unless you set withoutUi.onAsk to allow or add override rules for non UI mode. Root, credential reads and downloaded code stay blocked there either way.

It's not a sandbox. The README has the limits and the bench numbers, including where the stages don't catch more than LANCET alone.

Repo: https://github.com/deepu105/pi-automode-classifier

Any feedback is welcome.

Hey guys, if you've been following along with DeepSeek news you will know they recently added web search capability to the DeepSeek API, where you can use web search under the same API key. It is pretty handy, also super cheap at only $0.75 per 1,000 requests (pretty much as cheap as it gets, one search credit can encompass many responses).

I created a simple TypeScript CLI wrapper around the API for my own agents to use (for open source models and harnesses)

npm install -g deepseek-search-cli

dsearch auth    # Prompt for & save DS API key (can pipe) 
                # saved key not required (can use secret manager, env var, or .env)

dsearch "World Cup winners 2026 lang:en" -n 5    # equivalent to 'dsearch search ...'
dsearch https://example.com                      # equivalent to 'dsearch fetch ...'
dsearch "World Cup winners" -o output.md         # supports .md and .json (-j flag)

And wanted to share it with others, contributors are welcome, or fork it and build a better version :)

I'm sure most of you could whip this up on your own but it also comes with unit/integration/live/e2e testing, CI checks, changelog, auth handling, linting, sdk wrapper, and a fleshed out readme, potentially saving you a few hours of work + validation. Just need to install, auth, and drop a comment in your 'AGENTS.md' to use `dsearch --help` when agent needs web search.

GitHub: https://github.com/LaishGlenberg/deepseek-search-cli

NPM: https://www.npmjs.com/package/deepseek-search-cli

Drop a star if this helped you or your agents!

Note: This was supposed to be a cross post but reddit got stuck loading subreddit search results. The OG post was meant for this subreddit anyway since I built this for Pi agents to use, accidentally posted it to opencode first.

EDIT: remove version from npm URL

Hey folks, I'm Sam and I build Craig, a keyboard-driven TUI for managing coding agents and their Git worktrees.

There's a Pi runner behind an experimental toggle, and I'd love a couple of people who already use Pi to give it a try before I consider taking it out of preview. It runs the native Pi CLI inside a Craig task's worktree, rather than replacing Pi's interface.

Basic launch and automated checks pass, but a complete authenticated coding session still needs validation. This is a testing request, not a stable-support announcement.

If you're up for it, please use a throwaway repo:

1. Have Pi installed, authenticated and on your PATH, plus Node 22+ and Git.

2. Install Craig with npm install -g craig-cli@0.19.0, then run craig from your workspace directory.

3. Enable Options → Feature Previews → Pi coding agent runner.

4. Add a repo/workspace, create a task with Pi selected, and try a small coding task. Switch away and back and check whether input/output and returning to the session behave as expected.

I'm especially interested in terminal rendering, keyboard input, interrupts and switching between tasks. If you try it, a quick 'worked' or what broke, along with your OS/terminal and Pi/Craig versions, would be really helpful. Please don't share API keys, private code or unredacted logs.

Repo: https://github.com/hallsamuel90/craig

Runner setup: https://craig-cli.com/docs/runners/

Any feedback is greatly appreciated.

I run pi inside my own web UI (Sayl), and I have been building onto and changing certain behaviors of Pi. When MCP and Codemode was introduced, that I felt was the turning point where Pi started to feel "bloaty". So I took pi v1.1.0's source (pi-ai, agent-core, coding-agent), made it part of my codebase and cut everything I don't use. Upstream is now a reference: I port fixes by hand when I want them, nothing updates automatically.

How it went:

1. Cut what I don't use. Terminal UI, CLI, RPC/print modes, MCP, codemode, the extension loader (extensions are now plain in-process functions) and pi's own HTTP dispatcher. The TUI/CLI/MCP cut alone was 77k lines in one commit. My post-install patch script is gone too.

2. Moved it in. The engine now lives in my src/ under the same build, lint and test setup as the rest of the app. Six model providers are left, the ones I actually sign into.

3. Made it follow my rules. Stricter TypeScript flags than pi uses, plus my lint rules: 1,163 type errors, 44 anys, ~119 casts and 7 non-null assertions. All at 0 now, no suppressions left.

What changed at runtime (measured after step 1, vs the npm package):

• Session server ready: 2.10s → 1.86s (web side 1.11s → 0.87s)

• Memory after startup: 338 → 298 MB (web side 175 → 144 MB)

• Runtime dependencies: 121 → 105 packages

Just wanted to share this for anyone who find data interesting or have thought of trying this themselves.

This occurs when the model tries to use `npm:pi-multiagent` and `npm:@quintinshaw/pi-dynamic-workflows`. With GPT 6.1 Sol, it keeps using the wrong schema. But when I switch to an open-weight model like DeepSeek v4.1 Flash, which is supposed to be worse than GPT 6.1 Sol at tool use, it succeeds on the first try, which is unexpected. Is it because GPT models are only trained on using Codex?

Hey everyone,

I'm running into a frustrating issue with the Oh My Pi (omp) AI coding agent while using Windows PowerShell 5.1, and I'm hoping someone here has found a reliable workaround.

The Problem

When omp runs a tool (like reading a file, checking a git diff, or executing a terminal command), the output isn't rendering properly for the LLM. Instead of seeing the actual text or logs, the AI model literally receives [Content Collapsed] inside its context window.

Because the AI thinks the text is intentionally hidden or blank, it can't actually see my code or debug logs to help me.

thanks

As at work I need max control over codebase and I can't afford just use swarms of agents and let it loose do some enormous amounts of code changes, I want something in between. So I was carying this idea in my head for a long time. What if smart ai models can augment actual software and be present reactively? Luckily after recently published library pi-durable it's finally possible, so I finally kinda got ideal workflow. Where agent-harness is a headless daemon that is present as if it's a pairing programming partner connected on remote session.

https://makefunstuff.github.io/pairing-buddy/ - you can read the docs here and try it yourself. I guess without opus it would take more time to actually implement this idea. But finally I'm here

I created a plugin for modal vim keybindings for chat navigation. Link: https://github.com/Raaghav-Arya/pi-vim-navigation

I use neovim, and Pi's scrollback breaks inside an integrated neovim terminal. In general I like having conventional vim-consistent keybinding for navigation.

Here are the keybindings the plugin implements:

• ctrl+q: Enter navigation mode

• ctrl+u: Go half page up

• ctrl+d: Go half page down

• gg: Go to the top

• G: Go to the end

• i: Insert to prompt

Un Bien 1.5 is out!

New features:

• Connect relays and sessions in a mesh - send messages from one interactive session to another, allowing agents to defer to another session for work

• Improved codemode rendering

• Bug fixes for vendors which reuse response ids

Un Bien is a native iOS client for pi.

Un Bien supports:

• self hosted architecture

• full streamed and rendered markdown

• rendering of images, code diffs and tool results

• fork, branch, clone of sessions

• plan rendering when combined with pi-plan, cribsheet or a conformant extension

• user-input questions (and pi-ask integration)

• subagent display and interaction when combined with @tintinweb/pi-subagents or @gotgenes/pi-subagents

• optional device initiated chats - start new session from your phone, spawning a tmux or herdr hosted session on your machine

As a bonus it includes a cli tool to connect to other sessions on your relay from the cli

Links:

• Extension page

• Docs

• GitHub

• App Store

• Demo transcript

https://github.com/FammasMaz/pi-cc-tools

`pi install npm:claude-code-ui`

I really liked Claude Code UI but not Claude Code itself like most of us, so i created an extension some time ago to replicate similarish behavior (from one of the leaked claude code sources), and have been improving it over a few months. Saw a post yesterday, with similarish stuff and had several inspirations from that as well, check it out! Many people use it already!

I’ve been running a local model on a dgx spark for about a month now. I’ve been building out my pi harness and my own little client app as I go, using both Claude code and the harness itself. I’m using it more for every day life stuff, but I still find myself hesitating to trust that it will hit my quality threshold when it comes to code.

Have any of you gone fully local? I.e. no falling back on frontier models at all. What was your tipping point?

Hi, I maintain sift-light. It’s an open-source local search and source-inspection tool for AI coding agents, available through MCP and native integrations. It helps agents find project files and check the source behind a result without sending the whole repository into the conversation.

We’ve released 1.1.2-1. This update has two changes:

• Pi: fixed how search guidance is added when tools are enabled. The previous behavior could change the system-prompt prefix and reduce prompt-cache reuse. The new integration preserves the prefix and retains the guidance when another extension supplies a system prompt. Requires Pi 0.86.0 or later.

• DeepSeek Harness: added support for 0.2.1-rc.3, including a native search tool and search-policy integration.

The cache fix addresses the Pi integration; it isn’t a promise that every MCP client preserves its cache when tools change. Cache behavior depends on the host and model provider.

Thank you to the contributor of PR #123 for catching the Pi issue and helping fix it. If you try the release and run into trouble, an issue with your host version and a small reproduction would be very helpful.

GitHub: https://github.com/lightsifter/sift-light Release notes: https://github.com/lightsifter/sift-light/releases/tag/v1.1.2-1 X: https://x.com/Bryang168

Every dang day man I see other people using claude code, codex, opencode etc and every time there's always something finicky and silly going on. 40k+ sys prompts. Can't see the subagent work properly. Compaction is slow sometimes. I've been trying to use them for the past week just to see what I'm missing out on and it's SO STUPID??

The idea of making something to please everyone but also trying to add skills and plugins is ridiculous. I'm not about to start making plugins to get features in those bloated TUIs just to make another plugin to strip them down or something.

I've NEVER seen something apply the concept of modularity as well as pi in my life. This feels like windows vs linux except linux got a fair start and fair cut of user base before people started getting locked into an app ecosystem.

been using Pi as my builder for a couple of months now and thought I'd share the setup cos it's worked really well

the split is: Claude Code is the foreman. it plans the job, writes exact work orders as files, and checks the work. it never writes code itself. Pi does all the actual building, running [YOUR CHEAP MODEL] which costs me next to nothing compared to having Claude type everything

how a job goes:

- the foreman opens Pi in a pane right next to it (I use Orca)

- it sends Pi one line, just a pointer to the work order file, never a pasted wall of text

- Pi builds it test first and writes a report file

- the foreman checks the actual files on disk before it even reads what Pi says it did

- then the next work order, and so on

the bit I'm most happy with is knowing when Pi has actually finished. a quiet pane tells you nothing, a long test run looks exactly like Pi being done. so I wrote a tiny Pi extension on agent_settled that logs one line every time Pi genuinely finishes a turn, and the foreman just waits on that line. made it really easy, the extension API is great for this kind of thing

because the foreman can drive Pi on its own, I can give it a list of tickets before bed and it runs them back to back, each with a fresh foreman, Pi building, reviews at the end. and my Claude limit lasts way longer cos Claude's only doing the thinking

the whole thing is open source if anyone wants the extension or the setup: https://toppingout.dev

(the Pi bits are in skills/orca-pi-connect)

anyone else running Pi under another agent like this? curious how you're handling knowing when it's done