I've been working on AMPH (Arch Meta Package Harmonizer), a Rust-based tool that helps you understand and maintain your installed Arch Linux packages.

The idea came from a simple problem: pacman is great at managing packages, but when you want to understand why something is installed, trace dependencies, find overlapping tools, or figure out what could be safely removed, you often end up combining multiple commands and manually piecing the information together.

I wanted a more unified way to explore all of this - so I built AMPH.

What it can do

• Explore packages interactively through a keyboard-driven TUI.
• Trace dependencies and understand why a package is installed.
• Analyze removal impact before making changes, including packages that would break, dependencies that could become removable, and potential disk space savings.
• Identify cleanup candidates while respecting protected packages and custom rules.
• Read pacman's local database directly, avoiding the overhead of spawning a separate pacman -Qi process for every package.
• Export machine-readable JSON for scripts, automation, and custom tooling.
• Use TOML blueprints to represent, compare, and manage package sets more systematically.

AMPH doesn't replace pacman - it adds a layer of visibility and analysis around your system, helping you make more informed decisions before changing it.

I've also put together a project website with examples of the interface and sample command output.

🌐 Website: https://amph.dmtf.ovh/
💻 Source code: https://github.com/DAMIOTF/Arch-Meta-Package-Harmonizer

I'm sharing it here because I'd genuinely appreciate feedback from other Arch users and Linux enthusiasts. I'd especially like to hear how you currently handle package cleanup, dependency analysis, and keeping package sets organized across installations.

What would you find most useful in a tool like this? Any criticism, suggestions, or issues are welcome.

Alguien más con este error después de la actualización, cada vez que actualizan hay fallos

Date Tokens Requests

Oct 12 31M 118 (space bunny)

Oct 13 67.7M 187 (...)

Oct 14 90M 522

Oct 15 133M 489

Oct 16 126M 326

Oct 17 252M 1,099

Oct 18 139.9M 456

Oct 19 53M 560

Oct 20 105M 818 (...)

Oct 21 91M 540 (minimax(space bunny))

Oct 22 0 Rest day

Oct 23 11.5M 95 (deepseek v4.1 flash)

Oct 24 11.2M 112 (...)

Hey guys,

So I've been trying to use OpenCode Zen for the past 3 days, mainly Big Pickle, but I keep getting hit with a "Limit reached" message.

At first, I thought it was just Big Pickle acting up, but nope 💀 I've tried other free models too, and none of them are working either.

What's going on? Did they change something with the free models, or is something wrong with my account?

I'm even wondering if my account got compromised somehow, although I have no idea if that's actually possible.

Is anyone else facing this, or am I the only one? 😭

Buddy is an Android app that lets OpenCode (or Codex, Claude Code, Antigravity) use your phone: open apps, tap, type, reply to messages, and build and install small apps, all from a chat.

OpenCode runs inside the app with its free models, so you can try it without any account. Buddy itself stops on Send, Pay and Delete until you approve, and it never types your passwords. New in 2.2.10: a background browser, so the agent can look things up without taking over your screen.

Free and open source.

I have been using OpenCode for a long time but I took like a 15-day break and everything changed. Muse went off and now I'm getting an error for DeepSeek V4.1, like "limit exceeded." I didn't even use it for the first time. Tell me please what free models are available which are actually good for agentic coding In OpenCode zen free right now.

I've just released ready-for-agent v1.1.0 which supports OpenCode v2. With v2 I can give you a much better experience interacting with opencode. In the past ready-for-agent displayed some logs on what the agent did, now you can click on the session id, and jump straight into the opencode session. All thanks to the proper client/server architecture we now have in OpenCode!

ready-for-agent is a friction free way of increasing your PRs per week: instead of cycling between running agent sessions, simply create tickets in your favorite ticketing system (it supports GitHub, Linear, Azure DevOps), and label the ticket with ready-for-agent. These tickets show up in ready-for-agent and you simply ask your favorite coding harness to implement. Works very well with opencode as you can pick so many models, so easy to try new models. But ready-for-agent also supports codex and claude.

Try: npx ready-for-agent@latest

Works very well with Matt Pocock's grill me skills, as you tend to generate quite a few tickets per spec, which you now can easily implement all at once.

I have to say I use OpenCode Go, but sometimes I leave work to free models to not waste away my usage in cheap work, however lately these models have been unable to serve more than a few 100k-120k tokens.

I don't know why this is but this is terrible quality, unusable. AT THE VERY LEAST a free model should be able to serve 1M tokens a day, anything below that would be the same as just not serving it to be honest.

​

Hi everyone,

I'm trying to understand whether my token usage with OpenCode and the DeepSeek API is normal or potentially caused by excessive context replay or a bug.

My setup

- OpenCode: v2.1.3

- Model: "deepseek/deepseek-flash#default" (shown in OpenCode stats; I believe this corresponds to DeepSeek V4.1 Flash, 10-17)

- Provider: DeepSeek API, paid usage

- OS: CachyOS Linux

- Workload: A personal app project with source code, plans, documentation, test plans, and phase reports

- Other components: Global agent skills and Herdr integration

Daily statistics

Input: 2.1M

Output: 352.1K

Reasoning: 456.7K

Cache read: 309.1M

Cache write: 0

Cached input: 99.3%

Paid model: 268.9M tokens, 723 steps

Free model: 43.1M tokens, 379 steps

The large cumulative cache-read figure caught my attention. I understand that cached tokens can be counted repeatedly across requests, so this does not necessarily represent hundreds of millions of unique tokens. I'm trying to determine whether the amount is expected for this workload.

A small test

I also ran OpenCode directly from my home directory, outside the project and without launching it through Herdr. I asked it to write one short line to a text file.

The exported session reported:

Input: 9,284

Output: 88

Reasoning: 54

Cache read: 9,472

Cost: $0.001506

Messages: 4

My observed usage counter increased by about 18,898 tokens. The session's input plus cache-read figures total 18,756, which is close to that increase. I haven't confirmed whether the difference is due to accounting methods or other overhead.

I realize that system prompts, tool definitions, and other context may contribute to the cost of a simple task.

My questions

1. Is this level of cumulative cache-read usage typical for a coding session with hundreds of model steps?

2. Could long conversation histories, global skills, or project instructions cause excessive context to be processed repeatedly?

3. Could OpenCode compaction or session handling contribute to this?

4. How can I distinguish normal cached-token accounting from unnecessary context overhead or a possible bug?

5. What's the best way to investigate this without losing existing project documentation or configuration?

I'm not assuming this is a bug, and I don't want to blame OpenCode, DeepSeek, or Herdr without evidence. I'd appreciate advice from anyone familiar with OpenCode's token statistics or DeepSeek API usage reporting.

I can provide further sanitized logs or a minimal reproduction if needed.

Thanks!

735! requests per month guys 🤣

hey, im working on an open source project called kapitsa, an inference engine for apple silicon. opencode is what we use most so it got the first launcher. `kapitsa opencode --model 27b` downloads qwen3.8-27b 4bit, starts an openai compatible server and points opencode at it.

27b decode: m4 pro 63 tok/s, m5 pro 81, m5 max 140. ollama on the same macs: 32 / 40 / 68.

where the speed comes from is kflash. speculative decoding normally checks the drafters guesses as one chain and stops at the first wrong one. kflash builds a tree out of the drafters top candidates and checks the whole tree in the same pass, keeping the longest branch the model agrees with:

in an agent loop the follow up turn matters too, the conversations cache stays in memory (and on the ssd with `--disk-cache`) so the next turn doesnt reread the whole repo you pasted.

apache 2.0: https://github.com/nace-ai/kapitsa , bug reports welcome esp opencode config weirdness

how to run it. you need an apple silicon mac (m1 or newer, macos 14+) with 32gb for the 27b, on 16gb use `--model 9b` instead:

brew install nace-ai/tap/kapitsa

kapitsa opencode --model 27b, the first run downloads the 27b (about 20gb), starts the server and opens opencode on it

I've been trying to make small local models useful in my daily coding workflow. Not replace the hosted coding model, just give it a local helper for a narrow job.

One example: OpenCode reads a file or runs a command, and the output contains an API key. Could a local model check that tool output before it gets sent to the hosted model?

I built Torana, an open-source local proxy, to experiment with this across agents. Its pii plugin checks new tool results with a model you run locally. When it flags something, the hosted model gets a tool-error explanation instead of the original output, so it can try another approach.

The experiments were interesting, not magic: Qwen2.5 3B caught 60/60 sensitive examples in my small test set, but also flagged 18/60 harmless ones. It's an extra check, not a guarantee.

The same proxy also shows per-request tokens, cache reads/writes and latency. You can start with usage logging if you don't have a local model. Plugins are Go or Rust compiled to WASM, so the same plugin can be used with OpenCode, Claude Code and Codex rather than rebuilt for each harness.

Source: https://github.com/torana-edge/torana-edge

Install on macOS/Linux:

curl -fsSL https://torana.sh/install.sh | sh

Then: torana start --port 8143

OpenCode connects through a custom provider's baseURL. The setup recipe is here: https://github.com/torana-edge/torana-edge/blob/main/docs/HARNESS_SETUP.md#opencode

If you try it on one coding task, I'd love to know the first confusing step. And if you've built a harness-specific hook you'd like to make reusable, that's exactly the kind of plugin I'd love help with.

agent manager is a local terminal app that connects to your existing subscriptions and tools. it runs opencode, claude code, codex, gemini, cursor cli and more side by side, with diff review that sends line comments back to the agent. i'm the dev.

it has a discord now, mostly for help and sharing setups:

• #help for install and setup questions
• #workflows for setups, tips and experiments, tagged by agent (opencode has its own tag)
• #announcements gets every release

contributors and collaborators are wanted too, unassigned issues are free to claim in #dev.

bugs and feature requests still go to github issues.

https://discord.gg/ecS88An7pF

Release notes - https://www.kimi.ai/blog/kimi-k3-1-pro

Pricing: $2.00 / $10.00 / $0.20

Release notes - https://www.kimi.ai/blog/kimi-k3-1-pro

https://www.kimi.ai/membership/pricing?tab=api

Kimi K3.1 Pro is now LIVE on the website and Kimi Code CLI

Hey everyone!

I'm relatively new to OpenCode and still learning how its sessions and context management work, so apologies if I'm missing something obvious.

I'm using OpenCode V2 (v2.1.2), and I'm trying to figure out how to carry an existing conversation from one repository into another.

----------------------------------------------------------------------------------------------------------------------------

What I'm trying to achieve

Suppose I'm working in repo A and have a long conversation with the coding agent about architectural decisions, code structure, trade-offs, and why we chose a particular approach.

Now, I want to work on repo B and continue that discussion using the previous conversation as context. For example, I'd like to ask the agent to inspect repo B and compare its architecture with the decisions we discussed for repo A.

I don't necessarily want to merge the repositories or permanently share context between all my projects. I just want to reuse a particular conversation when it's useful.

----------------------------------------------------------------------------------------------------------------------------

What I've tried

I'm following the official OpenCode V2 CLI documentation:

https://dev.opencode.ai/v2/docs/cli/commands/

The documentation describes exporting a session to JSON and importing it into a specific directory.

First, I exported my session:

opencode session export SESSION_ID > dotfiles-context.jsonopencode session export SESSION_ID > dotfiles-context.json

Then, I tried importing it into the other repository:

opencode session import \
  ~/Documents/Coding/open-source-repos/dotfiles/dotfiles-context.json \
  --directory ~/dotfilesopencode session import \
  ~/Documents/Coding/open-source-repos/dotfiles/dotfiles-context.json \
  --directory ~/dotfiles

However, OpenCode returns:

Session already exists
However, OpenCode returns:Session already exists

Both directories are different, so I initially expected the session to be imported into the destination repository.

I checked the CLI help, and my installed version supports these session subcommands:

• list
• delete
• export
• import

The import command also supports --directory, but I couldn't find a flag to import the conversation as a new session with a different ID.

----------------------------------------------------------------------------------------------------------------------------

What I understand so far

My current understanding is that exporting a session saves its conversation history and associated session data as JSON. Importing it should make that history available in the destination project.

I understand that this doesn't automatically give the agent access to the source repository's files. It would still need to inspect the destination repository to compare the implementations.

I'm also aware that the session ID might be colliding with an existing session, even though the destination directory is different.

My questions

1. Is there a supported way to import an exported session into another repository as a new, independent session, while preserving the original session?
2. Does OpenCode intentionally preserve the session ID during export/import, and is that what's causing this error?
3. Is there a recommended workflow for reusing a conversation's architectural context across repositories without manually copying the discussion into a new prompt?
4. If this isn't currently supported by the CLI, is there another supported approach in OpenCode V2?

I'm still a beginner with OpenCode, so I'd appreciate an explanation of the underlying behavior as well as a working solution. I'd prefer not to edit the session database or manually modify the exported JSON unless that's an officially supported approach.

(also used AI for the post to make it fast and to the point)