Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Agentic IDE: thread layout
The Agentic IDE has two layouts, switched with the rounded switch in the middle of the window caption:
- Terminal grid — workspaces of terminal panes, each running a coding CLI.
- Threads — one conversation with a coding agent at a time.
Switching never stops anything: the grid stays mounted behind the thread view, so its terminals keep running and come back exactly as they were.
What a thread is
A thread is an agent-chat session on the IDE's own surface (agent). The
coding CLI — Claude Code, Codex, OpenCode, Grok Build, Antigravity, … — is
driven through its own binary (dodaios/agent_chat/runner_cli.py), so its
tools, skills, MCP servers, permissions and subscription login are the CLI's,
and the conversation is the CLI's own session (resumed with its own id). No
second harness sits in between.
A thread belongs to a project: the one it was started in, else the deepest connected project folder that holds the thread's folder.
Sidebar
On top, three start rows: New thread, New team thread (both in the project in
view, else the first one) and Dodaios Live. Below, "Pinned" and "Projects"
(its folder icon connects another folder), each project with its threads,
newest first. A thread is named by the title its
CLI gave the conversation (Claude Code's session title, Codex's thread name —
cli_title on GET /api/agent-chat/sessions?surface=agent), until the person
renames it; before the CLI names it, the first message is the name. The row
starts with the CLI's logo; its end shows how long ago it last moved, a spinner
while it works, an amber dot while it waits for an approval and a blue dot for
news since it was last opened.
Thread view
- New thread: the top row, or the pen on a hovered project row. The empty thread asks what to build in the project; the project name is a picker.
- Title bar: an open thread has the same controls as a grid pane's header: review the changes in the thread's folder, show them in the Git tab, more actions (rename, new thread, archive), fold the app sidebar to its rail for more room, a new thread in the project, and close — which moves the thread to the archive (not while it works or waits for an approval).
- Conversation: the person's messages on the right, the agent's answer as reading text, the work in between as folded rows ("Ran 3 commands, read 2 files") that open to each call, its diff or its output. A running turn ends in a live "Working for 12s" line; a finished one says how long it worked and which files it changed. When the agent has written its message but still waits for background tasks it started (a test run, a push), the line says so instead: "Waiting for 2 background tasks · 21m 40s", with the tasks named. The agent picks up again when they finish.
- Composer: one toolbar — coding agent and model, reasoning effort, access
mode — beside the paperclip and the send button. A new thread starts on the
agent, model, effort and access the person picked last (else the newest
thread's). Files and images go in by drop, paste or paperclip;
/@$open the typeahead where the CLI offers it. An approval or a question the agent waits on opens at the top of the composer. A message sent while the agent works is queued; after Stop the queue waits. - Under the composer: a strip that says where the agent works — the current checkout or a fresh git worktree for a new thread — and on which branch (the base of the worktree, or the branch to switch the checkout to).
- Caption buttons: at the right end of the window caption, beside the window buttons. In threads there are two: the terminal drawer, then the side panel. The grid has only the side panel button, since its panes are terminals already. A shut side panel leaves no rail on the window edge. Its button gets an amber dot while an agent of the active workspace waits for the person.
- Terminal drawer: plain shells under the conversation, in the open thread's folder, one tab each. The first press starts the folder's first shell, the next one hides the drawer without ending anything, and the top edge drags to resize. Threads that share a folder share its shells, and they keep running while the person moves between threads or back to the grid. Closing a tab ends that shell, and the drawer goes down with the folder's last one.
- Changes, files, git and more terminals live in the IDE's side panel, as in the grid layout.
Questions, approvals and plans
Every coding agent gets the same cards at the top of the composer
(dodaios/agent_chat/turn_prompts.py):
| Moment | Claude Code, GLM | Every other CLI (Codex, Antigravity, Grok Build, OpenCode, Kimi, Cursor, DeepSeek Harness) |
|---|---|---|
| The agent has a question | Its own AskUserQuestion opens the question card mid-turn; the answers go back on the control protocol and it keeps working |
It ends its reply with a jarvis-ask block (the protocol rides in front of every prompt); the card opens when the turn ends and the answers are the next message |
| The plan is ready | ExitPlanMode opens a plan card with the plan itself; Build it switches the thread to the runner's build mode and the same turn starts building |
A turn that finished in plan mode opens a plan card; Build it switches the thread to the runner's build mode and sends the go-ahead |
| A tool needs permission | The approval card (Approve, Always allow, Decline) | The CLI cannot ask from a headless run: the access mode decides, as each mode's description says |
The question card offers the agent's options (its recommendation first), a typed answer, and Skip, which leaves the open questions to the agent's recommendations. Keep planning closes a plan card so the person can type what to change. A card nobody answered closes when the person sends another message instead. Cards are rebuilt from the session's event log, so they survive reopening the thread and restarting the app.
Threads a Dodaios agent starts
A Dodaios agent can start a thread too ("let Opus 5.5 build this in the website project"). It picks the coding agent, model and folder the person named — looking into the folder first when it needs context — and writes the brief itself. The thread then appears under its project like any other; the agent's messages carry its name above the bubble, so the person sees exactly what it asked and what came back, and can step in at any time.
The agent's own chat shows a line that opens the thread. When a turn the agent started finishes, asks a question, presents a plan or waits for an approval, the agent is woken with the result: it checks the work, answers the question or plan card, sends a follow-up, and tells the person the outcome. A thread an agent opens runs with full access (bypass permissions), so it does not stop for approvals; the person can lower that in the composer. A turn the person types into the thread is theirs and wakes no agent. After 25 automatic updates for one thread the agent stops following it until the person writes in the agent's chat again.
Team threads
The people icon on a project row gives one task to several coding agents on
different models. They plan alone, challenge each other, agree on one plan,
and one builds while the others review, all in one shared thread:
agentic-ide-team-threads.md.
Restarts do not stop a thread
A thread's coding CLI does not run as a child of the app. It runs in the
turn host (dodaios/agent_chat/turn_host.py), a small background process
that the app starts on first use and talks to over a loopback socket. The
terminal grid keeps its agents in the PTY host the same way. The host keeps
every line the CLI prints and streams them to the app.
- Restart, update, crash: the CLI keeps working. The next app start attaches again. It feeds the lines the old app already handled back into the translator without showing them twice, then carries the turn on live: new output, approval cards, the real ending.
- Quit: the turn stays open while the CLI works. A turn that ends while no app is attached is written to a spool folder, and the next start shows its answer.
- Stop ends the CLI as before.
- Another app process takes over (a second start of the same instance): the old process hands its turns over without ending them.
Right after the app starts, it attaches to the host on its own, before any window opens a chat, so a waiting approval shows up without delay.
Only thread turns run there. A turn running as Dodaios, a goal turn and a
helper turn without tools need state inside the app and stay its children.
An installed (frozen) build starts the host by running its own executable
with --turn-host, since it has no python -m. Processes that are not the
desktop app or the web launcher, such as tests and scripts, never start or
attach to the host. Logs: logs/turn_host.log in the Dodaios data folder.
Platforms
Nothing in the thread layout is OS-specific: paths are compared
case-insensitively only for Windows drive paths, the terminal drawer opens the
platform's default shell, and the git calls run the same git everywhere. The
layout choice, the last agent pick and the drawer's height are kept in the
browser's storage and fall back to defaults when storage is blocked. Drawer
shells are never kept: a reload does not restart them.