A coding agent is not autocomplete with a chat window. It takes a task in plain language, reads the files in your repository, edits the code, runs the tests and comes back with a result, repeating the loop until something passes. This guide builds that workflow from scratch with Verboo Code: installation, project context, model choice, permissions, MCP and hooks. Every command below was checked against the source of the verbeux-ai/code repository, version 0.15.41, on 2026-11-06.
What is a coding agent?
It is a command line tool that runs the task inside your repository instead of only suggesting snippets. The practical difference is the loop: the agent tries, reads the error, fixes it and tries again, without you copying and pasting file by file.
Verboo Code is the Verboo platform CLI for that job. The package is @verboo/code, the binary is verboo, and it connects only to Verboo infrastructure, with no external provider API key. The toolset is the one of a terminal agent: Bash, file read and edit, grep, glob, subagents, background tasks, MCP and slash commands.
What changes when tokens stop being the limit?
The decision to try again changes. With a token quota, every extra pass costs money and becomes a conscious choice: is it worth re-reading the whole repository? Is it worth asking the model for a second opinion? With no quota, the marginal cost of failing and repeating is time, not money.
| Situation | With a token quota | With no quota |
|---|---|---|
| A test failed in a strange way | you decide whether to spend quota investigating | the agent re-reads the log and tries another hypothesis |
| Incomplete context | it trims files to fit the limit | it reads the whole directory before proposing |
| A large task | it splits only when there is no choice | it parallelizes across subagents |
That does not mean infinite speed. On the paid plans, the product page showed 40 requests per minute and 2 concurrent requests on 2026-11-06, with Enterprise as the only offer without a rate limit. What those plans do not have is a token quota.
How do you install Verboo Code?
The CLI requires Node 22 or newer, as declared in the engines field of package.json, and installs from npm:
npm install -g @verboo/codeOn the first run it opens the browser at code.verboo.ai for OAuth login and stores the session in the system vault: Keychain on macOS, DPAPI on Windows and libsecret on Linux. To sign in again later, use /login inside the session. On a server with no browser, verboo auth login --headless prints a URL to open on another device and asks for the confirmation code.
cd ~/projects/my-app
verboo
Gotcha: if the CLI reports ripgrep not found, install ripgrep system-wide and confirm rg --version works in the same terminal before starting the session. The agent's grep depends on it.
How do you give the agent project context with /init?
The agent starts out not knowing that the test command is make test or that the package manager is pnpm. /init fixes that: it reads the README, manifests, CI configuration and rules inherited from Cursor or Copilot, then writes the project instruction file, which is loaded into every session from then on.
/initIn the current mode, the command asks what to create: the project AGENTS.md, a personal CLAUDE.local.md, or both, and whether it should also set up skills and hooks. The project file goes into git; the personal one stays out of version control.
One rule catches many people: in the same folder, Verboo Code loads AGENTS.md and only uses CLAUDE.md when AGENTS.md does not exist. The two do not add up.
# AGENTS.md
## Commands
- install: pnpm install
- tests: make test
- single test: pnpm vitest run src/api/users.test.ts
## Architecture
- src/api exposes HTTP; src/jobs runs the queues; both read src/core
## Gotchas
- the build requires NODE_OPTIONS=--max-old-space-size=4096The file is an instruction, not a lock. A rule that must be enforced belongs in permissions, not in prose. The /init walkthrough shows what to review and what to cut.
How do you choose the model with /model?
/model opens the list of models available on your account and switches mid-session without losing the history. The right question is not which one is best, it is how long you are willing to wait for each answer.
For subagents, the choice lives in ~/.verboo/settings.json, under agentRouting. Each worker points to a profile:
{
"agentRouting": {
"Explore": "fast",
"worker-review": { "profile": "review" },
"worker-backend": { "profile": "coding" },
"worker-tests": { "profile": "testing" },
"default": { "profile": "balanced" }
}
}The profiles are fast, review, coding, testing and balanced. Each one has a model preference order, and the worker takes the first one that exists on the logged-in account. If none exists, it inherits the main agent model; to use the first model in the catalog instead of inheriting, add "fallback": "first-available" to the profile block.
| Profile | What it is for in practice |
|---|---|
fast | file search, summaries and exploration, where latency matters more than depth |
review | diff review and a second opinion on a change |
coding | the main implementation, when the worker is going to edit code |
testing | writing and running tests for what just changed |
balanced | the default for people who do not want to think about it on every task |
How do you run a task end to end?
With the project set up and the model chosen, the first task should be small enough for you to judge the result. One example request:
Read src/api/users.ts and src/api/users.test.ts.
Add a test for the duplicate email case in signup.
Run only that test file and show me the output.
Do not change the implementation if the test passes.Notice the three parts: what to read, what to change and how to prove it. A request without the third part is blind trust; with it, the agent closes the loop on its own and you review a diff instead of hunting for the error in the dark.
If the task is bigger, ask for the plan first: "list the files you are going to touch and what changes in each, without editing anything yet". You read the plan, correct the course and only then tell it to execute.
How do you control what the agent can run?
Permissions are what separate "the agent can run a test" from "the agent can push". They live in ~/.verboo/settings.json, or in the project's .verboo/settings.json, with three lists: allow, ask and deny.
{
"permissions": {
"allow": ["Bash(npm run *)", "Bash(git status)", "Read(*.ts)"],
"ask": ["Bash(git commit *)"],
"deny": ["Bash(git push *)", "Read(./.env)"]
}
}The rule syntax is Tool(pattern), and the pattern accepts wildcards anywhere. For MCP servers the format is mcp__server__tool, and mcp__server alone allows every tool on that server. The full table is in /permissions.
How do you connect external tools with MCP?
MCP is the protocol that plugs an outside tool into the session. The CLI adds a server without you editing JSON by hand:
verboo mcp add --transport http sentry https://mcp.sentry.dev/mcp
verboo mcp add -e API_KEY=xxx my-server -- npx my-mcp-serverThe default scope is local. Use -s project to version the configuration with the team or -s user to apply it to all your projects. Inside the session, /mcp lists the connected servers, shows each one's tools and lets you enable, disable and reconnect.
How do you automate with hooks?
A hook is a shell command that runs on a session event, without the model deciding whether it runs. It lives under the hooks key of the same settings.json, and the most common case is formatting after every edit:
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{ "type": "command", "command": "npx prettier --write . >/dev/null 2>&1 || true" }
]
}
]
}
}Available events include PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, Stop and PreCompact. A hook that exits with code 2 blocks the action and returns the error to the model, which is useful to prevent writes to a protected file, not only to format.
How do you keep a long session on track?
Long sessions consume context, and full context degrades decisions. Three commands cover most cases:
| Command | When to use it |
|---|---|
/context | see how much context is used and which part of the work is taking it |
/compact | summarize while preserving what matters, for example /compact keep the test error and the files touched |
/clear | start from zero when the next task does not depend on the previous one |
For long-running work, /tasks tracks what runs in the background and /resume picks up a closed session. /compact has the step by step with an example instruction.
How much does it cost to keep a coding agent running?
It depends on the format you pick. What changes across the offers is not the token quota on paid plans, it is speed and concurrency:
| Offer | Tokens | What actually limits you |
|---|---|---|
| Entry plan | weekly quota | the quota: once spent, requests wait for renewal |
| Paid plans | no quota | requests per minute and concurrent requests |
| Enterprise | no quota | dedicated cluster, no rate limit |
| Pay-as-you-go API | prepaid per token | what you consume |
On 2026-11-06 the product page showed 40 requests per minute and 2 concurrent requests on paid plans. Check the current table before subscribing: plan composition, price and speed limits change without notice.
The math that decides the purchase is different. The real cost of an agent is the time it gives back, and what makes your day expensive is not the token, it is the repetitive task still in your hands.
What do you do when the agent fails on the first try?
Failing is part of the loop, and this is where the absence of a quota changes the habit. Before rewriting the request by hand, check three things:
- Does the project instruction file contain the command it tried to guess? If not, add it.
- Is the real error in the conversation? Paste the terminal output, not a summary of it.
- Is the session carrying stale context? A
/compactwith an instruction, or a/clear, fixes more than a new request on top of the old one.
With a quota, the temptation is to keep pushing on the prompt to avoid spending tokens. With no quota, the right move is to give more context and let the agent try again.
If the bottleneck in your day is deciding whether a retry is worth it, the cost of the fifth attempt is what changes. With Verboo Code, paid plans have no token quota: the limit is speed and concurrency, so repeating costs time, not money.
