Unify data sources: Aggregate the user's data across systems, so the view is complete.

Resolve inconsistencies: Reconcile conflicting records, so the view is coherent.

Deduplicate: Merge redundant data about the user, so the picture isn't fragmented.

Rank source authority: Prefer authoritative sources on conflict, so the unified view is reliable.

Flag unresolved gaps: Surface where data is missing or conflicting, so the view's limits are known.

Establish a baseline distribution: Know normal variance, so real shifts stand out.

Test for significance: Use enough samples to distinguish signal from noise, so changes are trustworthy.

Run repeated evals: Measure multiple times, so variance is averaged out.

Compare against control: Hold a stable reference, so changes are relative to a constant.

Track trends, not single points: Look at sustained movement, so one-off noise doesn't mislead.

Diagnose the failure: Understand why it failed, so the retry can address the cause.

Vary the approach: Change strategy on retry rather than repeating, so you don't hit the same wall.

Use failure feedback: Feed the error into the retry, so the next attempt is informed.

Try alternative paths: Route retries differently, so a failing path isn't just repeated.

Communicate on persistent failure: Tell the user when retrying won't help, so they aren't stuck looping.

Cache data, not just answers: Cache underlying data with its own freshness, so answers reflect current data.

Tie cache validity to data: Expire answer caches when their source data changes, so stale answers aren't served.

Key caches by data version: Include data version in cache keys, so changed data misses stale cache.

Verify freshness on serve: Check the cached answer's data is still current, so staleness is caught.

Set appropriate TTLs: Match cache lifespan to how fast data changes, so freshness and efficiency balance.

Define sufficiency criteria: Specify what constitutes enough information, so stopping is principled.

Assess marginal value: Judge whether more data would change the answer, so gathering stops when it won't.

Weigh cost against benefit: Balance the time of gathering against accuracy gained, so you stop economically.

Set gathering limits: Cap how long to collect, so it doesn't run indefinitely.

Act on sufficient confidence: Proceed once confidence is adequate, so you don't over-gather.

Detect intent mode: Recognize whether the user wants a quick answer or deep exploration, so handling fits.

Serve transactional fast: Give direct answers to quick queries, so they aren't over-served.

Support exploration: Offer depth, follow-ups, and tangents for exploratory intent, so curiosity is served.

Adapt as it shifts: Switch modes when intent changes mid-conversation, so you stay aligned.

Let users signal: Allow explicit mode choice, so intent isn't only inferred.

Centralize user state: Store per-user state in a shared store, so all instances see the same thing.

Avoid instance-local state: Keep user-affecting state out of individual instances, so behavior doesn't vary.

Use consistent routing where needed: Pin a user to an instance if local state matters, so consistency holds.

Synchronize caches: Share or invalidate caches across instances, so cached state doesn't diverge.

Monitor cross-instance consistency: Detect when a user gets inconsistent behavior, so drift surfaces.

Use strong multilingual embeddings: Choose models with good cross-language coverage, so quality is more even.

Measure per language: Track retrieval quality by language, so weak ones surface.

Supplement weak languages: Add keyword search or translation where embeddings falter, so coverage holds.

Consider per-language models: Use specialized embeddings for underserved languages, so quality improves.

Test across languages: Evaluate retrieval per language, so gaps are caught.

Stream as ready: Deliver results incrementally, so users get value before completion.

Order by usefulness: Return the most useful parts first, so early results matter most.

Mark completeness: Signal what's partial versus final, so users know what to trust.

Let users act on partials: Enable acting on early results, so they aren't blocked waiting.

Complete in the background: Finish remaining work while users use partials, so nothing is lost.

Map the complexity: Inventory prompts, rules, and special cases, so you know what exists.

Identify dead weight: Find rules and cases that no longer matter, so removal targets are clear.

Establish a behavior baseline: Capture current behavior, so simplification can preserve it.

Simplify incrementally: Remove complexity in small verified steps, so risk stays low.

Regression-test each step: Verify behavior holds after each removal, so simplification doesn't break things.

Document what remains: Record why each retained piece exists, so complexity doesn't re-accumulate blindly.

Avoid hard volume assumptions: Design for variable load, so spikes don't break logic.

Bound resource use: Cap what any volume can consume, so spikes don't exhaust resources.

Scale or shed: Add capacity or drop excess under load, so volume is handled gracefully.

Buffer with queues: Absorb spikes, so downstream isn't overwhelmed.

Monitor against assumptions: Alert when volume exceeds expectations, so you react before breakage.

Normalize entities: Standardize names and identifiers, so variants map to one entity.

Resolve entities: Match different representations to the same underlying thing, so duplicates are recognized.

Use identifiers over names: Anchor to stable IDs where possible, so surface variation doesn't confuse.

Reconcile attributes: Merge facts about the same entity from different sources, so information is unified.

Handle ambiguity: Distinguish genuinely different entities with similar names, so resolution doesn't over-merge.

Expose progress: Show what stage the task is at, so users can check in.

Support interruption: Allow users to pause or redirect mid-task, so steering is possible.

Preserve work on change: Keep completed parts when direction shifts, so steering isn't wasteful.

Re-plan on new direction: Adapt the remaining work to the change, so it aligns with new intent.

Confirm significant changes: Verify redirections, so you don't misread a check-in as a pivot.

Recognize cultural context: Detect the user's cultural setting, so appropriateness can adapt.

Adapt content accordingly: Adjust examples, references, and framing, so output fits the context.

Avoid culturally insensitive defaults: Don't assume one culture's norms, so output doesn't offend elsewhere.

Test across cultures: Evaluate appropriateness in multiple contexts, so blind spots surface.

Enable local feedback: Let users flag cultural issues, so real cases inform improvement.

Classify data sensitivity: Tag data by sensitivity level, so handling can adapt.

Apply level-appropriate controls: Use stricter handling for sensitive data, so protection matches risk.

Enforce at boundaries: Change handling as data crosses sensitivity lines, so uniform treatment doesn't under-protect.

Restrict sensitive data flow: Limit where high-sensitivity data goes, so exposure is contained.

Audit sensitive handling: Log how sensitive data was processed, so compliance is verifiable.

Propagate tracing: Pass correlation IDs into sub-agents, so their work is traceable.

Log sub-agent actions: Capture what each sub-agent did, so nothing is a black box.

Return structured results: Have sub-agents report outcomes clearly, so the parent understands what happened.

Surface sub-agent reasoning: Make delegated reasoning inspectable, so failures are diagnosable.

Aggregate observability: Roll up sub-agent telemetry to the parent, so the full picture is visible.

Attribute quality to calls: Trace which calls influenced the final answer, so contribution is visible.

Ablate calls: Remove calls and measure quality impact, so you find which matter.

Track cost per call: Pair each call's cost with its contribution, so value is assessable.

Eliminate low-value calls: Cut calls that don't improve answers, so spend is justified.

Monitor call efficiency: Measure quality-per-call over time, so waste surfaces.

Correct obvious errors: Fix typos and misspellings before retrieval, so noise doesn't block matches.

Use fuzzy matching: Tolerate minor variations, so imperfect queries still match.

Rewrite the query: Normalize noisy input into a cleaner form, so retrieval works from clarity.

Rely on semantic search: Use embeddings robust to surface noise, so meaning matches despite errors.

Confirm on ambiguity: Clarify when a noisy query is unclear, so you don't retrieve on a wrong guess.

Assess before committing: Gauge complexity first, so you choose the right path.

Start cheap, escalate as needed: Try the simple path and upgrade if it's insufficient, so you don't over-invest upfront.

Detect insufficiency early: Recognize when the cheap path won't work, so you escalate promptly.

Preserve work on escalation: Reuse what the cheap path produced, so escalation isn't wasteful.

Monitor path decisions: Track how often escalation happens, so the classifier can be tuned.

Log complete request records: Capture inputs, context, reasoning, and outputs, so behavior is reconstructable.

Version all components: Pin the model, prompt, and config per request, so you know exactly what ran.

Store immutably: Keep tamper-proof records, so audit evidence is trustworthy.

Make records retrievable: Enable looking up any past request, so audits are practical.

Preserve for the required period: Retain records per audit requirements, so evidence survives long enough.