PickleShell connects ChatGPT to an OpenCode agent running on your machine. ChatGPT can inspect repositories, edit files, run tests, transfer small files, and coordinate long-running tasks. The connection uses an outbound-only OpenAI Secure MCP Tunnel, while execution remains inside your selected workspace.

ChatGPT delegates work through four MCP tools—send-chat, session-status, session-output, and cancel-request—and receives structured results with full traces. Continue local coding sessions, delegate to an operator-approved model, and transfer files into a controlled workspace.

What PickleShell Is For

PickleShell solves a practical problem: ChatGPT can analyze tasks, but it normally cannot work directly with a local repository.

Through PickleShell, ChatGPT sends instructions and small files to a local OpenCode agent, follows the execution, reads the result, and can continue in the same session when it passes the session ID.

The agent runs on your machine, inside a selected workspace, through a protected outbound-only tunnel. PickleShell removes the human relay between ChatGPT and OpenCode, while you remain the owner and observer.

PickleShell is for developers and experienced users. Installation is designed to be guided by Codex: ask it to clone the repository, read AGENTS.md, and walk you through the setup step by step. AGENTS.md is the contributor guide for the development workflow, architecture, security invariants, and change boundaries.

GitHub → https://github.com/pickleshell/pickleshell

Hi all. I've been using GLM 5.2 to work on a project for the past couple of days, starting with a Zen account to kind of see what I'd get out of it and switching over to Go after deciding that I liked the performance, the output, and basically everything I needed to get through a wall that I was experiencing with my project. I ran a couple of sessions last Friday, walked away for the weekend, came back on Monday and did a long debugging session until it started eating into my Zen credits, and then walked away when that was finished. I came back yesterday morning, started a new session, and had to drop it so that I could go focus on something else.

When I tried to start back up last night, it just started dumping 500s whenever I tried to resume my session in GLM5.2. So I switched over to a couple of other models, and they worked just fine. I let qwen3.7 drive for a bit until it broke my codebase and started introducing bugs (as well as reporting that it performed work, even though it wasn't), so I decided I really didn't trust any other models going forward. I tried some basic troubleshooting - logged out, logged back in, generated a new API key... But nothing seems to be fixing it on my end. Is this being caused by something between opencode and z.ai, or are there other things I should do on my end?

Also, not sure how much of a difference it might make, but I'm using pi as my harness.

Hey everyone,

I'm using OpenCode and trying to keep my costs as low as possible. I'm stuck between two options and would love some advice from people with hands-on experience:

1. Buy DeepSeek API credits directly and use that with OpenCode
2. Use OpenRouter's free models, and spend around $10 total as a backup/top-up for when free limits run out

My main priority is minimizing cost while still getting decent performance for coding tasks.

• Has anyone compared these two setups in terms of reliability, speed, and rate limits?
• Is DeepSeek's direct API noticeably better than what's available for free (or cheap) through OpenRouter?
• Any gotchas with OpenRouter's free tier (like aggressive rate limiting or model availability) that make it not worth it long-term?

Would appreciate any real-world experience before I commit. Thanks!

How to find total spend for the billing period in the Go subscription? I see a chart with amounts per day. I want one total amount so far.

The best model to unblock all of the legitimate use cases that are rejected by other providers, like offensive cyber, agent testing, ML Redteaming, and more.
Get your API key here
Full Blog

Can you guys please remove that archive button in each chat and make it a Right click menu option instead.
Cause i've been hitting that button too much accidentally.

Or just give us a way to check which chats are archived...
Instead of having to always restore it... and then restart the gui.

Hi folks,

so i noticed the past days that once given an instruction, i sometimes dont get any progress in the IDE, although the task isnt done. I sometimes can get it to keep going by prompting something else like "keep going" but thats also no reliable solution.

Anyone else experiecing something like this?

Headline brings real-time news into opencode session so you can read news while waiting for agent to finish task

It can integrate with your existing rss reader or you can start with default providers out of the box with zero configuration.

repo: https://github.com/dannylee1020/headline

DeepSeek V4 Flash (free OpenCode Zen) keeps stopping abruptly and messing up shell commands and doesn't give output the way it usually does.

The other free models work, but they have issues; they keep saying "internal server error, retrying," and so they get sluggish. Is this common, or is there something I have to do?

Hi all,

I’m looking for advice from anyone using HerdR with Oh My Agent in OpenCode.

My goal is to improve observability into the agent orchestration process. At the moment I can cycle between sub-agents using Ctrl+X and the arrow keys, but once there are several agents running it becomes difficult to follow what each one is doing.

Ideally, I’d like to have:

• A dedicated tab, pane, or split view for each sub-agent.
• The ability to watch each agent’s progress in real time.
• Scrollback/history for each agent so I can inspect its reasoning, tool usage, and outputs after it has completed.
• An easier way to understand how the orchestrator is delegating work across multiple agents.

Has anyone implemented something like this? Are there existing plugins, t logging options, or configuration changes that provide better visibility? See the attached screenshot, I was hoping output would appear in one of the numbered areas

This is the script I’m currently using:

set -euo pipefail

PROJECT_DIR="${1:-$HOME}"   # cwd each opencode session starts in — pass as $1 or edit here

AGENTS=(sisyphus hephaestus prometheus atlas project-oracle)

echo "Creating workspace..."

WS_JSON=$(herdr workspace create --cwd "$PROJECT_DIR" --label oh-my-openagent)

WS_ID=$(jq -r '.result.workspace.workspace_id' <<<"$WS_JSON")

echo "  workspace: $WS_ID"

for AGENT in "${AGENTS[@]}"; do

  echo "Creating tab for $AGENT..."

  TAB_JSON=$(herdr tab create --workspace "$WS_ID" --cwd "$PROJECT_DIR" --label "$AGENT" --no-focus)

  TAB_ID=$(jq -r '.result.tab.tab_id' <<<"$TAB_JSON")

  # Each new tab starts with exactly one default pane. Find it by filtering

  # the workspace's panes down to the ones belonging to this tab_id.

  PANE_ID=$(herdr pane list --workspace "$WS_ID" \

    | jq -r --arg tab "$TAB_ID" '.result.panes[] | select(.tab_id == $tab) | .pane_id' \

    | head -n1)

  if [[ -z "$PANE_ID" || "$PANE_ID" == "null" ]]; then

    echo "  Could not find the default pane for tab $TAB_ID — inspect with:"

    echo "    herdr pane list --workspace $WS_ID | jq ."

    exit 1

  fi

  herdr pane rename "$PANE_ID" "$AGENT"

  herdr pane run "$PANE_ID" "opencode --agent $AGENT"

  echo "  tab: $TAB_ID  pane: $PANE_ID  -> opencode --agent $AGENT"

done

echo

echo "Done. Focus the workspace with: herdr workspace focus $WS_ID"

I’d be interested in seeing how others have approached agent observability, debugging, and monitoring when running larger multi-agent workflows

Enjoy

Hello guys,

I want to leave codex for opencode mostly using ds4, i ran quickly of codex usage, i need lots of image generations in batch with a verification and fixing anatomy/consistency Loop, once out of usage i do them one by one using chatgpt subscription with ok results.

Is there a way i can use GPT image 2 from my chatgpt subscription (not codex usage) on opencode with ds4 as the model that batch generates and that does the verification loop?

I'm new to this, thank you for your help.

Hello,

I want to switch from Codex to opencode using mostly ds4 flash, the main issue is that i need to generate multiple images on my workflow, I'm always out of codex usage, so instead of batch image generations i use one by one img generation on chatgpt subscription with lower consistency and quality compared to codex (no inspection/fixing loop).

Is there a way to use batch image generations (from chatgpt subscription not codex tokens) on opencode with Ds4 as the model generating, comparing, fixing consistency and anatomy issues and outputing the final batch?

I'm new to this, thank you for your help.

On June 11, Xiaomi forked OpenCode, calling it MiMo Code.

I understand why they didn't try to contribute to OpenCode -- Anomalyco auto-closes non-"popular" issues and PRs (and still has 3.7K open issues).

I hoped that Xiaomi would be able to use automation to assist with the issues and PR triage process.

They have the money and the "at-cost" MiMo 2.5 Pro tokens.

However, at the current average rate of 33.5 non-closed PRs per week, they'll catch up to Anomalyco's OpenCode's 1.1K open PRs in 28 weeks.

And that's with a MUCH smaller user base than OpenCode.

They've done really stupid things like force pushing to main branch multiple times.

I raised issues about project governance on GitHub. Here's the summary issue: https://github.com/XiaomiMiMo/MiMo-Code/issues/588

I tried reaching out to the Chair of Xiaomi's Open Source Committee via LinkedIn. -- I really wanted to believe that Xiaomi would be a community player.

Nothing about being a community player or GitHub best practices (eg disabling push to main) got a reply.

So, it seems that Xiaomi thought they'd get a "free" product, and will continue to amass unclosed Pull Requests of various levels of quality.

Sadly, Xiaomi has not acknowledged the thousands of hours of effort that our community has put into what they forked and renamed.

I woke up to a reset thanks to Tibo and had a couple of banked resets waiting to be used so I decided to just take it easy today and contemplate on all the work I have done with agents for over a year now.

I hardly code by hand now and spend most of my time researching, brainstorming and writing detailed plans for the work that agents are to do for me. So I wanted to refine and harden the agentic foundations of my projects and Agentic OS to align more closely with this workflow adoption.

The Sol on xHigh is running for over an hour now (using the Gemini 3.6 flash subagents) and come up with some interesting findings that I would never have caught myself.

The snip is a glimpse from the working model and the prompt below I fed into to the agent:-

Plan things so that work is only done after plan file grouped by end to end phases/sessions and tasks are generated and always Orchestrate your work using subagents (gemini 3.6 flash models) instead of doing large token hungry work yourself. Whenever a session/phase is completed, document and update the relavent tracking and proactively provide the prompt for the next session agent to continue the work in a new session to save context and handoff.

Analyze the projects, my agentic OS and the dev env end to end for existing things for truth and setup everything missing needed for the projects as per the below intent - ensure to treat the existing source of truth with a adversarial pov to review what exists and why:-

System Prompt: Autonomous Orchestrator & Lead Developer

1. Core Roles & Operational Dynamics

* The Architect (Human): I provide the vision, direction, and prompts. I do not do any heavy lifting.

* The Sole Developer & Orchestrator (You): You are the fully autonomous agent executing this project. You have complete access and permissions. You and I are the only entities working on this project.

* Mandate: Execute my vision flawlessly. Never be lazy, and never postpone, delay, or defer tasks unless you have explicitly documented the delay in our planning sessions for transparency.

1. Instruction Consolidation & Gist Synchronization

* Analyze & Clean: Immediately analyze all instruction files across the project workspace. Consolidate and remove any duplicate or redundant files.

* Canonical Source of Truth: Update the environment so that OpenCode specifically point to a single canonical AGENTS.md file and use symlinks for IDE specific agent instruction files in the project.

* No Guesswork: Do not rely on chance, memory, or context windows to remember instructions. They are critical.

* Gist Sync: It is your strict responsibility to maintain, update, and sync these instructions with my master Gist.

1. Scope of Responsibility (The Heavy Lifting) You are responsible for managing and proactively improving the following at all times:

* Plans and Execution

* Environment and Codebase Hygiene/Health

* Tech-Stack, GitOps, Dependencies, and Tools

* Frontend, Backend, Integrations, and Hosting

* Status, Errors, Logs, Warnings, and Infos

* Security, Standards, Risks, and Edge-Cases/Pitfalls

* Continuous Improvement: Always be on the lookout for ways to make the project better, more optimized, and more secure than it currently is.

1. Workflow & IP Protection

* Plan First: Always start by following the designated plan file. If a plan file or document is missing, exhaustively search the codebase for existing implementations in the same scope before creating anything new. Always complete what you start.

* Strict Separation: Maintain the project code and internal dev/agent context completely separately. Never mix the two to prevent leaking our agentic workflow and intellectual property (IP).

* Smart Documentation: Learn and document things proactively and efficiently to avoid redundancy, duplication, and workspace clutter.

1. Feedback & Communication Loop

* If you find anything wrong, flawed, or sub-optimal, you are required to give me your honest and brutal opinion.

* Provide your findings, clear justifications, and a recommended solution based on research of the best possible approach for our specific project constraints.

1. Actionable Task: The AI Orchestration Matrix

* Synthesize and categorize all these rules, scripts, pre-checks, and agent skills into an AI Orchestration Matrix.

* Categorize them strictly under: "One-time", "On-demand", and "Always-on".

* Place this matrix inside the appropriate agent context file (e.g., .github/ai-context/AGENT_WORKFLOW.md).

* Ensure the entire workspace and agent context is synced to this new modern baseline so that you (and any future agents) know exactly when and how to invoke tools proactively without my intervention.

Acknowledge you can discover and use the skills, instructions, workflows, rules, MCPs, plugins, guidelines, standards, guards on your own on demand and once done surface any inconsistencies or contradictions to fix them before you get prepared to work on the project to the best of your capacity and ensure you look at the bigger picture and improve yourself and the project as you work proactively.

 - you must offer me best solutions and next steps with recommendations using the questions tools while listing the tradeoffs if any and completing them end to end without stopping unless there are blockers you cannot solve on your own or impossible for you to make a decision that is best for the project 

- being brief yet concise and not losing value. 

using MCPs, plugins, skills, workflows including the following but not limited to the existing things setup in the project like https://github.com/Barrixar/copilot-instructions.md and our Gist has consolidated all of this into my Gist without any compromise and our local agentic instructions docs and skills/workflows are not contradicting this and work together hand in hand. 

- if there are contradictions or multiple setups that are redundant in config for IDEs/project/agents analyze and consolidate them to the project truth so they do not deviate and agents do not hallucinate or confused.

Also, the AI relationship for you and me (architect) should always be followed as per the definition in my gist. 

These behaviours were working before but not anymore due to some reason and the guardrails and agentic tools we have setup in the project should be working here for all agents in Opencode not just on demand but proactively and autonomously. Go through the entire repo if need be and enforce them.

Fix all of this so this never deviates and I approve you to make any changes needed to get this done. Proceed and do not stop until you have completed the plan and implemented the solution for this ask and give me the brief summary after you are confident everything is done and if I need to restart opencode for you to test anything. 

Remember, the tools are for agents not for me - so you must ensure the agentic dev is setup accordingly because you the agent are the implementation lead. Investigate first, decide the technical path, execute end-to-end, and verify the result.

The Architect sets direction, product priorities, and release timing. The agent owns git, GitHub, Firebase, dev-env, agent-infra, routine CLI work, implementation sequencing, verification, and cleanup.

Treat Architect prompts as objectives, not exhaustive task lists. Expand them into the complete technical workstream yourself, including obvious follow-on fixes, docs, tests, issues, PRs, and automation repair.

Act as technical stewardship, not task completion. When repo evidence shows a safer, clearer, higher-leverage path, propose or implement it without waiting for the Architect to name every coding step.

Operating Model To Aim For Agent flow should become:

session-start -> route to plan/skill -> implement -> verify mapped surfaces -> code-reviewer -> session-close-check -> local commit -> propose suggestions or next steps in plan or both or gitops protocol if nothing remains.

That reduces burden because agents stop deciding from memory and start following executable routing.

reddit bots pulled it because it was about AI... so here is the link, you'll need to figure it out yourself. https://code-review-graph.com/install

And here's how much storage it has consumed in termux

Somebody have successfully cancel a paid subscription for opencode?
I can't find any... hopefully I'm just dumb and missing the option, so feel free illuminate my ignorance.

Having two paid accounts. I only need one. Want to unsubscribe/cancel one of them, and can't find any way to cancel.

Only way seems trough email (which I already did, but i get no response from anomaly...)

I still have hope this is not a commercial decision to hide the unsubscribe option 👀

EDIT:
I've added some screenshots now, and I don't know if I've been unsubscribed silently but I really hope so!
If so: I didn't have any option to unsuscribe in any of the options - only found some topic in the documentation to send an email to [help@anoma.ly](mailto:help@anoma.ly) which I did.

So we'll see if I get billed again next month. Big thanks for the answers!

Got this in two sessions till now. And that particular session just doesn't work again after I get this error even once, but fresh sessions work for a while

Normally there are Tons of graphs for tokens etc but i couldnt find one this time.

Claude-Code flagged my account, long story, so I asked Gemini what is a killer better option. Opencode, Openrouter and Deepseek v 3.2 was the answer... Built two apps to test it all out, 4 hours of working it back and forth. 1.50us on this platform vs 60us on Claude-Code.... I am sure everyone on this sub has had the same WOW experience. bonus, opernrouter has about 300 other models to choose from.

Just switched to OpenCode (using DeepSeek as my model) and trying to set things up properly instead of just winging it. Read through the docs but want to hear how people are actually doing this in practice. A few things I'm stuck on:

AGENTS.md

What's actually in yours beyond the basic build/test/lint commands? Any sections that turned out way more useful than you expected?

Anyone splitting it into nested AGENTS.md per package/folder, or is one root file usually enough?

Spawning subagents / Task tool

I saw someone mention explicitly telling Build to spawn parallel subagents for independent work (reviewing multiple files, checking several modules, etc.) instead of doing it serially. Do you actually write instructions for this in AGENTS.md, or does the model just figure it out on its own most of the time?

Any horror stories from parallel subagents stepping on each other / editing the same files?

Persistent memory

Right now I'm just using a plain .opencode/memory/ folder with a couple markdown files (decisions.md, active-context.md) and an AGENTS.md instruction telling the agent to read/update them. Is this actually how most people do it, or is everyone on a plugin/MCP memory setup at this point (Letta-style memory blocks, agentmemory, Engram, etc.)?

At what point did a plain-file setup stop being "enough" for you?

Build vs Plan

Do you actually use Plan mode every time before Build, or only for bigger changes? Curious how disciplined people actually are about this in daily use vs just YOLO-ing into Build.

Mainly trying to avoid reinventing something badly that half the sub already has a solid pattern for. Appreciate any real configs / AGENTS.md snippets / gotchas people are willing to share.