sens-ai

A desktop app for Claude Code, on your own subscription. Every step the agent takes, on screen. Every plugin, skill and MCP server, chosen per project.

Download · Tour · How it works · Build from source · Contributing · FAQ

What it is

Claude Code runs in a terminal. Sens gives it a window: a chat that shows every step the agent takes, the project's files, changes, browser and terminal beside it, and one place to choose what each project may load.

Under the window is the unmodified claude CLI. Sens drives it over Claude Code's own stream protocol — one process per session, resumed when you come back to it — so nothing Claude Code does is reimplemented, and nothing it does is hidden.

Download

1. Download Sens_<version>_x64-setup.exe from the latest release.
2. Open it. It installs for you alone, in %LOCALAPPDATA%\Sens, without an administrator prompt, and asks which language Sens should speak and how it should look before it does.
3. Open Sens. A short welcome sets your name and checks Claude Code — installing it from Anthropic's release channel, checksum-verified, if it is missing — then offers to bring your existing Claude Code sessions and the MCP servers you set up in Claude Desktop, Cursor, Windsurf, VS Code or Codex.

[!WARNING]The installer is not code-signed yet, so Windows SmartScreen shows Windows protected your PC. Choose More info → Run anyway only for a file downloaded from this repository's releases, and compare it with the SHA-256 in the release notes.

Requirements. Windows 10 or 11 on x64, with Microsoft Edge WebView2 (part of Windows 11; the installer sends you to Microsoft's download if it is missing), and a Claude account.

Updates. Sens checks this repository's releases when it opens and every 12 hours; Settings › General turns that off. A new version appears as a pill in the top bar, and Update and restart downloads it, verifies its signature, and reopens Sens on it — with what changed.

A tour

A chat that shows its work

• Every tool call is a step you can open. Commands read in their own shell's grammar and their output keeps its program's colours; reads, searches, edits as diffs, checklists, web sources, subagents, and background tasks you can stop. A file:line opens the file.
• Thinking says what it is about. Each thought is titled by its own text, with how long it took. Once a reply is done, the work folds into one line — Worked · 2 commands · 1 file read · 1 edit · 1 search — that opens to all of it. A failure is never folded away.
• Prompts arrive in the thread. Permission requests, questions and plans wait for you where you are reading.
• Attach anything. Pictures in any format the window can draw, converted and resized to what Claude accepts; files; folders Claude can explore; a PDF copied in Explorer; a long paste, as an attachment of its own.
• Type less. @ mentions a file, / offers Claude Code's commands and your skills, ↑ and ↓ bring back what you sent.
• Or say it. The microphone writes what you say into the message as you say it, with Whisper running on your computer: each phrase is corrected once you pause, and your voice never leaves it. Pick the microphone and test its level in Settings › Focus & voice.
• Choose per session. Model, effort, thinking, and a permission mode: Ask, Accept edits, Auto, Plan or No checks. The model list is the one Claude Code itself offers.
• Sessions name themselves after the first reply, in your language, and Sens tells you when one finishes or needs you while you are elsewhere.

The project, beside the chat

The tool panel keeps the project in view while Claude works on it.

Artifacts, in the sidebar, collects the pictures, files and links that came out of every session, so you find them without reading the session again.

Sessions that work apart

A new session in a git repository can work in a worktree of its own, on a new sens/<id> branch, so your folder stays as it is until you merge. Choose it with the Worktree chip before the first message. Sessions live next to the project, in .sens/, which keeps itself out of git.

What a session costs

Capabilities

Capabilities › Explore is a market of what Claude Code can load, browsed by purpose — code, agents, data, cloud, security, design, productivity and more — or searched as you type.

Every entry has a page with its readme, every file it ships and what it runs — hooks, MCP servers, executables and the variables it will ask for — before you install it. Installing downloads it once, pinned to a commit; enabling it is per project. Plugins reach the agent with --plugin-dir, never through your own Claude Code configuration.

Six languages, five accents

Sens speaks English, Español, Français, Deutsch, 日本語 and 简体中文 — the interface, the installer, its own messages and the titles it gives sessions. It looks dark, light or as Windows does, in Signal, Ice, Iris, Rose or Neutral. The installer asks first; Settings › Language and Settings › Appearance change them later, without a restart.

Keyboard

How it works

%%{init: {"theme": "neutral"}}%%
flowchart LR
  subgraph window["Sens window · WebView2"]
    ui["Interface<br/>React 19 · Vite · Zustand"]
  end
  subgraph native["sens-app.exe · Rust"]
    app["sens-app<br/>projects · capabilities · market<br/>git · terminal · updates"]
    agent["sens-agent<br/>one process per session<br/>stream-json · transcripts"]
  end
  cli["claude<br/>the Claude Code CLI"]
  anthropic(["Anthropic"])
  ui <-- "Tauri IPC" --> app
  app --> agent
  agent <-- "stdin / stdout" --> cli
  cli <--> anthropic

When you send a message:

1. The interface hands your text and attachments to sens-app over Tauri's IPC.
2. sens-agent starts claude for that session — or resumes it with --resume — speaking stream-json both ways, with the session's --model, --effort and --permission-mode, the MCP servers enabled in this project, and a --plugin-dir for each of its plugins.
3. Every event streams back as it happens: partial text, thoughts, tool calls and their results. Only the reply that changed is drawn again.
4. Permission requests and questions travel the same pipe, and wait in the thread for your answer.
5. Each Claude Code process runs in a Windows job object, so stopping a session also stops the MCP servers, dev servers and background tasks it started.

What Sens connects to

Your prompts and your code go where Claude Code sends them, and nowhere else. Sens itself only reaches these:

Where things live

Signed in with your Claude plan, Sens never sees your credentials: Claude Code keeps them. If you choose an API key instead, Sens seals it with Windows DPAPI and hands it to Claude Code as ANTHROPIC_API_KEY.

Build from source

You need Windows, Node.js 24, Rust 1.98 or newer — CI pins 1.98.1 — and, for whisper.cpp, CMake and LLVM (winget install Kitware.CMake LLVM.LLVM).

git clone https://github.com/iiTzSenn/Sens.git
cd Sens
npm ci
npm run app:dev

app:dev opens the app over Vite's dev server, so edits under rust/sens-app/ui/src show up without a rebuild. To build the installer:

npm run app:installer -- --unsigned --no-updater

That leaves rust/sens-setup/target/installer/Sens_<version>_x64-setup.exe. Sens's installer is its own, not NSIS: sens-app.exe compressed with Brotli inside a small Tauri window that installs per user and takes over an install made by the old NSIS setup in place. The script refuses to build an unsigned installer, or one without an update signature, unless you say so; rust/sens-app/README.md covers code signing, the updater key and what a certificate does and does not buy.

The interface without Rust

npm run dev -w sens-app-ui

serves the interface at http://localhost:5173 to any browser, over a simulated Tauri with fixtures for projects, sessions, the market and a streaming reply. The URL picks what you see:

npm run dev:setup -w sens-app-ui does the same for the installer, with ?mode=update, ?mode=uninstall, ?running=1 and ?fail=extract; npm run setup:dev opens it in its real window, as a demo that writes nothing.

Tests

npm test                 # vitest: the interface, the installer, the brand
npm run typecheck
cargo test --manifest-path rust/sens-agent/Cargo.toml
cargo test --manifest-path rust/sens-app/Cargo.toml
cargo test --manifest-path rust/sens-setup/Cargo.toml

CI runs all of it on every push and pull request: the type check, the tests and both interface builds on Ubuntu; cargo clippy -- -D warnings and the Rust tests for the three crates on Windows.

Repository layout

rust/
  sens-agent/     the engine: drives claude, one process per session, stream-json, transcripts, titles
  sens-app/       the desktop app: projects, capabilities, market, git, terminal, browser, updates
    ui/           the interface, and the installer's: React 19, Vite, Zustand, Shiki, xterm.js
  sens-setup/     the installer and uninstaller
src/brand/        design tokens, and the mark's and wordmark's geometry
scripts/          brand assets, the installer build, the version check
docs/             the visual identity, the language guide, design specs

Releasing

The version is written in several places and must agree everywhere; npm run version:check says where it does not. Pushing a v* tag runs the release workflow: it checks that the tag names that version, type-checks and tests, builds the installer, signs the update with the key whose public half is compiled into the app, and attaches the .exe and its .sig to the release. The release notes are what Sens shows under What's new, up to the first alert or ### Install heading.

Contributing

Issues and pull requests are welcome. A few rules keep the codebase the way it is:

• No comments. Code explains itself with names and structure, or it gets extracted until it does.
• Six languages. Anything a person reads exists in all six. copy() refuses to compile when a language is missing a key; Sens in six languages has the voice and the glossary.
• One identity. Anything visual follows the Sens visual identity. Colours live in src/brand/tokens.ts and the mark's geometry in src/brand/mark.ts: import the token instead of retyping a hex, and change the generator (npm run brand), not the asset it wrote.
• Commits say what changed for the person using Sens. fix(app): Enter while Claude works keeps the message, not fix: handle keydown.
• CI stays green, and clippy has nothing to say.

FAQ

License

MIT — do what you want, just keep the copyright notice.

Sens is an independent project, not affiliated with or endorsed by Anthropic. Claude and Claude Code are trademarks of Anthropic.