This prompt is for chaos engineers, SREs, and reliability engineers who need to define a formal, testable steady-state hypothesis before running a chaos experiment. The core job-to-be-done is translating a system's normal behavior into a structured, measurable definition that can be used as a control during fault injection. The ideal user has a specific target system in mind, a planned fault to inject, and access to monitoring dashboards that expose the system's key health metrics. The required context includes the system's architecture, its critical user journeys, and the specific metrics that indicate 'normal' operation. Without this context, the model cannot produce a hypothesis that is both specific and falsifiable.
Prompt
Chaos Engineering Steady-State Hypothesis Prompt

When to Use This Prompt
Defines the specific job, user, and context for the chaos engineering steady-state hypothesis prompt, and clarifies when it should not be used.
The prompt forces the model to produce a structured output that includes key metrics with their normal operating bands, explicit blast radius boundaries, and clear abort conditions. It also validates that the hypothesis is falsifiable—meaning a deviation can be definitively detected—and that the available monitoring is sufficient to observe that deviation. For example, if you are preparing to inject a 500ms network latency fault into a payment service, the prompt will guide the model to define the steady state in terms of p99 latency, error rate, and transaction throughput, and then check whether your dashboards can actually measure a shift from a 200ms to a 700ms p99. This prevents the common anti-pattern of running an experiment without a clear definition of success or failure.
Do not use this prompt for general performance testing, load test scenario design, or incident postmortems. It is specifically scoped to the hypothesis-design phase of chaos engineering, before any fault is injected. If you need to design a load profile from SLA requirements, use the 'API Load Profile Design Prompt.' If you are analyzing a past incident, this prompt will not help you structure a timeline or identify root causes. Using this prompt outside its narrow window will produce a hypothesis that is either irrelevant or untethered from an actual planned experiment. After generating the hypothesis, your next step is to review it with the engineering team that owns the service to confirm the metrics and thresholds are correct before proceeding to experiment execution.
Use Case Fit
Where the Chaos Engineering Steady-State Hypothesis Prompt delivers value and where it introduces risk.
Good Fit: Pre-Injection Experiment Design
Use when: You are designing a chaos experiment and need a measurable, falsifiable hypothesis before injecting faults. The prompt structures the steady-state definition so the team agrees on what 'normal' looks like. Guardrail: Always pair the generated hypothesis with a manual review of the monitoring dashboards to confirm the metrics are actually observable in real time.
Bad Fit: Post-Incident Root Cause Analysis
Avoid when: You are investigating an active incident or performing a postmortem. This prompt is designed for prospective experiment design, not retrospective analysis. Using it during an incident will produce a hypothetical steady state that may not match the degraded reality. Guardrail: Route incident analysis to a dedicated incident summary or root cause analysis prompt instead.
Required Inputs: Observable Metrics and SLOs
Risk: Without concrete latency percentiles, error budgets, or throughput baselines, the model will invent plausible but unverifiable metrics. Guardrail: Provide your actual SLIs and SLOs as [INPUT]. If you lack them, the prompt should be scoped to a 'metric discovery' variant that lists what you should be measuring before any experiment begins.
Required Inputs: Blast Radius Boundaries
Risk: The model may propose a steady-state hypothesis that spans too many components, making deviation impossible to attribute to a single fault injection. Guardrail: Explicitly constrain the [BLAST_RADIUS] to a single fault domain (e.g., a specific pod, AZ, or service) so the hypothesis remains falsifiable and the abort conditions are clear.
Operational Risk: Unrealistic Abort Conditions
Risk: The prompt may generate abort conditions that are too slow to trigger or too vague to automate, leading to prolonged degradation during an experiment. Guardrail: Validate that every abort condition maps to a specific alert threshold in your monitoring system. If an abort condition cannot be automated, the experiment should require a human-in-the-loop approval gate before injection.
Operational Risk: Falsifiability Drift
Risk: A hypothesis that is too broad ('the system will remain available') cannot be falsified by a single fault. Guardrail: Use the prompt's built-in validation step to check that the hypothesis predicts a specific, measurable deviation. If the hypothesis cannot be proven false by the planned injection, reject it and regenerate with tighter constraints.
Copy-Ready Prompt Template
Paste this prompt into your AI harness to generate a falsifiable steady-state hypothesis for chaos engineering experiments.
This prompt template produces a structured steady-state hypothesis that defines normal system behavior before fault injection. It forces the model to identify key metrics, establish operating bands, set blast radius boundaries, and define abort conditions. The output is designed to be directly usable in a chaos experiment plan, with enough specificity that an engineer can configure monitoring dashboards and automation rules from the hypothesis alone.
textYou are a chaos engineering architect. Your task is to produce a falsifiable steady-state hypothesis for a chaos experiment. ## INPUTS - System description: [SYSTEM_DESCRIPTION] - Architecture diagram or component list: [ARCHITECTURE_CONTEXT] - Known failure modes or prior incidents: [KNOWN_FAILURE_MODES] - Monitoring stack and available metrics: [MONITORING_STACK] - Experiment scope and constraints: [EXPERIMENT_SCOPE] - Risk tolerance level: [RISK_LEVEL] ## OUTPUT SCHEMA Return a JSON object with these fields: - hypothesis_statement: A single sentence declaring what steady state will persist during the experiment. - key_metrics: Array of objects with metric_name, query_or_source, normal_band (min, max, unit), and aggregation_window. - blast_radius: Object with affected_components, excluded_components, and justification for each exclusion. - abort_conditions: Array of conditions that trigger immediate experiment termination, each with metric, threshold, and detection_latency. - monitoring_gaps: Array of metrics or signals that are needed but currently unavailable. - falsifiability_check: Explanation of how the hypothesis could be proven false by the experiment results. ## CONSTRAINTS - Every metric must be observable with the stated monitoring stack. - Normal operating bands must reference historical data ranges, not arbitrary thresholds. - Blast radius must include justification for why excluded components are safe. - Abort conditions must include detection latency so automation can be configured. - If the hypothesis cannot be falsified with available monitoring, flag it and recommend instrumentation. - Do not invent metric values. Use [PLACEHOLDER] where real data is needed. ## EXAMPLES [EXAMPLES] ## TOOLS AVAILABLE [TOOLS]
To adapt this template, replace each square-bracket placeholder with your system's specific context. The [SYSTEM_DESCRIPTION] should include the service topology, data flow, and user-facing behavior. The [MONITORING_STACK] must list the actual observability tools and metric names available, because the model will reference them directly in the key_metrics and abort_conditions fields. If you have prior experiment results or incident postmortems, include them in [KNOWN_FAILURE_MODES] to ground the hypothesis in real failure signatures. The [EXAMPLES] placeholder should contain one or two well-formed hypothesis objects that demonstrate your team's expected level of detail and terminology conventions. Before running the experiment, validate that every metric in the output is actually queryable and that abort condition thresholds are wired into your experiment controller. For high-risk production experiments, a human reliability engineer must review the blast radius boundaries and sign off on the abort conditions before fault injection begins.
Prompt Variables
Each placeholder required by the Chaos Engineering Steady-State Hypothesis Prompt. Validate inputs before injection to prevent unfalsifiable or unmonitorable experiments.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[SYSTEM_UNDER_TEST] | Identifies the target service, component, or boundary for the experiment | payment-gateway-primary | Must match a known service in the service catalog or CMDB; reject free-text if no catalog exists |
[KEY_METRICS] | List of metrics that define normal operation and will be monitored during the experiment | p99 latency, error rate, throughput, CPU utilization | Each metric must have a known datasource (Prometheus, Datadog, CloudWatch); reject metrics without an observable endpoint |
[NORMAL_OPERATING_BAND] | The acceptable range for each key metric during steady state, expressed as thresholds | p99 latency < 200ms, error rate < 0.1%, throughput > 500 rps | Each band must include a numeric threshold and comparison operator; reject qualitative bands like 'acceptable' |
[BLAST_RADIUS_BOUNDARY] | The scope of impact the experiment is allowed to affect, including users, services, or regions | us-east-1 region, 5% of traffic via canary routing | Must specify a concrete isolation mechanism; reject experiments with no blast radius containment |
[FAULT_INJECTION] | The specific failure being introduced to test the steady-state hypothesis | terminate 1 of 3 payment-gateway pods | Must be a specific, repeatable action; reject vague injections like 'cause some errors' |
[ABORT_CONDITIONS] | The conditions that trigger immediate experiment termination to prevent excessive impact | error rate exceeds 1% for 30s OR p99 latency exceeds 500ms for 60s | Each condition must include a metric, threshold, and duration; reject abort conditions that are less strict than normal operating bands |
[OBSERVABILITY_WINDOW] | The time period for collecting pre-experiment baseline and post-injection recovery data | 5 minutes pre-injection, 10 minutes post-injection | Must be long enough to establish statistical significance; reject windows under 2 minutes for high-variance metrics |
[HYPOTHESIS_STATEMENT] | The falsifiable prediction about system behavior during the fault injection | If we terminate 1 payment-gateway pod, p99 latency will remain below 200ms and error rate below 0.1% | Must be falsifiable with the specified metrics; reject hypotheses that cannot be disproven by the monitoring setup |
Implementation Harness Notes
How to wire the steady-state hypothesis prompt into a chaos engineering workflow with validation, tool integration, and human review gates.
This prompt is designed to be the first step in a chaos experiment pipeline, not a standalone artifact. The output should feed directly into your experiment execution system—whether that's a chaos platform like Gremlin, LitmusChaos, or a custom fault injection harness. The hypothesis JSON becomes the contract that the subsequent blast radius check, monitoring dashboard configuration, and automated abort logic all reference. Treat the prompt output as a machine-readable experiment definition, not just a planning document.
Wire the prompt into a pre-experiment approval workflow. After the model generates the hypothesis, run a validation layer that checks: (1) every metric in steady_state_metrics maps to an actual observable in your monitoring stack (Prometheus metric name, Datadog query, or log-based metric), (2) the normal_operating_band for each metric has both upper and lower bounds expressed in the same units your dashboards use, (3) the blast_radius explicitly lists affected services, and (4) the abort_conditions reference specific metric thresholds with comparison operators. If validation fails, route back to the prompt with the specific failure reason appended to [CONSTRAINTS] for a correction pass. For high-risk production experiments, require a human to approve the validated hypothesis before any fault injection begins.
Model choice matters here. Use a model with strong structured output capabilities and low hallucination rates on technical specifications—GPT-4o or Claude 3.5 Sonnet with strict JSON mode enabled. Set temperature to 0 or near-zero to maximize consistency across runs. If your chaos platform has an API for experiment creation, map the validated hypothesis fields directly to the platform's experiment schema. Store the full prompt input, raw model output, validation results, and human approval decision in an audit log. This trace is essential for incident reviews when a chaos experiment surfaces a real production issue. Avoid using this prompt without first confirming that your observability stack can actually measure every steady-state metric the model proposes.
Expected Output Contract
Fields, format, and validation rules for the generated steady-state hypothesis. Use this contract to parse, validate, and gate the model output before it enters a chaos experiment workflow.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
steady_state_definition | string | Must contain at least one measurable system property described in plain language. Parse check: non-empty, min 20 characters. | |
key_metrics | object[] | Array of objects with fields: name (string), unit (string), normal_band (object with min and max numbers). Schema check: array length >= 1, each object passes field-level validation. | |
normal_operating_band | object | Must specify per-metric thresholds. Each key matches a metric name from key_metrics. Value is an object with min and max numbers. Schema check: no orphan thresholds, min < max for each band. | |
blast_radius_boundary | string[] | List of components, services, or user segments explicitly excluded from impact. Array check: length >= 1, no empty strings. Each entry must match a known system component from [SYSTEM_ARCHITECTURE_CONTEXT]. | |
abort_conditions | object[] | Array of objects with fields: condition (string), metric (string), threshold (number), operator (enum: gt, lt, gte, lte). Schema check: operator must be one of the allowed enum values, metric must reference a key_metrics name. | |
falsifiability_statement | string | Must state what observable outcome would disprove the hypothesis. Parse check: must contain a negation phrase such as 'is not', 'does not', 'fails to', or 'deviates from'. Min 30 characters. | |
monitoring_sufficiency_check | object | Object with fields: metrics_available (boolean), log_sources (string[]), alert_rules (string[]). Validation: if metrics_available is false, output must be flagged for human review before experiment execution. | |
confidence_notes | string[] | Optional array of uncertainty statements. If present, each string must be non-empty. Null allowed. If the model is unsure about any metric band, this field must be populated per [CONSTRAINTS]. |
Common Failure Modes
Chaos engineering hypotheses fail when they are unfalsifiable, unmeasurable, or too vague to trigger an abort. These cards cover the most common failure modes and how to prevent them before you inject a fault.
Unfalsifiable Hypothesis
What to watch: The hypothesis is phrased as a tautology or a vague hope (e.g., 'the system will be fine'). There is no measurable condition that would prove it wrong. Guardrail: Require every hypothesis to include a specific metric, a numeric threshold, and a direction of change. If you cannot write the sentence 'The hypothesis is disproven if [METRIC] goes [ABOVE/BELOW] [VALUE]', the hypothesis is not ready.
Monitoring Gap Before Injection
What to watch: The steady-state metrics defined in the hypothesis are not actually instrumented in dashboards, or the data has high latency. The experiment runs but no one can tell if the system deviated. Guardrail: Validate that every metric in the hypothesis is observable in real time with a resolution at least 5x finer than the expected time-to-detection. Run a dry-run observation period before injecting any fault.
Blast Radius Creep
What to watch: The experiment scope drifts during execution. A fault intended for a single pod or service cascades to dependencies that were not part of the hypothesis, making it impossible to attribute deviation to the intended variable. Guardrail: Define explicit blast radius boundaries in the hypothesis (specific hosts, services, or percentage of traffic). Include an abort condition that triggers if the radius is exceeded, enforced by the chaos tooling, not just human vigilance.
Normal Band Defined from Abnormal Data
What to watch: The 'steady state' baseline was calculated during a period that included a partial outage, a deploy, or a traffic anomaly. The hypothesis tests against a broken baseline, so real deviations are hidden or false positives dominate. Guardrail: Require the prompt to cite the time window and data source used for baseline calculation. Add a validation step that checks for known incidents, deployments, or anomalies in that window before accepting the baseline.
Missing Abort Criteria
What to watch: The hypothesis defines success and failure but no explicit abort condition. When something goes wrong that is worse than a hypothesis failure (e.g., customer data corruption, PII leak, cascading production outage), there is no pre-agreed trigger to stop. Guardrail: Include a separate 'Abort Conditions' section in the prompt output that lists irreversible harm triggers (data loss, security breach, SLA violation for real users) with automated halting procedures, distinct from hypothesis falsification.
Single-Metric Tunnel Vision
What to watch: The hypothesis only monitors one golden signal (e.g., p99 latency) while ignoring correlated degradation (e.g., error rate, saturation, or customer-facing correctness). The hypothesis 'passes' while the user experience degrades. Guardrail: Require the prompt to produce a small dashboard of 3-5 metrics covering latency, errors, saturation, and a business-level health indicator. The hypothesis is falsified if any one of them deviates beyond its threshold.
Evaluation Rubric
Use this rubric to test whether the generated steady-state hypothesis is production-ready before integrating it into a chaos experiment runbook. Each criterion targets a specific failure mode observed in LLM-generated hypotheses.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Falsifiability Check | Hypothesis contains a measurable metric with a defined normal band that can be violated by fault injection | Hypothesis is purely descriptive or states 'system remains available' without quantitative thresholds | Parse [OUTPUT] for metric name, numeric range, and unit; reject if any field is missing or uses unquantifiable language like 'acceptable' |
Metric Grounding | Every metric in the hypothesis maps to a named monitoring signal from [MONITORING_SOURCES] | Metric name does not appear in provided monitoring source list or is invented without source reference | Cross-reference metric names in [OUTPUT] against [MONITORING_SOURCES] list; flag any metric with no source match |
Blast Radius Boundary | Hypothesis explicitly states which components, users, or regions are inside vs outside the experiment scope | Blast radius is missing, uses 'all' without qualification, or fails to name excluded components | Check [OUTPUT] for a dedicated blast radius section with inclusion and exclusion lists; reject if only inclusion is present |
Abort Condition Completeness | At least one abort condition is defined per critical metric with a specific threshold that triggers experiment stop | Abort conditions are generic ('if something goes wrong') or reference metrics not in the hypothesis | Count abort conditions in [OUTPUT]; verify each references a metric from the hypothesis and includes a numeric threshold and comparison operator |
Monitoring Sufficiency | Hypothesis confirms that listed monitoring signals have sufficient granularity and frequency to detect deviation within experiment duration | Monitoring gap acknowledged but no mitigation stated, or sampling interval exceeds experiment time window | Check [OUTPUT] for monitoring interval per metric; verify interval is less than half the planned experiment duration; flag if gap is noted without fallback |
Steady-State Duration Justification | Normal operating band is derived from a stated historical baseline window with rationale for duration choice | Baseline window is arbitrary ('last 5 minutes') without justification or references a period with known anomalies | Parse [OUTPUT] for baseline window duration and justification field; reject if justification is missing or references a period with known incidents from [INCIDENT_HISTORY] |
Dependency Saturation Awareness | Hypothesis identifies downstream dependencies that may saturate before the target system and accounts for them in abort or scope | Downstream dependencies are not mentioned or are assumed to have infinite capacity | Search [OUTPUT] for dependency section; verify each dependency from [ARCHITECTURE_DIAGRAM] is addressed with saturation threshold or explicit exclusion rationale |
Experiment Duration Fit | Planned experiment duration is sufficient to reach steady state after injection and observe deviation before abort | Duration is shorter than metric collection interval or shorter than known warmup period for target system | Compare [OUTPUT] experiment duration against metric intervals and warmup notes in [SYSTEM_CONTEXT]; reject if duration is less than 3x the longest metric interval |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Use the base prompt with a frontier model (GPT-4o, Claude 3.5 Sonnet) in a chat interface. Remove the [OUTPUT_SCHEMA] constraint and ask for a narrative hypothesis first. Replace strict JSON output with a markdown table of metrics, bands, and abort conditions. Focus on falsifiability and blast radius clarity over machine-readability.
Watch for
- Hypotheses that are unfalsifiable (e.g., "the system will handle it")
- Missing abort conditions or "blast radius = everything"
- Vague metric bands like "normal" without numeric ranges

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us