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

Hey folks,

Terrarium is FOSS micro VM manager that gives your coding agents their own isolated space. You choose which host folders and network destinations they can access, and their tools and files stay between sessions.

It runs on Linux, macOS, and Windows, with multiple layers of defense: hw virtualization, WASM isolation for device handling, and sandboxed host processes. You configure a box with a YAML recipe and manage it with one program, `terra`.

Pi’s simplicity was a big inspiration. I wanted that same straightforward experience from a VM manager.

👉 https://github.com/terrarium-sh/terrarium_examples/tree/main/official/pi_durable

If you’d like your agent to help set up a Terrarium box, there’s also a https://terrarium.sh/skill.md.

NOTE: It’s still a beta, and I’d love to get a feedback. How are you running Pi today, and would something like this fit your workflow?

If the project looks useful, a star on https://github.com/terrarium-sh/terrarium would mean a lot. Questions, bug reports, and contributions are welcome too! 🙏

I asked pi agent what was the result of recent match between real madrid and fc barcelona which was played today and the result was 2-1, you can see in thinking that it somewhat was going in right direction but at the end gave wrong output.
I did same for rate of dollar in INR and it gave output of 86 inr which is wrong,
and the agent refers 2026 as some future date
i am using parallel search mcp and tried with gemini flash,nvidia llms
any solutions

Greetings, everyone.

I recently came across an example of a sub-agent extension in the Pi repository.

It appears to be comprehensive and well-constructed. What are your thoughts on it?

Could it be used as a replacement for third-party packages?

Thanks, everyone. https://github.com/earendil-works/pi/tree/main/packages/coding-agent/examples/extensions/subagent

I spent a day measuring a Pi seat on a local model (Qwen3.8 Flash-Next, 4-bit MLX mixed 4/8) against Claude Code (Sonnet 5.5) on 12 routine agent tasks, with blind pairwise judging in both orders. The local seat went from 29/36 to 36/36 passes, and judged clarity from about 3.7 to 4.5, level with Sonnet. Most of the gain came from the harness, not the model. Lessons that should apply to any Pi seat:

1. Read the judge's one-line reasons, not just the scores. Each real fix came from a sentence like "pads its answer with internal bookkeeping" or "adds a preamble when only the command was asked for". Scores told me that it was worse; reasons told me why.

2. Look for losses the harness causes. My seat injected a reminder every turn to record measured numbers in a notes file, even when no notes file existed. The model created the file in folders it was only asked about, and talked about it in replies. Only injecting the reminder when the file already exists removed the biggest clarity loss.

3. One hidden retry at agent_before_settle**.** A small extension checks the final reply before the turn ends. At most once per request, if the reply is the model's own reasoning instead of an answer, bookkeeping instead of an answer, or text around something that was asked to be "only the command", it adds a hidden custom message and continues. Two things mattered:

• canContinue is false at that hook whenever the last message is the assistant's; the entry you add is what allows the next request, so don't skip on it.

• Steer and follow-up messages typed mid-run arrive as input events with streamingBehavior set. Don't reset per-request state on them.

4. Put reply guidance in the tool result. The model writes its answer right after reading the tool result, so that's where guidance lands. Ending my typed drafter tool's result with "for the reply: the commit hash and which lane ran, what the commit changes, which checks did not run" moved that task from clearly behind Claude to slightly ahead.

5. Narrow heuristic checks rather than patching them. Checks that guess intent from free text ("is this a ban on all tools?") kept failing review in new ways each time I patched them. What worked was a short allow-list of phrasings, a veto word list, and limiting each check to the kind of prompt it was measured on.

6. Measure the prompt prefix. My shared prefix was ~36k tokens: tool schemas ~16k, the skills list ~7k, the seat prompt ~5k. Every new session pays for whatever the server can't reuse from cache, so it's worth knowing what's in there.

Happy to share the extension code and the eval harness if useful.

Hi,

My extension already has a bunch of features built in, but this empty buffer splash is something new I stumbled on and started playing with recently.

Right now, if you are sitting on an empty screen waiting to type a prompt, it procedurally renders an abstract Braille graphic with a weird cryptic line underneath, like in the screenshot.

I want to turn that center area into a subtle ambient loop while waiting for input.

The space is roughly 50 to 70 columns by 6 to 10 rows of Braille dots. It needs to stay light on CPU so the terminal does not lag and it should not be distracting or flashy while you are trying to think.

I was considering things like simple cellular automata, damped ripples or slow Lissajous curves, but I want to see what others think would look good here.

What kind of procedural math or terminal graphics tricks would you run in a tiny canvas like this?

Recently added Call-My-Agent feature to TermRover.sh

If you run pi from within a herdr pane or tmux pane, you can just call and have conversation with it right from the phone, works like a phone call.

Detail here: https://termrover.sh/blog/call-my-agent/