Cascade is Dead: Migrate to Devin Local Today Before Your CI Breaks

Today is July 1, 2026. If you use Devin Desktop (formerly Windsurf) and haven't touched your CI configs since June 2, you probably have a quiet time bomb in your automation stack. Cascade — the original local agent inside Windsurf — reached end-of-life at midnight UTC today. The editor migrated automatically. Your scripts did not.

This is the migration guide. It covers what Cognition changed, what specifically breaks, and the exact commands to find and fix every Cascade reference before your next deploy.

What happened to Windsurf

On June 2, 2026, Cognition shipped a silent over-the-air update that renamed the entire product. Windsurf became Devin Desktop. The domain redirected. The icon changed. Every Windsurf setting ported automatically. For most users, it looked like a normal maintenance update — until they noticed the splash screen.

The rebrand wasn't cosmetic. Cognition is repositioning around the Devin brand to unify its cloud and local products under one identity. The local agent that shipped inside Windsurf — Cascade — is the piece that didn't survive the transition intact.

What breaks today — and what doesn't

Most users won't notice anything. The in-editor migration is automatic: Devin Local is the new default local agent, your workspace settings transferred unchanged, and MCP connections continue working. Open the editor this morning and everything looks the same.

The breakage is in automation. Any script, CI workflow, or agent config that refers to Cascade by name will fail silently starting today. "Silently" is the operative word — the call won't throw an obvious error. It'll just do nothing, or fall back to behavior you didn't intend.

In-editor tasks, manual sessions, and anything you launch through the Devin Desktop UI are unaffected. The migration happened when the update installed. Only named automation breaks.

What Devin Local actually is

Devin Local isn't a patch on Cascade. It's a complete rewrite from scratch in Rust — Cascade was Python. That matters for two reasons: startup latency drops significantly, and the architecture is cleaner enough that Cognition could add subagent support, which Cascade's single-threaded design couldn't accommodate.

The three headline improvements over Cascade:

Token efficiency

Devin Local uses roughly 30% fewer tokens per task than Cascade did on equivalent workloads. The gain comes from the Rust rewrite's tighter context management: less scaffolding per tool call, more compact internal state. On a multi-file refactor that used to cost 400K tokens in Cascade, Devin Local spends about 280K. At any realistic billing rate, that's real money.

Subagent support

Cascade was single-agent. One context window, one task at a time. Devin Local supports the same subagent architecture that Devin's cloud product uses — parallel task handling where the local agent spawns child agents for independent work. For teams that have been waiting to run Devin's agent patterns locally without routing everything through the cloud, this is the unlock.

ACP compatibility

Devin Local speaks the Agent Client Protocol — JSON-RPC 2.0 over stdin/stdout — which means it can interop with any ACP-compatible agent. Claude Agent, OpenAI Codex, and OpenCode all work as peers today. You can route tasks to the right specialist without leaving the Devin Desktop UI.

The migration playbook

The entire migration is a find-and-replace exercise. Start with the grep, then work through each file type.

# Find all files that mention Cascade (case-insensitive)
grep -rI --include="*.yml" --include="*.yaml" \
     --include="*.sh" --include="Makefile" \
     --include="*.json" --include="*.md" \
     -l "cascade" . | sort

# Quick count across the whole repo
grep -rI "cascade" . --include="*.yml" --include="*.yaml" \
  --include="*.sh" --include="Makefile" -c | grep -v ":0$"

For most repos this returns zero to three files. If you get dozens, you probably have a Cascade-native CI pipeline that needs a more careful review.

# BEFORE (Cascade — breaks July 1)
- name: Run Cascade agent
  run: cascade run --task "review PR diff"

# AFTER (Devin Local)
- name: Run Devin Local agent
  run: devin-local run --task "review PR diff"

# BEFORE
cascade run --task "$TASK" --output json

# AFTER
devin-local run --task "$TASK" --output json

# BEFORE
review:
	cascade run --task "review staged changes"

# AFTER
review:
	devin-local run --task "review staged changes"

Agent workflow rules live in .devin/rules/ (previously .windsurf/rules/ — the rename happened automatically on the June 2 update). Check any rule files that route to a named agent:

---
# BEFORE — routes to retired agent
agent: cascade

# AFTER — routes to active local agent
agent: devin-local
---

ACP: pull in Claude Agent, Codex, or OpenCode

The most under-discussed part of the Devin Local release is ACP support. ACP — the Agent Client Protocol — is JSON-RPC 2.0 over stdin/stdout. The editor launches agents as subprocesses and proxies requests through a standard interface. All four ACP-compatible agents appear in the Devin Desktop Kanban view with identical controls.

{
  "name": "claude-agent",
  "protocol": "acp",
  "command": "npx @anthropic-ai/claude-agent",
  "capabilities": ["code", "test", "review"],
  "description": "Anthropic's Claude Agent via ACP — for tasks that need extended reasoning or large context"
}

With this config in place, you can route a code review to Claude Agent and a fast inline edit to Devin Local — from the same workflow, inside the same editor, with the same Kanban view tracking both. The routing happens in your workflow rule:

---
trigger: manual
---

For large refactors (> 200 lines changed): route to claude-agent.
For inline edits and quick fixes: route to devin-local.
For security audits: route to claude-agent with the security skill loaded.

Devin Local skills on skills-hub.ai

Skills-hub.ai ships a devin-local-migration skill in the ops category that automates the entire grep-and-replace workflow above. Install it once, run it against your repo, and it generates a migration diff you can review before applying.

# Install the migration audit skill
npx @skills-hub-ai/cli install devin-local-migration

# Run against your repo
/devin-local-migration

# The skill will:
# 1. Find all Cascade references across CI, scripts, Makefiles, rules
# 2. Generate a patch with the Devin Local equivalents
# 3. Check for custom tool definitions that need manual review
# 4. Output a summary of what changed and what needs human attention

For teams adopting ACP for the first time, the integration category has agent routing skills for Devin Local + Claude Agent, Devin Local + Codex, and full multi-agent setups using all three.

Verdict

The migration is low-effort for most teams. If you don't have Cascade named anywhere in your automation, you're already done — the editor handled it. If you do, the grep above finds everything in under a minute and the fix is a string replacement.

Devin Local is a genuine upgrade over Cascade. Faster startup, meaningful token savings, and subagent support that opens up multi-agent local workflows that simply weren't possible before. The EOL deadline is today, but the replacement is better. This is a migration worth making.

# Find + fix in one pass (review the diff before committing)
grep -rIl "cascade" . \
  --include="*.yml" --include="*.yaml" \
  --include="*.sh" --include="Makefile" \
  --include="*.json" | xargs sed -i 's/cascade/devin-local/g'

git diff  # review before staging

Related reading: the original Windsurf → Devin Desktop rebrand post, the ACP Spec 1.0 overview, and how subagents work in Claude Code if you're thinking about the broader multi-agent picture.