Task Contract Pause Policy in Reasonix: How It Manages Interruptions

The Task Contract pause policy in Reasonix requires the agent to stop and ask the user before any irreversible action, scope change, or user-dependent information request, while autonomously completing all other work.

Reasonix treats every non-trivial piece of work as a task contract that explicitly defines the work's purpose, required output, constraints, and a pause policy (sometimes called a checkpoint). This pause policy tells the agent when it must stop and ask the user before proceeding, preventing unwanted interruptions or irreversible actions. According to the Reasonix source code, the core definition lives in [docs/TASK_CONTRACT.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/TASK_CONTRACT.md), where the pause policy is codified as a decision rule that governs autonomous behavior.

Core Pause Policy Definition

The Task Contract pause policy follows a simple but powerful directive. As stated in docs/TASK_CONTRACT.md (lines 39-43):

"Unless the next step involves an irreversible or externally visible operation, a scope change, or information only the user can provide, keep working and report back after the task is complete."

This single sentence creates a default-autonomous behavior: the agent proceeds without interruption unless it encounters one of three specific pause triggers.

How Reasonix Handles Interruptions: The Four Situations

The pause policy creates four distinct behavioral patterns based on the nature of upcoming work:

Irreversible or External Effects

When the next step involves actions that cannot be undone or have visible external consequences—such as publishing a release, deploying to production, or writing credentials—Reasonix pauses and asks for confirmation.

This guarantees the user retains control over actions with lasting consequences. The agent never assumes authority over irreversible operations.

Scope Changes

If the work direction shifts fundamentally—for example, moving from UI work to backend API development—the agent pauses to confirm the new direction.

This prevents accidental drift from the original contract. The user explicitly approves any expansion or redirection of work before resources are committed.

Missing User-Only Information

When the agent lacks information only the user can supply—such as product preferences, access credentials, or business context—it pauses and prompts for the required data.

This prevents the agent from guessing or proceeding with incomplete specifications. The contract remains valid only when the agent has sufficient information to proceed correctly.

Routine, Reversible Work

For all other steps—ordinary file edits, local testing, documentation updates—the agent continues without pausing, automatically completing the requested work.

The agent only reports back once the contract's output format, constraints, and verification expectations are satisfied. This streamlines routine work while respecting the contract's boundaries.

Pause Policy Enforcement Across Reasonix Modes

The Task Contract pause policy operates consistently across three execution modes, with mode-specific adaptations:

Normal Chat Mode

The task contract template is applied directly to each conversational turn. The agent evaluates every proposed action against the pause policy, stopping only for the three trigger conditions.

Goal Mode

The entire goal is treated as a single task contract. The agent keeps working until the contract is fulfilled, pausing only for irreversible actions, scope changes, or user-dependent information. Once started, Goal Mode minimizes interruptions for programmatic work.

Plan Mode

The agent first drafts a structured plan, then applies the pause policy to each plan step individually. This ensures user approval before any irreversible action executes, even when the overall goal is complex.

Real-World Pause Policy Example

The following task contract demonstrates how the pause policy appears in practice:

# Example of a task contract with pause policy

Context:
  I am improving the desktop composer.
  The target user is someone doing repeated code-review sessions.
  This should help them avoid accidental interruptions.

Request:
  Make the slash-command menu keep keyboard focus while suggestions are open.

Output format:
  After implementation, summarize changed files and verification results.

Constraints:
  Do not change the Wails JSON contract.
  Do not refactor unrelated composer state.
  If browser verification cannot run, say why.

Pause policy:
  Unless the next step requires a product decision, a public push, or credentials,
  continue through implementation and verification before reporting back.

Runtime Execution Flow

1. The agent reads the Pause policy block from the contract
2. It evaluates each upcoming operation against the three pause triggers
3. If an operation writes to a public repo or manipulates credentials, it pauses and prompts for confirmation
4. For ordinary file edits and local verification, it continues autonomously
5. Upon contract completion, it returns the structured summary specified in Output format

Key Implementation Files

File	Purpose
[docs/TASK_CONTRACT.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/TASK_CONTRACT.md)	Primary definition of the task-contract template and pause policy (lines 39-43)
[docs/TASK_CONTRACT.zh-CN.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/TASK_CONTRACT.zh-CN.md)	Chinese translation for multilingual teams
[REASONIX.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/REASONIX.md)	High-level design document referencing task contracts and system prompt integration
docs/GOAL_MODE.md	Goal mode specification and its consumption of task contracts

These files collectively define the operational semantics of the pause policy, ensuring consistent behavior across all Reasonix implementations.

Summary

• Task contracts are the fundamental unit of work in Reasonix, binding purpose, output, constraints, and pause behavior
• The pause policy creates autonomous-by-default behavior with three specific stop conditions: irreversible actions, scope changes, and user-only information
• Irreversible operations always require explicit user confirmation before proceeding
• Three execution modes (Normal, Goal, Plan) apply the pause policy with mode-appropriate granularity
• Source definitions in docs/TASK_CONTRACT.md (lines 39-43) provide the authoritative reference for implementation

Frequently Asked Questions

What triggers a pause in Reasonix Task Contract execution?

Three conditions trigger a mandatory pause: irreversible or externally visible operations (like publishing releases), scope changes that redirect the work, and information only the user can provide. All other work proceeds autonomously until completion.

Where is the Task Contract pause policy defined in the Reasonix codebase?

The authoritative definition resides in [docs/TASK_CONTRACT.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/TASK_CONTRACT.md) at lines 39-43. This file serves as both documentation and functional specification for how Reasonix agents evaluate interruption conditions.

How does Goal Mode differ from Normal Chat Mode in pause policy application?

In Goal Mode, the entire goal becomes a single task contract, so the agent pauses only for the three trigger conditions across the full work sequence. In Normal Chat Mode, the pause policy is evaluated turn-by-turn, potentially creating more granular interruption points.

Can the pause policy be customized for specific workflows?

Yes. The pause policy is expressed in natural language within each task contract, allowing users to refine the three standard triggers. For example, a contract can specify "pause for product decisions" or "pause for credential operations" to match organizational requirements.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}