I Compared 8 AI Agent Platforms. Here's What Running a Team Actually Costs

AI-generated image

Eight Platforms, Ten Tasks, Ten Agent Teams, What Each One Costs, and How to Remove that Cost using Local LLMs

Table of Contents

I. Introduction to Agent Orchestration and the Power of Local LLMs

Why orchestration skills are in demand, what agents cost, and how local LLMs remove that cost.

II. How To Stay Under Budget

Seven rules and one hook that keep your token bills small.

III. Claude Code

A five-agent full-stack feature build with Anthropic's terminal agent.

IV. OpenAI Codex

A parallel test-coverage sweep using codex exec and git worktrees.

V. xAI Grok

Three competing landing-page prototypes, judged by a critic agent.

VI. Google Gemini

Mapping a legacy monorepo with Antigravity CLI's background agents.

VII. Microsoft Copilot

A 12-package dependency upgrade with /fleet and /delegate.

VIII. OpenCode

Complete API documentation from cheap readers and one premium writer.

IX. Pi Code

Four-language localisation with a scripted team of Pi workers.

X. DeepSeek

An overnight 200-file type-hint migration at off-peak prices.

XI. Master Agent Workflow (From Anthropic)

The orchestrator-worker pattern, its results, and a universal lead prompt.

XII. When To Use Multiple Agents

The patterns where an agent team earns its token bill.

XIII. When Not To Use Multiple Agents

The cases where a single agent beats a team.

XIV. Top Five Best Agent Harnesses

My ranking of the harnesses for daily multi-agent work.

XV. Skills Required For Agentic Orchestration

Ten skills that turn an agent user into a conductor.

XVI. Why Local LLMs Are A Game-Changer For Low Budgets

Why 64 GB is the minimum, plus a fully local four-agent team.

XVII. Best Local LLMs For Agentic Coding with 64 GB Unified Memory

The 64 GB shortlist and a two-model local security-audit team.

XVIII. Summary

Every task, team and bill on one screen, plus the method in five points.

XIX. Free Course for AI Agent Orchestration

10 courses from Google, Microsoft, Kaggle, UC Berkeley and others that are completely free

References

The 51 sources behind the claims in this article.

---

I. Introduction to Agent Orchestration and the Power of Local LLMs

There has been a statistic doing the rounds.

Job listings for AI orchestrators rose 1,294% in a single year, from February 2025 to February 2026, according to Lightcast data reported by IT Brew.

I am here to give you a loophole that removes that cost entirely -

Local LLMs that fit in 64 GB of dedicated VRAM or even Unified Memory can perform orchestration for you!

That removes the cost problem - by effectively taking AI inference costs to zero.

Again - not so much.

You can pick up AI Agent Orchestration in a month with dedicated practice.

Don't believe me?

Keep reading!

Also; to cover an important caveat:

That is how you get over the cost problem.

Local LLMs like Gemma 4 or Qwen 3.8 are the best option for 20 USD AI subscribers.

But we digress.

Anthropic measured the cost of agents carefully in its write-up on how it built its multi-agent research system, and the numbers are sobering.

• A single agent uses roughly four times the tokens of an ordinary chat conversation.
• A multi-agent system uses roughly fifteen times the tokens of an ordinary chat conversation.
• Token usage alone explained about 80% of the performance difference in Anthropic’s browsing evaluation.

More agents means more tokens, and more tokens means more money.

So the honest starting point of AI agent orchestration is not spinning up ten agents at once—it is setting a budget and deciding what each agent is worth to you.

However, with local LLMs, that problem disappears.

Read to the end to find out everything!

What Orchestration Actually Means

Orchestration is simple to describe, even though it takes practice to do well. In every setup in this article, the roles break down the same way.

1. One lead agent sets the goal, writes the plan, and enforces the constraints and the budget.

2. Several worker agents do focused jobs in parallel, each inside its own separate context window.

3. One verifier—another agent or a human—checks the combined result before anything is merged.

The developers who learn to conduct agents, rather than simply chat with them, are quietly becoming 10X engineers.

They are not typing any faster than before.

They are delegating far better than before.

The Crux - TL;DR in Short

How do you create a new agent in Claude?

You ask!

Or:

As easy as that, you are orchestrating multiple agents!

The Entry Tickets In October 2026

These are list prices taken from official pricing pages and recent reporting. Regional pricing, including pricing in India, can differ from the figures below.

Provider	Entry Plan	Heavy-Use Plan	Pay-As-You-Go
Anthropic (Claude Code)	Pro, $20/month	Max, from $100/month	Sonnet 5.5: $2 / $10 per M tokens
OpenAI (Codex)	Go $8, Plus $20	Pro: $100, $200, $500	Credits and API keys
xAI (Grok Build)	SuperGrok or X Premium+	Higher SuperGrok tiers	xAI API
Google (Antigravity CLI)	Free tier with AI credits	Enterprise via Google Cloud	Paid API keys
Microsoft (GitHub Copilot)	Pro $10 ($15 in credits)	Pro+ $39, Max $100	$0.01 per extra credit
OpenCode	Free client, some free models	—	Zen per token, or your own key
Pi	Free client	—	Your own key
DeepSeek	No subscription	—	V4-Pro: $0.66 / $1.98 per M (off-peak)

How To Read The Bills In This Article

Every provider section ends with an estimated bill for its task, and you should read those bills with three caveats in mind.

• Each bill uses list API prices and token counts that I assumed for a mid-sized repository, not measured usage.
• Prompt caching usually reduces the real figure, sometimes quite sharply, because repeated context is billed at a discount.
• On a subscription such as Pro, Max, Plus, or SuperGrok, the same work draws down your plan allowance instead of charging your card.

---

II. How To Stay Under Budget

This is important for efficiency even while using Local LLMs.

And companies pay 500,000 USD for employees who automate entire teams with Claude!

The single most important idea in this entire article is that context is the meter.

Every turn re-sends the conversation, every tool call adds its output to the pile, and every new agent starts a pile of its own.

Anthropic's guide to managing Claude Code costs puts real numbers on this, and they are worth memorising.

Keep that in mind when you are sponsoring your own agent bills.

Seven Rules That Keep You Under Budget

1. Route work by difficulty, not by habit. Use frontier models for architecture and hard debugging, mid-tier models for implementation, and small models for search, log reading, and running tests.

2. Clear the context between unrelated tasks. Running /clear in Claude Code costs nothing, whereas /compact is itself a large request because the model must read everything it summarises.

3. Keep your instruction files lean. Anthropic recommends keeping CLAUDE.md under 200 lines and moving specialist workflows into skills, which load only when they are needed.

4. Push noisy work into subagents or hooks. A subagent can read 10,000 lines of test output and return a three-line summary, and a hook can filter that output before any model sees it at all.

5. Prefer command-line tools over unused MCP servers. Tools such as gh, gcloud, and aws cost almost nothing in context, while every idle MCP server adds a small cost to every request.

6. Run locally before you run in the cloud. OpenAI states plainly that Codex cloud tasks consume more of your allowance than equivalent local work.

7. Put a hard cap on spending. Claude Code supports a --max-budget-usd flag for scripted runs, Copilot lets you keep overages switched off, and DeepSeek charges half price during off-peak hours.

The Cheapest Hook You Will Ever Write

The hook below filters test output so that only failures reach the model. It is adapted from Anthropic's own documentation, and on a large test suite it can save thousands of tokens on every single run.

json

{ "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "~/.claude/hooks/filter-test-output.sh" } ] } ] } } 

bash

#!/bin/bash # filter-test-output.sh — runs BEFORE every Bash call Claude Code makes. # If the command is a test runner, rewrite it so only failures come back. input=$(cat) # hook payload arrives as JSON on stdin cmd=$(echo "$input" | jq -r '.tool_input.command') # the shell command Claude wants to run if [[ "$cmd" =~ ^(npm test|pytest|go test|cargo test) ]]; then # Keep only FAIL/ERROR lines plus 5 lines of context, capped at 100 lines filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100" # Allow the call, but with the filtered command echo "$input" | jq --arg filtered "$filtered_cmd" \ '{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: (.tool_input + {command: $filtered})}}' else echo "{}" # any other command passes through untouched fi 

---

III. Claude Code

In Brief

• Claude Code is Anthropic's agentic coding tool, and it runs in the terminal, in VS Code and JetBrains, in a desktop app, and on the web.
• Every surface shares the same engine, the same CLAUDE.md files, and the same MCP servers, so your setup travels with you.
• It offers the deepest orchestration toolkit available today, including subagents, agent teams, hooks, skills, plugins, and dynamic workflows.
• It is included with Pro at $20 a month and with Max from $100 to $200 a month, according to Claude's official pricing page.

The Perfect Task: Build A Full-Stack Feature End To End

Claude Code is the best tool for tightly managed feature work, because each subagent gets its own model, its own tools, and its own context window.

That lets one lead keep the design coherent while specialists do the heavy lifting in parallel.

The task here is to add an "export invoices as CSV" feature to a web application, covering the API, the user interface, the tests, and a final review.

The Agent Team

Agent	Model	Job
Lead (your session)	Opus 5.5	Plans, assigns, and integrates
backend-dev	Sonnet 5.5	Builds the API endpoint
frontend-dev	Sonnet 5.5	Builds the export button and flow
test-runner	Haiku 5.5	Runs tests and reports only failures
reviewer	Sonnet 5.5	Reviews the final diff in read-only mode

Step-By-Step

Step 1. Install Claude Code with the native installer, which keeps itself up to date in the background.

bash

# macOS, Linux, or WSL — the native installer auto-updates curl -fsSL https://claude.ai/install.sh | bash claude --version # a version number means the install worked 

Step 2. Create the folder where project-level subagents live, from the root of your repository.

bash

cd your-project mkdir -p .claude/agents # every .md file in here becomes a subagent 

Step 3. Create the first agent, backend-dev, which may only touch server-side files.

bash

cat > .claude/agents/backend-dev.md <<'EOF' --- name: backend-dev description: Implements backend API changes only. Use for server-side tasks. model: sonnet # mid-tier model for implementation work tools: Read, Edit, Write, Bash --- You implement API endpoints. Touch only files under src/api/ and src/services/. Return a short summary of the files you changed and why. EOF 

Step 4. Create the second agent, frontend-dev, which may only touch client-side files.

bash

cat > .claude/agents/frontend-dev.md <<'EOF' --- name: frontend-dev description: Implements UI changes only. Use for client-side tasks. model: sonnet tools: Read, Edit, Write, Bash --- You build UI components. Touch only files under src/web/. Return a short summary of the files you changed and why. EOF 

Step 5. Create the third agent, test-runner, on the smallest model, because reading logs needs no deep reasoning.

bash

cat > .claude/agents/test-runner.md <<'EOF' --- name: test-runner description: Runs the test suite and reports ONLY failures. Use after any change. model: haiku # small, fast and cheap — ideal for reading logs tools: Bash, Read # can run and read, but never edit --- Run the tests. Return the test name, file:line, and a one-line probable cause. Never paste full logs. EOF 

Step 6. Create the fourth agent, reviewer, which can read and run git diff but cannot edit anything.

bash

cat > .claude/agents/reviewer.md <<'EOF' --- name: reviewer description: Reviews diffs for bugs, security issues and missing tests. Read-only. model: sonnet tools: Read, Bash # Bash is only for git diff; there are no editing tools --- Review the current branch against main. Return a numbered list of issues, most severe first. EOF 

Step 7. Start the lead session on Opus, so the strongest model does the planning while cheaper models do the work.

bash

claude --model opus 

Step 8. Press Shift+Tab to enter plan mode, ask for a plan for the CSV export feature, and approve the plan before any code is written.

Step 9. Launch the workers in parallel with a single instruction to the lead.

text

Use backend-dev and frontend-dev in parallel to implement the approved plan. When both finish, use test-runner. Fix any failures yourself. Finally, use reviewer and address every issue it raises. 

Step 10. Run /usage when the work is done, because it attributes your spend to each subagent and shows you where the tokens went.

Estimated Bill

Agent	Tokens In / Out	Cost At List Price
Lead (Opus 5.5, $4 / $20)	300K / 30K	$1.80
backend-dev (Sonnet 5.5, $2 / $10)	400K / 40K	$1.20
frontend-dev (Sonnet 5.5)	400K / 40K	$1.20
test-runner (Haiku 5.5, $1 / $5)	300K / 10K	$0.35
reviewer (Sonnet 5.5)	200K / 15K	$0.55
Total		≈ $5.10

On a Pro or Max plan, this work comes out of your plan allowance rather than your card.

On the API, prompt caching usually brings the real figure well below five dollars.

---

IV. OpenAI Codex

In Brief

• Codex is OpenAI's coding agent, and it is bundled into ChatGPT plans rather than sold as a separate product.
• It runs as a command-line tool, an IDE extension, a web app, and a cloud sandbox that returns results to your repository.
• The codex exec command runs Codex non-interactively, which makes it ideal for scripts and continuous integration.
• The default model is GPT-6.1 Sol at medium reasoning, according to OpenAI's Codex CLI documentation.
• Codex paired with GPT-5.5 holds the top Terminal-Bench 2.0 entry, a score of 82 in April 2026, on the Codesota Terminal-Bench 2.0 leaderboard.

The Perfect Task: A Parallel Test-Coverage Sweep

Codex is the best tool for headless, scriptable fan-out, because codex exec turns each agent into a single shell command.

When you combine it with git worktree, every agent gets its own isolated copy of the repository and the agents can never overwrite each other.

The task here is to write missing unit tests for four packages at the same time, and then to review all four sets of tests.

The Agent Team

Agent	Where It Runs	Job
tests-auth	Worktree 1	Tests for packages/auth
tests-billing	Worktree 2	Tests for packages/billing
tests-search	Worktree 3	Tests for packages/search
tests-notify	Worktree 4	Tests for packages/notify
reviewer	Main repository	Audits all four branches

Step-By-Step

Step 1. Install Codex and sign in with your ChatGPT account on the first run.

bash

curl -fsSL https://chatgpt.com/codex/install.sh | sh codex # the first run walks you through ChatGPT sign-in 

Step 2. Put your shared conventions in AGENTS.md, which Codex reads automatically and which Claude Code can also read, so your rules travel between vendors.

Step 3. Use /permissions, or your Codex configuration, to allow codex exec to edit files and run tests for this task, and keep the settings conservative everywhere else.

Step 4. Create four isolated worktrees, one for each agent, so that every agent works on its own branch and folder.

bash

# One branch and one folder per package, so the agents never collide for pkg in auth billing search notify; do git worktree add ../wt-$pkg -b tests/$pkg done 

Step 5. Launch the four test-writing agents in parallel, each inside its own worktree.

bash

# Each subshell is one Codex agent working inside its own worktree for pkg in auth billing search notify; do ( cd ../wt-$pkg && \ codex exec "Write missing unit tests for packages/$pkg. Run them until they pass. \ Do not modify any other package. Commit when done." \ > ../log-$pkg.md 2>&1 ) & # run in the background and save each agent's report done wait # block until all four agents have finished 

Step 6. Launch the fifth agent, the reviewer, once all four branches exist.

bash

codex exec "Review branches tests/auth, tests/billing, tests/search and tests/notify \ against main. Flag weak assertions, flaky tests and missing edge cases. \ Output a numbered list per branch." > review.md 

Step 7. Fix whatever the reviewer flags, merge each branch, and remove the worktrees with git worktree remove ../wt-<package>.

Estimated Bill

This estimate assumes API-equivalent pricing of $1.75 per million input tokens and $14 per million output tokens, which is the GPT-5.3-Codex rate reported in Jetadmin's Codex pricing breakdown.

Agent	Tokens In / Out	Cost
4 test-writing agents	500K / 40K each	$5.74
reviewer	300K / 20K	$0.81
Total		≈ $6.55

On a Plus plan at $20 a month, a run of this size typically fits inside your rolling five-hour usage window.

---

V. xAI Grok

In Brief

• Grok Build is xAI's terminal coding agent, and its CLI entered early beta on May 25, 2026, for SuperGrok and X Premium Plus subscribers.
• xAI open-sourced the harness on July 15, 2026, according to the official xAI news timeline.
• It offers plan mode, subagents, a headless mode for scripting, and a fast dedicated coding model called Grok Build 0.1.
• An independent research note on Grok Build's July 2026 upload incident reports that it uploaded repository bundles against users' wishes until a server-side fix stopped it, so keep it on open or throwaway code for now.

The Perfect Task: Rapid Prototyping With Competing Variants

Grok Build is ideal when speed matters more than secrecy.

Prototypes are disposable, they are often public anyway, and they benefit enormously from a fast model.

So the best use is to let several agents race each other and let a critic agent pick the winner.

The task here is to build three competing landing-page prototypes for a new open-source tool and then judge them.

The Agent Team

Agent	Job
Lead (your session)	Writes the brief, then spawns and judges the agents
proto-minimal	Builds a minimal, typography-led design
proto-bold	Builds a bold, illustration-heavy design
proto-docs	Builds a documentation-first, developer-focused design
critic	Scores all three designs against the brief

Step-By-Step

Step 1. Install Grok Build with the official installer script.

bash

curl -fsSL https://x.ai/cli/install.sh | bash # macOS / Linux / WSL # Windows PowerShell: irm https://x.ai/cli/install.ps1 | iex 

Step 2. Start Grok in a fresh, non-confidential repository, and complete the browser sign-in on the first launch.

bash

mkdir landing-race && cd landing-race && git init grok # the first launch opens browser sign-in 

Step 3. Ask Grok, in plan mode, to plan the shared brief covering the audience, the page sections, and the constraints, and approve that plan before anything runs.

Step 4. Spawn the three prototype agents in parallel, each in its own git worktree.

text

Spawn three subagents in parallel, each in its own git worktree: 1. proto-minimal: a minimal, typography-led landing page. 2. proto-bold: a bold, illustration-heavy landing page. 3. proto-docs: a docs-first page with a live code sample. Each must follow the approved brief and build as static HTML/CSS. 

Step 5. Spawn the fourth agent, the critic, with strict instructions not to edit anything.

text

Spawn a fourth subagent, critic. It must not edit anything. Score each prototype from 1 to 10 on clarity, speed and fit to the brief, then recommend one. 

Step 6. Script future runs in headless mode, which returns machine-readable output that you can pipe into other tools.

bash

# A headless one-shot with streaming JSON output, handy for nightly variant runs grok -p "Re-run the critic on all three worktrees" --output-format streaming-json 

Estimated Bill

This estimate assumes $2 per million input tokens and $6 per million output tokens, the Grok 4.6 API price listed in the independent research note above. My confidence in this figure is low, because xAI's pricing has changed several times this year.

Agent	Tokens In / Out	Cost
Lead	100K / 10K	$0.26
3 prototype agents	200K / 30K each	$1.74
critic	150K / 10K	$0.36
Total		≈ $2.36

On a SuperGrok subscription, CLI usage is covered by the plan rather than billed per token.

---

VI. Google Gemini

In Brief

• Gemini CLI stopped serving free users, Google AI Pro subscribers, and Google AI Ultra subscribers on June 18, 2026.
• Its replacement is Antigravity CLI, a new binary called agy that Google rebuilt in Go and that shares its agent harness with the Antigravity 2.0 desktop app.
• Antigravity is designed for asynchronous, multi-agent work, so agents can run in the background while you keep using the terminal.
• These details come from Google's official post on moving Gemini CLI to Antigravity CLI.

The Perfect Task: Map A Legacy Monorepo

Gemini models are built for very long context windows, and Antigravity adds background agents that keep working while you do something else.

That combination is perfect for reading a huge, unfamiliar codebase without blocking your day. The task here is to produce an architecture brief for a legacy monorepo with four subsystems.

The Agent Team

Agent	Job
Lead (your session)	Splits the repository and merges the reports
map-api	Maps the API gateway and its routes
map-data	Maps the database layer and its migrations
map-jobs	Maps background jobs and queues
map-web	Maps the front end and every API call it makes

Step-By-Step

Step 1. Install Antigravity CLI as a fresh binary, because it is a new tool rather than an upgrade of Gemini CLI.

bash

curl -fsSL https://antigravity.google/cli/install.sh | bash # installs `agy` to ~/.local/bin # Windows PowerShell: irm https://antigravity.google/cli/install.ps1 | iex 

Step 2. Find every remaining call to the old gemini command in your scripts and CI configuration, because those calls stopped working on June 18 if they used consumer credentials.

bash

# Search scripts and CI configs for lingering references to the retired CLI grep -rn --include="*.yml" --include="*.yaml" --include="*.sh" "gemini " . 

Step 3. Launch agy from the root of the repository and confirm workspace trust during the first-run setup.

Step 4. Spawn the four mapping agents as read-only background agents.

text

Spawn four background agents, each read-only: 1. map-api: map the gateway, routes and auth flow under services/api/. 2. map-data: map schemas, migrations and data access under services/db/. 3. map-jobs: map queues, workers and schedules under services/jobs/. 4. map-web: map the front end and every API call it makes under apps/web/. Each writes its findings to docs/arch/<agent-name>.md, max 80 lines. 

Step 5. Keep working in the foreground while the agents run, and use /agents to watch and manage them.

Step 6. Ask the lead to merge the four reports into a single architecture document.

text

Read docs/arch/*.md and write docs/ARCHITECTURE.md: a one-page overview, a dependency list between subsystems, and the top five risks. 

Estimated Bill

This estimate assumes a Gemini Pro-class rate of $2 per million input tokens and $12 per million output tokens.

Agent	Tokens In / Out	Cost
Lead	200K / 20K	$0.64
4 mapping agents	800K / 20K each	$7.36
Total		≈ $8.00

Reading is the expensive part of this task, which is exactly why it belongs on a long-context model with a free tier.

---

VII. Microsoft Copilot

In Brief

• For coding agents, the Microsoft product that matters is GitHub Copilot, while Microsoft 365 Copilot is a separate product for documents and email.
• The Copilot CLI includes /fleet, which runs parallel subagents, and /delegate, which hands a task to the cloud coding agent.
• The plans are Free, Pro at $10, Pro+ at $39, and Max at $100, with extra usage at $0.01 per credit, according to GitHub's Copilot plans page.

The Perfect Task: A Dependency Upgrade Across Many Packages

Copilot is the best tool for work that lives right next to your pull requests.

The /fleet command splits a repetitive job into parallel subagents, and /delegate sends the stubborn leftovers to a cloud agent that opens pull requests for you.

The task here is to upgrade a logging library across 12 packages and then hand off the difficult cases.

The Agent Team

Agent	Job
Main agent (your session)	Plans the upgrade and coordinates the work
12 /fleet subagents	One per package: upgrade, fix, and test
2 /delegate cloud agents	Finish the packages that failed and open pull requests

Step-By-Step

Step 1. Install the Copilot CLI, which requires Node.js 22 or later when installed through npm.

bash

npm install -g @github/copilot # or: brew install --cask copilot-cli | winget install GitHub.Copilot 

Step 2. Run copilot, then sign in once with /login, and note that organisation members need an administrator to enable the Copilot CLI policy first.

Step 3. Use /model to choose a mid-tier model, because mechanical edits do not need a frontier model.

Step 4. Create the 12 subagents with a single /fleet instruction.

text

/fleet Upgrade our logging library from v3 to v4 in every package under packages/. Use one subagent per package. Each subagent updates imports, fixes breaking changes, runs that package's tests, and reports PASS or FAIL with one line of detail. 

Step 5. Review the fleet report, merge every package that reported PASS, and list the packages that reported FAIL.

Step 6. Create one cloud agent per failed package with /delegate, and repeat the command for the second failed package.

text

/delegate Finish the logging v4 upgrade in packages/payments. Tests are failing on structured-field serialisation. Open a pull request when tests pass. 

Step 7. Script the next upgrade check in non-interactive mode, which prints quiet output suitable for CI.

bash

copilot -p "List every package still importing logging v3" -s 

Estimated Bill

This estimate assumes that AI credits track the underlying model cost at $0.01 per credit, using a mid-tier model priced at $2 per million input tokens and $10 per million output tokens.

Agent	Tokens In / Out	Cost
Main agent	200K / 20K	$0.60
12 fleet subagents	150K / 10K each	$4.80
2 cloud agents	Rough allowance	$1.00
Total		≈ $6.40 (about 640 credits)

Copilot Pro's $15 of monthly credits covers roughly two runs of this size.

---

VIII. OpenCode

In Brief

• OpenCode is an open-source, provider-agnostic terminal agent that works with almost any model provider.
• It has two primary agents, Build with full access and Plan with editing disabled by default, and you switch between them with the Tab key.
• It ships with three subagents—General, Explore, and Scout—which you call with @name.
• Every agent can run on a different model, according to OpenCode's agents documentation, and the client itself is free.

The Perfect Task: Write API Documentation For A Whole Repository

OpenCode is the best tool for mixing cheap and premium models inside one team.

Documentation needs a great deal of reading and only a little excellent writing, so cheap models should do the reading and one premium model should do the writing.

The task here is to produce reference documentation for every public module and then fact-check it against the code.

The Agent Team

Agent	Model	Job
Build (primary)	Sonnet 5.5	Writes the final documentation
doc-scout × 5	deepseek-flash	Extracts signatures and behaviour, read-only
doc-checker	deepseek-flash	Verifies every documented claim against the code

Step-By-Step

Step 1. Install OpenCode with the official installer script.

bash

curl -fsSL https://opencode.ai/install | bash 

Step 2. Run opencode, then use /connect to add two providers: Anthropic for the writer and DeepSeek for the readers.

Step 3. Run /init so that OpenCode analyses the project and generates an AGENTS.md file.

Step 4. Create the first agent, doc-scout, as a read-only subagent on a very cheap model.

bash

mkdir -p ~/.config/opencode/agents cat > ~/.config/opencode/agents/doc-scout.md <<'EOF' --- description: Read-only extractor. Lists public functions, parameters, return values and side effects for ONE module. mode: subagent # callable by the primary agent via @doc-scout model: deepseek/deepseek-flash # a very low-cost model for high-volume reading permission: edit: deny # cannot change files bash: deny # cannot run commands --- For the module you are given, return a compact list of public APIs with one-line behaviour notes. EOF 

Step 5. Create the second agent, doc-checker, which compares the finished documentation against the source code.

bash

cat > ~/.config/opencode/agents/doc-checker.md <<'EOF' --- description: Fact-checks documentation against source code. Read-only. mode: subagent model: deepseek/deepseek-flash permission: edit: deny bash: deny --- Compare each documented claim with the code. Return only the claims that are wrong, with file:line. EOF 

Step 6. Use /models to select Sonnet 5.5 as the model for the Build agent, which will do the actual writing.

Step 7. Run the whole team with one instruction to the Build agent.

text

Call @doc-scout five times in parallel, once each for src/core, src/api, src/db, src/auth and src/utils. Using their output, write docs/reference/<module>.md files. Then call @doc-checker on every new file and fix each error it reports. 

Step 8. Use /undo and /redo freely if the output misses the mark, because they make experimentation cheap.

Estimated Bill

Agent	Tokens In / Out	Cost
5 doc-scouts (flash, peak $0.30 / $1.20)	400K / 30K each	$0.78
Writer (Sonnet 5.5, $2 / $10)	300K / 40K	$1.00
doc-checker (flash)	200K / 10K	$0.07
Total		≈ $1.85

That is the real power of per-agent models: seven agents for less than the price of a cup of filter coffee at Cafe Coffee Day in India.

---

IX. Pi Code

In Brief

• Pi is a deliberately minimal coding agent created by Mario Zechner, the developer behind libGDX.
• It has four core tools—read, write, edit, and bash—along with a short, publicly visible system prompt and support for more than fifteen providers.
• It runs interactively, in print or JSON mode, over RPC, or embedded inside your own application through an SDK.
• It intentionally ships without built-in subagents, and the official Pi website suggests using tmux or an extension instead.

The Perfect Task: Localise An App Into Four Languages

Pi is the best tool for batch jobs that you script yourself, because each Pi process is a small, predictable worker.

Run several of them from one shell script and you have an orchestrator with no framework overhead at all.

The task here is to translate an app's English strings into Hindi, Tamil, Spanish, and German, and then verify the translations.

The Agent Team

Agent	Job
translate-hi	Translates English into Hindi
translate-ta	Translates English into Tamil
translate-es	Translates English into Spanish
translate-de	Translates English into GermanSource：https://hackernoon.com/i-compared-8-ai-agent-platforms-heres-what-running-a-team-actually-costs?source=rss My favorites PreviousBybit Expands Beyond Crypto as CEO Outlines Next Phase of Financial PlatformNextWhy Knowledge Graphs and Ontologies Are Making a Comeback in the Age of AI Related posts OpenAI is finally merging ChatGPT’s chat and Work tabs OpenAI said that ChatGPT and Codex will draw usage from the same allocation pool after this change. 0TechCrunch 10 Open-Source Robotics Repositories for 3D Perception, VLA Policies, and Sensor Calibration Physical AI breaks down at the boundary where software assumptions meet sensor reality. Vision-Language-Action (VLA) mod 0dev.to My self-modifying system tried to wire a gate-passing module into its own protection enforcer. It was refused three times. Part 4 of a series on a self-modifying multi-agent LLM system. Report and data: doi.org/10.5281/zenodo.23622286 . This e 0dev.to Last night an AI agent performed brain surgery on a mouse Article URL: https://twitter.com/OcanaSantero/status/2115442964574908902 Comments URL: https://news.ycombinator.com/item 0Hacker News The Card-Update Page Gets One Visit. Design for That Visit. Here is a design constraint most teams never state out loud: the customer who lands on your card-update page will probab 0dev.to UX SaaS Partner Scout: A Script for Identifying GitHub SaaS Project Contributors Today I'm releasing SaaS Partner Scout, a lightweight script designed to query GitHub. The script's primary function is 0dev.to GitHub