# Coding agent hit a usage limit mid-task? Save the work first

> Identify the actual limit, preserve the checkout and partial result, then resume, wait, or hand off without repeating work or changing accounts blindly.

Canonical HTML: https://canopyide.dev/guides/coding-agent-hit-usage-limit-mid-task
Article date: 2026-09-28

A limit notice is disruptive when an agent has edited half a feature. It does not tell you which files are safe, whether the current turn finished, or whether another model can continue on the same account. Read the live CLI state, preserve the partial artifact, and make the next decision from the owning provider's current limit view.

## Confirm which limit actually stopped work

Record the CLI, account or workspace, model, exact notice, time zone, and displayed reset time. Compare the live terminal with the provider's current usage page. A full context window calls for compaction or a fresh task handoff; a plan window may require waiting or an account-supported continuation option. A stale Canopy ‘as of’ snapshot is a clue, not the authority for a new limit decision. API rate, spend, and subscription allowances can also differ. Anthropic and OpenAI document plan-specific choices, so use the option displayed for the account you are actually using rather than assuming another person's limits apply.

*Different limits imply different recovery paths.*

| Signal | Verify | Likely next step |
| --- | --- | --- |
| Context full | CLI context view and current conversation | Compact with the CLI or start from a short handoff |
| Plan window reached | Provider account and reset time | Wait or use an available account-supported option |
| Model-specific allowance | Available models and account rules | Switch only if the provider shows remaining capacity |
| API rate or spend error | Owning API account and exact error | Use its documented limit or billing controls |
| Old percentage or estimate | Observation timestamp and live CLI state | Refresh evidence before diagnosing |

## Check whether the current turn is still running

Do not close a terminal merely because a usage bar looks full. Open the exact Canopy session and read the newest output: a limit error, a CLI prompt, an active tool, or a final answer mean different things. OpenAI's Codex plan guidance says some credit-based sessions can finish an active turn after the allowance is reached, subject to fair-use limits. Observe that turn's actual state before starting a replacement agent. If a local test or server is still running, distinguish its process from the coding CLI; a stopped model call does not establish that every child service stopped.

## Preserve the partial result without claiming completion

Inspect the current checkout, branch, Git status, changed files, and last passing check. Record what the agent intended, which parts are visible in the diff, which commands actually ran, and what failed or remained untested. Do not commit a broken partial change just to make the handoff look finished; preserve it in the correct worktree and make an explicit checkpoint according to your team's Git practice. If the last output is only an agent summary, verify it against files and test results. Keep credentials, private prompt contents, and your personal usage screenshot out of a shared note unless you choose to disclose them.

## Choose wait, same-CLI continuation, or cross-CLI handoff

Waiting for the documented reset keeps the original CLI and account path. If the provider offers another model, credits, a reset, or an administrator-approved route, check cost and authorization before selecting it; availability is plan-specific and a different model may share the same exhausted allowance. A different installed CLI in Canopy has its own conversation, permissions, account, and limits. It does not inherit the first CLI's private transcript. Give it the same checkout only after deciding ownership, or use a separate worktree and a small evidence handoff. Ask for one bounded next step, not a replay of the entire unfinished task.

## Resume from the artifact and verify the outcome

When capacity returns, reopen the original session through the CLI's supported resume path if its history remains useful; Canopy's integration audit shows that resume support varies by CLI. Recheck branch, worktree, services, and latest diff before typing ‘continue.’ Tell the agent what completed while it was away and what still needs testing. If another CLI finished the work, inspect its branch and PR instead of restarting the old agent on the same files. Repeat the original acceptance check, read the final diff, and compare actual provider usage to the outcome. The task is complete when the feature works and its review is settled, not when a usage bar resets.

## Copyable resources

### Limit-interruption handoff

Use the exact provider notice but omit account secrets and private billing details when sharing.

````text
Task, repository, checkout, branch, and CLI: [ ]
Exact limit message and observed at (time zone): [ ]
Provider account/model and current reset or option shown: [ ]
Current CLI turn: active, completed, waiting, or failed [ ]
Git status and changed files: [ ]
Last accepted behavior and checks actually run: [ ]
Partial result and remaining failure or test: [ ]
Decision: wait, same CLI/model route, or different CLI with named owner [ ]
Next bounded action and acceptance check: [ ]
After resuming: verify branch, services, final diff, and provider usage [ ]
````

## Frequently asked questions

### Will changing to a smaller model always bypass the limit?

No. Model allowances and shared plan windows vary by provider and account. Check the provider's current usage screen and available models before switching.

### Did Codex stop the moment its plan bar reached the limit?

Not necessarily. OpenAI says some included-allowance or credit-based sessions can continue the active turn, subject to fair-use limits. Inspect the live session output before assuming it stopped.

### Can I move the unfinished conversation from Claude Code to Codex?

The CLIs do not automatically share private transcripts. Hand off the goal, branch, changed files, checks, decisions, and next action explicitly, then verify the new session's checkout.

### Is a full context window the same as a plan limit?

No. Context is the material available to one model call; a plan limit controls usage over a period. Use the CLI's context tools or the provider's plan view for the correct problem.

## Sources and further reading

- [Claude Code models, context, and plan limits](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [OpenAI Codex plan usage and mid-turn limit behavior](https://help.openai.com/en/articles/11369540-using-codex-with-your-chatgpt-plan)
- [OpenAI Codex status and context inspection](https://developers.openai.com/blog/mastering-codex-remote-for-engineering)
- [Canopy README: usage, agents, and provider boundaries](https://github.com/FluidWorksApp/canopy-ide/blob/main/README.md)
- [Canopy integration audit: resume differences](https://github.com/FluidWorksApp/canopy-ide/blob/main/docs/agent-parity.md)
- [Public Codex question about a rate limit interrupting a task](https://www.reddit.com/r/codex/comments/1un8nds/codex_users_whats_your_actual_move_when_a_session/)

## Related Canopy pages

- [Your AI coding cost dashboard is not your bill](https://canopyide.dev/blog/your-ai-coding-cost-dashboard-is-not-your-bill.md)
- [Keep coding-agent context useful between sessions](https://canopyide.dev/guides/keep-agent-context-between-sessions.md)
- [Switch from Claude Code to Codex without losing the task](https://canopyide.dev/guides/switch-coding-agents-without-losing-context.md)
- [Coding agent stuck or waiting for input? Check the live session](https://canopyide.dev/guides/coding-agent-stuck-or-waiting-for-input.md)
- [Measure AI coding cost per accepted change](https://canopyide.dev/guides/measure-ai-coding-cost-per-accepted-change.md)

Canopy runs installed coding CLIs; CLI accounts, model selection, and provider billing remain separate. Check the installed release before relying on version-specific behavior.