Skip to content

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.

9.3 KB
Raw Blame

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.