Benefits of Claude Sonnet 5.5 for a Project Risk Register

Most risk registers die the same way: accurate at kickoff, then the status reports pile up and nobody touches the spreadsheet. A Claude risk register fixes the boring part. You give Claude Sonnet 5.5 the weekly reports, meeting notes and your RAID log (risks, assumptions, issues, dependencies), and it proposes updates for a human to approve. Below are five benefits with real prices from the docs, plus the case where you should skip all of it.

What a Claude risk register does well

1. It reads the whole project history in one request

Sonnet 5.5 has a 1M-token context window, which the models overview puts at roughly 555k words. A year of weekly 1,000-word status reports is about 52k words, so you need no chunking or retrieval step. The pricing page says the full window is billed at the standard per-token rate, so a 900k-token request costs the same per token as a 9k one.

That matters because expensive risks often arrive in pieces. It's 'vendor is a bit behind' in week 3, 'test environment not ready' in week 6 and 'go-live date under pressure' in week 9: one problem in three outfits. A model that sees all the reports at once can link them. A skim of one report at a time usually won't.

2. Every proposed risk comes with evidence you can check

Ask for structured output and each entry arrives in your template's shape, with quotes and dates attached. Structured outputs are supported on claude-sonnet-5-5, and the SDK's parse() helper validates the response against your Pydantic model.

import anthropic
from typing import Literal
from pydantic import BaseModel


class Risk(BaseModel):
    title: str
    status: Literal['new', 'recurring', 'escalating']
    likelihood: Literal['low', 'medium', 'high']
    impact: Literal['low', 'medium', 'high']
    evidence: list[str]  # short quotes, each tagged with the report date
    proposed_owner: str  # a name from the documents, or 'unassigned'
    proposed_mitigation: str
    existing_risk_id: str | None  # RAID log ID if this updates an entry


class RegisterUpdate(BaseModel):
    risks: list[Risk]


client = anthropic.Anthropic()

reports = open('q3_status_reports.md').read()
raid_log = open('raid_log.csv').read()

response = client.messages.parse(
    model='claude-sonnet-5-5',
    max_tokens=16000,
    system=(
        'You maintain a project risk register. Propose updates only. '
        'Quote the evidence with its report date. '
        'Use owner names that appear in the documents, never invent one.'
    ),
    messages=[{
        'role': 'user',
        'content': (
            f'<status_reports>{reports}</status_reports>'
            f'<raid_log>{raid_log}</raid_log>'
            'Flag new risks, risks that recur across reports, and risks that are getting worse.'
        ),
    }],
    output_format=RegisterUpdate,
)

for risk in response.parsed_output.risks:
    print(risk.status, risk.title, risk.proposed_owner)

The evidence field is the point. The model drafts the owner and mitigation, a person checks the quoted lines, and only then does the register change. Likelihood and impact are enums because structured outputs reject numeric limits such as minimum and maximum.

3. A refresh costs cents (Claude Sonnet 5.5 pricing)

Sonnet 5.5 costs $2 per million input tokens and $10 per million output tokens. Assume (my numbers, replace with yours) that 12 weeks of reports, notes and RAID log come to 150,000 tokens and the update runs 5,000 tokens.

| Mode | Input (per 1M tokens) | Output (per 1M tokens) | One refresh | | --- | --- | --- | --- | | Standard | $2 | $10 | $0.35 | | Batch | $1 | $5 | $0.175 |

Prompt caching helps inside one sitting. A 5-minute cache write costs $2.50 per million tokens and a cache read costs $0.10. Ten follow-up questions over the same 150k history cost $3.00 in input uncached, versus about $0.51 cached: one $0.375 write plus nine $0.015 reads.

import anthropic

client = anthropic.Anthropic()
reports = open('q3_status_reports.md').read()


def ask(question):
    response = client.messages.create(
        model='claude-sonnet-5-5',
        max_tokens=8000,
        system=[
            {
                'type': 'text',
                'text': 'You are a project risk analyst. Answer only from the documents and cite the report date.',
            },
            {
                'type': 'text',
                'text': f'<status_reports>{reports}</status_reports>',
                'cache_control': {'type': 'ephemeral'},
            },
        ],
        messages=[{'role': 'user', 'content': question}],
    )
    usage = response.usage
    print('written:', usage.cache_creation_input_tokens, 'read:', usage.cache_read_input_tokens)
    return response


ask('Which risks appear in three or more reports?')
ask('Which open risks involve the payments vendor?')

The first call logs a cache write and the second a cache read, as long as the cached prefix is identical. The cache lasts five minutes by default (a one-hour write costs $4 per million), so a weekly cron job gets no benefit, but a Friday review meeting does.

4. Portfolio sweeps run overnight at half price

The Message Batches API takes 50% off both input and output, and most batches finish within an hour, with 24 hours as the limit. For a 40-project portfolio at the same size, that is about $14 standard versus $7 batch.

import anthropic
from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request

client = anthropic.Anthropic()

RISK_PROMPT = 'You maintain a project risk register. Propose updates only, with quoted evidence and report dates.'
projects = {
    'atlas': open('atlas.md').read(),  # status reports + RAID log as one string
    'borealis': open('borealis.md').read(),
}

batch = client.messages.batches.create(
    requests=[
        Request(
            custom_id=name,
            params=MessageCreateParamsNonStreaming(
                model='claude-sonnet-5-5',
                max_tokens=16000,
                system=RISK_PROMPT,
                messages=[{'role': 'user', 'content': docs}],
            ),
        )
        for name, docs in projects.items()
    ]
)
print(batch.id, batch.processing_status)

Poll processing_status until it reads ended, then stream results with client.messages.batches.results(batch.id). One catch from the batch docs: requests and responses are stored for up to 29 days and batch isn't eligible for zero data retention, so check your client's data rules first.

5. It runs where your project data already lives

Registers name vendors, budgets and people, and some clients won't allow another SaaS. The models overview lists the same model on Amazon Bedrock as anthropic.claude-sonnet-5-5 and as claude-sonnet-5-5 on Microsoft Foundry and Google Cloud. Bedrock and Google-managed Claude Models on Google Cloud set their own prices, and the batch docs list only the Claude API, Claude Platform on AWS and Anthropic-managed Google Cloud, so confirm both before budgeting.

When a Claude risk register isn't worth it

If your project has a dozen risks, one weekly report and a PM who reads everything, a spreadsheet and a quick weekly read will beat this setup. Prompts, schema and review time cost more than they save.

Also, the model only sees what is written down. The risk that sinks a project is often the one nobody put in a status report because it involves the sponsor, and that is a conversation, not a document. Treat every output as a draft and never let it write to the register directly.

For anyone putting AI into production, this is a good first workload: cheap to run, easy to verify, and a human signs off on every change.