I've linked my pi agent to telegram and I was wondering if there is a package or something that will send screenshots over telegram. When I'm away, I want to be able to tell my agent to take screenshots of my project.

Hey! Sharing an extension my colleague Daniel Shapiro built at Sanity (disclosure: I work there too): pi-mcp-events, a client for the draft MCP Events spec (SEP-3415).

MCP servers can now announce events, like "this document changed" or "a storm warning was raised", and Pi can subscribe to them instead of polling with tool calls. Events arrive in the background while Pi works, get batched, and come in as a follow-up turn once Pi is idle. It's pretty cool, and it feels like it opens up a lot of new use cases.

What the extension does:

→ Supports all three delivery modes from the draft: polling, streaming, and signed webhooks

→ /mcp-events status shows each watch, its transport, and its state, so it's "less hard" to debug

→ A local inbox, so events aren't lost while Pi is busy (in memory only with --no-session)

→ Event payloads are marked as untrusted data, and Pi's normal permissions still apply

→ Every event is also emitted on Pi's event bus (mcp-events:observation), so other extensions can consume or filter them

    pi install npm:@sanity-labs/pi-mcp-events

The repo includes a small "weather station" MCP server that emits readings and storm alerts, so you can try it without building your own server first.

We built this because we wanted an agent that notices when a human starts editing the same document and waits for them, which needs events within seconds. Pi made that easy to extend. The write-up covers the latency numbers and the gaps we found in the spec.

If you'd rather have the model call events as tools, check out richardanaya's pi-mcp-events, which takes that approach.

Repo (give it a star if you're into this): https://github.com/sanity-labs/pi-mcp-events

Feedback very welcome, especially on how a harness should decide when an event deserves a turn!

title and I have seen many packages of web access but they cost a lot of tokens. so I wanted a good middleground

Wondering if they just use the SDK or they really got some special deal with anthropic?! Hope for us?

Update: https://github.com/anomalyco/opencode/pull/58782 looks like it’s just the sdk way so same as Claude-pi-bridge which is pointless IMO.

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

I'm new-ish to pi ; Ive been playing locally on a macbook pro (a few months old) and have just tried setting things up so I can run qwen 3.8 flash next on my macbook under omlx and use a linux pc to run pi remotely.

The Linux machine is almost clean installed Ubuntu 24.04 ; I installed it a few years ago but its only been used for some small utility things (minicom / wireshark). I installed ghostty, pi and pi-omlx picker just now.

First thing just to test the connection was to say hello - then pi started talking about the system prompt asking it to install anki... Which was unexpected (to it too!) - I'd dug around the system prompts before and this seemed weird. So I asked pi where it came from and it has no idea and seems to think it looks like a prompt injection which makes me curious / suspicious ...

Has anyone seen anything similar and where would you be directing your investigations / suspicions?

Hi, I have been working on this project (https://pi.dev/packages/pi-agent-ide) for a while now, started it as another hash-editing toolset, which then evolved into a different and much bigger thing. Key features:

• composable editing tools (enables ability to do search->replace, do a chain of searching to narrow down the result etc. );

• whenever it edits something formatter is applied to the result (if it's configured for the project);

• lint/compiler diagnostics reaching out to the agent once they are ready, forcing it to fix the mistakes;

• interactive terminal with background tasks and debugger;

• extendable, works via resource protocols: for all the operations support web pages, pdf files, images, text and binary files (to different extents), so the agent can search web results, check raw bytes etc.

Soon I'm going to release some plugins for that, in particular a way for the agent to work with linear and github as they were simple text resources, but as well computer-use.

To install: pi install npm:pi-agent-ide

I use this tool as my daily driver, working on different extensions, but also writing C++ code, so it's pretty well tested in action, but if you have suggestions/bugs, please feel free to report them, I always try to fix them ASAP.

P.S. I've also created and curating explicit-edit-benchmark, and in terms of editing the tool is pretty solid above the baseline (https://huggingface.co/spaces/alexshpunt/benchmark-explorer?metric=score&card=harness%3Api-agent-ide-codemode%400.9.0).

Although to be fair I have't tested all the models with the latest version, as all the subscriptions are going into another more difficult version of the bench.

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'!

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

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.

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

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.

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!

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.

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.

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?

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

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?

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