Your agents stop starting from scratch: the Hilbana plugin for Claude Code

The Hilbana plugin for Claude Code is now published in a public repository. It’s two lines:

/plugin marketplace add hilbana/claude-plugin
/plugin install hilbana@hilbana

Restart, paste your API key, and from then on your agents have project memory, pull from a work queue, and their token spend is billed to the specific task they were working on.

Connecting the MCP was never the hard part

You could already wire Claude Code to Hilbana with an API key and one command. What that doesn’t fix are the three things that break once you actually work this way every day.

Every new session starts blank. You close Claude Code and everything goes with it: why that grid needs a min(), what the root cause of last week’s bug was, that in this repo template comments go inside braces. Tomorrow you explain it again. And the day after.

Nobody knows what a task cost. You see the monthly bill and you can’t see where the money went. The useful question isn’t “how much did I spend”, it’s “how much did it cost to close this issue”, and nothing was answering that one.

Two agents collide. Launch several in parallel with nothing handing out the work and two of them end up on the same task.

What it installs

Per-project memory. A hook on opening the repository reminds the agent to load what’s already known, and one on closing saves a summary of the session. The scope is the folder’s name, so it works in any repository, not just those tracked as projects in Hilbana. It replaces engram, and the plugin ships a command to migrate whatever you already had.

Per-task token accounting. The plugin reads the transcript, computes real spend and sends it on its own. The server decides which issue to bill by looking at which one the agent has claimed at that moment.

There’s a design decision here worth spelling out, because it’s counterintuitive: the hook measures it, not the agent. We could have asked the model to report its own consumption when it finished. We don’t, because a model doesn’t know what it consumes, and if you ask, it answers with a plausible number it made up. An invented figure is worse than none: it looks like a metric.

A detail in the same spirit: the calculation deduplicates by message id. The same message shows up on several transcript lines, and summing per line inflates the figure by roughly 80%.

The cycle commands. They’re the human + agent working framework turned into commands:

• /hilbana-plan compiles a goal into a graph of sub-issues and queues the ones that are ready.
• /hilbana-claim-next pulls the next ready issue and starts it. The queue is atomic, so two agents asking at once never get the same one.
• /hilbana-finish verifies the definition of done, comments, records the run and releases the lock.
• /hilbana-review closes it or sends it back.

The rule holding this together: a worker never closes its own work. It stops at In Review. That isn’t bureaucracy. An agent that approves itself provides no guarantee at all; it’s just moving a card.

When to use the plugin and when not to

There are three ways to connect Hilbana with Claude, and they don’t compete:

• The plugin, if you work in Claude Code inside your repository. It’s the only route that brings memory, commands and spend measurement.
• The connector, if you want to read and operate things yourself from claude.ai, web or desktop, with no keys to manage.
• An API key, if you’re wiring up your own agents or a CI environment.

Where to start

The full guide, with requirements, configuration, verification and the usual failure modes, is in Claude Code plugin.

The essentials: you need Claude Code, Node 18 or later on your PATH (the hooks run under node) and an API key from the workspace you work in, created under Settings → API keys. If you don’t have a workspace yet, create one free: the Free plan never expires and asks for no card.

The plugin’s code is public and MIT licensed, at github.com/hilbana/claude-plugin. If something doesn’t fit how you work, open an issue there: the commands are text files, and text files can be argued with.