> This page is for version 0.7.0.
> For other versions, use one of these documentation indexes:
> - Main (default): https://docs.nvidia.com/nemo/gym/main/llms.txt
> - 0.7.0: https://docs.nvidia.com/nemo/gym/v0.7.0/llms.txt
> - 0.6.0: https://docs.nvidia.com/nemo/gym/v0.6.0/llms.txt
> - 0.5.1: https://docs.nvidia.com/nemo/gym/v0.5.1/llms.txt
> - 0.5.0: https://docs.nvidia.com/nemo/gym/v0.5.0/llms.txt
> - 0.4.0: https://docs.nvidia.com/nemo/gym/v0.4.0/llms.txt
> - 0.3.0: https://docs.nvidia.com/nemo/gym/v0.3.0/llms.txt
> - 0.2.1: https://docs.nvidia.com/nemo/gym/v0.2.1/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/gym/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/gym/_mcp/server.

# nemo_gym.core.outcome_policy

Shared configurable outcome selection; each boundary executes its own actions.

## Module Contents

### Classes

| Name                                                                                 | Description                                                                                  |
| ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
| [`OutcomeAction`](#nemo_gym-core-outcome_policy-OutcomeAction)                       | Action selected for one boundary decision.                                                   |
| [`OutcomeDecision`](#nemo_gym-core-outcome_policy-OutcomeDecision)                   | One policy decision for scoring and health consumers to preserve together.                   |
| [`OutcomePolicyConfig`](#nemo_gym-core-outcome_policy-OutcomePolicyConfig)           | Select an action from explicit failure evidence; partial overrides retain boundary defaults. |
| [`StageOutcomePolicyConfig`](#nemo_gym-core-outcome_policy-StageOutcomePolicyConfig) | Shared episode policies selected by the failure's originating stage.                         |
| [`StagePolicyConfig`](#nemo_gym-core-outcome_policy-StagePolicyConfig)               | Action rules for one stage; classification is configured independently.                      |

### Functions

| Name                                                                                   | Description                                                                                 |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
| [`_default_stage_policies`](#nemo_gym-core-outcome_policy-_default_stage_policies)     | -                                                                                           |
| [`_require_registered_kinds`](#nemo_gym-core-outcome_policy-_require_registered_kinds) | -                                                                                           |
| [`choose_action`](#nemo_gym-core-outcome_policy-choose_action)                         | Select by status, kind, class, then default; execution belongs to the boundary.             |
| [`choose_stage_outcome`](#nemo_gym-core-outcome_policy-choose_stage_outcome)           | Select one decision from established context, without examining causes or SDK details.      |
| [`failure_outcome_policy`](#nemo_gym-core-outcome_policy-failure_outcome_policy)       | Adapt only this event's evidence, without searching its causal chain.                       |
| [`is_policy_counted_zero`](#nemo_gym-core-outcome_policy-is_policy_counted_zero)       | Consume a saved explicit-zero decision, independently of completion or diagnostic evidence. |

### API

```python
class nemo_gym.core.outcome_policy.OutcomeAction
```

**Bases:** `enum.Enum`

Action selected for one boundary decision.

Each boundary restricts supported actions and enforces their prerequisites.

**`COUNT_AS_ZERO`** `= 'count_as_zero'`

---

**`FAIL`** `= 'fail'`

---

**`RETRY`** `= 'retry'`

---

**`VERIFY`** `= 'verify'`

---

```python
class nemo_gym.core.outcome_policy.OutcomeDecision()
```

**Bases:** `BaseModel`

One policy decision for scoring and health consumers to preserve together.

**`action`** `OutcomeAction`

---

**`attribution`** `FailureClass`

---

**`model_config`** `= ConfigDict(extra='forbid', frozen=True)`

---

```python
class nemo_gym.core.outcome_policy.OutcomePolicyConfig()
```

**Bases:** `BaseModel`

Select an action from explicit failure evidence; partial overrides retain boundary defaults.

**`by_failure_class`** `dict[FailureClass, OutcomeAction] = Field(default_factory=dict)`

---

**`by_failure_kind`** `dict[str, OutcomeAction] = Field(default_factory=dict)`

---

**`by_status_code`** `dict[Annotated[int, Field(ge=400, le=599)], OutcomeAction] = Field(default_factory=dict)`

---

**`default_action`** `OutcomeAction`

---

**`model_config`** `= ConfigDict(extra='forbid')`

---

**`supported_actions`** `frozenset[OutcomeAction] = frozenset(OutcomeAction)`

---

```python
nemo_gym.core.outcome_policy.OutcomePolicyConfig.merge_default_rules(
    value: dict[str | int, nemo_gym.core.outcome_policy.OutcomeAction],
    info: pydantic.ValidationInfo
) -> dict[str | int, nemo_gym.core.outcome_policy.OutcomeAction]
```

classmethod

Merge validated overrides so JSON status keys are normalized before replacing defaults.

```python
nemo_gym.core.outcome_policy.OutcomePolicyConfig.require_registered_kinds(
    value: dict[str, nemo_gym.core.outcome_policy.OutcomeAction]
) -> dict[str, nemo_gym.core.outcome_policy.OutcomeAction]
```

classmethod

Reject misspelled failure names at configuration load, before starting an evaluation.

```python
nemo_gym.core.outcome_policy.OutcomePolicyConfig.require_supported_actions() -> nemo_gym.core.outcome_policy.OutcomePolicyConfig
```

```python
class nemo_gym.core.outcome_policy.StageOutcomePolicyConfig()
```

**Bases:** `BaseModel`

Shared episode policies selected by the failure's originating stage.

Callers establish ownership and evidence before selecting a stage. A retry
decision permits only safe retries within the caller's existing budget; once
that budget is exhausted, the result stays ungraded. Provider-operation retry
policies remain separate from these episode decisions. Verification defaults
apply to admitted inconclusive attempts, never ordinary verifier scores.

**`by_stage`** `dict[FailureStage, StagePolicyConfig] = Field(default_factory=_default_stage_policies)`

---

**`classification`** `FailureClassificationConfig = Field(default_factory=FailureClassificationConfig)`

---

**`default_policy`** `StagePolicyConfig = Field(default_factory=StagePolicyConfig)`

---

**`model_config`** `= ConfigDict(extra='forbid')`

---

```python
nemo_gym.core.outcome_policy.StageOutcomePolicyConfig.merge_stage_defaults(
    value: object
) -> object
```

classmethod

Merge partial stage and rule overrides without dropping other defaults.

```python
class nemo_gym.core.outcome_policy.StagePolicyConfig()
```

**Bases:** [OutcomePolicyConfig](#nemo_gym-core-outcome_policy-OutcomePolicyConfig)

Action rules for one stage; classification is configured independently.

**`default_action`** `OutcomeAction = OutcomeAction.FAIL`

---

```python
nemo_gym.core.outcome_policy._default_stage_policies() -> dict[nemo_gym.core.failure_kinds.FailureStage, nemo_gym.core.outcome_policy.StagePolicyConfig]
```

```python
nemo_gym.core.outcome_policy._require_registered_kinds(
    value: dict[str, nemo_gym.core.outcome_policy._require_registered_kinds[T]]
) -> dict[str, nemo_gym.core.outcome_policy._require_registered_kinds[T]]
```

```python
nemo_gym.core.outcome_policy.choose_action(
    failure_kind: str,
    http_status: int | None,
    config: nemo_gym.core.outcome_policy.OutcomePolicyConfig,
    failure_class: nemo_gym.core.failure_kinds.FailureClass | None = None
) -> nemo_gym.core.outcome_policy.OutcomeAction
```

Select by status, kind, class, then default; execution belongs to the boundary.

```python
nemo_gym.core.outcome_policy.choose_stage_outcome(
    failure_kind: str,
    http_status: int | None,
    stage: nemo_gym.core.failure_kinds.FailureStage | None,
    config: nemo_gym.core.outcome_policy.StageOutcomePolicyConfig
) -> nemo_gym.core.outcome_policy.OutcomeDecision
```

Select one decision from established context, without examining causes or SDK details.

Missing stages use the conservative default policy. Preserve a known origin
when a failure propagates: catching an agent failure during verification does
not turn it into a verifier failure.

```python
nemo_gym.core.outcome_policy.failure_outcome_policy(
    failure: nemo_gym.core.typed_exceptions.NgFailureEvent,
    config: nemo_gym.core.outcome_policy.OutcomePolicyConfig,
    classification: nemo_gym.core.failure_kinds.FailureClassificationConfig | None = None
) -> nemo_gym.core.outcome_policy.OutcomeAction
```

Adapt only this event's evidence, without searching its causal chain.

```python
nemo_gym.core.outcome_policy.is_policy_counted_zero(
    row: collections.abc.Mapping[str, object]
) -> bool
```

Consume a saved explicit-zero decision, independently of completion or diagnostic evidence.

The owning boundary admits the failure and applies its policy before persisting `failure_outcome_action`.
Readers check only consistency with the measured result; counting does not establish fault attribution.