steventsvik/Tellurion

Download · Website · Boards · Live agents · Features · Compare · Install · Shortcuts · Security

_{Real app, real agents, demo projects. The full tour, as a GIF. Watch it in higher quality.}

Tellurion is a macOS terminal for developers who run several AI coding agents, like Claude Code, Codex, Gemini CLI and Copilot CLI, across several projects at once. It's a fork of Ghostty, the fast native terminal, that shows what every agent is doing, live: the code it's writing as it writes it, where it is in your project, what part of your backend it touches, and when it needs you. Agents share what they learn about each project, hand work to each other, and leave their changes in a review inbox you can undo from. Run them in tabs, or on a board where every terminal is a tile and one card can run a whole team of agents. Answer them from your phone, and chat with models that run on your own Mac.

Everything Ghostty does still works, and your Ghostty config works as-is. This fork tracks official Ghostty releases and adds its features on top.

Tellurion was called GhosttyEXTREME. Same app, same features; if you have GhosttyEXTREME installed, Check for Updates… brings you to Tellurion.

[!NOTE] Unofficial fork. Not affiliated with or endorsed by the Ghostty project.

curl -fsSL https://raw.githubusercontent.com/steventsvik/Tellurion/custom/install.sh | bash

_{Apple silicon, macOS 13 or newer. Free and open source (AGPL-3.0). No account, no telemetry.}

Boards

New in 1.8: put your terminals on a board instead of in tabs. Pick Board when you first open Tellurion, or any time in Settings → Edition. Classic stays the default, and nothing changes unless you switch.

_{Real app, demo projects. Claude Code and Codex are real; most of the background tiles are stand-ins. Watch it in higher quality.}

Every terminal is a tile

• A full terminal in each tile, so Vim, full-screen apps and every agent work as they do in a tab. Drag a tile by its title bar, resize it from its corner; tiles snap into line with their neighbors (hold ⌘ not to snap).
• Pan and zoom: pinch, or hold ⌘ and scroll, to zoom; drag empty space to move around. ⌥⌘9 shows everything, ⌥⌘0 goes back to actual size, and double-clicking a title bar flies to that tile. Zooming never resizes a terminal, so agents aren't interrupted.
• Switching moves your terminals: pick Board with classic windows open and Tellurion offers to move them. Every tab and split becomes a tile, grouped by project, with agents still running. Keep Windows leaves them where they are.
• Tiles in one project share a color, with a tinted area labelled with its name. Arrange by project tidies the whole board (⌘Z puts it back).
• Tools at the edges: Select, Agent, Group, Terminal, Text, Pen, Eraser, Web and Image on the left, each with a single key; Layers, Tasks, files and changes, and review loops on the right. Right-click empty board for a ring of quick actions.
• Saved as you go: tiles, where you were looking and the window come back when Tellurion starts, and Claude Code and Codex pick up their last conversation. The Boards list in the sidebar switches between boards; the one you leave keeps running.

See who needs you

• Every tile's edge shows its agent's status: it breathes while the agent works and pulses when it needs you. Zoomed out, each tile shows its agent and status in big type.
• The list beside the board puts agents that need you first, with Allow and Deny on the row. Click a row to fly to its tile.
• Agent names: agent tiles get short names (Ada, Otto, Cy…) so you can tell them apart and @mention them. Every title bar has Restart and Duplicate.
• Everywhere else too: notifications, the menu bar item, your phone and the command palette all include agents on boards.

Groups and presets

• The Group composer (the bar's Group chip): a name, a role, up to 12 agent slots, a folder, one first task for all of them, and Skip permission prompts (off unless you turn it on; those tiles wear a red No prompts badge). Spawn starts them as a grid.
• Presets: save a setup and start it again from the Presets chip, which has a few ready-made ones. Spawn 4 starts four of your default agent in one click.
• Groups have roles (Frontend, Backend, Testers, Reviewers, Design, Docs, Security, General), each framed in its color with how many tiles are working. Collapse a group into a list; its agents keep running. Its header menu messages, pauses, tidies or closes them all.
• Talk to a group: type @ in the bar and pick a group to message every tile in it.

Orchestrator

A card that runs a group of agents for you.

• Wire it up: tap Connect and click terminals, or a group's Click to wire group pill. Glowing wires show what's connected, with a dot running along each wire while that agent works.
• Give it a command: your own Claude Code (or Codex) splits the work, sends each agent its part, reads what they answer when they finish, and hands out the next steps until it's done, up to a turn limit you set. @name sends straight to one agent, and it can start new agents too ("start two reviewers").
• It only messages agents. A wired terminal with no agent running is never typed into, and permission prompts still come to you.

Mission Map

Who runs whom on a board: orchestrators, the groups they (or you) run, and every agent, joined by wires (dashed for agents you reach only with @). Filter by status (Working, Needs you, Idle, Done), search, hover to follow a node's wires, and select anything to see how long it's been in its state, go there, pause it or stop it.

The board's agent

A bar at the bottom of every board takes plain requests, typed or spoken (hold Space): "start three Claude agents, one per kanban card", "sketch the backend: API, queue, Postgres". It starts agents and terminals, adds notes, checklists, kanban boards and diagrams, hands cards to agents, groups tiles and zooms to what you ask for.

It runs your own Claude Code (or Codex) with no tools of its own, so all it can do is arrange the board. Closing tiles, typing into an agent that's already running and running a command wait for you to confirm, and ⌘Z undoes what it added. ⌘L jumps to it.

Agent Map

Boards have an Agent Map instead of the code editor: the project's files as a map, grouped by folder, with every agent working in the project as a dot that moves to the file it's reading or changing, trailing the files it came through. Files it changed stay in its color for a while. Hover a file to see who touched it, click an agent to go to its terminal. ⌃⌘M, or Show on Agent Map from a tile's menu.

Web tiles

A browser on the board, next to the agents building the page: tabs, back and forward, an address bar that also searches, and a start page listing the localhost servers running now. Size it to a real screen (24", 27" or 32" 4K) or a phone (iPhone SE to Galaxy S8+) and the page lays out at that size; {} opens Web Inspector. Web tiles keep their cookies and storage apart, get no bridge into Tellurion, and refuse downloads.

Notes, checklists and kanban

Add them from the + menu or by right-clicking the board. Hand a checklist item or a kanban card to an agent on the board, or to a new Claude Code or Codex tile: the card moves to In Progress while the agent works and to Done when it finishes. Kanban boards have Backlog, To Do, In Progress and Done, with due dates and priorities.

Sketches, diagrams and documents

• Sketches: a scratchpad tile with pen, boxes, decision diamonds, databases and arrows that stay attached when you move things. Drop or paste pictures, or bring one in from your iPhone with Continuity Camera. Send to Agent hands the sketch, with what you want built, to an agent on the board or a new Claude Code or Codex tile.
• Diagrams: have your Claude Code or Codex draw one of a project (architecture, user flow, data flow, components, request lifecycle or anything you describe), hand-drawn and fully editable.
• Documents: a project overview, onboarding guide, architecture, API reference or security overview, written from the project. It only reads the project; documents stay in Tellurion's folder, not your repo, and export as Markdown or PDF.
• Draw on the board itself with the pen, in 8 colors and 5 widths, and name areas with big labels.

Accounts, projects and more

• Accounts: use more than one Claude Code or Codex sign-in, choose which one new tiles use, and restart a tile's agent on another. Tellurion only points the agent at each account's folder and never reads sign-in details.
• Projects and Home: a board's top bar shows its project, the project's other boards as tabs (with how many agents need you on each) and when your usage limit resets. Home lists every project with its boards.
• Pause all freezes every tile's agent and everything it started, mid-turn, so they stop using CPU and tokens; Resume all carries on where they left off.
• Media tiles: drop video or music on the board to play it in a tile. They pause when the window is hidden.
• Shortcuts, Spotlight and Siri: Open Board, New Board, Launch Agents on a Board, New Sketch and Arrange Board by Project. "Launch agents in Tellurion" works from Siri.
• Settings → Features switches off Web tiles, drawing, Documents, Diagrams, Accounts, Mission Map and Media tiles; a feature that's off leaves the palettes and menus.

The full list is in the 1.8.0 notes.

Watch your agents work, live

Run Claude Code, Codex, Gemini CLI, Copilot CLI or another agent in a tab, the way you already do. Tellurion follows each one as it works.

Nine agents report live status: Claude Code and Codex, plus GitHub Copilot CLI, Droid, Gemini CLI, Antigravity (agy), Kiro CLI, Cursor CLI and OpenCode. The welcome window connects Claude Code and Codex in one click, and Check Setup offers Connect for each of the others it finds on your Mac. Each hook only observes: it never approves, blocks or changes anything, and any settings file it touches is backed up first (symlinked dotfiles stay symlinks). Copilot, Droid, Gemini and OpenCode also report permission prompts; Kiro, Antigravity and Cursor show Working and Done.

Amp, Goose, Hermes, Aider, Crush, Qwen Code, Kimi and Mistral Vibe are recognized by name and logo when you start them.

Features

Every agent, at a glance

A vertical sidebar (⌃⌘S) lists every tab with its folder, git branch and uncommitted changes. Tabs can be pinned, colored and renamed, and hovering one shows a card with more detail.

• Live status: working, waiting for permission, waiting for input, done or failed. Each card shows the task, how long the agent has been at it and its last action.
• Answer without switching: Allow and Deny right on the card, in Mission Control and in the notification. Keys are only sent when the agent's prompt is actually on screen.
• Project groups: tabs whose agents share a repository are grouped together, with a live summary ("2 working · 1 waiting") and a warning when two agents edit the same file.
• Agents act out their mood. Their sprite reads, types, runs commands and thinks, hops when it needs you and sparkles when it's done. The sigil glows amber while one waits and flares gold when one finishes.
• Alerts: when an agent waits on you in a pane you aren't looking at, you get a notification (click it to jump there) and a count on the Dock icon.
• Usage meters for your Claude and ChatGPT plans (5-hour and weekly windows), with graphs. Click the panel to switch between percentages and when each limit resets.

Mission Control

⌃⌘M shows every agent (or every pane) in every window as a live card: status, task, last action, time in that state and the last lines of its terminal. Agents waiting on you come first. Click a card to jump to it, or hand its work off from there.

The command palette (⌘P) puts waiting agents at the top too, so you can answer one in two keystrokes. It also starts new sessions and opens every tool.

Your terminal on your phone

Open your Mac's address in your phone's browser and you get every terminal tab, grouped by project, with agents that need you at the top.

• Live and in color: tap a tab to see its screen and type to it, with a key row (Esc, Tab, Ctrl, arrows, Ctrl-C) and 1 / 2 / 3 / Esc buttons while an agent asks for permission. Typing arrives as keystrokes, so vim, shells and agents behave as on the Mac.
• Feels like an app: add it to your Home Screen; tabs slide in and out, swipe back to the list, and a banner says when another agent needs you.
• Private by design: it runs over your own Tailscale network, nothing goes through a server of ours, and Funnel is never turned on. Each phone pairs once with a QR code or a one-time code, and only devices on your own Tailscale account can connect.
• Setting it up: the Phone window walks through each Tailscale step with one button per step. A small phone in the corner of the terminal shows whether phone access is live.

A code editor that follows the agent

Each tab has its own VS Code–style editor (Monaco, ⌃⌘E) on that tab's folder, in your terminal theme.

• Follow mode: the editor opens each file the agent reads and animates its edits in as they happen. It follows even while closed, so opening it mid-task shows where the agent is right away.
• Agent panel: a timeline of the session: prompts, thinking, messages, tool calls and results, sub-agents included. With several sub-agents, the editor splits into a pane for each.
• AI POV: replay a session as if you were at the agent's keyboard: files opening, code being typed, commands running.

Code map

Your project as a star map. Folders are tinted by what they are: frontend, API, database, tests, config. Files light up as the agent reads (cyan) and edits (orange) them.

• Zoom levels: Overview shows the project's areas and how much the agent did in each. Files shows every file. Symbols shows the functions and classes inside, with the ones changed this turn lit.
• Details for anything you click: what the agent did there, this turn's diff, the file's symbols, what imports it, and the backend pieces it uses.
• Blast radius: what imports the file is drawn on the map, with a warning when no test covers the change.

Project memory

⌃⌘Y shows what Claude Code and Codex remember about the current project, in one window.

• Claude Code's notes can be read, edited and deleted. Deleting one removes it from MEMORY.md too.
• Codex's memories for the project are shown read-only, because Codex rewrites them itself.
• Instruction files (CLAUDE.md, CLAUDE.local.md, AGENTS.md) that the agents load every session can be edited in place. It never overwrites a file an agent changed while you were editing.

Shared between agents

A new Codex session starts with what Claude Code has learned about the project, and a new Claude Code session with what Codex has learned, labelled as notes that may be out of date. Above, a fresh Codex session answers "how do I deploy and test this project?" from Claude's notes without opening a file. Nothing leaves your Mac, and you can turn it off in Settings.

Hand off

Pass a pane's work to another Claude Code or Codex session: a new one in a split beside it, or one that's already running.

• What it carries: the task, the recent conversation, exactly what the first agent changed (a diff since its first prompt), failed commands, and what the first agent remembers about the project. You can read and edit the message first.
• What to do: Continue picks up where the last agent stopped, Review checks the work without editing anything, and Second opinion weighs in on the approach.
• Failed commands can go straight to the agent already working on the project.

Review loops

Pair an agent with a reviewer (⋮ → Start a review loop…). Each time the writer finishes a turn, the reviewer gets its changes and answers APPROVED or CHANGES NEEDED, and its findings go back to the writer, until it approves or a round limit. Every message waits for your Send unless you turn on Send automatically, and nothing is ever typed into an agent mid-turn or over your own typing.

Review changes

When an agent finishes working in a git repository, its changes land in an inbox (⌃⌘I).

• Read the diff file by file, and approve or undo each file.
• Comment on lines and send the comments back as the agent's next prompt.
• Finish up: commit, or open a pull request.

Undo an agent's turn

Every agent turn starts with a snapshot of your project. Undo last turn (or an earlier one) from the tab's ⋮ menu, or Restore to before this on any of your prompts in the agent timeline. It lists every file it will change and asks first, and your current files are saved too, so the undo can be undone, and the review inbox updates to match. Snapshots are git objects only: no commits, branches or stash entries, and your staged changes stay as they are. Folders that aren't repositories work too.

In a jj repository, the snapshot also remembers jj's own state, so if the agent ran jj commands during the turn, Restore with jj puts jj's history back along with the files.

See your backend

The Backend tab in the code editor's agent panel shows what your project runs on, worked out from its own files (package.json, wrangler.jsonc, supabase/, .vercel/, Prisma, env variable names). It works offline and without logins.

• Architecture: frontend → compute → data → services, with a line only where your code really connects two pieces.
  • Cloudflare Workers show their environments, domains, cron schedules and every binding: D1, Hyperdrive, KV, R2, Queues, Durable Objects, service bindings, Workers AI and more.
  • Supabase, Vercel, Prisma, Firebase, and services like Stripe, OpenAI and Resend, show up too.
• Live status comes from each provider's own CLI (wrangler, supabase, vercel), using the logins you already have and only read-only commands. It shows deploys per environment, project health, migrations not applied yet, and commits newer than the last deploy.
• Code links: click any piece to see every file that uses it, and open the provider's dashboard or your live site.
• Agent awareness: when the agent edits something that belongs to a piece of your backend, that piece lights up.

Database

The Database view draws your schema: tables, columns and relations for Supabase, Cloudflare D1, Postgres behind Hyperdrive (read from your migrations) and Prisma.

• Click a table to see its columns, what references it and where your code queries it.
• Row-level security is checked on every Postgres table.
• Large schemas can be searched, and unrelated tables fade back.

Visual Fix

⌃⌘V previews your running dev server beside the terminal, at desktop, tablet or phone size.

• Pick an element: hover any element and click it, then say what should change.
• What the agent gets: the element's HTML and CSS selector, the component and source file that render it (React, Vue and Svelte), its computed styles, and a screenshot.
• Where it goes: the request goes to the agent working in that project, pinned to the element, and its card shows "Visual fix:" with what you asked for. When the change lands, the preview reloads where you were.

Local models

Chat with a model that runs on your Mac: nothing leaves it, and it works offline.

• Every model you already have: a Local models section in the sidebar lists models from Ollama, LM Studio, a llama.cpp or MLX server, and Apple's on-device model (no download needed on Macs with Apple Intelligence). Click one to open a chat below the one you're in.
• A chat that stays out of the way: replies stream in, a reasoning model shows a one-line "Thinking… 12s", and /think, /clear and /exit do what they say. Closing the chat frees the model's memory right away.
• Find and download: Tools → Local models lists the most popular models on Ollama in five sizes, Tiny to Huge, opens on the size that suits your Mac and marks the ones too big for it. A Hugging Face section adds the most downloaded models Ollama can run.
• From a terminal: tellurion local <model>.

Abliterated models on Venice, with Codex's tools. Connect a Venice account with an API key in Tools → Local models, and its models are a click away, read live from Venice: filter to Uncensored or Private, and see each one's privacy tier, context, price and whether it can call tools. Open in Codex runs Codex on that model with your own setup: config, AGENTS.md, skills, MCP servers, hooks and sessions all stay as they are, and its sandbox and approvals still apply, since commands run on your Mac. Chat opens a plain chat. On a board, a Venice model is an account in Accounts, so its tiles stay on it through restarts. It's billed to your Venice account, not your ChatGPT plan. From a terminal, while Tellurion is running: tellurion venice codex [options] and tellurion local --provider venice <model>.

What's different from a model on your Mac: your prompts, and what an agent reads while it works (your code, and the output of its commands), go to Venice's servers. For models marked Private, Venice and its partners say nothing is stored, which can't be verified from here. Models marked Anonymized hide who you are, but their own provider sees what's sent and may store it, and Tellurion warns each time you pick one. Compared with Codex on its own models: Venice serves other models through a translation layer that drops reasoning between turns, so they think again each turn, and its web search only works on some of them.

Localhost sessions

When an agent starts a dev server (npm run dev, vite, rails s, make dev, …), an SSH tunnel, kubectl port-forward, ngrok or cloudflared, it opens in its own tab instead, so it keeps running after the agent is done. The agent is told the URL and how to read the logs.

• Sidebar cards: each server gets a card with live status, its localhost URL, framework, uptime, restart and stop.
• The Localhost manager (⌃⌘L) groups servers by project and shows their CPU and memory. It previews pages in a built-in browser and finds dev servers running elsewhere on your Mac, with Keep alive to move one into its own tab.
• Start one yourself from New → Localhost Server…, which offers your package.json scripts.

Ports

The sidebar lists what's listening, which project it belongs to (Next.js, Vite, Django and more get their own badge) and what started it. Open it in the browser or Visual Fix, jump to its tab, or stop it. When a command fails because its port is taken ("EADDRINUSE", "address already in use"), the sidebar names what holds the port and offers to stop it.

Git panel

Click a tab's branch for a panel with its pull request (title, review state and every check, failing ones first, each linked to its log), branches (switch, filter, create), stashes (stash, apply, pop, drop) and recent commits. Tabs show commits to push and pull (↑2 ↓1) and the pull request's number and checks beside the branch. Pull requests come from the GitHub CLI (gh) when it's installed and signed in.

The panel also speaks the tools people use instead of plain branches:

• jj (Jujutsu): the change you're on (or its nearest bookmark) shows in the sidebar, and the panel shows the working-copy change with Describe, Commit, New change and Squash, the changes around it (edit one, start a new change on top, abandon), bookmarks with Fetch and Push, and the operation log, where Undo last or Restore reverses any jj command, an agent's included. Works with or without a git repository beside it.
• GitButler: the sidebar names the branches it has applied instead of gitbutler/workspace, and the panel shows them side by side with their commits, push state and pull requests, plus GitButler's own Commit (to the branch you pick), New branch, Push and Undo.
• Graphite: in a repository set up with gt init, the panel shows the stack your branch is in, trunk to top, with each pull request and a "needs restack" marker. Restack, Submit and Sync run gt in a new tab.

Isolated sessions

+ New → Isolated Session (Docker) opens Ubuntu 24.04, Python 3.13, Node 22, or a sandboxed Claude Code or Codex in a throwaway container. Only the tab's folder is mounted, at /workspace; your home folder is not, and the container is deleted when you exit. Sandboxed agents keep their own login in a Docker volume, so your Mac's credentials are never shared. Needs Docker Desktop, OrbStack or Colima; if Docker isn't running and Colima is installed, it starts Colima and stops it again afterwards.

Agent races

⌃⌘R gives the same task to several agents at once (Claude Code and Codex, or several of one), each in its own git worktree so they can't touch each other's work or yours. Compare their diffs side by side and apply the one you want.

Background processes

⌃⌘K finds everything left running: dev servers, Colima VMs and containers, agent sessions, browser automation, databases, watchers, log followers and login services.

• Last really used: the last typing or output in its terminal, its agent transcript being written, a live connection to its port, or a busy container.
• A staleness rating (Active, Idle, Stale or Ready to close), with the reasons.
• Cleanup in one click, always with a confirmation first. Login services are never marked ready to close.

Command history

Every command becomes a block with its output, exit code and duration (⌃⌘B). When one fails, a chip offers Fix with Claude or Fix with Codex, or sends it to the agent already working on the project, with the command and its output.

Agent activity

⌃⌘A shows active time, prompts, files and lines changed, commands, test runs and tokens, per day, hour, agent and project. It reads the session history Claude Code and Codex already keep. Resume any recent session in a new tab, and API value shows what your usage would cost at API prices.

Environment

⌃⌘N (or Environment in the command palette) shows what's around your agents:

• This Folder: the tool versions the folder asks for (mise, asdf, .nvmrc, .python-version and friends), which aren't installed, when the terminal's own copy differs, and the environment variables mise and direnv add. Only their names are shown; values are never read. Install missing versions, trust a mise config, and allow or block an .envrc after seeing what it runs.
• Containers: everything Docker runs (Docker Desktop, OrbStack or Colima), grouped by Compose project, with CPU, memory and published ports, and Start, Stop, Restart, Logs, a shell inside, and Remove.
• Local Models: the models in Ollama and LM Studio, which are loaded and how much memory and GPU they take, with Unload, Run, Pull and Remove.

Skills

⌃⌘U shows every skill your agents have in one place: Claude Code, Codex, Cursor, Hermes, the shared ~/.agents/skills folder, Claude Code plugins, Claude.ai's synced skills and the current project's own.

• Updates: skills installed with npx skills or cloned with git are checked against their source, with Update on each and Update All.
• Discover: what's trending, hot and most installed on skills.sh, with search, install counts and security reviews. Official company skills can be hidden.
• Install for the agents you pick, in every project or just this one. It shows the exact command and runs it in a new tab.

Setup, settings and updates

• Welcome window: on first launch it finds Claude Code, Codex and the tools the hooks need, connects your agents in one click (backing up each file it changes), lets you pick features, and runs a live test.
• Check Setup (Tellurion menu or ⌘P) checks the hooks, each agent's config, jq, the shell integration and notifications, with a fix button on each problem, and offers Connect for Copilot CLI, Droid, Gemini CLI, Antigravity, Kiro, Cursor CLI and OpenCode when it finds them. tellurion doctor runs the same checks in a terminal.
• Settings (⌘,) turns each feature on or off. A feature that's off has no menu item, shortcut, button or palette entry, and does no background work.
• Every shortcut: hold ⌃⌘ for a moment to see them all over the window.
• Menu bar: a Tellurion item shows a count when agents need you, in either edition, and lists every agent (waiting ones first), your boards, New Sketch, Launch Agents and New Board. Turn it off in Settings.
• Updates appear as a card at the top of the sidebar, checked shortly after launch and every hour. They're signed with this project's key (nothing else is accepted), and after the update your windows, tabs, splits, agent sessions and localhost servers come back.

Layout

Tools → Layout shows your window as boxes: the tabs, the terminal, the code editor, Visual Fix and command history. Drag a box to a new spot and the others slide aside; let go and every window rearranges. Start from Classic, Editor first, Tabs on the right or Mirrored; Reset goes back to Classic.

Design

Tellurion ships in ink and bronze around whatever terminal colors you already use. Design (Tools → Design, or "Design…" in the command palette) changes that, live.

• Twenty templates, each a vibe: Catppuccin Mocha and Latte, Dracula, Nord, Gruvbox dark and light, Tokyo Night, Rosé Pine and Dawn, Kanagawa, Everforest, Solarized, Synthwave, Matrix, Cyberpunk, Monokai Pro, GitHub Dark, Oxocarbon and Flexoki. Click one and the terminal's colors, the sidebar and panels, the window and the cursor change at once.
• Customize: keep your own terminal colors, pick any of Ghostty's built-in themes (with search), or set the background, text, cursor, selection and sixteen ANSI colors by hand. The chrome around the terminal follows those colors on its own, with an accent and an AI color of your choosing, or every chrome color set one by one. Then the font and size, the window's opacity, blur and padding, and the cursor's shape and blink.
• Draw your own logo: a 32×32 pixel editor with mirror painting, undo and starting shapes. Pixels are color roles, so the logo recolors with the design. It replaces the T in the new-tab splash and the tool windows, and can be the Dock icon while Tellurion runs.
• Save it under Templates → Yours. Reset returns to Tellurion as shipped.
• Your Ghostty config stays yours. The terminal's part of a design goes into tellurion-design.ghostty beside it, included by one config-file line; delete that line to stop using it.

Everything Ghostty already does

GPU-accelerated rendering, native tabs and splits, the quick terminal, hundreds of themes, ligatures, shell integration, AppleScript and Shortcuts. Your Ghostty config works as-is.

Light on your Mac

All of the sidebar's animations run in Core Animation, so the app does almost no work per frame. Anything you can't see pauses: background tabs, hidden and minimized windows. With six agents working at once, Tellurion uses about 1–3% CPU (measured on an Apple silicon MacBook).

Security and privacy

• Nothing leaves your Mac unless you ask. There's no account of ours, telemetry or server. What goes elsewhere is what you send to a cloud provider yourself: your agents' own sign-ins and, once you've connected a Venice account and opened a model, those chats and Codex sessions. Agent tracking and shared memory read the files Claude Code and Codex already write.
• Your Venice key stays in the keychain. It isn't in any terminal's environment, command line or file. Agents and chats reach Venice through a small server inside the app, on 127.0.0.1 with a token made each launch, which only passes on model requests and the model list. It leaves out the folder paths and install id Codex attaches to each request's metadata; the working folder Codex tells its model about is still part of the prompt. A program running as you could read that token and use your account while Tellurion runs, but it can't learn the key or reach anything else the key can do. Disconnect removes the key and stops the server.
• Only your own hooks can talk to it. Agent status arrives as terminal escape sequences, which any printed text could imitate. Each launch creates a secret that only its own terminals and hooks know, and events without it are ignored.
• The Backend view never stores credentials. It runs your providers' own CLIs with their existing logins, read-only commands only. It reads only the names of your env variables, never their values, and so does the Environment window.
• Agent hooks only observe. They report status and never approve, block or change what an agent does. Any agent settings file is backed up before it's changed.
• The editor stays local. It can only show its own pages, and Visual Fix only talks to your local dev server.

How it compares

Tellurion is for watching and steering the CLI agents you already use. If you want a terminal or editor with its own built-in AI, Warp or Zed may suit you better.

Where others are ahead: Warp and Zed run on Linux and Windows and come with their own AI. cmux has SSH workspaces and a browser your agents can control, and its sidebar also shows PR status and listening ports. Ghostty is the lean original that all of this is built on. Tellurion is macOS-only, Apple silicon only, and maintained by one person.

_{Compared from each project's public docs on October 7, 2026. Corrections welcome.}

Install

Apple silicon Macs, macOS 13 or newer. In Terminal:

curl -fsSL https://raw.githubusercontent.com/steventsvik/Tellurion/custom/install.sh | bash

It downloads the latest release, checks it against the release's SHA-256 checksums and puts Tellurion.app in /Applications. Then it opens: the welcome window connects Claude Code and Codex in one click and runs a live test.

Updates arrive in the app: Tellurion checks for new releases and installs them when you say so (Tellurion → Check for Updates…). They're signed, and the app only accepts updates signed by this project.

Your existing Ghostty configuration works as-is.

Keyboard shortcuts

Hold ⌃⌘ for a moment to see them all over the window.

On a board:

Agent status setup

./agent-hooks/install.sh

[[ -n "$GHOSTTY_EXTREME_AGENT_EVENTS" ]] && source ~/.ghostty-extreme/agent-hooks/ghostty-extreme.zsh

{ "type": "command", "command": "~/.ghostty-extreme/agent-hooks/agent-hook.sh claude stop" }

Build from source

git clone https://github.com/steventsvik/Tellurion.git
cd Tellurion
/opt/homebrew/opt/zig/bin/zig build -Doptimize=ReleaseFast -Dxcframework-target=native
ditto macos/build/ReleaseLocal/Ghostty.app /Applications/Tellurion.app

License

AGPL-3.0, see LICENSE. Ghostty's own code is MIT (LICENSE-GHOSTTY). Parts of the sidebar are derived from Warp (AGPL-3.0). Full credits and trademark notes are in NOTICE.md.

For Ghostty itself (configuration, themes, keybindings), see the Ghostty documentation.