800 articles
No matching articles.
Getting Started 12 articles
- What Is Claude 3P? A Plain-English ExplainerThe five-minute version: what "third-party platform" means and why it exists.
- 1P vs 3P: Two Ways to Buy Claude, ExplainedDirect from Anthropic or through your cloud provider — the trade-offs in plain terms.
- How to Choose Between Bedrock, Vertex AI, Foundry, and Claude Platform on AWSA decision framework based on the cloud you already run.
- Your First Claude Call on Amazon BedrockFrom AWS console to a working Python response in fifteen minutes.
- Your First Claude Call on Google Vertex AIEnable the model, authenticate with ADC, and get your first response.
- Your First Claude Call on Microsoft FoundryCreate a Foundry resource and call Claude from Python.
- Your First Call on Claude Platform on AWSAnthropic-operated, AWS-resident: workspace setup to first response.
- Opus, Sonnet, Haiku: Which Claude Model Does Your Business Need?Matching the three model tiers to real workloads and budgets.
- Why Model IDs Differ Across PlatformsThe anthropic. prefix on Bedrock, bare IDs everywhere else — and how to avoid confusion.
- Tokens 101: The Unit You're Actually Billed ForWhat a token is, roughly how many are in a page of text, and why it matters.
- The Claude 3P GlossaryTwenty-five terms — from inference to prompt caching — decoded for non-specialists.
- A One-Week Proof of Concept Plan for ClaudeDay-by-day plan to validate a use case without a big commitment.
Platform Deep Dives 13 articles
- Amazon Bedrock: The Complete Enterprise PrimerAccess model, IAM, quotas, and where Bedrock fits in an AWS estate.
- Google Vertex AI: The Complete Enterprise PrimerProjects, ADC, the global endpoint, and GCP-native governance.
- Microsoft Foundry: The Complete Enterprise PrimerResources, keys, beta features, and the Azure enterprise context.
- Claude Platform on AWS: Anthropic-Operated, AWS-ResidentThe newest option: same-day API parity inside your AWS boundary.
- Setting Up IAM Permissions for Claude on BedrockPractical least-privilege policies for dev, staging, and production.
- Application Default Credentials for Claude on Vertex AIHow ADC works and how to configure it for services and developers.
- Creating and Configuring a Foundry Resource for ClaudeResource, region, keys, and deployment settings step by step.
- Workspaces and SigV4: Authentication on Claude Platform on AWSWhat ANTHROPIC_AWS_WORKSPACE_ID does and how SigV4 signing works for you.
- Regions, the Global Endpoint, and Data Location BasicsWhat region choices mean for latency, availability, and residency.
- Quotas and Rate Limits: How Each Platform Meters ClaudeUnderstanding and raising the limits before launch day.
- The Feature Gaps: What Bedrock and Vertex Don't SupportBatch, Files, code execution, web tools — check this before you commit.
- Why Same-Day API Parity MattersNew Claude features land on Claude Platform on AWS the day they ship.
- Running Claude on Two Clouds: When Multi-Platform Makes SenseRedundancy, procurement leverage, and the real cost of abstraction.
Security & Compliance 13 articles
- Where Does Your Data Go? Claude 3P Data Flow BasicsWhat leaves your network, what's retained, and what to verify.
- Compliance Inheritance: Using Your Cloud's CertificationsHow running Claude inside your cloud simplifies audits — and what it doesn't cover.
- Least-Privilege Access for Claude: A Practical PatternScoping model access by team, environment, and use case.
- Keeping API Keys and Credentials Out of Your CodeSecret managers, workload identity, and rotation basics.
- Audit Logging Claude UsageCloudTrail, Cloud Audit Logs, and building an answerable usage record.
- Private Networking: Keeping Claude Traffic Off the Public InternetPrivate endpoints and network controls per platform.
- Data Residency Questions Your Legal Team Will AskFraming region choice, processing location, and retention honestly.
- Prompt Injection 101 for Enterprise TeamsThe attack every LLM app owner should understand, with defenses.
- Handling PII in Claude RequestsMinimization, redaction, and review patterns that keep privacy teams comfortable.
- The Security Review: What Your CISO Will AskThe ten questions security teams raise about Claude — with good answers.
- From Shadow AI to Sanctioned AIEmployees are already using LLMs; here's how to make it safe instead of forbidden.
- Writing an Internal Acceptable-Use Policy for ClaudeA template of what to allow, restrict, and log.
- When Something Goes Wrong: Incident Response for LLM AppsRunbooks for bad outputs, leaked prompts, and quota exhaustion.
Cost & Operations 12 articles
- Claude 3P Pricing, Explained Like a Utility BillInput tokens, output tokens, and how a request becomes a line item.
- Estimating Your Monthly Claude Bill Before You CommitA worksheet method: volume × tokens × price, with worked examples.
- Prompt Caching: The Single Biggest Cost LeverReusing long prompts can cut costs dramatically — here's how it works.
- Cutting Costs with Model TieringRoute routine work to Haiku, escalate hard cases to Opus.
- Committed-Use Discounts Through Your Cloud ProviderList price is the starting point; commitments are negotiated with your cloud.
- Setting Up Cost Alerts and Budgets for Claude WorkloadsTagging, budgets, and alerts so the bill is never a surprise.
- Retries, Timeouts, and Fallbacks: Production Resilience BasicsHandling rate limits and transient errors without duplicating work.
- Observability for Claude Apps: What to Log and WatchLatency, token usage, error rates, and output quality signals.
- Capacity Planning: Throughput, Quotas, and Peak LoadSizing quotas for launch and seasonal spikes.
- Version Pinning: Why "Latest" Is Not a Deployment StrategyPin model versions, test upgrades, roll forward deliberately.
- Streaming Responses: Better UX and Fewer TimeoutsWhy streaming is the default for anything long.
- FinOps for LLMs: Making Claude Spend AccountableShowback, unit economics, and per-feature cost attribution.
Industry Use Cases 13 articles
- Claude for Financial ServicesDocument review, client communications, and analysis inside a regulated boundary.
- Claude for Healthcare OrganizationsAdministrative relief and documentation support, with privacy front and center.
- Claude for InsuranceClaims summarization, policy Q&A, and underwriting support patterns.
- Claude for Retail and E-CommerceProduct content, customer service, and catalog operations at scale.
- Claude for ManufacturingMaintenance documentation, quality reports, and supplier communications.
- Claude for Legal Teams and Law FirmsFirst-draft review and research assistance — with the lawyer in charge.
- Claude for Education InstitutionsAdministrative workflows, content development, and responsible student-facing use.
- Claude for Government and Public SectorCitizen services and document processing within public-cloud compliance regimes.
- Claude for Logistics and Supply ChainShipment exception handling, documentation, and partner communications.
- Claude for Real EstateListing content, lease abstraction, and tenant communications.
- Claude for Media and PublishingResearch assistance, metadata, and localization — without replacing the newsroom.
- Claude for Hospitality and TravelGuest communications, review responses, and itinerary support.
- Claude for Professional Services FirmsProposals, deliverables, and knowledge reuse in consulting and accounting.
Business Function Use Cases 12 articles
- Building a Customer Support Assistant with ClaudeDeflect the routine tickets, escalate the rest — a reference design.
- Document Processing: Contracts, Invoices, and FormsExtraction and summarization pipelines with vision and structured outputs.
- An Internal Knowledge Assistant Your Employees Will UseGrounding Claude in your wiki, drive, and policies.
- Claude for Sales TeamsCall notes, CRM hygiene, and proposal drafts that start at 80%.
- Marketing Content Workflows with Human ReviewBriefs in, drafts out, humans approve — a workflow that scales.
- Claude for HR and RecruitingJob descriptions, policy Q&A, and screening support — minus the bias traps.
- Claude for Engineering TeamsCode review, documentation, migration help, and internal tooling.
- Natural-Language Data Analysis for Business TeamsLetting non-analysts ask data questions safely.
- Meeting Notes and Action Items, AutomatedTranscripts in, decisions and owners out.
- Translation and Localization at Enterprise ScaleConsistent tone across markets with terminology control.
- Automated Report Generation with GuardrailsWeekly reports drafted by Claude, verified by templates and checks.
- Email and Ticket Triage: Classification That Pays for ItselfThe unglamorous use case with the fastest payback.
Architecture & Integration 13 articles
- Tool Use 101: Letting Claude Call Your SystemsHow tool use works and why it's the foundation of useful LLM apps.
- RAG Basics: Grounding Claude in Your DocumentsRetrieval-augmented generation explained without the hype.
- Agents vs. Workflows: Choosing the Right Amount of AutonomyMost business problems are workflows; here's how to tell.
- Structured Outputs: Getting JSON You Can Actually ParseSchema-constrained responses for system-to-system integration.
- Vision: Processing Images, Screenshots, and Scanned DocumentsWhat Claude can read beyond plain text.
- Adaptive Thinking: When to Let Claude Reason LongerHarder problems benefit from more reasoning — and it's on all platforms.
- Prompt Engineering for Business ApplicationsSystem prompts, examples, and instructions that survive contact with users.
- Evaluating LLM Features: Test Before You TrustBuilding eval sets so quality is measured, not vibes.
- Human-in-the-Loop Design: Where People Stay in ChargeReview gates, confidence thresholds, and escalation paths.
- The Internal AI Gateway PatternOne internal door for all LLM traffic: auth, logging, cost attribution.
- Batch vs. Real-Time: Matching Workloads to the Right ModeOvernight jobs vs. interactive apps — and where Batch API is (and isn't) available.
- Making Sense of 1M-Token Context WindowsWhat fits in a million tokens and what it costs to use it.
- Beyond Python: SDK Options for Your Engineering StackOfficial SDKs exist for Python, TypeScript/JavaScript, Java, Go, Ruby, C#, and PHP.
Migration & Adoption 12 articles
- From Pilot to Production: A 90-Day Rollout PlanThe phases, gates, and staffing between demo and dependable.
- Migrating from the Anthropic API to a Cloud PlatformWhat changes (auth, client class, model IDs) and what doesn't.
- Switching Clouds: Porting Claude Workloads Between PlatformsThe SDK keeps most code identical; here's the checklist for the rest.
- Coming from Another LLM Provider: What ChangesAPI shape, prompting differences, and how to run a fair comparison.
- Upgrading Model Versions Without Breaking ProductionEval-gated upgrades and staged rollouts.
- Build vs. Buy: Custom Claude App or Off-the-Shelf Product?When a vendor tool wins and when your own integration wins.
- Skilling Up Your Team: Roles You Need (and Don't)You probably don't need ML engineers; you do need good product owners.
- Change Management: Getting Employees to Actually Use AITraining, champions, and measuring adoption honestly.
- Working with Procurement and Legal: A Field GuideMarketplace terms, DPAs, and who signs what.
- Measuring ROI on LLM Projects: Metrics That MatterTime saved, deflection rates, quality deltas — and what to ignore.
- The 10 Most Common Claude 3P MistakesThe failure patterns we see repeatedly, and the cheap fixes.
- The Executive FAQ: Questions Boards Ask About ClaudeCost, risk, jobs, vendors — direct answers for leadership.
Amazon Bedrock in Practice 50 articles
- Requesting Claude Model Access in the Bedrock ConsoleHow to navigate the AWS console to enable Claude model access in your account before your first API call.
- Using the Bedrock Console Playground for Prompt PrototypingTest system prompts, compare models, and validate response formats in the browser before writing any code.
- Multi-Account Bedrock Setup with AWS OrganizationsStructure model access, Service Control Policies, and resource sharing for Claude across an enterprise AWS organization.
- Cross-Region Inference Profiles: How Bedrock Routes Traffic for Higher ThroughputHow AWS-managed inference profiles distribute requests across regions to increase effective quota capacity.
- Creating Application Inference Profiles on BedrockBuild custom inference profiles that target specific regions and track costs separately from the AWS-managed defaults.
- Resource-Based Policies for Cross-Account Bedrock AccessWhen and how to use resource-based policies to grant cross-account principals access to Claude on Bedrock.
- IAM Service Roles for Lambda, ECS, and EC2 Calling BedrockAttaching the right execution roles to compute resources that invoke Claude, with least-privilege policy examples.
- Using SCPs to Restrict Bedrock Use Across AWS AccountsService Control Policies that enforce which accounts, regions, and Claude model versions may be invoked organization-wide.
- Cross-Account Bedrock Calls via IAM Role AssumptionHow to use STS AssumeRole to invoke Bedrock in a central account from workloads running in other accounts.
- Fine-Grained Access Control with Bedrock IAM Condition KeysUsing bedrock:ModelId and related condition keys to restrict which specific Claude models a principal may call.
- InvokeModel in Depth: Request Structure for Claude on BedrockThe exact JSON body, content-type headers, and endpoint path required for raw InvokeModel calls to Claude.
- The Converse API in Depth: Messages, Roles, and Tool ResultsStructuring multi-turn conversation history, system prompts, and tool result blocks with the Converse API.
- InvokeModel vs Converse: Which Bedrock API Should You UseA decision guide comparing the raw InvokeModel endpoint with the higher-level Converse API for Claude workloads.
- Setting Up Boto3 for Bedrock: From Install to First ResponseInstalling and configuring the AWS Python SDK for Bedrock, including the credential chain and region configuration.
- Calling Bedrock from Node.js with AWS SDK v3Configuring @aws-sdk/client-bedrock-runtime, sending a Converse request, and processing the response in TypeScript.
- Calling Bedrock from Java with the AWS SDK v2Setting up the BedrockRuntimeClient in Java and making synchronous and asynchronous InvokeModel calls.
- Streaming Claude Responses via the Converse Stream APIHow to use ConverseStream in Bedrock to receive token-by-token output for lower perceived latency in user-facing apps.
- Streaming with InvokeModelWithResponseStreamParsing the chunked Server-Sent Event stream from InvokeModelWithResponseStream for real-time Claude output.
- Implementing Tool Use via the Bedrock Converse APIDefining tools, handling ToolUse content blocks, and returning ToolResult blocks in a Converse conversation loop.
- Sending Images to Claude via the Bedrock APIHow to base64-encode images and embed them in InvokeModel and Converse request payloads for Claude's vision models.
- System Prompt Placement in Bedrock Request FormatsWhere the system field lives in InvokeModel versus Converse payloads and how each placement affects Claude's behavior.
- Choosing Regions for Cross-Region Inference ProfilesWhich region combinations Bedrock supports, how to designate a home region, and latency versus throughput trade-offs.
- Designing High-Availability Failover with Cross-Region Inference ProfilesUsing inference profiles as a built-in failover mechanism so a single-region disruption does not take down your Claude app.
- Bedrock Quota Dimensions: RPM, TPM, and Concurrent Request LimitsA guide to every quota type Bedrock enforces for Claude models and which dimension typically constrains production workloads first.
- How to Request and Track a Bedrock Service Quota IncreaseSubmitting a quota increase through the Service Quotas console, setting lead-time expectations, and planning around approval delays.
- Handling ThrottlingException: Retry Logic for Bedrock WorkloadsRecognizing ThrottlingException and ServiceQuotaExceededException and implementing exponential backoff with jitter correctly.
- Provisioned Throughput for Claude on Bedrock: What It Is and When to BuyHow Provisioned Throughput differs from on-demand invocations, how to size a commitment, and how to attach it to requests.
- Auditing Bedrock API Calls with AWS CloudTrailWhich management and data plane events Bedrock emits to CloudTrail and how to query them for security and access audits.
- CloudWatch Metrics for Bedrock: What to Monitor and WhyThe built-in invocation, latency, and token metrics Bedrock publishes to CloudWatch and how to build an operational dashboard.
- Enabling Bedrock Model Invocation LoggingHow to turn on full request and response logging to S3 or CloudWatch Logs for debugging, auditing, and compliance requirements.
- CloudWatch Alarms and Metric Filters for Bedrock MonitoringCreating alerts on Bedrock error rates, throttle counts, and token consumption spikes using CloudWatch Alarms and metric filters.
- Cost Allocation Tags for Bedrock Claude UsageTagging strategies that break Claude costs down by team, application, and environment in AWS Cost Explorer.
- Connecting to Bedrock via AWS PrivateLinkCreating a VPC interface endpoint for the Bedrock runtime service so all inference traffic stays inside the AWS network.
- Writing VPC Endpoint Policies for BedrockRestricting which IAM principals and which Claude models are reachable through your Bedrock PrivateLink endpoint.
- Network-Layer Security Controls for Bedrock AccessSecurity groups, NACLs, and VPC Flow Logs relevant to controlling and auditing Bedrock traffic originating from your VPC.
- Amazon Bedrock Guardrails: Capabilities and When to Use ThemA plain-English overview of content filtering, topic denial, and sensitive data redaction in Amazon Bedrock Guardrails.
- Creating and Attaching a Bedrock Guardrail Step by StepHow to create a guardrail in the console, configure its policies, and reference it in InvokeModel or Converse API calls.
- Content Filtering Policies in Bedrock GuardrailsConfiguring violence, hate speech, sexual content, and prompt-attack filters at the guardrail level with adjustable strength settings.
- Topic Denial: Blocking Off-Limits Subjects with Bedrock GuardrailsDefining denied topics so Claude declines to engage with specific subject areas regardless of how the prompt is worded.
- PII Detection and Redaction with Bedrock GuardrailsUsing guardrail sensitive-information policies to identify and mask personal data in Claude prompts and responses.
- Testing and Tuning Bedrock Guardrails Before Go-LiveHow to evaluate guardrail coverage, measure false positive rates, and adjust thresholds using the console testing tool.
- Replacing the Batch API on Bedrock with SQS and LambdaBuilding an async high-volume processing pattern with SQS queues, Lambda workers, and DynamoDB job tracking when Batch API is unavailable.
- Working Without the Files API on Bedrock: Document Handling PatternsPassing document content inline in request bodies or staging files in S3 when the Anthropic Files API is not supported on Bedrock.
- Adding Live Web Search to Claude on Bedrock Without Built-In Web ToolsImplementing search-augmented generation using Claude tool use and a self-managed search backend as a Bedrock-compatible alternative.
- Using Anthropic Prompt Caching via the Bedrock APIHow to set cache_control breakpoints in Bedrock request payloads to reduce latency and cost on repeated long-prefix prompts.
- Enabling Extended Thinking for Claude on BedrockHow to configure thinking budget tokens in a Bedrock InvokeModel or Converse request body to activate Claude's extended reasoning.
- Anthropic API Features on Bedrock: A Reference Availability MatrixA structured table mapping Anthropic API capabilities — prompt caching, extended thinking, vision, tool use — to their current Bedrock support status.
- Analyzing Claude Costs in AWS Cost ExplorerFiltering Cost Explorer by the Bedrock service, usage-type dimension, and resource tags to understand and attribute Claude spend.
- How Bedrock Claude Charges Appear on Your AWS InvoiceDecoding the usage-type codes and line items that represent Claude input and output token charges on an AWS monthly bill.
- Bedrock Error Reference: Causes and Fixes for Common ExceptionsA troubleshooting guide for AccessDeniedException, ValidationException, ThrottlingException, and ModelNotReadyException with actionable remediation steps.
Google Vertex AI in Practice 50 articles
- Enabling Claude in Vertex AI Model GardenHow to locate Claude models in Model Garden, accept publisher terms, and confirm access before writing any code.
- Service Account Authentication for Production Claude WorkloadsCreating a dedicated service account, binding the right IAM roles, and choosing between key JSON and impersonation.
- Vertex AI IAM Roles for Claude: What Each Role Grantsaiplatform.user, aiplatform.viewer, and custom roles — mapping permissions to developer, CI, and production job functions.
- Global Endpoint vs Regional Endpoints: A Decision GuideWhen to use the globally routed endpoint versus pinning to a specific region for latency, residency, and quota isolation.
- GCP Project Preflight Checklist for Claude on Vertex AIAPIs to enable, billing account requirements, and org policy gotchas that block first calls.
- Vertex AI Quota Types for Claude: RPM, TPM, and BeyondRequests-per-minute, tokens-per-minute, and how project-level versus model-level quotas interact.
- Requesting a Quota Increase for Claude on Vertex AIWhen to request, how to estimate required headroom, and the GCP Console workflow for submitting increases.
- Provisioned Throughput on Vertex AI: Commitment, Cost, and When It Pays OffHow dedicated throughput reservations work, minimum purchase sizes, and a break-even analysis against on-demand pricing.
- Cloud Audit Logs for Claude: Admin Activity vs Data AccessEnabling the right log types, understanding what each captures, and writing Log Explorer queries for compliance review.
- VPC Service Controls: Confining Claude Calls to Your PerimeterDesigning a service perimeter that includes Vertex AI, testing in dry-run mode, and enforcing without breaking ADC flows.
- Using the AnthropicVertex Python SDK End to Endpip install, client initialization with project and region, and the differences from the direct anthropic.Anthropic client.
- Calling Claude on Vertex AI from Node.jsInstalling @anthropic-ai/sdk, constructing a VertexAI-authenticated client, and handling responses in TypeScript.
- Calling Claude on Vertex AI from JavaMaven coordinates, credential setup via Application Default Credentials, and a minimal synchronous request example.
- No Batch API on Vertex: Patterns for High-Volume Async JobsUsing Cloud Run Jobs, Pub/Sub fan-out, and client-side rate-limited queues as substitutes for the missing Batch API.
- No Files API on Vertex: Sending Documents Without Persistent File IDsEncoding documents inline in requests, cost implications of repeated full-payload sends, and Cloud Storage as a staging layer.
- Web Search on Vertex AI: Google Grounding vs Direct API ToolsWhat the Grounding with Google Search feature offers on Vertex, how it differs from the tools available on the direct API, and configuration steps.
- No Code Execution Tool on Vertex: How to Fill the GapRouting computational tasks through tool use, Cloud Functions, or client-side evaluation when the code execution tool is unavailable.
- Reading Your Vertex AI Claude Bill in GCP BillingIdentifying Claude line items in the GCP Billing console, understanding SKU names, and setting up a cost table view by model.
- Resource Labels for Claude Cost Attribution on Vertex AIAdding request labels per team or feature, exporting Billing data to BigQuery, and querying cost by label.
- Common Errors When Calling Claude on Vertex AI and How to Fix ThemA reference for PERMISSION_DENIED, RESOURCE_EXHAUSTED, INVALID_ARGUMENT, and FAILED_PRECONDITION with root causes and resolutions.
- Diagnosing 403 PERMISSION_DENIED on Vertex AIThe four root causes — wrong IAM role, unenabled API, wrong project ID, and stale ADC credentials — and how to pinpoint each.
- Handling 429 RESOURCE_EXHAUSTED: Backoff and Rate LimitingImplementing exponential backoff, client-side token bucket rate limiting, and when to request quota increases versus redesign.
- Vertex AI Model ID Format and Stable Version PinningThe publishers/anthropic/models/... path format, the difference between @latest and pinned aliases, and how to track deprecation notices.
- Sending Images to Claude via Vertex AIInline base64 encoding versus Cloud Storage URI references for images, supported formats, file size limits, and cost implications.
- Handling Large Payloads and Long Context Windows on Vertex AIRequest size ceilings, chunking strategies for oversized inputs, and using Cloud Storage URIs to avoid payload bloat.
- Streaming Claude Responses on Vertex AIEnabling server-sent events with the AnthropicVertex client, handling stream events in Python and Node, and timeout configuration.
- Prompt Caching on Vertex AI: Setup and Token SavingsHow to enable caching headers on Vertex AI requests, minimum cacheable token thresholds, and measuring cache-hit savings.
- Extended Thinking on Vertex AI: Enabling Budget TokensHow to request extended thinking, setting the thinking budget, latency and cost implications, and when the feature is worth the cost.
- Tool Use with Claude on Vertex AIDefining tool schemas, parsing tool_use content blocks, and implementing the multi-turn tool result loop with the AnthropicVertex client.
- System Prompt Patterns for Vertex AI Enterprise DeploymentsStructuring system prompts for consistent role, tone, and safety boundaries across teams using a shared Vertex AI project.
- GCP Org Policies That Block Vertex AI Claude RequestsIdentifying constraints.gcp.disableCloudLogging, restrictCloudRunRegion, and similar policies that silently block or limit Vertex usage.
- Workload Identity Federation for Claude on GKEBinding Kubernetes service accounts to GCP IAM to eliminate static service account keys in containerized Claude workloads.
- Deploying a Claude Application on Cloud Run with Vertex AIContainerizing the AnthropicVertex client, injecting credentials via Workload Identity, configuring concurrency, and scaling to zero.
- Cloud Functions as Lightweight Claude Invocation TriggersUsing Cloud Functions (2nd gen) to invoke Claude on Vertex from HTTP or Pub/Sub events without managing a server.
- Private Service Connect for Vertex AI Claude TrafficRouting Vertex AI requests through a private IP so traffic never leaves your VPC boundary, with setup walkthrough.
- Customer-Managed Encryption Keys and Vertex AI Claude CallsWhat CMEK covers for Vertex AI, what it does not protect (in-flight inference), and how to configure it for at-rest resources.
- Exporting Vertex AI Audit Logs to BigQuery for Long-Term RetentionCreating a log sink, the BigQuery schema for audit events, and sample queries for per-caller usage forensics.
- Claude Model Versions on Vertex AI: Availability and DeprecationHow Anthropic and Google coordinate model version releases, what end-of-life notices look like, and how to build a version upgrade workflow.
- EU Data Residency with Claude on Vertex AIChoosing europe-west4 or other EU regions, the processing location guarantee, and what the regional endpoint does and does not restrict.
- Context Caching on Vertex AI: Feature Availability and UsageWhether the Anthropic context caching feature is available on Vertex AI, configuration differences from the direct API, and token accounting.
- Migrating from anthropic.Anthropic to AnthropicVertex in PythonThe exact lines that change — client class, constructor arguments, model ID format — and the lines that stay identical.
- Production Error Handling for Vertex AI Calls in PythonCatching google.api_core.exceptions and anthropic.APIStatusError, structuring retry logic, and emitting structured error logs.
- Security Command Center Findings for Vertex AI WorkloadsWhich SCC finding categories apply to Vertex AI usage, how to triage them, and which require remediation versus acceptance.
- Scoping GCP Budget Alerts to Vertex AI Claude SpendCreating a budget filtered to the Vertex AI service with forecast-based and actual-spend thresholds and alert notification channels.
- Local Development Workflow for Claude on Vertex AIUsing gcloud auth application-default login for local testing versus service account impersonation in CI and production environments.
- Access Transparency Logs: Visibility into Google Operator ActionsEnabling Access Transparency for Vertex AI, reading log entries that record Google operator access, and what they do not capture.
- Calling Vertex AI Claude from a Browser via a ProxyWhy direct browser-to-Vertex calls are insecure, and the Cloud Run or API Gateway proxy pattern that keeps credentials server-side.
- Multi-Region Failover Strategies for Vertex AI Claude WorkloadsUsing the global endpoint for automatic routing, implementing a manual regional fallback, and testing failover behavior.
- Counting Tokens Before Sending on Vertex AIUsing the countTokens API endpoint to estimate request cost, avoid oversized payloads, and gate requests at runtime.
- Cloud Audit Log Query Cookbook for Claude Usage ForensicsPractical Log Explorer and BigQuery SQL queries to answer who called Claude, from which service account, when, and at what scale.
Microsoft Foundry in Practice 50 articles
- Deploying Claude Models in Foundry: Versions, Aliases, and UpdatesStep-by-step guide to creating, naming, and updating model deployments inside a Foundry resource.
- Managing API Keys in Microsoft FoundryHow to create, scope, rotate, and revoke API keys from the Foundry portal.
- Authenticating with Microsoft Entra ID Instead of API KeysToken-based auth via Entra ID — how to skip API keys for workloads already inside Azure.
- Using the Anthropic SDK with Foundry in PythonConfiguring the AzureAnthropic client: base URL, credential setup, and first completion.
- Using the Anthropic SDK with Foundry in TypeScriptNode.js patterns for calling Claude through Foundry using the official Anthropic SDK.
- Calling Claude on Foundry from .NET and C#Client configuration and request patterns for .NET applications using the Anthropic SDK.
- Calling Claude on Foundry from JavaSetting up the Anthropic Java SDK for Foundry and integrating it with Spring Boot.
- Choosing an Azure Region for FoundryWhich regions support Claude on Foundry, how region choice affects latency, and what data-residency statements to expect.
- Understanding Foundry Quota Types: TPM, RPM, and Request LimitsThe different quota dimensions on Foundry, how they interact, and how to read your current consumption.
- Requesting a Quota Increase for Claude on FoundryThe official process for raising TPM and RPM limits, including what information to provide and typical timelines.
- Configuring Content Filters in Azure AI FoundryEnabling, disabling, and adjusting the built-in content filter policies that sit in front of Claude.
- Building Custom Content Filter Policies for FoundryCreating annotated filter configurations tailored to your industry's sensitivity requirements.
- Setting Up Private Endpoints for FoundryKeeping all Claude traffic inside your Azure virtual network using Azure Private Link.
- Virtual Network Integration for Foundry ResourcesNetwork topology options for Foundry — peering, hub-and-spoke, and inbound-only restrictions.
- NSG Rules for Foundry Private Endpoint TrafficThe Network Security Group rules you need (and don't need) when routing Foundry traffic through a private endpoint.
- Role-Based Access Control for Foundry ResourcesThe Azure built-in roles that grant model inference versus resource management, and how to assign them.
- Using Managed Identity to Call Foundry From Azure ServicesSystem-assigned and user-assigned managed identity setup for App Service, AKS, and Azure Functions.
- Storing and Retrieving Foundry API Keys with Azure Key VaultReferencing Key Vault secrets in app config so plaintext keys never appear in code or environment files.
- Enforcing Foundry Configuration Standards with Azure PolicyWriting and assigning policy definitions that audit or deny non-compliant Foundry resource settings.
- Conditional Access Policies for Foundry API AccessUsing Entra ID Conditional Access to restrict which identities and devices can call the Foundry endpoint.
- Analyzing Foundry Spending with Azure Cost ManagementFiltering Cost Analysis to Foundry resources, reading the meter names, and spotting unexpected charges.
- Setting Budget Alerts for Claude Spending in AzureCreating resource-group and subscription budgets that notify you before costs reach a threshold.
- Tagging Foundry Resources for Cost AttributionTag strategies that let you allocate Claude costs to teams, projects, and environments in billing reports.
- How Azure Marketplace Billing Works for FoundryHow Foundry usage flows through the Azure Marketplace meter, appears on your invoice, and relates to EA or MCA agreements.
- Committed Throughput vs. Pay-As-You-Go on FoundryWhen to provision a committed throughput unit, how to size it, and the break-even calculation.
- Monitoring Foundry With Azure MonitorWhich metrics Foundry emits to Azure Monitor, how to build dashboards, and what thresholds to alert on.
- Enabling Diagnostic Logs for FoundryTurning on diagnostic settings, choosing a destination, and understanding what each log category captures.
- Querying Foundry Logs in Log AnalyticsWriting KQL queries to analyze token usage, latency, error rates, and content-filter hits from Foundry logs.
- Beta Feature Caveats on Microsoft FoundryWhat "preview" means on Azure, which Foundry capabilities carry beta-stage limitations, and how to track GA announcements.
- Foundry vs. Direct API: The Current Feature GapTracking what the Anthropic API supports that Foundry doesn't yet — batch, Files API, newer tools — and when to expect each.
- Prompt Caching on Foundry: What's AvailableHow to enable and verify prompt caching for Foundry deployments and what caching behavior to expect.
- Streaming Responses from Claude on FoundryConfiguring SSE streaming in the Anthropic SDK against a Foundry endpoint, including timeout and retry considerations.
- Using Claude Tool Use on FoundryDefining tools, invoking them, and handling tool_use blocks within the Foundry request/response cycle.
- Processing Images with Claude on FoundrySending image content in messages — formats, size limits, and encoding patterns for Foundry deployments.
- Getting Structured JSON from Claude on FoundryPrompting strategies and schema enforcement techniques for system-to-system integration via Foundry.
- Handling Rate Limits and Throttling on FoundryReading 429 responses, implementing exponential backoff, and surfacing quota pressure to operators.
- Foundry-Specific Error Codes and TroubleshootingThe HTTP and application error codes returned by Foundry and how to resolve each one.
- Model Version Pinning and Upgrades in FoundryCreating versioned deployments, testing an upgrade in staging, and swapping production traffic safely.
- Deploying Foundry Resources with ARM Templates and BicepInfrastructure-as-code templates for repeatable, auditable Foundry resource creation.
- Managing Foundry Resources with TerraformUsing the AzureRM Terraform provider to create, update, and destroy Foundry resources as code.
- Integrating Foundry Deployments into Azure DevOps PipelinesAutomating deployment and configuration of Foundry resources as part of a CI/CD process.
- Calling Foundry Claude from Azure FunctionsConfiguring identity, dependencies, and the Anthropic SDK inside an Azure Functions host.
- Connecting Foundry to Azure Logic AppsUsing Logic Apps HTTP actions to invoke Foundry Claude and wire it into no-code automation flows.
- Running Foundry Calls from AKS with Workload IdentityBinding a Kubernetes service account to an Entra ID managed identity for credential-free Foundry access.
- Putting Azure API Management in Front of FoundryUsing APIM as a proxy: auth delegation, rate-limit policies, and controlled developer access to Foundry.
- Multi-Region Foundry Deployments for ResilienceDeploying Claude across two Azure regions, routing traffic with Traffic Manager, and handling failover.
- Azure Responsible AI Standards Applied to FoundryHow Microsoft's Responsible AI framework manifests in Foundry controls and what it requires of your application layer.
- Azure Support Plans for Foundry: What You Get at Each TierComparing Developer, Standard, and Premier support response times and coverage for Foundry incidents.
- Azure Service Limits That Affect Foundry at ScaleSubscription-level limits on deployments, keys, and resources that can surprise teams after early prototypes.
- Disaster Recovery Planning for Foundry-Dependent ApplicationsRTO/RPO thinking, regional failover patterns, and what Foundry's own availability commitments cover.
Claude Platform on AWS in Practice 50 articles
- Creating, Renaming, and Deleting WorkspacesThe full lifecycle of a Claude Platform on AWS workspace: provisioning via the Anthropic console, updating display names, and safe deletion without losing billing history.
- Multi-Workspace Strategy: Dev, Staging, and ProductionHow to structure workspaces across environments, why one workspace per production application is the recommended pattern, and how to propagate the right ANTHROPIC_AWS_WORKSPACE_ID per environment.
- The Credential Chain: How Claude Platform on AWS Resolves AWS CredentialsThe exact resolution order — environment variables, EC2 instance metadata, ECS task role, shared credentials file, SSO — and which source wins when multiple are present.
- SigV4 Under the Hood: What the SDK Signs for YouWhich HTTP headers SigV4 adds to every Claude Platform request, why you never write them manually, and how to diagnose SignatureDoesNotMatch errors in development.
- Claude Platform IAM Actions: The Full ReferenceEvery anthropic: IAM action the platform exposes, what operation each permits, and how to scope them by resource ARN in a deny-by-default account.
- Copy-Paste IAM Policies for Claude Platform on AWSReady-to-use read-only, write, and admin policy documents with inline comments explaining each statement, suitable for attaching to roles or permission boundaries.
- Short-Term Credentials: STS AssumeRole for Claude PlatformHow to request temporary tokens with a configurable TTL, why they reduce blast radius compared with long-lived keys, and how the Anthropic SDK picks them up automatically.
- Workload Identity Federation on Claude Platform on AWSFederate GitHub Actions, GitLab CI, or an external IdP to AWS IAM so no static secrets are needed to authenticate against Claude Platform on AWS.
- Using EC2 Instance Roles with Claude Platform on AWSAttach an IAM role to your instance; the AWS credential chain delivers it to the SDK automatically — zero key management and automatic rotation.
- IRSA: Per-Pod IAM Roles for Kubernetes WorkloadsMap Kubernetes service accounts to IAM roles with IAM Roles for Service Accounts so each pod gets scoped Claude Platform access without node-level over-permission.
- Calling Claude Platform on AWS from LambdaAssign the function an execution role, set ANTHROPIC_AWS_WORKSPACE_ID in the environment, and size timeouts to accommodate streaming — a complete working pattern.
- ECS Fargate Task Roles for Claude PlatformScope Claude access at the task level so containers inherit only the permissions they need, with no secrets injected into the task definition.
- Using the Batch API on Claude Platform on AWSSubmit asynchronous message batches, poll for completion, and retrieve results — the full Batch API workflow running inside your AWS boundary with same-day parity.
- The Files API on Claude Platform on AWSUpload files once, reference them by ID across multiple requests, and delete them when done — reducing payload size for repeated large-context workloads.
- Code Execution Tool on Claude Platform on AWSEnable the sandboxed Python execution tool, understand what Claude can and cannot access in the sandbox, and retrieve generated files from the response.
- Web Tools on Claude Platform on AWSGrant Claude live web-search access via the built-in web tool, control when it fires, and understand what data leaves your boundary during a web-tool call.
- Managed Agents on Claude Platform on AWSInvoke Anthropic's hosted agent runtime through the platform, pass tool definitions, and handle multi-turn agent loops without managing orchestration infrastructure yourself.
- Extended Thinking on Claude Platform on AWSEnable the extended_thinking parameter on Claude Platform, understand the additional token cost, and decide which workloads benefit from deeper reasoning.
- Available Regions for Claude Platform on AWSWhich AWS regions currently host Claude Platform on AWS, how to select the right region for latency and data-location requirements, and how to check the current availability list.
- Claude Platform on AWS vs. Amazon Bedrock: The Decision GuideFeature parity, authentication model, billing path, operational control, and the four questions that reliably determine which option fits your workload.
- How Billing Works: Claude Platform Charges on Your AWS InvoiceHow the Anthropic-operated platform appears as a consolidated AWS Marketplace line item, what the charge breakdown looks like, and how to reconcile it against token usage.
- Cost Allocation Tags for Claude Platform on AWSApply AWS cost allocation tags to workspace-level usage so finance can attribute Claude costs to teams, products, or cost centers without a separate billing system.
- Viewing Claude Platform Costs in AWS Cost ExplorerSelect the correct service filter, group by tag or workspace, set budget alert thresholds, and export usage data for chargebacks.
- Subscribing to Claude Platform on AWS via AWS MarketplaceWalk through the Marketplace subscription flow, accept vendor terms, link your Anthropic workspace to your AWS account, and confirm consolidated billing is active.
- Python SDK Setup for Claude Platform on AWSInstall the anthropic package with the aws extra, set ANTHROPIC_AWS_WORKSPACE_ID and AWS_REGION, choose the right client class, and send a verified test request.
- TypeScript and Node.js Setup for Claude Platform on AWSInstall the npm package, configure the AnthropicBedrock client for Claude Platform, handle async streaming with TypeScript types, and validate the setup end to end.
- Java SDK Setup for Claude Platform on AWSAdd the Maven dependency, configure the credential provider chain, instantiate the synchronous client, and run a minimal working example against your workspace.
- Environment Variable Reference for Claude Platform on AWSA single reference table: ANTHROPIC_AWS_WORKSPACE_ID, AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN, AWS_PROFILE — what each does and which the SDK reads first.
- Cross-Account Access: Calling Claude Platform from Another AWS AccountSet up an AssumeRole trust policy so a workload in account A can call Claude Platform whose IAM resources live in account B — useful for centralized-AI-access patterns.
- Private VPC Endpoint for Claude Platform on AWSConfigure an interface VPC endpoint so Claude Platform API traffic routes through AWS PrivateLink and never traverses the public internet.
- CloudTrail Logging for Claude Platform on AWSWhich API calls appear in CloudTrail, how to filter for anthropic: events, and which fields to alert on for security monitoring and compliance evidence.
- Credential Rotation for Claude Platform on AWSRotate IAM access keys with zero downtime using the dual-key pattern, automate rotation via Secrets Manager, and verify the new credential works before deactivating the old one.
- Migrating a Bedrock Application to Claude Platform on AWSThe four code changes — client class, auth method, model ID format, and endpoint — with before-and-after examples and a test checklist to confirm equivalence.
- Migrating from the Direct Anthropic API to Claude Platform on AWSWhat changes when moving from api.anthropic.com to the AWS-resident platform: client class, SigV4 instead of API key header, workspace ID, and what stays identical.
- Prompt Caching on Claude Platform on AWSAdd cache_control breakpoints to long system prompts, verify cache hits via the response's usage fields, and calculate the cost reduction for your workload.
- Streaming Responses on Claude Platform on AWSUse server-sent events with the platform client, handle partial content_block_delta chunks, implement back-pressure for slow consumers, and test timeout resilience.
- Error Codes and Retries on Claude Platform on AWSHTTP 429 rate-limit errors, 529 overload signals, and 5xx faults: what each means, how the SDK retries automatically, and when to add your own backoff.
- Quota Management on Claude Platform on AWSDefault token-per-minute and request-per-minute limits, how to request increases through the Anthropic console, and how to design headroom into your traffic model.
- Token Counting Before You SendCall the count_tokens endpoint to estimate cost and detect context-window overflow before committing to a full inference request — especially useful for RAG pipelines.
- Vision and Multimodal Requests on Claude Platform on AWSSend images as base64-encoded content blocks or Files API references, understand supported formats and size limits, and handle mixed text-and-image prompts correctly.
- Tool Use on Claude Platform on AWSDefine tools in the API request, detect tool_use stop reasons, execute the tool locally, and return tool_result blocks in the follow-up turn — a complete production loop.
- Structured JSON Outputs on Claude Platform on AWSEnforce a schema by wrapping it in a tool definition, validate the parsed response against the schema in application code, and handle malformed-output edge cases gracefully.
- System Prompt Management Across WorkspacesStore versioned system prompts in S3 or Parameter Store, load them at request time, and tie prompt versions to application releases so rollbacks are clean.
- Claude Platform on AWS in CI/CD PipelinesUse OIDC federation in GitHub Actions or AWS CodeBuild to assume a scoped IAM role so no long-lived secrets enter your pipeline and Claude access is auditable per run.
- Terraform for Claude Platform on AWSManage IAM roles, permission policies, Secrets Manager entries, and VPC endpoint resources as code — with example modules and a plan for environment promotion.
- Workspace Isolation: What It Gives You and What It Does NotHow workspaces scope API access and billing, why they are not a substitute for application-layer tenant isolation, and what additional controls to add for multi-tenant apps.
- Checking Claude Platform Availability Before You LaunchRead the Anthropic status page, probe the regional endpoint in your startup sequence, and implement a health-check pattern that degrades gracefully when the platform is unavailable.
- Feature-Flag Rollout Using Claude Platform on AWSGate new Claude capabilities behind feature flags, combine flags with workspace-level access control for staged rollouts, and measure impact before enabling broadly.
- Observability for Claude Platform on AWS WorkloadsEmit structured logs with request ID and token counts, publish latency and error-rate metrics to CloudWatch, and build a dashboard that surfaces cost and quality signals together.
- Compliance Patterns for Claude Platform on AWSMap CloudTrail events, IAM access reviews, and workspace policies to SOC 2 and ISO 27001 controls — with the evidence artifacts each audit control requires.
API Features & Capabilities 50 articles
- Messages API Anatomy: Requests, Responses, and the Body You Actually SendEvery field in the request object and response object decoded — model, messages, system, max_tokens, stop_sequences, and what comes back.
- System Prompts: The Contract Between Your App and ClaudeHow the system field works, where it sits in the token budget, and patterns for writing durable system prompts for enterprise apps.
- Multi-Turn Conversations: Managing the Messages ArrayHow the alternating user/assistant array models a conversation, what happens when you append turns, and where history management goes wrong.
- Streaming Event Types: Every SSE Block Explainedmessage_start, content_block_start, content_block_delta, message_delta, message_stop — what each carries and how to assemble them into a complete response.
- Thinking Budgets and Effort Levels: Controlling Extended Reasoning CostThe budget_tokens parameter, effort levels, and how to tune reasoning depth versus latency and cost without overshooting.
- Prompt Cache Mechanics: cache_control, 5-Minute and 1-Hour TTLsWhere to place cache_control breakpoints, how the two TTL tiers behave, and what counts as a cache hit on each platform.
- The Token Counting Endpoint: Pre-Flight Cost EstimatesUsing the count_tokens endpoint before sending a request to gate on budget, surface surprises, and build cost-aware dispatch logic.
- Message Batches API: Submitting, Polling, and Retrieving Bulk JobsThe full batch lifecycle — creating a batch, polling for completion, streaming results, and handling per-request errors inside a batch run.
- The Files API: Uploading and Reusing Documents Across RequestsUploading files once and referencing them by ID across many requests — availability, size limits, and lifecycle management.
- PDF Support: Sending Multi-Page Documents to ClaudeHow to attach PDFs, how Claude handles page layout and embedded images, and size limits across Claude Platform on AWS and other platforms.
- Image Inputs: Formats, Size Limits, Base64 vs URLSupported MIME types, dimension and file-size constraints, when to use base64 versus URL source, and cost differences between image sizes.
- Citations: Getting Claude to Reference Its Sources in Structured FormThe citations feature — enabling it, the structure of citation objects in the response, and how to render them in downstream UIs or audit trails.
- Strict Tool Use: Enforcing Schema-Valid Tool CallsHow Claude validates tool inputs against JSON Schema, what strict mode adds, and how to write schemas that eliminate invalid argument shapes.
- Stop Reasons: Decoding end_turn, max_tokens, stop_sequence, and tool_useWhat each stop_reason value means for your application logic and how to branch on it correctly in production code.
- Error Codes: The Full Taxonomy and What to Do With EachEvery 4xx and 5xx error, when it's retryable, and the right client-side response to invalid_request_error, authentication_error, overloaded_error, and friends.
- Rate Limit Headers: Reading X-RateLimit-* to Adapt in Real TimeThe full set of rate limit response headers — requests, tokens, input tokens — and how to build adaptive back-off logic that reads them.
- 1M-Token Context: Loading, Ordering, and Navigating Large InputsPractical strategies for filling a million-token window — document ordering, needle placement, and cost management when context is huge.
- Context Compaction: Automatic Summarization When Windows Fill UpHow the compaction feature works, when it triggers, what you lose, and how to configure it or opt out of automatic summarization.
- Context Editing: Surgically Removing or Replacing Messages Mid-ConversationTechniques for modifying the messages array between turns — redacting sensitive content, trimming stale context, and injecting tool results correctly.
- The Bash Tool: Letting Claude Execute Shell Commands SafelyHow the built-in bash tool works, its security model, operator permissions, and when it's available versus when you need a custom tool.
- The Text Editor Tool: Line-Level File Edits with Undo SemanticsThe text_editor_20250429 tool — view, str_replace, create, undo_edit commands and how Claude uses them to make targeted code changes.
- The Memory Tool: Persistent Facts Across SessionsHow the memory tool lets Claude read and write a persistent fact store, what it stores, and how to scope memory to a user or workspace.
- Computer Use: Driving GUIs with Claude's Vision-and-Action LoopThe computer_use_20250124 tool — screenshot, click, type, scroll actions and how to scaffold a safe execution environment around them.
- Code Execution: Running Python in a Sandboxed EnvironmentThe code execution tool, its sandboxed Python runtime, output capture, and how to pass data in and retrieve structured results out.
- The Web Search Tool: Live Internet Queries Inside a ConversationHow the built-in web_search tool works, how to control the number of results, and availability differences across Claude Platform on AWS and 3P platforms.
- The Web Fetch Tool: Retrieving and Parsing Specific URLsUsing web_fetch to pull a known URL into context — response size limits, content-type handling, and when to prefer fetch over search.
- Tool Search: Surfacing the Right Tool from a Large Tool RegistryHow Claude selects tools when you pass dozens of definitions, and how to structure tool metadata so the right one is chosen reliably.
- Programmatic Tool Calling: Processing tool_use Blocks in Your CodeThe client-side loop — extracting tool_use content blocks, dispatching to your functions, and returning tool_result blocks correctly.
- Skills: Reusable Prompt Bundles That Extend Claude's BehaviorWhat Skills are, how they are defined and referenced, and how they differ from raw system prompt text for enterprise prompt governance.
- The MCP Connector: Wiring Model Context Protocol Servers to ClaudeHow the built-in MCP connector lets Claude call external MCP servers, the configuration format, and authentication options.
- Managed Agents: Session Lifecycle and Turn ManagementHow managed agent sessions are created, how turns are submitted, what happens between turns, and how sessions are closed or expire.
- Agent Environments: Sandboxed Compute for Long-Running TasksThe environment abstraction in Managed Agents — what runs in one, how files and state persist inside a session, and teardown behavior.
- Agent Vaults: Secure Secret Storage for Autonomous TasksHow vaults give agents access to secrets without exposing them in prompts — creation, binding to a session, and rotation.
- Agent Webhooks: Event Notifications From Running AgentsSetting up webhook endpoints to receive turn-complete, agent-stopped, and error events from long-running managed agent sessions.
- The Models API: Listing Available Models ProgrammaticallyThe /v1/models endpoint — what it returns, how to filter by capability, and how to use it to build model-selection logic that stays current.
- Model Deprecation: Timelines, Notices, and How to MigrateHow Anthropic announces deprecations, typical timelines, what happens on the cutoff date, and a version-pinning strategy that makes upgrades deliberate.
- The Metadata Field: Tagging Requests for Tracing and AttributionUsing the metadata.user_id and custom fields to tie API calls back to your internal users, sessions, and features for audit and cost attribution.
- Setting max_tokens: Output Caps, Defaults, and the Truncation RiskHow max_tokens interacts with the model's own output length, what happens when the limit is hit, and how to set it without silently truncating responses.
- Temperature and Top-P: Tuning Output Randomness for Business UseWhen determinism beats creativity, how temperature and top_p interact, and recommended settings for classification, extraction, and generation tasks.
- tool_choice: Forcing, Disabling, or Delegating Tool SelectionThe three tool_choice modes — auto, any, tool — what each does, and patterns for forcing a specific tool call in structured workflows.
- Parallel Tool Calls: Handling Multiple Simultaneous tool_use BlocksHow Claude can return multiple tool_use blocks in one turn, how to execute them concurrently, and how to return all results in the next user turn.
- Streaming With Tool Use: Assembling Partial tool_use Blocks From SSE EventsHow tool input arrives incrementally in content_block_delta events and how to buffer and parse it before dispatching to your functions.
- Content Blocks: Text, Image, Tool Use, and Tool Result in One RequestThe content array structure — how to mix block types in a single turn, the rules for what can appear where, and nested content in tool results.
- Multimodal Turns: Mixing Text, Images, and Documents in the Messages ArrayHow to combine text, image_url, base64 images, and file references in a single user turn and what the model sees for each type.
- Cache Read vs Write Tokens: Understanding the Two-Token Pricing SplitHow cached token reads are priced differently from cache write tokens, what shows up in usage objects, and how to track cache efficiency.
- Input vs Output Tokens: Why Output Costs More and How to Minimize ItThe pricing asymmetry, how to measure your input-to-output ratio, and techniques to reduce output volume without losing quality.
- Server-Sent Events: Connecting, Reconnecting, and Parsing the StreamThe SSE protocol mechanics — headers, data lines, event types, reconnection with Last-Event-ID, and library choices by language.
- Batch API Platform Availability: Where Batches Work and Where They Don'tWhich platforms support the Message Batches API today, what the workarounds are on Bedrock and Vertex, and how to write code that degrades gracefully.
- Tool Result Errors: Returning Failure State to Claude GracefullyHow to set is_error on a tool_result block, what Claude does with error content, and patterns for letting the model self-correct after a failed tool call.
- Conversation History Sizing: Trimming the Messages Array Without Losing CoherenceStrategies for keeping multi-turn history within budget — sliding windows, selective summarization, and pinning critical turns at the top.
SDKs & Developer Experience 50 articles
- Python SDK Quickstart: Install, Configure, and First CallFrom `pip install anthropic` to a working API response using the official Python SDK.
- TypeScript and JavaScript SDK QuickstartInstall the npm package, create a typed client, and call Claude from Node.js or Deno.
- Java SDK Quickstart: Maven, Gradle, and First RequestAdd the dependency, build the client, and handle a synchronous response in idiomatic Java.
- Go SDK Quickstart: Module Setup and First Request`go get`, client initialization, context handling, and a working end-to-end Go example.
- Ruby SDK Quickstart: Gem, Bundler, and First CallBundler setup, the `Anthropic::Client` class, and structured response handling in Ruby.
- C# SDK Quickstart: NuGet, Client Setup, and First ResponseInstall the NuGet package and make your first Claude call from a .NET application.
- PHP SDK Quickstart: Composer, Client, and First CallComposer setup, PSR-compatible HTTP, and calling Claude from a PHP application.
- Switching to AnthropicBedrock: Client Setup and ConfigurationHow `AnthropicBedrock()` differs from `Anthropic()` and what stays identical across languages.
- Switching to AnthropicVertex: Client Setup and Configuration`AnthropicVertex()` parameters, project and region, and how ADC credentials flow through the SDK.
- Using the SDK with Microsoft Azure AI FoundryConfiguring the SDK client for Foundry endpoints — base URL, authentication, and model identifiers.
- SDK Setup for Claude Platform on AWSConnecting the SDK to the Anthropic-operated, AWS-resident endpoint with SigV4 and workspace IDs.
- API Key Authentication in the SDK: Patterns and PitfallsWhere to set the key, which env var each SDK reads, and how to handle key rotation cleanly.
- OAuth and Browser-Based Login for Claude SDKsInteractive login flows, token refresh, and when OAuth is the right choice over static API keys.
- Workload Identity Federation: Keyless Auth for Cloud WorkloadsEliminate stored secrets with WIF on GCP and equivalent patterns on AWS and Azure.
- The Full List of SDK Environment VariablesEvery env var the official SDKs recognize, what each one overrides, and priority order.
- Configuring the SDK for Dev, Staging, and ProductionProfile-based config, dotenv patterns, and keeping environment-specific settings out of source code.
- Overriding the Base URL in the SDKPointing the SDK at a proxy, internal gateway, or local test server — and when this is useful.
- Configuring Retries in the SDKHow to set max retries, backoff strategy, and which HTTP error codes trigger automatic retries by default.
- Tuning Timeouts in the SDKConnection timeout, read timeout, and idle-timeout settings across the Python, TypeScript, and Java SDKs.
- Handling 429 Rate-Limit Errors in SDK CodeReading retry-after headers, implementing exponential backoff, and avoiding thundering-herd retries.
- Streaming Basics: The SDK Streaming APIHow streaming works at the protocol level and how the SDK wraps it with iterators and event callbacks.
- Streaming in TypeScript: Async Iterators and Event StreamsUsing `stream()`, async-for-of, and `.on('text')` listeners in the TypeScript SDK.
- Streaming to Browser Clients with Server-Sent EventsProxying SSE from your backend to the browser using the SDK's stream primitives.
- SDK Streaming Helpers: Accumulators, Finalizers, and Type SafetyThe SDK's built-in helpers for reassembling a complete message from a streaming response.
- Building a Tool-Calling Loop in PythonThe agentic loop pattern: call, inspect `tool_use` blocks, execute tools, and continue until done.
- Building a Tool-Calling Loop in TypeScriptTyped tool definitions, result injection, and loop termination strategies in TypeScript.
- Defining Tool Schemas in the SDKJSON Schema syntax, required vs optional parameters, and type mapping in each language's SDK.
- Orchestrating Multiple Tools in One Agentic LoopRouting tool calls, handling parallel invocations, and managing state across multi-turn agentic sessions.
- Mocking Claude API Calls in Unit TestsUsing SDK test utilities, monkey-patching, and HTTP intercept libraries to write fast, repeatable tests.
- Recording and Replaying API Responses for TestsThe VCR cassette pattern with vcrpy, nock, and language equivalents for deterministic Claude SDK tests.
- pytest Patterns for Claude SDK Integration TestsFixtures, parametrize, and asyncio mode for testing Claude-backed Python code with pytest.
- Jest Patterns for TypeScript Claude SDK TestsMock implementations, spy functions, and async testing strategies with Jest and Vitest.
- Injecting Claude Credentials into CI/CD PipelinesGitHub Actions secrets, GitLab CI variables, and Buildkite SSM integration for API keys and tokens.
- Using the Claude SDK in GitHub ActionsSetting up auth, installing dependencies, and calling Claude safely inside a CI/CD workflow.
- Containerizing Applications That Use the Claude SDKDockerfile patterns, runtime secret injection, and multi-stage builds for production SDK apps.
- Secrets Handling Patterns in SDK CodeLoading keys from AWS Secrets Manager, GCP Secret Manager, and Azure Key Vault instead of env files.
- Rotating API Keys Without DowntimeBlue-green key rotation, grace periods, and how to validate the new key before retiring the old one.
- Pinning SDK Versions and Managing Upgrade CyclesWhy locking to patch versions matters and how to automate safe dependency updates with Dependabot.
- Tracking SDK Changelogs and Breaking ChangesWhere to find SDK release notes, how to subscribe to updates, and reading the CHANGELOG effectively.
- Migrating Between Major SDK VersionsWhat typically breaks across major version bumps and a practical checklist for upgrading to the latest release.
- Raw HTTP vs SDK: When to Skip the Official LibraryThe tradeoffs, the request format, and the cases where curl or fetch is the more appropriate tool.
- Customizing the Underlying HTTP ClientInjecting custom transports, configuring certificate pinning, and setting proxy details in each SDK.
- Introduction to the ant CLIWhat the ant CLI is, how to install it, and the core command structure for developer workflows.
- Authenticating the ant CLILinking your API key or cloud provider credentials to the ant CLI for local development.
- Scripting with the ant CLI in Shell PipelinesPiping prompts, capturing structured output, and embedding ant calls in bash scripts and Makefiles.
- Listing and Switching Models with the ant CLIQuerying available models and switching between them without changing code during development.
- Async and Concurrent SDK Calls: asyncio, Promises, and goroutinesPatterns for making multiple simultaneous Claude calls efficiently across Python, TypeScript, and Go.
- Error Handling Patterns Across SDK LanguagesAPIError subclasses, HTTP status code semantics, and language-idiomatic error handling for each SDK.
- Logging SDK Requests for Debugging and AuditEnabling verbose request and response logging, redacting secrets, and emitting structured log output.
- Type Safety with the Claude SDK: TypeScript, Java, and C#How the SDKs surface response types, discriminated unions, and null-safety patterns in typed languages.
Prompt Engineering & Output Quality 50 articles
- Designing System Prompts That Hold Up in ProductionStructure, scope, and common failure modes for the instruction layer Claude always sees.
- Role Prompting: Giving Claude a Persona That Stays in CharacterWhen personas help, when they hurt, and how to write roles that produce consistent professional output.
- Few-Shot Examples: Teaching by DemonstrationHow carefully chosen input–output pairs reshape Claude's defaults — and why quality beats quantity.
- Structuring Prompts with XML TagsUsing named tags to organize instructions, context, and examples so Claude parses complex prompts reliably.
- Zero-Shot vs. Few-Shot: When to Provide ExamplesChoosing between pure instruction and demonstrated examples depending on task novelty and output sensitivity.
- Chain-of-Thought Prompting for Business TasksAsking Claude to show its reasoning to surface assumptions and catch errors before the answer lands.
- Controlling Output Length: From One-Liners to Full ReportsTechniques for getting Claude to stop early or go deep — and why word counts alone don't work.
- Tone and Style Control in PromptsShaping formality, voice, and vocabulary to match your brand or audience without losing accuracy.
- Multilingual Prompting: Getting Consistent Quality Across LanguagesInput language, instruction language, and output language — the triangle you need to manage explicitly.
- Building Reusable Prompt Templates for Business WorkflowsParameterizing prompts so teams can use them without touching the underlying engineering.
- Prompt Versioning: Treating Prompts Like CodeGit-backed prompt files, semantic versioning, and change-log discipline for production systems.
- Handling Long Documents in PromptsChunking, summarization ladders, and placement strategies when context windows run out.
- Reducing Hallucination Through Prompt DesignConstraining Claude to supplied context, hedging phrases, and refusal fallbacks to minimize confident errors.
- Asking Claude to Cite Its SourcesPrompt patterns that produce verifiable references — and how to audit what comes back.
- Building a Prompt Evaluation FrameworkCriteria, scorecards, and rubrics for judging prompt output systematically instead of by feel.
- A/B Testing Prompts in ProductionRunning parallel variants, choosing sample sizes, and interpreting results without overfitting.
- Regression Testing Prompts After Model UpgradesFreezing a golden-output set and detecting quality regressions before they reach users.
- Guardrail Prompts: Drawing Lines Around What Claude Will DoExplicit and implicit refusal constraints in system prompts for enterprise safety.
- Handling and Recovering from Claude RefusalsWhy Claude declines requests, how to diagnose the trigger, and how to restructure the prompt.
- Building a Prompt Library and Governance ProcessCentralizing, reviewing, and maintaining prompts across teams so good ones spread and bad ones retire.
- Prompt Patterns for Document SummarizationExtractive vs. abstractive, fixed vs. guided formats, and length calibration for business summaries.
- Prompt Patterns for Information ExtractionPulling structured fields from unstructured text: invoices, contracts, emails, and more.
- Prompt Patterns for Text ClassificationRouting, tagging, and sentiment — writing prompts that return consistent labels at scale.
- Prompt Patterns for Drafting Business ContentBriefs-in, drafts-out: the prompt structures behind emails, proposals, and reports.
- Prompt Patterns for Document Review and CritiqueGetting Claude to evaluate rather than generate — comparison, scoring, and gap-finding prompts.
- Persona vs. Instruction: Two Ways to Shape Claude's BehaviorChoosing between "you are a…" and explicit rules — trade-offs in predictability and scope.
- Writing Negative Instructions That Actually Work"Do not" clauses are tricky; here's how to frame them so Claude follows them reliably.
- Where You Put Context Changes the AnswerPlacement order — before vs. after instructions — and its effect on what Claude prioritizes.
- Temperature, Top-P, and When to Touch ThemWhat these parameters do to prompt output quality, and the conservative defaults that work for most enterprise tasks.
- Conditional Branching in PromptsIf-then instructions for handling multiple input types inside a single system prompt.
- Grounding Prompts for RAG ApplicationsThe instructions that tell Claude to stay inside retrieved context — and what to say when context is insufficient.
- Input Validation via Prompt DesignPrompting Claude to detect and handle malformed or out-of-scope user inputs before generating a response.
- Controlling Output Format: Markdown, Prose, Tables, and MoreExplicit format instructions and examples that keep output consistent across varied inputs.
- Asking Claude to Express Confidence and Hedge AppropriatelyInstructions for calibrated uncertainty — "I'm not sure," "based on the provided text" — in professional outputs.
- Iterative Prompt Refinement: A Systematic MethodThe loop of draft, test, diagnose, and fix that separates good prompts from great ones.
- Instruction Hierarchy: System, User, and Assistant TurnsHow Claude weighs conflicts between system-prompt rules and user requests — and how to use this deliberately.
- Prompting in Sensitive Domains: Legal, Medical, FinancialExtra guardrails, disclaimer patterns, and scope constraints for regulated industries.
- Designing Multi-Turn Conversations with System PromptsState handling, re-injection of context, and keeping behavior consistent across long sessions.
- Extraction to JSON via Prompt-Only TechniquesBefore reaching for tool use, these prompt patterns reliably return parseable JSON without schema enforcement.
- Prompting Claude to Decompose Complex TasksGetting Claude to break down a hard request before answering — useful for long-form and multi-step work.
- Why You Should Run Your Own Evals, Not Just Read BenchmarksPublished benchmark scores don't transfer to your task; here's how to generate the numbers that do.
- Format Sensitivity: How Small Wording Changes Move the NeedleWhy "summarize" and "write a summary of" produce different outputs, and how to control for it.
- Prompting Differences Across Haiku, Sonnet, and OpusThe same prompt doesn't behave identically across tiers — how to adapt instructions for the model you're routing to.
- Short Prompt vs. Long Prompt: When Brevity WinsThe diminishing returns of adding instructions and when a concise prompt outperforms a detailed one.
- Common Prompt Anti-Patterns and How to Fix ThemThe structural mistakes that produce inconsistent, verbose, or off-target outputs — and the fixes.
- Injecting Domain Glossaries into System PromptsTeaching Claude your industry's vocabulary to reduce misinterpretations in specialized fields.
- Prompting Claude to Critique Its Own OutputSelf-review loops — now evaluate what you just wrote against these criteria — and when they add value.
- Calibrating Output Quality to Downstream UseMatching detail level, register, and structure to whether output goes to an API, a human reader, or another AI step.
- Assessing the Impact of Prompt Changes Before DeploymentSide-by-side comparison methods and sample-set testing to catch surprises before a prompt goes live.
- Prompting for Graceful EscalationInstructions that make Claude hand off to a human — with context preserved — when it reaches the edge of what it should handle.
Enterprise Governance & Risk 50 articles
- Building an AI Governance Program from ScratchA practical structure for policy, ownership, and oversight that scales with your growing use-case portfolio — confirm scope with your provider and counsel before treating any structure as sufficient.
- Forming an AI Steering CommitteeWho belongs in the room, what decisions the committee owns, and how often to meet to keep governance current without creating bottlenecks.
- An Internal AI Use Policy Template for the EnterpriseThe sections every enterprise AI policy needs — scope, permitted uses, prohibited uses, and escalation paths — framed as a starting point you adapt with your legal team.
- AI Governance Maturity: A Four-Stage ProgressionHow to assess where your organization stands today and what concrete steps move you to the next stage of repeatable, auditable AI governance.
- Writing an AI Program CharterThe one-page document that scopes governance authority, names accountable owners, and establishes the escalation chain before anything reaches production.
- Model Risk Management Basics for LLM ApplicationsApplying the validation, documentation, and ongoing-monitoring concepts behind model risk frameworks to your Claude-powered systems — without substituting this for expert guidance.
- Validating a Claude-Powered Application Before LaunchThe pre-deployment review process: what questions to answer, what evidence to collect, and which stakeholders should sign off before users interact with the system.
- Building and Maintaining an AI Model InventoryTracking every Claude integration in a single registry: owner, use case, risk tier, last review date, and status — the minimum viable audit artifact.
- Risk-Tiering Your AI Use CasesA rubric for classifying use cases as high, medium, or low risk based on autonomy, audience sensitivity, and consequence of error — so review depth matches actual exposure.
- Managing Changes to Production AI ModelsWhat counts as a material change to a live AI system, when to re-validate, and how to version and document updates to system prompts, retrieval sources, and model versions.
- Department-Level AI Usage PoliciesWhy a single company-wide policy rarely fits every team and how to layer department-specific addenda without creating contradictions.
- AI Usage Guidelines for Finance TeamsExtra controls that fit treasury, regulatory reporting, and audit contexts: output-reliance limits, data restrictions, and mandatory review requirements.
- AI Usage Guidelines for HR and People TeamsGuardrails for recruiting, performance support, and employee-relations use cases where sensitive data and decision-influence warrant tighter oversight.
- AI Usage Guidelines for Legal TeamsPrivilege, confidentiality, and output-reliance rules that general counsel typically requires before legal staff use AI in client or matter work — confirm specifics with your GC.
- AI Usage Guidelines for Customer-Facing RolesWhat employees can and cannot delegate to Claude when the output reaches external parties: disclosure expectations, accuracy obligations, and escalation triggers.
- Designing an AI Use-Case Intake ProcessThe form and the funnel: how new ideas move from employee suggestion to risk assessment to approved deployment, with clear owners at each stage.
- Approval Gates for AI DeploymentsWhich functions — security, privacy, legal, business — sign off at which stage, and what evidence each gate requires before waving a deployment through.
- Handling Exceptions to AI PolicyWhen a genuine business need conflicts with a standing restriction, an auditable exception process is safer than informal workarounds — here is one to adapt.
- Fast-Track Reviews for Low-Risk AI Use CasesA lightweight approval path for clearly bounded, internal-only, non-sensitive applications so governance does not become a barrier to low-stakes experimentation.
- When AI Use-Case Changes Require a New ReviewThe signals — new data types, expanded user audiences, changed output destinations — that should reopen governance regardless of when the original approval was granted.
- Data Classification Before AI AdoptionMapping your existing data tiers to what you can and cannot send to Claude, so teams know the answer before they ask the question.
- Building a Data Sensitivity Matrix for AIA practical grid: data type crossed with AI use case, resulting in allowed, requires review, or prohibited — the tool that makes data policy actionable.
- Controlling What Data Enters AI PromptsUpstream filtering, masking, and access controls that prevent sensitive content from reaching the model in the first place.
- Controlling What Leaves AI ApplicationsFiltering, structuring, and logging model outputs before they reach end users or downstream systems — the complement to input controls.
- Retention and Deletion Practices for AI InteractionsWhat to keep, how long to keep it, and how to delete — covering prompt logs, responses, and trace data — consult your legal team for jurisdiction-specific obligations.
- Managing Prompt and Response LogsBalancing the debugging and audit value of detailed logs against privacy obligations and storage costs in a sustainable logging strategy.
- Vendor Risk Assessment for AI ProvidersThe due-diligence checklist when evaluating Claude via a cloud platform: subprocessors, security certifications, breach notification, and contractual protections to verify with your provider.
- Assessing Third-Party Products Built on ClaudeWhat to ask when a SaaS vendor runs Claude under the hood: data handling, model versioning, incident notification, and your obligations as a customer.
- AI Incident Playbooks: Beyond the Break-Fix RunbookScenario-specific response plans for harmful outputs, prompt-extraction attempts, data leakage signals, and model-version regressions — distinct from general IT incident response.
- Periodic Access Reviews for AI SystemsHow to audit who and what has access to your Claude integrations on a cadence, remove stale grants, and document the review for audit purposes.
- Creating Audit Trails for AI-Assisted DecisionsWhen and how to record that a Claude output influenced a business decision, what metadata to capture, and how long to retain the record — confirm retention obligations with your counsel.
- System Prompt Version ControlTreating system prompts as code: storing them in version control, requiring change review, and maintaining rollback capability so you can explain any production behavior.
- Documenting Your AI Evaluation ResultsKeeping a structured record of eval runs — test sets, metrics, pass/fail thresholds, reviewer sign-off — that satisfies both engineering needs and downstream audit questions.
- Designing Human Oversight Into AI SystemsArchitectural patterns for review gates, confidence thresholds, and mandatory escalation that keep humans accountable for consequential outputs.
- High-Stakes Output Review RequirementsWhich categories of AI output should require a human to read them before action is taken — and how to define "high-stakes" in a way your teams can apply consistently.
- Deciding What to Automate vs. Require Human ReviewA decision framework for balancing operational speed against accountability, using output type, audience impact, and reversibility as primary inputs.
- Red-Teaming Your LLM Application: A Defensive IntroductionWhat adversarial testing is, why it belongs in pre-launch review, how to scope a first exercise, and what to do with the findings — framed as defense, not offense.
- Scoping a Red Team Exercise for Enterprise AIDefining goals, participant roles, rules of engagement, and what counts as a reportable finding so exercises produce actionable results rather than anecdotes.
- Cataloguing Adversarial Prompt Patterns Your Team Should TestThe attack families — jailbreak attempts, indirect injection, role-play bypasses, exfiltration probes — that every LLM app team should exercise before shipping.
- Monitoring AI Applications for MisuseThe signals — query volume anomalies, output-type shifts, unusual user patterns — that warrant investigation, and how to build a lightweight detection layer.
- Usage Anomaly Detection for Claude WorkloadsHow to establish a baseline for normal usage across tokens, request patterns, and user behavior, then alert when deviations appear.
- Enforcing Content Policy in AI OutputsCombining automated checks, human-review sampling, and escalation paths so policy violations are caught and acted on consistently.
- Training Employees on AI RiskThe core concepts every staff member who uses Claude needs to internalize: what it can and cannot be trusted for, when to escalate, and what never to send.
- Building a Tiered AI Literacy ProgramAwareness training for all staff, deeper guidance for power users, and practitioner-level curriculum for teams building and maintaining AI systems.
- Evaluating AI Outputs for BiasA practical review process for identifying, documenting, and addressing disparity in model behavior across demographic groups or use-case subpopulations.
- Accessibility Considerations for AI-Powered FeaturesMaking Claude-assisted interfaces work for users with disabilities: output formatting, alternative interaction modes, and testing practices to build in from the start.
- Records Your Regulators May Ask ForA guide to the categories of documentation — risk assessments, validation results, change logs, incident records — that examiners commonly request, without claiming any set satisfies a specific requirement.
- Maintaining an Enterprise AI RegistryThe living record that tracks every AI use case, its owner, its risk tier, its last review, and its current status — the foundation of any governable AI program.
- Defining AI Roles: Owner, Reviewer, and OperatorClear role definitions — who is accountable for a use case, who reviews outputs, who operates the system — that close the gaps that auditors find.
- Sunsetting AI Features: A Decommissioning ChecklistHow to retire a Claude-powered feature without leaving orphaned data, stale system prompts, open access grants, or undocumented gaps in your AI registry.
Cost Optimization & FinOps 50 articles
- Anatomy of a Claude Token BillBreaking down every line item: prompt tokens, completion tokens, cache writes, and cache reads — what each one means and why it appears.
- Input Tokens vs. Output Tokens: The Asymmetric PriceWhy generating text costs several times more per token than reading it, and how to shift the ratio in your favor.
- Cache Write vs. Cache Read Pricing: The Break-Even MathWriting a cache entry costs more per token than a cache hit — the calculation that tells you how many reuses you need before caching pays off.
- The Batch API Price Discount: What It Is and Where It AppliesThe 50% discount for async batch jobs, which platforms support it today, and the latency trade-off you accept.
- Extended Thinking Token Budgets as a Cost ControlSetting per-request thinking budgets to cap reasoning spend without sacrificing answer quality on hard tasks.
- Output Length Budgeting: Setting max_tokens with IntentMatching max_tokens to what each task actually needs — classification tasks need tens, summaries need hundreds, not the model maximum.
- Right-Sizing max_tokens Endpoint by EndpointA task-by-task audit: which endpoints are over-allocated and the token savings from correcting each one.
- Context Strategy: Summarize vs. Full HistoryWhen compressing conversation history saves more than it costs in quality, and how to decide per use case.
- Image Token Costs: How Vision Inputs Are BilledThe pixel-and-tile formula that determines image token counts and how resizing before the API call cuts vision costs.
- PDF Token Costs: What Document Uploads Actually BillHow page count, resolution, and content density translate into token charges when using the Files API or base64 upload.
- Tool Call Token Overhead: The Hidden Cost of Agent LoopsSchema tokens, result injection tokens, and the per-turn overhead that accumulates across multi-step agent runs.
- AWS Billing Mechanics for Bedrock Claude WorkloadsHow Bedrock charges appear in Cost Explorer, which service and usage-type dimensions to filter on, and the tag strategy that makes attribution work.
- GCP Billing Mechanics for Vertex AI Claude WorkloadsBilling export to BigQuery, the SKU names to filter on, and label-based cost attribution for Vertex Claude usage.
- Azure Cost Management for Claude on Microsoft FoundryResource-level cost analysis views, budget alerts, and the meter names that correspond to Claude inference on Foundry.
- Billing Mechanics on Claude Platform on AWSHow Anthropic invoices through AWS Marketplace and how the charges appear alongside native AWS services in your Cost Explorer.
- Building a Chargeback Model for Claude UsagePer-team and per-product cost attribution from API token logs to internal invoices — methodology and tooling options.
- Showback Before Chargeback: Starting with VisibilityWhy most organizations start with read-only cost reports, how to structure them, and when to graduate to actual chargebacks.
- Budgeting a New AI Feature: From Prototype to Monthly Run RateToken rate times volume times price equals forecast — a worked worksheet for a feature going from pilot to production.
- Cost Regression Testing: Catching Spend Spikes Before DeploymentRunning token-count diffs as part of CI so a prompt change that triples the bill is caught before it ships.
- Anomaly Detection for Claude SpendThreshold alerts, percentage-change alerts, and statistical baselines — per-platform configuration for each approach.
- Forecasting Claude Costs as Usage ScalesCohort-based and volume-based projection models for annual planning cycles, including assumptions to document for finance.
- Provisioned Throughput on Amazon Bedrock: When and HowReserved capacity on Bedrock — the model units pricing model, break-even volume, latency benefit, and how to open the conversation with AWS.
- Committed Use on Google Vertex AI for ClaudeWhat commitment structures exist on Vertex for Vertex AI workloads and how to approach the negotiation with your GCP account team.
- Azure Commitment Structures for Claude on FoundryHow Azure Savings Plans and reserved commitments interact with Foundry Claude spend and what to ask your Microsoft account team.
- Free Tiers and Trial Credits: What You Actually GetMapping the free-tier limits and trial credit amounts across each platform — expiry dates, excluded features, and the ceiling that ends the free run.
- The Cost of Running EvaluationsHow to estimate eval pipeline spend, why eval costs are often invisible, and patterns for controlling them without skipping coverage.
- When Provisioned Throughput Pays OffThe volume and latency conditions under which reserved capacity beats on-demand pricing — a decision framework with worked numbers.
- Auditing Your System Prompt for Token WasteFinding redundant instructions, padding, and stale context in system prompts that inflate the cost of every request.
- Unit Economics for LLM Features: Cost Per TaskMeasuring cost per document processed, per ticket deflected, per user session — the metric that connects AI spend to business value.
- Routing to Haiku: Implementing Model Dispatch by Task DifficultyBuilding a classifier or rules layer that sends routine tasks to the lowest-cost model and reserves expensive models for genuinely hard cases.
- Streaming vs. Batch Cost ProfilesHow billing differs between interactive streaming and async batch jobs, and the workloads where each mode produces a materially lower bill.
- System Prompt Caching ROI: Step-by-Step CalculationThe exact cache_control placement, the tokens required to break even, and the monthly savings at different request volumes.
- Multi-Turn Conversation Cost ControlWhen to truncate, summarize, or externalize history to cap per-session spend as conversations grow long.
- Tagging Claude Requests for Cost AttributionAdding application, team, and feature metadata at the API or SDK layer so cost data can be sliced by any dimension later.
- Logging Token Counts for Internal FinOpsCapturing usage.input_tokens, usage.output_tokens, and cache fields from every API response and routing them to your cost store.
- Separating Dev, Staging, and Production CostsAccount-level vs. tag-level isolation and why letting dev and prod costs share a reporting bucket makes optimization impossible.
- Optimizing Tool Schemas to Reduce Token OverheadShorter descriptions, compressed parameter names, and trimmed enums — cutting tool schema size without breaking function.
- Structured Output vs. Free Text: Token Cost Trade-OffsComparing token overhead between JSON-mode and prose-with-extraction approaches for the same information need.
- Batch API Availability by Platform: A Current MapWhich of Bedrock, Vertex, Foundry, and Claude Platform on AWS support batch processing today and under what constraints.
- On-Demand vs. Reserved Capacity: A Decision FrameworkThe five factors — volume predictability, latency requirements, budget horizon, contract flexibility, and feature access — that determine which wins.
- Cost Per Quality Point: When to Stop Spending MoreHow to measure what each marginal dollar buys in eval score and identify the point of diminishing returns for a specific task.
- Peak Load Cost Spikes: Causes and Smoothing StrategiesWhy unthrottled batch jobs create invoice surprises and how request queuing and rate shaping flatten the spend curve.
- Image Resizing to Cut Vision Token CostsPractical maximum dimensions for common document types — receipts, slides, screenshots — before sending to the vision API.
- Prompt Compression Techniques That Preserve AccuracyAbbreviations, reference-by-ID patterns, and templating approaches that trim tokens without introducing ambiguity.
- Maximizing Cache Hit Rates: Prompt Structure and TTLHow cache key stability — identical prefix bytes — determines hit rate, and the prompt authoring habits that preserve it.
- The Full Multimodal Request Cost ModelCalculating total request cost when a single call includes text, images, tool schemas, and cache layers — all at once.
- Reconciling Cloud Invoices Against Internal Token LogsMethodology for matching AWS, GCP, or Azure invoices to your own usage records and explaining any gap to finance.
- Measuring Actual Savings from Optimization WorkA before-and-after methodology for quantifying the impact of prompt caching, model routing, and output length changes.
- Finance-Ready Claude Cost ReportingBuilding the monthly cost report your CFO accepts: GL code mapping, team allocations, actuals vs. forecast, and trend commentary.
- From Free Tier to Production Billing: What ChangesThe exact moment each platform starts charging, what triggers the transition, and how to avoid a surprise first invoice.
Solution Patterns & Playbooks 50 articles
- Document Summarization Pipeline: End-to-End Reference DesignMap-reduce chunking, prompt templates, and output schema for high-volume document summarization at scale.
- Building a Classification Service with ClaudeLabel taxonomy design, calibration, confidence thresholds, and monitoring for a production classifier.
- Extraction-to-Database PipelineStructured extraction from unstructured text, schema mapping, and idempotent database upserts.
- RAG Chunking Strategies That Actually WorkFixed-size, sentence-aware, and semantic chunking — trade-offs and when each wins.
- Citation Grounding Without Embeddings: Files API and Search ResultsDelivering grounded, source-cited answers using the Files API or search results instead of a vector store.
- Hybrid Retrieval: Combining Keyword and Semantic SearchBM25 plus dense vectors, re-ranking, and when hybrid beats either alone.
- Conversational Assistant with MemorySession state, long-term memory injection, and managing context window limits across conversation turns.
- Escalation-to-Human: The Definitive Design PatternConfidence thresholds, handoff payloads, queue integration, and measuring escalation quality.
- Multi-Step Workflow Orchestration with ClaudeChains, branches, error handling, and keeping humans in the loop at the right moments.
- Agentic Loops with Tool Use: Building Reliable Autonomous WorkersLoop design, tool schemas, output validation, and stopping conditions for production agents.
- Managed Agents: Building a Coding AgentRepository access, test-run tools, review gates, and safe sandbox constraints for an autonomous coding agent.
- Managed Agents: Building a Research AgentWeb search, document retrieval, citation synthesis, and hallucination guardrails for a research agent.
- Managed Agents: Scheduled and Background AgentsCron-triggered agents, idempotency across runs, and notification design for unattended workloads.
- MCP Integration: Connecting Claude to Your Enterprise ToolsServer setup, tool definitions, authentication, and permission scoping for Model Context Protocol.
- Multi-Server MCP: Composing Tools Across ServicesCombining multiple MCP servers, handling namespace collisions, and routing requests by capability.
- Prompt Caching Architecture for High-Traffic AppsCache key design, TTL strategy, cache warming, and measuring hit rates in production.
- Queue-Based Async Processing for Claude WorkloadsJob queues, worker pools, back-pressure handling, and fan-out patterns for async inference.
- Multi-Model Routing: Haiku Triage to Opus EscalationClassifier-based routing, cost-accuracy trade-offs, and routing logic that adapts under load.
- Idempotency and Retry Design for LLM PipelinesIdempotency keys, exponential back-off, dead-letter queues, and exactly-once semantics.
- Versioned Prompts in ProductionPrompt registries, change control, A/B testing prompts, and rollback workflows.
- Blue/Green Rollout of Model UpgradesTraffic splitting, eval gates, and canary deployment for safe model version upgrades.
- Evals in CI: Catching Regressions Before They ShipAutomated evaluation suites in CI pipelines, LLM-as-judge scoring, and pass/fail gates.
- Logging and Observability Reference Stack for LLM AppsStructured log schema, trace IDs, latency histograms, and alert thresholds for production.
- Gateway Pattern Extensions: Rate Limiting, Routing, and PoliciesExtending the internal AI gateway with per-team limits, fallback routing, and policy enforcement.
- Webhook-Driven Automation with ClaudeReceiving events, processing with Claude, and writing results back to source systems reliably.
- Batch Analytics Over Archives with ClaudeProcessing historical document archives: parallelism, checkpointing, and cost controls.
- Form-Processing PlaybookIngesting form images and PDFs, extracting fields, validating against schemas, and routing exceptions.
- Email Automation PlaybookClassification, drafting, sending via API, threading conversation context, and handling reply chains.
- Meeting-Intelligence PlaybookTranscript ingestion, speaker attribution, action-item extraction, and CRM writeback.
- Translation Pipeline PlaybookSegment-level translation, terminology glossaries, QA scoring, and human review gates.
- Document Comparison PipelineDiff-level summarization, change detection, and version-to-version delta reports for contracts and policies.
- Re-Ranking in RAG: Improving Retrieval PrecisionCross-encoder re-ranking, score normalization, and when re-ranking closes the accuracy gap.
- Streaming Response Pipeline for Real-Time UXSSE and WebSocket integration, partial output parsing, and client-side rendering of streamed tokens.
- Content Moderation Pipeline with ClaudePre-screening user inputs, policy classification, human review queue, and audit trail design.
- Accuracy-First Extraction: Confidence Scores and FallbacksField-level confidence, multi-pass verification, and escalation for low-confidence extractions.
- Knowledge Base Sync PatternIncremental ingestion, chunk-level invalidation, and keeping RAG indexes fresh with source changes.
- Stateless Multi-Turn API DesignManaging conversation history server-side, token budget tracking, and session expiry handling.
- PII Redaction PipelineDetect, redact, and audit PII before Claude sees it and verify it is absent from responses.
- Output Validation and Self-Correction LoopsSchema validation, retry on failure, and when to escalate versus self-correct bad outputs.
- Report Assembly PipelineSection-by-section generation, template injection, table of contents construction, and final document assembly.
- Product Catalog Enrichment PipelineAttribute extraction, description generation, and classification at catalog scale with quality controls.
- Contract Review WorkflowClause extraction, risk flagging, comparison to playbook, and attorney handoff protocol.
- Agentic RAG: Claude Decides What to RetrieveSelf-querying retrieval, iterative search refinement, and source attribution in an agentic loop.
- Tool Result Caching: Avoiding Redundant External CallsMemoizing tool results within a session and across sessions for deterministic tool outputs.
- Per-Feature Cost Attribution PipelineTagging requests by feature and team, aggregating token spend, and feeding FinOps dashboards.
- Synthetic Training Data Generation with ClaudePrompt templates for labeled example generation, diversity controls, and output quality filters.
- Multimodal Document Pipeline: PDFs, Images, and TablesCombining vision and text extraction for complex documents with mixed content types.
- Audit Trail Design for LLM PipelinesImmutable request and response logs, redaction for privacy, and retention policy implementation.
- Multi-Platform Failover PatternAutomatic failover between Bedrock, Vertex AI, and Claude Platform on AWS when one is degraded.
- Scheduled Batch Job PlaybookOvernight processing jobs: splitting, progress tracking, failure recovery, and result delivery.
Streaming, Errors & Resilience 25 articles
- Mid-Stream Error Events: Handling Errors After the HTTP 200 ResponseOn SSE streaming, an overloaded_error or other fault can arrive as an in-stream error event after the server has already returned HTTP 200, making it a separate failure path from pre-response HTTP status codes.
- The 10-Minute Non-Streaming Limit: When You Must Switch to Streaming or BatchThe Claude API enforces a hard timeout on non-streaming requests and the SDK validates this before sending, so any task likely to run longer than roughly 10 minutes must use streaming or the Message Batches API.
- Bedrock Read Timeout: Raising botocore's Default for Long Claude 4 ResponsesClaude 4 models on Amazon Bedrock support a 60-minute inference timeout, but the AWS SDK defaults to a 1-minute read timeout — a mismatch that silently kills long completions before the model finishes.
- Token-Bucket Rate Limiting: How the Claude API Replenishes Capacity ContinuouslyThe Claude API uses a continuous token-bucket algorithm rather than fixed-window resets, which changes how bursts behave, how to ramp traffic safely, and what the X-RateLimit-Reset timestamp actually means.
- ITPM and Cache Reads: Why a High Cache Hit Rate Multiplies Your Effective ThroughputCache-read tokens do not count toward the input-token-per-minute rate limit on most Claude models, so an 80% cache hit rate at a 2M ITPM quota can let you process 10M total input tokens per minute — with one documented exception.
- The refusal Stop Reason: HTTP 200 With Content You Cannot Use and a Bill You Still OweWhen Claude declines to complete a request mid-generation, the response returns HTTP 200 with stop_reason set to "refusal" and you are billed for all tokens produced — detecting this condition is separate from catching 4xx error codes.
- Ping Events: Why SSE Pings Exist and Why Intermediate Proxies Must Not Drop ThemThe SSE ping event keeps a streaming connection alive during quiet stretches between token bursts, and any proxy or load balancer that strips these events silently breaks long-running streaming requests.
- Streaming Adaptive Thinking: signature_delta, display:omitted, and Time-to-First-TokenThinking blocks produce a distinct SSE event sequence, and setting display to "omitted" replaces the thinking_delta stream with a single signature_delta — reducing time-to-first visible text without changing what you are billed.
- Thinking Tokens and the max_tokens Ceiling: Why Extended Thinking Truncates UnexpectedlyThinking tokens count against the same max_tokens hard limit as output text, so a response that stops with stop_reason max_tokens during extended thinking needs a larger budget or a lower effort level, not a prompt change.
- Tool Input Streaming: Buffering partial_json Fragments and When to Enable eager_input_streamingTool use input arrives as a stream of partial_json fragments that must be concatenated and parsed only after content_block_stop arrives, unless eager_input_streaming is enabled per tool for earlier per-parameter delivery.
- Bedrock Mantle Admission Control: How Token Reservations Trigger 429s Before Output StartsOn the current Claude in Amazon Bedrock Messages surface, the service reserves input tokens plus max_tokens against your TPM quota before producing any output, so you can exhaust your quota on a single large pending request.
- Request Size Limits: 32 MB, 256 MB, and 500 MB — Which Ceiling Applies to Your API CallThe Messages, Batch, and Files APIs each enforce a different maximum payload size, and oversize requests return 413 from Cloudflare before the model ever sees the request body.
- Model-Specific 400 Errors: Prefill, Temperature, and Thinking Block RulesNewer Claude models reject request patterns that older models accepted — prefilled assistant messages, explicit temperature or top_p settings, and modified thinking blocks each return 400 with a distinct error message pointing to the specific violation.
- Claude Fable 5 and Data Retention: The Org-Level 400 That Has Nothing to Do With Your Request BodyClaude Fable 5 requires at least 30 days of data retention, and any organization configured for Zero Data Retention returns 400 on every Fable 5 request regardless of the payload — the fix is in org settings, not in the API call.
- The fallback Content Block: Detecting a Model Switch Inside a Streaming ResponseDuring server-side model fallback, the SSE stream emits a fallback content block as an empty start/stop pair with no deltas between, signaling that a different model handled part of the response from that point forward.
- Bedrock Invocation Logging Gap: Why Mantle Calls Are Missing From Your S3 LogsBedrock's invocation logging feature captures requests made through the legacy InvokeModel and Converse APIs but does not capture calls through the current bedrock-mantle Messages API endpoint used by AnthropicBedrockMantle.
- Vertex AI Endpoint Anatomy: streamRawPredict, URL Shape, and anthropic_version in the BodyStreaming on Vertex AI uses the :streamRawPredict suffix on the endpoint URL, and anthropic_version must be placed in the request body as "vertex-2023-10-16" rather than sent as an HTTP header.
- Claude Platform on AWS Setup Errors: SigV4 Region Mismatch and the Outbound WIF PrerequisiteTwo configuration mistakes cause nearly all early failures on Claude Platform on AWS — a SigV4 region mismatch produces only a generic signature rejection, and skipping the one-time outbound web identity federation enable step blocks every request with a specific error message.
- Foundry and Claude Fable 5: Zero Default Quota on Pay-As-You-Go SubscriptionsClaude Fable 5 on Microsoft Foundry ships with 0 RPM and 0 ITPM on standard pay-as-you-go accounts and requires an Enterprise or MCA-E agreement plus a quota increase request before any Fable 5 requests can succeed.
- Compaction in Streaming: The compaction Stop Reason and Why Top-Level Token Counts MisleadWhen server-side compaction is enabled, long sessions can pause with stop_reason compaction mid-stream, and the top-level input_tokens and output_tokens fields exclude compaction iteration tokens — requiring you to sum all iterations for the true billed amount.
- Workspace Sub-Limits and Acceleration Limits: Quota Control Below the Org CeilingWorkspaces can be assigned custom rate and spend limits below the organization-wide ceiling, but sharp traffic spikes can trigger acceleration-limit 429s even when neither the workspace nor org quota is yet exhausted.
- Structured Output Truncation: When stop_reason max_tokens Yields Unparseable JSONA structured output response cut off by the max_tokens limit produces an incomplete JSON object that fails schema validation — the correct response is to retry with a larger max_tokens, not to repair the partial output.
- 401 vs 402 vs 403: Why Authentication, Billing, and Permission Errors Need Different FixesThe Claude API returns three distinct non-retryable 4xx codes for access failures — authentication errors mean the key is invalid, billing errors mean the account is blocked, and permission errors mean the key lacks the required scope.
- Claude Platform on AWS Rate Limits: Permanent Start Tier and How to Request More CapacityOrganizations on Claude Platform on AWS remain on the Start tier indefinitely — unlike the direct Claude API where tiers advance automatically — and must contact Anthropic directly to raise rate limits.
- Foundry ITPM Accounting: Cache Writes Count Against Your Limit, Cache Reads Do NotMicrosoft Foundry measures ITPM as uncached input tokens plus both 5-minute and 1-hour cache write tokens, but excludes cache reads from the calculation — a distinction that matters when sizing your quota for prompt-caching-heavy workloads.
Advanced Tool Use & Agent Engineering 25 articles
- MCP Connector Platform Availability: The Hard Split ExplainedWhy the API-native MCP connector works on the Claude API, Claude Platform on AWS, and Foundry Hosted-on-Anthropic but is blocked on Amazon Bedrock and Google Vertex AI — and what each of those platforms offers instead.
- Inside the MCP Connector Request: mcp_servers, mcp_toolset, and Block TypesThe two-part structure every MCP connector call requires — one mcp_servers entry and one matching mcp_toolset per server — and how the mcp_tool_use and mcp_tool_result blocks differ from ordinary tool_use blocks.
- MCP Tool Filtering: Allowlists, Denylists, and Mixed PatternsUsing mcp_toolset default_config and per-tool configs to control exactly which tools from a connected MCP server Claude is allowed to call, including precedence rules when defaults and overrides conflict.
- OAuth for MCP Servers: Running the Auth Flow YourselfThe connector does not handle OAuth on your behalf — you run the authorization flow, pass the resulting token as authorization_token, and are responsible for refreshing it before each API call.
- Combining MCP Toolsets with defer_loading to Control Context CostWhen an MCP server exposes dozens or hundreds of tools, pairing mcp_toolset with defer_loading and the tool search tool keeps unused tool definitions out of the context window without removing them from the request.
- Client-Side MCP Helpers for Local and STDIO ServersThe anthropic[mcp] package ships four helper functions — mcpTools, mcpMessages, mcpResourceToContent, and mcpResourceToFile — for developers running their own MCP client against local servers that the remote connector cannot reach.
- Agent SDK vs. Managed Agents: Same Loop, Different HostingBoth options run Claude's agentic tool loop, but the Agent SDK runs in your process with JSONL session state on your filesystem, while Managed Agents runs on Anthropic's infrastructure with a hosted container and REST sessions — here is how to pick.
- Running the Agent SDK on Amazon BedrockThe CLAUDE_CODE_USE_BEDROCK env var, how the credential chain resolves, the CLAUDE_CODE_USE_MANTLE flag that switches to Bedrock's native Anthropic API shape, required IAM permissions, and the WebSearch tool gap on Bedrock.
- Running the Agent SDK on Google CloudCLAUDE_CODE_USE_VERTEX setup, CLOUD_ML_REGION values including the global multi-region option, per-model region overrides with VERTEX_REGION_CLAUDE_* vars, and why MCP tool search is disabled by default on Vertex and how to re-enable it for Sonnet 4.5+.
- Running the Agent SDK on Microsoft FoundryCLAUDE_CODE_USE_FOUNDRY is the only configuration path — there is no setup wizard — covering env var setup, Azure credential chain fallback, startup behavior differences versus Bedrock and Vertex, and base URL override for custom endpoints.
- Agent SDK Lifecycle Hooks and the Permission ModelPreToolUse, PostToolUse, Stop, SessionStart, and SessionEnd callbacks let you validate, log, or block agent actions; combined with allowed_tools and permission_mode settings they define a layered policy model for safe autonomous operation.
- Building Subagent Systems with the Agent SDKDefine specialized agents via the agents option using AgentDefinition, invoke them through the built-in Agent tool, control which tools each subagent can access, and trace delegation chains via the parent_tool_use_id field on subagent context messages.
- Session Continuity: Resume, Fork, and JSONL StorageThe Agent SDK assigns a session_id in the first query's init message; pass resume=session_id to continue with full context, or fork the session to explore two approaches from the same point — all backed by JSONL files on your filesystem.
- Agent Skills Three-Level Loading: Keeping Context LeanOnly the name and description from a skill's YAML frontmatter enter the system prompt at startup (~100 tokens per skill); the SKILL.md body and bundled scripts load on demand through bash, so unused skills cost almost nothing.
- Agent Skills on 3P Platforms: What Is and Is Not SupportedPre-built and custom Agent Skills are available on the Claude API, Claude Platform on AWS, and Microsoft Foundry with a Hosted-on-Anthropic deployment; they are absent on Amazon Bedrock and Google Vertex AI.
- Agent Skills Runtime Constraints Differ by SurfaceAPI skills run without network access and cannot install packages at runtime; Claude Code skills have full network access; claude.ai skills depend on workspace admin settings — the same SKILL.md behaves differently depending on where it runs.
- Auditing Agent Skills Like Installing SoftwareA skill with bundled scripts can execute arbitrary code in Claude's environment; Anthropic's own guidance says to treat skills like installed software — including auditing all bundled files and applying heightened scrutiny to any skill that fetches external URLs.
- Server-Side Context Editing: Trimming Tool Results and Thinking Before They Reach the ModelThe context-management-2025-06-27 beta header enables two server-applied strategies — clear_tool_uses_20250919 and clear_thinking_20251015 — that prune old content before Claude processes the prompt, with applied_edits in the response reporting exactly what was removed.
- Context Editing and Prompt Caching: Managing the Cache Invalidation CostClearing tool results removes cached prompt prefixes at the cleared point; the clear_at_least parameter lets you set a minimum bytes-cleared threshold so the context window savings always outweigh the cache miss penalty.
- Using Claude with Amazon Bedrock AgentCore HarnessThe AgentCore Harness defaults to Claude Sonnet 4.6 via the converse_stream API format; you can switch to the responses or chat_completions format for Bedrock's Mantle endpoint, and you can even reach Anthropic's 1P API from AgentCore using liteLlmModelConfig with a key stored in AgentCore Identity.
- Amazon Bedrock AgentCore Services Overview: Where Claude FitsAgentCore's twelve services — Harness, Runtime, Memory, Gateway, Identity, Code Interpreter, Browser, and more — work independently or together; Claude is one of many supported models, not a special first-class citizen, and AgentCore's Skills and MCP support are AWS-native concepts distinct from Anthropic's.
- Bedrock Agents Classic Is Closing to New Customers July 30, 2026Amazon Bedrock Agents (launched November 2023) is now Bedrock Agents Classic and will not accept new customers after July 30, 2026; existing customers continue as normal, and AWS points newcomers to AgentCore — here is what to evaluate when choosing between AgentCore, the Anthropic Agent SDK, and Managed Agents.
- Foundry Hosted-on-Azure vs. Hosted-on-Anthropic: Which Features UnlockFoundry offers Claude in two deployment modes; Hosted-on-Azure (GA) supports the core Messages API but not the MCP connector, Agent Skills, or code execution; Hosted-on-Anthropic (preview) unlocks all three — and Fable 5 — at the cost of data leaving Azure infrastructure.
- Claude on Google Cloud Has No Server Tools: Building Agents Around the GapGoogle's official docs confirm Claude partner models on the platform support Client tools only — no web search, code execution, web fetch, or MCP connector via the API; this article maps the architectural implications and where Google's own Agent Runtime docs are silent on Claude support.
- Multiagent Coordination in Managed AgentsA coordinator agent delegates tasks to up to 20 roster agents within a single session; all share the container filesystem but maintain isolated conversation threads with their own models and tool sets; delegation is one level deep only, and cross-thread tool confirmations surface on the primary session stream.
Networking, Identity & Private Connectivity 25 articles
- The bedrock-mantle VPC Endpoint Service ExplainedHow the Messages-API surface gets its own PrivateLink endpoint service (`com.amazonaws.{region}.bedrock-mantle`) separate from `bedrock-runtime`, and how to create and scope VPC endpoint policies for both.
- FIPS 140-3 Endpoints for Amazon BedrockWhich regions offer `bedrock-fips` and `bedrock-runtime-fips`, what they validate, why no FIPS variant exists yet for the bedrock-mantle surface, and when a government workload needs them.
- The Dual-ARN Requirement When Using Inference Profiles in IAMWhy an IAM policy that scopes `Resource` only to an inference-profile ARN silently fails, how to add the matching foundation-model ARN for every destination region, and how the `bedrock:InferenceProfileArn` condition key locks callers to a specific profile.
- SCPs and Cross-Region Inference: the aws:RequestedRegion TrapHow geographic inference profiles require all destination regions to be allowed in SCPs, why global profiles use `aws:RequestedRegion = "unspecified"`, and how to add an explicit Deny to block global routing entirely.
- Auditing Where Cross-Region Bedrock Inference Actually RanHow to find the `additionalEventData.inferenceRegion` field in CloudTrail records to confirm which region processed a cross-region inference request, and why logs always appear in the source region.
- What AWS KMS Encryption Covers — and Does Not Cover — on BedrockMapping customer-managed KMS key support across model customization, agents, knowledge bases, and evaluation jobs, and why on-demand inference prompts fall outside customer-KMS scope under the Model Deployment Accounts architecture.
- VPC Service Controls Blocks Request-Response Logging on Vertex AIWhy enabling a VPC-SC perimeter around Vertex AI disables prompt-and-completion logging, what the documented alternatives are for capturing audit evidence inside a perimeter, and how to plan for this before locking down a production environment.
- Enforcing Regional Endpoints with a GCP Org Policy ConstraintHow to apply `constraints/gcp.restrictEndpointUsage` to prevent Vertex AI traffic from hitting the global endpoint, and how to configure clients to use the regional domains (`aiplatform.us.rep.googleapis.com` / `aiplatform.eu.rep.googleapis.com`) instead.
- Enabling Cloud Audit Logs for Vertex AI Claude PredictionsHow to turn on Data Access (DATA_READ) audit logging for `endpoints.predict` calls, why these logs are disabled by default, and the `roles/logging.privateLogViewer` role required to read them.
- Workload Identity Federation for Non-GKE Workloads Calling Claude on Vertex AISetting up WIF pools and OIDC providers for workloads running on AWS, GitHub Actions, GitLab, or any standards-compliant IdP so they can obtain short-lived Google Cloud credentials without exporting service account keys.
- The Two IAM Roles Every Vertex AI Claude Deployment NeedsWhy both `roles/consumerprocurement.entitlementManager` (to enable models in Model Garden) and `roles/aiplatform.user` (to call the predict endpoint) are required, which persona gets each, and the `roles/serviceusage.serviceUsageAdmin` prerequisite for enabling the API itself.
- Enforcing Keyless-Only Access by Disabling API Keys in FoundryHow to set `disableLocalAuth: true` via PowerShell, Bicep, or ARM template to eliminate key-based auth once all consumers have migrated to Entra ID, and how to verify no callers still depend on keys before flipping the switch.
- Foundry RBAC Roles for Claude: Which Role to Assign and WhereThe Foundry User, Foundry Owner, Foundry Agent Consumer, and Foundry Project Manager role taxonomy, why Microsoft warns against assigning "Cognitive Services" or "Azure AI Developer" roles for Foundry work, and how scoping a role to a resource versus project versus individual agent changes the blast radius.
- How Azure DNS Routes Foundry Traffic Through a Private EndpointThe mechanics of Azure CNAME rewriting into a `privatelink` subdomain, why the same Foundry hostname resolves to a private IP inside the VNet and a public IP outside it, and how to configure custom or on-premises DNS servers to forward to Azure DNS at 168.63.129.16.
- Letting Trusted Azure Services Bypass Foundry Network RulesHow to grant Azure AI Search, Azure Machine Learning, and other trusted Azure services access to a Foundry resource whose public network access is disabled, using managed identity combined with a role assignment rather than opening network rules.
- Foundry's Three Public Network Access Modes and Their Network ImplicationsA plain-English walkthrough of Disabled, Enabled from selected IP addresses, and public PNA settings, including why removing a private endpoint does not automatically re-enable public access and how to reach a fully locked-down resource for management.
- The aws-external-anthropic SigV4 Service Name: Why It MattersWhy the SigV4 service name for Claude Platform on AWS is `aws-external-anthropic` rather than a Bedrock alias, how to set it correctly in cURL and SDK clients, and the misleading generic signature-rejection error produced by a service-name mismatch.
- The One-Time STS Prerequisite for Claude Platform on AWSWhy the gateway must call `sts:GetWebIdentityToken` server-side and why `aws iam enable-outbound-web-identity-federation` must be run once per account before any SigV4-authenticated call can succeed.
- Federating IAM Roles into the Claude ConsoleHow the `aws-external-anthropic:AssumeConsole` IAM action generates a short-lived JWT redirect to `platform.claude.com`, the just-in-time user provisioning it triggers, and the difference between Admin and Developer console roles.
- Workspace Region vs. Inference Geography on Claude Platform on AWSWhat the `inference_geo` parameter controls (where inference actually runs on Anthropic infrastructure) versus what the workspace's AWS region controls (gateway endpoint, IAM, CloudTrail, billing), and the 1.1x cost multiplier that applies to `us` geography.
- CloudTrail Coverage for Claude Platform on AWS: Management vs. Data EventsWhy inference, batch, file, and skill API calls are Data events that require explicit opt-in and incur extra charges, how to enable them, and how to correlate logs using the dual request IDs (`x-amzn-requestid` from AWS and `request-id` from Anthropic).
- Anthropic's Native Workload Identity Federation for the Claude APIHow to configure service accounts, federation issuers (OIDC discovery, explicit JWKS URL, or inline for air-gapped clusters), and federation rules to exchange external JWTs for short-lived `sk-ant-oat01-...` tokens without storing long-lived API keys.
- Fixed IP Ranges for Claude API Firewall RulesAnthropic's documented inbound CIDR (`160.79.104.0/23`) and outbound tool-call CIDR (`160.79.104.0/21`), why Claude Platform on AWS inbound traffic uses AWS IP ranges instead, and how to phase out the legacy `34.162.*` /32s that are being decommissioned.
- Workspace Isolation: API Keys, Prompt Caches, and Spend LimitsHow workspace scoping differs across platforms (per-workspace on the Claude API, Claude Platform on AWS, and Foundry versus per-organization on Bedrock and Vertex AI), the 100-active-workspace limit, and why archiving a workspace immediately and irreversibly revokes all its API keys.
- Admin API Keys vs. OAuth org:admin Tokens: When to Use EachThe difference between `sk-ant-admin` keys and OAuth bearer tokens with `org:admin` scope, why the Admin API deliberately prevents creating new API keys programmatically, and which of the five organization roles can obtain each credential type.
Observability, Usage & Analytics 25 articles
- The AWS/BedrockMantle CloudWatch Namespace: Why Your Dashboards May Miss Half Your TrafficHow the current bedrock-mantle surface publishes to a completely separate namespace from the legacy AWS/Bedrock, which metrics the two namespaces share and which differ (Project dimension, missing TTFT and latency equivalents on mantle), and how to build a unified dashboard that covers both surfaces.
- Enabling CloudTrail Audit Coverage for bedrock-mantle Inference CallsWhy inference on the current Claude in Amazon Bedrock surface is a CloudTrail data event (off by default, incurs charges), how to enable data event capture with advanced event selectors, and why existing filters on bedrock.amazonaws.com miss the bedrock-mantle.amazonaws.com eventSource entirely.
- Inside a Bedrock ModelInvocationLog Record: Fields, Size Limits, and Overflow HandlingA field-by-field walkthrough of the ModelInvocationLog schema — timestamp, accountId, identity.arn, requestMetadata, inputBodyJson/outputBodyJson — the 100 KB body cap, how larger payloads and binary data overflow into separate S3 objects, and what the log entry's reference to those objects looks like.
- Using requestMetadata Tags for Per-Call Attribution on Amazon BedrockHow to attach caller-supplied key-value tags to bedrock-runtime inference calls via the requestMetadata field, how Bedrock preserves them verbatim in invocation logs, and how to write CloudWatch Logs Insights queries that group token usage by those tags for per-team or per-feature chargeback.
- Monitoring Bedrock's Invocation-Logging Pipeline with Delivery Health MetricsThe ModelInvocationLogsCloudWatchDeliverySuccess, ModelInvocationLogsCloudWatchDeliveryFailure, and three S3 delivery health metrics that AWS publishes under AWS/Bedrock, what failures look like, and how to build alarms that fire before logging gaps reach your compliance retention window.
- Why EstimatedTPMQuotaUsage Cannot Replace Throttle-Based Capacity PlanningThe documented AWS caveat that EstimatedTPMQuotaUsage does not reflect the reservation-based accounting (input tokens plus max_tokens reserved upfront) that actually drives throttling, what InvocationThrottles and SDK retry settings show instead, and how to size max_tokens conservatively to reduce unintended throttle counts.
- The CloudWatch Generative AI Observability Dashboard for BedrockWhat the pre-built CloudWatch gen-AI dashboard shows (invocation count, latency, token counts by model, throttles, error rates), why drilling into per-request prompt content requires bedrock-runtime invocation logging enabled to CloudWatch Logs first, and how to extend the dashboard with OTel traces from ADOT-instrumented frameworks.
- Setting Up Vertex AI Request-Response Logging for Claude: REST-Only, Regional-OnlyWhy Claude on Vertex AI requires the REST API (not gRPC) and a regional endpoint (not the global endpoint) to configure request-response logging, the setPublisherModelConfig API call structure with samplingRate and bigqueryDestination, and the few-minute propagation delay before changes take effect.
- Field-by-Field Guide to the Vertex AI Request-Response Log Table in BigQueryWhat each column in the auto-created request_response_logging BigQuery table contains — endpoint, logging_time, request_id, request_payload, response_payload, full_request, full_response, metadata latency, otel_log — the 10 MB row-size limit that silently drops large conversations, and how sampling rate affects completeness.
- The otel_log Column: Vertex AI's Only OpenTelemetry Hook for ClaudeHow enabling enableOtelLogging on the Vertex publisher model config adds an otel_log JSON column in OpenTelemetry schema format alongside the standard request-response columns in BigQuery, why this is the only documented OTel sink for Claude on Vertex AI, and what the column contains versus what the standard columns already provide.
- Vertex AI Tamper-Proof Log Sharing with Anthropic for Advanced AI ModelsHow to enable real-time tamper-proof sharing of Vertex request-response logs with Anthropic's trust-and-safety team for Claude Fable 5, Mythos Preview, and Mythos 5 using dataSharingEnabledProvider, why BigQuery logging does not need to be active for sharing to work, the Advanced AI Safety Addendum consent requirement, and the VPC Service Controls restriction that blocks sharing by default.
- Reading the Vertex AI Pre-Built Model Observability Dashboard for ClaudeWhat the Vertex AI model observability dashboard shows for MaaS partner models like Claude (requests per second, token throughput, first-token latency, error rates), how to navigate to it (Gemini Enterprise Agent Platform console → Model observability), why the section only appears after real API calls exist, and the documented exclusion of Vertex AI Studio traffic.
- Why the Vertex AI Quota Page Shows Inaccurate Token Counts for ClaudeThe documented inaccuracy of Quota page token figures caused by Anthropic's estimation-and-refund token model, why Metrics Explorer token_count metrics are the authoritative source for Claude token accounting on Vertex, and how to find the right quota lineage metrics (global_online_prediction_input_tokens_per_minute_per_base_model with base_model dimensions like anthropic-claude-opus).
- Rate-Limit Visibility on Foundry Without anthropic-ratelimit-* HeadersWhy Foundry omits all nine anthropic-ratelimit-* response headers that the direct Claude API returns, what signals are available instead (ProvisionedUtilization metric crossing 100%, Azure portal quota page, 429 responses), and how to implement exponential back-off without header-based token budget tracking.
- Two Correlation IDs in Every Foundry Response: request-id and apim-request-idWhat the Anthropic-side request-id and the Azure API Management apim-request-id each trace, why Anthropic support requires both to cross-reference a request across their system and Azure's, and how to extract and log both headers reliably from SDK responses.
- OpenTelemetry Tracing for Claude in Foundry's Agent FrameworkHow Foundry's agent-framework tracer emits spans following OTel GenAI semantic conventions (gen_ai.provider.name, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens), the three environment variables required to opt into recording prompt and completion content in spans, and how to route traces to a Log Analytics workspace.
- Reconciling Claude Consumption Units Against Foundry Token MetricsHow Claude charges on Foundry appear as CCU-denominated metered entries on your Azure invoice billed monthly in arrears, the documented five-hour delay before charges appear in Azure Cost Management, and how to cross-check the CCU line items against InputTokens and OutputTokens metrics in Azure Monitor to surface discrepancies.
- Admin API Keys, Standard API Keys, and Analytics API Keys: Which Does WhatThe three key types for the Claude API (sk-ant-admin01- Admin keys, standard sk-ant- API keys, and Claude Enterprise Analytics keys), which endpoints each unlocks, why the Usage and Cost Admin API is restricted to organizations (not individual accounts), and how organizations using Claude Enterprise Analytics get a separate Analytics API instead.
- Group-By Dimensions and Filters in the Usage Report EndpointA practical guide to every group_by dimension in GET /v1/organizations/usage_report/messages (account_id, api_key_id, context_window, inference_geo, model, service_account_id, service_tier, speed, workspace_id), what each dimension enables (per-workspace chargeback, data-residency verification, model-level rollup), and the beta header required for speed-based grouping.
- The Cost Endpoint: Daily Granularity, Cents Format, and What It OmitsHow GET /v1/organizations/cost_report differs from the usage endpoint (daily-only bucket_width, USD decimal strings in cents, grouping by description or workspace_id), why Priority Tier costs are absent (different billing model), and why code execution costs appear only here and not in the usage endpoint.
- Closing the Attribution Gaps in the Admin Usage APIThe three documented blind spots in the Usage API — Workbench usage that returns api_key_id: null, usage from the default workspace appearing as workspace_id: null, and per-user Claude Code cost breakdowns requiring the separate Claude Code Analytics API — and practical workarounds for each.
- Why the Usage and Cost Admin API Is Unavailable on Claude Platform on AWSThe documented exclusion of programmatic Usage and Cost API endpoints from Claude Platform on AWS, what the Console Usage and Cost pages provide instead (hourly/minute token breakdowns, rate-limited request counts, cache-rate charts, CSV export), and the access-role requirements that limit visibility to Developer, Billing, and Admin roles.
- Usage Fields in Streaming Responses: message_start, message_delta, and the Cumulative TrapHow token counts appear at two points in a streaming response (initial message_start usage snapshot with output_tokens: 1, and the final message_delta with cumulative totals including cache fields and server_tool_use), why summing delta counts produces wrong totals, and how compaction iterations affect top-level usage figures.
- usage.server_tool_use and usage.service_tier: Billing Fields Beyond Token CountsWhat the usage.server_tool_use object reports (web_search_requests and web_fetch_requests counts for server-tool billing reconciliation), what usage.service_tier tells you about which serving tier handled the request (standard, priority, batch), and why these fields are the authoritative per-response source for reconciling server-tool charges.
- What Actually Lands in Platform Logs: A Cross-Platform Prompt-Content InventoryA factual comparison of what prompt and completion content reaches each platform's logging system — full JSON request and response bodies (up to 100 KB) in Bedrock invocation logs, full payloads in Vertex BigQuery request-response logs, status codes and latency only (no bodies documented) in Foundry diagnostic RequestResponse logs — and the governance implications of prompts containing personal data flowing into cloud-managed log stores.
Retrieval & Document Workflows 25 articles
- How search_result Content Blocks Work: The BYO-Retrieval PatternHow to pass your own retrieved chunks to Claude using search_result blocks, how citation indexing differs from document-block citations, and why citations are disabled by default on search results even though the feature is explicitly designed for RAG.
- Bedrock's Two PDF Modes: Document Chat vs Claude PDF ChatWhy Bedrock's Converse API offers two distinct PDF processing paths, how enabling citations switches from text-only to full visual analysis, and when switching to InvokeModel gives you direct control without that constraint.
- Pairing Voyage AI Embeddings with Claude Retrieval PipelinesHow Anthropic's officially recommended embedding companion works — choosing among general, domain-specific, and contextualized Voyage models, setting input_type correctly, and using quantization to reduce index size.
- Bedrock RetrieveAndGenerate API: Using Claude as the Generation ModelHow to call RetrieveAndGenerate with a Claude modelArn or cross-region inference profile, what the citation span objects in the response look like, and how session continuity works across a multi-turn knowledge-base conversation.
- Bedrock Knowledge Bases Data Sources: S3, SharePoint, and Permission FilteringWhich connectors Bedrock Knowledge Bases supports out of the box, how document-level ACL filtering applies at retrieval time, and what the Web Crawler connector does and does not cover.
- Bedrock Knowledge Bases Chunking Modes: Five Strategies and Their ConstraintsA field guide to Bedrock KB's default, fixed-size, hierarchical, semantic, and no-chunking options — including the hierarchical-plus-S3-vector-bucket incompatibility and the 8,000-token combined-chunk metadata ceiling.
- Bedrock Knowledge Base Embedding Models: Titan vs Cohere ComparedChoosing between Amazon Titan Text Embeddings V2 and Cohere Embed for a customer-managed knowledge base, dimension and quantization options, and when the multimodal embedding models change the comparison.
- Why Claude Is Not a Vertex RAG Engine Generator — and What to Do InsteadHow the Vertex RAG Engine supported-models list excludes Claude, why Google's server-side grounding tools do not attach to Claude, and how to build a retrieval pipeline using search_result content blocks with your own retrieval backend.
- Grounding Claude on Microsoft Foundry Without Azure AI SearchWhy Azure AI Search integration for Claude is undocumented in Foundry, how to implement BYO retrieval using citations and search_result blocks, and which grounding features require a Hosted-on-Anthropic deployment versus Hosted-on-Azure.
- Long Context vs RAG: Platform Economics and the Vertex SurchargeWhen loading full documents into a 1M-token window beats retrieval, why Vertex's ≥200K-token pricing changes the calculation compared to 1P or Bedrock where standard rates apply across the full window, and how context rot limits the stuffing approach regardless of platform.
- Citations Billing: What Counts, What Doesn't, and Caching BehaviorHow enabling citations adds a small system-prompt overhead, why cited_text in the response does not count toward output tokens, how to combine prompt caching on document blocks with citations for cost efficiency, and why citations and structured outputs return a 400 error when combined.
- Custom Content Documents: Controlling Citation PrecisionHow custom content document blocks let you define the exact unit Claude will cite using content_block_location ranges, how this differs from sentence-chunked plain text, and when splitting content into smaller blocks improves attribution accuracy.
- Scanned PDFs and Citations: What the API Cannot AttributeWhy scanned PDFs without extractable text are not citable, how the absence of image citation support affects mixed document sets, and practical fallback patterns for collections that include non-extractable scans alongside machine-readable PDFs.
- Files API Security Model: Workspace Scoping, Retention, and ZDR Trade-offsHow Files API uploads scope to the uploading workspace, why the Files API is not Zero Data Retention-eligible while other document inputs can be, the immutability and non-recoverability constraints, and how storage-limit errors surface.
- Web Search Tool Versions: Basic, Dynamic Filtering, and Response InclusionHow web_search_20250305, _20260209, and _20260318 differ from each other, what dynamic filtering achieves by running search from inside code execution, and how the allowed_callers field controls which callers can trigger searches.
- Web Fetch URL Validation: Why Claude Can Only Fetch URLs Already in ContextThe URL-in-context security rule that prevents Claude from fetching self-constructed URLs, residual data-exfiltration risk despite the restriction, and the configuration controls — max_uses, allowed_domains, max_content_tokens — that reduce attack surface further.
- Using Claude Vision as a Document Parser in Bedrock Knowledge BasesHow to configure Claude vision models as the advanced parsing foundation model in a Bedrock Knowledge Base, what this enables for complex layouts and mixed-content documents, and how it differs from the default text-extraction path.
- Contextualized Chunk Embeddings: Voyage Context Models for Long DocumentsHow voyage-context-4 and voyage-context-3 embed each chunk using the surrounding 120K-token document context, when this approach improves retrieval over standard chunk embeddings, and the different contextualized_embed() API call pattern it requires.
- Bedrock RetrieveAndGenerate External Sources: Generating Without a Persistent Knowledge BaseHow to use externalSourcesConfiguration to ground Claude responses in S3 objects or raw byte content without first indexing a persistent knowledge base, and the operational scenarios where this on-demand pattern fits better than a managed index.
- Streaming Citations: Reading citations_delta Events in Real TimeHow citation blocks arrive as citations_delta deltas during streaming responses, why each delta carries exactly one citation appended to the current text block, and how to build a real-time UI that renders source links progressively as they arrive.
- Files API and Citations Together: Referencing Stored Documents by file_idHow to upload a document once, reference it by file_id in a document block, enable citations on it, and what the resulting char_location or page_location citation objects contain in the response.
- Web Search in the Message Batches API: Pricing and Throttling at ScaleHow web search behaves inside batched jobs submitted through the Message Batches API, what per-organization throttling applies to batched search calls, and why batch web search is not available on Bedrock or Vertex.
- Bedrock Knowledge Bases: Managed vs Customer-Managed ArchitectureWhen to let Bedrock own the vector store and retrieval pipeline versus supplying your own OpenSearch Serverless or Aurora backend, what you gain and give up with each option, and the AgentCore Gateway MCP integration that managed knowledge bases unlock.
- Bedrock Knowledge Bases Multimodal Chunking: Audio, Video, and the Data Automation ParserHow to configure audio and video chunk duration for Nova multimodal embeddings, how the Bedrock Data Automation parser converts media files to transcripts and scene summaries before text chunking, and what document types this path is designed for.
- Contract Review at the Retrieval-Architecture LevelHow to chunk contracts by clause for citation precision, why the custom content document type maps naturally to clause-level attribution in audit trails, and how prompt caching on large contract corpora reduces per-query cost at scale.
Evaluation, Testing & Quality 25 articles
- Writing SMART Success Criteria for Claude TasksHow to turn a vague goal like "good responses" into a Specific, Measurable, Achievable, Relevant metric using Anthropic's documented framework — with a worked F1-score example.
- Multidimensional Evaluation: Balancing Task Fidelity, Latency, and CostWhy most production tasks require simultaneous scoring across accuracy, response time, and inference cost, and how to decide which dimension to weight most when they trade off.
- Code-Based Grading: Exact Match, String Match, and When Each AppliesThe fastest, most scalable grading method — how to write exact-match and substring-match graders in Python, what they miss, and which task types they suit best.
- LLM-as-Judge: Writing Rubrics That Force Reliable ScoresHow to write judge prompts with auto-fail rules, forced binary or Likert outputs, and chain-of-thought reasoning steps that improve scoring without contaminating the final grade.
- Why the Judge Model Should Differ From the Evaluated ModelAnthropic's documented best practice of using a separate model to grade outputs, the practical tradeoffs of cost versus independence, and how to apply this principle across platforms.
- Human Grading: When It Is Unavoidable and How to Keep It SmallAnthropic's guidance to treat human grading as a last resort, which task types genuinely require it, and how to structure labeling sessions so annotators reach consistent verdicts.
- The Anthropic Console Evaluation Tool: Setup to Side-by-Side ResultsThe double-brace variable prerequisite, three methods to add test cases (manual, auto-generate, CSV), side-by-side prompt comparison, five-point quality grading, and re-running the suite after edits.
- The Console Prompt Generator: From Blank Page to Structured TemplateHow the Claude Sonnet 4.5-powered generator creates {{variable}}-based prompt templates, what it decides about variable placement, and when this tool saves more time than it costs.
- The Console Prompt Improver: Four Steps and Their Latency CostThe four-stage improvement process — example identification, initial draft, chain-of-thought refinement, example enhancement — and the documented trade-off that improved prompts are longer, slower, and more expensive.
- Bootstrapping an Eval Set With the Console Test Case GeneratorUsing the Console to generate synthetic input rows from a seed example, editing Claude's responses into ideal answers, and assembling a labeled dataset before you have real production logs.
- The Console Toolchain as a System: Generator, Improver, and Eval Tool TogetherHow the prompt generator decides which variables a prompt needs, the improver preserves them, and the Evaluation tool tests and versions across that consistent {{variable}} contract.
- Four Edge-Case Categories Every Eval Set Must IncludeAnthropic's documented taxonomy — irrelevant input, overly long input, harmful or adversarial input, and ambiguous cases where humans disagree — with guidance on generating examples for each.
- Volume Over Quality: The Case for Automated Evals at ScaleWhy Anthropic recommends more questions with automated grading over fewer hand-graded questions, how to use Claude itself to generate test cases from a small seed set, and where human review still earns its cost.
- Six Hallucination-Reduction Techniques Ranked by Implementation EffortDirect quotes, citation requirements, chain-of-thought verification, best-of-N runs, iterative refinement, and external-knowledge restriction — what each demands from your pipeline and when to reach for it.
- Output Consistency on Current Claude Models Without PrefillThe documented techniques for enforcing consistent formats on Fable 5, Opus 4.8, and other models where assistant-turn prefilling is deprecated — structured outputs, explicit format instructions, few-shot examples, and prompt chaining.
- Prefill Deprecation: Which Models Are Affected and What Replaces ItThe exact model list on which prefilling the assistant turn is no longer supported, why it was removed, and the two recommended replacements (structured outputs and system-prompt format instructions).
- Model Migration Regression Checklist: Re-Baseline, Re-Tokenize, Re-ReviewThe three recurring steps in Anthropic's per-model migration guide — cost and latency re-baselining on your own workloads, re-running token counts after a tokenizer change, and a prompt-and-harness review for behavior shifts.
- Retuning the Effort Setting Across Model UpgradesWhy the thinking-token budget behind each effort level shifts between model generations, and the documented recommendation to start at `high` — not `xhigh` — when migrating workloads to Claude Fable 5.
- Tokenizer Drift: Why Token Counts Change Between Model GenerationsHow tokenizer updates shift both input and output token counts across generations, why reusing measurements from an older model is unreliable, and how to build a token-count regression step into your upgrade process.
- Bedrock Automatic Evaluation Jobs: Task Types, Metrics, and ConstraintsThe four programmatic task categories (text generation, summarization, Q&A, classification), their built-in and custom datasets, the metrics each computes, and the one-task-per-job limit.
- Bedrock LLM-as-Judge: Pairing a Generator With a Claude EvaluatorHow to configure a Bedrock judge-model evaluation job, which Claude versions are documented as supported judge models (through Opus 4.5 / Sonnet 4.5 / Haiku 4.5), and why Fable 5 and Opus 4.8 are not currently listed as judge options.
- Bedrock Bring-Your-Own-Inference: Evaluating Outputs From Any Claude DeploymentHow to supply pre-generated responses to a Bedrock evaluation job so Bedrock scores them without invoking a generator — useful for comparing Claude outputs from Anthropic's API, Claude Platform on AWS, or offline pipelines.
- Evaluating RAG Pipelines With Bedrock Knowledge Base Evaluation JobsThe retrieve-only and retrieve-and-generate job types, the ground-truth dataset requirement, which Claude models are documented as RAG judge models, and how to bring in a non-Bedrock RAG source for comparison.
- Evaluating Claude on Vertex AI's Gen AI Evaluation ServiceWhat Google documents about partner-model evaluation support (enable via Model Garden first, inference billed at Claude rates), the metric families available, and where current documentation gaps require verifying directly with Google.
- Foundry Evaluators and the Claude Judge GapMicrosoft's documented restriction that LLM-as-judge evaluators accept only Azure OpenAI models — not Claude — as judges, what this means for teams deploying Claude in Foundry, and the static-data workaround for scoring pre-generated Claude outputs.
Multi-Platform Portability & Model Upgrades 25 articles
- Request-Shape Differences Across All Four PlatformsWhere the model ID goes (URL path vs request body), where anthropic_version goes (request header vs body field), and which value each platform requires — side by side.
- Authentication Across Platforms: x-api-key, SigV4, ADC, and Entra IDWhat auth layer each platform expects — API key header, AWS SigV4 signing, Google Application Default Credentials, or Azure API key / Entra ID — and what the SDK client classes handle automatically.
- The anthropic-beta Header: Which Platforms Pass It ThroughThe beta header reaches Claude on 1P, Claude Platform on AWS, Vertex, and Foundry, but the legacy Bedrock InvokeModel surface does not support it — what breaks when you forget this and how to gate beta features by platform.
- Building a Provider Factory: One Call Site, Four BackendsA factory function that reads a PLATFORM env var and returns the right SDK client (AnthropicAWS, AnthropicBedrockMantle, AnthropicVertex, or AnthropicFoundry) so the rest of your application code never branches on platform.
- Environment Variables Across SDK Clients: What Each Platform ReadsThe complete set of env vars each provider client resolves at construction time, and a portable twelve-factor config layout that covers all four platforms without code changes.
- The anthropic. Prefix Rule: Why Bedrock Model IDs Are DifferentOnly Amazon Bedrock prefixes model IDs with anthropic.; the current Mantle surface uses bare-prefixed dateless IDs while the legacy InvokeModel surface uses ARN-versioned IDs — how to build a resolver that returns the right form per platform.
- Vertex AI Model IDs: The @date Form and Cross-Platform Lookup TablesOlder Claude models on Vertex require a @date version suffix (e.g. claude-haiku-4-5@20251001) while the 4.6+ generation uses bare IDs — how to maintain a lookup table that maps canonical IDs to platform-specific forms at runtime.
- Upgrading from Legacy Bedrock to the Current Mantle SurfaceMoving from InvokeModel / Converse with AnthropicBedrock, ARN-versioned model IDs, and the bedrock-2023-05-31 body field to AnthropicBedrockMantle, anthropic.-prefixed dateless IDs, and the standard Anthropic request shape.
- Porting a Vertex AI Workload to Claude Platform on AWSThe concrete changes when migrating from AnthropicVertex to AnthropicAWS: swapping ADC for SigV4, adding the anthropic-workspace-id header, keeping bare model IDs, and validating feature parity.
- The 30-Percent Tokenizer Jump: Rebaselining Costs When Upgrading to Opus 4.7 and LaterOpus 4.7 and later, Sonnet 5, and Fable 5 use a newer tokenizer producing roughly 30% more tokens for the same text — what this means for context window capacity, cost estimates, and cache hit rates when you upgrade.
- Prompt Cache Invalidation on Model Upgrade: How to Pre-warm the New ModelChanging the model string clears the existing prompt cache regardless of content; how to pre-warm the replacement model's cache during a gradual rollout to avoid a cold-cache cost spike on cutover.
- Upgrading Through Three Thinking API GenerationsThree distinct thinking parameter shapes exist across model generations — extended thinking (budget_tokens), adaptive + effort, and always-on adaptive (Fable 5) — with the exact parameter changes and 400-error triggers at each upgrade step.
- Rebaselining Tool-Schema Token Overhead When Upgrading Model VersionsSystem-prompt and tool-definition token overhead differ by model version (e.g. Opus 4.8 auto-mode adds 290 tokens vs Opus 4.7's 675); how to re-measure before upgrading to avoid context-limit surprises and cost underestimates.
- Batch Processing Across Platforms: Anthropic Message Batches vs Cloud-Native AlternativesAnthropic's Message Batches API (1P and Platform on AWS only, 50% discount) vs Bedrock's S3-based async inference vs Vertex AI's GCS/BigQuery batch endpoint — when each applies and what the platform constraints mean for workload design.
- The Files API Portability Gap: Where It Works and the Inline FallbackThe Files API is available on 1P, Claude Platform on AWS, and Foundry (Hosted-on-Anthropic deployments) but not on Bedrock or Vertex AI; how to detect availability at startup and fall back to inline base64 payloads for platforms that lack it.
- Web Search Across Platforms: Absent, Basic, or FullWeb search is absent on Bedrock, limited to the basic web_search_20250305 variant on Vertex (no dynamic filtering), and fully supported on 1P and Claude Platform on AWS — how to detect and gate server-side tool use by platform at initialization.
- Automatic Prompt Caching: Where It Works and How to Degrade GracefullyAutomatic caching via a single top-level cache_control field is unavailable on Bedrock and Vertex AI; explicit cache_control breakpoints on content blocks work on all platforms — how to write cache code that downgrades cleanly when the platform lacks the automatic mode.
- Image Source Types Across Platforms: URL and file_id vs Base64 OnlyURL-referenced and Files API file_id image sources work on 1P and Claude Platform on AWS; Bedrock and Vertex accept base64 only — an adapter layer that fetches and encodes images before sending on platforms that require it.
- PDF Source Types Across Platforms: URL and file_id vs Base64 OnlyPDF document blocks support URL, base64, and file_id sources on 1P and Claude Platform on AWS but only base64 on Bedrock and Vertex AI — how to build a portable document-delivery layer and what the Bedrock Converse API citation caveat adds.
- Dual-Platform Rate-Limit Isolation: Exploiting Independent Token PoolsRunning on two platforms simultaneously gives two separate rate-limit pools; how to design a routing layer that overflows onto the second platform when the first returns 429 without double-counting quota or doubling costs.
- Normalizing Costs Across CCU Billing and Per-Token BillingClaude Platform on AWS and Foundry bill in CCUs metered through their respective cloud marketplaces while Bedrock and Vertex bill per token directly — how to build a unified spend model when dual-running across billing surfaces.
- CCU Billing, MACC Eligibility, and Platform-Selection Trade-offsFoundry CCU spend decrements your Microsoft Azure Consumption Commitment and Claude Platform on AWS CCUs flow through AWS Marketplace billing — how committed-spend programs on each cloud can influence which platform your workload lands on.
- MCP Connector Availability: Where It Works and the Routing Workaround for BedrockThe MCP connector is in beta on 1P, Claude Platform on AWS, and Foundry but absent on Bedrock and Vertex AI; how to route MCP-dependent workloads to a supported surface without redesigning tool definitions.
- Fable 5 and the 30-Day Retention Requirement: A Cross-Platform Portability ConstraintFable 5 requires a minimum 30-day data retention window and is not ZDR-eligible on any platform — how this constraint narrows platform and configuration options for regulated workloads that need zero data retention.
- Normalizing Error Responses Across Platforms for Retry LogicBedrock wraps errors in AWS SDK exceptions, Vertex in Google API error structures, and Foundry in Azure APIM responses alongside its apim-request-id header — how to normalize all of these to Anthropic's HTTP status plus error type string for platform-agnostic retry and fallback logic.
Scaling, Quotas & Capacity Planning 25 articles
- Bedrock's Two Quota Pools: Mantle vs Runtime Endpoint LimitsThe bedrock-mantle and bedrock-runtime endpoints track completely separate TPM allocations for the same Claude model, so a quota increase on one endpoint has no effect on traffic hitting the other.
- How Bedrock Mantle Reserves Token Quota Before Generation StartsThe mantle endpoint reserves input tokens plus the full max_tokens value upfront when it admits a request, then releases the unused reservation after generation completes — making max_tokens choice a live quota-management decision.
- Cache-Read Tokens Don't Count Against Bedrock Mantle QuotaTokens served from a prompt cache hit are excluded from the mantle input-TPM counter, meaning a workload with a high cache hit rate can process far more total tokens per minute than its nominal quota figure suggests.
- Vertex AI's Lineage Quota: One Shared Bucket for All Opus VersionsClaude models launched after May 2026 on Vertex share a single quota bucket per model family rather than per model version, so all Opus variants draw from one pool and adding a new Opus version requires no extra quota request.
- Why the Vertex Quota Page Can Misreport Your Token ConsumptionAnthropic's token estimation and partial-refund system causes the Google Cloud Console quota view to diverge from actual billed usage; accurate consumption figures require the token-counting API or Cloud Monitoring metric queries.
- Foundry Quota Is Shared Across Every Deployment in a SubscriptionAll Global Standard deployments of the same model version within an Azure subscription draw from one shared RPM and ITPM pool regardless of which region they are deployed to, so adding more deployments does not multiply available capacity.
- What Foundry Actually Counts as Input Tokens for Rate LimitingFoundry's ITPM counter includes uncached input tokens and cache-write tokens, but excludes output tokens and cache-read tokens — a different accounting than the Claude API's own ITPM definition, affecting how you estimate headroom.
- Foundry Doesn't Return Rate-Limit Headers: How to Monitor Quota InsteadMicrosoft Foundry does not emit the standard anthropic-ratelimit-* response headers that signal remaining capacity, so teams must use Azure Monitor metrics and the Foundry portal's monitoring tab to observe quota consumption in real time.
- Claude Platform on AWS Stays on Start Tier Until You Ask AnthropicOrganizations on Claude Platform on AWS remain on the Start usage tier indefinitely with no automatic promotion, unlike the Claude API where tiers advance over time — raising limits requires contacting Anthropic directly.
- Claude Platform on AWS Runs from Its Own Isolated Capacity PoolAnthropic-operated capacity on Claude Platform on AWS is entirely separate from both the Claude API pool and Amazon Bedrock, so congestion or quota exhaustion on one platform does not drain capacity available on the others.
- TPM or RPM: How to Calculate Which Limit Will Constrain You FirstDividing your average tokens per request against your target concurrency reveals whether your workload will hit the tokens-per-minute ceiling or the requests-per-minute ceiling first — and each demands a different mitigation strategy.
- Estimating Required Quota from Workload Shape Before LaunchMultiplying peak concurrent requests by average tokens per request yields a required TPM figure that you can compare against published platform defaults to identify quota gaps before your application handles real traffic.
- The New Tokenizer Shifts Your Quota Budget by Up to 30%Opus 4.7 and later, plus Sonnet 5, produce roughly 30% more tokens for the same text than earlier models, which directly changes how much TPM headroom the same workload consumes when you migrate to a newer generation.
- Long-Context Requests Consume TPM Disproportionately FastA request carrying a 900k-token context window can exhaust as much tokens-per-minute quota as hundreds of short requests, making large-context workloads a distinct capacity planning problem requiring dedicated scheduling or quota allocation.
- Using Batch Processing as a Capacity Relief ValveRouting non-time-sensitive jobs to the Batch API at 50% discount — or to cloud-native batch services on Bedrock and Vertex at 50% of on-demand pricing — offloads work from the real-time quota pool and lets urgent traffic claim that headroom.
- Prompt Caching Can Multiply Your Effective TPM Several Times OverOn the Claude API and Bedrock Mantle, cache-read tokens are excluded from input-TPM limits, so a workload with a 90% cache hit rate processes ten times more total tokens per minute than its nominal quota number would imply.
- Each Model Family Has Its Own Quota Pool: Leverage ThatHaiku 4.5 and Opus models draw from separate TPM buckets on every platform, so routing high-volume low-complexity requests to Haiku conserves Opus and Fable quota for the work that genuinely needs a more powerful model.
- Token Buckets Replenish Continuously: The Burst Window and Its LimitsClaude API rate limits use a continuous-replenishment token-bucket algorithm rather than fixed-interval resets, creating a short burst window above the steady-state rate — but acceleration limits cap how fast traffic can ramp before 429s appear.
- Setting Per-Workspace Rate Limits Below the Organization CeilingThe Claude API lets you configure custom spend and token limits on individual workspaces, enabling per-application or per-cost-center throttling without touching the organization-wide cap — a control not available on Claude Platform on AWS.
- Why Sudden Traffic Spikes Trigger 429s Even When You Have QuotaAcceleration limits mean opening the throttle too quickly causes throttling even when nominal TPM headroom is available; the correct launch pattern is a gradual ramp over minutes rather than sending full traffic immediately.
- Monitoring Quota Consumption: A Platform-by-Platform GuideRate-limit response headers signal remaining capacity on the Claude API; CloudWatch metrics cover Bedrock; Cloud Monitoring covers Vertex; Azure Monitor covers Foundry — each platform exposes quota burn through different tooling.
- Pooled vs Isolated: How Multi-Region Quota Accounting Differs by PlatformBedrock cross-region inference profiles pool quota across regions into one bucket, while Vertex AI global and multi-region endpoint quotas are completely independent buckets — a difference that shapes how multi-region failover actually increases available capacity.
- inference_geo Doesn't Grant Extra Quota: The Shared Pool TrapSetting inference_geo to "us" on the Claude API pins where inference runs for data-residency purposes but does not allocate additional capacity; US and global routing draw from the same rate-limit pool, so throughput and residency are entirely separate concerns.
- Right-Sizing Model Choice to Reach a Throughput TargetChoosing the cheapest model that meets quality requirements also maximizes requests per minute per dollar, because Haiku 4.5 supports a far higher RPM ceiling than Fable 5 within the same usage tier.
- Foundry Pay-As-You-Go vs Enterprise Rate Limits: An Order-of-Magnitude GapPay-as-you-go Azure subscriptions receive a small fraction of the RPM and ITPM available to Enterprise and MCA-E contracts — and Fable 5 is capped at zero on pay-as-you-go — making subscription type a prerequisite check before planning any capacity model.