Test across lengths: Evaluate quality at increasing input sizes, so the breaking point is found.

Identify the threshold: Determine where quality drops, so you know the safe limit.

Chunk beyond the limit: Split oversized inputs, so long content is handled in pieces.

Summarize or retrieve: Condense long inputs, so the model works within its effective range.

Warn or degrade gracefully: Handle over-limit inputs explicitly, so quality doesn't silently collapse.

Link actions to triggers: Record what request caused each action, so causation is traceable.

Capture full context: Log inputs, reasoning, and decisions per action, so the why is preserved.

Assign correlation IDs: Tag the whole chain from request to action, so the path is reconstructable.

Store immutably: Keep tamper-proof records, so the trail is trustworthy.

Make it queryable: Enable looking up any action's cause, so audits are practical.

Change one thing at a time: Isolate each optimization, so its effect is attributable.

A/B test each: Compare with and without the change, so impact is measured, not assumed.

Baseline before optimizing: Capture pre-change metrics, so you have a reference.

Attribute quantitatively: Measure each optimization's contribution, so you know what worked.

Retire ineffective ones: Drop changes with no measurable benefit, so complexity stays justified.

Acknowledge instantly: Confirm receipt right away, so the user knows it's handled.

Process asynchronously: Run the long task in the background, so the response isn't blocked.

Provide a status handle: Give a way to check progress, so users can follow along.

Notify on completion: Push results when done, so users get the outcome without polling.

Show progress: Update status during the task, so waiting feels informed.

Audit for contradictions: Review prompts for conflicting directives, so contradictions are found.

Establish precedence: Define which instructions win when they conflict, so behavior is predictable.

Test edge cases: Probe where instructions might collide, so unpredictability surfaces.

Simplify instructions: Remove redundant or overlapping rules, so fewer conflicts arise.

Validate on change: Check new instructions against existing ones, so conflicts aren't introduced.

Detect conflicts: Identify when sub-agent results disagree, so conflicts aren't resolved blindly.

Weight by reliability: Trust more reliable sub-agents more, so resolution favors quality.

Use a reconciler: Have a component adjudicate disagreements, so resolution is deliberate.

Seek more evidence: Gather additional signal on conflicts, so decisions are informed.

Escalate the unresolvable: Route genuine ties to a human, so hard conflicts get judgment.

Hold out a blind set: Keep test data the team never inspects, so it can't be optimized against.

Rotate eval cases: Refresh the set periodically, so continued tuning can't overfit a fixed set.

Separate dev and test: Tune on one set, evaluate on another, so validation stays honest.

Watch for suspicious gains: Flag improvements that don't generalize, so overfitting is caught.

Validate on fresh production data: Test against new real traffic, so scores reflect reality, not memorization.

Detect incoherence: Recognize when a request doesn't make sense, so the agent doesn't answer earnestly.

Seek clarification: Ask the user to rephrase, so genuine intent can be recovered.

Avoid fabricating meaning: Don't invent an interpretation to answer, so you don't produce nonsense.

Handle gracefully: Respond helpfully to confusion, so the user isn't left stuck.

Deploy with rolling updates: Update instances gradually, so some always stay serving.

Use blue-green deployment: Switch traffic between environments, so cutover is instant and reversible.

Drain connections gracefully: Let in-flight requests finish before shutting down, so users aren't dropped.

Health-check before routing: Send traffic only to ready instances, so half-started ones don't serve.

Keep rollback instant: Revert to the prior version immediately on trouble, so a bad deploy is quickly undone.

Lead with the answer: Put the key point first, so users get it immediately.

Structure by importance: Order content most-to-least critical, so priority is clear.

Use appropriate formatting: Apply structure that aids scanning, so users find what they need.

Match structure to content: Fit the format to the answer type, so structure serves clarity.

Summarize when long: Provide a takeaway upfront for detailed answers, so the point isn't lost.

Generate synthetic cases: Construct examples of rare failures deliberately, so you don't wait for them to occur.

Mine historical failures: Collect past rare cases over time, so you accumulate a corpus.

Adversarially probe: Design inputs to trigger failures, so you surface them on purpose.

Amplify in testing: Weight rare cases heavily in evals, so they get real coverage.

Simulate conditions: Recreate the circumstances that cause failures, so they're reproducible.

Incorporate user context: Factor in the user's situation and constraints, so answers fit their reality.

Retrieve relevant specifics: Pull the user's own data where applicable, so answers are grounded in their case.

Ask about constraints: Clarify situational factors, so you don't answer generically when specifics matter.

Tailor to the scenario: Adapt the answer to the user's context, so correctness is situational.

Flag assumptions: State the context you assumed, so wrong assumptions get corrected.

Deploy regionally: Run inference close to users, so requests don't cross the globe.

Route to nearest region: Direct traffic to the closest deployment, so latency drops.

Cache at the edge: Serve common responses near users, so repeat requests are fast.

Replicate data regionally: Keep indexes local to each region, so retrieval isn't a long round-trip.

Monitor per region: Track latency by geography, so regional problems surface.

Validate config on load: Check values against a schema, so invalid config is rejected before it takes effect.

Set safe defaults: Provide sensible fallbacks, so missing config doesn't break things.

Track overrides explicitly: Record what each environment overrides, so surprises are visible.

Test config changes: Validate overrides before deploying, so bad values are caught early.

Enable fast rollback: Revert config independently of code, so a bad override is quickly undone.

Classify the workload: Detect quick versus deep requests, so each gets suitable handling.

Route to appropriate paths: Send lookups to fast paths and analysis to thorough ones, so each fits its need.

Allocate resources by type: Give deep tasks more time and budget, so they aren't shortchanged.

Set expectations: Signal to users when a request needs more time, so waiting feels intentional.

Escalate when needed: Upgrade a request that turns out complex, so misclassification is recoverable.

Suggest relevant actions: Surface what the agent can do in context, so users learn by doing.

Offer examples: Show sample requests, so users see the range of possibilities.

Proactively hint: Point out capabilities relevant to the current task, so discovery happens naturally.

Guide onboarding: Introduce key features upfront, so users start with a mental model.

Learn from usage: Track what users miss, so you improve where discovery fails.

Model the required sequence: Define valid action orderings explicitly, so constraints are known.

Track completed steps: Maintain state of what's done, so prerequisites can be checked.

Gate on prerequisites: Block an action until its dependencies complete, so ordering is enforced.

Validate before executing: Check the sequence is legal before acting, so out-of-order steps are caught.

Fail safely on violations: Halt or correct when ordering breaks, so bad sequences don't proceed.

Log each stage separately: Capture retrieval and generation outputs distinctly, so you can inspect each.

Evaluate stages independently: Score retrieval and generation on their own, so you isolate the failing one.

Test with perfect context: Give ideal retrieval and check generation, so you rule retrieval in or out.

Trace the full path: Follow a request end to end, so the failure point is locatable.

Categorize failure types: Classify each failure by stage, so patterns guide where to fix.

Carry conversation state: Maintain context across turns, so follow-ups build on what came before.

Resolve references: Interpret pronouns and implicit subjects from history, so "it" and "that" map correctly.

Reuse prior context: Keep earlier retrieved data available, so follow-ups don't need full re-retrieval.

Detect topic shifts: Recognize when a question starts fresh, so old context isn't wrongly applied.

Maintain answer consistency: Align follow-up answers with prior ones, so the thread stays coherent.

Protect quality-critical paths: Reserve capacity for core reasoning, so load doesn't force silent shortcuts.

Degrade explicitly: If you must reduce quality, do it deliberately and visibly, so degradation isn't hidden.

Shed load instead of cutting quality: Queue or reject excess rather than serving worse answers, so quality stays intact.

Scale before degrading: Add capacity under load, so you avoid quality cuts where possible.

Monitor quality against load: Track whether quality drops as load rises, so silent degradation surfaces.