The 3C Lifecycle

The Story

A mid-market legal technology company built an AI contract review assistant. Lawyers uploaded contracts, asked questions about clause risks, compared terms against precedent, and iterated across multiple review sessions over days or weeks. The product worked well for short sessions. Quality scores averaged 89%.

A lawyer would upload a 40-page supply agreement, ask about indemnification exposure, and get a solid analysis. Twenty minutes of work, maybe eight turns of conversation. Then usage matured. Lawyers stopped doing quick reads. They started running full review cycles -- 30-50 turns across two or three sessions, comparing clauses across multiple documents, referencing analyses from previous weeks.

Turns 1 through 15 felt sharp. Turns 16 through 30 got vague. By turn 40, the assistant was contradicting its own earlier analysis -- because the context window held a compressed summary of the first 20 turns, full verbatim history of the last 10 turns, and nothing in between. The critical clause-by-clause analysis from turn 8 had been compressed into a four-sentence summary that dropped the specific dollar thresholds the lawyer cared about.

Monthly churn spiked. The team investigated model quality, ran prompt experiments, even tested a model upgrade. Nothing moved the needle. The problem was not the model. The problem was what happened to context AFTER it had been assembled.

The seven-letter framework from The CONTEXT Stack defines the bill of materials. Context Assembly is the factory that builds each window. Neither addresses what happens to context over time. Context ages. Context accumulates. Context competes for limited window space as sessions grow. That is the lifecycle problem. The legal-tech company solved it with explicit lifecycle rules: which context gets preserved verbatim, which gets compressed, which gets pre-computed and cached, and which gets dropped entirely. Quality scores climbed back to 91% -- even at turn 40. Monthly cost dropped 34%.

The Core Idea

Context has three operational phases: Create, Compress, and Cache. Every piece of information in a production AI system moves through these phases according to rules the PM designs.

If the seven-letter CONTEXT framework is the bill of materials, the 3C lifecycle is the assembly line -- how the ingredients move through the system over time. Context Assembly builds the context window for a single inference call. The lifecycle manages what happens between calls -- across turns, across sessions, across the product's entire operational lifetime.

Phase 1 -- Create. New information enters the system.

Every source of context has a creation point. The user types a message -- context creation. The retrieval pipeline returns documents -- context creation. A tool executes and returns results -- context creation. The model generates a response -- that response becomes context for the next turn.

The PM's creation decision: what enters and at what fidelity? Not everything the system can create should enter the context window. A database query returning 200 rows might need to enter as a summary or a sample, not the full result set. A retrieved document might enter as key paragraphs, not the complete text.

JetBrains discovered this when building their AI coding assistant. Masking older tool observations reduced costs by 52% while improving task success rates by 2.6%. The older tool outputs were noise. They had served their purpose in earlier turns and were now just consuming tokens and confusing the model.

Phase 2 -- Compress. Summarise to save tokens without losing meaning.

As context accumulates, compression becomes necessary. A 50-turn conversation can consume the entire context window if every turn is preserved verbatim. Compression trades fidelity for space.

Extractive compression pulls the most important sentences or facts directly from the original text, preserving exact phrasing. Research shows extractive methods outperform abstractive methods by +7.89 F1 points on factual retention benchmarks -- because they do not rephrase, they do not introduce subtle distortions.

Abstractive compression generates a new, shorter text that captures the meaning. More flexible, more concise, but risks altering facts. "The indemnification cap is $2.5M per occurrence with a $10M aggregate" might become "the contract includes standard indemnification caps" -- accurate in spirit, useless in practice.

Anthropic's research surfaced a critical finding: for task-critical information, resetting context outperforms compressing it. Compression introduces subtle information loss that compounds across turns. Reset eliminates the accumulated noise entirely. Claude Code implements this -- when context grows too large, it spawns a sub-agent with a fresh window rather than compressing the existing one.

Phase 3 -- Cache. Pre-compute for speed and cost efficiency.

Application-level caching stores the results of expensive assembly stages. The constitution rarely changes -- cache it. Tenant configurations change infrequently -- cache with invalidation on update. A well-designed cache layer can reduce assembly latency by 30-50% for common query patterns.

KV-cache optimisation operates at the model provider level. When the context window starts with the same prefix across calls, the provider can cache the computed attention states and reuse them. Anthropic's documentation shows up to 90% cost reduction on cached prefixes and 85% reduction in time-to-first-token.

The PM's caching decision: what is stable enough to cache, and what is the invalidation strategy? A cached constitution from last week's deployment that does not reflect this week's policy change produces systematically wrong responses -- and nobody notices because the assembly trace shows constitution loaded successfully (it loaded from cache, not from the source of truth). Skip the invalidation rule and your cache becomes the bug.

Where This Hits in Production

Lifecycle rules are product decisions, not infrastructure decisions. When the PM decides compress conversation history after five turns but preserve all decisions verbatim, that is a product-quality decision. When the PM decides cache constitutions for 24 hours with event-driven invalidation, that is a reliability decision. When the PM decides reset context instead of compressing for high-stakes queries, that is a risk-management decision. Hand the policy entirely to engineering and you will discover that the lifecycle policy is whatever was easiest to ship.

Lifecycle failures are invisible until they are catastrophic. Bad compression is the silent killer. A summary that drops a specific number, a cached constitution that is one deployment behind, a creation policy that lets verbose tool output consume the token budget -- none of these throw errors. They produce subtly wrong answers that erode trust over weeks. The only defence is lifecycle-aware monitoring (the topic of Context Observability): tracking not just what the model received but how that content was processed through Create, Compress, and Cache before it arrived.

The 3C lifecycle varies by tenant in B2B. A healthcare customer needs verbatim preservation of all clinical data because of HIPAA audit requirements. A retail customer tolerates aggressive compression of browsing history. A financial-services customer needs 90-day cache retention for compliance. The lifecycle is not one-size-fits-all -- it is a per-tenant configuration the PM designs and the harness enforces.

The Economics of Lifecycle Management

Consider a B2B customer-support platform processing 100,000 queries per day. Without lifecycle management: avg context per query 14,000 tokens, cost per query $0.042, monthly cost $126,000.

With 3C lifecycle optimisation: constitution and tool definitions cached (~3,000 tokens saved per query), conversation history beyond five turns compressed extractively (~2,500 tokens saved), frequent knowledge chunks pre-cached (~120ms latency saved). Avg context 9,200 tokens. Cost per query $0.028. Monthly cost $84,000.

The delta: ~$42,000 per month, or roughly $500,000 annually. Scale to 300,000 queries per day and the savings approach $90,000 per month. The engineering investment in lifecycle management -- typically four to six weeks of one backend engineer -- pays for itself in the first month. Manus AI, building a general-purpose autonomous agent, identified context management as one of the biggest cost drivers and use the file system as extended memory rather than holding everything in the context window. That is a 3C lifecycle in action.

Connecting the Dots

The 3C lifecycle is the operational response to context rot. Context Rot diagnosed the disease: context degrades with volume, position effects cause information loss, irrelevant content dilutes quality. The 3C lifecycle is the treatment: actively manage what enters (Create), reduce what has accumulated (Compress), optimise what is repeated (Cache).

The connection to assembly is sequential. Context Assembly builds the window for each call. The lifecycle manages what is available for assembly to work with across calls. Assembly is a snapshot. The lifecycle is the film.

Asymmetry is the pattern that keeps surfacing. The best lifecycle designs invest heavily in preserving the 10% of context that is load-bearing -- decisions, facts, commitments -- and aggressively compress or drop the 90% that is supporting. The legal-tech company's fix was not compress less. It was compress the right things less. The next topic -- Multi-Turn State -- takes the lifecycle into real-time conversation management.

Remember This

1. Context has a lifecycle -- Create (what enters and at what fidelity), Compress (how context is reduced as it ages), and Cache (what's pre-computed for speed). The PM designs the transition rules. The harness executes them.

2. Not all context deserves the same lifecycle treatment. Load-bearing context (decisions, facts, commitments) should be preserved verbatim or reset. Supporting context (exploration, clarification) can be compressed. Noise (small talk, redundant acknowledgments) should be dropped.

3. For task-critical information, reset outperforms compress. Compression introduces subtle information loss that compounds across turns. When accuracy matters more than continuity, start fresh with the essentials re-injected.

In Practice -- Lifecycle Configuration & Monitoring

Here is a production lifecycle configuration for a B2B financial-advisory platform. The product: an AI assistant that helps financial advisors prepare client meeting briefs, analyse portfolio performance, and draft recommendation letters. Average session: 25 turns across two or three sittings.

3C LIFECYCLE CONFIGURATION -- FinAdvisor AI
Version: 2.4   Effective: 2026-04-01
Tenant class: Enterprise Financial Services

═══════════════════════════════════════════════════
CREATE RULES -- What enters and at what fidelity
═══════════════════════════════════════════════════
  User messages          Verbatim, always
  Model responses        Verbatim for current turn
  Tool results:
    portfolio_query      Summary + key metrics (max 400 tok)
    compliance_check     Full result, verbatim (never truncate)
    market_data          Latest values only
    document_retrieval   Top 3 chunks reranked (max 2,000 tok)

  Creation budget: 4,500 tokens/turn
  Overflow: truncate tool results first, then older KB.
  Never truncate: user message, compliance, recommendations.

═══════════════════════════════════════════════════
COMPRESS RULES -- How context reduces as it ages
═══════════════════════════════════════════════════
  Turn Age    Context Type        Treatment
  0-5 turns   All                 Verbatim
  6-15 turns  Decisions/recs      Verbatim (tagged)
              Compliance results  Verbatim (tagged)
              Portfolio numbers   Extractive summary
              Exploration/Q&A     Abstractive summary
              Small talk          Drop
  16+ turns   Decisions/recs      Extractive summary
              Compliance          Verbatim (never compress)
              Everything else     Drop, reference in metadata

  Compression model: Claude Haiku (fast, cheap)
  Quality gate: must retain proper nouns, dollar amounts,
                dates, action items from source.

  RESET POLICY (overrides compression):
    If session purpose changes, spawn fresh context with
    constitution + extracted decisions + new retrieval.
    Reset, don't compress. Per Anthropic's finding.

═══════════════════════════════════════════════════
CACHE RULES -- What is pre-computed for speed
═══════════════════════════════════════════════════
  Content              Cache TTL    Invalidation
  Constitution         24 hours     On deployment
  Tool definitions     7 days       On release
  Tenant config        1 hour       On settings change
  Compliance rules     6 hours      On regulatory update
  Market data          5 minutes    On price feed update
  Client profiles      30 minutes   On CRM update
  Popular KB chunks    2 hours      On index rebuild

  KV-cache hit rate target: 78%   Cost reduction: 62%
  TTFT reduction: ~70%

TTL -- Time To Live. TTFT -- Time To First Token. KV-caching cuts TTFT dramatically because the model does not have to re-read the system prompt from scratch.

Lifecycle monitoring dashboard (sampled hourly):

3C LIFECYCLE HEALTH -- 2026-04-12 14:00 UTC
══════════════════════════════════════════════════
CREATE METRICS
  Avg tokens created/turn:        3,840
  Budget utilisation:              85%
  Tool result truncations/hour:    142
  Compliance truncations/hour:     0    (target: 0)

COMPRESS METRICS
  Compressions triggered/hour:     2,847
  Avg compression ratio:           4.2:1
    Extractive: 2.8:1   Abstractive: 6.1:1
  Quality gate failures/hour:      23   (0.8%)
    ├── Missing dollar amounts:    11
    ├── Missing dates:             7
    └── Missing proper nouns:      5
  Resets triggered/hour:           89
  Tokens saved by compression:     4.2M/hour

CACHE METRICS
  Constitution cache hit rate:     99.2%
  Tool definition hit rate:        97.8%
  Tenant config hit rate:          84.3%
  KB chunk hit rate:               71.6%
  KV-cache hit rate:               78.4%
  Stale cache incidents (24h):     2

LIFECYCLE ECONOMICS (daily)
  Metric              Without 3C   With 3C
  Avg tokens/query     14,200       9,100
  Avg cost/query       $0.043       $0.027
  Daily cost (80K q)   $3,440       $2,160
  Monthly projection   $103,200     $64,800
  Monthly savings:     $38,400
  Annualised:          $460,800
  Engineering invest:  $85,000 (one-time)
  Payback period:      ~7 weeks

QUALITY IMPACT
  Turn 1-10 quality:   92.1%  (baseline: 91.8%)
  Turn 11-20 quality:  89.7%  (baseline: 84.2%)
  Turn 21-30 quality:  87.3%  (baseline: 76.1%)
  Turn 31+  quality:   85.8%  (baseline: 68.4%)
  3C quality lift at turn 30+: +17.4 percentage points

What the financial advisor sees. A consistently helpful assistant that remembers important decisions and recommendations from earlier in the session -- even at turn 30+. Portfolio numbers are accurate. Compliance references are precise. The session does not feel foggy the way it did before lifecycle management.

What the PM sees. Compression quality gates catching 23 failures per hour -- mostly missed dollar amounts in abstractive summaries. That is a signal to shift more financial content to extractive compression. The cache stale incident on compliance rules required manual intervention -- that invalidation trigger needs to be automated. The quality lift at turn 30+ (from 68.4% to 85.8%) is the business case. The $460,000 annual savings is the executive summary.

Reset vs. Compress -- Visualized

Accumulated compression preserves noise alongside signal. Periodic reset rebuilds context fresh -- delivering higher quality and lower cost.