Fresh in the preview Background follow-ups · faster Review · Fira Code chat

Run all your coding agents.
In parallel. Without the chaos.

Feather Terminal is a free, local-first desktop app for Claude Code, Codex, Gemini CLI and more. Every task gets its own Git worktree, terminal, chat and app preview, so five agents can build five things at once and you review one clean result.

Download the free preview See how it works
  • Free developer preview
  • macOS, Windows & Linux
  • Your code stays on your machine
A little room to explore
Feather Terminal
LOCAL WORKSPACE
Interactive preview Made for the way you work

Your favorite agents. Right at home.

Claude Code Codex Gemini CLI OpenCode Cursor CLI Copilot CLI

WHY IT EXISTS / A note from the maker

I got tired of
explaining myself twice.

Every agent wanted its own window. Claude Code in one terminal, Codex in another, something else in a third — each one good at what it does, and each one starting from nothing.

So I’d switch, and the thread went with it. The branch I was on. What we’d already tried. The reason we’d ruled it out. I’d type the whole story again to a different agent just to get back to where I already was.

I didn’t want to build another agent. I wanted somewhere to keep the ones I already use — one terminal, one chat, one place the work lives — so I can reach for whichever harness suits the task and it starts out knowing where I am.

The harness changes. Your context stays.

Mario — maker of Feather Terminal

▤claude code~/acme-webcontext lost
▤codex~/acme-webcontext lost
▤opencode~/acme-webcontext lost
▤feather terminal~/acme-webcontext kept
Same repository, same task. The difference is what survives the switch.

WHAT IT IS / How it works

What Feather Terminal does,
in three steps.

You add a repository once. From then on, every task runs in its own isolated worktree with its own terminal, chat, ports and app preview, and comes back to you as one reviewable change.

  1. 01

    Add a repository

    Point Feather at a local Git repo. It detects the framework, test command and dev-server port, and keeps them in one config you can read.

    Any language · any framework
  2. 02

    Start tasks with any agent

    Describe the job, pick an agent, go. Each task gets its own worktree, branch and port, so agents never step on each other or on you.

    Six agent CLIs · one workflow
  3. 03

    Review, verify, merge

    Read one combined diff. Run your tests and a second-agent review, then merge or open a pull request. Follow-ups queue themselves while you move on.

    Evidence next to every change

WHY / How it helps

Built for how
agent work really goes.

Agents are fast but messy. Feather keeps the speed and removes the mess: isolation for every task, evidence for every change, and a queue that keeps moving while you think.

Ship in parallel

Run several agents at once instead of babysitting one. Isolated worktrees and per-task ports mean no branch collisions and no stash gymnastics.

Worktrees · ports · services

Never lose the thread

Every task keeps its chat, terminal, runtime and diff. Queue a follow-up and it sends itself when the agent is free, even while you work in another task.

Chat · terminal · queue · replay

Merge with evidence

Tests, a second-agent review and GitHub checks sit next to the diff. Merge is gated on the current tree, never on a stale report.

Tests · review · checkpoints · PRs

Stay local, stay in control

Your repository never leaves your machine. Agents use your own CLI logins. Remote access from your phone is optional and end-to-end encrypted.

Local-first · encrypted remote
A pile of terminal tabsFeather Terminal
  • Six tabs on one branch, constant stashing and rebasingEvery task in its own worktree, branch and port
  • Scroll through logs to guess what actually changedOne combined diff with test, review and CI evidence beside it
  • An agent sits waiting until you happen to noticeNotifications, a queue that keeps working, and a phone remote
  • Copy-paste feedback from the browser or GitHub by handPoint at an element or a PR thread and a draft is prepared for you

Made for

◆ Solo builders running several agents at once ◆ Teams that review agent output before it merges ◆ Anyone who wants agents without giving up local control

Real screens Captured from the running app

Not a mockup.
The app itself.

Seven screens, straight out of the developer preview on macOS. The same glass, the same density, the same live state you get the moment you open it.

Feather Terminal
Workspace
The Feather Terminal workspace: a task rail listing four workspaces and six tasks, beside a running Codex terminal and a live chat pane.
One rail for everything. Workspaces, tasks, and the agents working inside them. Status sits on the left edge of every row, so a glance is enough.
Feather Terminal
App preview
A chat pane beside a live browser preview of a landing page, with a Select element control in the preview toolbar.
Your app, next to your agent. Run what you are building inside Feather. Select an element and your note carries the page and the selector with it.
Feather Terminal
Chat
An agent chat showing a plan, a TSX code block, an expanded tool call, and an open slash command palette.
The plan before the diff. Reasoning, code, and tool calls arrive as they happen, and the slash commands from every harness sit in one list.
Feather Terminal
Review
A pull request view with failing checks and unresolved reviewer threads, beside an agent draft panel.
Feedback, already in context. The pull request for your branch: its checks, its reviewer threads, and a draft you read before anything is sent.
Feather Terminal
Terminal
A terminal pane showing a Claude Code session with a git diff, passing tests, and an open search field.
A real terminal per task. Not a log. Search the scrollback, run your own commands, and watch the diff and the test output land.
Feather Terminal
Remote
The remote access dialog with a pairing QR code, a phone-sized task list, and three recent devices.
Keep going from your phone. Pair a device with a QR code and drive the same tasks. End-to-end encrypted, with nothing put on the public internet.
Feather Terminal
Quick switch
The Find a task palette listing tasks grouped by Needs you, In progress, and Completed.
⌘ Space, then anywhere. Find any task by name, branch, agent, or workspace. Whatever is waiting on you sits at the top.

Drag a screen sideways to read the detail.

Captured from Feather Terminal on macOS. Workspaces, repositories, and review threads are examples, not real accounts.

New A closer connection to your work

See it. Refine it.
Keep moving.

The app you’re building. The feedback that makes it better. The space to think. Now closer to your agent, and closer to hand.

Inside the latest preview
01 / APP PREVIEW

Your app,
beside your agent.

Open the app you’re building inside Feather. Point at a detail and turn your feedback into a draft with the right context attached.

  • ↗ Page and element context
  • ↔ Desktop and mobile viewports
  • ✓ Review the draft before sending

Try it: choose Select element, then the shop button.

✦Storefront refreshExample
localhost:3000
forma®Objects for everyday living
LESS, BUT LOVELIER.

A little more
ordinary magic.

Thoughtful objects.
Made for the moments in between.

Considered details. Lasting favorites.Discover the collection ↗
02 / GITHUB REVIEW

Feedback in.
A clear next step.

See the pull request for your branch, its CI checks, and reviewer conversations. Bring unresolved feedback straight into an agent draft.

  • ↗ The PR beside your work
  • ◉ Checks and review threads
  • ✓ You choose what gets sent

Uses your GitHub CLI sign-in. Try the thread filters and prepare a draft.

⑂Pull requestExample
Open#128storefront-refresh → main

Give the storefront room to breathe

✓ Typecheck passed× 1 layout test failed
Review threads
src/components/Hero.tsxline 42
Jamie Reviewer

Can we keep the call to action clear of the illustration on smaller screens? The layout test catches an overlap at 390px.

Unresolved
src/styles/tokens.cssline 18
Jamie Reviewer

The updated text contrast looks good. Thanks for the fix.

✓ Resolved
1 unresolved thread
03 / YOUR SPACE

A little atmosphere.
A lot of focus.

Soft glass when you want depth. Solid surfaces when you want simplicity. Your chat, terminal, and code stay easy to read.

  • ◐ Glass or Solid appearance
  • ↔ Desktop scale and accent controls
  • ✓ Respect for system preferences

Try a material below. Your choice applies to this website and is saved in this browser.

✦A space for your next idea
FEATHER / WORKSPACE

Make room
for the good work.

Storefront refreshReady for your review↗
Accessibility passAgent working↗

Choose the surface that feels right.

Interactive examples · sample dataAbout the developer preview

Just landed Improvements in the latest preview

Follow-ups that send themselves.

Queue a message while an agent works. It goes out when the turn finishes, even after you move to another task or Home. Errors and approvals pause it.

Review that never waits.

Changed files and the diff appear immediately. Saved reports, verification and GitHub status load alongside instead of holding them back.

Chat in Fira Code.

Messages and the composer default to Fira Code. Choose Fira Code, JetBrains Mono or system fonts and a 12–18 px size in Settings, with a live preview.

Local AI on your GPU.

An optional WebGPU assistant for quick questions when a provider quota runs out. Explicit model downloads, no account, prompts stay on your machine. Explore Local AI ↗

Local AI A second opinion, on device

Think it through.
Keep it local.

Understand a task, untangle your setup, or shape the next step. Bring a local model into the places you already work, with useful context ready for the conversation.

Local AI On device
CONTEXT Checkout task · Workspace setup · Recent chat
YOU

Why do these two tasks keep fighting over the same port?

LOCAL AI

Both dev commands use a fixed port. Give each task its allocated port so the servers can run side by side.

pnpm dev -- --port {{app_port}}

For this Vite example, review the command in the workspace’s deployment settings.

Keep your next move in your hands.
Use a reply as a draft in your coding-agent chat.

Illustrative examples · no model runs on this page
01 / YOUR GPU

Download once. Ask locally.

Choose a model and download it explicitly. Local inference needs no provider account or API credits.

02 / YOUR CONTEXT

Focused on the task at hand.

Bounded workspace context helps ground answers. Each task keeps its own local conversation and draft.

03 / YOUR DECISION

A suggestion you can review.

Turn useful replies into task briefs or setup drafts. Review and save command changes before using them.

Expanded integrations · next desktop build. Requires compatible WebGPU hardware. Local chats stay in memory while the app is open; small models can make mistakes.

Explore the desktop preview

NEW / Queue & review

From your next task
to a reviewed result.

Choose what runs next. Keep the outcome of every attempt. Bring the changes, local verification, and GitHub feedback together when it is time to review.

The work, in order.
01 / MAKE ROOM FOR THE NEXT IDEA

A queue that
keeps its place.

Move waiting tasks up or down, pause new dispatch, and retry a failed attempt in a fresh worktree. Add a prerequisite when one task needs to finish first.

  • Unrelated tasks can pass a blocked item
  • Room reserved for a collaborative worker
  • Every failed attempt stays inspectable

Dependencies control start order. Code is reviewed and merged separately. Scheduled work requires Feather to be running.

Queue 1 / 3 active

Dispatch on · 1 place reserved for a worker

  1. 1
    Improve checkout validation CollaborateNeeds room for a lead + worker
  2. 2
    Refresh the setup guideReady when a task slot is available
  3. 3
    Check the checkout journeyStarts after checkout validation succeeds
Failed
Investigate a flaky testAttempt 1 · previous task preserved
Retry in new task ↗

Try moving a task up. Its prerequisites still apply.

02 / KNOW WHAT WAS CHECKED

The result.
And the evidence.

The Review tab brings the task brief, changed files, saved local test and agent-review reports, and GitHub feedback into one overview.

  • See the tree and base behind local checks
  • Spot stale evidence after another edit
  • Turn unresolved feedback into a chat draft

Local verification and GitHub CI show their own versions. Missing or skipped checks are never presented as passed.

Checkout validation Review overviewGitHub needs attention
LOCAL TESTS✓ Passed

Configured checks passed.

Recorded tree 3de91af
AGENT REVIEW✓ Passed

No blocking findings.

Recorded tree 3de91af
GITHUB1 unresolved

2 reported checks passed.

PR commit 72bd810
5 changed files +84 / −19Current tree 3de91af

Local checks cover the current worktree. The PR still has feedback to address.

Interactive examples · sample dataBackground execution across app restarts is planned.

01 / Better together

Parallel work.
A shared finish line.

Give one goal to a lead. Let the right agents take on independent work, each in its own worktree. Bring it all back to one result you can review.

  1. 01
    Plan

    The lead reads the goal and decides whether parallelism will actually help.

  2. 02
    Spawn

    Up to four direct workers receive complementary, non-overlapping briefs.

  3. 03
    Work

    Each worker runs with its own branch, worktree, model, and live status.

  4. 04
    Merge

    Edits are committed, ancestry checked, and failed merges are aborted cleanly.

  5. 05
    Review

    Finished workers close themselves and free their worktree. You review one integrated diff.

4
Direct-worker limit

Enough parallelism without runaway fan-out.

↳
No recursive swarm

Workers cannot create workers of their own.

⊘
Clean conflict aborts

The lead is restored when integration fails.

✓
Truthful completion

Done means the worker change is integrated.

⤓
Workers clean up after themselves

An integrated worker releases its process, worktree, and ports. Its report stays with the lead, and a failed worker stays open for you to inspect.

02 / In your element

From first thought
to final diff.

A workspace that keeps up with your ideas. Brief your agents, follow their progress, and review the details, all in one place.

Feather Terminal product tour
Product tour unavailableThe rest of the page shows every core workflow.

The workspace, in motion A guided recreation of the desktop experience.

01

Brief, then dispatch

Create a task with its goal attached. Choose your agent and environment, then follow the work from its first turn.

02

Queue the next move

Build a task backlog, choose a concurrency limit, and set recurring schedules while Feather Terminal is running.

03

Route the right model

Choose the harness and model per task, or let Smart Models match the work to an available option.

03 / Confidence, built in

Every change.
In the clear.

One branch. One combined diff. A clear view of what changed, and the checks to help you move forward.

  • 01
    Inspect the combined diff

    Review every integrated change with syntax-aware, file-by-file context.

  • 02
    Run the configured gates

    Tests and a second-agent review can feed findings back into the task.

  • 03
    Keep a way back

    Save checkpoints and restore worktree files. When you’re ready, merge into the base branch or prepare a pull request.

04 / A little more freedom

Out of office.
Still in the loop.

Pair the whole workspace or share one task with a server-enforced scope. Continue through the encrypted web companion when an agent needs a decision.

  • ⌁
    Share the right scope

    Choose full control or a task-scoped link before showing the QR.

  • ◇
    The right controls

    Use chat, terminal, and diff for one task; add fleet, queue, and usage with full control.

  • ⌾
    Encrypted bearer link

    The relay sees ciphertext. The QR is the key, and Stop Sharing revokes it for everyone.

05 / Thoughtfully equipped

The little things.
Already thought through.

The tools around your agents matter, too. Keep your environment, your time, and your next move under control.

Real Git worktrees

Start tasks in isolated branches and working directories, or add another agent to an existing workspace.

FILES & COMMITS

A terminal that stays close

Move between structured chat and a real terminal. Search output and navigate command blocks in supported shells.

CHAT & TERMINAL

Runtime visibility

Track ports, processes, app-wide services, and per-worktree SQLite isolation.

RUNTIME & SERVICES

Queues and schedules

Keep a backlog, set concurrency and task budgets, and schedule recurring work while the desktop app is running.

AUTOMATION

A clearer view of usage

Check available account quotas, recorded tokens, and cost breakdowns. Token-priced estimates are identified separately from provider-reported costs.

MODELS & USAGE

Local MCP control

Expose core task, terminal, diff, review, queue, and agent operations on localhost.

AUTOMATABLE

06 / The complete picture

Everything inside.
Nothing hidden away.

The full capability index of the developer preview — grouped the way you actually work. Pick an area, or read straight through.

01 — WORKSPACES

Isolation you can trust

Register a repository once. Every task after that gets its own branch, directory, ports, and data.

10 capabilities

  • Real Git worktrees Each task runs on its own branch in its own working directory, off a workspace you add once.
  • Zero-config onboarding Adding a repo detects the framework, package manager, and a sensible isolation default to confirm.
  • Three isolation tiers Files only, a per-worktree SQLite copy, or a full Docker app for the task — chosen per workspace.
  • Ports that never collide Every worktree receives its own port block and runtime variables, so parallel apps can all run.
  • Shareable project config Setup steps, environment, and services live in editable JSON you can keep beside the code.
  • Workspace categories Group repositories, then filter the task list down to the one you are actually working in.
  • Base branch, your choice Pick where a task starts, sync it with the base later, and merge back when the work is done.
  • Project memory & scratchpad Durable notes per workspace, plus a scratchpad per task that travels with the conversation.
  • Attach to existing work Point a new agent at a worktree you already started instead of branching again.
  • Open in your editor Jump from a task or a single changed file straight into VS Code, Cursor, or your editor of choice.
02 — AGENTS & MODELS

Bring the agents you already use

Feather drives the CLIs you are signed in to. No new provider account, no proxy in the middle.

11 capabilities

  • Seven harnesses Claude Code, Codex, Gemini CLI, OpenCode, Cursor CLI, GitHub Copilot CLI, and a plain shell.
  • Swap agent or model Change which agent and which model a task uses without losing the conversation or the worktree.
  • Permission modes Run a task with normal prompts, auto-accepted edits, plan-only, or full autonomy.
  • Several accounts per agent Sign in to more than one account per harness and switch between them from Settings.
  • Install and verify Install a missing CLI from the app, and see which harnesses are ready before spending a token.
  • Doctor One pass over your environment, tooling, and agent sign-in, with what to fix spelled out.
  • Skills & slash commands Browse what each harness can load on demand, per workspace, before you ask for it.
  • Saved prompts Reusable briefs you can drop into any chat instead of retyping the same instructions.
  • Quick commands One-click commands in every task's terminal quick-bar — your build, your tests, your seed script.
  • Stall detection New A harness that has gone quiet is surfaced with a way out, instead of spinning forever.
  • Local AI assistant An optional assistant running on your GPU. Expanded task chat, setup, planning, and Linear integration arrive in the next desktop build. Explore Local AI ↗
03 — CHAT & TERMINAL

Two views of the same work

A structured conversation when you want the summary, a real terminal when you want the truth.

12 capabilities

  • Structured chat Messages, plans, questions, tool calls, and diffs rendered as blocks you can actually read.
  • Real terminals Several PTY tabs per task, inside the worktree, with output search and command-block navigation.
  • Terminal appearance Colour theme, font, size, line height, letter spacing, and cursor style — or edit single ANSI colours.
  • Answer without leaving Respond to an agent's permission question inline, in the same place you read it.
  • Repeat a turn Run the same prompt in a loop for iterative work, and cancel the loop at any point.
  • Reset the context Clear a conversation or start a fresh context while keeping the worktree and its changes.
  • Reference other tasks Attach another task as context, read-only or in full, so an agent sees related work.
  • Per-task todos A small checklist that stays with the task and survives restarts.
  • Images in chat Paste a screenshot into the conversation and let a vision-capable agent read it.
  • Replay Step back through recorded agent activity — conversation and tool events — at your own pace.
  • Background follow-ups Queue a message during a turn; Feather sends it when the agent is free, even after you switch task or go Home.
  • Chat typography Fira Code by default, or JetBrains Mono and system fonts, from 12 to 18 px, with a live preview in Settings.
04 — COLLABORATION

Many agents, one result

A lead splits the goal, workers run in parallel, and the code comes back through verified merges.

8 capabilities

  • Lead and workers A lead plans, then dispatches up to four direct workers, each in its own isolated worktree.
  • Suggested swarm size Feather proposes how much parallelism the goal actually needs before anything is spawned.
  • Planned workflows Lay out the steps up front and let the lead execute them, instead of improvising fan-out.
  • Verified merges Worker commits are checked for ancestry, merged serially, and aborted cleanly on conflict.
  • Workers retire themselves New A worker that finishes and integrates releases its process, worktree, and ports on its own.
  • Reports outlive the worker The final report stays available to the lead after the worker closes, and after a restart.
  • Compare parallel attempts Run several takes on the same brief, then judge them side by side and keep the best one.
  • One shared capacity A single global limit covers leads and workers, so your machine is never quietly oversubscribed.
05 — QUEUE & AUTOMATION

Work that waits its turn

Line up what comes next, control when it starts, and keep a ceiling on what it costs.

9 capabilities

  • A durable queue Waiting tasks survive a restart and keep their place in line.
  • Reorder and pause Move a task up or down, pause dispatch entirely, and resume when you are ready for it.
  • Prerequisites Make one task wait for another. Unrelated work still passes a blocked item.
  • Explicit retries A failed attempt stays inspectable, and retries in a fresh worktree only when you ask.
  • Reserved worker room A queued collaborative lead holds capacity for the workers it is going to need.
  • Schedules Recurring runs for routine work, executed while the desktop app is open.
  • Open-task automation Decide what happens the moment you open a task — focus chat, run setup, or stay put.
  • Webhooks Fire an HTTP hook on task and agent lifecycle events, and test it before you rely on it.
  • Per-task budgets Cap what a task may spend and have it pause itself at the limit rather than running on.
06 — REVIEW & DELIVERY

Evidence, not assurances

Everything you need to decide whether a change is good — gathered in one place and honest about its gaps.

9 capabilities

  • Review overview The brief, the changed files, saved reports, and GitHub feedback in a single view.
  • Diff by file Read the change file by file, and revert the parts you do not want to keep.
  • Local verification Run your tests or any command, then keep the result as recorded evidence for the task.
  • Stale evidence, flagged A later edit marks saved checks stale. Missing or skipped checks are never shown as passed.
  • Agent review pass Ask a second agent to review the change and save its report next to the diff.
  • Pull requests Open a PR from a task, then pull its review threads and check results back into the app.
  • Feedback into a draft Turn unresolved review threads into a ready chat draft, with the thread context attached.
  • Checkpoints & rewind Snapshot a task before a risky step, then rewind to it if the agent takes a wrong turn.
  • Merge with history checked Merge back into the base branch with ancestry confirmed, or stop before anything lands.
07 — RUNTIME & SERVICES

The app, running beside the agent

Ports, processes, services, and a live preview — so you can see the result, not just the diff.

8 capabilities

  • Activity Live processes and listening ports across every task, with a way to free a stuck port.
  • Shared services Start, stop, restart, and read logs for app-wide services like databases, caches, and queues.
  • Credentials wired in Feather writes service connection details into the task's environment so setup just works.
  • Per-task databases Create and drop an isolated database for a worktree, so migrations never touch your main data.
  • App preview Your running app next to the conversation, in a desktop or mobile viewport.
  • Element feedback Point at a button in the preview, write a note, and send the request anchored to that element.
  • Run environment Setup and run commands defined once per workspace and reused by every task started from it.
  • Fleet view Every active agent, its workspace, and its state on one canvas when several are running.
08 — USAGE & INSIGHT

Know what it cost

Recorded token use and provider quotas, presented without pretending an estimate is a receipt.

5 capabilities

  • Recorded usage Tokens and cost broken down by task, model, and day, from turns that actually ran.
  • Provider quotas Remaining limits read from your own signed-in accounts, alongside your recorded spend.
  • Estimates labelled Token-priced estimates are identified separately from provider-reported cost, always.
  • Usage alerts Set a threshold and hear about it before you hit a limit rather than after.
  • Floating widget Pin a small always-on usage window beside your editor while the work runs.
09 — CONTROL & PRIVACY

Yours to drive

Everything the interface can do is available to your own automation — and none of it leaves the machine unasked.

12 capabilities

  • Optional cloud accountGoogle sign-in, a website account page and local use without a Feather account.
  • Cloud configuration savesFour free workspace saves and one settings backup; reviewed v1 .agent-config.json export and restore.
  • Environment recipesPro snapshots record setup and runtime versions without uploading repository files or environment values.
  • Approved remote devicesAccount-bound encrypted invitations, device approval, view/control roles and revocation in the new build.
  • Local MCP server Drive tasks, terminals, diffs, review, the queue, and the swarm over localhost.
  • One action, two front doors An external agent and the interface call the same operations under the same rules.
  • Live events Subscribe to task, chat, and terminal events instead of polling for changes.
  • Phone companion Pair with a QR code and follow the work from your phone over an encrypted relay.
  • Scoped remote access Chat, terminals, verification, and queue control — each granted only if you grant it.
  • Workspace plugins Opt-in per-repository capabilities, like a local code index your agents can query over MCP.
  • Settings import & export Carry your workspaces, prompts, commands, and preferences to another machine.
  • Storage you can check Durability status in the app, with an explicit retry when a save could not be written.

Desktop developer preview. Scheduled and queued work runs while Feather Terminal is open; background execution across restarts is still planned. Structured chat and collaboration depend on each harness's headless and tool-bridge support.

OPTIONAL FEATHER CLOUD

Local by default.
Your setup, on hand.

Keep using Feather without an account. Sign in with Google when you want cloud configurations and secure remote access. Cloud features are in preview. Desktop integration will arrive in an upcoming release.

LOCAL

Just your computer

No Feather account required. Projects, settings and .agent-config.json stay local.

FREE ACCOUNT

Four saved workspaces

Review configurations before uploading, back up personal settings and try remote access for seven days.

PRO · US$15 / MONTH

More room to return

30 cloud workspaces, 10 environment snapshots per workspace, and up to 5 active invitations from one desktop. Cancel online; keep Pro until your paid period ends. Paid upgrades are opening soon.

Simple monthly pricing, with no per-minute remote charges. AI provider usage is billed separately. Existing cloud saves remain available after a downgrade.

Environment snapshots save configuration, runtime versions and lockfile fingerprints. They do not upload your repository, dependencies or environment values. Restore into a local checkout, review its commands, then rebuild.

Manage your Feather account ↗

At home on your machine

Your code. Your space.

Feather Terminal runs on your computer. Your repository stays in local worktrees, with no upload to a Feather backend. Your coding agents use their own providers and data terms. Remote access is always optional.

✓ Local worktrees✓ Existing CLI auth✓ Optional remote relay✓ Local control API

A few things to know

Good questions.
Clear answers.

Feather Terminal is currently a desktop developer preview. Here’s what to expect.

macOS · Windows · Linux
What is Feather Terminal, in one sentence?+

A free, local-first desktop app that runs AI coding agents such as Claude Code, Codex and Gemini CLI side by side, each task in its own Git worktree, with a live terminal, chat, app preview and an evidence-backed review before you merge.

Is it free? Do I need an account?+

The desktop developer preview is free and needs no Feather account. Your coding agents use their own provider logins and billing. An optional Feather Cloud account adds saved configurations and secure remote access; Pro is US$15 per month.

Which coding agents are supported?+

Feather Terminal includes Claude Code, Codex, Gemini CLI, OpenCode, Cursor CLI, GitHub Copilot CLI, and a plain shell. Structured chat and collaboration depend on each harness’s headless and tool-bridge support.

How is worker integration kept safe?+

Workers start from a recorded commit in isolated worktrees. Feather Terminal commits their edits, verifies branch history, merges serially, confirms the worker commit landed, and aborts failed merges while restoring the lead. A worker that integrates then closes itself and releases its worktree and ports; its final report stays with the lead, and a failed worker stays open for you to inspect.

Does Feather Terminal send my repository to a backend?+

No Feather Terminal backend receives your repository. The app and worktrees run locally. The coding-agent CLI you choose may send prompt or code context to its own provider under that provider’s terms.

What can I do from the remote companion?+

A task link exposes that task’s chat, terminal, diff, and permission replies. Full control adds workspace-wide task, queue, fleet, and usage surfaces. The desktop enforces the API scope, but a shared terminal still has your local user’s filesystem permissions.

Can agents automate Feather Terminal itself?+

Yes. A localhost MCP control plane exposes core workspace operations including tasks, terminals, diffs, reviews, queues, and bounded worker delegation.

How does visual feedback work?+

Open your running app in the task’s Preview tab, select an element, and describe your change. Feather adds the element’s page, text, and layout context to a chat draft for you to edit and send. Desktop and mobile-width previews are available.

Can I review GitHub pull requests here?+

Yes. Sign in with the GitHub CLI to see the current branch’s pull request, CI checks, and review threads. Selected feedback becomes an editable agent draft. You decide when to send it; preparing a draft does not post or resolve GitHub comments.

Can I turn off the glass effect?+

Yes. Choose Glass or Solid in the desktop appearance settings, alongside accent color and display scale. The interface also respects supported system preferences for reduced motion, reduced transparency, and increased contrast.

Will scheduled tasks run if I close Feather?+

Schedules run in the desktop app, so Feather must remain running on your computer. Queue items can have their own task budgets. When a schedule has a budget, each occurrence starts with a fresh budget.

Where can I download it?+

Choose your platform in the download section. Links follow the latest published release automatically. macOS has separate Apple Silicon and Intel installers; Windows and Linux builds are experimental previews. Install Git and your coding-agent CLIs separately, then sign in with their own accounts.

Get Feather Terminal

Your next workspace.
On your desktop.

Choose your platform. These links always follow the latest published desktop release.

Apple Silicon

macOS

M1 or newer

Download DMG

Intel

macOS

Intel-based Macs

Download DMG

Latest desktop installers

Release notes & checksums ↗

Developer preview. Windows and Linux builds are experimental. Install Git and your preferred coding-agent CLI before starting. Unsigned Windows builds and macOS builds without notarization may need approval from your operating system.

Developer preview

Big ideas deserve
a little headspace.

Bring your agents. Find your focus. Build what’s next.

Download Feather Terminal

Developer preview · macOS, Windows & Linux