Read impatience signals: Detect when the user wants speed, so you can adapt.

Lead with the answer: Give the essential result first, so impatient users are satisfied fast.

Offer depth optionally: Make thoroughness available without forcing it, so both needs are served.

Match effort to urgency: Scale thoroughness to how much time the user has, so it fits.

Let users choose: Allow explicit fast-versus-thorough selection, so impatience is respected.

Identify order sensitivity: Detect where ordering incidentally affects behavior, so it's addressed.

Make selection order-independent: Choose tools by relevance, not position, so order doesn't matter.

Test with reordering: Vary orderings in tests, so hidden dependencies surface.

Normalize presentation: Present tools and context consistently, so incidental order is removed.

Ground behavior in content: Base decisions on what things are, not where they appear, so ordering is irrelevant.

Identify the audience: Determine who the answer is for, so framing can suit them.

Adapt framing: Adjust emphasis, detail, and language to the audience, so the answer lands.

Match the purpose: Frame for how the answer will be used, so it's actionable in context.

Adjust technical level: Fit terminology to audience expertise, so it's neither over nor under their heads.

Confirm audience when unclear: Ask who the answer is for if ambiguous, so framing isn't a guess.

Detect test signals: Recognize when a request seems exploratory or testing, so handling can adjust.

Handle both correctly: Serve genuine needs fully while not over-committing to tests, so neither is mishandled.

Avoid harmful actions on tests: Don't take real consequential actions for apparent tests, so testing is safe.

Provide a test mode: Offer an explicit way to test safely, so users don't have to trigger real behavior.

Don't dismiss real needs: Avoid wrongly treating genuine requests as tests, so real users are served.

Identify useful information: Recognize what additional data would help, so proactive fetching is targeted.

Fetch relevant context: Retrieve or look up helpful information automatically, so answers are richer.

Balance proactivity against cost: Fetch only when the value justifies it, so you don't over-gather.

Avoid unnecessary fetching: Skip proactive gathering when provided info suffices, so you stay efficient.

Be transparent: Note when you've pulled in extra information, so users understand the basis.

Detect gaming patterns: Recognize inputs designed to exploit the agent, so abuse is caught.

Enforce intent, not just rules: Judge the purpose behind requests, so users can't game the letter of the rules.

Rate-limit exploitation attempts: Throttle suspicious behavior, so gaming is slowed.

Constrain exploitable behavior: Bound what the agent will do, so there's less to game.

Monitor and adapt: Track new gaming tactics and close them, so resistance keeps pace.

Prioritize high-value context: Gather the most decision-relevant context first, so limited time is well spent.

Set a context budget: Cap how much context-gathering time is allowed, so latency is respected.

Decide on sufficient context: Act once you have enough, so you don't over-gather.

Cache to accelerate: Reuse context from prior requests, so gathering is faster.

Degrade gracefully: Make a reasonable decision with partial context, so tight budgets don't block answers.

Tag content status: Mark documents as authoritative, draft, or deprecated, so status is known.

Prefer authoritative sources: Ground answers in approved content, so drafts don't drive answers.

Exclude or flag drafts: Keep unfinished content out of retrieval or clearly marked, so it isn't treated as fact.

Filter by status at query time: Retrieve only appropriate-status content, so answers rest on the right basis.

Surface content status: Tell users when an answer draws on non-authoritative content, so they judge accordingly.

Follow instructions by default: Honor explicit requests, so users stay in control.

Flag likely-suboptimal instructions: Point out when an instruction may hurt the outcome, so users can reconsider.

Suggest the better alternative: Offer the improved approach, so users see the option.

Defer to the user's choice: Let them decide after being informed, so you don't override them silently.

Deviate only with consent: Change course only when the user agrees, so trust is preserved.

Conduct postmortems: Analyze each incident's root cause, so lessons are extracted.

Add regression coverage: Encode each incident as a test, so it can't recur silently.

Fix root causes: Address underlying causes, not just symptoms, so classes of failure are prevented.

Track incident patterns: Look across incidents for recurring themes, so systemic issues surface.

Feed learnings back: Turn lessons into design and process improvements, so the system gets more resilient over time.

Don't assume partner reliability: Treat the partner side as potentially unreliable, so you're defensive.

Add boundary resilience: Use timeouts, retries, and fallbacks at the boundary, so partner issues are contained.

Validate across the boundary: Check partner responses, so their errors don't corrupt your side.

Degrade when the partner fails: Function partially without them, so you're not fully dependent.

Monitor the boundary: Track partner-side health, so their problems surface as yours.

Re-evaluate periodically: Revisit parameters as the corpus changes, so they stay optimal.

Monitor retrieval quality: Track metrics over time, so parameter drift surfaces.

Re-tune on degradation: Adjust parameters when quality drops, so growth doesn't erode retrieval.

Scale parameters with size: Adapt top-k and thresholds to corpus growth, so they fit the new scale.

Automate tuning where possible: Continuously optimize parameters, so they don't go stale.

Add sequence numbers: Tag items with order, so sequence is recoverable despite async delivery.

Buffer and reorder: Hold items until they can be processed in order, so ordering is enforced.

Wait for prerequisites: Block a step until its predecessor completes, so dependencies are respected.

Detect out-of-order arrival: Recognize when order breaks, so it's corrected, not processed wrongly.

Make ordering-independent where possible: Design steps that don't need strict order, so the problem shrinks.

Gauge background: Infer the user's knowledge level, so answers can match it.

Calibrate assumed knowledge: Neither over-explain nor under-explain, so the answer fits.

Adjust terminology: Match jargon to their level, so answers are accessible without being condescending.

Offer to adjust: Let users signal if it's too basic or advanced, so calibration corrects.

Adapt over the conversation: Refine based on their responses, so matching improves.

Identify the core request: Extract what the user actually wants, so you answer the real question.

Filter the noise: Set aside tangential content, so it doesn't distract from the ask.

Handle multiple requests: Detect if the rambling contains several asks, so none is missed.

Confirm on ambiguity: Verify the extracted request when unclear, so you don't answer the wrong part.

Address relevant context: Use pertinent detail from the message, so extraction doesn't lose useful information.

Validate preprocessing output: Check the result of each preprocessing step, so silent failures are caught.

Fail loudly: Surface preprocessing errors rather than passing bad data on, so they don't corrupt downstream.

Handle problem inputs: Manage inputs that break preprocessing, so they're handled, not silently mangled.

Test on diverse inputs: Exercise preprocessing with varied data, so failure cases surface.

Monitor preprocessing health: Track failure rates, so silent problems become visible.

Use context to disambiguate: Interpret terms by their surrounding context, so meaning is resolved.

Maintain a domain glossary: Define term meanings per context, so ambiguity is documented.

Detect ambiguous terms: Recognize when a term could mean multiple things, so it's not resolved blindly.

Confirm on genuine ambiguity: Clarify when context doesn't resolve it, so you don't guess wrong.

Ground in the right context: Retrieve context matching the intended meaning, so answers use the correct sense.

Define autonomy limits: Specify what the agent may do independently, so bounds are explicit.

Gate high-impact actions: Require approval for consequential steps, so autonomy excludes the risky.

Constrain the action space: Limit available actions to safe ones, so autonomy can't cause harm.

Monitor autonomous behavior: Watch what the agent does independently, so overreach is caught.

Expand autonomy incrementally: Grant more as trust is earned, so autonomy grows safely.

Detect prior errors: Recognize when new information contradicts a past answer, so errors are caught.

Acknowledge the correction: Admit the earlier answer was wrong, so trust is maintained.

Provide the correct answer: Replace the error with the right information, so the user is served.

Avoid doubling down: Don't defend a wrong answer, so errors aren't compounded.

Explain what changed: Clarify why the answer is now different, so the correction reads as reasoning.

Track trends, not just thresholds: Watch metrics over time, so slow decline is visible before it breaks.

Baseline normal behavior: Know what healthy looks like, so drift stands out.

Alert on sustained movement: Flag gradual negative trends, so degradation is caught early.

Monitor leading indicators: Watch signals that precede failure, so you get advance warning.

Investigate slow drifts: Diagnose gradual changes before they compound, so failure is prevented.