---
version: dev-20260716.1
date: 2026-07-16
title: Cradle Work: Let Agents Finish the Job
---

> Give ideas room to grow—and work a path to completion.

Chat is for exploration. Work is for finishing.

A conversation can help you understand a problem, explore a direction, or change some code. Real work usually lasts longer: it has a clear objective, needs its own environment, moves through execution, waiting, review, and revision, and eventually needs to become a commit or pull request.

This release introduces **Cradle Work**—a new product concept for carrying that process, together with a rebuilt workbench, context system, resource layer, and delivery experience around it.

## ✨ Cradle Work

Cradle Work is not just another chat, and it does not depend on an issue or kanban item. You can create a Work at any time, describe what you want to accomplish, and choose the right agent, model, and execution environment. Issues and kanban are optional sources of context, not prerequisites.

A Work remembers its objective, working environment, related sessions, current progress, and delivery state. Conversations can pause, continue, or be handed off without causing the work itself to disappear.

`Objective → Isolated execution → Review changes → Local commit → User confirmation → Pull request`

The agent works in an isolated environment first. When it finishes, Cradle brings the changes back into a reviewable surface, where you decide whether to revise them, create a local commit, or enter the delivery flow. Remote actions such as pushing or opening a pull request only happen after explicit confirmation.

Work now lives in Cradle's everyday interface as well. It appears alongside its related sessions in the Workspace sidebar, with a unified language for running, waiting, blocked, Draft PR, Ready PR, and merged states.

This is not a new chat mode. It is a new way to finish work with an agent.

## 📥 Bring Past Work Home

The new **Import Center** discovers Claude Code and Codex sessions on your machine or a connected server.

Cradle reconstructs the projects they belonged to, presents a recoverable Workspace, and lets you choose the conversations you want to bring back. Once imported, those histories are no longer just JSONL files scattered across provider directories—they become Cradle sessions you can search, browse, continue, and archive.

Imported sessions can keep synchronizing. Cradle recognizes appended messages and stops guessing when the source history has been rewritten, avoiding unreliable merges between histories that have diverged. Claude and Codex subagent histories are preserved as part of their parent sessions as well.

External data remains read-only throughout the process. Cradle first creates its own size- and SHA-256-verified bundle, then projects chat history from that copy; the original Claude and Codex data directories are never modified.

## 🧭 Workspace Becomes a Real Workbench

Workspace is no longer just a way to group sessions. It now carries the surfaces where work actually happens.

You can open a browser on the right to read documentation, inspect deployments, or operate web tools, and open Terminal or TUI panels from the bottom. These panels follow the Workspace lifecycle and release their resources when closed.

Remote Workspaces can be browsed and imported too. Remote sessions are projected into the local interface, and Cradle clearly blocks new actions while their host is offline instead of letting messages fail silently.

When a project directory moves or a disk becomes temporarily unavailable, Cradle marks the Workspace as missing and lets you relink it to a new location.

This release also lets you move Cradle's own data directory. Databases, logs, plugins, and runtime files can live on another disk. Migration uses a staging copy, file-by-file verification, and a health check against the new server location; Cradle only switches after the new root is confirmed healthy, while the previous directory remains available as a backup.

## 📦 Make Tools and Environments Part of the Product

The new **Resources** surface manages the model assets and runtimes Cradle depends on.

OpenCode can be installed, upgraded, and switched as a managed runtime. Application updates, models, plugins, and runtime downloads now flow through a shared **Download Center**, with consistent progress, cancellation, retry, and integrity checks that survive page closes and application restarts.

Desktop now bundles a standalone Codex app server, reducing its dependence on a separately installed Codex environment. When native CLI behavior is preferred, Codex CLI-compatible identity can be enabled as well.

Plugin Center now includes Marketplace, Installed, and local import surfaces. Plugin developers can also start a Development Session from the CLI and let Desktop synchronize and hot-reload the plugin under development.

## 💬 From Conversations to Continuous Context

Composer is now better suited to the complex inputs that real work requires.

Large pasted text becomes a dedicated card that can be previewed, expanded, restored to the editor, or removed. You can also add context attachments and reference files or specific lines without forcing everything into one plain-text message.

While an agent is running, you can keep adding follow-ups and edit or rearrange queued instructions. A previous message can be revised and executed again while preserving file changes that already exist in the Workspace.

When a model cannot read images directly, local Light OCR can extract the text first. Mermaid and controlled HTML can also render directly in Chat, so architecture diagrams, flows, and technical explanations no longer have to remain code blocks.

Environment Handoff, Turn Checkpoint, Session Group, and ZIP Export make long-running work easier to pause, recover, organize, and pass along.

## 📊 Understand What Agent Work Costs

Usage now presents two complementary views: the device-level authoritative totals recorded in local Claude and Codex archives, and the activity Cradle can attribute directly to particular runs and sessions.

Consumption from a primary session and its subagents is aggregated into a complete session tree. Previously missing Codex model calls are backfilled without counting data that has already been recorded twice.

You can inspect Prompt, Completion, Cache, and Reasoning tokens and estimated cost by time, model, and session to understand what a complete piece of work actually consumed.

## ⚡ Less Visible, but Important

This release redesigns how Chat is stored over the long term.

Message bodies are no longer duplicated into every event. They are stored as independent payloads and hydrated on demand. Large diagnostic snapshots from completed runs are compacted in the background, and expired snapshots follow a retention policy—this maintenance applies only to run diagnostics and does not delete normal conversation history.

Streaming now uses monotonic cursors for incremental synchronization, making reconnects less likely to duplicate or lose output. Work context has also been separated from the frequently changing system prompt, keeping agents more stable during long tasks while improving prompt-cache reuse.

Diff Review Guide, Commit Plan, and other long-running processes now use durable background jobs. Even after an application restart, Cradle still knows where the job stopped and which product surface should receive its result.

OpenCode runtimes are pooled per Workspace to reduce repeated processes and startup cost. The renderer also waits for the local server to become ready before loading its main modules, reducing startup races and wasted requests.

## 💎 More Improvements

- Added a Pull Request dashboard, detail view, review states, and cursor pagination for large result sets
- Sessions can create pull requests, mark them ready, and wait for CI or review outcomes
- Thinking Effort is remembered independently for each provider and model
- Added `none`, `minimal`, `max`, and `ultra` reasoning levels
- Providers can expose their own permission, interaction, and Plan Mode settings
- Added theme customization, terminal fonts, preferred editor, keybinding, and update preferences
- Provider config import can manually decode Base64 API keys and restore their original value at any time
- Retryable runtime errors appear in the timeline instead of immediately terminating the response
- Claude Agent tool activity, alerts, waiting states, and usage appear as structured UI
- Sessions support quick previews, mark-all-read, and custom groups
- Windows, Linux, and macOS now share a unified custom title bar

## 🔐 Security and Privacy

- Import Center only reads Claude and Codex data directories and never modifies provider-owned files
- Downloads verify expected size and checksums before installation
- ACP binaries without trusted checksums are no longer installed; only `npx` and `uvx` distributions are currently offered
- Sensitive credentials are managed through a runtime keyring
- Authentication and lifecycle boundaries are tighter across local runtimes, remote runtimes, and WebSockets
- Anonymous product analytics and AI observability are now available without sending raw error text in failure classifications

## 🐞 Fixes and Hardening

- Fixed Work flows that could skip a local commit or perform remote actions without explicit confirmation
- Fixed dynamic Work context repeatedly invalidating the prompt cache
- Fixed Browser Panel resource leaks, initialization races, shortcut conflicts, and preload URLs
- Fixed preload APIs under Electron Sandbox
- Fixed missing, misattributed, and incorrectly backfilled Codex usage
- Fixed default-model resolution drifting from the provider inventory
- Fixed Thinking Effort fallback when switching models
- Fixed state conflicts between multi-turn rollback, queues, and synthetic turns
- Fixed structured OpenCode tool results and missing todo identifiers
- Fixed internal `refs/cradle/*` references appearing in the Git graph
- Fixed races across streaming responses, tool approval, message recovery, and runtime cleanup
