Your AI coding environment.

Chat, Design Studio and a native terminal in one Rust-built app for macOS, Windows and Linux. Managed models included — or bring your own keys.

See pricing

macOS · Windows · Linux

The Zodex desktop app: project sidebar on the left, an agent session with applied patches and executed commands on the right.

The Zodex desktop app in dark mode: project sidebar on the left, an agent session with applied patches and executed commands on the right.

One app, instead of six windows.

Your terminal, Git client, code editor, browser, Design Studio and Linear tasks live beside your agent conversations. Plan the work, design it, build it and check the result without switching windows.

Native terminal

Run commands, start a dev server or check build output without opening a separate terminal.

Git client

Review diffs, stage files and commit changes without switching to a separate Git app.

Code editor

Open and edit project files beside the conversation. Inspect changes without opening another editor.

Web browser

Preview your app and browse documentation in the built-in browser, right next to the code.

Design Studio

Generate UI components, arrange them on a canvas and mark up revisions without opening a separate design tool.

Tasks

Connect Linear, assign issues to agents and track their progress without switching to your task tracker.

Built-in browser

Let your agent check its own work.

Code changes are only half the job. Open your app inside Zodex and let the agent inspect the page, interact with it, and check what happens.

Preview
Your app, beside your code.
Open a local app or website in a side panel or editor tab. Check different viewport sizes without leaving the workspace.
Inspect
Give the agent something concrete.
Read page elements, inspect console messages and network requests, and capture screenshots. Bring what the browser shows into the conversation.
Verify
Check the work in the running app.
The agent can click, type, select and scroll, then inspect the result. Test the actual flow instead of stopping at a code change.

Agent-owned pages use a separate session, not your personal browser cookies or logins.

See the built-in browser in action inside Zodex.

Point to the element you mean.: Pick an element on the page to attach its selector and details to chat. Give the agent context without describing where to look.
Take a screenshot. Drop it into chat.: Capture the visible page and drag the screenshot into a conversation, another app or a folder.

Session import

Bring the work with you.

Zodex automatically detects your local Codex, Claude Code, and Pi history, keeping every conversation organized inside its project and ready to continue.

CodexClaude CodePi

Local

Nothing leaves machine

Selective

Import what you need

Organized

Grouped by project

Project notes

Keep the thinking beside the work.

Capture the plan, the constraint you do not want to forget, or the links behind a decision. Notes stay attached to the project and open alongside the conversation.

Project-scoped: Each note stays with the project it belongs to.
Markdown ready: Write plans, checklists, links and code without leaving the workspace.
Your reading pace: Choose the typeface and size that keep long notes comfortable.

A browser-planning note open beside its project conversation in Zodex.

Agents

Dispatch work, then check it.

Connect Linear, build agents for the jobs you repeat, and send them straight at an issue. Nothing they write reaches your branch until you've read it.

Straight from the backlog

Pick an issue, hand it to an agent, and keep working while it runs.

Every diff, before it lands

Read the change file by file, approve what's right, throw away what isn't.

Sub-agents

Let a cheaper model do the busywork.

A session can start its own agents and run three of them at once. You pick the model those agents use, so the strong one keeps thinking while a cheaper one does the typing.

GPT-5.6 SolYour session. Plans the work and reads everything that comes back.

Uses whichever model you pick for this session.Updates the call sites
Uses whichever model you pick for this session.Fixes the failing tests
Uses whichever model you pick for this session.Finds the out-of-date docs

Choose it once

An agent uses whatever model is set when it starts, so there's nothing to choose task by task. Change it later and the next agent picks up the change.

See what each agent cost

Tokens and cost are listed agent by agent, so you can see what the session spent on its own and what it spent on help.

Design Studio

Try the UI before you commit to it.

Generate component variants in an isolated sandbox, lay them out on a canvas, and implement only the one you actually want.

Nothing is written until you say so: Variants render in a sandbox. Your project files stay exactly as they were until you press Implement.
Take the good half of each: Keep the header from one variant and the layout from another, and combine them into the one you ship.
Tokens, not guesswork: Spacing, colour and radius are editable as real theme tokens, previewed live before they go global.

Generate in the conversation

Ask for a component the same way you ask for anything else, and compare what comes back.

Or open the whole canvas

Place variants side by side, comment on a detail, and send it back for another pass.

Zody

Think out loud. It keeps up.

A voice companion that understands your code and controls the workspace around it — from navigating the interface to opening a session.

Controls your workspace: Toggles sidebars, switches tabs, and opens the terminal or the view you need — all without breaking your flow.
Knows the codebase: Reads your local files, navigates the project, and drafts a fully-contextualised session for you.
Reaches your tools: Moves Linear issues and pulls live Context7 docs while you think out loud.