Anthropic: Claude Opus 5.5 (batch)

Review this 80-page technical specification document for our new API gateway. Identify any inconsistencies in authentication flows, flag potential security gaps, and suggest three concrete improvements to the rate-limiting section.

In this scenario, Claude Opus 5.5 would produce a structured analysis spanning several pages. It would cite specific page numbers and section references, noting that the OAuth2 flow described on page 23 conflicts with the JWT validation logic on page 47. The security review would highlight that the specification lacks explicit handling for token refresh edge cases. For rate-limiting improvements, the model would propose: (1) adding per-endpoint granularity rather than global limits, (2) implementing exponential backoff guidance for clients, and (3) clarifying how distributed rate-limit state syncs across gateway instances. The response would maintain technical precision across the full document scope.

The 1M token context window enables analysis of complete technical documents without chunking or summarization loss. This example shows the model's ability to cross-reference distant sections and maintain coherent reasoning over long inputs. The batch processing mode means responses arrive asynchronously, making this less suitable for interactive debugging sessions where immediate feedback matters.

Here's a screenshot of our dashboard showing anomalous metrics at 3:47 AM. Walk me through what might have caused the spike in database connections while API request volume stayed flat, and outline a debugging plan.

Claude Opus 5.5 would analyze the visual data in the screenshot, identifying the divergence between connection pool saturation and stable request rates. It would hypothesize several root causes: a connection leak in a background job scheduler, a misconfigured connection timeout causing accumulation rather than recycling, or a database migration script holding connections open. The debugging plan would be methodical—first, check application logs for the 3:30-4:00 AM window; second, query the database's process list for long-running transactions; third, review recent deployments for connection-handling changes. The model would reference specific metrics visible in the image to ground each hypothesis.

Multimodal input (image + text) lets engineers paste screenshots directly rather than transcribing chart data. This reduces friction in incident response workflows. However, at $10/Mtok output pricing, lengthy diagnostic responses during high-pressure incidents add cost compared to smaller models that could handle simpler triage questions.

Generate a Python function that parses this 12,000-line XML schema file (attached), extracts all elements with 'required=true', validates their data types against our internal type system (definitions below), and outputs a migration script for our Postgres database. Include error handling for malformed schema entries.

The model would produce a complete Python module with clear separation of concerns: an XML parser using lxml with namespace handling, a validation layer that maps XML schema types to the provided internal type definitions, and a SQL generation component that creates ALTER TABLE statements with appropriate constraints. Error handling would catch malformed XML, undefined type mappings, and circular dependencies in the schema. The code would include docstrings explaining the type-mapping logic and a main() function demonstrating usage with the attached file. Comments would note where manual review is needed—for instance, when a 'required' field conflicts with existing nullable columns in production.

File upload support combined with the large context window means the model can process substantial codebases or data files in a single request. This example demonstrates code generation grounded in specific input artifacts rather than generic templates. The batch processing mode trades immediacy for cost efficiency—suitable for overnight ETL jobs or bulk refactoring tasks, less so for rapid prototyping where iteration speed matters.

Why Opus 5.5 batch mode wins for legal doc review at scale

A 12-person legal ops team needs to extract clauses from 800 vendor contracts every month. They run the job overnight, results ready by 8am. Opus 5.5 in batch mode costs $2/Mtok input and $10/Mtok output—half the price of real-time Opus—and the 1M token context window means each contract (typically 40-80k tokens) fits in a single call with full cross-reference accuracy. The team loads all 800 contracts into a queue at 6pm, Anthropic processes them over 8-12 hours, and the structured JSON hits their CRM before the workday starts. If you need answers in under 60 seconds, batch mode isn't the play. But if your workflow tolerates a 12-hour SLA and you're processing more than 500 documents a month, this is the cheapest way to run Opus-class reasoning at volume.

When to use Opus 5.5 batch for large-scale code migrations

A 20-engineer SaaS company is migrating 150 TypeScript services from REST to gRPC. Each service spans 8-15 files; the refactor requires understanding cross-file dependencies and generating new proto definitions. Opus 5.5's 1M token window lets the model ingest an entire service (typically 120k tokens of code plus docs) in one prompt, so it catches breaking changes across modules that smaller-context models miss. Batch mode cuts the cost to $2 in / $10 out per Mtok—critical when you're running 150 jobs that each generate 30k tokens of output. The team queues all services Friday afternoon, reviews the diffs Monday morning, and merges after spot-checking 10 percent. If you need interactive back-and-forth during the refactor, real-time Opus is better. But for parallelizable, high-token migrations where a 12-hour turnaround works, batch mode is the right economic call.

How Opus 5.5 batch handles multi-source financial synthesis

A 40-person finance team at a mid-market manufacturer produces board decks every quarter by synthesizing data from NetSuite, Salesforce, and three Excel models—total input around 600k tokens per report. Opus 5.5 batch mode ingests all sources in a single context window, cross-references revenue against pipeline without hallucinating line items, and outputs a 15-page narrative with tables in 90 minutes. The $2/$10 per Mtok pricing means each report costs under $8 in API fees versus $16+ for real-time Opus. The team kicks off the job Thursday night, the draft lands Friday morning, and analysts spend the day refining formatting rather than stitching together fragmented outputs. If you're running this weekly or need sub-hour latency, real-time is the move. But for monthly or quarterly cadences where overnight processing works, batch mode delivers Opus reasoning at half the cost.