Can sub-agents talk to each other directly?

No. The architecture is tree-shaped — sub-agents only talk to their parent. To "share state," go through the filesystem or an MCP-exposed intermediate store.

Do MCP servers slow the session down?

Depends on the implementation. Lightweight ones (GitHub API, local file search) are tens of milliseconds. Heavy ones (run an ML model, query a huge DB) extend tool-call wait time. Add timeouts to slow tools and surface that via a PreToolUse Hook.

Is prompt caching enabled on CodeGateway?

Yes. Any client going through the gateway gets transparent cache header propagation and the matching billing discount. Discounts follow Anthropic's official rules.

Is sharing a CI key safe across the team?

Per-repo with strict RPM and monthly spend caps, marginally. Across many teams and repos, it's an antipattern. One key per repo with failure / anomaly alerts on the key dimension.

Is Opus really 5x more expensive than Sonnet?

Roughly, per Anthropic's pricing page. But for tasks where Sonnet needs three iterations + redoes (multi-service architecture, complex DB migrations), one Opus pass can be cheaper. Decision rule: is the task ≥ 70% reasoning? If yes, Opus.

What happens when a Hook fails?

PreToolUse exit code 2 blocks the call; Claude Code sees the error and adjusts. PostToolUse failures don't block by default but the error feeds into context. Stop Hook failures don't block exit.

Multiple MCP servers at once?

Yes. List them all in .claude/mcp.json. Claude Code spawns them in parallel and namespaces tools to avoid name collisions.

What if a long task gets interrupted halfway?

Claude Code preserves session state by default. Re-launching claude resumes from the last checkpoint. Pair with a git commit per sub-task and resumption is essentially lossless. If you hit the 10-minute total-response ceiling at the gateway layer, see the connection timeout guide.

Advanced Claude Code: Sub-Agents, MCP, Cost

Loading…

Advanced Claude Code: Sub-Agents, MCP, Cost | CodeGateway

1) Single-layer fan-out
   Main
   ├── sub-A: grep + enumerate change targets
   ├── sub-B: apply backend edits
   ├── sub-C: apply frontend edits
   └── sub-D: run all tests, collect failures

2) Two-stage pipeline
   Main → sub-Planner (design) → sub-Builder (apply) → sub-Verifier (verify)

3) GAN-style adversarial loop
   Main
   ├── sub-Generator: produce implementation
   └── sub-Critic: critique, suggest improvements
   loop N rounds until Critic score crosses threshold

4) Fan-out with fan-in
   Main
   ├── sub-FrontEnd
   ├── sub-Backend
   ├── sub-DataPipeline
   └── Main writes the release notes once everyone reports back

text

# Inside an interactive session
/agents

# Tell the main agent in plain English
"Spawn one sub-agent to fix ESLint errors and another to compute test
coverage, run them in parallel"

# Inside a Skill template that bakes in scheduling
/skill multi-frontend

# Expose sub-agents as MCP tools so other systems can call them
(see next section)

bash

npm install -g @modelcontextprotocol/server-github

# .claude/mcp.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    }
  }
}

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  { name: "internal-billing", version: "0.1.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "get_customer_usage",
      description: "Query a customer's last-30-day token usage",
      inputSchema: {
        type: "object",
        properties: { customerId: { type: "string" } },
        required: ["customerId"],
      },
    },
  ],
}));

server.setRequestHandler("tools/call", async (req) => {
  const { name, arguments: args } = req.params;
  if (name === "get_customer_usage") {
    const usage = await queryUsage(args.customerId);
    return { content: [{ type: "text", text: JSON.stringify(usage) }] };
  }
});

await server.connect(new StdioServerTransport());

Scenario	Pattern
Team wiki search	Wrap as MCP, main agent retrieves on demand
Customer attribution	MCP + DB connection, query as needed
Cross-product release sync	MCP orchestrates GitHub / Slack / Linear
Internal LLM routing	MCP wraps specialist models, route by task

bash

# Reject Edit calls that try to write outside the project directory
node -e "
let d='';process.stdin.on('data',c=>d+=c);
process.stdin.on('end',()=>{
  const i=JSON.parse(d);
  if(i.tool_input?.file_path && !i.tool_input.file_path.startsWith(process.cwd())){
    console.error('[Hook] cross-directory write rejected');
    process.exit(2);
  }
  console.log(d);
});
"

json

{
  "hooks": {
    "PostToolUse": [
      { "matcher": "Write|Edit", "command": "ruff check --fix \"$FILE_PATH\"" },
      { "matcher": "Write|Edit", "command": "ruff format \"$FILE_PATH\"" },
      { "matcher": "Write|Edit", "command": "mypy --quiet \"$FILE_PATH\" || true" }
    ]
  }
}

yaml

name: AI Code Review
on:
  pull_request:
    branches: [main]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { fetch-depth: 0 }
      - uses: actions/setup-node@v4
        with: { node-version: 20 }
      - run: npm install -g @anthropic-ai/claude-code
      - name: AI review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.CODEGATEWAY_KEY }}
          ANTHROPIC_BASE_URL: https://api.codegateway.dev
        run: |
          claude --print "Review the current git diff with CRITICAL/HIGH/MEDIUM/LOW labels. Output markdown to review.md"
      - name: Comment on PR
        run: gh pr comment ${{ github.event.pull_request.number }} -F review.md

Workload                          Model              Why
=========================================================
Architecture / DB migration       Opus              Single-shot deep reasoning
Daily refactor / generation       Sonnet            Balance + strong coding
Sub-agent / batch lint            Haiku             Cheap + sufficient
Tool-shaped tasks / OCR           Haiku             Cheap + fast
Long chain reasoning + cache      Sonnet + cache    Amortizes to near-zero

90-day cumulative spend	Markup
$0 – $10	1.5x
$10 – $50	1.4x
$50 – $200	1.3x
$200 – $500	1.2x
$500+	1.2x (floor, stable long-term)

yaml

# .claude/skills/cost-aware-llm/SKILL.md
---
name: cost-aware-llm-pipeline
description: Default main agent to Sonnet, sub-agents to Haiku. Switch to Opus only for multi-service architecture, DB migrations, or hard debugging.
---

Use case	Naming	Limits	Owner
Personal dev machine	`dev-<name>-<host>`	None	Owner
Main repo CI	`ci-<repo>`	RPM 60	Platform
Docs / demos	`demo-<scenario>`	RPM 30, $20/mo cap	Platform
Customer demo (temporary)	`tmp-<customer>-<date>`	Set expiry	Sales

Advanced Claude Code: Sub-Agents, MCP, and Cost Optimization

Advanced Claude Code: Sub-Agents, MCP, and Cost Optimization

Table of Contents

Multi-agent orchestration: from one agent to a team topology

Why spawn sub-agents at all?

Four topologies that actually show up

Four ways to invoke

Choosing models for sub-agents

MCP server integration: extending tools and data sources

What MCP is

Installing a public MCP server

Writing a custom MCP server

Where MCP fits

Advanced Hooks: intercept, mutate, compose

PreToolUse: mutate arguments

PostToolUse: chain quality gates

Stop hook: end-of-session safety net

Skill + Hook composition

Workflow automation: scripts, CI, scheduled jobs

Non-interactive: --print

CI integration (GitHub Actions example)

Scheduled jobs

Prompt cache and cost optimization

How prompt cache works

How Claude Code uses it

Practical advice

Model × workload cost cheatsheet

Tier markup and model routing strategy

CodeGateway tier markup recap

Driving the markup down

Model routing as a Skill

Observability: usage, spend, errors

Dashboard signals

Log filtering

Self-hosted metrics

Team practices: standardization and key governance

Commit your config

Key governance

Pre-PR checklist as a Skill

Real scenarios: four high-leverage engineering patterns

Pattern 1: long-document summarization and extraction

Pattern 2: cross-service refactor

Pattern 3: incident root-cause analysis

Pattern 4: cross-language port

FAQ

Related reading

Non-interactive: `--print`