TL;DR

Tracked every token across Claude Code, Hermes Agent (via OpenRouter), and GitHub Copilot for two weeks of real software development. Claude Max delivered $3,021 in API-equivalent value for €350/mo (~$399) but hit weekly limits after ~2 heavy days. mimo-v2.5-pro via OpenRouter cost $0.10/MTok with no usage caps — 1/37th of Claude Sonnet's rate. GitHub Copilot's credit system is consumption-based with variable discounts, not flat-rate. The cost-effective strategy: mimo for 80% of daily work (~$8.60–65.70/day), Claude for high-stakes tasks, Copilot for code review. Total: ~$1,436/mo across all three agents.

The Agents Tested

Tracking Tools Used

• ccusage (npx ccusage daily --json) — the primary tracker. Auto-detects Claude Code, Hermes, Copilot CLI, and many others from their local data files. Provides per-day, per-session, per-model, per-agent breakdowns with cost calculations.
• OpenRouter Explorer — built-in dashboard with per-model token counts, spend, and request counts. Exported as CSV and PDF for this analysis.
• OpenRouter Activity API — granular per-call data including provider routing, cache hits, generation time, and cost breakdowns. 4,454 API calls analyzed from a 2-day period (Jul 22–23).
• GitHub Copilot AI Usage Report — billing export with per-model, per-day credit consumption, discount rates, and quota information. Available from GitHub's billing settings. This is the most granular Copilot data available for individual accounts.
• GitHub Copilot OTEL — file-based telemetry export (newly configured). Currently tracking MCP server connections; token-level data will accumulate over time.

The Continuous Work Problem

The most important difference between these agents isn't cost per token — it's availability.

Claude Max hits its weekly token limit after ~2 days of heavy use. Sessions terminate mid-task. There's no auto-resume. You either buy additional tokens (€250/mo) or wait for the weekly reset. When you're in flow state on a complex feature, this disrupts workflow.

mimo-v2.5-pro via Hermes has no session limits, no weekly caps, no interruptions. You can work 24 hours straight, 7 days a week. The model is always available. At ~$65.70/day on heavy work days (ccusage, Jul 23), it's a coding partner that never says "you've reached your limit." The 7-day OpenRouter average is lower (~$8.62/day for mimo alone), reflecting lighter usage on some days.

The core trade-off: cost per token matters less than consistent availability.

The fair comparison: Claude Max 5x ($100/mo) lets you work roughly 2 heavy days per week before hitting limits. At that usage level, mimo costs about the same (~$131 for 2 days). But mimo doesn't stop there — you can keep going for the remaining 5 days at ~$65.70/day, totaling ~$460/week for uninterrupted 7-day work. Claude would need additional token purchases (€250/mo) and still can't match the continuity.

The trade-off: mimo costs more per month for continuous use but provides uninterrupted access. Claude is cheaper per-token but subject to session and weekly caps that can interrupt work mid-task.

The recommended pattern: Use mimo for the 80% of daily work where continuity matters (implementation, tests, docs, iteration). Use Claude for the 20% where peak quality matters and you can plan around the limits (architecture decisions, complex refactors, code review).

The Data: 16 Days of Real Usage

Claude Code — The Subscription Advantage

Claude Code runs on the Claude Max subscription (€100/mo, billed in EUR from the EU, includes 23% Polish VAT). The ccusage tool calculates per-token API costs to show what the usage would have cost at pay-per-token rates — but the actual out-of-pocket cost is the subscription plus overages.

API-equivalent value consumed (Jul 8–21, 10 days):

What this means: The Max plan delivered $3,021 worth of API tokens for €114 (~$130 incl. VAT) — a ~26x return on the subscription alone. Cache reads are 98.6% of all input tokens, meaning the sessions are heavily context-reuse driven.

Additional token costs: The Max plan's weekly allowance wasn't enough for the workload. An additional €250 (~$285 at €1 = $1.14) in token purchases were needed to cover overages when the weekly limit was hit mid-session. Total actual Claude spend: ~$399/mo ($114 subscription + $285 additional tokens). This is still a massive discount vs. pure API pricing ($3,021), but it's important to note the subscription alone doesn't cover heavy usage.

Currency & VAT note: Claude's pricing is in EUR (billed from the EU). All other services (OpenRouter, Copilot) are billed in USD. The EUR amounts include 23% Polish VAT, which inflates the real cost. The most cost-effective strategy is to buy additional tokens in bulk — larger purchases have a lower per-unit cost after VAT, so topping up once when you hit the limit is cheaper than multiple small purchases throughout the month.

Daily API-equivalent cost variance:

Strengths:

• Access to the best models (Fable, Opus) for complex reasoning
• Hooks system for workflow automation
• 98.6% cache hit ratio keeps sessions efficient

Weaknesses:

• Sessions are too short — you hit the limit mid-work
• No auto-resume; must work around it with skills
• Cron needs agent tokens (auto-resume on limit is locked)
• No API access in plans lower than MAX

Hermes Agent via OpenRouter — The Real Spend

This is where the actual money goes. OpenRouter charges per-token, and the costs are real.

OpenRouter Explorer data (Jul 16–23, 7 days):

Token distribution by model (OpenRouter, Jul 16–23):

Provider routing (from activity data, 4,454 calls on Jul 23):

Key metrics (from activity CSV, Jul 22–23):

• Total API calls: 4,454
• Average cost per call: $0.014
• Cache efficiency: 88.9% (540M cached / 608M total prompt tokens)
• Most calls: mimo-v2.5-pro via Xiaomi ($0.003/call) or Novita ($0.005/call)
• Most expensive calls: mimo-v2.5-pro via DeepInfra ($0.099/call)

Why mimo-v2.5-pro dominates: It's the workhorse — 93% of all Hermes cost. The model handles multi-step coding tasks reliably, follows project conventions (reads CLAUDE.md, respects invariants), and manages context windows well. Costs roughly 1/37th of Claude Sonnet per output token.

DeepSeek V4 Pro — underperformed: Despite consuming 40.3% of total tokens (399M tokens, $35.94), DeepSeek V4 Pro's outputs required significantly more rework. The model missed project conventions and produced less reliable code. The per-token cost was low, but the rework overhead made it poor value in this testing.

Xiaomi's cost advantage: mimo-v2.5-pro via Xiaomi's direct API was the cheapest routing option at $0.003/call (2,632 calls, $8.49 total). The same model via DeepInfra cost $0.099/call — 33x more expensive. OpenRouter's automatic provider routing sometimes picked expensive providers, resulting in up to 33x cost variation for the same model.

Strengths:

• OpenRouter has huge model selection from all providers
• mimo-v2.5-pro is a real workhorse — performance on par with Fable/Opus most of the time, cheaper than Haiku
• Best hooks/skills implementation with token-efficient focus
• Can use any API provider and multiple providers simultaneously
• Agent-free cron supported
• Auto-improvement: modifies skills without prompting if it thinks they can be enriched
• Channel connectors (WhatsApp, SMS, email)

Weaknesses:

• Some terminal rendering bugs
• Has its own data structure convention — doesn't play well with Claude Code and other CLIs (ai-badger helps bridge this)
• More setup required upfront
• Skill authoring has a learning curve

GitHub Copilot — AI Credits, 12 Models, Heavy Discounts

GitHub Copilot's pricing is more complex than it looks. It uses an AI credits system with two SKU types:

• coding_agent_ai_credit — agent mode (like Claude Code, autonomous coding)
• copilot_ai_credit — chat, inline suggestions, and code review

Each model consumes credits at different rates, and discounts are applied based on your plan tier and monthly quota.

AI Usage Report (Jul 11–14, 4 days):

By model (sorted by net cost):

By usage type:

Key findings:

• Code Review model is the biggest consumer — 12,354 credits ($30.23 net) across 4 days. This is Copilot's automated PR review, and it's heavily used.
• Plan upgrades trigger temporary discounts — the data shows you upgraded from Pro ($10/mo, 1,500 credits) to Pro+ ($39/mo, 7,000 credits) on Jul 12, then to Max ($100/mo, 20,000 credits) on Jul 14. Each upgrade triggered massive 100% discounts on many models that day, which reverted to normal rates the next day. This is likely an upgrade bonus, not a permanent feature. Credits reset monthly (1st of each month at 00:00 UTC), not weekly.
• Discount rates vary wildly — from 0% to 100%, with an average of 63%. The high discounts are tied to plan upgrades, not permanent features.
• 12 models available — far more than expected. Includes Claude Fable 5, Claude Opus 4.8, GPT-5.6 Terra/Luna, and a dedicated Code Review model.
• Agent mode vs chat mode — agent mode (coding_agent_ai_credit) consumed 3,460 credits ($25.03), while chat/inline/review consumed 18,345 credits ($54.97). Code review dominates.

Projected monthly cost: At $80/4 days = ~$600/month net — but this is unstable. The discount structure depends on plan tier, upgrade timing, and model selection. On a stable Max plan without mid-cycle upgrades, expect the full 20,000 credits at face value (~$200/month) plus any overages. The $80/4 days figure includes upgrade bonuses that won't recur monthly.

Practical lessons from 4 days of heavy Copilot use:

• Run demanding tasks at the end of the month — credits reset on the 1st at 00:00 UTC. If you burn through your allowance early, you're stuck waiting. Front-loading heavy work into the first week means sitting idle for 3 weeks.

• Fable has a separate counter — different models draw from different pools. If you exhaust one model's limit, you can't redirect unused credits from another. This happened during testing: Opus was set as the default model, its limit was hit, and 50% of the Fable allowance remained unused.

• Manage model selection consciously — the best strategy is to exhaust premium model credits (Fable) first for high-value work, then fall back to cheaper models for the rest of the cycle. But this requires constant attention to which model is active and how much allowance remains.

• Delegation burns limits fast — you can't just delegate work freely. Every subagent call, every code review, every chat message consumes credits. The moment you stop paying attention to model selection, you waste allowance on the wrong model. This is the biggest operational overhead of Copilot vs. flat-rate alternatives.

The Real Cost Comparison

Here's the honest comparison — what actually came out of pocket:

Cost Per Million Tokens (Actual API Rates)

The subscription arbitrage: Claude Max gives you $3,021 worth of API tokens for €114 ($130, incl. 23% VAT) — but heavy users will hit the weekly limit and need additional purchases (€250/mo = $285). At $399/mo total, you're still getting a 7.6x return vs. pure API pricing. The most cost-effective approach is to buy additional tokens in bulk — one large top-up has a lower per-unit cost than multiple small purchases. The question is whether you need Claude for everything — and the answer is no. mimo-v2.5-pro handles 80% of implementation work at 1/37th the cost.

The 80/20 Strategy

Monthly cost with this split:

• Claude Max + overages: ~$399/mo (€100 subscription + €250 additional tokens, EUR prices include 23% VAT; €1 = $1.14)
• OpenRouter (Hermes, mimo-v2.5-pro only): ~$40–60/mo (USD)
• Copilot: ~$200/mo net (USD, consumption-based with 63% average discount)
• Total: ~$620–660/mo
• Savings vs pure API pricing: $3,021 API-equivalent for $399 = 7.6x return on Claude alone

Cost Optimization Strategies

1. Model routing: Use cheap models (mimo-v2.5-pro) for implementation, expensive ones (Opus/Fable) for planning and review. Hermes's persona routing makes this automatic.
2. Cache awareness: Keep context byte-stable across turns. Claude's cache reads cost 1/10th of writes. OpenRouter cache efficiency is 88.9% — rewriting state files mid-session kills this.
3. Provider selection on OpenRouter: The same model costs vastly different amounts depending on the provider. mimo-v2.5-pro via Xiaomi is $0.003/call; via DeepInfra it's $0.099/call. OpenRouter routes automatically, but you can influence it.
4. Skill loading: Load skills on-demand, not every turn. Reduces context token overhead significantly.
5. Task decomposition: Break work into focused subagents. Smaller context = fewer tokens per agent.
6. Quality over price: DeepSeek looked cheap on paper but cost more in rework. mimo-v2.5-pro at $0.40/MTok output delivered better results than models costing 15x more. Always factor in retry costs when comparing models.

How to Track Your Own Usage

# OpenRouter — built-in Explorer dashboard
# Visit: https://openrouter.ai/activity
# Export as CSV/PDF for analysis

# Claude Code — ccusage (auto-detected)
npx ccusage daily
npx ccusage claude daily --json

# Hermes Agent — ccusage or built-in CLI
npx ccusage hermes daily --json
hermes usage --by-model --since "7 days ago"

# GitHub Copilot — AI Usage Report (billing export)
# Visit: https://github.com/settings/billing/summary
# Download "AI Usage Report" CSV for per-model credit consumption
# Also set up OTEL for CLI-level tracking:
export COPILOT_OTEL_ENABLED=true
export COPILOT_OTEL_EXPORTER_TYPE=file
export COPILOT_OTEL_FILE_EXPORTER_PATH="$HOME/.copilot/otel/copilot-otel-$(date +%Y%m%d-%H%M%S).jsonl"
npx ccusage copilot daily --json

# All agents combined
npx ccusage monthly --json
npx ccusage session --json

Code Quality Case Study

A common concern with AI-generated code is quality. Here's evidence from the largest project — job-search-ai-assistant (private repo) — a .NET/C# backend + React 19 frontend built primarily with Claude Code and Hermes Agent. All code was hand-reviewed and refactored by a human developer before merging.

Backend

Strong points:

• Domain purity enforced by ArchUnit tests
• Guard clauses used consistently (CommunityToolkit.Diagnostics.Guard)
• Immutable records as the norm
• High-performance logging ([LoggerMessage] on nested static partial class Log) adopted uniformly
• Thorough take-home calculator (UoP + B2B/JDG, progressive/flat/ryczałt, ZUS schemes, KUP caps)
• Clean signal model with conflict-aware merge closing a documented TOCTOU gap

5 minor findings: one UUID version inconsistency, one guard clause style mismatch, one missing range validation, one duplicated helper, one frontend/backend type divergence. No architectural issues.

Frontend

Strong points:

• Monochrome palette with hue reserved exclusively for domain state chips
• Screaming Architecture followed consistently (domain-named folders)
• All data fetching via TanStack React Query (no raw fetch)
• Tailwind CSS v4 @theme configuration rated "exemplary"
• React 19 ref-as-prop pattern correctly adopted (no deprecated forwardRef)

Note: This code was built by AI agents (Claude Code + Hermes) but hand-reviewed and refactored by a human developer. The reviews above are independent assessments of the final merged code, not the raw AI output. The combination of AI speed + human judgment produces code that passes professional code review standards.

Methodology Notes

• All data collected from July 8–23, 2026 (16 active days)
• Tasks were real production work across three projects:
• arasz-home-page (this repo) — Angular + Azure Functions + Terraform (this blog, infrastructure)
• job-search-ai-assistant (private repo) — .NET/C# + React 19 + Cosmos DB (the main product)
• ai-badger — AI agent marketplace/catalog framework (GitHub)
• Claude Code: Claude Max subscription (€100/mo) + €250 in additional token purchases. Billed in EUR, includes 23% Polish VAT. Converted to USD at €1 = $1.14. API-equivalent costs calculated by ccusage for comparison only.
• Hermes Agent: OpenRouter API (pay-per-token). Actual spend tracked via OpenRouter Explorer and ccusage.
• GitHub Copilot: Business plan. AI credit system with per-model consumption tracked via GitHub's AI Usage Report (billing export). Used primarily via Rider IDE integration, but billing and usage data come from GitHub, not JetBrains.
• Currency: Claude Code billed in EUR; all other services billed in USD. All figures in this article are in USD unless noted.
• ccusage detected agents automatically from their local data stores (no manual configuration)

Tools, Agents, and Resources

Agents tested:

• Claude Code — Anthropic's terminal-based coding agent
• Hermes Agent — open-source CLI agent by Nous Research
• GitHub Copilot — GitHub's AI coding assistant

Model providers:

• OpenRouter — unified API for 200+ AI models (used for mimo-v2.5-pro, DeepSeek, Qwen)
• Anthropic — Claude models (Sonnet, Opus, Fable, Haiku)
• Xiaomi MiMo — mimo-v2.5-pro model

Tracking tools:

• ccusage — CLI tool for tracking AI coding agent usage across Claude Code, Hermes, Copilot, and more
• OpenRouter Explorer — built-in usage dashboard with per-model token counts and spend
• GitHub Copilot AI Usage Report — billing export with per-model credit consumption

Documentation referenced:

• Claude Max plan — pricing, usage limits, weekly caps
• Claude Code with Pro/Max — 5-hour rolling sessions, shared limits
• GitHub Copilot usage-based billing — AI credits, plan tiers, monthly quotas
• Claude Code usage limits — third-party analysis of session/weekly caps

Last updated: 2026-07-23