Your agents.
Your infrastructure.
One command center.

Real Claude Code terminals

Run the actual Claude Code CLI in a PTY, with interactive input, streaming output, terminal resizing, and replay. Keep the harness you already know inside a persistent workspace.

Chat and terminal views

Follow a readable conversation with tool activity, then switch to the terminal when you need the underlying CLI. Inspect what the agent is doing while it works.

Concurrent session dashboard

Launch and monitor multiple sessions across projects and repositories. See running, waiting, completed, and failed work without cycling through terminal windows.

Optional session advisor

Enable rolling one-line digests and coarse state assessments for watched sessions. The advisor summarizes activity without writing instructions to the live agent.

Availability & scopeOff by default. Automatic digests use model calls; a configured compatible endpoint can serve them locally.

Session triage

Use the docked sessions panel or compact pulse rail to find work that needs attention. Unread indicators and waiting-for-input states make the next intervention easier to spot.

Reconnect to running work

Refresh the page or reconnect your browser and reattach to the same live PTY. A disconnected client does not end the agent's work.

Server-restart survival

Native daemon-backed PTYs run separately from the Cuttle server, so server restarts can leave active terminals intact.

Availability & scopeNative default; Docker opt-in. Does not cover machine reboots or ACP sessions.

Mobile session control

Launch sessions, send instructions, follow progress, and respond when an agent needs input from a phone. Project navigation and account preferences have dedicated mobile surfaces.

Claude Code orchestration

Use the native Claude Code runner for interactive work and the unattended workflows behind automations, Ralph, BigRalph, Autopilot, and pipelines.

Codex and Gemini CLI runners

Launch interactive sessions through the Agent Client Protocol with built-in Claude, Codex, and Gemini CLI runner definitions. Stream conversation, tool calls, plans, and permission requests into the session UI.

Availability & scopeBeta. Install and authenticate the selected CLI; runner capabilities vary.

Custom ACP agents

Administrators can register compatible agent executables and make them available in the runner picker. Reuse Cuttle project context, agent instructions, and skill references with the selected runner.

Availability & scopeACP is for supported interactive launches; unattended workflows, restart recovery, usage budgets, and MCP pass-through are not supported.

Live runner configuration

Discover the model options an ACP runner actually advertises. Change supported model, reasoning, and mode settings from the session, with the active selection reflected in the UI.

Cloud provider lanes

Configure Anthropic, OpenAI, Gemini, Groq, and xAI model access. Supported non-Anthropic provider lanes use Cuttle's translation proxy with encrypted provider-key storage.

Availability & scopeProvider credentials and model access required. A provider lane is distinct from running that provider's coding CLI.

Scoped model defaults

Set defaults and agent model pins, then override them for a session or trigger. Supported automation routing can select a model for the task while explicit choices remain visible.

Multi-repository projects

Group repositories into projects and subprojects. Project-level sessions can coordinate across a repo map; repository-level sessions work in the selected codebase.

Configurable agent roles

Define specialist agents with their own instructions, skills, model choices, permission modes, and turn limits. Keep repeatable roles for implementation, review, QA, research, and operations.

Markdown skills

Store runbooks and reusable procedures as editable Markdown files. Assign them to agents so domain knowledge travels with the role instead of being retyped into every prompt.

Scoped context composition

Compose workspace instructions, project context, repository mappings, and agent-specific guidance at session launch. Skill indexes point agents to the relevant files without stuffing every skill body into every prompt.

Git worktree isolation

Give supported sessions separate worktrees and branches for concurrent changes. Inspect worktree state and diffs, then bring reviewed work back into the repository.

Availability & scopeGit isolation separates working copies; it is not an operating-system sandbox.

Cross-repository PR overview

See open pull requests and CI status across connected repositories. Follow the work from an agent session into the code-review surface.

Persistent feature intents

Capture a goal or product story as a durable unit of work. Research, plans, sessions, runs, and pull requests stay attached to that intent.

Research and plan refinement

Launch focused research or refinement sessions before implementation. Turn a broad request into concrete plan steps and revise the approach as the codebase reveals constraints.

Plan, Changes, and History

Read the current plan, inspect implementation changes and PR checks, and trace the decision history from one intent detail view.

Step-level execution

Work through a selected plan step or hand the broader goal to a session, Ralph, or BigRalph. Progress is recorded against the intent as work reports completed steps.

Autoplay handoffs

Let enabled autoplay act on supported next-step recommendations: continue work, refine the plan, launch a specialist, start a loop, or prepare a draft PR. Its next action and reason remain visible.

Review-aware progression

Readiness checks gate the transition to review. Requests for human review stop autoplay, and a human directive can steer the next attempt. Draft PR creation, readiness, and completing an intent remain distinct actions.

Ralph's fresh-session iterations

Run repeated agent sessions against a PRD while persisting progress between attempts. Each iteration gets a fresh context and the accumulated state of the task.

Configurable completion strategies

Stop on PRD completion, passing tests, or a model-judge verdict. Configure iteration limits, per-iteration timeouts, and wall-clock caps to bound the run.

Pause, resume, and rewind

Pause at iteration boundaries, resume a run, retry with an edited PRD, or rewind to an earlier iteration snapshot. Inspect the live PRD and accumulated progress log.

BigRalph's skeptical outer judge

Wrap complete Ralph runs in a separate judgement session that inspects the working directory against the original goal. A failed judgement refines the next attempt with a concrete, verifiable subgoal.

BigRalph task graphs and waves

Break larger goals into dependent tasks and run independent work in parallel worktree lanes. Checkpoint judges reconsider the remaining plan; a final judge evaluates the original goal.

Persistent judgement memory

Carry lessons from earlier BigRalph attempts into later judgements. Inspect verdicts, evidence, refined goals, and stuck-loop signals in the run history.

Gauntlet builder–critic rounds

Decompose a goal into components with a concrete quality bar. Independent critics inspect actual output and feed each component's largest remaining gap into the next builder round.

Availability & scopeExperimental. Parallel critics, sequential builder writes, bounded rounds; exhausted runs are reported separately from success.

DAG workflow builder

Connect agent sessions, Ralph runs, BigRalph runs, and gates into a saved directed graph. Express dependencies visually and let independent branches progress when their inputs are ready.

Availability & scopeCode-mutating nodes sharing a working directory are serialized.

Shared blackboard variables

Pass declared node outputs into downstream prompts with template variables. Namespaced outputs retain their producing node, while shared names support convenient handoffs.

Parameterized runs

Reuse a graph for new tasks by supplying run parameters. Editor autocomplete and variable warnings help connect prompts to the values the workflow produces.

Foreach work queues

Run a sealed sub-chain over a list of items, with per-item variables, captured outputs, and a final roll-up. Track success, partial completion, and failure.

Availability & scopeForeach items execute serially; this is distinct from independent DAG branches.

Gates and run inspection

Place gates between stages, watch live node status, and drill into the sessions behind a node. Keep a visible boundary between implementation and the next workflow action.

Templates and scheduled graphs

Start from a pipeline template, customize the graph, and run it manually or attach it to an automation. Follow a triggered run back to its originating schedule.

Cron and interval triggers

Give an agent a prompt and a schedule for recurring tasks such as regression checks, issue triage, maintenance, or research. Scope the work to its project and repository.

Webhook-triggered runs

Start configured work from external events using webhook triggers. Connect incoming events to the same session and workflow surfaces used for manual runs.

Autopilot project crews

Provision a standing improver, reviewer, and QA role with shared operational skills. The default improvement workflow targets one small change, verifies it in isolation, and opens a draft PR.

Custom crew members

Add project-specific or workspace-wide standing agents. Configure their roles and cadence while retaining Autopilot's required isolation and result-reporting instructions.

Configurable PR-handling posture

Choose how far a reviewer may take a change: report, prepare for review, or merge when explicitly enabled and the configured confidence requirements are met.

Visible automation outcomes

Inspect the sessions, runs, verification evidence, and draft PRs produced by background work. Enable or disable the schedule without losing the reusable agents and skills.

Champion–challenger comparisons

Use Forge to compare a current skill or loop strategy with proposed alternatives against a quality rubric. Keep a stable champion while evaluating candidates.

Golden tasks and held-out cases

Define evaluation cases and separate training examples from held-out checks. Compare candidates on tasks that exercise the behavior you want to improve.

Execution-based rollouts

Opt into running candidate instructions in isolated worktrees and grading the resulting work. Captured outputs, checks, duration, and token cost inform the comparison.

Promotion and rollback

Review tournament results before promoting an eligible challenger. Keep the last-known-good version available for rollback.

Agent-prompt improvement

Propose improvements to agent prompts as well as skills and iteration strategies. Preserve version history instead of silently replacing the instructions active agents rely on.

Living project wiki

Maintain a cross-linked Markdown knowledge base for each project. Configured curator agents synthesize sessions and repository knowledge into persistent documentation.

Intelligence feed

Collect findings, decisions, and summaries from work across sessions, repos, and pipelines. Search the feed or publish a knowledge entry so later sessions can reuse it.

Codebase RAG

Index repository source with local embeddings and ask where an existing capability is implemented. Retrieve relevant code before asking the configured model to explain it.

Availability & scopeOpt-in index; local embedding backend required. Answer generation follows the selected model and offline settings.

Verified file-and-line citations

Codebase answers re-read cited lines at answer time and drop citations that no longer resolve. A confidence and citation gate can return no answer when the evidence is insufficient.

Architecture codemaps

Explore codebase structure through module and service graphs. Combine the architecture view with the knowledge feed and code-level retrieval when investigating a change.

Bounded deep research

Run a research loop with explicit limits and retain its findings in a report. Review generated visual reports and the underlying research artifacts from the workspace.

Multi-model council review

Ask a configured panel of models for independent perspectives on an artifact or decision. Retain the review output and apply the workspace's local-model restrictions when offline mode is enabled.

Local model backends

Connect supported Ollama and llama.cpp backends to run local models through Cuttle. Keep model selection and project context in the same workflow as cloud-backed sessions.

Availability & scopeRequires configured models and hardware capable of serving them.

Offline model policy

Enable workspace offline mode to clamp supported orchestration paths to local models. Cloud-dependent ACP launches are rejected in an offline workspace.

Availability & scopeThis controls model routing; it does not make external integrations or web research available without a network.

Enrolled worker nodes

Register inference workers and advertise the models they can serve. Node enrollment and health visibility turn separate machines into a managed inference fleet.

GPU and VRAM-aware selection

Inspect node capacity and model-fit information. Supported dispatch paths consider model availability, readiness, and capacity when selecting an inference worker.

Capacity and readiness checks

Reserve capacity and probe readiness before dispatching supported work. Surface unavailable or unsuitable nodes instead of treating every registered endpoint as ready.

Remote host terminals

Register remote machines once and open interactive terminal sessions to them. Inspect host health and operate infrastructure from the workspace.

Availability & scopeInference workers serve models; registering one does not move every agent process or checkout onto that machine.

Remote desktop computer use

Give agents access to configured remote machines for screenshots, mouse actions, keyboard input, and visual verification. Use isolated targets for tasks that need a real GUI.

Live mirror and kill switch

Watch the remote machine through the mirror console and stop agent interaction from the control surface. Keep the desktop activity observable while a task runs.

Shared Chrome tabs

Pair the Chrome extension with Cuttle and explicitly share a tab from your own browser. Supported sessions can read, navigate, click, type, and capture the shared page.

Availability & scopeManual extension setup, browser feature flag, and per-site permission required. Human-started sessions only; unshared tabs remain inaccessible.

Audited browser actions

Record extension navigation and interaction events in the project decision log. Stop sharing a tab or revoke the extension pairing when the task is finished.

Isolated development instances

Run per-worktree development servers with separate configuration and discovered ports. Registered instances can be inspected and orphaned instances reclaimed by the runtime reaper.

Git provider credentials

Configure credentials for GitHub and supported Git hosts with user and workspace scopes. Sessions resolve the appropriate host credentials without repeating manual authentication.

Discord session bridge

Mirror project sessions into configured channels and threads, send follow-up instructions, and receive progress notifications where the team already works.

Slack session and intent workflows

Use the configured Slack integration to interact with sessions and connect conversations to tracked intents. Keep project context associated with the work discussed in chat.

Linear integration

Configure API-key or OAuth credentials per project, mirror intent events to Linear, and ingest story comments. Echo guards prevent synchronized comments from endlessly bouncing between systems.

Cuttle command-line interface

Operate sessions, projects, agents, skills, automations, pipelines, knowledge, worktrees, settings, and status from a shell. Script repeatable actions or let a supported session operate its own workspace.

MCP tool surfaces

Expose supported Cuttle operations through its stdio MCP server and gateway. Specialized bridges cover chat platforms, codebase queries, and computer use.

Availability & scopeTool availability depends on the integration and session transport; ACP MCP pass-through is not supported.

Desktop and self-hosted deployment

Run CuttleCode as a packaged desktop application on Windows, macOS, or Linux, or operate a self-hosted instance. The packaged app includes its runtime and server payloads.

Availability & scopeAgent CLIs, authentication, and optional inference or media services require their own setup.

Local project data

Keep the runtime database, project instructions, skill files, logs, and run artifacts in your instance's data directory. Register repositories where they already live and control cloud synchronization separately.

Personal and shared workspaces

Separate projects and configuration by workspace. Shared cloud workspaces support memberships, invitations, and linked devices according to the account's plan.

Availability & scopeCloud accounts and workspace sync are beta.

Selective cloud synchronization

Link an account and choose which workspaces a machine syncs. Share supported configuration and run-history summaries across linked devices.

Availability & scopeBeta. Cloud sync does not host live terminals or synchronize PTY output and full session transcripts.

Device management

Review linked devices and revoke your own device access from the cloud account. Keep workspace membership and machine access separately manageable.

Availability & scopeCloud device management is beta.

Permission modes and review gates

Set agent permission modes and use workflow-specific review gates. ACP sessions surface permission requests and supported runner modes rather than assuming every runner has identical controls.

Token and cost ledger

Inspect recorded token usage and cost by session, agent, and project, with supported provider attribution. Use the ledger to understand where work is consuming model spend.

Availability & scopeMetering coverage depends on the runner and provider. ACP usage-budget enforcement is not supported.

Run budgets and time limits

Bound supported loops with iteration, time, and token controls. Review the termination reason when a run exhausts its configured limits.

Availability & scopeSome budget checks occur at iteration or round boundaries, rather than stopping a request mid-generation.

Encrypted secrets and two-factor authentication

Store provider and integration secrets through the configured secrets backend. Protect sign-in with TOTP enrollment and recovery controls; sensitive credential migration requires administrator access and inline verification.

Portable credential archives

Export sensitive credentials into a passphrase-encrypted archive and import them into another instance. Preview the import before applying it; the destination re-encrypts values under its own key.

Fetch and untrusted-content guards

Supported server fetch paths use SSRF protection, while retrieved external content is marked as untrusted context. These controls help distinguish source material from operator instructions.

Operational health and recovery

Use supported native supervision for crash and readiness recovery, rotating server logs for diagnosis, and outbound heartbeat pings for an external uptime monitor.

Availability & scopeBehavior depends on launch mode. Docker health checks alone do not restart a wedged container.

Local image generation

Generate images from text with a configured local diffusion backend and browse the resulting gallery. Connect image generation to a pipeline when the workflow needs visual assets.

Availability & scopeRequires the media feature and a compatible local backend.

Short video and image-to-video

Use configured video models for short generated clips, including animation from an image. Video work runs as jobs with model and clip-length limits.

Motion Studio

Turn a brief into a Remotion composition and run a render, review, and correction loop toward an MP4 artifact.

Availability & scopeBeta; rendering environment and media dependencies required.

Built-in feature discovery

Search the product's Discover catalog by capability or task. Find related documentation, CLI examples, and natural-language prompts for operating the workspace.