Allocate time per step: Divide the deadline across sub-steps, so no one step consumes it all.

Enforce per-step timeouts: Bound each step, so overruns are cut off.

Track remaining budget: Monitor time left as steps complete, so later steps adapt.

Prioritize essential steps: Ensure critical steps get their time first, so the core is protected.

Return best-available on deadline: Deliver what's ready when time runs out, so the deadline is met.

Target the specific question: Retrieve for what answers the query, not just the topic, so results are useful.

Rerank for answer content: Prioritize chunks that contain answers, so answerability drives ranking.

Decompose the query: Retrieve for each part of a complex question, so all needed content is found.

Check answerability: Verify retrieved context can actually answer, so topically-relevant-but-useless results are caught.

Re-retrieve on insufficiency: Search again when context can't answer, so gaps are filled.

Weight action costs: Factor the high cost of wrong action, so caution is favored.

Require confidence to act: Set a high bar for taking action, so uncertain cases default to inaction.

Prefer reversible steps: Choose actions that can be undone, so mistakes are less costly.

Escalate instead of acting: Route uncertain high-stakes cases to humans, so risky action isn't automated.

Make inaction a valid choice: Treat doing nothing as an acceptable outcome, so the agent isn't forced to act.

Track source changes: Detect when source facts are corrected, so propagation can begin.

Re-index corrected content: Update the index when sources correct, so retrieval reflects fixes.

Invalidate affected answers: Clear cached answers built on corrected facts, so stale ones aren't served.

Prefer current source for critical facts: Verify important facts against live sources, so corrections are honored.

Notify on material corrections: Alert users whose prior answers are affected, so acting on corrected info is possible.

Test combinations, not just parts: Evaluate capabilities working together, so integration issues surface.

Cover common interactions: Test how capabilities are actually combined, so real usage is validated.

Watch for emergent behavior: Check whether combinations produce unexpected results, so surprises are caught.

Isolate combination failures: Diagnose which interaction breaks, so it can be fixed.

Expand combination coverage: Add newly used combinations to tests, so validation keeps pace.

Segment evaluation: Measure changes on key segments separately, so their impact is visible.

Set segment guardrails: Block changes that harm important segments, so they're protected.

Weight high-value cases: Give critical segments extra weight in evals, so their needs aren't averaged away.

Test on power-user scenarios: Include their use cases in testing, so regressions surface.

Monitor segments post-change: Watch key segments after rollout, so harm is caught fast.

Express predictions as probabilities: Frame forecasts with uncertainty, so they aren't stated as fact.

Ground predictions in evidence: Base them on actual data, so they're not speculation.

Communicate confidence: Signal how certain a prediction is, so users weigh it appropriately.

Avoid false precision: Don't state more certainty than warranted, so predictions aren't misleading.

Note what could change it: Surface factors that would alter the prediction, so users understand its basis.

Separate content from presentation: Generate core content, then render per consumer, so one logic serves both.

Provide multiple formats: Offer machine-readable and human-readable versions, so each gets what it needs.

Structure for machines: Include parseable structure, so machine consumers can rely on it.

Format for humans: Present readable output for people, so it's usable.

Detect the consumer: Serve the right format based on who's consuming, so each is well-served.

Segment by content type: Separate primary content from comments, so each is treated differently.

Weight by authority: Trust primary content over user-generated parts, so unreliable content has less influence.

Tag content reliability: Mark sections by trust level, so the model knows what to lean on.

Ground answers in the reliable parts: Prefer authoritative content for claims, so answers rest on solid ground.

Flag reliance on unreliable content: Signal when an answer draws on comments, so users judge accordingly.

Quantify the benefit: Estimate the value a capability adds, so it's weighed concretely.

Assess added complexity: Evaluate the maintenance and risk it introduces, so cost is clear.

Weigh against alternatives: Consider simpler ways to get most of the value, so you don't over-build.

Consider the long-term burden: Factor ongoing cost, not just build cost, so complexity is fully priced.

Decide against clear criteria: Judge on a value-versus-complexity threshold, so decisions are principled, not impulsive.

Abstract external capabilities: Wrap third-party systems behind stable interfaces, so you're insulated from their internals.

Handle their unreliability: Add timeouts, retries, and fallbacks, so external failures don't break you.

Respect their constraints: Stay within their limits and terms, so integrations remain viable.

Degrade when they're unavailable: Function partially without them, so you don't fully depend on systems you don't control.

Monitor external dependencies: Track their health, so their problems surface as yours before users notice.

Track source dates: Record when each source was published or updated, so age is known.

Weight by recency: Favor fresher sources where currency matters, so outdated data doesn't dominate.

Surface source age: Show when information is from, so users judge currency.

Prefer current for volatile facts: Use the freshest source for fast-changing topics, so answers stay accurate.

Flag potential staleness: Warn when relying on older sources, so users are aware.

Evaluate the intermediate outcome: Assess the earlier step's result, so branching is informed.

Branch on the result: Choose the path based on actual outcome, so you adapt to what happened.

Handle uncertain outcomes: Account for low-confidence intermediate results, so branching isn't overconfident.

Verify before branching: Confirm the intermediate result when stakes are high, so you don't branch on a wrong basis.

Support re-branching: Allow correcting course if the branch proves wrong, so mistakes are recoverable.

Attribute cost granularly: Break spend down by feature, user, and request type, so drivers are visible.

Track cost over time: Monitor spend trends, so variation is observable.

Correlate with usage: Link cost changes to usage patterns, so causes are found.

Identify anomalies: Flag unusual cost spikes, so surprises are explained.

Report cost drivers: Surface what drove each period's spend, so variation is understood.

Assess input quality: Evaluate incoming data's reliability, so trust can be calibrated.

Weight by quality: Rely more on high-quality input, so poor data has less influence.

Verify low-quality input: Cross-check questionable data, so it isn't taken at face value.

Flag quality issues: Signal when answers rest on poor input, so users judge accordingly.

Handle poor input gracefully: Degrade rather than confidently answer from bad data, so errors don't propagate.

Add a regression test: Encode the exact case in evals, so it's checked on every change.

Fix the root cause: Address why it failed, not just the symptom, so the class of failure is prevented.

Add a guardrail: Put a deterministic check for the case, so it's caught even if the fix regresses.

Verify the fix holds: Confirm the case now passes, so the fix works.

Monitor for recurrence: Watch for the pattern in production, so any return is caught immediately.

Group into transactions: Treat the operations as one atomic unit, so partial completion can't happen.

Stage before committing: Prepare all operations, then commit together, so nothing applies until all can.

Compensate on failure: Undo completed operations when the group fails, so partial state is reversed.

Make operations idempotent: Ensure safe retries, so recovery doesn't compound problems.

Verify group completion: Confirm all-or-nothing held, so inconsistency is caught.

Suggest refinements: Offer better-formed versions of vague questions, so users get more.

Surface relevant dimensions: Point out aspects they might not have considered, so questions get richer.

Ask guiding questions: Draw out what they actually need, so the real question emerges.

Offer examples: Show well-formed questions, so users learn the pattern.

Answer and expand: Address what they asked while surfacing what they didn't, so gaps get filled.

Confirm your understanding: Restate your interpretation, so wrong mental models get corrected early.

Ask clarifying questions: Resolve ambiguous descriptions, so you don't reason from a wrong picture.

Request the actual artifact: Ask for the image or data when words are insufficient, so precision replaces guessing.

Surface assumptions: State what you're picturing, so mismatches are visible.

Adapt on correction: Update quickly when the user clarifies, so errors don't persist.

Monitor usage patterns: Track how the agent is actually used, so unanticipated uses surface.

Detect out-of-validation use: Flag requests outside tested scenarios, so unvalidated use is known.

Handle unknown use safely: Degrade cautiously on unexpected use, so unvalidated paths don't cause harm.

Assess emerging patterns: Evaluate whether new uses should be supported, so you respond deliberately.

Expand validation: Add newly common uses to testing, so validation catches up to reality.