Claude Architect · Lesson

Full History Is Required

Every request carries the entire conversation.

Full History Is Required is a free Claude Architect lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Claude Architect learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

The Model Keeps No State

The most important fact about the Claude API: the model is stateless. It remembers nothing between requests. There is no hidden session on Anthropic's side holding your earlier turns.

Every time you call the API, you send the entire conversation history in the messages array. If a fact isn't in that array, the model simply doesn't know it — even if it told you the same fact thirty seconds ago.

For a Claude Certified Architect, internalizing this changes how you design every multi-turn system, agentic loop, and multi-agent handoff.

Anatomy of a Request

A Claude API request carries a fixed set of fields. The ones you'll touch on every turn:

model — which Claude model to call
max_tokens — output budget
system — the system prompt (instructions, persona, rules)
messages — the full conversation history as an array of role/content objects
tools and tool_choice — optional tool definitions and selection control

Notice what is NOT here: any kind of conversation ID or session token. State lives entirely in what you resend.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="You are a concise travel assistant.",
    messages=[
        {"role": "user", "content": "I want to visit Japan in spring."}
    ],
)

Building the History Array

To continue a conversation, you don't 'reply' to a session — you append the model's previous answer and the new user turn to the same messages list, then resend the whole thing.

The pattern: take last turn's messages, push the assistant's response, push the new user message, and call again. The array grows with every exchange.

messages = [
    {"role": "user", "content": "I want to visit Japan in spring."},
    {"role": "assistant", "content": "Great — cherry blossom season peaks in early April."},
    {"role": "user", "content": "What about the weather then?"},
]

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=messages,  # full history, every turn
)

What Happens If You Forget

Suppose you send only the latest user message — "What about the weather then?" — and drop the earlier turns. The model has no idea what 'then' refers to or that Japan was ever mentioned.

It will either ask for clarification or hallucinate a context. This is the single most common cause of 'the bot forgot what we were talking about' bugs. The fix is never a prompt trick — it's resending the full history.

Tool Results Are Part of History Too

History isn't just user and assistant text. When the model calls a tool, the conversation continues with structured turns:

an assistant turn containing a tool_use block
a user turn containing the matching tool_result

You must append the tool result back into messages and resend everything. The model only 'sees' the tool's output because it's now part of the history you carry forward.

messages.append({"role": "assistant", "content": response.content})  # has tool_use
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": tool_use_id,
        "content": "Tokyo, April: ~15C, mild, occasional rain.",
    }],
})

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    messages=messages,  # history now includes the tool_result
)

The Agentic Loop Carries History

This is why the agentic loop works the way it does. Each iteration: send the request, inspect stop_reason, and if it's tool_use, run the tools, append the results to history, and loop again — until stop_reason is end_turn.

The loop is fundamentally a history-accumulation loop. Terminate on the stop_reason, NEVER by scanning the text for words like 'done'. An iteration cap is a safety net, not the primary stop mechanism.

while True:
    response = client.messages.create(
        model="claude-sonnet-4-5", max_tokens=1024,
        tools=tools, messages=messages,
    )
    if response.stop_reason == "tool_use":
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": run_tools(response)})
        continue  # resend the FULL grown history
    break  # end_turn -> done

Subagents Do NOT Inherit History

Here's the multi-agent trap. In a hub-and-spoke system, a coordinator delegates work to subagents via Task calls. But a subagent gets a fresh conversation — it does NOT inherit the coordinator's message history.

If the subagent needs the customer's ID, the order number, or any earlier finding, the coordinator must pass it explicitly inside the subagent's prompt. Assuming inheritance is a guaranteed failure: the subagent runs blind.

Passing Context Explicitly

Because state isn't shared, the coordinator's job includes packaging the right context into each delegation. Give the subagent exactly what it needs to act — no more (least privilege also applies to context).

Multiple Task calls in one response run in parallel, and each one is a self-contained brief. Treat every subagent prompt as a complete, standalone request.

subagent_prompt = f"""
You are researching flight options.
Context (you have no other history):
- Destination: Tokyo, Japan
- Travel window: early April 2026
- Origin: Istanbul (IST)
Return the 3 cheapest round-trip options with dates and prices.
"""
# Coordinator allowedTools must include "Task".
# Subagent starts with a blank message history -> context must be inline.

History Grows — and So Does Cost

Resending everything has a consequence: each turn re-tokenizes the entire history. Long conversations mean larger, slower, costlier requests, and eventually the context window fills up.

Architect-level reliability work is about managing that growth without losing fidelity:

Trim verbose tool output to only the relevant fields before appending.
Progressive summarization compresses old turns — but beware: it makes numbers, percentages, and dates vague.

Keep Transactional Facts Verbatim

The fix for vague summaries: pull hard facts — order IDs, amounts, dates, verified identities — into a separate 'case facts' block kept verbatim, outside the summary. Summarize the chatter, never the numbers.

Also mind lost-in-the-middle: models attend most to the start and end of the context. Put the most critical facts and the current instruction where they'll be seen, not buried in the middle of a long history.

messages = [
    {"role": "user", "content":
        "CASE FACTS (verbatim):\n"
        "- Order #A-4471, total $129.00, placed 2026-03-02\n"
        "- Customer verified: ID CUST-8830\n\n"
        "CONVERSATION SUMMARY:\n"
        "Customer reported a late delivery and requested options."
    },
    {"role": "user", "content": "Now: can you process a partial refund?"},
]

Sessions Resume — Tool Results May Be Stale

Claude Code persists history across sessions: --resume <name> continues a named session, and fork_session branches from a shared point. Convenient — but a caution worth remembering for the exam.

Resumed tool results can be stale if the codebase changed since they were captured. Carrying forward old history isn't always right; sometimes a fresh session seeded with a clean, structured summary beats replaying outdated context.

# Continue a prior named session (history reloaded)
claude --resume refactor-auth

# Branch from a shared point without polluting the original
# fork_session -> new line of exploration from the same base

Quick Check: The Forgetful Subagent

A scenario testing the core decision of this lesson.

Recap: Full History Is Required

Lock these in for the exam and for real systems:

The model is stateless; every request must carry the entire messages history.
Tool calls extend history — append each tool_result and resend everything.
The agentic loop is a history-accumulation loop; stop on stop_reason, not on parsed text.
Subagents do not inherit the coordinator's history — pass all context explicitly in each prompt.
History grows: trim verbose tool output, summarize old turns, but keep transactional facts verbatim and mind lost-in-the-middle.
Resumed sessions can carry stale tool results — sometimes a fresh session with a clean summary is better.

Frequently asked questions

Is the “Full History Is Required” lesson free?

Yes — the full text of “Full History Is Required” is free to read here on the web, and the Claude Architect course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Claude Architect course, upgrade to CoddyKit PRO.

What will I learn in “Full History Is Required”?

Every request carries the entire conversation. You practise Claude Architect with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Claude Architect?

No prior experience is required. Claude Architect on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Full History Is Required” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Claude Architect lesson?

Yes. Every Claude Architect lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Claude Architect