@@ -459,6 +459,21 @@ expected page to satisfy "success message is shown" (12%) with confidence of 70%
 
 `I.decideVisually` also sends a screenshot, so it needs a model with image input. It uses `visualModel`, which is [Clef](https://openrouter.ai/cloudflare/clef) by default. Visual decisions are experimental.
 
+To turn decisions off without removing the helper, set its `mode`:
+
+| Mode | Behavior |
+|---|---|
+| `assert` | default, fails the step when a statement is not confirmed |
+| `report` | requests the model but never fails, even on API errors; results and errors are added to the step as a comment |
+| `skip` | does not request the model, every decision passes |
+
+```js
+helpers: {
+  Playwright: { url: 'http://localhost' },
+  Decision: { mode: process.env.CI ? 'assert' : 'skip' },
+}
+```
+
 A failed decision is not retried by the [retryFailedStep](/plugins/retryFailedStep) plugin: asking again would cost another request and return the same answer. Only connection errors and timeouts are retried.
 
 Use decision assertions for what a page means, and built-in assertions for exact values. `I.see('Total: $42.00')` is still the right check for a price.
 
@@ -347,27 +347,33 @@ class DecisionAI {
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), this.config.timeout)
 
-    let response
+    let result
     try {
-      response = await this.fetchImpl(this.endpoint.url, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({ model, state, questions }),
-        signal: controller.signal,
-      })
+      let response
+      try {
+        response = await this.fetchImpl(this.endpoint.url, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ model, state, questions }),
+          signal: controller.signal,
+        })
+      } catch (err) {
+        throw new DecisionConnectionError(`Decision model ${model} request failed: ${err.message}`)
+      }
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => '')
+        throw new Error(`Decision model ${model} responded with ${response.status}: ${body}`)
+      }
+
+      result = await response.json()
     } catch (err) {
       if (controller.signal.aborted) throw new DecisionConnectionError(`Decision model ${model} did not respond in ${this.config.timeout}ms`)
-      throw new DecisionConnectionError(`Decision model ${model} request failed: ${err.message}`)
+      throw err
     } finally {
       clearTimeout(timer)
     }
 
-    if (!response.ok) {
-      const body = await response.text().catch(() => '')
-      throw new Error(`Decision model ${model} responded with ${response.status}: ${body}`)
-    }
-
-    const result = await response.json()
     debug('Decision response', result?.answers, result?.usage)
 
     const answers = result?.answers || {}
 
@@ -5,6 +5,7 @@ import Helper from '@codeceptjs/helper'
 import Container from '../container.js'
 import Config from '../config.js'
 import store from '../store.js'
+import output from '../output.js'
 import AssertionFailedError from '../assert/error.js'
 import { compactAriaSnapshot } from '../aria.js'
 import { minifyHtml } from '../html.js'
@@ -37,8 +38,7 @@ import { DecisionAI, DecisionConnectionError } from '../ai.js'
  *
  * ## Configuration
  *
- * Decision model is configured in the `ai.decisionModel` section of the config.
- * The helper itself has no options:
+ * Decision model is configured in the `ai.decisionModel` section of the config:
  *
  * ```js
  * ai: {
@@ -63,18 +63,45 @@ import { DecisionAI, DecisionConnectionError } from '../ai.js'
  * * `timeout` (default: `15000`) - request timeout in ms.
  * * `maxLength` (default: `12000`) - maximal length of ARIA snapshot or HTML sent to the model.
  *
+ * The helper has one option:
+ *
+ * * `mode` (default: `assert`) - how decisions are executed:
+ *   * `assert` - request the model and fail the step when a statement is not confirmed.
+ *   * `report` - request the model but never fail, even on API errors. Results and errors are added to the step as a comment.
+ *   * `skip` - do not request the model, every decision passes.
+ *
+ * ```js
+ * Decision: { mode: process.env.CI ? 'assert' : 'skip' }
+ * ```
+ *
  * Decisions work without the `--ai` flag.
  * Browse all decision models at [OpenRouter](https://openrouter.ai/models?output_modalities=decisions).
  *
  * ## Methods
  */
+const MODES = ['assert', 'report', 'skip']
+
 class Decision extends Helper {
   constructor(config = {}) {
     super(config)
+    this.mode = config.mode || 'assert'
+    if (!MODES.includes(this.mode)) throw new Error(`Unknown Decision helper mode "${this.mode}", use one of: ${MODES.join(', ')}`)
     this.decisionAI = new DecisionAI(Config.get('ai', {}).decisionModel)
     this.options = this.decisionAI.config
   }
 
+  get isAsserting() {
+    return this.mode === 'assert'
+  }
+
+  get isReporting() {
+    return this.mode === 'report'
+  }
+
+  get isSkipping() {
+    return this.mode === 'skip'
+  }
+
   /**
    * Asserts that a statement (or each of statements) is true for the current page.
    * The decision model receives page URL, title and ARIA snapshot.
@@ -87,9 +114,10 @@ class Decision extends Helper {
    * ```
    *
    * @param {string|string[]} statements statement or list of statements to verify.
-   * @returns {Promise<number|number[]>} probability of each statement.
+   * @returns {Promise<number|number[]|undefined>} probability of each statement, `undefined` in `skip` mode.
    */
   async decide(statements) {
+    if (this.isSkipping) return this._skip()
     return this._run(async () => {
       const state = await this._grabState()
       return this._assert(statements, this.options.model, state)
@@ -107,9 +135,10 @@ class Decision extends Helper {
    * ```
    *
    * @param {string|string[]} statements statement or list of statements to verify.
-   * @returns {Promise<number|number[]>} probability of each statement.
+   * @returns {Promise<number|number[]|undefined>} probability of each statement, `undefined` in `skip` mode.
    */
   async decideVisually(statements) {
+    if (this.isSkipping) return this._skip()
     return this._run(async () => {
       const state = await this._grabState()
       const screenshot = await this._grabScreenshot()
@@ -121,10 +150,19 @@ class Decision extends Helper {
     })
   }
 
+  _skip() {
+    if (store.currentStep) store.currentStep.comment = ' (skipped)'
+  }
+
   async _run(fn) {
     try {
       return await fn()
     } catch (err) {
+      if (this.isReporting) {
+        if (store.currentStep) store.currentStep.comment = ` (error: ${err.message})`
+        output.say(`  ✖ ${err.message}`, 'yellow')
+        return
+      }
       if (!(err instanceof DecisionConnectionError)) err.isTerminal = true
       throw err
     }
@@ -137,12 +175,20 @@ class Decision extends Helper {
     const probabilities = await this.decisionAI.decide(model, state, list)
 
     const failed = []
-    list.forEach((statement, i) => {
+    const results = list.map((statement, i) => {
       const passed = probabilities[i] >= this.options.confidence
-      this.debugSection('Decision', `${passed ? '✔' : '✖'} ${statement} (${formatProbability(probabilities[i])})`)
+      const result = `${passed ? '✔' : '✖'} ${statement} (${formatProbability(probabilities[i])})`
+      this.debugSection('Decision', result)
       if (!passed) failed.push(`"${statement}" (${formatProbability(probabilities[i])})`)
+      return result
     })
 
+    if (this.isReporting) {
+      if (store.currentStep) store.currentStep.comment = `\n${results.join('\n')}`
+      results.forEach(result => output.say(`  ${result}`, result.startsWith('✔') ? 'green' : 'yellow'))
+      return Array.isArray(statements) ? probabilities : probabilities[0]
+    }
+
     if (failed.length) {
       const err = new AssertionFailedError(
         { statements: failed.join(', '), confidence: formatProbability(this.options.confidence) },
 
@@ -6,9 +6,9 @@ import Decision from '../../../lib/helper/Decision.js'
 import store from '../../../lib/store.js'
 import Config from '../../../lib/config.js'
 
-function createDecision(decisionModel) {
+function createDecision(decisionModel, config = {}) {
   Config.create({ ai: { decisionModel } })
-  return new Decision({})
+  return new Decision(config)
 }
 
 function fakeFetch(answers, calls, status = 200) {
@@ -159,6 +159,20 @@ describe('Decision helper', () => {
     expect(err.isTerminal).to.be.undefined
   })
 
+  it('times out stalled response body', async () => {
+    decision = createDecision({ apiKey: 'secret', timeout: 50 })
+    decision._actingHelper = () => browser
+    decision.decisionAI.fetchImpl = async (url, { signal }) => ({
+      ok: true,
+      status: 200,
+      json: () => new Promise((_, reject) => signal.addEventListener('abort', () => reject(new Error('aborted')))),
+    })
+
+    const err = await decision.decide('page is loaded').catch(e => e)
+    expect(err.message).to.include('did not respond in 50ms')
+    expect(err.isTerminal).to.be.undefined
+  })
+
   it('marks failed decisions as not retryable', async () => {
     decision.decisionAI.fetchImpl = fakeFetch(noul(0.1), calls)
     const err = await decision.decide('cart is empty').catch(e => e)
@@ -214,4 +228,48 @@ describe('Decision helper', () => {
       if (key) process.env.TYPESAFE_API_KEY = key
     }
   })
+
+  describe('mode', () => {
+    afterEach(() => {
+      store.currentStep = null
+    })
+
+    it('skips decisions without requests', async () => {
+      decision = createDecision({}, { mode: 'skip' })
+      decision.decisionAI.fetchImpl = fakeFetch(noul(0.1), calls)
+      store.currentStep = { comment: '' }
+
+      expect(await decision.decide('cart is empty')).to.be.undefined
+      expect(await decision.decideVisually('sidebar is shown')).to.be.undefined
+      expect(calls).to.be.empty
+      expect(store.currentStep.comment).to.include('skipped')
+    })
+
+    it('reports results in step comment without failing', async () => {
+      decision = createDecision({ apiKey: 'secret' }, { mode: 'report' })
+      decision._actingHelper = () => browser
+      decision.decisionAI.fetchImpl = fakeFetch(noul(0.9, 0.1), calls)
+      store.currentStep = { comment: '' }
+
+      const probabilities = await decision.decide(['form has fields', 'submit enabled'])
+      expect(probabilities).to.eql([0.9, 0.1])
+      expect(calls).to.have.length(1)
+      expect(store.currentStep.comment).to.include('✔ form has fields (90%)')
+      expect(store.currentStep.comment).to.include('✖ submit enabled (10%)')
+    })
+
+    it('reports api errors in step comment without failing', async () => {
+      decision = createDecision({ apiKey: 'secret' }, { mode: 'report' })
+      decision._actingHelper = () => browser
+      decision.decisionAI.fetchImpl = fakeFetch({}, calls, 500)
+      store.currentStep = { comment: '' }
+
+      expect(await decision.decide('page is loaded')).to.be.undefined
+      expect(store.currentStep.comment).to.include('responded with 500')
+    })
+
+    it('validates mode', () => {
+      expect(() => createDecision({}, { mode: 'soft' })).to.throw('Unknown Decision helper mode')
+    })
+  })
 })