DEV Community: Avinash Sangle

Getting Started with the ant CLI: Deploy Claude Agents

Avinash Sangle — Wed, 22 Apr 2026 05:25:26 +0000

This article was originally published on avinashsangle.com.

The ant CLI is Anthropic's official command-line client for the Claude API, and it's the fastest way to create, configure, and manage cloud-hosted agents without writing application code. From install to a running managed agent in under 10 minutes.

TL;DR

The ant CLI is Anthropic's official Go-based CLI for the Claude API, launched April 2026. It manages agents, environments, and sessions from your terminal.
Install on macOS with brew install anthropics/tap/ant. Linux and Go installs are also supported.
Define agents as YAML files, check them into Git, and deploy through CI - full GitOps for your agent configs.
Sessions cost $0.08/hour (billed to the millisecond) plus standard Claude token rates. Idle time is free.

What Is the ant CLI?

The ant CLI shipped alongside Claude Managed Agents on April 8, 2026, and it's built specifically for developers who want to create, configure, and run cloud-hosted agents without writing wrapper code. The GitHub repo already has over 300 stars in its first ten days.

It follows a resource-based command structure: ant [resource] <command> [flags...]. Think of it like kubectl for Claude agents. You can pipe YAML into it, extract fields with GJSON transforms, and chain commands in shell scripts. If you've worked with any modern infrastructure CLI, the patterns will feel familiar.

One thing to clarify early: the ant CLI and Claude Code solve different problems. Claude Code is your interactive coding assistant in the terminal - you talk to it, it writes code, and you pay through a subscription. The ant CLI is a programmatic API client for managing hosted agent infrastructure. You authenticate with an API key, and you're billed at standard API rates. I use both daily, and they complement each other well. Claude Code even understands how to shell out to ant natively.

How to Install the ant CLI

There are three installation paths depending on your platform. If you're on macOS, Homebrew is the fastest route.

macOS (Homebrew)

# Install from Anthropic's tap
brew install anthropics/tap/ant

# Clear the macOS quarantine flag (required)
xattr -d com.apple.quarantine "$(brew --prefix)/bin/ant"

# Verify
ant --version

That quarantine step trips people up. macOS flags unsigned binaries downloaded by Homebrew, and without clearing it you'll get a "cannot be opened because the developer cannot be verified" error. It's a one-time thing.

Linux / WSL (curl)

VERSION=1.2.1
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m | sed -e 's/x86_64/amd64/' -e 's/aarch64/arm64/')

curl -fsSL \
  "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
  | sudo tar -xz -C /usr/local/bin ant

From Source (Go 1.22+)

go install github.com/anthropics/anthropic-cli/cmd/ant@latest
export PATH="$PATH:$(go env GOPATH)/bin"

Set Your API Key

Once installed, set your Anthropic API key. The CLI reads it from the ANTHROPIC_API_KEY environment variable:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

You can generate an API key from the Anthropic Console. I keep mine in a .env file that my shell sources on startup, but any secret management approach works.

Shell Completions

The ant CLI supports completions for bash, zsh, fish, and PowerShell. For zsh (the default macOS shell):

# Generate zsh completions
ant completion zsh > ~/.zfunc/_ant

# Add to your .zshrc if not already there
echo 'fpath=(~/.zfunc $fpath)' >> ~/.zshrc
echo 'autoload -Uz compinit && compinit' >> ~/.zshrc

Tab completion saves a lot of time when working with the beta: namespaced commands, which can get long.

Core Concepts - Agents, Environments, and Sessions

Before you create anything, it helps to understand how the four core pieces fit together.

Agent - A versioned configuration defining the model, system prompt, tools, and MCP server connections. Think of it as a blueprint. Each update creates a new version, so you can roll back if needed.

Environment - A container template specifying pre-installed packages (pip, npm) and networking rules. Create it once, reference it by ID. Multiple sessions can share one environment config, but each gets its own isolated container.

Session - A running instance that pairs an agent with an environment. It has its own container, filesystem, and conversation history. Sessions are where the actual work happens.

Events - The communication protocol. You send user events (messages, interrupts, tool confirmations) and receive agent events (messages, tool calls, thinking). Everything is event-based and streamable.

The flow works like this: you create an agent (the what), create an environment (the where), start a session linking them together, and then communicate through events. Anthropic handles the container orchestration, tool execution, and conversation state. According to the official docs, sessions cost $0.08 per session-hour billed to the millisecond, and idle time doesn't count.

Creating Your First Agent with the ant CLI

Let's build a simple code review agent. I'll walk through each step so you can see exactly what the CLI does at each stage. All managed agent commands sit under the beta: prefix since the feature is still in beta.

Step 1: Create the Agent

ant beta:agents create \
  --name "Code Reviewer" \
  --model claude-sonnet-4-6 \
  --system "You are a senior code reviewer. Read the code carefully, check for bugs, security issues, and style problems. Be specific about line numbers and provide fix suggestions." \
  --tool '{"type": "agent_toolset_20260401"}'

The response comes back as JSON with the agent ID and version. I like to extract just the ID for scripting:

# Extract the agent ID
AGENT_ID=$(ant beta:agents create \
  --name "Code Reviewer" \
  --model claude-sonnet-4-6 \
  --system "You are a senior code reviewer." \
  --tool '{"type": "agent_toolset_20260401"}' \
  --transform id --format raw)

echo "Created agent: $AGENT_ID"

The --transform flag uses GJSON syntax to pluck a specific field from the response, and --format raw strips the quotes. This is one of the CLI's best features for scripting.

Step 2: Create an Environment

ENV_ID=$(ant beta:environments create \
  --name "python-dev" \
  --pip-packages '["pytest", "ruff", "mypy"]' \
  --networking unrestricted \
  --transform id --format raw)

echo "Created environment: $ENV_ID"

Environments define what's pre-installed in the container. I'm giving this one Python linting tools since it's a code review agent. The unrestricted networking flag lets the agent fetch external resources if needed.

Step 3: Start a Session

SESSION_ID=$(ant beta:sessions create \
  --agent-id "$AGENT_ID" \
  --environment-id "$ENV_ID" \
  --transform id --format raw)

echo "Started session: $SESSION_ID"

Step 4: Send a Message and Stream the Response

# Send a review request
ant beta:sessions:events send \
  --session-id "$SESSION_ID" \
  --type user.message \
  --content-type text \
  --content-text "Review this Python function for bugs:

def divide(a, b):
    return a / b
"

# Stream the agent's response in real-time
ant beta:sessions stream --session-id "$SESSION_ID"

The stream command opens a real-time SSE connection to the session. You'll see the agent's thinking, tool calls (it might run the code through ruff), and its final review - all printed to your terminal as they happen.

Tip: Want to explore the response interactively? Replace --format raw with --format explore on any command to open the TUI explorer. It lets you navigate nested JSON with arrow keys - really useful when debugging agent responses.

YAML Version Control for Agents

This is the ant CLI's best feature, and the one I haven't seen anyone write about yet. Instead of passing flags inline, you can define agents and environments as YAML files, check them into Git, and deploy through your CI pipeline.

# code-reviewer.agent.yaml
name: Code Reviewer
model: claude-sonnet-4-6
system: |
  You are a senior code reviewer. Read the code carefully,
  check for bugs, security issues, and style problems.
  Be specific about line numbers and provide fix suggestions.
tools:
  - type: agent_toolset_20260401
    configs:
      - name: web_fetch
        enabled: false

# code-reviewer.environment.yaml
name: python-dev
pip_packages:
  - pytest
  - ruff
  - mypy
networking: unrestricted

Now you can create the agent directly from the file:

# Create from YAML
ant beta:agents create < code-reviewer.agent.yaml

# Update an existing agent (version is required for safety)
ant beta:agents update \
  --agent-id "$AGENT_ID" \
  --version 1 \
  < code-reviewer.agent.yaml

The versioning requirement matters. When you update an agent, you must pass the current version number. If someone else updated it since you last pulled, the command fails rather than silently overwriting. It's optimistic concurrency control - the same pattern you'd find in Kubernetes or Terraform.

This YAML approach is where the ant CLI really shines for teams. Your agent configs live in the same repo as your application code, go through pull request review, and deploy through the same pipeline. I wrote more about the broader Managed Agents architecture in my Managed Agents vs Agent SDK comparison, but the YAML workflow is what makes the CLI my preferred interface.

According to the official CLI docs, Anthropic designed the YAML workflow specifically for GitOps-style agent management. If you're already doing infrastructure as code, this slots right in.

ant CLI vs curl vs SDK - Why Use the CLI?

You can hit the Managed Agents API three ways: raw HTTP with curl, a language SDK (Python, TypeScript, Go, etc.), or the ant CLI. Each has its place.

Feature	curl	ant CLI	Python SDK
Setup time	None	2 minutes	5 minutes
JSON body authoring	Manual	Typed flags / YAML	Typed objects
Auto-pagination	Manual	Built-in	Built-in
File references	Manual base64	`@path` syntax	File objects
Response filtering	Pipe to jq	`--transform`	Code
Shell scripting	Verbose	Ergonomic	Requires Python
CI/CD fit	OK	Excellent	Good
Best for	Quick tests	Ops / automation	App integration

The ant CLI sits in a sweet spot. It's faster than writing curl commands by hand (no JSON body construction, no header management), and lighter than pulling in a full SDK when you just want to script some agent operations. For anything that lives in a shell script or CI workflow, it's the right tool.

If you're building an application that embeds agent interactions - a web app, a Slack bot, a data pipeline - use the SDK. The ant CLI is for the operational layer: provisioning agents, rotating credentials, monitoring sessions, deploying config changes.

Scripting and Automation Patterns

Here are a few patterns I've found useful when automating agent workflows with the ant CLI.

Extract IDs from Create Commands

#!/bin/bash
set -euo pipefail

# Create agent and capture the ID
AGENT_ID=$(ant beta:agents create \
  < agents/reviewer.agent.yaml \
  --transform id --format raw)

# Create environment and capture the ID
ENV_ID=$(ant beta:environments create \
  < agents/reviewer.environment.yaml \
  --transform id --format raw)

echo "Agent: $AGENT_ID"
echo "Environment: $ENV_ID"

# Store for later use
echo "AGENT_ID=$AGENT_ID" >> .env.agents
echo "ENV_ID=$ENV_ID" >> .env.agents

GitHub Actions Deployment

name: Deploy Agents
on:
  push:
    branches: [main]
    paths: ['agents/**']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install ant CLI
        run: |
          curl -fsSL \
            "https://github.com/anthropics/anthropic-cli/releases/download/v1.2.1/ant_1.2.1_linux_amd64.tar.gz" \
            | sudo tar -xz -C /usr/local/bin ant

      - name: Update agent config
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          ant beta:agents update \
            --agent-id "${{ vars.AGENT_ID }}" \
            --version "${{ vars.AGENT_VERSION }}" \
            < agents/reviewer.agent.yaml

List All Agents and Environments

# List agents in a readable table
ant beta:agents list --format yaml

# List environments with just names and IDs
ant beta:environments list --transform "data.#.{id,name}" --format yaml

# Check session status
ant beta:sessions retrieve \
  --session-id "$SESSION_ID" \
  --transform status --format raw

The --transform flag accepts full GJSON path syntax. You can filter arrays, project specific fields, and even do conditional extraction. It's much cleaner than piping to jq for simple extractions, though for complex transformations I still reach for jq.

What Tools Can Managed Agents Use?

When you include {"type": "agent_toolset_20260401"} in your agent config, it gets access to a standard set of tools: bash, read, write, edit, glob, grep, and web_fetch. All are enabled by default.

You can selectively disable tools you don't want the agent to have. For a read-only code review agent, you might disable write and edit:

# readonly-reviewer.agent.yaml
name: Read-Only Reviewer
model: claude-sonnet-4-6
system: Review code without modifying it.
tools:
  - type: agent_toolset_20260401
    configs:
      - name: write
        enabled: false
      - name: edit
        enabled: false
      - name: web_fetch
        enabled: false

Or flip the default and whitelist only what you need:

tools:
  - type: agent_toolset_20260401
    default_config:
      enabled: false
    configs:
      - name: bash
        enabled: true
      - name: read
        enabled: true

Agents can also connect to external MCP servers for tools beyond the built-in set. If you've built a custom MCP server, a managed agent can use it by adding an mcp_servers block to the agent config.

Frequently Asked Questions

What is the ant CLI from Anthropic?

The ant CLI is Anthropic's official command-line client for the Claude API. Written in Go, it provides a resource-based command structure for managing agents, environments, and sessions. It supports typed flags, YAML input, auto-pagination, and multiple output formats including an interactive TUI explorer.

How do I install the ant CLI on macOS?

Install via Homebrew: run brew install anthropics/tap/ant, then clear the macOS quarantine flag with xattr -d com.apple.quarantine "$(brew --prefix)/bin/ant". Set your ANTHROPIC_API_KEY environment variable and verify with ant --version.

What is the difference between the ant CLI and Claude Code?

Claude Code is an interactive agentic coding assistant that runs in your terminal and uses a subscription. The ant CLI is a programmatic API client for managing Managed Agents resources, uses an API key, and is built for scripting and CI/CD automation. They're complementary - Claude Code can even shell out to ant commands.

How much does it cost to run a managed agent session?

Sessions cost $0.08 per session-hour, billed to the millisecond. Idle time is free. You also pay standard Claude API token rates on top. A typical 1-hour coding session with Opus costs roughly $0.70 total including both tokens and session runtime.

Can I version control agents with the ant CLI?

Yes. Define agents as YAML files (e.g. reviewer.agent.yaml), check them into Git, and deploy via CI. Use ant beta:agents create to create from YAML and ant beta:agents update with the version flag to push updates. This gives you full GitOps for agent configurations.

Can managed agents connect to MCP servers?

Yes. Agents support remote MCP server connections via the --mcp-server flag. You specify the server URL and name, then add an mcp_toolset tool entry referencing that server. This lets agents use tools from GitHub, Slack, or custom MCP servers you've built.

How do I use the ant CLI in CI/CD pipelines?

Define agents and environments as YAML files in your repo. In CI, use ant beta:agents create < agent.yaml to provision and ant beta:agents update to deploy changes. The --transform flag extracts IDs for scripting, and --format controls output parsing.

What tools are available to managed agents?

The agent_toolset_20260401 built-in toolset includes bash, read, write, edit, glob, grep, and web_fetch. You can enable or disable individual tools, or disable all by default and whitelist specific ones. Agents can also connect to external MCP servers for custom tool integrations.

Read the full tutorial with interactive code examples and component-based layout on the original post: Getting Started with the ant CLI on avinashsangle.com.

Claude Code Cost Tracking: Monitor and Cut Your Spending

Avinash Sangle — Fri, 17 Apr 2026 05:04:30 +0000

This article was originally published on avinashsangle.com.

How Much Does Claude Code Actually Cost?

The pricing structure is straightforward. Claude Code Pro runs $20 per month (or $17 annually). The Max plan comes in two tiers: $100/month for 5x the Pro usage allowance, and $200/month for 20x. If you are on the API, you pay per token - Sonnet 4.6 at $3/$15 per million input/output tokens, and Opus 4.6 at $15/$75.

Across enterprise deployments, the average lands between $150 and $250 per developer per month, according to Anthropic's published benchmarks. Ninety percent of users stay under $12 per day. But that top 10% can burn through tokens fast, especially with extended thinking enabled and Opus as the default model.

The real issue? Tracking is scattered. Subscription users can't see dollar costs in the Console. API users get billing data but not per-session breakdowns. And everyone has local JSONL files sitting on their machine that most people don't even know exist.

TL;DR

Track costs with built-in commands: /cost for API users, /stats for subscribers, /usage for rate limit status
Find your hidden usage data: Claude Code logs every session to ~/.claude/projects/ as JSONL files with full token counts
Use third-party tools for real visibility: ccusage (4.8k GitHub stars) gives you daily, monthly, and per-session cost reports
Cut costs by 50% with 7 practical changes: default to Sonnet, cap thinking tokens, clear context between tasks, and write specific prompts

Built-In Cost Tracking Commands You Should Know

Claude Code ships with three commands for checking usage. Which one you should use depends on whether you are paying through the API or a subscription plan.

/cost - Session API Spend

The /cost command shows your current session's token usage and estimated dollar cost. Designed for API users. Subscription users still see token counts, which is useful for understanding consumption patterns.

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    127 lines added, 43 lines removed

/stats - Subscriber Usage Dashboard

If you are on Pro or Max, /stats opens a dashboard with a usage heatmap, session counts, token totals by model, and activity streaks. No dollar costs (flat-rate plan), but you see exactly how much of your allowance you are burning.

/usage - Rate Limit Status

Shows your plan limits and current rate limit status. Check this when Claude Code feels slow or you suspect throttling. Shows both 5-hour and 1-week usage windows.

Status Line Configuration

# Show cost in the status line (API users)
claude config set status_line.show_cost true

# Show token count in the status line
claude config set status_line.show_tokens true

When to use which:

API users: Use /cost for dollar amounts and /usage for rate limits
Pro/Max subscribers: Use /stats for usage patterns and /usage for rate limits
Everyone: Configure the status line for passive monitoring

Where Claude Code Stores Your Usage Data

Every session gets logged to your local filesystem as JSONL files. These contain detailed token counts for every API call - input tokens, output tokens, cache creation tokens, cache read tokens, and the model used. This is the same data third-party tools read to build their dashboards.

Session Logs

Claude Code writes one JSONL file per session to ~/.claude/projects/. If you are on a subscription plan, these local logs are the only way to get granular cost data since the Console doesn't expose it.

# Find your session logs
ls ~/.claude/projects/

# Look at the most recent session
ls -lt ~/.claude/projects/ | head -5

# Count tokens in a session with jq
cat ~/.claude/projects/<session-file>.jsonl | \
  jq -s '[.[].message.usage // empty] |
    { total_input: (map(.input_tokens) | add),
      total_output: (map(.output_tokens) | add),
      cache_read: (map(.cache_read_input_tokens // 0) | add),
      cache_creation: (map(.cache_creation_input_tokens // 0) | add) }'

Status Line Snapshots

Second file most people miss: ~/.claude/statusline.jsonl. Contains periodic snapshots with server-reported cumulative cost and your 5-hour and 1-week rate-limit usage percentages. This data is only in this local file.

# View recent status line snapshots
tail -5 ~/.claude/statusline.jsonl | jq .

# Extract cost progression over time
cat ~/.claude/statusline.jsonl | \
  jq -r '[.timestamp, .cost_usd] | @csv'

Third-Party Tools for Claude Code Usage Analytics

The built-in commands give a snapshot. For real visibility into trends, per-project breakdowns, and forecasting, you need more.

ccusage - The Most Popular Option

4,800+ GitHub stars. CLI that reads your local JSONL files and produces clean tables with daily, monthly, or per-session cost breakdowns. Tracks cache tokens separately, supports billing window analysis, works offline with cached pricing data.

# Install and run - no setup needed
npx ccusage              # Daily report (default)
npx ccusage daily        # Detailed daily breakdown
npx ccusage monthly      # Monthly aggregated totals
npx ccusage session      # Cost per conversation session
npx ccusage blocks       # 5-hour billing window analysis

# Filter by project
npx ccusage --instances  # Group usage by project

claude-usage - Local Web Dashboard

Reads the same local log files but renders them as charts with cost estimates, session timelines, and model breakdowns. Pro and Max subscribers get a progress bar for their allowance.

Claude-Code-Usage-Monitor - Real-Time Alerts

Real-time chart of token consumption with predictions about when you will hit your limits. Good for Max plan users who want early warnings before getting throttled.

ccost - Per-Request Granularity

Analyzes per-request JSONL logs with detailed token counts using LiteLLM pricing data. Use when you want to know exactly which requests were the most expensive.

Tool	Interface	Best For	GitHub Stars
ccusage	CLI	Daily/monthly reports, billing windows	4,800+
claude-usage	Web dashboard	Visual charts, subscriber progress	1,200+
Usage-Monitor	CLI (real-time)	Limit predictions, early warnings	500+
ccost	CLI	Per-request cost analysis	200+

How to Set a Budget Limit for Claude Code

Per-Command Budget Cap

The --max-budget-usd flag caps the maximum dollar amount for a single print-mode command. Useful in CI/CD pipelines or automated scripts where a runaway agent could burn through tokens.

# Cap a single command at $5
claude -p --max-budget-usd 5.00 "Refactor the auth module"

# Combine with max-turns for double protection
claude -p --max-budget-usd 10.00 --max-turns 5 "Fix failing tests in src/"

Workspace Rate Limits for Teams

Claude Code creates a workspace called "Claude Code" when you first authenticate with Console. Set rate limits on this workspace in the Console's Limits page to cap Claude Code's share of your API allocation.

Agent SDK Cost Tracking

If you are building on the Claude Agent SDK, every result message includes a total_cost_usd field.

import { query } from "@anthropic-ai/claude-agent-sdk";

let totalSpend = 0;

const prompts = [
  "Read the files in src/ and summarize the architecture",
  "List all exported functions in src/auth.ts"
];

for (const prompt of prompts) {
  for await (const message of query({ prompt })) {
    if (message.type === "result") {
      totalSpend += message.total_cost_usd;
      console.log(`This call: $${message.total_cost_usd}`);
    }
  }
}

console.log(`Total spend: $${totalSpend.toFixed(4)}`);

7 Ways to Cut Claude Code Costs by 50%

After tracking my spending for a few weeks, I identified the patterns that were burning tokens fastest. These seven changes brought my daily average from ~$12 down to $5-6, with zero quality loss.

1. Default to Sonnet, Switch to Opus Only When Needed

Sonnet 4.6 costs $3/$15 per million input/output tokens. Opus 4.6 costs $15/$75. That's 5x more expensive. For most coding tasks, Sonnet produces results that are just as good.

# Switch models on the fly
/model sonnet    # For everyday tasks
/model opus      # For complex reasoning only

2. Set MAX_THINKING_TOKENS to 10,000

Extended thinking is the single biggest cost lever. Uncapped thinking tokens can generate tens of thousands of tokens per request. A 10,000 limit still gives Claude enough room to reason.

# Set thinking token limit
export MAX_THINKING_TOKENS=10000

# Or lower the effort level for simple tasks
/effort low       # Significant token savings
/effort medium    # Balance of cost and quality

3. Use /clear Between Tasks

Stale context is a silent cost multiplier. Every message includes the full conversation history as input tokens. Run /clear when you switch to unrelated work. Use /rename first if you want to come back to the session later with /resume.

4. Use /compact When Context Grows

If you are mid-task and can't clear, use /compact to summarize the conversation history. Reduces token count while preserving important context.

5. Write Specific Prompts

Vague prompts are expensive. "Make this better" forces Claude to spend tokens figuring out what you want. "Extract the hardcoded strings in src/auth.js into constants" gets the job done in one pass.

6. Use Plan Mode Before Expensive Operations

Press Shift+Tab twice to enter plan mode before starting a big task. Claude outlines its approach before writing code. Costs a few hundred tokens for the plan but saves thousands by preventing costly rework.

7. Break Work Into Scoped Sessions

One session for everything is the most expensive way to use Claude Code. Context accumulates, cache misses increase, and irrelevant history gets sent with every request. Work in task-scoped sessions: one for fixing the login bug, another for adding the new API endpoint, a third for writing tests.

Claude Code API vs Subscription: Which Costs Less?

Usage Profile	API Cost/Month	Best Plan	Savings
Light (1-2 hrs/day)	$30-50/mo	API or Pro ($20)	Pay-per-use wins
Moderate (3-5 hrs/day)	$100-180/mo	Max 5x ($100)	Up to 44% savings
Heavy (6+ hrs/day)	$200-400/mo	Max 20x ($200)	Up to 50% savings

The API makes more sense with sporadic usage or when you need fine-grained budget controls like --max-budget-usd. It's also the only option for per-project cost allocation when billing clients. The subscription wins on predictability.

My approach: Max 5x plan for day-to-day, API key configured for automated scripts and CI pipelines where I want hard budget caps. Hybrid setup gives predictable costs for interactive work and strict controls for automation.

Frequently Asked Questions

How do I check my Claude Code costs?

Use /cost in any session for API spend totals with token counts and dollar estimates. Subscribers should use /stats for a usage dashboard with heatmaps and model breakdowns, or /usage for rate limit status. You can also configure the status line to show costs continuously.

Where does Claude Code store usage data locally?

Claude Code writes one JSONL file per session to ~/.claude/projects/ with full token counts for every API call. It also writes periodic snapshots to ~/.claude/statusline.jsonl containing cumulative cost and rate-limit usage percentages. Third-party tools like ccusage read these files.

What is ccusage and how do I use it?

ccusage is an open-source CLI tool with 4,800+ GitHub stars that analyzes Claude Code usage from local JSONL files. Run npx ccusage for a daily report, npx ccusage monthly for monthly totals, or npx ccusage session to see costs per conversation. Works offline with cached pricing data.

How much does Claude Code cost per day on average?

Anthropic reports the average at about $6 per developer per day, with 90% of users under $12 per day. Enterprise deployments average $150 to $250 per developer per month. Heavy Opus sessions with extended thinking can spike past $20 in a single day.

How do I set a budget limit for Claude Code API usage?

Use --max-budget-usd in print mode to cap spending per command: claude -p --max-budget-usd 5.00 "your prompt". For team-wide limits, set workspace rate limits in the Claude Console. You can also use --max-turns to indirectly limit costs.

Is Claude Code Max plan worth it vs API pricing?

If your API equivalent spend exceeds $100/month, the Max 5x plan at $100/month saves money. If you spend over $200/month on API, Max 20x is the better deal. For sporadic usage under $50/month, pay-per-token API pricing usually costs less overall.

How does prompt caching reduce Claude Code costs?

Claude Code automatically caches repeated content like system prompts and CLAUDE.md files. Cached tokens cost 90% less than fresh input tokens. The cache has a 5-minute TTL, so keeping sessions under 5 minutes apart maximizes savings. Track cache hit rates in local JSONL logs.

Read the full version (with extra examples and updates) on the original post: Claude Code Cost Tracking on avinashsangle.com.

Claude Managed Agents vs Agent SDK: Which Should You Use?

Avinash Sangle — Tue, 14 Apr 2026 11:38:39 +0000

This article was originally published on avinashsangle.com.

Anthropic launched Claude Managed Agents in beta on April 8, 2026. It's a hosted service that runs long-horizon Claude agents in Anthropic's infrastructure - sandboxed, persistent, and integrated with MCP servers out of the box.

If you're choosing between Managed Agents and the Agent SDK, the short answer is:

Pick Managed Agents for multi-hour production workloads
Pick the Agent SDK when you need full control over the runtime

Here's the breakdown after digging through the docs and API.

TL;DR

Managed Agents = Anthropic runs the agent harness, sandbox, and runtime for you (hosted, beta)
Agent SDK = you run the same engine yourself, with full control over infrastructure
Pricing: standard token rates + $0.08 per session-hour of active runtime + $10 per 1,000 web searches
Early adopters: Notion, Rakuten, Asana - focused on long-running enterprise workflows
Beta header required: managed-agents-2026-04-01

The Core Difference

Think of it like this:

Managed Agents = Vercel (hosted, opinionated, pay-per-use)
Agent SDK = self-hosted Next.js (you run it on your infra)

Same underlying engine. Different operational trade-offs.

Managed Agents handles the agent loop, sandboxed code execution, file system access, web browsing, persistent sessions, and checkpointing for you. You send a prompt, connect your MCP servers, and the agent runs - even for hours - without you maintaining any of that runtime infrastructure.

The Agent SDK exposes the same engine for self-hosted runtimes. You get local file access, private network connectivity, custom tool execution, and full runtime control. No session-hour charges - just token costs.

Pricing

Managed Agents pricing on top of standard Claude API rates:

$0.08 per session-hour of active runtime
$10 per 1,000 web searches
Idle time is free - sessions can wait for input without billing

For a 2-hour research task, you're looking at roughly $0.16 in compute plus token costs. For zero infrastructure management, that's a strong tradeoff for production workloads.

When to Pick Which

Pick Managed Agents when:

You have multi-hour production workloads (research, batch processing, monitoring)
You need sandboxed code execution out of the box
Web browsing + MCP integrations matter
You don't want to build or maintain agent infrastructure

Pick Agent SDK when:

You need local file access (working against repos)
Private network access required
Custom tool execution logic
You want predictable token-only costs without session-hour pricing
Development and debugging - the SDK lets you inspect everything

What You Get Out of the Box with Managed Agents

Sandboxed containers with code execution, file system, and web access
Sessions can run for hours with checkpointing for fault tolerance
MCP server support - any MCP server you've built for Claude Desktop or Claude Code can be configured for a Managed Agent session
Built-in web browsing and search

Beta Status

Managed Agents is currently in beta. All endpoints require the beta header:

anthropic-beta: managed-agents-2026-04-01

The official Anthropic SDKs set this automatically when you use the beta namespace. Some features like multi-agent orchestration remain in limited research preview.

The Bigger Picture

Notion, Rakuten, and Asana are early adopters - all using Managed Agents for enterprise workflows where the agent needs to run for extended periods, integrate with internal tools via MCP, and survive infrastructure failures.

This is Anthropic moving up the value chain: instead of just selling the model, they're selling the complete runtime that wraps it. For teams without dedicated AI infrastructure, that's a meaningful shift.

Read the full deep-dive with code examples, pricing math, and a decision flowchart on the original post: Claude Managed Agents vs Agent SDK on avinashsangle.com.