Welcome to the Pochi Developer Updates — a digest of what's new in the codebase.

Here you will find highlights on features, enhancements, and bug fixes, plus insights into how we're improving the developer experience. Come back often! 👋

Weekly Update #11

Nov 21, 2025

TL;DR

This week was a big one.

We shipped Next Edit Suggestions (one of our biggest upgrades so far), along with real-time task notifications and cleaner diff views. Pochi now feels smarter, tighter, and much more intuitive across the codebase.

🚀 Features

• Next Edit Suggestions (NES): We’ve introduced our internal edit model powering Next Edit Suggestion (NES). It is an upgrade to Tab Completion that predicts the next change your code needs, wherever it lives. It learns from your recent edits, understands how your file is evolving, and auto-surfaces likely follow-up edits.
  
  We’ve published a deep-dive on how we trained and evaluated the edit model, and how it powers Pochi's experience. You can read more here.

• Pop-up Notifications for Task Status Changes: Pochi now shows real-time notifications when a task completes, fails, or needs your input. Each notification includes a “View Details” button that jumps directly into the task. In the case the task panel is already open, we suppress duplicable notifications to reduce noise.

• Gemini 3 Support: We’ve added support for Gemini 3 Pro alongside 2.5 Pro. The UI for model selection is updated and ready for you to take over!
  

✨ Enhancements

• Line Wrap Toggle in Code Blocks: We added a line wrap toggle to the code block component in the VS Code extension. This way, long lines inside diffs and model edits are now way easier to read, especially when reviewing wide changes across generated code.

🔥 Preview

• We’re actively working on a set of UX upgrades for the VS Code sidebar - things like grouping tasks by worktree, cleaner task headers, and a diff-summary panel that shows all file edits at a glance. More on this in an upcoming update.

NES Series (Part 1): The Edit Model Behind Tab Completion

Nov 19, 2025

In this post, we’re introducing our internal edit model, the foundation behind Next Edit Suggestion (NES). It’s an upgrade to Tab completion, designed to predict the next change your code needs, wherever it lives.

Technically this is much harder to achieve, since NES considers the entire file plus your recent edit history and predicts how your code is likely to evolve: where the next change should happen, and what that change should be.

Other editors have explored versions of next-edit prediction, but models have evolved a lot, and so has our understanding of how people actually write code.

As an open-source team, we want to share this work transparently. This is the first post in our "Next Edit Suggestion" series, where we walk you through how we trained the underlying model to how it powers real-time editing inside the extension.

How We Train the Edit Model

When we decided to build NES, one of the first pressing questions on our mind was: What kind of data actually teaches a model to make good edits?

It turned out that real developer intent is surprisingly hard to capture. As anyone who’s peeked at real commits knows, developer edits are messy. Pull requests bundle unrelated changes, commit histories jump around, and the sequences of edits often skip the small, incremental steps engineers actually take when exploring or fixing code.

The Training Process

To train an edit model, we format each example using special edit tokens. These tokens tell the model:

• What part of the file is editable
• The user’s cursor position
• What the user has edited so far
• What the next edit should be inside that region only

Unlike chat-style models that generate free-form text, NES is trained to predict the next code edit inside the editable region.

Below is an example of how NES predicts the next edit:

In the image above, the developer makes the first edit allowing the model to capture the intent of the user. The editable_region markers define everything between them as the editable zone. The user_cursor_is_here token shows the model where the user is currently editing.

NES infers the transformation pattern (capitalization in this case) and applies it consistently as the next edit sequence.

To support this training format, we used CommitPackFT and Zeta as data sources. We normalized this unified dataset into the same Zeta-derived edit-markup format as described above and applied filtering to remove non-sequential edits using a small in-context model (GPT-4.1 mini).

Choosing the Base Model for NES

With the training format and dataset finalized, the next major decision was choosing what base model to fine-tune. Initially, we considered both open-source and managed models, but ultimately chose Gemini 2.5 Flash Lite for two main reasons:

• Easy serving: Running an OSS model would require us to manage its inference and scalability in production. For a feature as latency-sensitive as Next Edit, these operational pieces matter as much as the model weights themselves. Using a managed model helped us avoid all these operational overheads.

• Simple supervised-fine-tuning: We fine-tuned NES using Google’s Gemini Supervised Fine-Tuning (SFT) API, with no training loop to maintain, no GPU provisioning, and at the same price as the regular Gemini inference API. Under the hood, Flash Lite uses LoRA (Low-Rank Adaptation), which means we update only a small set of parameters rather than the full model. This keeps NES lightweight and preserves the base model’s broader coding ability.

Overall, in practice, using Flash Lite gave us model quality comparable to strong open-source baselines, with the obvious advantage of far lower operational costs. We can , keeping the model stable across versions.

Why this matters for you

Using Flash Lite directly improves the user experience in the editor. As a user, you can expect faster responses and likely lower compute cost (which can translate into cheaper product).

And since fine-tuning is lightweight, we can roll out frequent improvements, providing a more robust service with less risk of downtime, scaling issues, or version drift; meaning greater reliability for everyone.

How we evaluated the model

We evaluated our edit model using a single metric: LLM-as-a-Judge, powered by Gemini 2.5 Pro. This judge model evaluates whether a predicted edit is semantically correct, logically consistent with recent edits, and appropriate for the given context. This is unlike token-level comparisons and makes it far closer to how a human engineer would judge an edit.

In practice, this gave us an evaluation process that is scalable, automated, and far more sensitive to intent than simple string matching. It allowed us to run large evaluation suites continuously as we retrain and improve the model.

Enhancing Context at Inference

Training and evaluation only define what the model knows in theory. To make Next Edit Suggestions feel alive inside the editor, the model needs to understand what you are doing right now. So at inference time, we give the model more than just the current file snapshot. We also send:

1. Your recent edit history Wrapped in <|edit_history|>, this gives the model a short story of your current flow: what changed, in what order, and what direction the code seems to be moving.

2. Additional semantic context Added via <|additional_context|>, this might include type signatures, documentation, or relevant parts of the broader codebase. It’s the kind of stuff you would mentally reference before making the next edit.

Here’s a small example image showing the full inference-time context with the edit history, additional context, and the live editable region which the NES model receives:

NES combines these inputs to infer the user’s intent from earlier edits and predict the next edit inside the editable region only.

In this post, we’ve focused on how the model is trained and evaluated. In the next post, we’ll go deeper into how these dynamic contexts are constructed, ranked, and streamed into the model to drive real-time, context-aware edit predictions.

Weekly Update #10

Nov 13, 2025

TL;DR

We added modular @import rules and fixed PDF handling in readFile. Behind the scenes, we’re preparing two big improvements: smart task notifications and a refreshed, faster tab-completion experience.

✨ Enhancements

• Modular Rules with @import Syntax: You can now split and organize large rule files by importing other markdown files using the @ prefix (e.g. @./rules/api-guidelines.md). Pochi will stitch them together, managing complex configurations for your multi-agent or multi-project setups. #540

🐛 Bug fixes

• PDF Handling in readFile: Resolved a bug that caused readFile to return PDF files as plain text. #591

🔥 Preview

• Smart Task Notifications: Pochi will now show real-time notifications when a task needs your input, completes, or fails. Notifications will include a “View Details” button to jump directly into the task, and will be automatically suppressed when the task panel is already open to avoid duplicates.

• We’re also preparing an upgrade to our tab completion system to make suggestions feel faster and more intuitive. More details coming soon!

Launching Parallel Agents

Nov 11, 2025

Teams rarely work on a single task at a time. You might be part-way through a feature when a bug report arrives, someone needs a small refactor reviewed, or a documentation fix is pending. Most tools and workflows force these tasks to share one working state.

So you end up switching branches, stashing and popping changes, resetting your workspace, and trying to hold the original task in your head. This is context switching, and it’s one of the biggest hidden costs in software development.

We released Parallel Agents to remove that cost. Each agent runs in its own Git worktree, which isolates the task’s state from the rest of your work.

A great example would be to run the same task with different models to pick the best response. Won’t that be a faster and much better experience - all within the same timeframe?

This is different from other existing solutions, which operate inside a single editor tab. In those tools, you’re effectively working in one tab at a time: switching tasks means switching the state of the same working directory and the same conversation.

On the other hand, Parallel Agents in Pochi keep tasks fully isolated by running each one in its own Git worktree. You can keep multiple tasks active at once and switch between them without stashing or losing context.

How to use?

1. You can create a worktree from the Pochi sidebar. Once a worktree exists, starting a task in that worktree opens it as its own tab in Pochi.
2. When a task finishes, use the diff view to review its changes. If it looks good, create a PR from that worktree.

When to use Parallel Agents

Parallel Agents are most useful when you want to avoid breaking focus on ongoing work: quick bugfixes during feature development, long-running refactors that you want to keep separate, documentation changes that happen alongside coding, or letting an AI assistant explore broader changes in a sandbox.

On the other hand, if a change is meant to be reviewed and merged as a single unit, keeping it on one branch remains simpler.

Here is the demo showing the feature in action:

Read the full documentation here.

Weekly Update #9

Nov 01, 2025

TL;DR

Custom Agent gets even better ⚡ + i18n upgrades for global users 🌏! And major Chat Sidebar UX upgrades are coming soon! 🚀

🚀 Features

• Custom Agent with Slash Section: You can now invoke custom agents directly through slash commands in the VS Code chat sidebar — just like how you trigger workflows. #567

This change unifies how agents and workflows are invoked, creating a more intuitive and consistent experience for interacting with Pochi’s capabilities.

• Chat UI i18n: We are bringing full internationalization to the chat UI!✨ Hardcoded strings are being replaced with our i18n system (powered by i18next), paving the way for a localized experience in English, Chinese, Japanese, and Korean. #201

✨ Preview

We’re actively working on a series of UX improvements to the VS Code chat sidebar, aimed at making Pochi more seamless and intuitive to use. Stay tuned for the upcoming update!

Weekly Update #8

Oct 21, 2025

TL;DR

We’ve given Pochi new tricks.

Workflows can now execute Bash commands, readFile tool handles multimedia inputs, and markdown rendering is faster and cleaner with streamdown.ai.

Let’s get on with it!

🚀 Features

• Bash Commands in Workflows You can now execute Bash commands directly inside Pochi workflows using the ! prefix. This allows workflows to pull live system or repository context, like git status or uname -a, and feed the results into the model before running your task. For example:

- With this: !`uname -a` and !`uptime` 
- Please show the system info and uptime

Pochi automatically runs these commands and includes their outputs in the model’s context, making workflows more dynamic and connected to your local environment. #541

✨ Enhancements

• Faster Markdown Rendering with streamdown.ai: We’ve replaced react-markdown with streamdown.ai in the VS Code web UI. This upgrade improves performance, adds streaming-based markdown rendering, and ensures better support for rich content (like math, code blocks, and workflows). #401

• Extended Multimedia Support in readFile Tool: The readFile tool now supports reading multimedia files, including images, audio, and video, for multimodal models. Pochi automatically detects file types and encodes the content in base64 for models that can interpret visual and auditory data. #539, #569

• Added Linux ARM64 Release: Pochi is now available for Linux ARM64 systems, improving compatibility for developers running on Raspberry Pi or ARM-based environments. #543

Weekly Update #7

Oct 14, 2025

TL;DR

This week, we focused on making Pochi more capable for builders who live in the terminal. We extended image-prompt support to the CLI, added global workflows for shared automations, and made the command-line experience smoother with shell autocompletion.

We’ve also shipped .pochiignore support and small but delightful touches like copying images directly from the extension chat.

🚀 Features

• CLI Autocompletion: The Pochi CLI now supports shell autocompletion for bash, zsh, and fish. Improve your flow as you discover commands, subcommands and options while typing, without the need to stop and check docs mid-flow. #307

• Global Workflows: You can now store workflows globally in ~/.pochi/workflows, and Pochi will load them across all workspaces. Easily share automations, setups, or linting rules, while allowing your team to maintain consistent review or deployment routines.#123, #517

• Image Prompts in CLI: You can pass images directly to Pochi from the CLI, be it a diagram, a UI screenshot, or a flow chart. Models interpret and respond to your visuals, explaining issues, parsing charts and generating code based on UI mockups. #513

✨ Enhancements

• .pochiignore Support: You can now use .pochiignore (just like .gitignore) to exclude files and directories from Pochi’s context, keeping your large repositories lean and your prompts focused on the task at hand. #515 , #516

# Example .pochiignore
node_modules/
dist/
*.log

• Copy Images from MCP and Attachments: You can now right-click any image generated by MCP tools or shared in chat to copy it to your clipboard or open it in an editor tab. A small addition, but a big win for anyone working with visual data or model-generated diagrams. #500

🐛 Bug fixes

• Command Queue Stability: Fixed race conditions between queued and other requests (particularly during preview operations) to improve execution consistency and error handling. #528

Weekly Update #6

Oct 03, 2025

TL;DR

Q4 is here, and Pochi’s cooking. 🍳

We’ve rolled out new built-in tools (webFetch and webSearch) that extend Pochi’s server-side capabilities, added support for new AI vendors (Codex and Qwen Coder), and released a new tutorial that shows how Pochi can act as your AI teammate in GitHub Actions.

Let’s start! 🧡

🚀 Features

• Built-in Tools: Pochi now supports server-side tools, allowing it to register and expose capabilities that come bundled directly with the app. The first two built-in tools introduced are webFetch and webSearch. These let AI agents fetch, read, and process web content directly. #447

• New AI Vendor Support: Pochi now supports Qwen Coder and Codex, adding new model vendors alongside Claude, Gemini, and Copilot. We've also introduced native compatibility with Anthropic’s API format, enabling faster and more stable integration with Claude models. #52, #304, #302

  

✨ Enhancements

• Model-Aware Workflows: You can now define which model a workflow should use directly in its configuration. This gives you more control over which LLM handles each automation, especially useful if your team switches between providers like Claude, Gemini, or Codex. #343

🐛 Bug fixes

• Assistant Retry Logic: Fixed an issue where assistant messages without tool calls were treated as new steps instead of retries, causing the retry count logic to behave incorrectly. #342

• Diff View in VS Code: Files open before a diff operation are now reopened after accepting or rejecting changes, preserving your workspace layout. #440

📖 Resources

• We’ve published a new tutorial: Build Your Own AI Teammate with Pochi in GitHub Actions. Learn how Pochi can review and gatekeep PRs, enforce coding standards, open issues, and even run as a continuous background agent.

Weekly Update #5

Sep 26, 2025

TL;DR

This release introduces a manual sub-task execution mode for more control over sensitive workflows. We’ve also added MCP support in the CLI, enabled GitHub Copilot and Claude Pro/Max authentication, and shipped new tutorials and key security and stability improvements. 🙌

🚀 Features

• Manual Execution Mode for Sub-Tasks: Sub-tasks created with newTask can now be run in a manual, step-by-step mode avoiding large unmoderated changes to your codebases in your sensitive workflows. #300

• MCP support in CLI: The CLI now supports running your Model Context Protocol (MCP) servers, allowing you to connect your tools, and run MCP-powered workflows directly from the terminal. This update brings the CLI closer to parity with the VS Code extension. #100

• AI Tooling Integrations (GitHub Copilot + Claude): You can now authenticate and use your GitHub Copilot and existing Claude Pro/Max subscriptions within Pochi across both the CLI and VS Code. Once authenticated, these services provide completions and suggestions directly in your workflows, enhancing the overall AI-assisted development experience. #184 , #61, #306

  

• Improved VS Code Configuration Navigation: VS Code commands like Pochi: Open MCP Server Settings now open the relevant config file and jump directly to the specific setting, #301

✨ Enhancements

• Enhanced Gemini Model Support: We've improved existing image input capabilities with added PDF and video inputs, providing richer multimodal workflows with Gemini models. #219

• Malformed Custom Agents in VSCode Settings: Previously ignored malformed agent files (e.g., with YAML parsing errors) are now displayed in the settings UI with a clear warning, making it easier to debug and fix broken custom agent configurations. #391, #415

📖 Resources

• Connect Pochi to Your Self-Hosted Tabby Server
• Build a Custom MCP Server to Query Supabase

Weekly Update #4

Sep 19, 2025

TL;DR

We are excited to introduce Queued Messages — type prompts in advance and stop waiting for Pochi to finish a task! We also launched a new Tutorials section with guides on voice-driven development and Mermaid graphs. Have tips or insights? Contribute your own via PRs! Plus, Pochi now supports more file types, and the CLI is friendlier and more interactive. ✨

Features 🚀

• Queued Messages: Don't wait around — ⌘/Ctrl + ↵ to line up your next prompt when Pochi is busy. #286

  

• Tutorials: A new documentation hub to help you get more out of Pochi. This week: voice-driven dev with Hex, and Mermaid graph communication.

Enhancements ✨

• Multimedia file support: Share not just images, but also PDFs and videos with Pochi. #271

• Claude Code login: The CLI now supports authentication with Claude Code. #282

• Friendlier CLI experience: Interactively pick auth vendors and navigate through tasks, get clearer help/error messages, and see upgrade notices on startup. #287, #294, #308, #329, #357

  

• Docs updates: Added documentation for queued messages and tab completion model settings and improved VS Code docs. #317, #321, #365

Bug fixes 🐛

• VS Code UX tweaks: Unified drag-and-drop overlays with the prompt editor, fixed tooltip arrows, and ensured model selections are preserved with clear alerts when a model is unavailable. #350, #316, #373

New Contributors 🐾

A belated shout-out to @DESU-CLUB for their first contribution last week — and another one this week! 🥳

Weekly Update #3

Sep 12, 2025

TL;DR

This week we brought custom agents to life!🐣 Pochi CLI is on npm, newTask makes it simple to create and manage tasks right from the terminal, and Mermaid diagrams render beautifully inside the app. MCP interactions are smarter too, and the docs and UI keep getting smoother with every update. ✨

Features 🚀

• Custom Agents: Define your own assistants in .pochi/agents using markdown. #176, #181
• newTask in CLI: Spin up tasks directly from the terminal, each with its dedicated agent. #232
• Mermaid diagrams: Drop Mermaid code blocks into Pochi and see them rendered as nice diagrams. #255

Enhancements ✨

• Pochi CLI on npm 📦: npm install -g pochi and get it running! #238
• Custom models for completion: Use your own models for code completion in VS Code. #251
• MCP instructions: MCP servers can now guide models on tool usage, enabling more complex interactions. #254
• Token auth: Log in with a token when browser auth doesn't work. #235, #236
• Diff view focus mode: Pochi automatically closes a file's regular editor tab when opening its diff view. #197
• More CLI commands: pochi mcp list to inspect configured MCP servers, and pochi task list to check task lists. #231, #266
  
• VS Code UI polish: Autocomplete mention list is responsive and tabbable, workflow list is collapsible and better spaced. #215, #204, #230, #228, #242
• Docs updates: Added checkpoint feature and updated GitHub integration docs with API key setup. #203, #262

Bug fixes 🐛

• Scoped replies: Pochi only responds when you start a comment with /pochi. #202

Weekly Update #2

Sep 5, 2025

TL;DR

We had a massive week — 62 PRs shipped 🎉!

Pochi can now reply to you right in GitHub comments & issues, the interface speaks more languages with new i18n support, and we rolled out a sleeker, more powerful background job system. On top of that, the CLI got smarter, autocomplete got friendlier, and the docs got a glow-up!

Features 🚀

• GitHub Action integration: Pochi now lives in your PR comments / issues! Ask for help in a PR with /pochi. #76
• Internationalization (i18n): The VS Code extension now supports 🇺🇸 🇨🇳 🇯🇵 🇰🇷. Want your language included? Open a PR! #90

Enhancements ✨

• CLI upgrades: The Pochi CLI got a big boost this week!
  • Install via Homebrew 🍺 #125
  • Authenticate with pochi auth, including support for Gemini login #167
  • Trigger workflows directly with pochi -p "/create-pr" #110
• Enhanced Background jobs: Added terminal integration and lifecycle controls. Enhanced the job UI with collapsible detail logs and readable IDs for a clearer experience. #81, #97
• Autocomplete: Pochi suggests relevant tools, functions, and variables to help you type prompts faster. #89
• Documentation updates: Refreshed CLI usage docs, expanded model provider configuration examples, and added Slack integration documentation. #133, #141, #82

Bug Fixes 🐛

• File writing reliability: The CLI ensures directories exist before writing, so writeToFile tool won't fail. #118
• Code completion fix: Corrected how VS Code calculates the replacement range for suggestions, so completions insert correctly. #131

New Contributors 🐾

@karim-coder made their first contribution this week! Welcome aboard! 🎉

Weekly Update #1

Aug 29, 2025

TL;DR

This week we polished the VS Code extension with some UX upgrades, open-sourced the Pochi CLI, and did a few rounds of codebase cleanup to make contributing easier and friendlier for newcomers. We look forward to your first visit to the repo!

Enhancements ✨

• Drag & drop images: Share visuals with Pochi in the VS Code chat just by dragging them in. #64
• Improved docs: Updated structure and added guidance on model settings for easier use. #60, #63 , 900d162
• Model pricing at your fingertips: Check model costs directly in settings before choosing one. #74

Bug Fixes 🐛

• File search now correctly surfaces matching files: Queries that used to return empty results will now behave as expected. #79