10 New Options Devs Must Know

1. Nested Sub-Brokers with 3-Degree Depth

How Layered Job Decomposition Works

Claude Code now helps hierarchical agent spawning the place a mum or dad agent can create baby brokers, and every baby can spawn its personal youngsters, as much as three ranges deep. This structure allows layered job decomposition for operations spanning a number of modules or recordsdata. A top-level agent dealing with a big codebase migration, for example, can delegate to module-level brokers, which in flip delegate to function-level brokers for focused rewrites. You possibly can assign every agent within the tree a definite function, mannequin, and constraint set, and every operates with its personal context window.

Configuration and Implementation

Outline the hierarchy in .claude/brokers.yaml:

max_depth: 3
brokers:
  - agent_role: migration_coordinator
    description: "Prime-level agent for Python 2 to three migration"
    mannequin: claude-sonnet-4
    delegate_to:
      - agent_role: module_migrator
        description: "Handles per-module migration duties"
        mannequin: claude-sonnet-4
        delegate_to:
          - agent_role: function_refactorer
            description: "Rewrites particular person capabilities for Python 3 compatibility"
            mannequin: claude-haiku

Invoke the top-level agent and observe the delegation chain in actual time:

claude agent run migration_coordinator --verbose-agents

The --verbose-agents flag outputs every time one agent delegates to a different, together with which baby agent it spawned, what function it assigned, and the duty fragment it obtained. That is important for debugging hierarchies the place failures at decrease ranges might be troublesome to hint with out structured visibility.

You possibly can assign every agent within the tree a definite function, mannequin, and constraint set, and every operates with its personal context window.

2. fallbackModel Configuration

Setting Up Mannequin Fallback Chains

Price limits, transient mannequin outages, and price administration all create eventualities the place a single mannequin goal is inadequate. The fallbackModel configuration addresses this by permitting an ordered record of fashions that Claude Code makes an attempt sequentially. If the first mannequin returns a rate-limit error or is unavailable, Claude Code mechanically tries the subsequent mannequin within the chain.

Sensible Configuration

Save the next as .claude/settings.json:

{
  "mannequin": "claude-sonnet-4",
  "fallbackModel": [
    {
      "model": "claude-haiku",
      "maxTokens": 4096,
      "costCeiling": 0.25
    },
    {
      "model": "local/codellama-34b",
      "maxTokens": 4096,
      "costCeiling": 0.00,
      "timeoutSeconds": 30
    }
  ]
}

The fallbackModel array ought to record solely different fashions. Don’t repeat the first mannequin as a fallback entry, since a mannequin that has already failed as a result of a price restrict or outage is not going to succeed on instant retry. Every entry helps per-model maxTokens and costCeiling parameters, providing you with per-model limits on output dimension and spend because the system falls by means of the chain. The costCeiling parameter units the utmost spend (as a numeric greenback quantity) allowed on that mannequin earlier than advancing to the subsequent fallback. The native mannequin choice with a zero value ceiling serves as a last-resort fallback that ensures availability.

Native mannequin assist: The native/ prefix requires a working native inference server (e.g., Ollama). Configure the endpoint in your Claude Code settings earlier than utilizing native/-prefixed fashions. And not using a working inference server, this fallback entry will fail.

Searching, Putting in, and Publishing Instruments

Skip this part in case your group restricts third-party device set up. For everybody else: {the marketplace} is a registry of community-contributed Claude Code instruments, together with linters, formatters, customized slash instructions, and specialised refactoring utilities. It operates by means of the CLI:

claude market search "react"



claude market set up @group/react-refactor


claude market publish

⚠️ Safety discover: Confirm your authentication credentials earlier than publishing (claude auth standing). Neighborhood-published instruments usually are not reviewed or assured by Anthropic. Earlier than putting in group instruments, evaluation the device’s supply and permissions. Train the identical warning you’ll with any third-party bundle from a public registry.

The publish command walks by means of a guided movement that packages the device definition, validates its manifest, and submits it to the registry. You possibly can invoke put in instruments as slash instructions or agent-callable instruments inside the present undertaking.

4. Utilization Attribution and Price Monitoring

Per-Agent and Per-Job Price Breakdown

The brand new --attribution flag generates an in depth .claude/attribution.json file after every session, breaking down token utilization, value, and mannequin choice by sub-agent, job, and timestamp. For groups billing AI utilization to particular tasks or purchasers, this gives the granularity wanted for correct chargebacks.

Studying Attribution Studies

The next is an illustrative instance. Precise value values will differ based mostly on present Anthropic pricing for every mannequin tier:

{
  "schema_version": "1.0",
  "session_id": "ses_550e8400-e29b-41d4-a716-446655440000",
  "total_cost": 0.87,
  "total_tokens": 142350,
  "brokers": [
    {
      "agent_role": "migration_coordinator",
      "model": "claude-sonnet-4",
      "tokens_in": 12000,
      "tokens_out": 4500,
      "cost": 0.12,
      "timestamp": "2026-06-18T14:22:01Z",
      "tasks": ["coordinate migration plan"]
    },
    {
      "agent_role": "module_migrator",
      "mannequin": "claude-sonnet-4",
      "tokens_in": 85000,
      "tokens_out": 32000,
      "value": 0.63,
      "timestamp": "2026-06-18T14:23:15Z",
      "duties": ["migrate auth module", "migrate payments module"]
    },
    {
      "agent_role": "function_refactorer",
      "mannequin": "claude-haiku",
      "tokens_in": 6500,
      "tokens_out": 2350,
      "value": 0.12,
      "timestamp": "2026-06-18T14:25:44Z",
      "duties": ["refactor parse_token()", "refactor validate_session()"]
    }
  ]
}

Immediate tokens (tokens_in) and completion tokens (tokens_out) are tracked individually, which issues as a result of pricing differs between the 2. Every duties array ties prices to particular work items, so you’ll be able to spot a subtask that consumed, say, over half the session’s whole value and examine why. Price values are saved as numeric varieties (e.g., 0.87) for direct programmatic consumption with out string parsing.

5. Scoped Permissions for Sub-Brokers

Precept of Least Privilege in Agent Bushes

Now you can limit baby brokers to particular directories, instruments, and write capabilities. This prevents a function-level refactoring agent from by accident modifying configuration recordsdata or invoking harmful instruments outdoors its meant scope.

- agent_role: function_refactorer
  mannequin: claude-haiku
  permissions:
    allow_paths:
      - "${PROJECT_ROOT}/src/utils"
    deny_tools:
      - shell_execute
      - file_delete
    can_write: true

The allow_paths discipline restricts the agent’s file system entry. Use ${PROJECT_ROOT} to anchor paths to the undertaking root (the listing containing .claude/), making certain paths resolve to absolute canonical areas and can’t escape the meant scope by way of .. segments or symlinks. The deny_tools array explicitly blocks particular instruments even when they’re globally obtainable. Device names should match the identifiers listed in claude instruments record. Setting can_write: false creates a read-only agent helpful for evaluation or evaluation duties.

⚠️ Warning: Sub-agents with can_write: true and broad allow_paths values can modify recordsdata throughout their whole permitted scope. Scope paths as narrowly as doable, particularly in configurations the place brokers function throughout a number of repositories.

6. Streaming Agent Logs

Beta function. Conduct and schema might change in future releases. Not really useful for manufacturing pipelines with out pinning your CLI model.

Pipe real-time, structured JSON logs from all lively sub-agents into monitoring dashboards, CI/CD techniques, or log aggregation platforms utilizing the --stream-logs flag.

(Requires jq: brew set up jq / apt set up jq)

claude agent run migration_coordinator --stream-logs 
  | jq 'choose((.agent_level | tonumber) <= 2 and .standing == "error")'

Every log line is a JSON object containing fields for agent_role, agent_level, standing, message, and timestamp. The jq filter above makes use of tonumber to soundly coerce agent_level (which can be emitted as a string) earlier than comparability, and narrows output to errors from the highest two ranges of the agent tree. That is helpful for surfacing important failures with out drowning in verbose output from leaf brokers.

7. Agent Checkpointing and Resume

Beta function. Conduct and schema might change in future releases. Not really useful for manufacturing pipelines with out pinning your CLI model.

Saving and Restoring Agent State Mid-Job

This function is distinct from session persistence. Session persistence saves dialog historical past. Agent checkpointing moreover saves all the agent tree state, together with every sub-agent’s progress, intermediate outputs, and pending job queue. This enables a multi-hour migration to be paused and resumed with out restarting from scratch.

claude checkpoint save migration-v2



claude checkpoint resume migration-v2

The checkpoint contains the pending job queue, so resumed periods proceed precisely the place they left off moderately than re-evaluating accomplished work.

Vital: If recordsdata modified by the agent tree have modified externally for the reason that checkpoint was saved, evaluation the variations earlier than resuming to keep away from conflicts with stale intermediate state. Checkpoint recordsdata might comprise delicate intermediate outputs (code fragments, token context). Add the checkpoint storage listing to .gitignore and limit listing permissions (e.g., chmod 700) to keep away from committing or exposing this knowledge.

8. Inline Price Budgets per Agent

Arduous greenback or token caps might be set on particular person sub-agents to stop runaway prices. When a funds is exceeded, the agent halts and stories an error to its mum or dad.

- agent_role: function_refactorer
  mannequin: claude-haiku
  funds:
    max_cost: 0.50
    max_tokens: 50000

When exceeded, the output reads: Error: Agent 'function_refactorer' exceeded funds. Used $0.51 of $0.50 restrict. Escalating to mum or dad agent. The mum or dad agent can then resolve whether or not to allocate further funds, reassign the duty, or abort. The max_cost worth is a naked numeric greenback quantity (not a string). Use 0.50 moderately than "$0.50" to make sure the CLI appropriately enforces the funds cap.

9. Customized Agent Templates

You possibly can pre-define reusable agent configurations as templates, encapsulating function, mannequin, permissions, and funds right into a single file invocable by identify. Templates are saved in a templates/ listing on the undertaking root, and the templates_dir key in brokers.yaml should level to this listing for --template to resolve appropriately. Use ${PROJECT_ROOT}/templates to make sure right decision no matter working listing.

agent_role: code_reviewer
description: "Evaluations code for model, bugs, and safety points"
mannequin: claude-sonnet-4
permissions:
  can_write: false
  deny_tools:
    - shell_execute
funds:
  max_cost: 0.25
  max_tokens: 30000

Run from the undertaking root the place templates/ exists. The --template flag accepts the bottom filename with out extension:

claude agent run --template code-reviewer

This resolves to ./templates/code-reviewer.yaml. Templates standardize agent habits throughout groups and tasks, stopping inconsistencies like mismatched funds caps or permission scopes when a number of builders outline comparable brokers independently.

10. Multi-Repo Orchestration

Beta function. Conduct and schema might change in future releases. Not really useful for manufacturing pipelines with out pinning your CLI model.

Sub-agents can now function throughout a number of native repositories inside a single session. This allows cross-repo duties like synchronized dependency updates, API contract validation, or coordinated model bumps.

brokers:
  - agent_role: dependency_updater
    mannequin: claude-sonnet-4
    repos:
      - "${PROJECT_ROOT}/../frontend-app"
      - "${PROJECT_ROOT}/../backend-api"
      - "${PROJECT_ROOT}/../shared-libs"
    duties:
      - "Replace axios to 1.8.0 throughout all repos and repair breaking adjustments"

The repos array accepts ${PROJECT_ROOT}-relative paths to sibling directories. All listed repos should exist on the specified paths earlier than invocation; lacking paths will trigger an error. Every sub-agent features file system entry scoped to the listed repositories, and the mum or dad agent can coordinate adjustments that span repository boundaries.

⚠️ Warning: Multi-repo brokers with write entry can modify recordsdata throughout all listed repositories concurrently. Take a look at on copies or branches of your repositories earlier than working harmful or large-scale operations.

Placing It All Collectively: Full Configuration Reference

A mixed configuration utilizing all 10 options:

Save the next as .claude/settings.json:

{
  "mannequin": "claude-sonnet-4",
  "fallbackModel": [
    {
      "model": "claude-haiku",
      "maxTokens": 4096,
      "costCeiling": 0.25
    }
  ]
}

max_depth: 3
templates_dir: "${PROJECT_ROOT}/templates"
brokers:
  - agent_role: migration_coordinator
    mannequin: claude-sonnet-4
    funds:
      max_cost: 5.00
      max_tokens: 500000
    repos:
      - "${PROJECT_ROOT}/../backend-api"
      - "${PROJECT_ROOT}/../shared-libs"
    delegate_to:
      - agent_role: module_migrator
        mannequin: claude-sonnet-4
        funds:
          max_cost: 2.00
          max_tokens: 200000
        permissions:
          allow_paths:
            - "${PROJECT_ROOT}/src"
          deny_tools:
            - file_delete
          can_write: true
        delegate_to:
          - agent_role: function_refactorer
            mannequin: claude-haiku
            funds:
              max_cost: 0.50
              max_tokens: 50000
            permissions:
              allow_paths:
                - "${PROJECT_ROOT}/src/utils"
              deny_tools:
                - shell_execute
                - file_delete
              can_write: true

Solo builders ought to begin with fallback fashions and price budgets, which offer instant worth with out organizational overhead. Groups ought to prioritize utilization attribution and scoped permissions first, then layer in templates and multi-repo orchestration as workflow complexity grows.

Abstract and What’s Subsequent

The ten Claude Code June 2026 options lined right here:

• Nested sub-agents with as much as 3-level depth for layered job decomposition
• fallbackModel configuration for resilient mannequin chains
• Neighborhood device market for locating and sharing instruments
• Utilization attribution with per-agent, per-task value breakdowns
• Scoped permissions implementing least privilege on sub-agents
• Streaming agent logs for real-time structured monitoring (beta)
• Agent checkpointing for saving and resuming agent tree state (beta)
• Inline value budgets for per-agent spend caps
• Customized agent templates for reusable agent definitions
• Multi-repo orchestration for cross-repository duties (beta)

Nested sub-agents, fallback fashions, and {the marketplace} are typically obtainable as of the CLI 2026.6 launch prepare. Agent checkpointing, streaming logs, and multi-repo orchestration stay in beta, and their schemas and habits might change. Anthropic’s changelog tracks the newest standing of every function. For protection of the session persistence repair that preceded this batch, see SitePoint’s prior article on that matter.