# 1DevTool — full published content > 111 articles. Source: https://1devtool.com --- ## Let an AI Agent Drive the Browser You're Already Using Source: https://1devtool.com/blog/agents-drive-your-real-browser Published: 2026-07-22 Tags: browser-automation, mcp, ai-agents, browser-panel, testing Agent browser automation usually means a second, empty browser that hits your login wall on step one. In 1DevTool v1.51.0, an agent connected through MCP drives the Browser panel already docked in your workspace — your tabs, your session, watched live. You ask the agent to check the checkout flow. It spins up a browser — a fresh, empty one — and hits the login wall on step one. No cookies, no session, none of the state you've had loaded all morning. So you do the thing everyone does: paste a test account into the prompt, or give up and click through the flow yourself while the agent waits. The problem was never that agents can't drive a browser. It's that they drive *a different browser* — one you can't see, that knows nothing about your session, and whose actions you find out about only when it reports back. ## What changed An agent connected through 1DevTool MCP can now operate the Browser panel that's already docked in your workspace. Same tabs. Same navigation history. Same signed-in sessions. You watch the page move while the agent works, because it's the browser sitting right there in front of you. ![AI terminal calling the browser_wait MCP tool while the 1DevTool Browser panel shows the checkout page the agent is driving](/app-screenshots/1devtool-1.51.0-live-browser-automation.jpg) ## How it works in practice ### Point the agent at the browser you can see Mention **1devtool** or **onedevtool** browser MCP in your prompt and the request routes to the Browser panel instead of an external Chrome session. Describe the task the way you'd describe it to a person — which page, what to fill in, what to click, what counts as done. ![Agent Input prompt telling the agent to use the onedevtool browser MCP tools inside the 1DevTool Browser panel](/app-screenshots/1devtool-1.51.0-browser-mcp-direct-routing.jpg) Under that one sentence sit sixteen tools. The agent can `browser_open_tab`, `browser_list_tabs`, and `browser_select_tab`; move with `browser_navigate`, `browser_go_back`, `browser_go_forward`, and `browser_reload`; act with `browser_click`, `browser_type`, `browser_select_option`, and `browser_press_key`; and read with `browser_snapshot`, `browser_get_console_logs`, and `browser_take_screenshot`. When a page needs a moment, `browser_wait` blocks on a condition — text appearing, text disappearing, a load state — instead of on a guessed sleep. ### Let it read the page, not guess at it `browser_snapshot` returns the page's accessibility structure with a reference for each interactive element, so the agent clicks the button it actually identified rather than coordinates it hoped were right. After navigation, page references refresh, so a stale handle from the previous page can't silently target the wrong control. When structure isn't enough — a rendering bug, a layout question, a chart — `browser_take_screenshot` captures the current tab exactly as you see it, and `browser_get_console_logs` pulls the errors the page logged while the agent worked. ### Keep it scoped, and keep passwords out Every call is scoped to an explicit project and tab, so an agent working on one project can't wander into another project's tab. Typing into password fields is blocked by policy, file inputs are protected, and sensitive values in a page snapshot come back as `«redacted»` rather than plaintext. ### Read back what it did Terminal badges show the last few calls and then clear. For everything else, **Settings → MCP → Activity** keeps a searchable history of recent calls — tool name, status, duration, project, terminal, error — and it survives app restarts. ![Settings MCP Activity tab listing recent browser tool calls with status, duration, project, and terminal](/app-screenshots/1devtool-1.51.0-mcp-activity-history.jpg) Filter to just the errors when something failed, or expand a call to read its input and a truncated preview of what came back. Large results are shortened and sensitive values redacted before they reach the interface, so the log stays readable — the agent still receives the complete result. ![An expanded MCP activity entry showing the tool input and a truncated output preview for a browser snapshot](/app-screenshots/1devtool-1.51.0-mcp-activity-details.jpg) ## Before vs after | | Before v1.51.0 | With v1.51.0 | |---|---|---| | Which browser the agent uses | A separate headless or external Chrome session | The Browser panel already open in your workspace | | Logged-in state | Fresh profile — log in again, or hand over credentials | Your existing session, already signed in | | Watching it work | Read the transcript afterwards | Watch the page move in real time | | Finding an element | Coordinates or selector guessing | Accessibility snapshot with a reference per element | | Waiting for a page | Fixed sleeps | `browser_wait` on text appearing, disappearing, or a load state | | Reviewing a run later | Badges that disappear | Searchable activity history that survives restarts | ## Who benefits most **Anyone testing a flow behind a login.** Checkout, dashboard, admin panel — the agent inherits the session you already have, so there's nothing to re-authenticate. **Frontend developers debugging in place.** The agent reads console output and takes a real screenshot of your dev server, in the browser panel that's been next to your editor the whole time. **People who don't fully trust agent automation yet.** Watching it click, with a per-call log you can read afterwards, is a much easier way to build that trust than reading a summary of what it claims it did. ## Also in this release **Machine Terminals.** The Add Terminal dialog now has a Machine Terminal tab listing the terminal apps installed on your machine — Ghostty, iTerm, Terminal — and opens your pick already in the selected project's folder. ![Add Terminal dialog on the Machine Terminal tab showing Ghostty, iTerm, and Terminal discovered on the machine](/app-screenshots/1devtool-1.51.0-machine-terminals.jpg) **Antigravity session resume.** Antigravity conversations now appear in Resume AI Sessions with their workspace, title, recent messages, and activity time, and continue in a new Antigravity terminal. **Renamed conversations stick.** Renaming a terminal tab updates the coding agent's own session title, so the name follows the conversation when you reopen or resume it. ## Try it Update to v1.51.0, open the Browser panel on the page you care about, and ask an agent to work in it — just say **1devtool browser mcp** in the prompt. Then open Settings → MCP → Activity and watch the calls land. The browser the agent drives is the one you're already looking at. --- ## Stop retyping the same instructions to your AI agents Source: https://1devtool.com/blog/stop-retyping-agent-instructions Published: 2026-07-20 Tags: prompt-templates, ai-agents, agent-input, productivity 1DevTool 1.50 adds Prompt Templates — a reusable library of AI instructions you write once and append or insert into any terminal, so you stop retyping the same guardrails every session. Every time you start a fresh AI terminal, you type the same instructions again. "Find the root cause before you fix it." "Run the related tests when you're done." "Keep the diff small." They aren't part of the task — they're the guardrails you want on *every* task. So you retype them, or you keep a scratch note open and paste them in, or you just forget and get an answer that skipped the step you cared about. The instructions never change. Only the task does. Retyping the constant part, session after session, is pure friction. ## What changed 1DevTool 1.50 adds **Prompt Templates** — a small library of reusable instructions you write once and then reuse across your AI terminals without retyping. You build the library in Settings, decide which templates apply to a given terminal, and either let them attach automatically when you send or drop one in at the cursor with an `@` mention. The editor text you type stays yours; the template is the part you stop repeating. ![Settings AI tab showing the Prompt Templates library with a New prompt template field and a table of saved templates marked Available or Hidden](/app-screenshots/01-prompt-template-library.jpg) ## How it works in practice ### Build the library once Open **Settings → AI → Prompt Templates**. Type an instruction into the **New prompt template** field — "Analyze the root cause before fixing", "After fixing, run the related tests" — and press `⌘↵` or click **Add template**. Each one lands in your library with a status you control: **Available** templates are ready to use, **Hidden** ones stay in the list but out of the way. A counter at the top keeps score — "5 templates · 3 available" — and you can edit or delete any row from the same page. These are, in the app's own words, "reusable sentences appended to your message the moment it's sent — the editor text itself is never modified." You're building a set of standing instructions, not snippets you paste and clean up. ### Turn them on per terminal A template library is only useful if the right instructions ride along with the right work. So templates are enabled **per terminal**: from the Agent Input overlay, each AI terminal picks which of your available templates are active. Enable "run the tests after" on the terminal where you're fixing a bug; leave it off on the one where you're just exploring. When you hit **Send**, the active templates are appended to your message automatically — you write only the task, and the guardrails come along for free. ### Drop one in on the fly Sometimes you want a template for just this one message, not every message. Type `@` in Agent Input and the mention menu opens with a **Templates** tab right next to **Files** and **Agents**. Pick a template and its text is inserted directly at the cursor — `↑↓` to navigate, `↵` to insert, `Tab` to switch tabs. It's the same library, reachable the moment you need it without opening Settings. ![Agent Input @ menu open on the Templates tab, inserting a saved prompt template at the cursor in an AI terminal](/app-screenshots/02-insert-prompt-template-with-at-mention.jpg) ### Curate as you go Your first few templates won't be your final ones. As you learn which instructions actually change an agent's behavior, add the good ones, edit the wording, hide the ones you're testing, and delete the rest — all from the one settings page. The library grows into the set of standing rules you'd otherwise have to remember to type. ## Before and after | | Before 1.50 | With 1.50 | | --- | --- | --- | | Standing instructions | Retyped or pasted every session | Written once, stored in a library | | Applying them | Manual, easy to forget | Enabled per terminal, appended on send | | One-off use | Dig through notes, copy, paste | Type `@`, pick from the Templates tab | | Keeping them tidy | Scattered across notes and docs | Add, edit, hide, or delete in one place | ## Who benefits most **Anyone who runs the same review discipline on every task** — root-cause-first, tests-after, small-diffs — gets those rules attached automatically instead of relying on memory. **People juggling several AI terminals at once** can give each one a different standing brief: strict on the bug-fix terminal, loose on the exploration one. And **teams standardizing how they prompt agents** get a shared vocabulary of instructions that's one click to apply rather than a wiki page nobody opens. ## Try it Update to 1DevTool 1.50, open **Settings → AI → Prompt Templates**, and add the two or three instructions you already type most. Enable them on your next AI terminal, or reach for them mid-message with `@`. The task is the only part you should have to write twice. --- ## Put a Team of Agents on One Job Source: https://1devtool.com/blog/put-a-team-of-agents-on-it Published: 2026-07-19 Tags: agent teams, orchestration, ai agents, swarms Start a Team of agents that share a workspace, or a Swarm of headless workers, and coordinate all of them from one live Orchestrations view — instead of babysitting a wall of terminals. The moment a task gets big enough, you stop handing it to one AI agent and start splitting it up. One agent takes the migration, another writes the tests, a third updates the docs. So you open a terminal for each, paste a prompt into each, and hit go. Then the babysitting starts. You alt-tab between terminals to see who is still thinking and who has finished. You lose track of which agent was supposed to hand its output to which. When one stalls waiting on a decision, you do not notice until you happen to click back into its tab. And when you need your laptop's fans to stop screaming, you kill the terminals one at a time and hope you did not cut off the one that was almost done. Running several agents at once has always been possible in 1DevTool. Running them as a *group* — with one place to watch them, pause them, and see them talk to each other — has not. Until now. ## What changed 1DevTool 1.49 introduces **Agent Teams and Agent Swarms**: you put multiple AI agents on a single job and coordinate all of them from the Orchestration Dashboard, which now opens on a new **Orchestrations** view of every active team and swarm. Instead of a wall of terminals you have to poll one by one, you get one place that shows every agent working the problem — their status, their handoffs, and the controls to steer the whole pool at once. ![The Agent Orchestration dashboard on its Runs tab, every delegated agent run listed with status, agent, duration, output size, and exit code](/app-screenshots/02-agent-teams-orchestration-runs.jpg) ## How it works in practice There are two shapes a group of agents can take, and 1DevTool treats them as separate choices so you pick the one that fits the work. ### Start a Team that shares a workspace A **Team** is a set of agents working in real terminals that share one workspace. Ask an agent to work in Team mode and it brings up teammates alongside itself — each in its own terminal, all pointed at the same project. A small **Agent orchestration · Team** badge marks the terminals that belong to the team, so even in a busy workspace you can tell the coordinated agents apart from the one-off ones. ![A 1DevTool terminal running in Team mode, its header showing an "Agent orchestration · Team 1/1" badge](/app-screenshots/01-agent-teams-team-badge.jpg) Because the team shares a workspace, the agents see the same files and build on each other's work — one lays down a module, the next writes against it, without you copying anything between windows. ### Or a Swarm of headless workers When you do not need to watch every keystroke, start a **Swarm** instead. A swarm runs headless workers — no visible terminal per agent — kicked off from the `1devtool-agent` CLI. It is the right shape for fan-out work: run the same task across many inputs, or throw a pool of workers at a backlog and let them grind while you do something else. The Orchestrations view labels each run `Swarm · headless`, so you always know which runs have a workspace to open and which are running in the background. ### Watch everything from one view Whichever shape you choose, the Orchestration Dashboard is where you see it. The **Orchestrations** tab lists every active team and swarm as a row with a live status badge — `active`, `queued`, `done`, `failed`, or `paused` — so a glance tells you whether the group is still working or waiting on you. The **Runs** tab keeps the delegation history: every handoff to every agent, with its duration, output size, and exit code, so a failed or timed-out run is right there instead of buried in a terminal you closed. For a closer look, open a run to follow that agent's exact prompt, its `1devtool-agent` command, and its full output. ![A delegation run's detail panel showing the 1devtool-agent command, timing, exit code, and the run's full prompt and output](/app-screenshots/03-agent-teams-run-detail.jpg) ### See the agents hand work off The part that used to be invisible is now a rail. A **Team activity** feed shows the messages passing between teammates — *this agent to that agent* — as they hand work off and coordinate. When the tester finishes and pings the agent that owns the fix, you see it. When a worker is blocked waiting on another's output, the rail shows why the job is not moving instead of leaving you to guess. ### Stay in control of the pool Steering the group does not mean touching each agent. From the Orchestrations view you can: - **Pause or resume the whole pool** with one button — slow things down or free up your machine without losing the run, then pick it back up where it left off. - **Cancel queued workers while already-running ones finish** — trim the backlog without yanking the rug out from under an agent mid-task. - **Open the Team's shared workspace** to jump straight into the agents' terminals when you do want to get hands-on. And when something misbehaves, the **Logs** tab keeps the raw run files — prompt, output, and stderr for each one — so you can read exactly what an agent saw. ![The Logs tab of the Agent Orchestration dashboard, listing raw run files per agent with a prompt, output, and stderr viewer](/app-screenshots/04-agent-teams-orchestration-logs.jpg) ## Before vs after | Coordinating several agents | Before | With Agent Teams | |---|---|---| | Seeing who is working | Click into each terminal, scroll to the bottom | One row per group with a live status badge | | Watching handoffs | Invisible — you infer it from output | A live Team activity rail of member-to-member messages | | Pausing everything | Kill terminals one by one | One Pause pool button, resume where it left off | | Trimming the backlog | Kill runs and hope you got the right ones | Cancel queued workers, let running ones finish | | Reading a failed run | Hunt through a closed terminal's scrollback | Open the run in the Runs tab, or its raw files in Logs | ## Who benefits most **Anyone running fan-out tasks.** If you already throw one prompt at many files — codemods, per-package upgrades, bulk refactors — a Swarm turns that from a shell loop you supervise into a pool you start and monitor. **Developers orchestrating a multi-step job.** When one agent's output feeds the next, a Team's shared workspace and activity rail let you watch the chain move instead of stitching it together by hand. **Anyone whose laptop has limits.** The Pause pool control means a big run is no longer all-or-nothing: throttle it when you need the CPU back, resume it when you do not. ## Also new: Hermes as a first-class agent 1.49 also adds **Hermes** to the roster of AI agents you can run. Pick Hermes when adding a terminal and 1DevTool treats it exactly like Claude, Codex, or any other agent — it detects your Hermes install automatically on macOS, Linux, and Windows, tracks its usage in the quota pill, and stores its sessions so you can browse and resume them from the Resume Manager. ![The Add Terminal dialog's AI Agents grid with Hermes Agent highlighted, listed alongside Codex, Antigravity, OpenCode, Cline, Claude, and Grok](/app-screenshots/05-hermes-agent-add-terminal.jpg) ## Try it Update to 1DevTool 1.49, ask an agent to run in Team mode — or start a swarm with the `1devtool-agent` CLI — and open the Orchestration Dashboard. The first time you watch five agents work a problem from one board instead of five terminals, going back to alt-tabbing will feel like a step backward. --- ## Read, Schedule, and Prompt Without Leaving 1DevTool Source: https://1devtool.com/blog/read-schedule-and-prompt-in-one-window Published: 2026-07-17 Tags: reader-mode, cron-jobs, terminals, agent-input, productivity 1DevTool 1.48 keeps three things in one window: dock a live terminal beside whatever you're reading, manage system cron jobs from a real panel, and float the Agent Input composer to any size. You know the rhythm of a long working session. You're deep in a design doc or an AI agent's six-thousand-word plan, reading carefully — and then you need to run one command. Check a branch. Kick off a build. Ask the agent a follow-up question. So you leave. You drop out of the clean reading view, hunt for the right terminal, run the thing, and then try to find your place in the document again. The reading and the doing live in different windows, and every switch between them costs you the thread you were holding. The same tax shows up in smaller ways all day. You want a script to run every morning, so you open a terminal, type `crontab -e`, squint at five space-separated fields, and hope you didn't fat-finger the schedule. You're writing a careful prompt to an agent, but the composer is wedged into a narrow terminal pane with barely three lines of room. None of these are hard problems. They're just interruptions — little context switches that quietly add up over a day. ## What changed 1DevTool 1.48 is about staying put. Three separate parts of the app now come to you instead of making you leave: you can dock a live terminal beside whatever you're reading, manage your system cron jobs from a proper panel, and pull the Agent Input composer out into a floating window sized however you like. Read, schedule, and prompt — without switching windows. ![Reader Mode showing a Markdown document with a live Terminals panel docked on the right, listing two AI sessions](/app-screenshots/1.48.0-terminals-inside-reader-mode@2x.jpg) ## How it works in practice ### Run a terminal right beside what you're reading Reader Mode strips a Markdown file down to a clean, book-like page — serif type, a contents outline, a word count and reading-time estimate. It's the best way to actually read a long plan. The catch used to be that reading and running were mutually exclusive: the moment you needed a terminal, you left. Now there's a **Terminals** button in the Reader Mode header. Click it and any of the project's terminals docks to the side of the page — a real, live terminal with full output, scrollback, and Agent Input, not a static snapshot. You can start a command, watch it run, and keep reading without leaving the reading view. Spin up a new terminal straight from the dock, and when you close it your scrollback hands back cleanly so nothing is lost. Because it's the real Agent Input, you can prompt an AI agent while you read, too. Reach a passage in the plan you want to push back on, type your correction into the composer docked on the right, and send it — the document stays open, your place intact. ![Agent Input composer floating over Reader Mode with a prompt typed while a codex terminal runs beside the document](/app-screenshots/1.48.0-reader-mode-prompt-while-reading@2x.jpg) ### Schedule a job without touching the crontab Open the **Runtime tools** menu in the status bar and you'll find a new entry: **Cron Jobs**. ![Runtime tools menu in the status bar with Docker, Ports, Cron Jobs, and Env entries](/app-screenshots/1.48.0-cron-jobs-runtime-menu@2x.jpg) The Cron Jobs manager reads your current user crontab and lays every job out in a table — schedule, command, status, and a per-row Edit and Delete. Adding one is a single **New Job** click away: pick a ready-made schedule (every 5 minutes, hourly, weekdays at 9:00, monthly, at startup) or type your own five-field expression, and 1DevTool spells the timing out in plain English so you can confirm exactly when it will run before you commit. Enable or disable a job without deleting it, and pop the whole manager out to a second monitor when you want it off to the side. ![Cron Jobs manager listing one enabled job, npm run dev running every minute, with Edit and Delete actions](/app-screenshots/1.48.0-cron-jobs-manager@2x.jpg) A **Logs** tab pulls recent runs straight from the macOS unified log, so you can confirm a job actually fired over the last few hours instead of wondering. It's also honest about a detail people trip over: cron mails a job's own output to the local user, so the Logs view shows you *that the job ran* rather than pretending to capture what it printed. ![Cron Jobs Logs tab showing recent cron executions pulled from the macOS unified log over the last six hours](/app-screenshots/1.48.0-cron-jobs-logs@2x.jpg) Cron Jobs works on macOS and Linux, where the system crontab lives. On Windows, 1DevTool points you to Task Scheduler instead of pretending a crontab is there. ### Give your prompt room to breathe The Agent Input composer used to be pinned inside its terminal pane. In 1.48 you can grab its header and drag it anywhere in the workspace, then resize it from any edge or corner until it's the size you actually want to write in. ![Detached Agent Input composer floating over a split view of two AI terminals, resized larger for writing](/app-screenshots/1.48.0-floating-resizable-agent-input@2x.jpg) It also floats on its own when it needs to — if a terminal pane gets too narrow to hold the composer comfortably, it detaches automatically so the editor and its controls stay reachable. The size you settle on is remembered between sessions, and a **Dock** control snaps it back into the terminal pane whenever you want the anchored composer again. ## Before vs after | Task | Before 1.48 | In 1.48 | | --- | --- | --- | | Run a command while reading a doc | Leave Reader Mode, find the terminal, run it, scroll back to find your place | Dock a live terminal beside the page and keep reading | | Prompt an agent about what you're reading | Exit the reading view, switch to the terminal, lose the passage | Type into Agent Input docked next to the document | | Add a scheduled job | `crontab -e`, count five fields, hope the syntax is right | Pick a preset, read the schedule in plain English, click Add | | Confirm a cron job ran | Dig through system logs by hand | Open the Logs tab in the Cron Jobs manager | | Write a long prompt | Squeeze into a three-line pane or go fullscreen | Float and resize the composer to any size you like | ## Who benefits most **Anyone who reads long AI transcripts.** Plans, design docs, and agent output routinely run to thousands of words, and Reader Mode is where you go to actually absorb them. Being able to run a command or fire a follow-up prompt without dropping out of the reading view keeps a two-hour review from turning into two hours of window-switching. **Developers with recurring local tasks.** Backups, sync scripts, nightly builds — the small jobs that belong in cron but never quite make it there because editing a crontab is a chore. The Cron Jobs manager turns it into a panel you'll actually open: presets, plain-English schedules, and a log to prove it ran. **Heavy prompt writers.** If you routinely hand agents long, structured instructions with mentions and attachments, a composer you can size and place yourself beats fighting a cramped pane every time you have something real to say. ## Try it Update to 1DevTool 1.48, and the next time you're deep in a document, look for the **Terminals** button in the Reader Mode header — then never leave the page to run a command again. Read, schedule, and prompt, all without switching windows. [Download the latest 1DevTool](https://1devtool.com/download), or browse the full [changelog](https://1devtool.com/changelog) to see everything in 1.48. --- ## Every Terminal Control in Every Layout — and Grok Gets Your Tools Source: https://1devtool.com/blog/every-control-in-every-layout Published: 2026-07-15 Tags: terminal right, layouts, grok, mcp, release Terminal Right stops costing you the toolbar: copy as Markdown, Reader Mode, pop-out, and a resizable channel list that remembers its width. Plus Grok can now run your database and HTTP tools, and delegated Grok runs open live from their badge. You picked Terminal Right because an AI agent talking back to you reads better in a tall column than in a squat grid pane. The channel list sits on the left, the conversation fills the rest, and it looks like what it actually is — a chat. Then the run finishes and you want to keep it. Copy the whole thing out as Markdown, or open it in Reader Mode because it's four hundred lines long. And the buttons aren't there. They're there in grid. They're there in columns. So you switch layouts, hunt for the terminal again, click the thing, and switch back. Every time. ## What changed Terminal Right is a layout again, not a trade. The active terminal carries the same control row as every other layout, and the divider between the channel list and the terminal is yours to drag. ![Terminal Right layout with the active terminal's control row highlighted and the draggable channel-list divider beside it](/app-screenshots/1devtool-1.40.0-terminal-right-controls.jpg) ## How it works in practice ### The control row follows the active terminal Whatever terminal is active in Terminal Right now has its full header: **Copy output as Markdown**, **Search (Cmd+F)**, **Open in Reader Mode**, **Reformat terminal** for when a resize leaves the buffer in ribbons, sticky notes, **Pop Out to New Window**, focus mode, and close. Eight actions, the same eight you'd get in grid. The one that changes your day is Reader Mode. A long agent run in a terminal is a wall; the same run in Reader Mode is something you can actually read, and now you can get there without leaving the layout you chose for reading in the first place. ### The channel list is yours to size The divider between the channel list and the terminal drags — "Drag to resize · double-click to reset" — anywhere from 160px to 480px. If your terminals are named `refactor-the-auth-middleware` you can give the list room to show it. If you'd rather have the output, squeeze the list down and take the pixels back. The width you settle on is saved to the project, not to the app. Each project keeps the balance that suits its terminal names, and a double-click on the divider snaps back to the 220px default. ### Grok can reach your database and HTTP tools Grok has run as a first-class agent in 1DevTool since 1.35.0, but it couldn't touch your tools — so every schema question ended with you opening the database client, running the query, and pasting rows back into the prompt. New Grok sessions now discover 1DevTool's MCP server and can run it themselves: the database tools (`list_connections`, `describe_schema`, `query`, `preview_table`) and the HTTP client's (`request`, `list_saved_requests`, `run_saved_request`, `list_environments`). Settings → MCP now lists and manages Grok next to Claude Code, Gemini CLI, Codex, and OpenCode, writing to `~/.grok/config.toml` so you don't hand-edit TOML. One detail worth knowing if you're wiring it up yourself: the server key is `onedevtool`, not `1devtool`. Grok prefixes tool names with the server key and rejects the resulting functions when that key starts with a digit — so the shared key is deliberately alphabetic, and the same entry works in Grok and in the clients that import from it. ![Agent quota popover with Grok selected alongside Antigravity, Claude, Codex, and OpenCode, showing Grok's weekly limit at 53 percent](/app-screenshots/1devtool-1.40.0-grok-quota-display.jpg) ### Follow a delegated Grok run from its badge When you hand work to Grok from another agent, the sub-agent badge that appears is now a door. Click it and the delegated run's transcript opens — prompts, responses, reasoning, and each tool call with its result, in order. It reads Grok's own local session file and tails it as the run grows, so you're watching the delegation happen rather than waiting for a verdict. The view shows **● live** while it follows along, and flips to **○ paused** the moment you scroll up, so a fast run can't yank the view out from under you. If a delegation is going sideways, you find out in the first thirty seconds instead of at the end. ## Before vs. after | What you're doing | Before 1.40.0 | With 1.40.0 | |---|---|---| | Copying a run from Terminal Right | Switch layouts, copy, switch back | Copy as Markdown, in place | | Reading a long agent transcript | Leave the layout to reach Reader Mode | Reader Mode from the same header | | Long terminal names | Truncated in a fixed channel list | Drag the divider; width sticks per project | | Asking Grok about your schema | Run the query yourself, paste it in | Grok queries the connection directly | | Checking a delegated Grok run | Find and tail its JSONL by hand | Click the badge, read it live | ## The rest of 1.40.0 The File Explorer remembers which folders you had expanded when you switch projects or worktree roots — including when you switch immediately after expanding one. The Windows fixes are the ones worth calling out. Prompts handed between AI agents no longer corrupt Vietnamese and other Unicode text. AI terminals in full-screen interfaces receive wheel input properly, including while Agent Input is open. And moving your mouse over a Cursor terminal no longer types streams of control characters into the prompt. Open editor tabs also stop lagging behind files that agents change underneath you — background tabs included, without clobbering unsaved work. ## Who benefits most **Anyone who lives in one layout.** If you picked Terminal Right or Chat and quietly accepted the missing toolbar, that tax is gone. **People running Grok on real projects.** Tools plus readable delegation is the difference between an agent you supervise and one you have to relay for. **Windows users.** Unicode delegation, terminal scrolling, and Cursor's mouse handling all got fixed in the same release. ## Try it Switch to Terminal Right from the Layout menu, run an agent, and hit Copy output as Markdown without going anywhere. Then drag the channel divider until the names fit — it'll be there next time you open the project. 1DevTool 1.40.0 is out now. --- ## Turn Your TODO Comments Into a Kanban Board Source: https://1devtool.com/blog/turn-todo-comments-into-a-kanban-board Published: 2026-07-13 Tags: code-tasks, kanban, productivity, task-management Code Tasks now plots the TODO, FIXME, and BUG comments scattered across your project onto a drag-and-drop board — with manual tasks, filters, and one-click handoff to an AI agent. Every codebase has a second, invisible to-do list. It lives in your comments: the `// TODO: handle the empty state`, the `# FIXME: this races on slow networks`, the `// HACK: remove after the migration`. You write them in the moment, fully intending to come back. But they scatter across dozens of files, buried under imports and business logic, and the only way to find them again is to grep — or to stumble into one while debugging something else. So the list grows. A `FIXME` you meant to handle last month is still sitting three functions deep in a file you haven't opened since. There's no single place to see what's outstanding, no way to tell the critical notes from the throwaway ones, and no sense of progress as you clear them. The comments that were supposed to remind you become background noise. ## Your code comments are now a board 1DevTool's **Code Tasks** already scanned your project for tag comments and listed them in one panel. As of v1.39.0, that list is a board. Open Code Tasks and your `TODO`s, `FIXME`s, `BUG`s, and `HACK`s land as cards on a drag-and-drop Kanban board — grouped, filterable, and ready to work through. And you can now add tasks that were never in your code at all, so the board holds your whole plan, not just the parts you happened to annotate. ![Code Tasks board in 1DevTool showing tasks scanned from code comments grouped into BUG, NOTE, TODO, and FIXME columns, each card citing its source file and line number](/app-screenshots/code-tasks-kanban-board.jpg) ## How it works in practice ### The board scans itself Open the Code Tasks dialog, pick a project, and 1DevTool scans it in milliseconds — the header tells you exactly what it found, right down to "7 tasks found · 15 files scanned in 26ms". Every tag comment becomes a card, and the cards arrange themselves into columns. By default they group by tag, so all your `BUG`s sit in one lane and your `NOTE`s in another, but you can regroup by priority, file, author, or source without rescanning. Prefer the old flat list? One click on the view toggle brings it back. Priority and ownership come straight from the comment. A `// FIXME!!: ...` reads as critical, a single `!` as high, and `// REVIEW(alex): ...` hands the task to Alex — so the board reflects the intent you already encoded, with no extra tagging required. ### Add the tasks that were never comments Not every task belongs in the source. The follow-up you thought of in a standup, the doc you need to write, the dependency you keep meaning to bump — none of those start life as a `// TODO`. Click **Add** and create a manual task with a description, tag, priority (Normal, High, Critical), and an optional file, line, and assignee. It sits on the board next to the scanned cards and saves with the project, so it's still there tomorrow. Manual cards are the ones you can drag. Move one to another column and it re-tags or re-prioritizes itself to match — drop a task into the Critical lane and it becomes critical. Scanned cards stay put on purpose, because they mirror your code; try to drag one and 1DevTool quietly reminds you to edit the comment instead. ### Filter down to what matters now A board with a hundred cards is just a prettier pile. Search narrows it as you type — by description, file, or assignee — and the filter popover lets you show only a given priority, or only scanned vs. only manual tasks. Combine them to answer real questions: "show me every critical FIXME I wrote," or "just my manual tasks for this week." ### Do something about it A card isn't a dead end. Select one and you can **Open in Editor** to jump straight to the exact line, **Send to Agent** to hand the tag, file, line, and surrounding code to an AI terminal as a ready-to-run fix prompt, or **Copy as Markdown** to drop it into a GitHub Issue, Linear ticket, or Notion doc. The board is where you find the work; these are how you clear it. ## Before vs. after | Clearing your TODOs | Without Code Tasks | With the board | |---|---|---| | Finding them | `grep -rn "TODO\|FIXME" .` and read the wall of output | Open the panel — every tag comment, already sorted | | Telling them apart | Eyeball which ones look urgent | Priority columns from `!` / `!!`, filter to critical | | Tasks without a comment | Keep a separate scratch file | Add a manual card that saves with the project | | Working through them | Open each file by hand | Open at the line, or send it to an AI agent | | Sharing one | Copy the text, reformat it | Copy as Markdown, paste into your tracker | ## Who gets the most out of it **Solo builders moving fast** leave a trail of `// TODO`s in their wake. Code Tasks finally gives that trail a home — and lets you hand the tedious ones to an AI agent without breaking flow. **Anyone inheriting a codebase** can open Code Tasks on day one and read the previous author's `FIXME`s and `HACK`s as an instant, prioritized map of the project's known rough edges. **Small teams** get lightweight task tracking that lives where the work does. `// REVIEW(sam):` assigns a card, manual tasks capture the non-code work, and nothing has to be duplicated into a separate tool until it's genuinely ready to be. ## Try it Update to 1DevTool v1.39.0, open a project, and launch Code Tasks. Whatever's already annotated in your code shows up on the board in a few milliseconds — so start by dragging your loudest `FIXME` into Critical, or add the task you've been meaning to write down somewhere. Your scattered comments were always a to-do list. Now they finally look like one. --- ## Know exactly what every AI agent is doing — from your desk or your phone Source: https://1devtool.com/blog/know-what-your-ai-agents-are-doing Published: 2026-07-12 Tags: ai-agents, terminals, remote-control, reader-mode, productivity 1DevTool v1.38.0 adds live run timers to every terminal tab and brings Reader Mode to Remote Control, so you can tell which agents are still working at a glance and read their full conversations comfortably from your phone. You hand a task to an AI agent in a terminal, then switch to another tab to keep working. Ten minutes later you glance back — is it still thinking, or did it quietly finish four minutes ago while you weren't looking? The only way to know is to click into the tab and scroll. Multiply that by the three or four agents you have running at once, and a real part of your day becomes checking on work you can't see. It gets worse the moment you stand up. You start a long refactor, grab a coffee, and want to check progress from your phone. Remote Control has always let you do that — but you were reading the agent's reasoning in a raw terminal, wrapping and scrolling through a wall of monospaced text on a screen the size of your palm. 1DevTool v1.38.0 fixes both. You can now see how long every agent has been working at a glance, and read its entire conversation on your phone as comfortably as an article. ## What changed Two additions, one goal — knowing what your AI agents are doing without digging for it: - **Live run timers on every terminal tab.** While an agent is working, its tab shows a spinner and a live elapsed timer. The instant it finishes, that turns into a check mark. - **Reader Mode on Remote Control.** The clean, readable transcript view you already have on the desktop now works from your phone, turning a live terminal into something you can actually read. ## How it works in practice ### See how long every agent has been running Every terminal running an AI agent now carries its own timer, right on the tab. A spinner and a running clock — `5m 36s`, ticking up — tell you an agent is still working. When the run completes, the spinner becomes a check mark and the timer stops for good. That small change answers the two questions you used to open each tab to check: *is this one still going?* and *how long has it taken?* You can scan a row of terminals and immediately tell which agents are busy and which are done, without interrupting any of them. ![1DevTool terminal dashboard with a live 5m 36s run timer and spinner on an active agent tab while finished agent tabs show green check marks](/app-screenshots/1.38.0-live-run-timers-on-terminals.jpg) The timer is also honest about finishing. A run that fails or is cancelled stops cleanly — the timer won't hang forever or come back to life after the agent has already stopped, so a check mark on the tab always means the work is genuinely done. ### Read the whole conversation on your phone Open Remote Control on your phone, tap the Reader Mode icon in the header, and the raw terminal becomes a clean transcript — your prompts and the agent's replies laid out as readable messages instead of wrapped terminal output. It reads like a document because it is treated like one. There's a word count and a reading-time estimate at the top, and you can bump the font up or down through five sizes (14 to 23 pt) until it's comfortable on your screen. A **Latest / All** switch lets you jump to just the newest exchange or scroll the entire history, and the view keeps up as the agent keeps talking. ![Reader Mode on a phone showing an AI agent conversation as a clean, scrollable transcript with font-size controls and a word and reading-time estimate](/app-screenshots/1.38.0-reader-mode-on-remote-control.png) ### Tap less, and keep your desktop layout intact Two smaller changes make the phone experience feel less cramped. When you're reading rather than typing, you can hide the on-screen keyboard with a single toggle in Remote Control, giving the transcript the full height of the screen. And viewing a terminal from your phone no longer forces your desktop app down to phone width — the desktop keeps its own layout, so you don't come back to your Mac to find everything squeezed into a narrow column with a blank gap beside it. ![1DevTool Remote Control on a phone with callouts pointing to the Reader Mode toggle and the control that hides the on-screen keyboard](/app-screenshots/1.38.0-reader-mode-and-keyboard-toggle-remote-control.png) ## Before vs after | Checking on an AI agent | Before v1.38.0 | Now | |---|---|---| | Is this agent still working? | Click into the tab and scroll to the bottom | Glance at the tab — spinner and live timer, or a check mark | | How long has it been running? | No idea unless you timed it yourself | Elapsed time counts up on the tab | | Reading its reasoning on a phone | Raw terminal text, wrapped and tiny | Clean transcript with adjustable font and reading time | | Jumping to the latest reply on mobile | Scroll through the whole buffer | Tap **Latest** to go straight to the newest exchange | | Checking mobile without wrecking your desktop | Desktop layout squeezed to phone width | Desktop keeps its own width | ## Who benefits most **People running long agent jobs.** If your agents routinely work for minutes at a time — big refactors, test runs, migrations — the per-tab timer turns "did it stall?" anxiety into a one-second glance. **Anyone who steps away from their desk.** Kick off a task, walk away, and follow the agent's thinking from your phone in a view built for reading, not just a mirror of the terminal. **Multi-agent orchestrators.** When you're running several agents in parallel, the row of timers and check marks becomes a live status board — you always know which lanes are still moving and which are ready for your review. ## Try it Update to 1DevTool v1.38.0 and the timers show up automatically the next time you run an agent; open Remote Control on your phone and tap the Reader Mode icon to read along. The result is less clicking to find out what your agents are doing — and the freedom to keep an eye on them from wherever you are. --- ## Pick the Model for Every AI Agent Handoff Source: https://1devtool.com/blog/choose-a-model-for-every-handoff Published: 2026-07-11 Tags: agent delegation, ai orchestration, model selection, ai agents, release Delegating a task to another AI agent no longer means accepting whatever model it defaults to. Now you pick the exact model — and reasoning level — for each handoff, right from the @mention picker. You started leaning on delegation the moment 1DevTool let one agent hand work to another. Claude drafts the plan, then passes the mechanical parts to Codex; a long-running agent farms out a batch of small edits so it can keep moving. It is a genuinely good way to work — right up until you notice *what* each handoff was actually running on. Because the delegated agent always launched on whatever model its CLI happened to default to. The throwaway "rename these variables" task went out to your most expensive reasoning model. The genuinely hard refactor got whatever cheap default was configured weeks ago. You had no say at the moment that mattered — the moment you handed off the task. Changing it meant editing the agent's config file and restarting, which is not something anyone does mid-flow. ## Now you choose the model for each handoff You can now pick the exact model — and, where the agent supports it, the reasoning level — for every AI agent handoff, right from the @mention picker, before the task is sent. The delegated run launches on the model you chose instead of the one it would have fallen back to. ![The Agent Input overlay with the Agents tab open, showing "OpenAI Codex — pick model" and a filterable list of models including gpt-5.6-terra:ultra and gpt-5.6-luna variants](/app-screenshots/model-aware-agent-delegation-picker.jpg) ## How it works in practice ### Pick a model the moment you hand off Open the **Agents** tab in Agent Input and select the agent you are delegating to — say, **OpenAI Codex — pick model**. Its available models appear in a list you can filter by typing; the arrow keys move through it, `←` steps back, and Enter inserts your choice. Send the task and it is delegated through the local `1devtool-agent` CLI with `--model` set to exactly what you picked. No config file, no restart — the decision lives at the handoff. ### Dial in the reasoning level, not just the model Some models expose more than one effort tier, and the picker surfaces them as first-class choices: `gpt-5.6-luna:low` for something quick, `gpt-5.6-luna:high` when it needs to think, `gpt-5.6-terra:ultra` for the heavy lifting. You are choosing how hard the delegated agent should work, not only which model answers. ### See what each agent can actually run Every agent's model list has a different origin, and **Settings → AI → Orchestration** shows you the whole catalog in one place. Each agent reports where its models came from: **from CLI** for Codex, OpenCode, and Grok — read straight from the tool's own account cache, reasoning variants included — **from API** for Claude and Gemini, using your key when one is in the environment and otherwise the keyless models.dev catalog, **from config** for Cline's configured providers, and a **curated** list for Qwen. The catalog loads lazily and is cached to disk, so the picker stays fast; when you switch accounts or add a provider, hit **Refresh models** to re-probe. If a live probe ever fails, it quietly falls back to the last good list rather than leaving you with an empty picker. ![Settings → AI → Orchestration showing the agent model catalog: Claude with models from API, Codex from CLI, Gemini from API, OpenCode from CLI, plus Qwen, Grok, and Cline, each with a Refresh models button](/app-screenshots/settings-orchestration-model-catalog.jpg) ### Follow the handoff chain Once work is delegated, the sub-agent badge shows the logo and name of every agent in the chain, with the one currently running animated — so a `claude → codex` handoff reads at a glance, and the delegated command carries the model you chose right there in the run. If you have ever wondered which model a nested handoff actually used, the answer is now visible instead of assumed. ![A terminal running a delegated task with a handoff badge reading "claude to codex", and the delegated command showing --model=gpt-5.6-luna:high](/app-screenshots/sub-agent-handoff-chain-badge.jpg) And when you pick a model, you get that model. A reliability fix in this release means model-specific handoffs launch the requested model every time, including Codex's reasoning variants — the picker is not a suggestion the CLI can quietly ignore. ## Before vs after | Handing off a task | Before | Now | |---|---|---| | Choosing the model | Whatever the agent's CLI defaulted to | Pick it per handoff in the @mention picker | | Reasoning level | Fixed by config | Low, high, or ultra where supported | | Seeing the options | Read each agent's own docs | One catalog in Settings → AI → Orchestration | | Changing it | Edit config, restart the agent | Choose it at the moment you delegate | | Knowing what ran | Assume the default | Read the model off the sub-agent badge | ## Who benefits most **Orchestration-heavy workflows.** If you already route work between Claude, Codex, and others through the [AI Agent Orchestrator](https://1devtool.com/features/ai-agent-orchestrator), this is the dial that was missing — each hop can now run on the model that fits it. **Cost-conscious developers.** Send the mechanical work to a fast, inexpensive model and reserve your premium reasoning quota for the tasks that actually earn it, instead of spending it by accident on a delegated rename. **Anyone tuning for quality.** A tricky migration can get maximum reasoning while a boilerplate change stays quick — same session, different models, chosen deliberately rather than inherited. ## Try it Update to the latest 1DevTool, @mention an agent, and open the **Agents** tab before you send your next handoff. Pick the model that fits the task — and let the easy work and the hard work stop sharing a default. --- ## Know Before Your AI Quota Runs Out Source: https://1devtool.com/blog/know-before-your-ai-quota-runs-out Published: 2026-07-10 Tags: ai quota alerts, account switching, claude code, ai usage, release Set a usage threshold per agent and 1DevTool warns you before you hit your AI limit — then switches you to a spare account that still has room in one click. There's a particular kind of stall that only happens with AI coding tools. The agent is halfway through a change you actually care about, you step away to let it run, and when you come back the session is dead — not because the work failed, but because you hit a usage limit you had no way of seeing coming. The only signal was the error itself. By then every option is a bad one. You log out, log into another account, restart the terminal, and hope the agent can pick up where it left off. The limit was always going to arrive. The problem is that it arrived as a surprise, at the worst possible moment, with nothing you could have done about it earlier. ## Get warned before the wall, not at it Now you can set the point where you want a heads-up and hear about it before you run out. Pick a percentage — 80% is the default — and when an agent's live usage crosses it, 1DevTool shows you a plain alert: which agent, how much of its quota is gone, and when the window resets. You find out while there's still room to act, instead of after the session is already blocked. The alert isn't tied to one provider or a single number. It watches the same live usage you already track, and it fires the moment your real consumption crosses the line you drew — no polling a dashboard, no doing percentage math in your head between prompts. ![Center-screen Claude Code quota alert showing it has reached a share of its five-hour quota, with Dismiss and Open AI Accounts buttons](/app-screenshots/ai-quota-alert-claude.jpg) ## Set the line once and forget it ### Turn it on where you already watch usage You set alerts in the two places you'd look for them anyway: **Settings → AI → Accounts**, or straight from the quota pill in the header. Toggle **Alert me when quota reaches** for the agent you care about, and it's on. Because the control lives next to your [live usage readout](https://1devtool.com/features/ai-usage-dashboard), turning it on is part of the same glance where you notice you're burning through a plan. ![Quota pill popover with the Alert me when quota reaches control, setting separate five-hour and weekly percent thresholds](/app-screenshots/ai-quota-alert-setup.jpg) ### Two windows, because you burn them differently Most plans meter you on more than one clock — a short rolling session window and a longer weekly one — and you can blow through either. So the alert gives you a separate threshold for each. Set the session (five-hour) line where a heavy afternoon should warn you, and the weekly line where you want to protect the back half of your week. Both default to 80%, which is a reasonable place to start before you tune it to how you actually work. ### One alert, then it's quiet A warning you get twenty times is a warning you learn to ignore. Quota alerts fire **once per quota window** — you get the single heads-up that matters, and then nothing until the window resets. It's a nudge, not a notification stream. ## Switch accounts without leaving the alert The alert isn't just information; it's the fastest place to act on it. If you keep a spare account for that agent — a second Claude login, a separate Codex seat — and it still has room, the alert offers a **Switch account** button that moves you to it in one click. Restart that terminal and you're working again on quota you actually have. If there's no spare with headroom, **Open AI Accounts** drops you straight into [account management](https://1devtool.com/features/ai-account-switcher) to sort it out. That's the difference between a dead-end error and a detour. The wall still exists; you just get to step around it instead of into it. ![Antigravity quota alert shown over the editor, giving the same early warning for a second agent](/app-screenshots/ai-quota-alert-antigravity.jpg) ## Before and after | The old way | With quota alerts | | --- | --- | | Find out you're capped when the agent errors mid-task | Get a heads-up at the percentage you chose | | Guess how much of your session or week is left | See the exact percent used and when it resets | | Log out, log in, and restart while the work stalls | One click to a spare account still under the limit | | Run the same scramble every time you hit a wall | Set the threshold once, per agent, and move on | ## Who gets the most out of it If you lean on Claude Code or Codex all day against a plan limit, this turns "surprise outage" into "planned handoff" — you wind a task down or switch accounts on your terms. If you run walk-away sessions, where an agent works while you do something else, the alert is the thing that tells you to come back before the run dies quietly. And if you juggle several accounts across agents, per-agent thresholds mean each one warns you independently, so you always know which login is about to tap out. It reaches you wherever you're watching, too: the same quota lives in the pill on your desktop and on your phone through Remote Control, so a long run doesn't have to be babysat from your desk. ## Turn it on Quota alerts are already sitting next to your usage. Open **Settings → AI → Accounts** or click the quota pill, flip on **Alert me when quota reaches**, and set the session and weekly percentages where you want the tap on the shoulder. Then get back to work and let the app watch the meter for you. The limit was always coming. Now it knocks first. --- ## Split-View Editor, Collapsible Terminals, and Grok as a Built-In Agent Source: https://1devtool.com/blog/reshape-your-editor-and-terminals Published: 2026-07-09 Tags: split-view editor, terminals, workspace, grok, release 1DevTool 1.35.0 lets you split the editor into side-by-side groups, collapse and resize the terminal panel, auto-name your AI tabs, switch branches from the status bar, and run Grok as a built-in agent. Your editor started the day with one file open. By mid-afternoon you're jumping between a component and the API route that feeds it, scrolling up in one to remember what the other returned. The terminals stacked under your code have crept up to half the screen, so reading a long file means squinting at the top third. And the four AI agents you kicked off an hour ago are all labeled "Terminal 2," "Terminal 3," "Terminal 4" — you have to click into each one just to remember which is refactoring auth and which is writing tests. None of that is the work. It's the friction *around* the work — a workspace that doesn't quite fit the shape of what you're doing right now. ## Your editor and terminals now bend to fit the task 1DevTool 1.35.0 makes the workspace reshape around you instead of the other way around. You can split the editor into side-by-side groups, fold the terminal panel out of the way when you need to read, widen the terminal tab list, and let your AI tabs name themselves after what they're actually doing. The layout stops being a fixed frame and starts moving with the task in front of you. ## How it works in practice ### Compare two files without losing either one Open a second file *beside* the first instead of tabbing back and forth. The editor now splits into as many as four side-by-side groups, and you drag the dividers to give each one the width it needs — a wide code pane on the left, a narrow reference on the right. You can even keep the same file open in two groups at once, editing at the top while you watch a different section below. When you close the last file in a group, that group closes itself, so the split never leaves an empty column behind. ![Code editor split into four side-by-side groups with draggable dividers, each group showing a different file](/app-screenshots/02-split-view-editor.jpg) ### Fold the terminals away when you're reading Sometimes you just want the whole screen for the file. Collapse the terminal section with the header toggle or **Cmd/Ctrl+Shift+J**, and the editor expands to fill the space. The terminals don't stop — they keep running in the background, so your dev server, your build watch, and your AI agents all carry on while they're hidden. Hit the toggle again and everything is exactly where you left it, scrollback intact. ![Terminal section collapsed to a slim bar beneath the editor using the header toggle, giving the editor the full height](/app-screenshots/03-collapse-terminal-section.jpg) ### Give your terminal tabs the width — and the names — they deserve In the vertical-tabs layout, the tab list used to be a fixed sliver. Now you drag its edge to whatever width reads best, and double-click the handle to snap it back to default. The width is remembered per project, so a repo with long session titles can keep a wider list while a scratch project stays compact. ![Vertical-tabs terminal layout with a draggable tab sidebar being resized to a wider custom width](/app-screenshots/04-resizable-vertical-tabs.jpg) And those anonymous "Terminal 3" tabs are gone: AI terminal tabs now rename themselves to the current session title, so the tab that's "Choose SEO feature to implement" says exactly that. Tabs you named by hand stay untouched — the auto-naming only fills in the ones you never bothered to label. ![AI terminal tabs automatically renamed to their session titles such as "Choose SEO feature to implement"](/app-screenshots/05-auto-name-ai-terminal-tabs.jpg) ### Switch branches without leaving your code The branch name in the status bar is now a full picker. Click it and your most recently used branches sit at the top, grouped with relative dates, so the branch you touched ten minutes ago is one click away instead of buried in an alphabetical list. You can create a new branch inline, fetch and sync, and jump to a worktree — all without opening a separate Git view. ![Status-bar branch picker on the main branch with a dropdown to switch and create branches](/app-screenshots/06-git-branch-picker-statusbar.jpg) ## Before vs after | Task | Before 1.35.0 | With 1.35.0 | |---|---|---| | Reference a second file | Tab back and forth, losing your place | Split the editor and keep both in view | | Read a long file | Terminals eat half the screen | Collapse the terminal panel with Cmd/Ctrl+Shift+J | | Find the right AI tab | Click each "Terminal 3" to see what it's doing | Tabs are named after their session | | Widen the tab list | Stuck at a fixed width | Drag it to fit, remembered per project | | Switch branches | Open the Git client, scroll the branch list | Click the status-bar picker, recent branches on top | ## Also new in 1.35.0 ### Grok joins the agent lineup Grok (xAI) is now a first-class agent, not a plain shell you paste a command into. It shows up in the terminal launchers, in settings visibility, and in the empty-workspace quick actions, and it uses the same prompt handling, headless mode, and sub-agent detection as every other supported agent. You can resume earlier Grok conversations from Resume AI Sessions — with titles, previews, and project context — and orchestration handoffs can now target Grok or let Grok delegate out to other tools. ![Launch a coding agent panel with a Grok CLI card shown alongside Codex, Antigravity, OpenCode, Cline and Claude agent launchers](/app-screenshots/01-grok-builtin-agent.jpg) ### Schedule prompts from your phone Remote Control can now send an Agent Input prompt *later* — on a timer, at a specific time, or at the next quota reset — matching the scheduling you already have on the desktop. Queue the prompt from your phone on the walk home and it fires when your quota comes back, attachments and agent handoffs included. ### A safer way to quit Close the app with live sessions open and 1DevTool now asks first. The quit dialog shows exactly what's at stake — how many shell tabs and AI agent tabs are affected — and lets you **Save & Quit** (shells detach to tmux and reattach next launch, AI agents resume the conversation), **Cancel**, or deliberately **Quit Without Saving**. No more losing an afternoon of context to a reflexive Cmd+Q. ![Quit 1DevTool confirmation dialog offering Save and Quit, Cancel, or Quit Without Saving, listing shell tabs and AI agent tabs to preserve](/app-screenshots/07-quit-confirm-save-sessions.jpg) The empty-workspace launcher also got tidier: it now shows only the agents you've actually set up and hides the ones that still need a CLI install, so every card you see launches cleanly instead of failing halfway. ## Who benefits most - **Anyone running multiple AI agents at once.** Named tabs, a resizable tab list, and a quit dialog that preserves sessions turn a wall of anonymous terminals into something you can actually navigate. - **Readers and reviewers.** Split view plus a collapsible terminal panel means you can put two files side by side or hand the whole screen to one, depending on whether you're writing or reading. - **Frequent branch switchers.** The status-bar picker with recent branches on top pays off every time you bounce between a feature branch and main. ## Try it Update to 1DevTool 1.35.0 and the workspace stops fighting you: split the editor when you need two files, collapse the terminals when you need one, and let your tabs name themselves. Then launch Grok next to Claude and Codex and see which one you reach for. [Download the latest 1DevTool](https://1devtool.com/download) or [browse the full changelog](https://1devtool.com/changelog) to see everything in this release. --- ## Guided Startup Commands & Antigravity: Launch Any AI Agent Faster Source: https://1devtool.com/blog/guided-startup-commands-and-antigravity Published: 2026-07-08 Tags: ai-agents, antigravity, startup-commands, orchestration, terminals 1DevTool 1.34.0 builds your agent startup commands for you with a guided form, and makes Antigravity a first-class AI agent in every launcher and orchestration handoff. You picked your coding agent a long time ago. What you never quite settled is how it launches. Every agent has its own incantation. Claude wants `--dangerously-skip-permissions`, plus a `--model` flag if you care which model answers. Codex wants `--dangerously-bypass-approvals-and-sandbox`. Get one flag wrong and the terminal either refuses to start or quietly runs in a mode you didn't intend. So you keep a scratch file of commands somewhere, or you retype the same long string every time you open a project — and you certainly don't hand that setup to a teammate. The moment a new agent shows up, none of that muscle memory helps either. Google's Antigravity lands, you want to try it next to Claude, and it's simply not in your launcher. You're back to a plain shell, pasting a command from a README, with none of the prompt handling, quota tracking, or orchestration the built-in agents get. ## What changed 1DevTool 1.34.0 takes both problems off your plate. First, a **guided form** now builds your startup commands for you. You type or paste a command, and 1DevTool fills in the name, sets the run mode, and recognizes the agent — before it ever appears in a launcher. Second, **Antigravity is now a built-in AI agent**, wired into the same launchers, settings, quota lookups, and orchestration handoffs that Claude, Codex, and Gemini already use. ![Empty workspace showing the Launch a coding agent panel with Claude Code, Codex, Antigravity and other agents plus a Customize agent action](/app-screenshots/02-empty-workspace-agent-launcher.jpg) ## How it works in practice ### A form that reads your command back to you Open **Manage Startup Commands** (or Settings → Terminal → Commands) and you get a single prompt line with one instruction: *"Type a command — the name and run mode fill in automatically."* Paste `claude --dangerously-skip-permissions --model claude-opus-4-8` and watch the rest of the form respond. The **Name** field fills itself in with "Claude Opus 4.8 Full." The **Run mode** flips to **AI agent** — the mode that turns on prompt handling, orchestration, and idle detection. A small **"Claude detected"** chip appears to confirm it recognized the CLI. You labelled nothing; the form read the command and did it for you. It recognizes more than the big three. Package scripts like `npm run dev`, Docker Compose, and package-runner commands such as `npx` all get readable names automatically. When you're wrapping an agent inside a script — the one case detection can't see through — a manual **AI agent / Normal** switch lets you set the mode yourself. Pick an emoji, drop it in a category so it groups cleanly in the picker, and click **Add Command**. ![Manage Startup Commands modal with the guided Add-command form auto-filling the name and run mode, plus a checklist of built-in AI agents and shells](/app-screenshots/01-guided-startup-commands.jpg) ### Set one up before you even have a terminal You don't have to open a terminal first to configure one. A project with no terminals now shows a **Customize agent** action right on the empty-workspace launcher, next to **New terminal** and **Scan My Machine**. Add your custom agent command there and it's ready before your first shell exists — which is exactly when you want it. ### Antigravity, orchestrated like everything else Antigravity now shows up everywhere the other agents do: the empty-workspace launcher, the Add Terminal dialog, command detection, and the built-in agents checklist. Launch it and the terminal behaves like any other AI agent — it gets headless prompt mode, its quota appears in the usage pill next to Claude and Codex (on desktop and on your phone through Remote Control), and its sub-agent runs surface in the badge stack. That last part matters for orchestration. When you delegate work across agents, a handoff can now target Antigravity directly, and those delegated runs show up as badges so you can watch the chain — codex handing off to Antigravity, a few seconds each — instead of guessing what ran where. ![Sub-agent badge stack showing codex delegating to Antigravity headless runs](/app-screenshots/05-antigravity-subagent-badges.jpg) The orchestration skill install widened, too. 1DevTool can now install its orchestrator skill for fourteen host tools — Claude, Codex, Gemini, Antigravity, OpenCode, GitHub Copilot, Roo, Qoder, Trae, Droid, Kilo Code, Warp, Augment, and Cline — so the agent you drive from can hand work to the ones you don't. ![Orchestrator terminal delegating work in parallel with a sub-agent handoff badge showing a codex to cline delegation](/app-screenshots/04-parallel-agent-orchestration.jpg) ## Before vs after | Setting up an agent | Before | With 1.34.0 | |---|---|---| | Naming a startup command | Type a name by hand, hope it reads clearly later | Auto-filled from the command ("Claude Opus 4.8 Full") | | Getting the run mode right | Remember to mark it as an AI agent | Flipped to AI agent on detection, with a manual override | | Trying Antigravity | Plain shell, pasted command, no quota or prompt handling | First-class agent in every launcher | | Delegating to Antigravity | Not a valid handoff target | Direct orchestration handoff with sub-agent badges | | Configuring before a terminal exists | Open a terminal first, then reconfigure | "Customize agent" on the empty workspace | ## Who benefits most If you run **more than one agent** — a Claude tab and a Codex tab side by side — the guided form is the difference between a launcher you trust and a pile of half-remembered flags. If you're **evaluating Antigravity**, you get to judge it on equal footing with the agents you already use, quota and orchestration included. And if you **hand your setup to teammates**, a named, categorized command is something you can actually share. ## Try it Update to 1DevTool 1.34.0, open Manage Startup Commands, and paste in the ugliest launch command you've got. Watch it name itself. Then add Antigravity next to your usual agent and give them the same task. The setup that used to live in your head now lives in the launcher — ready the next time you open the project. --- ## Recover Closed Terminals and Edit C# Projects Faster Source: https://1devtool.com/blog/recover-terminals-csharp-code-intelligence Published: 2026-07-07 Tags: terminal recovery, C#, code intelligence, project management, AI usage 1DevTool 1.33.1 adds Reopen Closed Terminal, C# and .NET Code Intelligence, safer project folder renaming, and clearer AI usage surfaces. Closing the wrong terminal is usually a small mistake with a long tail. You remember the command, the folder, and maybe the agent that was running there, but rebuilding the exact tab still interrupts the work. The same thing happens when you open a C# project in a general-purpose editor and the editor treats it like plain text: the file opens, but the project context is missing. 1DevTool 1.33.1 focuses on those everyday breaks in flow. It gives closed terminals a quick recovery path, brings C# and .NET projects into Code Intelligence, and makes project renaming safer when the folder on disk has to move with the workspace. ## What changed You can now reopen recently closed terminals from the terminal menu, edit C# files with Code Intelligence when the C# language server is available, and rename local project folders from the sidebar while 1DevTool keeps workspace paths aligned. ![Terminal context menu showing Reopen Closed Terminal with the most recently closed terminal name beside the action.](/app-screenshots/01-reopen-closed-terminal-menu.jpg) ## How it works in practice ### Recover the terminal you closed a moment ago Right-click a terminal tab and choose Reopen Closed Terminal. 1DevTool restores the most recently closed terminal setup in last-closed order, so you can bring back several closed tabs one at a time. The restored terminal keeps the details that make the tab useful: its name, command, color, working folder, worktree binding, and AI conversation resume information. Under the hood, closed terminals are stored per project, then restored into the same project with a fresh terminal id and the original setup. That means recovery is fast without trying to revive a killed PTY session as if nothing happened. ### Work in C# and .NET projects with editor intelligence C# files now get language badges, editor language detection, diagnostics, go-to-definition support, and language-server-backed editor behavior when the C# language server is installed. If you move between TypeScript, shell scripts, and .NET code in the same workspace, the editor can now recognize C# files as first-class code instead of generic text. ![C# file open in the editor with language detection and Code Intelligence available for a .NET project.](/app-screenshots/02-csharp-code-intelligence-editor.jpg) Code Intelligence settings list C# / .NET alongside other supported language servers. 1DevTool uses csharp-ls and can install or update it through .NET global tools. If the app sees a .NET runtime but no SDK, or no .NET install at all, the setup surface gives you the specific next step instead of leaving a language server failure unexplained. ![Code Intelligence settings listing the C# / .NET language server with diagnostics and go-to-definition support.](/app-screenshots/03-csharp-language-server-settings.jpg) ### Turn editor intelligence on when the project needs it The Enable Code Intelligence dialog makes the setup decision explicit. You can see which language servers are supported, which ones are detected, and what needs to be installed before the editor starts depending on them. ![Enable Code Intelligence dialog showing supported language servers and setup status before turning editor intelligence on.](/app-screenshots/04-enable-code-intelligence-dialog.jpg) This matters for mixed stacks. A workspace can contain frontend code, backend services, scripts, and C# projects. The app should not guess blindly, and it should not make you debug language-server setup through a separate terminal unless that is what you want to do. ### Rename a local project without breaking the workspace Renaming a local project from the sidebar now moves the folder on disk and rebases the project paths that point inside it. Open files, terminal working folders, worktree bindings, HTTP request file paths, SQLite database paths, prototype roots, file-tree expansion state, and project settings write-back all follow the new root. SSH projects are handled differently on purpose. Renaming an SSH project updates the display name without trying to rename a remote folder. That keeps the local UI flexible without performing a remote filesystem operation you did not ask for. ### Keep AI surfaces easier to scan This release also extends recognizable agent logos across AI usage, Remote Control usage, AI Diff sessions, Skills, and Memory. The App Toolbar now places AI usage immediately after Prompts and before Memory, keeping prompt history, usage, and memory controls together. ![AI usage panel showing recognizable agent logos beside usage rows for different coding agents.](/app-screenshots/05-ai-usage-agent-logos.jpg) ## Before vs After | Workflow | Before | Now | | --- | --- | --- | | Closed terminal recovery | Recreate the tab, folder, command, and AI context manually | Reopen the last closed terminal from the tab menu | | C# editing | Open C# files without full language-server support | Use C# detection, diagnostics, and go-to-definition when csharp-ls is available | | Language server setup | Diagnose missing .NET or csharp-ls outside the editor | Install or update through Code Intelligence settings with clearer setup messages | | Project renaming | Rename the label and risk stale paths elsewhere | Move the local folder and rebase workspace paths together | | AI usage scanning | Read text labels across several AI surfaces | Recognize agent marks in usage, AI Diff, Skills, and Memory | ## Who benefits most If you keep many terminal tabs open, Reopen Closed Terminal saves you from rebuilding a working tab after a mistaken close. It is especially useful when the terminal had a custom command, a worktree folder, or an AI conversation attached. If you work in .NET alongside web projects, C# Code Intelligence keeps the editor useful without leaving 1DevTool. You can inspect diagnostics and definitions while the terminal, browser, Git, and database tools stay in the same workspace. If you rename project folders during cleanup or handoff, safer project renaming reduces stale path problems. The folder move and workspace rebase happen together, and SSH project names stay UI-only. ## Try it Download 1DevTool 1.33.1, close a disposable terminal, then reopen it from the terminal menu. Open a C# file in a .NET project and check Code Intelligence settings for the C# / .NET language server. The result is less recovery work, better editor context, and safer project organization inside the same workspace. --- ## Work Across Multiple Git Repositories From One Workspace Source: https://1devtool.com/blog/multi-repo-git-workspaces Published: 2026-07-06 Tags: multi-repo, git, worktrees, ai-terminals Multi-Repository Workspaces let one project folder hold several independent Git repositories while Git actions, worktrees, change badges, and AI terminals stay scoped to the repo you choose. A project folder often starts simple: one repo, one branch, one set of changes. Then real work expands it. You keep an API checkout next to a web checkout, add a shared package, create a temporary worktree for a risky branch, and leave docs or local scripts beside them. The folder is still one workspace in your head, but Git sees several independent repositories. Before this release, that split forced you to keep extra mental state. You had to remember which terminal was in which repo, which worktree a branch belonged to, and whether a change badge came from the project root or a nested checkout. It was easy to open the right workspace and still run the wrong Git action against the wrong repository. ## What changed Multi-Repository Workspaces let you work inside one project folder that contains several Git repositories without flattening them into one repo or opening each one as a separate project. ![Git Client repository picker showing api, checkout, shared, and web repositories inside one workspace.](/app-screenshots/1.33.0-git-client-repository-picker.jpg) ## How it works in practice ### You choose the repository before Git actions run The Git Client now detects independent repositories inside the workspace folder and shows a repository picker next to the project picker. Choose `api`, `web`, `shared`, or another nested repo, and the Git Client narrows itself to that target. Changes, History, Worktrees, Graph, branches, commits, diffs, fetch, pull, push, and publish actions all follow the selected repository. That means you can keep a parent folder such as `test-workspace` open while reviewing only the `web` repo. When you switch to `api`, the old selected file, commit, diff, and branch state clears before the new repo loads, so stale rows from another repo do not stay clickable. ### The file explorer keeps the whole workspace visible The file tree still starts at the workspace root. Switching the Git Client to a nested repo does not hide the rest of the folder from you. Non-git folders remain visible, and change badges account for the nested repositories below the root. ![File Explorer showing nested repositories, a non-git folder, and per-repo change counts in the status bar.](/app-screenshots/1.33.0-multi-repo-file-explorer-change-badges.jpg) The status bar also understands the multi-repo shape. If the root folder is not itself a repo but contains repositories, it opens the Git Client instead of trying to initialize Git at the root. You see how many repos were found and how many changes need review across them. ### Worktrees stay scoped to the active repo Worktree actions now follow the repository you selected, not the outer workspace folder. Create, remove, prune, lock, unlock, graph, and terminal launch actions use the active repo as their base. If you are viewing the `web` repo, a new worktree path is generated under that repo's workspace area instead of being attached to the wrong checkout. ![Worktrees tab creating a new branch worktree inside the selected nested repository.](/app-screenshots/1.33.0-repo-scoped-worktree-creation.jpg) This matters when you keep multiple related repos together. You can create a `feat/fix-frontend` worktree for the web app while the API and shared package stay in the same visible workspace. You do not have to leave the project or rebuild your terminal layout just to keep the worktree attached to the right repository. ### AI terminals can start in the repo that matches the task Add Terminal now offers repository choices when a workspace contains multiple repos. You can start an AI agent at the workspace root when the prompt needs to coordinate across everything, or start it inside a specific repo when the task should stay narrow. ![Add Terminal dialog selecting a nested repository and worktree before launching an AI agent.](/app-screenshots/1.33.0-ai-terminal-repo-worktree-launch.jpg) That distinction is useful for agent work. A refactor across API and web can still begin from the root. A focused bug fix in `api-feat-checkout` can start inside that repo and worktree, with the terminal already pointed at the right files. ## Before vs After | Before | After | | --- | --- | | Open each repo as a separate project or keep switching terminal folders. | Keep the parent workspace open and pick the active repo in Git Client. | | Guess whether a change badge came from the root repo or a nested checkout. | See nested repo change counts across the workspace. | | Create worktrees from the wrong base when several repos sit together. | Worktree actions follow the selected repository. | | Launch an AI terminal, then manually `cd` into the repo or worktree. | Choose the repo and worktree before the terminal starts. | | Risk stale diff or commit selections after changing context. | Repo switches clear old selection state before the new target loads. | ## Who benefits most If you work in a small monorepo-like folder made from separate repos, you can keep the mental model you already use without forcing Git into the wrong shape. If you juggle feature worktrees, you can create and launch terminals from the repo that owns the branch instead of checking paths by hand. If you use AI agents across a stack, you can decide whether the agent should see the whole workspace or stay inside one repo before it starts. ## Try it Open a folder that contains several Git repositories, then open the Git Client from the status bar. Pick a repo, review its changes, create a worktree if needed, and launch your next AI terminal from the matching repo or worktree. You keep one workspace on screen while each Git action stays attached to the right repository. --- ## See Codex quota resets and safer AI prompts in 1DevTool Source: https://1devtool.com/blog/clearer-codex-quota-prompts Published: 2026-07-05 Tags: 1devtool, codex, ai agents, agent input, release 1DevTool now shows Codex reset credits with exact expiry times, makes AI terminal tabs easier to scan with real agent logos, and keeps Agent Input submissions and file drops cleaner. When you are deep in an AI-assisted coding session, the small interruptions hurt more than they look. You glance at a terminal tab and have to remember which custom command is running there. You ask Codex for another pass, but you are not sure whether your current quota window is almost done or whether you have reset credits available. You drop files into a prompt and then stop to clean up duplicated text before you can send the actual instruction. None of those moments is a full workflow on its own, but they decide whether a long agent run feels controlled or fragile. Version 1.32.1 focuses on those moments: the status details you need before you start another Codex task, the visual labels that tell agents apart at a glance, and the prompt handoff rules that keep Agent Input from carrying stray text into the next composer. ![Codex usage popover showing manual reset credits and expiry times in 1DevTool](/app-screenshots/codex-quota-reset-credits.jpg) ## What changed Now you can see Codex reset credits, scan agent terminals by their real logos, and submit or drop prompt context without cleaning up leftovers afterward. The Codex usage popover now includes manual reset expiry details from the Codex usage API. Instead of only seeing the active 5-hour and weekly windows, you can also see how many reset credits are available and when each one expires. The same reset information is available in the desktop quota popover and in Remote Control, so you do not have to switch devices or open a separate billing page before deciding whether to keep a heavy Codex task moving. AI terminal branding is also easier to read. Built-in launchers and terminal tabs now show recognizable marks for Claude, Codex, Gemini, Amp, OpenCode, Qwen, Cline, Cursor, Windsurf, and Antigravity. Custom presets can inherit the right logo when the command matches a known agent, while still keeping the preset name and shortcut you chose. Agent Input received the practical cleanup that matters when you compose prompts all day. Submitting from the overlay no longer leaves trailing words behind in a fresh composer. Dropping files into an AI terminal no longer duplicates multi-line prompt text, and selected Codex skills survive the drop path instead of being broken by the inserted file context. ## How it works in practice ### You can decide whether Codex has room for the next task Open a Codex terminal and look at the usage pill in the status bar. The pill still follows the focused AI terminal, so you see the active agent instead of a generic workspace number. Click the pill and the popover shows the current Codex 5-hour limit, weekly limit, and the manual reset section. The reset section is meant for the moment before you start work that might burn a lot of quota. You can see whether reset credits are available, then read the exact expiry time for each credit. That changes the decision from guesswork into a quick check: use a reset now, save it for later, or switch to another agent before you strand a task halfway through. Because the same data appears in Remote Control, you can make that call from your phone while watching a longer run. If a Codex session is waiting and you are away from the desktop, you can still check the reset state before nudging the next prompt forward. ### You can identify custom agents without reading every tab label Many 1DevTool setups mix official agents with custom wrappers. A terminal named `codex usage`, a preset that launches Claude through a local script, and an OpenCode command can all look similar when the screen is busy. The new agent logo matching gives those terminals a visual anchor. ![Terminal switcher showing AI agent presets with matched Codex and Claude logos](/app-screenshots/ai-agent-logo-presets.jpg) When a launcher, tab, or custom preset maps to a known agent, 1DevTool shows the matching mark next to the name. You still keep your custom command, naming convention, and shortcut number; the icon simply makes the list easier to scan. In a grid layout, that means you can spot Codex, Claude, Gemini, or another agent before you read the full tab text. This helps most when you are running several agents in parallel. You can leave one tab reviewing a diff, another tab generating tests, and another tab checking docs, then return to the right one by sight instead of by memory. ### You can submit richer prompts without repairing the composer Agent Input exists so you can write a real prompt instead of squeezing instructions into a terminal line. The value disappears if the handoff adds cleanup work. Version 1.32.1 tightens that handoff. When you submit from Agent Input, 1DevTool gives the terminal enough time to receive the prompt before sending the return key. It also trims the submit-only newline that should not become part of the next draft. The result is simple: after you send a prompt, the new composer starts clean instead of keeping a few trailing words from the previous instruction. File drops are cleaner too. If you drag a file or folder into an AI terminal while a multi-line prompt is present, the drop no longer duplicates that prompt text. If you selected Codex skills before adding files, the inserted file context does not break the skill selection. You can build the context you meant to send, rather than stopping to delete accidental copies before the agent sees them. ## Before vs After | Workflow | Before | After | | --- | --- | --- | | Checking Codex capacity | You saw active usage windows, then had to infer whether reset credits were available elsewhere. | The usage popover shows available reset credits and exact expiry times beside the active Codex windows. | | Managing several AI terminals | Custom presets could require reading each label carefully, especially in dense tab or launcher lists. | Known agents show recognizable logos, including matched custom presets, so the right terminal is easier to spot. | | Sending Agent Input prompts | A fast submit could leave trailing text behind in the next composer. | Prompt submission is delayed and trimmed so the next composer starts clean. | | Dropping files into prompt context | Multi-line prompt text could duplicate, and selected Codex skills could be disrupted by the drop. | File drops preserve the intended prompt and keep selected Codex skills intact. | | Running fresh dev sessions | A clean first-run dev session could collide with another development window. | Fresh sessions can run beside another dev window without closing it. | ## Who benefits most If you use Codex heavily, the quota changes are the most direct win. You can see reset credits before you commit to a long edit, migration, or review, and you can make the same check from Remote Control when you are not sitting at the desktop. If you maintain several custom AI presets, the logo matching makes your launcher and tab list less ambiguous. You do not have to rename every command just to make the UI scannable; the matched agent mark gives each preset a recognizable shape while your own label still carries the local meaning. If you use Agent Input for context-heavy prompts, the submit and file-drop fixes remove the small cleanup loops that interrupt flow. You can write the instruction, attach the files, keep selected Codex skills, and send the prompt without checking whether the composer accidentally carried old text forward. ## Try it Version 1.32.1 is available now from the 1DevTool download page. Open a Codex terminal, check the usage pill, then try your usual Agent Input workflow with a few file drops. The difference should show up in the places where you normally had to pause, reread, or clean up before letting the agent continue. --- ## Share Your Project Setup Through the Repo Source: https://1devtool.com/blog/share-your-project-setup Published: 2026-07-04 Tags: project-configuration, team-onboarding, workspace, scheduled-prompts, ai-terminals 1DevTool v1.32.0 lets you commit your workspace — database connections, API requests, browser tabs, and terminal layout — in a .1devtool/ folder, so teammates clone into the same project without sharing secrets. Also new: scheduled agent prompts and Antigravity quota in the usage pill. You clone a repository, open it, and the code is all there — but the project around the code is missing. The database connection you need to run a query isn't set up. The API requests you'd been testing live in some other window. The browser tabs you keep open beside the app — the docs, the staging URL, the dashboard — start empty. Your terminals aren't split the way you like them, and the agent you launch has no idea what this project is. The repo carried the source. It didn't carry the workspace. That gap is quiet but expensive. Every new teammate rebuilds it by hand, usually by pinging someone to ask which connection string to use and which URL is staging. Every time you move to a second machine, you do the same setup twice. And none of it is written down anywhere the repo can see, so it drifts — whoever configured the project three months ago ends up with a slightly different setup than everyone who joined since. ## What changed Now you can commit your workspace setup alongside your code. 1DevTool v1.32.0 introduces **Project Configuration Folders**: a `.1devtool/` folder — in the spirit of `.vscode/` — that captures your browser tabs, database connections, HTTP requests and environments, deploy config, environment preferences, and terminal presets as plain JSON. Push it, and a teammate who clones the repo opens the project into the same workspace you set up: same tabs, same connections, same layout. ![Project Configuration editor showing the .1devtool folder's file list — browser.json, database.json, http.json, agents.json — with browser.json open and a "Folder present, 0 credentials needed" status.](/app-screenshots/02-project-configuration-folder-editor.jpg) ## How it works in practice ### Share your setup through the repo You turn it on per project. Open **Settings → Project**, or right-click the project in the sidebar and choose **Project Settings…**, then enable the settings folder. 1DevTool writes `.1devtool/` into the project and keeps it in sync as your config changes. When you want to snapshot the current state — the tabs you have open now, the connection you just added — click **Update from current project** and it captures everything into the folder, ready to commit. The folder is deliberately readable. Each domain gets its own file: `browser.json` for tabs, `database.json` for connections, `http.json` for requests and environments, plus `deploy.json`, `env.json`, and `agents.json`. Every file is written sorted and stable, so changing one connection produces a clean one-line diff in review instead of a churned blob. ![1DevTool project sidebar context menu with the "Project Settings…" item highlighted — the entry point for creating a shareable .1devtool config folder.](/app-screenshots/01-project-settings-configuration-menu.jpg) ### Your config travels, your secrets don't Sharing a database connection is useful. Sharing its password in a committed file is not. So 1DevTool splits them. When it writes the config, it strips every secret — database passwords, HTTP secret variables, deploy tokens and env values — into a separate `secrets.local.json` that is gitignored before anything is written and encrypted with your OS keychain. What lands in the committed files is a reference, never the value itself. When your teammate opens the cloned project, they see a **Credentials needed** prompt listing exactly which secrets the project expects — this connection's password, that environment's API key. They supply their own once, stored encrypted on their machine, and the prompt clears. Nobody pastes secrets into chat, and no secret rides along in git history. ### Review what can run before it runs Some project config is just data — tabs and URLs are harmless to apply. Other config can run code: terminal startup commands, agent presets, channel templates, and skills. Applying those automatically from a repo you just cloned would mean trusting a file to execute on your machine sight unseen. 1DevTool holds that line. When you open a project whose shared config includes anything executable, the passive parts — browser, env, HTTP requests, database connections — are applied for you, and the executable parts wait in a review panel labeled clearly as *able to run code*. You expand each one, see what it does, and choose **Apply all** when you're satisfied — or **Skip for now**. Approval is tracked per file by content hash, so a later `git pull` that changes one preset re-prompts for that single file and leaves everything you already trusted alone. ## Before vs After | Getting a teammate productive on a project | Before v1.32.0 | With Project Configuration Folders | |---|---|---| | Database connections | Ask which host and database, add each by hand | Present on clone; supply your own password once | | API requests & environments | Rebuild them or export/import manually | Come with the repo | | Browser tabs (docs, staging, dashboards) | Reopen from memory | Restored with the project | | Terminal layout & startup commands | Recreate, then run unknown commands on faith | Restored after an explicit review | | Secrets | Shared over chat, easy to leak | Never committed; each dev supplies their own | ## Also new in v1.32.0 ### Schedule a prompt to send later Agent Input can now wait. Type your prompt, set a timer in hours, minutes, and seconds, and click **Schedule** instead of Send — 1DevTool holds the message and delivers it to the terminal when the timer fires. ![Agent Input composer with the schedule timer set to 10 seconds and the blue Schedule button ready, next to Clear all and Send.](/app-screenshots/03-schedule-agent-input-timer.jpg) While it waits, the composer shows the queued prompt with a live countdown and a **Cancel** button, so you can call it back if plans change. It's the same send path as a normal message: attachments, AI Diff, and agent handoff all behave exactly as they would if you'd hit Send yourself. Line up a prompt to kick off after a long build finishes, or stage work so an agent starts the moment you step away. ![A scheduled Agent Input prompt counting down with a "Sending in 00:00:08" badge and a red Cancel button before it fires.](/app-screenshots/04-scheduled-prompt-countdown-cancel.jpg) ### Antigravity quota in the usage pill If you run Google's Antigravity agent, its quota now shows up in the AI usage pill alongside Claude, Codex, and the rest. When an Antigravity terminal is focused, 1DevTool reads its usage screen directly — and falls back to your signed-in Google credentials when it can't — then shows your weekly limit as a bar and a ring you can click for the full breakdown. The same quota now appears in Remote Control, so you can check what's left from your phone. Terminals launched from custom `agy` presets are recognized too. ![The AI usage pill showing Antigravity at 13% of its weekly limit, with the quota popover open above an active agy Antigravity terminal.](/app-screenshots/05-antigravity-usage-quota-pill.jpg) This release also sharpens Remote Control on phones across the board: terminals, file viewers, and navigation now fit around mobile browser chrome and the on-screen keyboard instead of hiding behind them; desktop-attached terminals mirror at their real size so agent screens don't redraw at phone width; and mobile terminal cards show project avatars so multi-project lists are easy to scan. ## Who benefits most **Teams onboarding new developers** get the biggest lift. The setup that used to live in someone's head or a stale wiki page now travels with the repo, and a new hire is productive on day one instead of day three. **Solo developers who work across machines** stop doing setup twice. Commit once on your desktop, pull on your laptop, and the workspace is already there. **Open-source maintainers** can ship a sensible default workspace with the project so contributors land in a configured environment — with the reassurance that nothing executable runs until the contributor has reviewed and approved it. ## Try it Update to 1DevTool v1.32.0, open a project you work on with other people, and turn on the settings folder from **Settings → Project**. Commit the `.1devtool/` folder it creates, and the next person to clone the repo opens it into the workspace you built — connections, requests, tabs, and layout included, each with their own secrets and their own approval. The project finally travels with the code. --- ## Recover SSH Workspaces Without Restarting Source: https://1devtool.com/blog/recover-ssh-workspaces-without-restarting Published: 2026-07-02 Tags: ssh, remote-development, ai-terminals, opencode Remote SSH projects can now recover from stale mounts, missing sshfs, and dropped connections without making you restart the app. AI terminals also reopen with useful context when native session resume is not available. When a remote workspace drops, the interruption is bigger than the error message. You were in the middle of reading files, running commands, or asking an AI agent to inspect code on a server, and suddenly the project feels half-attached. The file tree may stop reflecting the remote machine. The terminal may still be open, but the mount underneath it is no longer trustworthy. The old escape hatch was familiar: close things, reopen the app, reconnect the host, and rebuild enough context to continue. That friction gets worse when it happens at the same time as an app restart. Remote projects depend on the network, sshfs, host keys, paths, and local helper processes. AI terminals depend on agent-specific session stores that may not be ready at the exact moment the app quits. When either side misses its recovery window, you spend your time proving that the environment still exists instead of doing the work you opened it for. ## What changed Now you can recover an SSH workspace from inside the workspace itself, and your AI terminal tabs keep useful context even when a native resume session cannot be matched. 1DevTool v1.31.0 makes remote projects more recoverable before connection, during setup, and after a stale mount or restart. ![1devtool IDE interface showing an active SSH connection to harry@192.168.68.104, with the file browser visible and the 'SSH connected' status indicator highlighted.](/app-screenshots/ssh_to_other_machine.jpg) ## How it works in practice ### You choose the remote folder before saving the project Remote setup starts earlier now. When you add an SSH project or edit a host in SSH Manager, you can use `Scan` to browse directories on the remote machine before the project is saved. You move through folders with the same key-based access that the final mount will use, then choose `Use this folder` when the workspace root is correct. That matters because path mistakes used to hide until the mount step. A typo in `/var/www/app`, a home directory written as `~`, or a key that could not authenticate might not become obvious until after you created the project and tried to open it. Scanning turns that into a setup-time check. If access fails, you see the problem while you are still deciding which folder to use. ### You can install sshfs where the missing dependency is felt SSH workspaces need sshfs support. When it is missing, the Files sidebar now gives you the install action directly in the place where the remote file tree should appear. You can launch the installer, copy the install command, open Libraries settings, or retry after installing without digging through a separate settings hunt. The workspace also retries once sshfs is detected. The practical result is simple: you fix the dependency and continue the project setup from the same context. You do not have to remember which host, user, key, and path you were configuring before the dependency check stopped you. ### You remount from the status bar when the server comes back The SSH status pill is now a recovery control, not just a label. If a server sleeps, restarts, changes network state, or drops the mount, you can use the status bar to refresh the remote workspace. Switching back to an SSH project also checks whether the mount is still alive and refreshes stale state when needed. This is the day-to-day difference in v1.31.0: a remote project can recover without making the app restart part of the workflow. You can get back to the server after a network drop, stale mount, or dependency repair from the workspace you are already using. ### Your AI tabs stop reopening as blank rooms AI terminals now get another layer of persistence. When an agent cannot be matched to a resumable conversation before the app quits, 1DevTool keeps a capped copy of the last terminal output. On reopen, that transcript appears above the fresh agent session with a visible separator, so you can see where the previous work ended and where the new session begins. This does not pretend to be the same as a native agent resume. It gives you the important part when native resume is not available: the last useful context on screen. You can read the previous commands, agent output, file paths, and decisions before continuing. OpenCode also joins the automatic session detection list in this release. If you use OpenCode next to Claude, Codex, Gemini, or Qwen, 1DevTool can detect the right OpenCode session and reopen it with the same kind of continuity you expect from the other AI terminals. ## Before vs After | Workflow | Before v1.31.0 | In v1.31.0 | | --- | --- | --- | | Choose an SSH project folder | Type the path and discover mistakes after saving or mounting. | Scan remote directories first, then pick `Use this folder`. | | Missing sshfs | Leave the workspace flow to figure out the dependency. | Install, copy commands, open Libraries settings, and retry from the file tree. | | Stale remote mount | Restart the app or recreate enough state to reconnect. | Use the SSH status pill or project switch recovery to refresh the mount. | | AI terminal with no matched resume session | Reopen to a blank tab and reconstruct the last context manually. | Reopen with a saved transcript above a fresh agent session. | | OpenCode continuity | Treat OpenCode sessions as harder to match after restart. | Auto-detect OpenCode sessions alongside the other supported agents. | ## Who benefits most If you work directly on remote servers, this release removes several small recovery rituals that used to stack up. You can validate the folder while creating the project, handle sshfs from the file tree, and refresh the mount after the machine or network changes state. If you keep multiple AI terminals open inside a project, the fallback transcript protects you from the most frustrating failure mode: an agent tab that comes back empty even though it had useful output before quit. You may still start a fresh agent process, but you start with the previous transcript visible. If OpenCode is part of your workflow, the session detection work makes it a first-class participant in restart recovery. Your OpenCode tabs have a better chance of finding the right prior conversation instead of reopening without context. ## Try it Update to v1.31.0, open an SSH project, and watch the bottom status pill the next time the remote host changes state. The important change is not a new screen you have to manage. It is that the workspace gives you recovery controls in the places where remote development actually breaks. --- ## Ship Git Changes From Your Phone Source: https://1devtool.com/blog/ship-git-changes-from-phone Published: 2026-07-02 Tags: remote-control, git, source-control, prompt-history, mobile 1DevTool v1.30.1 brings Source Control and Prompt History to Remote Control, so you can review diffs, inspect commits, and ship narrow Git changes from your phone. When an AI agent finishes work while you are away from your desk, the hard part is not usually reading the terminal output. The hard part is deciding whether the change is safe to keep. You need to see what files changed, inspect the diff, understand whether the branch is ahead or behind, and capture the work before the context disappears. Until now, that usually meant waiting until you were back at the desktop. Remote Control could keep you close to your running terminals, but Git review still belonged to the full app. If an agent fixed a bug while you were on the train, at lunch, or standing in another room, you could watch the result but not comfortably review and ship it. ## What changed Source Control in Remote Control now lets you review and ship Git changes from your phone without returning to the desktop. Each project gets a mobile Git view with Changes, History, and Sync tabs, plus a companion Prompt History view so the prompt or note that led to the change is still close by. ![Remote dashboard Project section showing Prompt History and Source Control actions for the selected project.](/app-screenshots/remote-dashboard-project-picker.png) ## How it works in practice ### Start from the project you are already monitoring Open Remote Control and choose the project you are supervising. The Project section now includes Source Control next to Browse Files, Resume AI Session, and Prompt History. That means the path from watching an agent to reviewing its code is one tap, not a handoff to another screen on your desktop. The dashboard also shows the current branch under each project, so you can see whether you are looking at the right repository before you enter the Git flow. If you are managing several repos from the same phone session, that small detail matters. You can jump into the project that just changed, check Git, and return to terminals without losing your place. ### Review changed files before you act The Changes tab is built for the phone screen. It shows the current branch, upstream, ahead and behind state, changed-file counts, staged files, untracked files, and conflicts. You can search changed files, filter by state, and tap a file to open the mobile diff. The diff view keeps code in a monospace layout with line numbers, additions, removals, and hunk context. You are not guessing from filenames or terminal output. You can inspect the exact patch, move between files, and decide whether the agent made the change you asked for. ![Mobile Git diff view showing monospace TypeScript additions and removals with line numbers.](/app-screenshots/git-diff-monospace.png) ### Check history and commit details The History tab now gives you recent commits from the selected branch. Tap a commit and you can inspect the author, hash, parent count, changed files, total additions and deletions, and the text diff for that commit. This is useful when you need to understand what happened just before the current change. Maybe the agent built on a commit you made yesterday. Maybe a landing-page update already shipped and the current work only needs a small follow-up. The phone view now lets you answer that without opening the desktop Git client. ![Remote Control Git History tab listing recent commits with hashes, authors, and timestamps.](/app-screenshots/deeper-git-history.png) ![Mobile commit detail view showing author initials, file totals, additions, deletions, and changed files.](/app-screenshots/git-avatar-accounts.png) ### Commit, pull, and push with Operator access When the change is ready, the Sync tab shows the branch, upstream, Pull and Push actions, and a commit box. The commit action stages and commits the repository's staged, unstaged, and untracked files with your message. Pull and Push use the current branch and show counts when the repo is behind or ahead. Write actions still respect Remote Control permissions. Viewers can inspect status and diffs, but commit, pull, push, sync, and delete actions require Operator or Admin access. That keeps the phone workflow useful for review without turning every paired device into an unrestricted deploy surface. ![Source Control Sync tab showing branch status with Pull, Push, and Commit controls.](/app-screenshots/git-client-redesign.png) ### Reuse the prompt that produced the change Prompt History is now available from Remote Control too. You can search prompts for this project or across all projects, filter by agent, copy a previous prompt, delete entries with Operator access, and sync local prompt history. Sticky notes have their own tab and source filters, so notes from reader mode and terminals are not mixed into one long list. That closes a common mobile review loop. If the diff looks almost right but needs one more instruction, you can copy the earlier prompt, adjust it, and send the next request from the phone instead of reconstructing it from memory. ![Remote Control Prompt History page filtered to Claude with copy and delete actions.](/app-screenshots/from-your-phone-prompt-history.png) ## Before vs After | Before | After | | --- | --- | | Watch terminal output from your phone, then wait for the desktop to inspect Git. | Open Source Control from the same Remote Control project view. | | Guess whether a changed file is safe from filenames or terminal summaries. | Search, filter, and open a real mobile diff with additions and removals. | | Return to the desktop to inspect recent commits or commit details. | Tap History and open commit details from the phone. | | Leave small completed fixes uncommitted until you are back at your keyboard. | Commit, pull, and push from the Sync tab when you have Operator access. | | Recreate the prompt that led to the work from memory. | Search Prompt History, copy the previous prompt, and continue the loop. | ## Who benefits most If you supervise AI agents while away from your desk, this removes the dead time between "the agent finished" and "the work is captured." You can review the diff while the context is still fresh and decide whether to commit or ask for one more change. If you maintain small production fixes, the mobile Git view gives you enough information to handle narrow updates without opening the full desktop app. You still see branch state, upstream state, and changed files before you push. If you build from reusable prompts, Remote Control Prompt History makes your phone workflow less disposable. The prompt that worked yesterday is searchable, copyable, and ready to reuse when the next project hits the same pattern. ## Try it Update to 1DevTool v1.30.1, open Remote Control from your phone, and choose a project with Git changes. Start with Changes to inspect the patch, use History when you need context, then move to Sync when the change is ready to commit or push. The result is a shorter loop between an agent finishing work and you deciding what happens next. --- ## A Friendlier Git Client That Follows You Across Projects Source: https://1devtool.com/blog/git-client-across-projects Published: 2026-06-30 Tags: Git, Source Control, Workspace, Release 1DevTool's Git Client got a warmer redesign — and now you can switch projects, see whose account you're committing as, and scroll your full history without ever closing the window. If you touch more than one repository in a day — a frontend here, an API there, a landing page you keep nudging — the Git window has a way of getting underfoot. You open it for one project, scan your changes, commit, close it. Then you switch projects and open it again. And again. Somewhere in that loop you push as the wrong account, because the only way to tell which identity was active was to remember. Source control shouldn't ask for that much bookkeeping. ## The Git Client now moves with you This release gives the Git Client a warmer, friendlier look — and, more to the point, makes it follow your work instead of pinning you to one project at a time. You can switch projects from inside the Git window, see exactly which account you're committing as, and scroll back through your whole history without it stalling a few commits in. Diffs, hashes, and file paths still render in monospace, and diff colors are untouched, so code still reads like code. ![Redesigned Git Client with the in-toolbar project picker open, listing projects by avatar while a CHANGELOG.md diff stays visible on the right](https://1devtool.com/app-screenshots/01-git-client-switch-project.jpg) ## How it works in practice ### Switch projects without leaving Git The project name in the Git toolbar is now a picker. Click it, type into **Find a project…**, and jump straight to any other project's **Changes**, **History**, **Worktrees**, or **Graph** — no closing the dialog, no reopening it for the next repo. Each project in the list carries its own avatar, color, and emoji, so a workspace full of repos stays scannable instead of collapsing into a column of near-identical names. ### See who you're committing as Pushing under the wrong identity is the kind of mistake you only notice after it lands. The git account picker now shows your GitHub or GitLab profile picture for each account, with a colored initials badge when no avatar is set. The same faces show up in **Settings → Git**, so the account you're about to commit with is something you recognize at a glance rather than a name you have to parse. ![Git Client toolbar showing the committing account with its GitHub profile picture, next to the Graph tab and the full commit timeline](https://1devtool.com/app-screenshots/02-git-client-account-avatar.jpg) ### Project avatars in the header, too The recognizability carries beyond the Git window. The project switcher in the top breadcrumb now shows each project's avatar and emoji as well, so the same visual shorthand you use to tell repos apart in Git works everywhere you switch projects. ![Header breadcrumb project switcher open, each project shown with its own colored avatar and emoji for quick scanning](https://1devtool.com/app-screenshots/03-header-project-switcher-avatars.jpg) ### Scroll back through your whole history The **History** tab used to stop at the most recent handful of commits. Now it keeps loading older commits as you scroll, so you can travel all the way back through a project's timeline — useful when you're tracking down when a change actually shipped instead of guessing where the list cut off. ## Before vs. after | Working across repos in Git | Before | After | |---|---|---| | View another project's changes | Close the Git window, switch projects, reopen it | Pick the project from the toolbar | | Know which account you're committing as | Remember it, or dig through settings | A profile picture sits right in the toolbar | | Tell projects apart | Read each name | Scan by avatar, color, and emoji | | Look at older commits | Stuck at the most recent few | Scroll back through the whole timeline | ## A few more quality-of-life wins Not everything here is about Git. **Decide whether the Agent Input bar shows up.** A new Terminal setting lets you hide the floating Agent Input composer on AI terminals. When it's off, a small **⌘I input** pill — and its keyboard shortcut — brings the composer back whenever you want it. You can also flip the same switch straight from the Agent Input overlay header, so the bar is there when you're drafting a prompt and out of the way when you're reading output. ![Terminal settings panel with the new 'Show Agent Input composer on AI terminals' toggle switched off](https://1devtool.com/app-screenshots/04-agent-input-composer-setting.jpg) **Generated files appear instantly.** Files your AI agent writes into build-output folders — `dist`, `build`, `.next`, `coverage`, `target`, `vendor` — now show up in the File Explorer in real time, instead of only after a manual refresh or a project switch. When an agent scaffolds output, you see it the moment it lands. **Copy from the phone terminal.** Remote Control can now copy terminal text straight to your phone's clipboard, and tapping a project on the dashboard scrolls right to it — small things that make driving your dev machine from your phone feel less like a workaround. ![Remote Control phone terminal with the Copy Text button and a Copy / Visible / All toolbar for copying terminal output to the phone clipboard](https://1devtool.com/app-screenshots/06-remote-terminal-copy-text.png) We also fixed pasting into Claude on Windows losing the cursor, so your next keystrokes land in the prompt instead of disappearing, and made phone connections more reliable when a session reconnects. ## Try it Update to v1.30.0, open the Git Client on any project, and click the project name in the toolbar. Switch to another repo, check the face next to your commit, and scroll all the way back through the history — all without ever closing the window. The fewer detours between you and a clean commit, the more the tool stays out of your way. --- ## Send HTTP Requests and Query Your Database From Your Phone Source: https://1devtool.com/blog/check-apis-and-databases-from-your-phone Published: 2026-06-26 Tags: remote-control, mobile, http-client, database, release Remote Control's new Tools tab puts an HTTP client and a database client on your phone — send a request or run a query through your desktop without going back to your keyboard. You sent an agent off on a task and stepped away from your desk — coffee, lunch, the couch, the train. A few minutes later the question lands: *did that endpoint actually come back up?* Or *did the migration write the rows it was supposed to?* Until now, answering meant one of two things — walk back to your keyboard, or sit on the question until you did. 1DevTool's Remote Control already let you watch terminals, browse files, review an agent's diff, and even commit from your phone. But the moment you needed to *test* something — hit an API, run a quick query — the phone ran out of road. You could see that the work happened; you couldn't poke it to confirm it worked. ## What changed v1.29.0 adds a **Tools** tab to Remote Control. Open it on your phone and you get two clients that used to live only on your desktop: an **HTTP client** and a **database client**. Now you can send a real request or run a real query from wherever you are, and the call runs through your desktop workspace — same network, same saved connections, same project context. ![Remote Control on a phone showing the 1devtool-desktop project expanded to its terminals list and a Browse Files entry](/app-screenshots/remote-control-list-projects.jpg) ## How it works in practice ### Send an HTTP request without your keyboard Open **Tools → HTTP**. You pick a method — GET, POST, PUT, PATCH, DELETE, HEAD, or OPTIONS — type the URL, and fill in headers, auth, and a body type (JSON, text, XML, form-urlencoded, or form-data) the same way you would on the desktop. Then you tap send. The response comes back with everything you'd normally check by eye: the status code, how long it took in milliseconds, the body, and the headers — each on its own view, so a large JSON payload never buries the status line. A green `200 OK` in 1007 ms tells you the service is healthy before you've even thought about opening a laptop. ![Tools tab showing an HTTP request's 200 OK response in 1007 ms, with Body and Headers views and a formatted JSON payload](/app-screenshots/remote-control-http-response.jpg) You don't have to rebuild the request every time, either. Save it — globally, so it follows you across projects, or back to a specific project so the phone and your desktop stay in sync. The request you built at your desk this morning is one tap away from the couch tonight. ### Query a database from the same tab Flip the toggle to **Database** and the Tools tab becomes a SQL client. It lists the database connections you've already saved in 1DevTool, so you're not retyping a connection string on a phone keyboard. Tap one, test that it still connects, and load its schema to see which tables exist. From there you run a query and read the result inline — rendered as a table when the response fits one, or as raw output when it doesn't. Want to eyeball a table without writing SQL at all? Preview it directly. Checking whether a row landed, whether a job marked itself done, whether prod has the record you expect — that's now a thirty-second answer from your pocket. ![Tools tab in Database mode running a SELECT against the sites table, returning 12 rows with slug, name, and domain columns in 451 ms](/app-screenshots/remote-control-database-query.jpg) ### It respects who's allowed to act Reading logs is one thing; sending network requests and running database commands is another. The Tools tab knows the difference. HTTP and database tools require **operator** or **admin** access — the same permission tiers that already govern Remote Control. Hand someone a viewer link and they can follow along; only an operator can actually fire a request or run a query. The capability scales with how much you trust the person holding the phone, instead of being all-or-nothing. These tools sit alongside the rest of the redesigned phone experience — the Projects, Terminals, and Browser tabs, plus a cleaner chat-style terminal composer for prompting your agents — so testing an endpoint and nudging an agent now live in the same place. ![Remote Control terminal detail on a phone with AI output above the new chat-style composer and its mention, image, and attachment controls](/app-screenshots/remote-control-terminal-detail-and-terminal-input.jpg) ## Before vs after | When you're away from your desk | Before v1.29.0 | With the Tools tab | |---|---|---| | Check if an endpoint is up | Wait until you're back, or open a laptop | Tap a saved request, read the status and latency | | Confirm a migration wrote rows | Ask someone sitting at a keyboard | Run a SELECT and read the table inline | | Reuse a request you built earlier | Rebuild it from memory on a phone | Open the one you saved to the project | | Let a teammate test safely | Share full access or nothing | Operators act, viewers watch | ## Who gets the most out of this - **Solo developers and indie hackers** who are the entire on-call rotation. The "is it up?" question doesn't wait for you to sit down — and now neither does the answer. - **Anyone running long agent tasks.** You kick off a migration or a deploy script, walk away, and verify the outcome — endpoint healthy, rows written — from the same phone you're already watching the terminal on. - **Small teams with shared environments.** Operator and admin gating means you can hand out Remote Control access without handing everyone the keys to run arbitrary queries against your database. ## Try it Update to v1.29.0, open Remote Control on your phone, and tap the new **Tools** tab. Send a saved request or run a quick query and watch it execute through your desktop workspace. The next time the "did it actually work?" question hits while you're away from your keyboard, you'll have the answer before you've finished reaching for your laptop. --- ## Track AI Usage Without Leaving Your Workspace Source: https://1devtool.com/blog/track-ai-usage-live Published: 2026-06-26 Tags: ai-usage, agent-input, remote-control, release 1DevTool v1.28.0 puts Claude and Codex plan usage in the status bar, keeps unsent Agent Input drafts visible, and gives the phone remote a faster tabbed home. Before this release, checking whether an AI session was about to hit a plan limit meant breaking your flow. You might be watching Claude work through a long refactor, or running Codex through a Windows terminal session, and the only way to know where you stood was to leave the workspace and check somewhere else. That is exactly the kind of small context switch that turns into a missed warning. The same thing happened with prompts. You could start shaping a careful Agent Input message, close the overlay, switch projects, or inspect output, and the draft still existed, but it was easy to forget it was there. On your phone, Remote Control also had the pieces you needed, but moving between projects, terminals, and browser preview took more navigation than a small screen should require. ## What changed Now you can see AI plan usage, recover unsent prompts, and navigate the phone remote without leaving the work surface you are already using. ![AI usage popover showing Claude 5-hour and weekly limits from the status bar pill](https://assets.stoicsoft.com/posts/1devtool/track-ai-usage-live/ai-usage-status-pill.jpg) The headline change is a live usage pill in the status bar for AI terminals. When you focus a Claude or Codex terminal, 1DevTool shows the active agent, the current usage percentage, and a small ring for the secondary quota window when one is available. Click the pill and you get the full usage popover, including the 5-hour window, weekly limit, plan badge, reset timing, and a refresh control. ## How it works in practice ### You can watch quota without opening another page Start working in a Claude or Codex terminal as usual. The usage pill follows the focused AI terminal, so a shell tab stays clean and an AI tab shows the relevant account. Under the hood, the renderer resolves the terminal's declared agent kind, maps it to the quota provider, and asks for that agent only. That keeps the status bar useful without forcing every provider to refresh just because you changed focus. When you click the pill, the popover loads the bigger picture. You can compare every signed-in AI account that reports quota data, see the plan badge when the provider returns one, and refresh the selected account from the same panel. If you manage multiple Claude or Codex accounts, Settings, AI, Accounts also includes an opt-in "Auto-switch at" control. When enabled, 1DevTool can switch to a healthier saved account once the active account reaches your chosen threshold. ### You can return to an unsent prompt at a glance The Agent Input box now makes pending drafts visible even when the overlay is closed. If you typed a message, attached files, or pasted images but have not sent the prompt, the idle composer changes from "Type a message with Agent Input" to a preview of that draft. It shows the saved text when there is text, or the attachment count when the draft is mostly files. ![Agent Input idle composer preview below a running Claude terminal with the Cmd-I shortcut](https://assets.stoicsoft.com/posts/1devtool/track-ai-usage-live/agent-input-draft-preview.jpg) This matters when you are building a prompt slowly. You can inspect terminal output, jump to another panel, or close the overlay to get more screen space, then come back without trying to remember what you were about to ask. Click the composer or press Cmd-I or Ctrl-I, and the same draft is ready to finish. ### You can drive the phone remote from three obvious places Remote Control on your phone now opens into a home shell with three bottom tabs: Projects, Terminals, and Browser. Projects keeps the refreshed dashboard for choosing a workspace and opening project actions. Browser gives you the embedded preview path without making you drill through a project card first. The new Terminals tab is the biggest navigation improvement. It flattens terminals across projects into Needs review, Running, and Idle groups. Running AI sessions show elapsed time. Review-ready sessions get a badge on the bottom tab, so the phone can tell you when something needs attention even before you open the list. Tap a card and you land directly in that terminal. ## Before vs After | Workflow | Before | Now | | --- | --- | --- | | Check AI usage | Leave the workspace, inspect a provider page or account state, then return to the terminal | Read the live pill in the status bar and open the popover for quota windows and plan details | | Continue an unsent prompt | Reopen Agent Input and remember whether you had a draft | See the draft preview in the idle composer and continue it directly | | Review phone terminals | Open a project, scan its terminals, back out, and repeat for another project | Open the Terminals tab and scan Needs review, Running, and Idle across all projects | | Handle quota pressure | Notice a limit late and manually switch accounts | Opt into auto-switch for Claude or Codex accounts at a threshold you choose | ## Who benefits most Developers who keep long AI terminals running get the most immediate value. The status bar makes quota visible while the agent is still working, so you can plan a handoff or switch accounts before the session stalls. Anyone who writes careful prompts in stages also gets a smoother loop. The draft preview turns the idle composer into a reminder instead of a blank entry point, which is especially useful when a prompt includes file mentions or screenshots you do not want to rebuild. Remote Control users get a faster phone workflow. If you use your phone to check agents away from the desk, the bottom tabs and Terminals overview reduce the number of taps between "something finished" and the exact terminal that needs your attention. ## Try it Update to 1DevTool v1.28.0, focus a Claude or Codex terminal, and watch the status bar while you work. Open Agent Input, type a draft, close it, and confirm the idle composer keeps the prompt visible. If you use Remote Control, open the phone UI and switch between Projects, Terminals, and Browser from the new bottom tab bar. --- ## Switch AI Agents Mid-Task — and Pick Up Sessions From Any Terminal Source: https://1devtool.com/blog/switch-ai-agents-mid-task Published: 2026-06-24 Tags: ai-agents, gitlab, terminal, sessions Switch the AI agent on any terminal tab without losing the conversation, pull in sessions running in iTerm or Ghostty, and publish straight to GitLab. You're deep in a session with one coding agent. The plan is mostly right, but it's stuck on a detail, and you have a hunch a different model would crack it in one shot. So you do the math: kill the session, open a fresh one with the other agent, re-paste the context, re-explain everything you already tried, and hope you didn't leave out the part that mattered. The model switch costs you five minutes and most of your momentum. Or this one: you kicked off a long agent run in iTerm last night, closed your laptop, and now you want it back — but inside 1DevTool, where your project, files, and terminals already live. The session is right there, running in another terminal app, with no clean way to bring it home. v1.27.0 closes both gaps. Your AI session is no longer tied to the agent that started it or the terminal that's hosting it. ## What changed You can now switch the AI agent on any terminal tab without losing the conversation, and you can pick up agent sessions running in other terminal apps — iTerm, Ghostty, VS Code, and more — and continue them inside 1DevTool. This release also adds first-class GitLab support and a PowerShell terminal. ## How it works in practice ### Change the agent on a terminal tab Right-click any AI terminal tab and open the **Change AI** submenu. Pick a different agent — Claude, Codex, Gemini, Amp, OpenCode, or Qwen — and 1DevTool launches it in place. Before the old agent closes, its last visible prompt is read straight off the screen and seeded into the new session, so the thing you were just asking carries over instead of evaporating. ![Terminal tab right-click menu with the Change AI submenu open to switch the running agent on that tab](/app-screenshots/change_session_into_another_ai_agent.jpg) Trying a second opinion now costs one click, not a context-rebuilding ritual. If Codex stalls on a refactor, hand the same prompt to Claude and see who does better — on the same tab, in the same working directory. ### Switch agents from the Resume panel too The same Change AI control lives in the Resume panel, next to every saved session. Browse your history, find the session you want to revisit, and relaunch it with a different agent right from the card — handy when you already know which past conversation to continue but want a different model driving this time. ![Resume AI Sessions panel with the Change AI dropdown open, listing Codex, Gemini CLI, OpenCode and preset agents](/app-screenshots/change_ai_in_resume.jpg) ### Continue a session that's running in another terminal Open the Resume panel and you'll see a new **Running In Another Terminal** group at the top. 1DevTool scans for Claude, Codex, Gemini, and OpenCode sessions running live outside the app — in Ghostty, iTerm, Apple Terminal, VS Code, Cursor, WezTerm, kitty, Warp, and others — and lists them separately so you can tell them apart from your own tabs. Each card shows which app owns the session and its working directory, and the list refreshes every five seconds so it stays honest as sessions start and stop. Click **Continue here** and 1DevTool closes the external agent process and reopens the session inside the app with a full resume — the whole conversation comes with it. ![Resume panel Running In Another Terminal section showing Codex sessions in iTerm and Ghostty, each with a Continue here button](/app-screenshots/detect_running_ai_in_another_terminal.jpg) ### Publish and sync with GitLab GitLab is now a first-class git host alongside GitHub. Add a GitLab Personal Access Token in **Settings → Git** and 1DevTool verifies it, showing the username, avatar, and namespace it belongs to — so you know exactly which account will act on your behalf before anything is pushed. ![Settings Git panel adding a GitLab Personal Access Token, verified against the GitLab username and namespace](/app-screenshots/gitlab-add-account.jpg) From there the Publish Repository dialog lets you choose GitLab as the destination, pick a namespace (your personal account or any group you can access), and set visibility — public, internal, or private. If your token is missing the `api` scope, you get a clear warning up front instead of a failed push and a cryptic error. Projects backed by GitLab repos then push, pull, and track branches exactly like GitHub ones, and self-hosted GitLab instances work too. ![Publish Repository dialog with the GitLab tab selected, choosing a namespace and visibility before creating the repo](/app-screenshots/gitlab-push-repo.jpg) ### One more: PowerShell terminals The Add Terminal dialog now lists PowerShell next to Bash and Zsh in the Shells tab. Windows users — and anyone who prefers PowerShell — can open one with a single click and run it in the same grid, layouts, and session persistence as every other terminal. ## Before vs After | Task | Before v1.27.0 | After v1.27.0 | |---|---|---| | Try a different agent on the same task | Kill the session, open a new one, re-paste context | Right-click the tab, choose Change AI; last prompt carries over | | Resume an agent running in iTerm or Ghostty | No way to bring it into 1DevTool | Resume panel, Continue here | | Push a repo to GitLab | Drop to the CLI or a browser | Publish Repository, GitLab tab | | Open a PowerShell shell | Not available | Add Terminal, Shells, PowerShell | ## Who benefits most - **Multi-agent developers** who keep Claude, Codex, and Gemini in rotation — switching between them is now a tab action, not a restart. - **Developers who live between terminals** — start a run wherever's convenient and pull it into your workspace when you sit down. - **GitLab teams** who were locked out of 1DevTool's git workflows until now. ## Try it Update to v1.27.0, right-click a terminal tab, and hand your current prompt to a different agent. Then open the Resume panel and look for sessions running in your other terminals — you can pull them home in one click. [Download 1DevTool](https://1devtool.com/download) · [View the full changelog](https://1devtool.com/changelog) --- ## Slash Commands, Skills, and Photos — Now in the Remote Terminal on Your Phone Source: https://1devtool.com/blog/slash-commands-and-photos-from-your-phone Published: 2026-06-23 Tags: remote, mobile, ai-agents, terminal Run slash commands, drop in Codex skills, mention files, and attach photos to your AI agent — all from the remote terminal on your phone. You're away from your desk when the agent you left running needs a nudge. You pull up the remote terminal on your phone — and you can type a message, but that's about it. You can't run `/compact` to tidy the context, you can't reach for a Codex skill, and the photo you just took of the broken UI is useless because there's no way to hand it over. The agent at your desk can do all of this; the phone in your hand can't. v1.26.1 brings the remote terminal up to parity with the things you actually do at your keyboard. ## What changed In the remote terminal you can now type `/` to run an agent's slash commands, `$` to drop in a Codex skill, and `@` to mention project files — and you can attach a photo straight from your phone and have the agent read it. The three pickers finally coexist cleanly, so reaching for a command doesn't trip over a file mention. ## How it works in practice ### Run slash commands with `/` Type `/` in the remote terminal and the agent's command menu appears, just like it does at your desk. Run `/compact` to shrink a bloated context, `/model` to switch models, or any other command the agent exposes — from your phone, mid-walk, without waiting until you're back. ### Drop in a Codex skill with `$` Type `$` to browse your Codex skills and drop one straight into the prompt. The capability you'd normally pick from the desktop is now a tap away on mobile. ### Mention files with `@` The `@` file-mention typeahead is still there, and now all three pickers — `$` skills, `/` commands, and `@` files — work side by side without fighting over the same keystroke. You can line up a skill, a command, and a file reference in one prompt. ### Send a photo to your agent Attach an image in the remote terminal and it's delivered to the agent as a real file it can read and reason about. Snap a screenshot of a layout bug or a whiteboard sketch and send it over; large photos are resized automatically before upload, so they go through quickly instead of stalling the connection. ![Remote terminal on a phone attaching image files to the AI agent, shown as IMG_8772.png and a download chip above the command input](/app-screenshots/attach_image_from_phone_remote_terminal.png) ## Before vs After | From your phone | Before v1.26.1 | After v1.26.1 | |---|---|---| | Run an agent command | Type the raw text and hope | `/` opens the command menu | | Use a Codex skill | Not possible | `$` browses and inserts skills | | Mention a project file | Worked, but clashed with other pickers | `@` coexists with `/` and `$` | | Share a screenshot | No way to attach | Attach a photo; auto-resized and delivered | ## Who benefits most - **Developers who kick off long agent runs** and want to steer them from anywhere — compact the context or switch models without being at the machine. - **Anyone debugging visual issues on the go** — a photo of the problem is often faster than describing it in words. This release also fixes the attachment spinner getting stuck and dropping the connection, SSH terminals and remote folders failing to open on Windows, and the companion mobile app being unable to pair — so the remote workflow holds up end to end. ## Try it Open 1DevTool's remote terminal on your phone, type `/` to pull up the command menu, then attach a photo and ask your agent about it. The things you do at your desk now travel with you. [Download 1DevTool](https://1devtool.com/download) · [View the full changelog](https://1devtool.com/changelog) --- ## Control Your Dev Machine From Your Phone Source: https://1devtool.com/blog/control-your-dev-machine-from-your-phone Published: 2026-06-21 Tags: remote-control, mobile, source-control, ai-agents, notifications Remote Control now lets you browse and read project files, review diffs and push commits, mention files in agent prompts, and get a notification the moment a task finishes — all from your phone. You wrapped up at your desk, handed an agent a long-running task, and walked away. Now you're on the couch — or on the train — and the question gnaws at you: *is it done yet? Did it touch the right file? Did it break anything?* Until now, the honest answer was "I'll find out when I get back to my machine." Your project lived on one computer, and so did you. That gap is where work stalls. You can't read the file the agent just rewrote. You can't glance at the diff before it goes stale in your memory. You can't commit the good change while it's fresh, and you definitely can't tell — without staring at the screen — the exact moment a command finishes or an agent goes idle waiting for your input. ## What changed Remote Control is no longer just a live terminal on your phone. In v1.26.0 it becomes a real, two-way window into your project: you can **browse and read your files, review and ship Git changes, drop file mentions into an agent prompt, and get a notification the instant something finishes** — all from the phone in your pocket, while your machine keeps doing the heavy lifting at your desk. Open any project in the Remote Control dashboard and you'll see two new entries sitting right under the terminal list: **Browse Files** and **Source Control**. ![Remote Control project dashboard showing the new Browse Files and Source Control entries below the terminal list](/app-screenshots/file_viewer_and_git_control_in_remote_control.jpg) ## How it works in practice ### Read any file — markdown, code, or images Tap **Browse Files** and you get the same project tree you have at your desk: folder navigation, breadcrumbs, and a project-wide **Search files by name** box for when you'd rather jump straight to `SEO_PLAN.md` than click through three folders. Open a file and it renders the way it should. Markdown drops into a distraction-free reader — not a wall of raw `##` and backticks, but formatted headings, lists, and links you can actually read on a small screen. Code opens with syntax highlighting. Images preview inline. Because you're reading on a phone, the reader gives you the knobs that matter: pick a **Dark**, **Sepia**, or **Light** theme, nudge the text size up or down, and 1DevTool remembers your choice for the next file you open. If you want the source instead of the rendered view, **Raw** is one tap away. ![Remote Control markdown reader displaying a file with Dark, Sepia and Light theme options and adjustable text size](/app-screenshots/reader_mode_markdown_in_remote_control.jpg) And if you spot a typo or a one-line fix while you're reading? With operator access you can edit the file in place and save it straight back to the project — no terminal, no detour. ### Review and ship changes from Source Control This is the part that closes the loop on agent work. Tap **Source Control** and you see your current branch, every changed file grouped by status — **Staged** and **Changes** — and a tap on any file opens its diff. You can read exactly what your agent did to the codebase on the live terminal stream, then check the diff to confirm it's what you wanted. When it is, you don't have to wait until you're back at your desk to capture it. With operator access the action bar gives you **Commit**, **Pull**, and **Push** right there. Write a message in the commit composer — it stages all changes — tap **Commit all changes**, then **Push**. The change is in your remote before the moment passes. (And if the working tree is clean, it tells you so plainly instead of leaving you guessing.) ### Mention files while prompting an agent Prompting an agent from your phone used to mean either typing out full paths by hand or settling for vague instructions. Now, type `@` in the remote terminal and a file typeahead pops up, filtering your project as you type — so `@seo` narrows to the files you mean in a couple of keystrokes. Prefer to browse? Open the full file picker sheet, search or navigate the whole project, and insert a mention from there. Either way the agent gets a precise `@path/to/file` reference instead of a hand-typed guess — so prompting from the couch is as exact as prompting at your desk. ![Phone terminal showing the @-mention file typeahead filtering project files while prompting an agent](/app-screenshots/mention_file_in_remote_control_terminal.PNG) ### Know the moment it's done The whole point of handing work to an agent and walking away is that you *don't* want to babysit it. But you also don't want to check back ten times for nothing. So now your phone tells you when something actually happens: a terminal command finishes, or an AI agent goes idle waiting for you. The alert reaches you three ways, depending on where you're looking. An in-app banner slides in at the top while you're using Remote Control. A bell in the header keeps an unread count. And when the page is in the background — phone locked, app switched away — a native notification reaches you anyway. Tap it and you land directly in the exact terminal that triggered it, ready to read the result or send the next instruction. ![Remote Control notifications sheet showing an Agent is idle - waiting for you alert with Clear and Close actions](/app-screenshots/notification_in_remote_control.PNG) ## Before vs after | When you're away from your desk | Before v1.26.0 | With v1.26.0 | |---|---|---| | Read the file an agent just changed | Wait until you're back at the machine | Browse Files → open it in the reader | | Check what the agent actually did | Trust the terminal scrollback | Open Source Control → tap the file for its diff | | Capture a good change | Hope nothing overwrites it before you return | Commit and push from your phone | | Point an agent at a specific file | Type the full path by hand, or guess | Type `@` and pick it from the typeahead | | Know a task finished | Keep checking the screen | Get a banner, a bell, or a native notification | ## Who benefits most **If you lean on AI agents for long-running work**, this is the release that lets you actually leave the room. Kick off the task, pocket your phone, and get pulled back only when the agent finishes or needs you — then review the diff and ship it without sitting back down. **If you context-switch between rooms, meetings, and a commute**, your project stops being chained to one desk. A five-minute gap is now enough time to read a file, approve a change, and push it. ## Try it Update to v1.26.0, open Remote Control, and pair your phone with your machine. Then walk away from your desk on purpose — start an agent, leave the room, and let your phone tell you when there's something worth looking at. The work keeps moving whether or not you're sitting in front of it. [Download 1DevTool](https://1devtool.com/download) and put your dev machine in your pocket. --- ## Keep Notes On The Terminal Where The Work Happened Source: https://1devtool.com/blog/keep-notes-on-the-terminal Published: 2026-06-20 Tags: terminals, sticky-notes, productivity, v1.25.4 v1.25.4 lets you pin sticky notes directly to terminal sessions and reopen those notes later from the app-wide Notes library in the header. You notice something important in a terminal, but the terminal is the worst place to treat that thought carefully. It scrolls. It refreshes. It gets replaced by the next agent response, the next build log, or the next command output before you have decided what to do with it. So the usual workaround is awkward. You copy the text into another app, leave yourself a half-written todo in a markdown file, or keep the terminal open longer than you want because you do not trust yourself to find that context again later. That friction is small each time, but it adds up across every debugging session, AI handoff, and shell workflow. ## What changed In v1.25.4, you can place **sticky notes directly on a terminal session** and reopen all of those notes later from the app-wide **Notes** library in the header. You no longer have to move terminal context somewhere else just to keep it. ![Terminal pane with the notes button active and a sticky note overlay attached directly to that terminal session](https://github.com/user-attachments/assets/d583bcf7-5634-436f-91d7-8a5d919dfd1a) ## How it works in practice ### Add a note without leaving the terminal you are working in Every terminal pane now has a notes control in its toolbar. It sits alongside the other pane controls, before fullscreen, so adding a note is part of the same workflow as monitoring output or adjusting the layout. Click the button and a sticky note layer opens directly on that terminal. Click again and the note layer hides, while the note itself stays tied to that session. That matters when the terminal is not just a shell, but a working conversation with Claude, Codex, or another agent. You can leave yourself a reminder next to the exact terminal where the issue appeared instead of pushing that context into a separate system and hoping you reconnect it later. ### Keep terminal-specific context attached to the right session The note does not become a generic project note floating somewhere else in the app. It stays bound to the terminal it came from. If one terminal is running a build, another is holding an AI review, and a third is a shell for cleanup work, each one can carry its own note context. That keeps your reminders aligned with the session that created them. This is especially useful when the terminal output is valuable but not yet actionable. You might want to draft a follow-up prompt, mark a suspicious log line, or note a command sequence to retry after another step finishes. The terminal stays live, and the note stays local to that live work. ### Open the full notes library from the header when you need the bigger picture The main header now includes a **Notes** button that opens the Sticky Notes list directly. That puts notes beside Prompt History in the same high-level workflow: capture context where it happens, then review it globally when you need to search, filter, or revisit older work. Inside the Sticky Notes view, you can search notes and filter them across projects and sources, including terminal notes. That turns terminal annotations from temporary scratch space into a reusable context layer you can actually return to later. ![Sticky Notes library open from the header Notes button, showing searchable notes grouped across terminal and file sources](https://github.com/user-attachments/assets/54029338-7f48-422e-a3df-4d61dfa20ef9) ### Scroll inside the note without fighting the terminal behind it The workflow polish in this release matters too. When Agent Input and terminal notes are open at the same time, scrolling inside the note stays inside the note instead of hijacking the terminal behind it. The note button also highlights when notes are visible, so you can tell at a glance which terminal currently has a note layer open. That sounds small, but it is the difference between a feature you try once and a feature you keep using. Annotation tools only help if they feel native to the surface they live on. ## Before vs After | Workflow | The old way | With v1.25.4 | |---|---|---| | Save a thought from terminal output | Copy it into another app or leave the terminal open | Click the notes button and keep the note on that terminal | | Revisit notes from old terminal work | Remember where you wrote them or search manually elsewhere | Open the Notes library from the header and filter by source | | Mark which terminal has annotations | Scan manually and guess | The notes button highlights when that terminal's notes are visible | | Scroll a note while using terminal overlays | Risk moving the terminal instead of the note | The note keeps its own natural scroll behavior | ## Who benefits most Developers running multiple AI terminals benefit first, because terminal context is often transient and session-specific. A note attached to the exact Codex or Claude terminal where an issue appeared is more useful than a detached task in another tool. People who use terminals for debugging benefit too. A build error, deployment quirk, or command sequence often needs a short reminder more than a full document. Terminal notes make that lightweight capture possible without forcing a context switch. ## Try it Update to v1.25.4, open a terminal you are actively using, and click the notes button in the pane toolbar. Add one reminder you would normally have thrown into another app. Then open the header Notes view and confirm that the note is now part of your wider notes library. That is the real value of this release: terminal context stops being disposable. --- ## Save Your Terminal Sessions Before You Quit 1DevTool Source: https://1devtool.com/blog/save-terminal-sessions-before-quitting Published: 2026-06-18 Tags: terminals, git, session-save, v1.25.3 1DevTool now asks whether to save or discard active terminals when you quit, and Git History adds commit actions that reduce the number of side trips to external tools. You close the app at the end of a long session and realize too late that one terminal still had the useful output, another had the exact working directory you needed tomorrow, and a third was still doing work you meant to keep alive. That kind of loss usually happens in the gap between intent and consequence. You meant to close the app. You did not mean to throw away the state of every terminal attached to it. ## What changed In v1.25.3, 1DevTool asks whether you want to **save or discard active terminal sessions before quitting**. If you save, the app keeps the terminal tabs, working folders, and recent output so the next launch feels like a continuation instead of a reset. If you discard, the sessions are shut down cleanly instead of being left ambiguous. ![Quit dialog asking whether to save active terminal sessions before closing 1DevTool](https://github.com/user-attachments/assets/040f7de8-ba82-445a-bdcc-370cca4f5bf3) ## How it works in practice ### Make quitting a deliberate decision instead of a gamble When you quit with active terminal sessions, 1DevTool opens a dialog with three explicit choices: **Save & Quit**, **Quit Without Saving**, or **Cancel**. The dialog explains what the save path preserves and what the discard path stops. You no longer have to remember whether this specific close action will preserve the state you care about. ### Resume the work that actually mattered Choosing **Save & Quit** preserves the terminal tabs, their working folders, and the recent output you were using as context. That matters most when the app is serving as a multi-terminal workspace for AI agents, build processes, and project-specific shells. Reopening the app stops feeling like starting over from a cold terminal grid. ### Inspect old commits without leaving the History panel The same release makes Git History much more actionable. Commit detail now shows stacked author avatars, a one-click full-hash copy button, an external link to open the commit on GitHub, GitLab, or Bitbucket, total additions and deletions in the header, and a right-click file menu inside the History tab. That menu lets you open the file in the IDE, open it on the remote, reveal it in Finder or Explorer, or copy its path straight from commit history. ![Git History file context menu offering open in IDE, open in Git remote, reveal in Finder, and copy path actions](https://github.com/user-attachments/assets/b5e24bd3-51e0-451c-bcc1-7889c3754d6c) ## Before vs After | Workflow | The old way | With v1.25.3 | |---|---|---| | Quit with several active terminals | Hope the app preserves what you wanted | Choose Save, Discard, or Cancel explicitly | | Recover terminal context next launch | Recreate tabs and re-find output manually | Reopen the app with saved tabs, folders, and recent output | | Inspect a file from an older commit | Copy the path by hand or switch to an external tool | Right-click the file inside History and act immediately | | Share or inspect a commit hash | Re-select text or open another app | Click one button to copy the full hash or open the remote page | ## Who benefits most People using 1DevTool as their primary terminal workspace benefit first, because terminal state is the thing they are most likely to lose by accident. Developers reviewing commit history also benefit, because the History tab now supports real next steps instead of just passive reading. ## Try it Update to v1.25.3, open a few meaningful terminals, and quit the app once on purpose. The moment you see a clear save-or-discard choice instead of a blind shutdown, the feature makes sense. --- ## Pin Comments On Any Web Page And Send Them To Your AI Agent Source: https://1devtool.com/blog/comment-on-web-pages-send-to-ai Published: 2026-06-14 Tags: browser, ai-agents, comments, feedback, v1.25.0 Drop numbered comments directly on any page in the browser panel, then bundle them into a single AI prompt with element and position context attached. You're QA'ing a teammate's pull request in the built-in browser. The pagination is wrong on the second page, the empty-state card overflows on mobile, and the gradient in the header has the wrong stop. Three things, three different spots on the page. So you do what you always do: alt-tab to your AI terminal, type "the pagination is broken — see screenshot 1", paste the screenshot, type the next note, paste again. By the third one you've already lost track of which screen you were describing. The agent gets a wall of vague text and a few disconnected images, and answers with a vague fix that addresses one issue and misses the other two. ## What changed In v1.25.0 you can drop **numbered comments directly on the page** — element-aware, position-aware, page-aware — and send the whole bundle to an AI agent as a single prompt. The agent receives every comment with the element it points to, where on the page it sits, which route it was made on, and the screenshots and console state alongside. You stop describing the bug. You point at it. ![Browser panel in comment mode with a numbered pin attached to a highlighted page element, ready for a note](/app-screenshots/1devtool-browser-comment-mode.jpg) ## How it works in practice ### Turn on comment mode and start pinning Open the browser panel, click the comment toggle (💬) in the toolbar — the icon also has the keyboard shortcut **C**. The page goes into comment mode: hover any element and it highlights, click and you drop a numbered pin with a popover for the note. Each pin captures the element it's attached to, its position, the page URL, and the screen size so a fix can later be reproduced on the exact viewport you saw. You can drop several comments on the same page, navigate to another route, and keep going. The pins stick. The whole session is yours until you send or clear it. ### Review and triage in the Comments tab When you're done pinning, switch to the **Comments** tab. Notes are grouped by page so you can see "five things wrong with /pricing, two with /dashboard" at a glance. Each one has **Jump to comment**, a selection checkbox, and a delete control. You can prune duplicates, demote nitpicks, and pick exactly the set worth sending. ![Comments tab grouped by page showing numbered notes with jump-to and delete controls](/app-screenshots/1devtool-comment-list-context.jpg) ### Bundle everything into one AI prompt Hit **Send to AI Terminal**. The dialog packages the comments you selected — each one with its anchor element, its location on the page, and the page URL — along with the browser's console logs, network requests, and screenshots. Add a top-level instruction ("fix these three layout bugs"), pick the terminal, and send. What the agent receives isn't a paraphrase of what you saw. It's element-aware, position-aware, route-aware feedback grouped by page. The agent can read it the same way you'd read a structured bug report. ![Send to AI Terminal action bundling selected page comments into a single agent prompt with element and position context](/app-screenshots/1devtool-comment-to-prompt.jpg) ## Before vs After | Workflow | The old way | With v1.25.0 | |---|---|---| | Spot 3 bugs on a live page | Screenshot each, alt-tab, type vague descriptions | Click comment mode, drop 3 pins, type one note each | | Tell the agent *where* the bug is | "the second card from the top, sort of" | Element ref, x/y position, page URL — sent automatically | | Group feedback across routes | Manually note "this is from /pricing, this from /home" | Comments grouped by page in the panel | | Trigger the fix | One bug per prompt, hope for the best | One prompt with all the structured context attached | ## Who benefits most **Developers QA'ing their own UI work.** Instead of describing CSS bugs in prose, pin them. The agent fixes the exact element you pointed at, not its best guess. **Designers reviewing implementation.** Drop pins where the build diverged from the design and send the whole batch to whoever's iterating — without leaving the app you're already looking at. **Anyone reviewing AI agent output.** When the agent rebuilds a page and the result needs three corrections, the round trip used to take five messages. Now it's one. ## Plus: Reader Mode and Sticky Note Settings v1.25.0 also gives Reader Mode its own settings panel — set your preferred background (Sepia, White, Dark, Green, or a custom color), font, font size, and content width once in **Settings → IDE** and it applies wherever you read. Sticky notes get the same treatment: default color, font, font size, and size, so every new note matches how you actually like to work. Old preferences carry over automatically on first upgrade. ![Article displayed in Reader Mode with a sticky note overlaid using the user's chosen color and font](/app-screenshots/note_in_reader_mode.jpg) ## And: First-Run Onboarding For people opening 1DevTool for the first time, v1.25.0 adds a guided welcome card, a dismissible Get Started checklist that ticks itself off as you do the steps, and a smarter empty-terminal screen with one-click launch chips for Claude, Codex, Gemini, Amp, OpenCode, and Bash — the chips dim the agents that aren't installed and show a copy-paste install hint, so nobody's first 1DevTool moment is "command not found". ## Try it Update to v1.25.0, open the browser panel on whatever app you're building, and press **C**. Drop three pins. Send them. The first time you get an AI fix that addresses all three at once — with the right elements — is the moment this clicks. --- ## Drive Your 1DevTool Desktop From Anywhere With Cloudflare Tunnel Source: https://1devtool.com/blog/remote-control-from-anywhere Published: 2026-06-11 Tags: remote-control, cloudflare-tunnel, mobile, remote-terminals, v1.24.0 Cloudflare Tunnel routes Remote Control over a public URL, so your phone can reach your desktop from any network — and the phone dashboard can now start new terminals on its own. Remote Control used to require you and your phone to be on the same Wi-Fi. Tethered to your desk at the office, fine. Working from a coffee shop, fine. Stuck on hotel Wi-Fi that puts every device on its own client-isolated network, watching tests run on your laptop back at the apartment and unable to tap a single button — not fine. The workaround was port-forwarding on a router you didn't own, or a VPN, or just giving up and running back to the laptop. None of those are realistic when the build's already running and you just want to kick off the next agent from your phone in the airport. ## What changed In v1.24.0 Remote Control can route over a **Cloudflare Tunnel** that 1DevTool installs and manages for you. Open Settings → Remote, pick **Cloudflare Tunnel**, and the QR code your phone scans points at a public URL instead of a LAN address. Pair once, then control your desktop from anywhere — LTE, hotel Wi-Fi, somebody else's network — without router config or a VPN. The same release also adds **Add Terminal** to the phone dashboard, so once you're paired remotely you don't just watch terminals: you start new ones. ![Remote Control settings showing the Local Network and Cloudflare Tunnel modes side by side](/app-screenshots/remote_control_settings.jpg) ## How it works in practice ### Switch from LAN to Cloudflare Tunnel In **Settings → Remote**, the connection mode now has two pills: **Local Network** and **Cloudflare Tunnel**. Pick the tunnel. The first time, 1DevTool downloads `cloudflared` directly from the app — there's a progress bar, signature verification, and start/stop controls. The binary lives in app data and you can remove it from the same panel; there's no global install to clean up later. Once the tunnel starts, the pairing URL and QR code automatically switch over to the public address. Stop the tunnel and they switch back to your LAN address. You don't have to regenerate anything. ### Pair from the phone, deliberately The pairing flow only completes after you tap **Connect** on the phone — opening a QR preview in a camera app or scanner no longer triggers a pair on its own. If you start in an in-app browser (Instagram, Slack, Messages), the pairing page now stays valid while it nudges you to open the link in Safari and explains why a real browser keeps you signed in across reloads. The credentials are remembered per server URL, so refreshing the page or coming back later doesn't force a fresh pair. ### Add terminals from the phone The phone dashboard now shows each project with its real avatar and emoji — not just a color dot — and every project card has an **Add Terminal** button. Tap it and you get a mobile sheet for picking what to launch: **Claude, Codex, Gemini, Amp, OpenCode**, plain **bash / zsh / PowerShell**, or any saved command preset you've defined. The new terminal opens immediately, streams live output, and lets you type without going back to the desktop. ![Phone remote dashboard with project cards showing avatars and an Add Terminal button](/app-screenshots/mobile_remote_list_projects.jpg) The status row at the top of the dashboard makes your access level explicit — Viewer, Approver, Operator, or Admin — and the Add Terminal sheet tells you up front when starting a process needs Operator or Admin permission. You stop tapping buttons and waiting for ambiguous "nothing happened" failures. ## Before vs After | Scenario | The old way | With v1.24.0 | |---|---|---| | Connect from hotel Wi-Fi or LTE | Port-forward, VPN, or give up | Pick **Cloudflare Tunnel**, scan the new QR code | | Install `cloudflared` | brew, manual download, PATH | App downloads, verifies, and starts it for you | | Open a new terminal from your phone | Couldn't — only watch existing terminals | Tap **Add Terminal** → pick an agent or shell | | Pair from a Messages preview | Pair started silently and burned the link | Pair only triggers after you tap **Connect** | | Lose pairing after a refresh | Re-scan every time | Credentials saved per server URL | ## Who benefits most **Anyone running long agent jobs on a desktop they're not sitting at.** Kick off a Codex refactor on the office machine, drive to lunch, watch progress on your phone over LTE, and start the next terminal without going back. **Developers on hotel or conference Wi-Fi.** Networks with client isolation kill LAN-only remote control. The tunnel doesn't care about the network topology. **Anyone whose phone uses a different network than their laptop.** Carrier 5G on the phone, Wi-Fi on the laptop — the tunnel bridges them cleanly with no router config. ## Try it Update to v1.24.0, open **Settings → Remote**, flip to **Cloudflare Tunnel**, and let 1DevTool install `cloudflared` for you. Scan the QR with your phone from anywhere — not just your home Wi-Fi. Then tap **Add Terminal** on a project and watch a remote agent start from your pocket. --- ## Stop Switching Tools to Search Your Files: VS Code-Style Search Is Now in the File Explorer Source: https://1devtool.com/blog/vscode-style-search-file-explorer Published: 2026-06-10 Tags: file-search, file-explorer, elixir, terminal 1DevTool's file explorer now offers full-text search with case-sensitive, whole-word, and regex toggles, include/exclude glob patterns, and direct-to-line jumps — plus Reveal in Finder from terminal output and Elixir language support. Finding a string in your codebase means remembering where you put things. When you cannot remember — when you know something exists somewhere but not the exact file — the file tree is no help. Filename search tells you nothing about what is *inside* those files. So you open another window, start another search tool, paste in the term, wait for indexing, then copy the path back into 1DevTool to do anything useful with it. That context-switch compounds across a whole day: stack traces, error messages, grep results, build output — all of it contains file paths and class names you need to locate. Flipping between tools to act on them is friction that accumulates. ## You no longer need a separate search tool The file explorer now includes full-text search that works the way you would expect from VS Code or JetBrains. Type a term, see every match across your project — not just filenames — and click any result to open the file at exactly the line where the match lives. ![File explorer search panel open with include and exclude glob pattern input fields and regex toggle buttons (Aa, ab, .*) showing 451 results across 22 files for the query traefik with match snippets](/app-screenshots/search_files_include_exclude.jpg) ## How it works in practice ### Tighten your search without leaving the search bar Three compact toggle buttons sit directly inside the search bar: - **Aa** — case-sensitive matching. `Component` no longer matches `component`. - **ab** — whole-word matching. `use` no longer matches `reuse`. - **.*** — regex. Full regular expression syntax to match patterns instead of literals. You can combine all three. A whole-word, case-sensitive regex search is two clicks from a plain text match — no separate settings panel to open. ### Scope results with glob patterns Two fields appear below the search bar: **Include** and **Exclude**. Type `*.ts, src/**` in Include to search only TypeScript files under `src/`. Type `**/*.log, dist, coverage` in Exclude to skip those paths. The default exclude list — `node_modules`, `.git`, `dist`, `build`, `.next`, `.cache` — is pre-filled and togglable with a single click. When you need to search inside one of those folders, turn the default off. Results update as you adjust the patterns, so you can narrow scope interactively without restarting the search. ### Jump to the exact matching line Clicking a filename in the results opens the file at the top. Clicking a specific result row — the line with the code snippet — opens the file and scrolls the editor directly to the match. You land on the line, not somewhere near it. ### A panel that stays out of the way The search panel auto-expands when you focus the field and collapses back to a single-line bar when you clear the query and move focus. It does not compete with the file tree for vertical space when you are not searching. ## Reveal any file path in your filesystem from the terminal When a file path appears in terminal output — a stack trace, a build error, a log line — right-clicking it now shows **Reveal in Finder** (macOS), **Show in Explorer** (Windows), or **Show in Files** (Linux). ![Context menu over a selected file path in 1DevTool terminal output showing Copy, Send to AI, Open in Editor, and Reveal in Finder options](/app-screenshots/reveal_in_folder.jpg) The option appears both in the text-selection context menu and in the link-hover menu for paths that are automatically linked. You do not need to copy the path or navigate Finder manually — the containing folder opens directly from where you spotted the reference. This turns every file path in terminal output into a navigation shortcut. When a build error names a config file, a log line names a module, or a test failure names a fixture — one right-click gets you to the folder. ## Elixir projects now look the way they should `.ex` and `.exs` files get a dedicated purple **EX** badge in the file tree and full Monaco syntax highlighting in the editor — keywords, strings, module names, and sigils are coloured correctly without any setup. ![1DevTool editor showing an Elixir mix.exs project with syntax highlighting active and a purple EX badge visible next to the filename in the file tree sidebar](/app-screenshots/Elixir_syntax_highlight.jpg) Phoenix and mix projects now read the same way a JavaScript or Python project does in 1DevTool: files are instantly identifiable by icon, and code is readable the moment you open it. ## Before vs After | Task | Before v1.23.4 | After v1.23.4 | |---|---|---| | Find a class name across the project | Switch to a separate search tool | Search directly in the file explorer | | Filter out noise from search results | No built-in exclude | Default exclude list, togglable per search | | Navigate to a match | Open file, scroll manually | Click the result row — land on the line | | Open a folder from a path in terminal output | Copy path, open Finder, navigate | Right-click the path → Reveal in Finder | | Work in an Elixir project | Plain text, no file icons | Syntax highlighting, EX badge | ## Who benefits most **Backend developers** who trace errors through stack traces and log output — every file path in your terminal is now a navigation shortcut, and every class name reference is a searchable term that lands you exactly where the bug lives. **Polyglot projects** mixing TypeScript, Python, and config files — glob-based include/exclude lets you scope a search to the language or directory tier you are working in, so results stay relevant instead of noisy. **Elixir developers** who have been opening Phoenix projects in 1DevTool but working around the lack of syntax support — that gap is closed. ## Try it Update to v1.23.4 from the update banner or download from 1devtool.com. The search panel lives in the file explorer — click the magnifying glass or use your configured search shortcut to open it. --- ## Stop Describing UI Bugs in Words — Draw on Your Screenshots Instead Source: https://1devtool.com/blog/annotate-screenshots-before-ai Published: 2026-06-07 Tags: ai-agents, screenshots, annotations, ai-productivity 1DevTool now lets you draw arrows, add text, and highlight areas on attached images and screenshots directly in the agent input overlay before sending them to an AI agent. You attach a screenshot of a broken layout to your AI agent and type: "The button in the top right, below the header, next to the search icon — it has the wrong padding." The AI looks at the image, reads your description, and flags three different buttons that could match. You go back and forth twice before it fixes the right one. Describing a UI element in words when you can see it in a screenshot is the slowest way to point at something. You know exactly what you mean. The AI does not have a cursor. ## You can now draw directly on the image before you send it The agent input overlay now includes an annotation layer. Before you hit send, you can draw on any attached image or screenshot — add arrows, place text labels, highlight a region with colour, or sketch a freehand mark. The annotated version replaces the original attachment, so the AI receives your marked-up image automatically. ![Image annotation overlay in the agent input panel showing a drawing toolbar with arrow and text mark tools, with freehand annotations pointing to a specific area of an attached UI screenshot](/app-screenshots/draw_on_attached_images_and_screenshots.jpg) ## How it works in practice ### Open the annotation toolbar Attach an image or take a screenshot with the attachment button in the agent input area. An annotation icon appears on the preview thumbnail. Click it to open the drawing overlay — the image fills the panel and the toolbar appears along the top or side. ### Mark exactly what you mean Pick from arrows, text labels, highlight brushes, and freehand drawing. Add an arrow pointing to the misaligned element. Type a short label: "this one". Highlight the region with a colour wash if the area is ambiguous. You can combine tools in a single annotation pass. ### The annotated image is the attachment When you close the annotation view and send the prompt, the AI receives the annotated image — not the clean original. You do not need to export it separately, save it to disk, or re-attach it. The overlay handles the merge. ## Before vs After | Pointing the AI at a UI element | Before v1.23.1 | After v1.23.1 | |---|---|---| | Describe which button has the bug | Write a paragraph | Draw an arrow on it | | Show where a layout breaks | Paste coordinates or element names | Circle the region directly | | Distinguish between two similar elements | Lengthy disambiguation text | Label each one with a text annotation | ## Who benefits most **Designers reviewing implementations** — when the component does not match the spec, marking up the screenshot is faster than writing an issue and leaves no ambiguity about which element you mean. **Developers debugging CSS** — highlight the exact region where padding, alignment, or overflow is off so the AI can focus its analysis on the right place without guessing from a full-page screenshot. **QA engineers filing tickets via AI** — annotate the reproduction screenshot in the same session where you are describing the bug, without switching to a separate image editor. ## Try it Update to v1.23.1 or later from the update banner or 1devtool.com. Attach any image in the agent input overlay — the annotation option appears on the attachment thumbnail. --- ## See Every Terminal and Resume AI Sessions Your Way Source: https://1devtool.com/blog/terminal-canvas-resume-commands Published: 2026-06-05 Tags: terminal-canvas, ai-sessions, terminals, release 1DevTool v1.23.0 adds a full-screen Terminal Canvas for scanning live terminal work and editable resume commands for restarting AI sessions with the right mode. When several terminals are doing useful work at the same time, the hard part is no longer starting another command. The hard part is keeping enough of the work visible that you can make the next decision without clicking through a stack of tabs. You might have a dev server streaming logs, a test runner waiting on a file change, Claude reviewing one branch, Codex implementing another fix, and a shell parked in a different project. Each session matters, but a compact terminal list can make them feel disconnected. When you cannot see the whole workspace, you spend attention asking where things are instead of deciding what needs your input. ## What changed 1DevTool v1.23.0 adds Terminal Canvas and editable AI session resume commands, so you can see terminal work spatially and restart agent sessions with the exact command you intend to run. ![Terminal dropdown showing Dashboard, List, and Canvas Layout options with keyboard shortcuts](/app-screenshots/terminal_views_shortcuts.jpg) Terminal Canvas gives you a full-screen map of live terminal cards. Editable resume commands give you a review step before a past AI session opens, with normal and bypass variants visible before launch. ## How it works in practice ### You can scan terminal work as a workspace, not a list Open the terminal dropdown and choose Canvas Layout. Instead of compressing every terminal into a tab or row, 1DevTool lays them out as cards on a pannable canvas. Each card keeps the important context in view: terminal name, project path, live output or saved preview, and status indicators for running, idle, error, live, and inactive sessions. That changes how you monitor parallel work. You can keep a long-running build in one corner, an AI agent in another, and a log stream beside the project it belongs to. When the canvas is crowded, zoom out to regain the overview. When one session needs attention, zoom back in and open it directly. ![Terminal Canvas displaying multiple live terminal cards with status badges across a dark workspace](/app-screenshots/terminal_canvas_layout.jpg) The canvas also understands that multi-project work is different from single-project work. Turn on Group by project when you want each project to become its own cluster. Leave Show running enabled when you only care about sessions that are currently active. If an inactive terminal still matters, its preview card can reopen it without forcing you to hunt through the project tree. ### You can resume AI sessions with the command in front of you Resuming an AI session is more sensitive than opening a normal shell. The command decides which agent starts, which session ID it receives, and whether it runs with normal approval prompts or bypass permissions. Before this release, the app could choose the resume command for you, but you had less room to inspect or adjust it before the terminal opened. Now the Resume AI Sessions flow prepares two command cards: Run with bypass permissions and Run with normal permissions. Each card shows the command that will be executed, and each command is editable. If the generated command is already right, you launch it as-is. If you need to adjust a flag, remove a bypass mode, or adapt the command to a particular workspace, you can do that before the session starts. ![Claude Code Resume session dialog showing editable bypass and normal command cards before launch](/app-screenshots/customize_resume_command.jpg) This matters most when you work across several AI CLIs. Claude, Codex, Gemini, Qwen, Amp, and OpenCode do not all resume the same way. 1DevTool now prepares agent-specific resume commands, resumes Codex in inline mode to keep restored conversations cleaner, and resumes Gemini sessions natively instead of dropping you into a fresh Gemini terminal without the selected context. ### You can move through terminal views faster The terminal dropdown now treats Dashboard, List, and Canvas as first-class destinations. The menu shows shortcut hints, so you can learn the fastest path while you browse. Terminal shortcuts are configurable too, which means the new defaults can fit around the bindings you already rely on. The terminal list also gets keyboard navigation with Arrow keys, Home, End, Page Up, Page Down, Enter, and Space. When you need the precision of a list, you can move through it without reaching for the mouse. When you need the shape of the workspace, you can jump to Canvas. ## Before vs After | Before | After | | --- | --- | | You clicked through terminal tabs or a compact list to understand what was running. | You open Canvas Layout and see live terminal cards across the workspace. | | Active, idle, and inactive sessions were harder to compare at once. | Status badges and running-only filters make the important sessions stand out. | | Multi-project terminal work felt mixed together. | Group by project clusters related terminals together. | | AI resume commands launched with less chance to inspect the exact command. | Normal and bypass command cards are visible and editable before launch. | | Different AI agents required you to remember resume syntax details. | 1DevTool prepares agent-specific commands for the supported CLIs. | | New terminal shortcuts could collide with existing custom bindings. | Shortcut updates merge safely and duplicate bindings are blocked with a visible warning. | ## Who benefits most If you run multiple AI agents, Terminal Canvas gives you a better control surface. You can keep the agents visible as they work, spot which one needs attention, and jump into the right session without turning monitoring into its own task. If you switch between projects during the day, project grouping reduces the cost of context changes. A terminal is no longer just another item in a global list; it sits near the project it belongs to, with its path and state visible. If you care about permission mode, editable resume commands remove guesswork. You can choose normal approvals for routine work, use bypass only when the workspace is isolated enough for it, and confirm the actual command before a terminal is created. ## Try it Install 1DevTool v1.23.0, open the terminal dropdown, and switch between Dashboard, List, and Canvas Layout. Then open Resume AI Sessions and inspect the normal and bypass command cards before restarting an agent session. You get a clearer view of parallel terminal work and more control over how your AI context comes back. --- ## Delegate Any AI Agent From Anywhere — v1.22.0 Brings @-Mention Orchestration, Live Theme Editing, and a Whiteboard Source: https://1devtool.com/blog/cross-agent-at-mention-orchestration Published: 2026-06-01 Tags: v1.22.0, ai-agents, orchestration, themes, whiteboard, excalidraw v1.22.0 turns every AI terminal in 1DevTool into a delegation hub: type @codex or @opencode inside Claude's terminal and the task pipes through the bundled 1devtool-agent CLI — no MCP server, no copy-paste. Plus call-chain badges, a Theme Editor with live preview, and an Excalidraw whiteboard. You set up Claude to write the new endpoint. It nails the handler but the validation feels off, so you want a second pair of eyes — maybe Codex would catch the edge case Claude keeps glossing over. So you alt-tab, paste the same prompt into a different terminal, wait, copy the answer back, and try to remember where you were. By the time the comparison is in front of you, the loop is broken and you've lost the thread. Multi-agent workflows have been like this for a year — every AI CLI in its own terminal, every handoff a manual copy-paste, every "let me get a second opinion" costing a context switch you can't afford. ## What changed v1.22.0 turns those terminals into a network. Type `@codex review what claude just wrote` inside any AI terminal and the agent you're already talking to delegates to Codex — runs it, pipes the result back into your conversation, lets you keep going. No second window, no copy-paste, no MCP server to babysit. The mechanism behind it is a small CLI called `1devtool-agent`, installed under `~/.1devtool/bin/` on first launch. Your host agent calls it through a per-agent skill that 1DevTool reinstalls on every app boot. The old MCP-based `Run Agent` tool is gone — it dropped after about ten minutes of idle time, which made long sessions unusable. The CLI doesn't. ![Two terminals running parallel AI agent orchestration chains with colored call-chain badges](/app-screenshots/run-ai-orchestration-across-multiple-terminals.jpg) ## How it works in practice ### Delegate with an @-mention Inside any AI terminal — Claude, Codex, Gemini, OpenCode, Amp, Qwen, Aider — type `@` followed by the task. Your active agent picks it up, hands it off, and waits for the result. ``` @codex review the validation in api/orders/route.ts @opencode score the test coverage in tests/checkout/ @gemini summarize this stack trace ``` The delegated agent runs headless in the same project working directory, so it can read and write the same files the caller can. When it finishes, its full text output lands in your terminal as the @-mention result — ready to act on, or to chain into another @-mention if you want a three-way comparison. The popup that helps you write those mentions got nicer too. File and folder icons now render next to suggested paths, so you can see at a glance whether `@codex review api/orders` is going to land on a directory or a single file. ![Agent input @-mention popup showing folder and file icons next to suggested source paths](/app-screenshots/folder_and_file_icon_when_mention.jpg) ### Follow the call chain on the badge Every spawn is visible above the terminal as a badge — and now those badges show the whole chain. Where you used to see `spawn codex`, you now see `claude → codex` with each agent name in its own color. When Codex itself decides to call OpenCode mid-run, the badge updates in place to `claude → codex → opencode`. You can tell, without opening a single log file, which agent kicked off which sub-task, and how deep the chain has gone. ![Call-chain badge above a terminal showing claude → codex → opencode delegation in colored chips](/app-screenshots/orchestrate_AI_agent_badge.jpg) ### Sketch where you're already working Half of debugging is drawing arrows on top of things. A box for each service, a line for the request that's failing, a circle around the spot on the screenshot where the dropdown disappeared. Pulling out a separate app for that breaks the loop you're already in. v1.22.0 adds a Draw button to 1DevTool's top bar. Click it and a full-screen Excalidraw canvas opens — freehand pen, shapes, arrows, text, sticky-note frames, image insert. Drop in a screenshot of the bug, annotate it, and save. Close the canvas, come back tomorrow, your scene is still there. The Excalidraw bundle is loaded lazily, so app startup stays as fast as it was without it. ### Tune your theme without restarting The other quiet upgrade is the Theme Editor. Settings → Appearance → Theme, hover any theme card, click **Fork & Edit**, and a side-by-side editor opens — raw JSON on the left, named form fields on the right for every color slot. Every change repaints the app within a fraction of a second. There's no Save-and-Reload loop. If you're starting from a VS Code theme you imported, the editor copies the current values so you can tweak two or three colors instead of rebuilding the whole palette. And the import itself got dramatically more faithful — sidebar, breadcrumb, status bar, panel, peek view, and Monaco accents now round-trip correctly, and a theme's `semanticTokenColors` are converted into matching Monaco syntax rules. ## Before vs after | Before v1.22.0 | After v1.22.0 | | --- | --- | | Open a second terminal for Codex, paste the prompt, wait, copy result back to Claude | `@codex review …` inside Claude's terminal; result pipes back inline | | MCP server drops after ~10 min idle, mid-session | `1devtool-agent` CLI runs per-invocation; nothing to keep alive | | Sub-agent badge says `spawn codex` — no idea who called it | Badge shows `claude → codex → opencode` with each agent colored | | Pull out Excalidraw web or a separate sketch app to mark up a screenshot | Click Draw, annotate, close — scene persists locally | | Edit a theme JSON file, reload the app, realize the contrast is off, repeat | Fork & Edit → JSON + form editor → live repaint on every keystroke | ## Who benefits most **Multi-agent power users** — anyone routinely running two or more AI CLIs side by side. The cost of asking for a second opinion drops to a single line of text in the terminal you're already in. **Anyone whose long sessions used to drop** — the MCP-based orchestrator failed at ~10 min idle, which made all-day Claude or OpenCode sessions unreliable. The CLI is stateless per invocation, so there's nothing to drop. **Theme tinkerers** — if you've ever fought with VS Code theme imports that silently dropped half your colors, the new converter and the live editor make the loop tight enough to actually finish a theme. ## Try it Update to v1.22.0, open any AI terminal, and type `@ ` — pick any agent you've got installed. The skill is auto-reinstalled on boot, the CLI is on your PATH, and the badge above the terminal will tell you who's talking to whom. If anything looks off after an upgrade, **Settings → AI → Orchestration → Reinstall orchestration skill** rebuilds the skill files in every detected agent's skills directory in one click. What used to be a manual handoff is now a one-line delegation. The terminals you've been running side by side finally know about each other. --- ## OpenCode Spend Joins Your AI Dashboard, Groups Accept Folder Drops, HTML Previews in One Click Source: https://1devtool.com/blog/opencode-usage-group-drops-html-preview Published: 2026-05-30 Tags: opencode, ai-usage, project-groups, html-preview 1DevTool v1.21.4 adds OpenCode token and cost tracking to the AI Usage dashboard, lets you drag folders directly into project groups, and puts a one-click HTML preview button in the editor toolbar. Three independent workflows got meaningfully better in v1.21.4 — and all three solve the same underlying problem: information that should be visible inside 1DevTool was ending up outside it. If you were using OpenCode alongside Claude or Codex, your AI spend tracking was incomplete. If you were adding projects that belonged in a group, you were doing it in two steps instead of one. And if you were working on HTML files, you were opening a browser window to see what you wrote. ![Mission Control overlay showing a project grid with keyboard navigation hints bar and a focused card with accent ring highlight in 1DevTool](/app-screenshots/mission_control_light_theme.jpg) ## OpenCode sessions now show up in AI Usage The AI Usage dashboard tracks token counts, session costs, and per-model breakdowns for Claude, Codex, Gemini, and Qwen. As of v1.21.4, OpenCode joins that list. ### How it works 1DevTool reads OpenCode's shared `opencode.db` file once and splits it into individual session records — the same structure used for every other agent. Each record includes the model used, token counts for that session, and cost calculated against the actual pricing for that model (not a per-provider estimate). Switch between projects and the OpenCode history for each one loads correctly. ### Why this matters If you are evaluating whether OpenCode is worth running alongside Claude on a given project, the comparison belongs in a single dashboard. Before this change, the only way to see OpenCode costs was to check the OpenCode interface directly — a separate context switch that most people skip. Now the comparison is visible without leaving 1DevTool. ## Drag folders directly into project groups Dropping a folder from Finder or Explorer onto 1DevTool has always created a new project. But it always landed ungrouped at the top level — a second manual step was needed to move it into the right group. Now you can drag the folder onto any group surface — the group header, the empty "Drag projects here" placeholder, or any existing project inside a group — and the new project is added directly to that group. A live highlight shows which group will receive the drop before you release, so you can confirm before committing. Dropping in the empty sidebar area still adds at the top level. The existing behavior for ungrouped projects is unchanged. ## Preview any HTML file in the built-in browser with one click When an `.html` or `.htm` file is active in the editor, a globe button appears in the editor toolbar. Clicking it renders the file in the built-in browser panel — no dev server required, no external browser to open. The button is visible only when an HTML file is active, so it does not clutter the toolbar for other file types. It complements the existing right-click "Open in 1DevTool's Browser" option from the file tree — the toolbar button is the faster path when you are already in the editor. ## Before vs After | Task | Before v1.21.4 | After v1.21.4 | |---|---|---| | See OpenCode session costs | Check the OpenCode interface separately | Visible in AI Usage alongside Claude/Codex | | Add a project to a specific group | Add ungrouped, then drag into group | Drag folder directly onto the target group | | Preview an HTML file | Open external browser, navigate to file | Click globe button in editor toolbar | ## Try it Update to v1.21.4 or later. AI Usage is in the left sidebar under the usage icon. Project groups accept folder drops immediately — no settings to toggle. The HTML preview button appears automatically in the editor toolbar when an HTML file is open. --- ## Click a Postman, Bruno, or Insomnia collection — every request opens instantly Source: https://1devtool.com/blog/click-postman-bruno-insomnia-to-open Published: 2026-05-28 Tags: http-client, postman, bruno, insomnia, import, html-preview 1DevTool now treats Postman, Bruno, and Insomnia collection files as native — click any of them in the file explorer and the requests, folders, and environments land in the HTTP client straight away. If you've ever shared an API project between teammates, you know the dance. Someone exports a Postman collection or commits a `bruno/` folder. You clone the repo, find the file, then go file → import → pick file → confirm → wait. Three dialogs and a coffee later, the requests are in your HTTP client. The import worked. But it took longer than the test request you wanted to run in the first place. And next time someone updates the collection, you do the whole dance again — or worse, you forget, and ship a stale version of the call. v1.21.3 deletes that whole dance. ## What changed Postman, Bruno, and Insomnia collection files are now first-class citizens in 1DevTool's file explorer. Click one and every request in it opens in the HTTP client immediately — no import dialog, no manual format selection, no copy-paste. The first request becomes the active tab and the rest are right there in the HTTP sidebar. ![Postman collection clicked in the file explorer auto-imports requests into the HTTP client sidebar with folder structure preserved](/app-screenshots/select_and_auto_open_http_requests.jpg) ## How it works in practice ### Supported formats are the ones you actually use Three formats, recognised by filename and content: - **Postman v2.1** — `*.postman_collection.json`, plus `*.postman_environment.json` for env variables - **Insomnia v4** — `*.insomnia.json`, `*.insomnia.yaml`, plain `insomnia.yaml`, or `insomnia_v4.json` - **Bruno** — individual `.bru` files *and* whole `bruno/` folders with their `environments/*.bru` siblings If a file doesn't match one of those name patterns, or the content doesn't look like the format it claims, 1DevTool quietly skips it and treats the file as plain text. No false positives, no "why did clicking this YAML file open the HTTP client" surprises. ### Folder structure is preserved, not flattened If your Postman collection had `Auth → Login`, `Auth → Refresh Token`, `Users → Get Profile`, that's the tree you see in 1DevTool's HTTP sidebar — not a flat list of seven requests with prefixed names. Bruno folder hierarchies translate the same way. The mental model your team built into the collection survives the import. ### Environments come along Postman environment files dropped next to a collection, Insomnia environment blocks inside the same JSON, Bruno `environments/*.bru` files — they all get pulled in alongside the requests. The variables you'd use to fill in `{{baseUrl}}` or `{{accessToken}}` are immediately available in the environment picker. When the import finishes, a summary toast tells you exactly what landed: *"Imported 47 requests + 2 environments from MyCollection.postman_collection.json"*. You know what you got without spelunking through the sidebar. ### Re-clicking is fast jump, not re-import Once a collection file is imported, clicking the *same* file again doesn't re-import — it instantly switches the HTTP panel to that request. So if you have your file tree open on the left and the HTTP client on the right, you can navigate your API the way you navigate code: by clicking the file you care about. Dedicated file icons for `.bru`, `.postman_collection.json`, and Insomnia exports make collection files stand out in the tree so you can find them at a glance. Right-click any of them for the explicit **Open in HTTP Client** menu item if you prefer. ## Before vs after | Step | The old way | With v1.21.3 | |---|---|---| | See collection in file explorer | ✓ | ✓ | | Open HTTP client | Click panel | (already open) | | Trigger import | File → Import → Pick file → Confirm format | Click the file | | See requests | After the import dialog closes | Immediately | | Switch to a specific request | Hunt in the sidebar | Click that request file | | Update after teammate edits | Re-run the import | Pull from git, file change picks up automatically | ## Also new — preview HTML files in the built-in browser A smaller convenience in the same release: right-click any `.html` or `.htm` file and you'll see **Open in 1DevTool's Browser** alongside **Open with Machine's Browser**. The first one renders the file inside the browser panel right next to your editor — perfect for previewing static sites, build outputs, exported reports, or that scratch HTML you wrote to test a layout idea. ![Right-click context menu on an HTML file with Open in 1DevTool's Browser and Open with Machine's Browser options](/app-screenshots/open_html_files.jpg) The same context menu pair is available for PDFs, audio, and video files — so previewing build artefacts, design exports, or media assets stays inside 1DevTool instead of bouncing through Finder. ## A few quieter fixes - The **project dropdown in the breadcrumb** now sorts the way your sidebar does (group-aware, root groups first), instead of in random insertion order. - **Force scroll to bottom on terminal click** is now off by default for new users — so you can scroll up through agent output without the terminal yanking you back. Existing users keep their current setting; it's a toggle in Settings → Terminal. - Fixed clicking an already-imported Bruno or Postman request file *doing nothing* — the HTTP panel now refreshes from project state instead of silently keeping the previous request on screen. ## Try it Update to v1.21.3, drop a `.postman_collection.json`, `.bru`, or `.insomnia.json` into a 1DevTool project, and click it. The collection that took you a multi-step import last week opens in one click this week. If you live in a multi-collection API project, this is the first version of 1DevTool that lets you navigate your API the same way you navigate code. --- ## Click any .sqlite file to start querying — no connection setup Source: https://1devtool.com/blog/click-sqlite-files-to-query-them Published: 2026-05-26 Tags: sqlite, database, shortcuts, file-explorer 1DevTool's new SQLite client opens .sqlite, .sqlite3, and .db files straight from the file explorer. Plus a searchable keyboard shortcut guide one ⌘/ away. You spotted a `.sqlite` file in the project — maybe a Rails dev database, a Better-Auth session store, or a scratch file some script left behind. You want to peek inside. What happens next is annoyingly familiar. You go look for a SQLite GUI. You install DB Browser, or you remember you already have TablePlus but it's behind a paywall now, or you give up and pipe `sqlite3 file.db '.dump'` through `less`. Either way, the moment you wanted to ask the file *one quick question* — what tables does it have, how many rows, what's in the user table — turned into a 60-second detour into installing or configuring another tool. That detour is gone in v1.21.2. ## What changed Click any `.sqlite`, `.sqlite3`, or `.db` file in 1DevTool's file explorer and it opens in the database client immediately — same SQL editor, same result grid, same schema sidebar you use for Postgres, MySQL, Redis, and every other engine 1DevTool already speaks. No connection setup, no "new connection" dialog, no engine picker. You clicked a database file; you're querying it. ![SQLite database client open with the schema sidebar showing tables, row counts, and a query editor over the database file](/app-screenshots/sqlite_editor_overview.jpg) ## How it works in practice ### Click-to-open from the file tree SQLite files now get a dedicated file icon in the explorer so they stand out next to your code. Single-click one and 1DevTool tests the file is a valid SQLite database, creates an internal connection on the fly, and drops you into the query editor with the schema already loaded in the sidebar. Right-click the same file and you'll see **Open in Database Client** in the context menu — handy when you want to be explicit about intent. The connection that gets created is scoped to the file. It doesn't pollute your saved-connections list with one-off entries for every database file you've ever clicked. ### The schema sidebar tells you what you're looking at ![SQLite editor in full-screen mode showing query results and a Commit Changes action for staged edits](/app-screenshots/sqlite_editor_fullmode_and_commit_changes.jpg) Table and view listings now show row counts inline. Before you write a single query, you can see at a glance: *this `users` table has 3 rows, this `sessions` table has 12,847*. That's usually enough to know whether you're looking at the right database or the wrong one — and which tables are worth a `SELECT *` versus a `LIMIT 100`. Edits in the result grid are staged, not committed. When you're ready you click **Commit Changes** and 1DevTool writes them in one transaction. Misclick a cell? Discard the edit and the file on disk is untouched. ### Adding a connection by hand still works — but easier For files outside your project tree, the connection form now adapts when you pick SQLite as the engine. Host, port, user, password, SSL — all hidden, because none of them apply to a local file. The only field that matters is the path, and there's a **Browse** button next to it that opens your OS file picker so you don't have to type the path manually. ## Before vs after | Step | The old way | With 1DevTool v1.21.2 | |---|---|---| | Discover database file | See `.sqlite` file in explorer | See `.sqlite` file in explorer | | Pick a GUI | Install DB Browser, pay for TablePlus, or use `sqlite3` CLI | (skip) | | Configure connection | Point the GUI at the file | (skip) | | Open file | Wait for schema to load | Single-click in file tree | | Start querying | New tab → write SQL | Cursor already in editor with schema loaded | ## One more thing — press ⌘/ for the shortcut guide ![Keyboard shortcut guide overlay with category cards and a search field for finding shortcuts by name or key](/app-screenshots/shortcuts_guide.jpg) While you're getting comfortable with the SQLite client, here's something else worth knowing about: press `⌘/` (or `Ctrl+/` on Windows/Linux) and a searchable shortcut reference fades in. Every keyboard binding the app has, organized into General, Layout, Terminal, Editor, Browser, and Tasks. Type to filter by name, key combination, or description — *"switch panel"* surfaces the panel-switching bindings, *"⌘k"* shows you what's bound to that combo. There's a link straight to Settings → Shortcuts in the header if you want to rebind anything. ## Try it Grab v1.21.2 and click a `.sqlite` file. If you don't have one handy, the easiest test is to look in your operating system's caches — Chrome, Slack, Notes.app, almost every Electron and native macOS app keeps state in SQLite. (Just don't `UPDATE` anything while the app is running.) For everything else, press `⌘/` to see what shortcuts you have for free. --- ## Preview PDFs, Videos, and Audio Without Leaving Your Editor Source: https://1devtool.com/blog/inline-media-preview Published: 2026-05-25 Tags: media-preview, pdf-viewer, video-player, browser-panel, v1.21.1 Click a PDF, video, or audio file in the file explorer and it renders in the browser panel — no separate app, no context switch. You click a PDF in your file explorer and your OS opens Preview. You click a video and QuickTime launches. Each file pulls you out of your editor and into a different app. By the time you find the right page or timestamp, you have forgotten what you were looking for. 1DevTool v1.21.1 keeps media files inside the app. PDFs, videos, and audio play in the built-in browser panel — no context switch, no separate window. ## Media files open where you already are Click a PDF, video, or audio file in the file explorer and it opens directly in the browser panel. The file renders inline using the embedded Chromium engine, which means full PDF page navigation, native video controls with seeking and playback speed, and audio playback with waveform scrubbing. ![Video and audio player rendering an MP4 file in the 1DevTool browser panel with native playback controls](/app-screenshots/video-audio-player.jpg) Supported formats cover the files developers actually encounter: PDF for documentation and specs, MP4/WebM/OGV for video, and MP3/WAV/OGG/FLAC/AAC/M4A/OPUS for audio. If you open a media file through the editor tabs instead of the file explorer, a styled placeholder card explains the file type and offers a one-click "Open in Browser" button. If the browser has reached its tab limit, the file falls back to an editor tab so it always opens somewhere. ## How media preview works in practice ### Preview documentation alongside code Open a project's `ARCHITECTURE.pdf` in the browser panel while editing the code it describes. Scroll through the PDF on the right, write code on the left. No separate window to manage, no Alt-Tab to find the right page. ### Review video recordings without leaving your workspace Click a screen recording or test video in the file explorer and it plays in-place. Pause, seek, adjust speed — all with standard video controls. Useful when reviewing UI recordings, demo videos, or test output captured as video. ![PDF document rendered in the 1DevTool browser panel showing full page navigation](/app-screenshots/view-pdf.jpg) ### Listen to audio assets in context Audio files play with the same embedded controls. If you are working on a project that handles audio — transcription tools, podcast apps, sound effects — you can preview files without opening a media player. ## MCP badges now land on the right terminal This release also fixes a subtle but important accuracy issue with MCP tool activity badges. Previously, badges for tool calls could appear on whichever terminal was most recently active, regardless of which agent triggered the call. Now each badge is tied to the specific AI agent that invoked the tool. ![MCP tool activity badges showing database query results in a detail panel with correct terminal assignment](/app-screenshots/mcp-badge-and-log-details.jpg) The fix works through terminal identity tracking in the MCP bridge. Each tool invocation carries a terminal ID through the bridge so badges land on the correct terminal even when multiple agents are running simultaneously. Sub-agent detection has also been expanded to recognize Codex inline-mode output patterns (`Running `, `Ran `) alongside the existing Claude `Bash()` format. ## Before vs After | Scenario | Before v1.21.1 | After v1.21.1 | |---|---|---| | Open a PDF from the project | Launches system Preview → separate window → find the right page | Click in file explorer → renders in browser panel → scroll alongside code | | Play a video file | Launches QuickTime/VLC → new window → lose workspace context | Click in file explorer → plays inline with native controls | | Check which AI triggered a tool call | Badge appears on the last active terminal → ambiguous | Badge appears on the exact terminal that owns the agent | | Open a `file://` path in the browser | Broken — path got prefixed with `http://` | Works — local paths are recognized and loaded correctly | ## Try it Update to 1DevTool v1.21.1 and click any PDF, video, or audio file in your file explorer. It opens in the browser panel — no configuration, no plugins, no separate app. --- ## Your AI Agents Can Now Delegate to Each Other Source: https://1devtool.com/blog/ai-agent-orchestration Published: 2026-05-25 Tags: ai-orchestration, multi-agent, mission-control, mcp-tools, v1.21.0 Type @Codex in a Claude terminal and Claude delegates the task, captures the result, and reasons over it — plus Mission Control for project overview and live MCP tool badges. You have three AI coding agents installed. Claude is great at architecture. Codex is fast at one-shot edits. Gemini knows your codebase from last week. But using all three means copying prompts between terminal windows, comparing outputs by scrolling back and forth, and deciding which answer to keep — all manually. That workflow just changed. 1DevTool v1.21.0 lets your AI agents talk to each other, gives you a single dashboard for every open project, and makes invisible tool calls visible. ## Your AI agents can now delegate to each other Type `@Codex write unit tests for auth.ts` in a Claude terminal, and Claude spawns Codex headlessly, waits for it to finish, reads the output, and reasons over it — all without you switching terminals. This works with every major coding CLI: Claude, Codex, Gemini, Amp, OpenCode, Qwen, and Aider. The orchestrator is built on two new MCP tools — `run_agent` and `list_agents` — exposed to every AI terminal through the MCP bridge. Your current agent calls `run_agent` with a target agent name and a prompt. The target runs in headless mode, and its text output flows back as the tool result. ![AI Agent Orchestrator MCP settings showing run_agent and list_agents tools with toggle controls](https://github.com/user-attachments/assets/cbcc6797-730c-41fc-bb8a-335596dbe3ab) Multi-agent workflows happen in natural language. Ask "have Codex write jokes and score them until 8/10" and the orchestrating agent handles the retry loop on its own. Mention multiple agents and the AI decides whether to run them in parallel or sequence based on your prompt. You manage the orchestrator from Settings → MCP, where you can toggle it on or off and see both tools with their descriptions and current status. ## How multi-agent orchestration works in practice ### Delegate a single task Open a Claude terminal and type something like `@Gemini review this PR for security issues`. Claude calls `run_agent` targeting Gemini, passes the prompt, and waits. When Gemini finishes, Claude receives the full response and can summarize, critique, or act on it. ### Chain agents for iterative work Ask Claude to "have Codex generate a migration, then ask Gemini to review it." Claude runs Codex first, reads the output, then passes the migration to Gemini for review — two agent calls in sequence, zero manual handoff. ### Run agents in parallel for second opinions Type "ask both Codex and Gemini to refactor this function and show me which approach is cleaner." The orchestrator spawns both simultaneously, collects their outputs, and presents a comparison. Each agent runs with a configurable timeout (default 120 seconds, max 600). ## Mission Control: see every project at a glance Press the grid icon in the toolbar and Mission Control opens as a full-screen overlay. Every project appears as a card showing what's actually running: terminal count by agent type (3 Claude, 1 Codex), open browser tabs, active HTTP requests, and database connections. ![Mission Control overlay showing project cards with terminal badges, browser tabs, and activity indicators](https://github.com/user-attachments/assets/6cc9b8d6-cdab-4784-9fb0-1d31284ca381) Active projects float to the top. Inactive ones are grouped below with a subtle divider. Custom commands are parsed and badged — if a terminal runs `claude --model opus`, the card shows a colored Claude badge with the flags spelled out. Navigate with arrow keys, press Enter to switch to a project, Escape to close. Spring-animated transitions make the overlay feel responsive: cards shrink in from full size on open, and the selected card zooms back out on close. ## MCP tool activity badges: see what your AI is doing When an AI agent calls an MCP tool — a database query, an HTTP request, or an orchestrator delegation — a live badge now appears in the terminal area. A pulsing dot shows while the tool is running, replaced by a checkmark or error icon when it finishes, with an elapsed time counter throughout. Click any badge to open a detail panel showing the full result. Database queries render as formatted tables. HTTP responses show status, headers, and body. Orchestrator delegations display the target agent's complete response. Badges are color-coded by category: green for database, blue for HTTP, amber for orchestrator. They stay visible until you dismiss them individually or clear all at once — so you can review results at your own pace instead of watching them scroll past in the terminal output. ## Before vs After | Workflow | Before v1.21.0 | After v1.21.0 | |---|---|---| | Get a second opinion from another AI | Copy prompt → switch terminal → paste → wait → manually compare | Type `@Agent do X` → orchestrator handles it → results appear inline | | Check what's running across projects | Click through each project tab → count terminals manually | Press grid icon → Mission Control shows everything on one screen | | See what an MCP tool returned | Scroll through terminal output → find the response buried in text | Click the colored badge → full result in a formatted detail panel | | Run parallel AI tasks | Open separate terminals → manage timing yourself | Mention multiple agents → orchestrator runs them simultaneously | ## Who benefits most **Teams running multiple AI agents.** If you switch between Claude for planning and Codex for execution, orchestration eliminates the copy-paste handoff. Your planning agent delegates execution directly. **Developers juggling many projects.** Mission Control replaces the mental overhead of remembering what's running where. One screen, all projects, real activity counts. **Anyone debugging AI-assisted workflows.** MCP badges make tool calls transparent. Instead of guessing why your AI made a certain decision, you see every database query and HTTP request it triggered. ## Try it Download 1DevTool v1.21.0 and open Settings → MCP to enable the Agent Orchestrator. Then type `@` followed by any installed agent name in your terminal — your AI agents will handle the rest. --- ## Find Every TODO, FIXME, and HACK Buried in Your Codebase Source: https://1devtool.com/blog/find-every-todo-fixme-hack-codebase Published: 2026-05-23 Tags: code-tasks, todo, fixme, workspace, keyboard-shortcuts, productivity Code Tasks scans your entire project for annotation comments and shows them in one organized panel — grouped by tag, file, or priority — so nothing falls through the cracks. You know they're in there. Scattered across dozens of files, buried under layers of imports and business logic — the TODOs you wrote three months ago, the FIXMEs from that late-night debugging session, the HACKs that were supposed to be temporary. Every developer accumulates them. Few ever go back to find them all. The problem isn't discipline. It's visibility. grep works, but it dumps raw lines with no structure, no priority, and no way to act on what you find. You end up scrolling terminal output trying to remember which TODO was the urgent one. ## What changed 1DevTool v1.20.0 introduces **Code Tasks** — a built-in panel that scans your entire project for TODO, FIXME, BUG, HACK, XXX, NOTE, and OPTIMIZE annotations and presents them in a structured, filterable view. You can now see every outstanding annotation in one place and jump to any of them in a single click. ![Code Tasks panel showing TODO, FIXME, and HACK annotations grouped by tag with priority indicators and file paths](/app-screenshots/new_task_feature.jpg) ## How it works in practice ### Scan and organize your annotations Open the Code Tasks panel from the left sidebar. It scans your project root and returns every annotation it finds, with the tag, file path, line number, and surrounding context. Group the results by tag (all TODOs together, all FIXMEs together), by file (see everything in a single file at once), by author, or by priority. Switch between views instantly — no re-scan needed. ### Filter down to what matters right now Use the tag filter to isolate just FIXMEs, or just BUGs. Set the priority filter to show only critical and high-priority items — anything tagged FIXME, BUG, or marked with `!` or `!!` in the comment. Type a search term to narrow results further. When you have 200 annotations across a monorepo, these filters turn noise into a focused action list. ### Jump to the code or send it to an AI agent Click any task row to see its full context in a detail pane — the surrounding code, the exact line, and the annotation text. Click again to jump straight to that line in the built-in editor. Or hit the "Send to Terminal" button to pipe the annotation as a prompt to your AI terminal — Claude, Codex, or whichever agent you're running — and let it propose a fix. ### Configure what gets scanned Open the Config panel to exclude directories like `node_modules`, `dist`, or `vendor` from scans. Add your own custom tags beyond the built-in set — `REVIEW`, `PERF`, `DEPRECATED`, whatever your team uses — and assign each one a distinct color so they're visually identifiable at a glance. ![1DevTool workspace showing the new collapsible editor panel and icon rail sidebar with toggle layout buttons](/app-screenshots/new_toggle_layout_buttons.jpg) ## Beyond Code Tasks: a more flexible workspace v1.20.0 also reshapes how you arrange your workspace: - **Collapsible Editor Panel** — hide the editor entirely to full-screen your terminals. A slim status bar shows the keyboard shortcut and open file count so you can bring it back instantly. - **Collapsed Sidebar Icon Rail** — when the left sidebar is hidden, a thin icon rail appears with one icon per panel. Click any icon to jump to that panel and re-expand. - **Open in External Editor** — click any file to launch it in VS Code, Cursor, Zed, Sublime Text, or WebStorm. 1DevTool detects what's installed and remembers your choice per project. - **Customizable Keyboard Shortcuts** — remap any shortcut from Settings, organized by category. Modified shortcuts are highlighted so you always know what you've changed. - **Unified Activity Feed** — an amber-badged activity button in the toolbar shows recent terminal completions as inline chips. Click one to jump straight to that terminal. ## Before vs After | Before | After | |---|---| | `grep -rn TODO src/` dumps raw lines | Structured panel with grouping, filtering, and priority | | No way to see priority at a glance | FIXME and BUG auto-flagged as high/critical | | Copy the file path, open it, find the line | Click the row to jump to the exact line | | Custom tags invisible to tooling | Define custom tags with colors in the config | | Terminal and editor compete for screen space | Collapse either panel with a toggle | | Keyboard shortcuts are fixed | Remap any shortcut from Settings | ## Try it Update to v1.20.0, open a project, and click the Code Tasks icon in the left sidebar. Every TODO you forgot about is waiting for you — organized, prioritized, and one click away from a fix. [Download 1DevTool](https://1devtool.com) --- ## Drag Files Into Any Terminal — No More Typing Paths Source: https://1devtool.com/blog/drag-files-into-any-terminal Published: 2026-05-22 Tags: drag-and-drop, terminal, file-paths, tmux, performance Drop a file from Finder or the File Tree onto any terminal to insert its path instantly — AI terminals get @mention syntax, shell terminals get properly escaped paths. You're halfway through a command and you need a file path. So you switch to Finder, navigate to the file, right-click, copy the path, switch back to the terminal, paste it, and realize you forgot the quotes around the space in the directory name. Or you're feeding a file to your AI agent and you type the path from memory, getting it wrong twice before landing on the right one. Path entry shouldn't require context-switching or memorization. You can see the file right there in Finder or the File Tree. You just need to get it into the terminal. ## What changed 1DevTool v1.19.0 lets you drag any file or folder from Finder, Explorer, or the built-in File Tree directly onto a terminal to insert its path at the cursor. AI terminals receive `@mention` syntax so your agent treats the file as a real reference. Shell terminals get properly shell-escaped paths with correct quoting for your platform. ![Dragging a folder from Finder into a bash terminal with the "Drop to paste path into terminal" tooltip visible](/app-screenshots/drag_and_drop_folder_to_normal_terminal.jpg) ## How it works in practice ### Shell terminals: escaped paths ready to use Drag a file from Finder onto a bash or zsh terminal. The path lands at the cursor with proper single-quote escaping on macOS and Linux, or double-quote escaping on Windows. If you've already typed `cat ` or `cd `, the path slots right in after your partial command. Drop multiple files at once and they arrive space-separated, each individually escaped. ### AI terminals: @mention syntax for agent prompts Drop a file onto a Claude, Codex, or Gemini terminal and the path appears as `@path/to/file` in the agent prompt draft. Your AI agent parses it as a file reference — not a quoted string it needs to guess about — so it can read, edit, or reason about the file directly. ### Internal File Tree drags The same gesture works from 1DevTool's own File Tree panel. Drag a file from the sidebar onto any terminal. No need to right-click and copy path, no need to type it out. The File Tree already shows you the file — now you can put it where you need it in one motion. ![Dragging a scripts folder into a Gemini CLI terminal showing the drop-to-paste tooltip over an AI agent prompt](/app-screenshots/drag_and_drop_folder_to_normal_terminal_default.jpg) ## Native Selection is now the default tmux mode v1.19.0 also makes `Native Selection` the default tmux mouse behavior. Wheel scroll moves the terminal directly, drag selects text natively, and the tmux copy-mode position indicator never appears. If you previously switched to "Force tmux mouse on" to work around scroll issues, you're automatically migrated back to the working default. ## Before vs After | Before | After | |---|---| | Copy path from Finder, paste, fix quoting | Drag the file, path is inserted and escaped | | Type `@/path/to/file` manually for AI agents | Drop the file, `@mention` syntax auto-generated | | Multi-file paths: copy-paste one at a time | Drop a selection, all paths inserted at once | | Tmux scroll broke native wheel behavior | Native Selection mode works out of the box | ## Performance gains under the hood The dashboard is dramatically faster in this release. Terminal card previews now pull from an indexed SQLite query instead of scanning live PTY buffers. Git status calls for AI terminal cards are fetched lazily and cached per run. The terminal process lookup that used to scan every project's terminal list on every keystroke is now an O(1) Map index. And AI terminal buffers are no longer saved to disk every 30 seconds — they rehydrate via session resume on restart, so the periodic serialization was pure wasted I/O. ## Try it Update to v1.19.0 and drag a file from Finder onto your terminal. That path you used to type from memory arrives perfectly escaped in one gesture. [Download 1DevTool](https://1devtool.com) --- ## A New Look: Stoic Themes and Bundled Nerd Font Source: https://1devtool.com/blog/stoic-themes-bundled-nerd-font Published: 2026-05-21 Tags: themes, nerd-font, customization, agent-input, ux Stoic Dark and Stoic Light are the new default themes — a warm, calm palette for long sessions. Plus, JetBrainsMono Nerd Font ships in the box so icon glyphs render everywhere from day one. You install a new dev tool, open it up, and the terminal font is missing half the glyphs. Powerline symbols render as boxes. Devicons show question marks. You spend ten minutes installing Nerd Fonts system-wide, restarting the app, and hoping the font cache caught up. That's ten minutes of friction before you write a single line of code. And the default theme — functional, sure, but not something you'd choose to stare at for eight hours. You end up in Settings within the first five minutes, tweaking colors that should have been thoughtful from the start. ## What changed 1DevTool v1.18.8 ships two new default themes — **Stoic Dark** and **Stoic Light** — and bundles **JetBrainsMono Nerd Font** directly in the app. Every icon glyph renders correctly in your terminal, editor, and AI panels from the first launch, on any machine, without installing anything. ![1DevTool welcome screen showing Stoic Dark theme with project sidebar, onboarding cards, and the new warm charcoal palette](/app-screenshots/onboarding.jpg) ## How it works in practice ### Stoic Dark: designed for long sessions Stoic Dark is a warm, calm One Dark-derived palette — charcoal background, soft red strings, blue functions, amber types. It's built for the developer who spends hours in the app and wants colors that don't fight for attention. The contrast is high enough to be readable, low enough to not cause eye strain at midnight. ### Stoic Light: familiar and clean Stoic Light is based on the classic VS Code Light Visual Studio palette — pure white background, navy keywords, maroon tags, green comments. If you're coming from VS Code's default light theme, everything reads the way you expect it to. No adjustment period. ### JetBrainsMono Nerd Font: every glyph, every machine The full JetBrainsMono Nerd Font Mono family ships as bundled WOFF2 files inside 1DevTool. Devicons, Font Awesome, Powerline symbols, Octicons — they all render in terminals, the editor, and AI panels without a system-wide font install. Fresh machines, locked-down corporate laptops, SSH-into-an-unfamiliar-Mac sessions — the icon font works from first launch. If you already have JetBrainsMono installed system-wide, 1DevTool uses your system copy via `local()` lookups, so there's no double font decode cost. ![Terminal agent picker showing Claude Code, Codex, Gemini CLI, Amp, OpenCode, and bash options with the Stoic Dark theme](/app-screenshots/onboarding_terminals.jpg) ### Agent Input pickup and close popups v1.18.8 also adds safety nets to the Agent Input overlay. When you open it with text already typed at the native AI prompt, a popup asks whether to bring that text across or start fresh. When you close the overlay with unsaved content, another popup asks whether to return the text to the native prompt, discard it, or keep editing. No more accidentally losing a long prompt by hitting Escape. ## Before vs After | Before | After | |---|---| | Default theme is functional but harsh | Stoic Dark/Light designed for long sessions | | Nerd Font glyphs render as boxes until you install fonts manually | JetBrainsMono Nerd Font bundled — works from first launch | | Opening Agent Input with existing text silently drops or duplicates it | Pickup popup asks whether to bring text across or start fresh | | Closing Agent Input with content loses it silently | Close popup offers to return text to prompt, discard, or keep editing | | System theme toggle picks generic dark/light | System toggle now picks Stoic Dark/Light | ## Try it Update to v1.18.8 and launch the app. The new theme is already active. Open a terminal with Powerline or Devicon glyphs — they render without you lifting a finger. [Download 1DevTool](https://1devtool.com) --- ## Quickstart everywhere: 1DevTool's new welcome screen, one-click agent launchers, and editor back in the center Source: https://1devtool.com/blog/quickstart-everywhere-welcome-screen-and-agent-launchers Published: 2026-05-21 Tags: welcome-screen, layouts, onboarding, terminals, windows v1.18.7 turns the empty state into a launchpad: a welcome screen with five project-picker tiles, six color-matched agent buttons on empty terminals, the editor back in the center column, and two new built-in layouts — Terminal Center and Terminal Right. A new developer joins your team. They install 1DevTool for the first time. You watch them stare at an empty window with a single "+ Add Project" button, click it, and immediately face a dialog asking *which kind of project?* — followed by a second screen asking for a path, and a third asking which agent to launch in the terminal. By the time anything is actually on screen, they've made four decisions for an answer they already knew when they downloaded the app: "I want to clone our staging repo." Or maybe it's not a new teammate. Maybe it's you, on a Monday morning, opening a project you haven't touched in a month. The terminal grid is empty. You want a Claude session next to a bash shell. You click "+", pick "Custom", scroll the dropdown, type the startup command. Three clicks for something you do twenty times a day. Quickstart everywhere is the theme of v1.18.7. The first click and the empty state both get dragged out of the dialog and onto the surface where you actually work. ## What changed The welcome screen turns "add a project" into one tile-click instead of a dialog walk. The empty terminal grid turns "spawn an agent" into one button-click instead of a picker. And the editor — long pinned to the right sidebar as just another tab — moves back to the center column where code-on-top, terminal-underneath is the natural shape of a coding session. ![New 1DevTool welcome screen with five tiles for Open Folder, Create New, Clone Git Repo, Connect SSH, and From Template](/app-screenshots/onboarding.jpg) ## How it works in practice ### One click to start a project The welcome screen replaces the empty "+ Add Project" state with five large tiles: **Open Folder**, **Create New**, **Clone Git Repo**, **Connect SSH**, and **From Template**. Each tile pre-selects its mode in the Add Project dialog, so the dialog opens in the right state instead of waiting for you to pick one. Click Clone, and the dialog lands you straight on the GitHub-account-and-repo picker — no first-screen question, no extra click. Click SSH, and your saved hosts are already showing. If you already have projects in your workspace, the welcome screen reads the room: instead of pushing you to add another, it reminds you to pick one from the sidebar or hit `⌘P` for the command palette. ### One click to start an agent Open a project with no terminals and you get a small empty state — `No terminals yet`, `Pick an agent to launch, or open the full picker` — followed by six color-matched buttons: Claude, Codex, Gemini, Amp, OpenCode, and bash. Each spawns the right CLI in a new terminal in a single click. ![Empty terminal grid showing one-click launchers for Claude, Codex, Gemini, Amp, OpenCode, and bash next to a New Terminal button and a Settings shortcut](/app-screenshots/onboarding_terminals.jpg) If you need something off the menu — a custom startup command, a non-default shell — the **New Terminal** button (with its `⌘T` keyboard hint) opens the full Add Terminal dialog. And if your default agent is wrong, a Settings shortcut on the empty state jumps straight to the Terminal Settings tab, so changing your default doesn't require digging through the preferences tree. ### The editor moves back to the center For a few months the editor lived in the right sidebar, next to Browser and Database and HTTP, all of them sharing one narrow column. It worked for short edits but cramped anything longer than a screen. In v1.18.7 the editor returns to the center column, above your terminals — the classic IDE arrangement where the code is the main canvas and the terminal sits underneath it. The Settings dialog gets the same treatment: it now opens at near-full window width, so the Layout Editor, the Commands list, and the Detected CLIs panel have room to render without horizontal scrolling. ### Two new built-in layouts: Terminal Center and Terminal Right If you live in your terminals more than your editor — say, you spend most of your day orchestrating AI agents — the built-in presets now include two terminal-first layouts. ![Terminal Center built-in layout: project icon strip on the left, terminals filling the center column, and a right sidebar that pins the file tree alongside Editor, Browser, HTTP, Database, Mobile, and AI Diff tabs](/app-screenshots/terminal_center_layout.jpg) **Terminal Center** puts terminals in the middle of the workspace. Project icons sit on the far left, the chat-style channel sidebar and terminal view fill the center column, and a split right sidebar pins the File Tree alongside Editor / Browser / HTTP / Database / Mobile / AI Diff / Tool Box. ![Terminal Right built-in layout: project icons on the left, file tree plus tool tabs in the center, and terminals filling the entire right column](/app-screenshots/terminal_right_layout.jpg) **Terminal Right** mirrors that arrangement: the File Tree and tool tabs split the center column, and terminals fill the entire right column. The result is a layout where you can scan code on the left while AI agents work on the right without the two competing for horizontal space. Both presets auto-apply the chat-style terminal grid, so the channel sidebar comes along with the preset — no separate layout switch required. The built-in preset list itself is now smaller and sharper: Default, Chat Interface, Terminal Center, and Terminal Right. Focus, Terminal, Web Dev, API Dev, Database, and AI Collab have been retired in favor of the more powerful Layout Editor and your own custom presets. Anyone on a removed preset auto-migrates to Default, with their actual panel arrangement preserved. ### Jump back to the tail with one click Scrolling up to read past output used to mean scrolling all the way back to the live tail by hand. A floating **jump-to-bottom pill** now appears in any terminal the moment you're no longer at the tail — ringed in your accent color, visible against any terminal background, one click to snap back to live output. ![Floating jump-to-bottom pill in the corner of a long terminal session, ringed in the accent color so it stays visible against the terminal background](/app-screenshots/scroll-arrow.jpg) The pill is smart enough to disappear when it would get in the way. In reader mode and on alt-screen TUI apps (vim, htop, tmux) it hides itself, so it never overlaps with the TUI's own UI. ### Drag tabs, inspect ports, and keep layouts straight Three smaller-but-loved improvements round out the release. The right sidebar's tabs — Browser, Editor, HTTP, Database, Mobile, AI Diff, Tool Box — are now **drag-reorderable**, with the new order persisting per project so each project carries its own ordering. The **Port Manager** now expands inline when you click any PID: parent PID, user, CPU%, memory%, RSS, started-at, state, working directory, and the full command line all show up under the row, with a per-row Copy command button on hover. And the Agent Input `@`-mention picker is much faster — it searches lazily in the main process via `execFile` instead of synchronously enumerating ten thousand files when the overlay first opens, which fixes the "typing `@` takes three seconds on Windows" symptom on large monorepos. ## Before vs after | The old workflow | v1.18.7 | | --- | --- | | Empty state shows one ambiguous "+ Add Project" button. Click → pick mode → pick path. | Welcome screen shows five tiles. Click → land in the right pre-configured flow. | | Empty terminal grid: Add Terminal → pick agent → pick shell → maybe pick a preset. | Empty grid shows six color-matched agent buttons. One click spawns a running CLI. | | Editor lives in the right sidebar, cramped between Browser and Database. | Editor in the center column above terminals — classic IDE shape. | | Right-sidebar tabs are fixed order. Tools you use least sit next to tools you use constantly. | Drag any tab. Order persists per project. | | Scrolling up means losing your place getting back. | Jump-to-bottom pill in the corner. One click back to the tail. | | Click a PID in Port Manager → run `lsof`/`ps`/`pwdx` in a terminal to find out what it is. | Click a PID → CPU%, memory%, working directory, full command line all show up under the row. | | Agent Input `@`-mention freezes for 3 seconds on a large Windows monorepo. | Lazy search via `execFile`. Snappy on any project size. | ## Who benefits most **Teammates onboarding to 1DevTool.** The welcome screen turns "first project in five clicks" into "first project in one click". The new defaults nudge them into a sensible layout without an opinion lecture. **Developers who live in terminals.** Terminal Center and Terminal Right are designed for the workflow where AI agents and shells are the primary surface and code is something you read while they work. **Windows monorepo users.** The `@`-mention fix alone is worth the upgrade — a project with 5,000+ files no longer stalls the overlay every time you reach for it. ## Try it Download v1.18.7 and open a fresh project. The welcome screen and the empty terminal grid do the rest — most of the upgrade is just *less* clicking to get to the same place. Open the layout picker in Settings to try Terminal Center or Terminal Right; if your eye lands on a built-in preset that's no longer there, you'll already be on Default with your panels preserved. --- ## Toolbelt for AI agents: 1DevTool gives Claude, Codex, and friends HTTP and database tools Source: https://1devtool.com/blog/toolbelt-for-ai-agents-http-and-database-mcp Published: 2026-05-20 Tags: mcp, ai-agents, http-client, database, sub-agents v1.18.6 adds two MCP servers that hand AI agents the tools they kept asking you to use for them: a `request` tool for HTTP through your project's auth and environment, and a `1devtool-database` server for queries that respect safe mode without exposing credentials. You're debugging a flaky staging endpoint. You ask Claude to check whether `/api/orders/42` returns the right shape. Claude can't actually call the endpoint — it's an LLM, not an HTTP client — so it writes you a `curl` command. You paste it into your terminal. The response comes back. You paste *that* into the chat. Claude reads it, asks for another endpoint to compare against. Same loop. You're the messenger. Now imagine the same conversation about a Postgres query. *"What's the row count on `orders` for last week?"* Claude can't query the database either, so it writes you a SELECT. You paste it into the SQL editor. You paste the result back. Loop. Loop. Loop. v1.18.6 is the release that hands AI agents the tools they kept asking you to use for them. There's a new `request` MCP tool that lets Claude, Codex, Gemini, and OpenCode fire HTTP requests through your active project's environment, and a new `1devtool-database` MCP server that lets them query your configured database connections — without seeing the credentials, and without bypassing safe mode. ## What changed This release adds two MCP servers and a system tab that finally answers "is the right CLI even on my PATH?" Plus a sub-agent history viewer so you can see what nested agents are actually doing. ![1DevTool Settings → MCP showing the new HTTP and Database MCP servers ready to install across Claude, Codex, Gemini, and OpenCode](https://github.com/user-attachments/assets/b38f22be-31f8-40c7-b615-0d2c6c05ef8c) ## How it works in practice ### HTTP requests, run by the agent through your environment Every supported AI client — Claude, Codex, Gemini, OpenCode — now gets a `request` MCP tool. It takes a method, URL, optional headers and body, and runs the call **through your active project's HTTP client setup**: the bearer tokens, basic auth, base URL, and any project-level headers you already configured. It returns status, headers, body, and latency in one structured response. So instead of being the messenger, you ask: *"Hit `/api/orders/42` on staging and tell me whether `total` matches `sum(items[].subtotal)`."* The agent does it. It uses the staging environment, the staging bearer, the staging base URL — because that's what your active project is set to — and reports back. There's also a `run_saved_request` tool that lets agents fire any saved request from your HTTP collection by name. *"Re-run the staging health check"* picks the right URL, environment, and auth without you having to spell out the URL. And `list_environments` and `list_saved_requests` let agents browse your collection so you can ask follow-ups like *"which environment is this request in?"* without pasting URLs every time. ### Database queries, agent-issued but credential-safe The other new MCP server is `1devtool-database`. It exposes every database engine 1DevTool supports — Postgres, MySQL, MongoDB, Redis, Elasticsearch, and the rest — to AI agents through four tools: `list_connections`, `describe_schema`, `preview_table`, and `query`. The important thing is what doesn't move: credentials never leave 1DevTool. Agents see connection *names* via `list_connections`, never connection strings. When they call `query` or `preview_table`, the call goes through 1DevTool's existing connection pool. Each connection's `safeMode` flag and the same read-only / write detection that the manual SQL editor uses still gate every agent-issued query. A read-only connection stays read-only no matter what the agent asks. When an agent runs a query, the result streams into a new "AI query" tab next to your own queries in the Database panel, and the SQL is captured into history. You can audit exactly what the agent asked and what it saw. ### Detected CLIs — finally, an answer to "is this on my PATH?" The new **Detected CLIs** section under Settings → General → System scans every supported AI agent (Claude, Codex, Gemini, OpenCode, Amp, Qwen, Aider) plus runtimes, package managers, dev tools, and database CLIs in parallel. Each row reports a state: `detected`, `override`, `ambiguous` (multiple paths found — pick one), `not-found`, `unverified`, `timeout`, or `error`. You see the actual paths, the detected version, and how long the probe took. A Cancel button appears after four seconds, so a flaky NFS share or a broken symlink in your PATH can't lock the dialog. Per-row Retry handles individual timeouts. Slow paths get quarantined automatically with an "Include anyway" escape hatch. And if you have a CLI 1DevTool doesn't know about, you can add it to the list with a name and binary — it shows up alongside the built-ins everywhere 1DevTool reaches for a CLI. This is the answer to a question every multi-tool setup eventually faces: *"Why doesn't this work on this machine?"* You stop guessing. ### Sub-agent badge and history viewer Modern AI CLIs spawn sub-agents constantly — Claude fires off bash sub-agents and tool-call agents, OpenCode runs summarizer passes, Aider chains edits. Until now, you had no way to see what those nested agents were actually doing without opening their log files by hand. A small **sub-agent badge** now appears on any running terminal whose CLI has spawned a nested agent. The badge shows which CLI is running underneath and how long it's been alive. Click the badge and a separate window live-tails the sub-agent's session log, color-coded per CLI: Claude amber, Codex green, Gemini violet, Amp pink, OpenCode blue, Qwen indigo, Aider red. The viewer parses JSONL, JSON, and markdown session formats the same way — assistant text, thinking, tool calls, tool results, system messages, and turn durations all show up with the labels each CLI actually uses. ### Smaller things, all worth a line OpenCode joins the MCP settings tab as a first-class client — one-click install / uninstall of channels, database, design, and http MCP servers into `~/.config/opencode/opencode.json`, matching the existing flow for Claude, Codex, and Gemini. Drag-and-drop from Finder / Explorer can now target **any sub-folder at any depth** in the file tree — it used to always land at the project root. Hovering a folder highlights it as the drop target, and dropping into a collapsed sub-folder auto-expands it so you immediately see what landed. Opening a file from the file tree now auto-focuses the editor panel in whichever slot it lives — no more hidden-behind-the-Browser-tab moments. The MCP settings tab splits Tools from External clients into two sub-tabs. The Tools sub-tab lists every MCP tool registered with 1DevTool — name, profile, description, output kind, mutates / long-running flags, enable state — so you can see exactly what's exposed to AI agents at a glance. The bridge health badge now reports how many tools are registered and the registry's revision, so a stale process or a bridge restart is immediately obvious. The browser viewport in the Send-to-Terminal dialog is now tracked live, not snapshotted — it updates whenever you resize the panel, toggle the debug console, or switch device-emulation modes. ![Browser viewport dimensions tracked live in the Send-to-Terminal dialog, updating as the panel resizes or the device-emulation mode changes](https://github.com/user-attachments/assets/4ee97d1a-3433-4f54-aac4-c7b180744166) And terminal session recording (the MP4 export and share-menu flow) has been retired. Transcript copy-paste, the new Sub-Agent History viewer, and channel history cover the same ground with less footprint — recording will return in a different form if there's demand for it. ## Before vs after | The old workflow | v1.18.6 | | --- | --- | | AI agent writes a `curl` for you. You run it. You paste the response back. | Agent calls `request` directly. Response lands in the chat in one round-trip. | | AI agent writes a SELECT. You paste it into the SQL editor. You paste results back. | Agent calls `query` against the right connection. Results stream into an audit tab. | | Paste connection strings into chat so the agent can "help". | Agent sees connection *names* via `list_connections` — credentials never leave 1DevTool. | | Read three blog posts to guess whether Claude is on this machine's PATH. | Detected CLIs scans every supported CLI with versions, paths, and per-row diagnostics. | | Tail Claude's session log in a separate terminal to see what its sub-agents are doing. | Click the sub-agent badge → color-coded live viewer in a separate window. | | Manually paste files into the project root, then move them with the file tree. | Drag-and-drop straight onto any sub-folder at any depth. | ## Who benefits most **Anyone who has ever been the messenger between an AI agent and a tool.** The `request` and `1devtool-database` MCP tools turn that loop into a single sentence to the agent. **Teams that share databases.** Safe mode plus credentials-never-leave-the-app means the agent can investigate without you handing it the keys. **Multi-machine developers.** The Detected CLIs section is the fastest way to answer "what's actually installed on this box?" without leaving the app. ## Try it Update to v1.18.6 and open Settings → MCP. Install the http and database MCP servers into whichever AI client you use. The next time you'd reach for the messenger pattern — *"I'll paste it"*, *"let me run that for you"* — try asking the agent to do it directly. The clipboard hop disappears. --- ## Edit Mermaid diagrams visually — no more hand-tweaking syntax until the layout looks right Source: https://1devtool.com/blog/visual-mermaid-diagram-editor Published: 2026-05-10 Tags: mermaid, diagrams, visual editor, markdown, ai-friendly v1.18.3 ships a full visual editor for Mermaid diagrams: click any rendered diagram in markdown to open a lightbox, drag nodes, recolor, restyle edges, and save the layout back into the source. Plus on-the-fly startup command presets and a saner Mermaid renderer for AI-generated diagrams. An AI agent gives you a Mermaid diagram. The shape is mostly right but the layout is a tangle — two nodes are stacked on top of each other, the labels overflow, that one important node is buried in the middle of the graph instead of at the entry point. You know what you want, and you know it would take ten seconds in a visual editor to drag things around. But Mermaid is text. So you go back to the source. You guess at coordinates. You add `style` directives by trial and error. You hop back to the preview, see what changed, hop back to the source, change another value, render again. After fifteen minutes you have something that looks acceptable, and you've forgotten what you were originally trying to document. ## What changed In v1.18.3 you can now click any rendered Mermaid diagram in a markdown preview to open it in a full visual editor. You drag the nodes where you want them, right-click to recolor and restyle edges, and Save writes the updated Mermaid source — including layout positions and styles as native `style` directives — straight back to the markdown file. ![Visual Mermaid Diagram Editor showing live source-and-canvas split view with a flowchart on the right and the raw Mermaid syntax on the left](/app-screenshots/mermaid_editor.jpg) ## How it works in practice ### Click the rendered diagram, edit on a canvas In any markdown file with a Mermaid block, the rendered preview is now a live entry point. Click it and a lightbox opens with the visual editor: your diagram on a real canvas, every node draggable, every edge selectable. Drag a node and its position persists per file — the layout sticks across sessions instead of resetting to whatever Mermaid's auto-layout produces every time you reopen the file. ![Drag-and-drop node positioning inside the visual Mermaid editor — pick a node up and drop it where you want it](/app-screenshots/drag_and_drop_elements_in_mermaid_editor.jpg) Right-click is where most of the styling lives. Right-click a node to pick a color from a preset palette of 8 friendly colors — no hex pickers, no guessing. Right-click an edge to set arrow direction (forward, backward, both, or none) and line style (solid, dashed, or dotted). The choices you make on the canvas are encoded back into the Mermaid source as native `style` directives, so when the file renders anywhere else — GitHub, your blog, a docs site — it looks the same. ### Source and canvas in sync The lightbox shows the visual editor next to the raw Mermaid source. Edits you make on either side update the other in real time. So if a quick text edit is faster than a drag (renaming a node, adding a new arrow), you can do it in the source pane and watch the canvas update. And if you want to see exactly what your visual changes produced, the source pane shows you the new Mermaid syntax line by line as you click around. ### Save writes straight to disk One more thing about the workflow: hitting Save in the lightbox writes the updated Mermaid source straight to the markdown file, no waiting for the regular auto-save debounce. The diagram you just laid out is on disk by the time the lightbox closes — no risk of losing the layout to a refresh, no second click to confirm. ## A nicer Mermaid renderer for AI-generated diagrams The other half of v1.18.3 is renderer fixes that make AI-generated Mermaid actually render. Three patterns that used to break: - **Literal `\n` inside node labels.** AI agents emit `\n` (the two characters) inside Mermaid labels expecting a newline. Mermaid 11+ rejected these as `Invalid syntax`. 1DevTool now rewrites them to `
` so the diagram renders the way the AI expected. - **Bracket labels starting with `/` or `@`.** Patterns like `F[/urd /brd /prd]` (Mermaid thought it was a parallelogram) and `G[@handle: foo]` (Mermaid thought it was shape-data) used to fail the parser. They're now quoted automatically and render as plain rectangles. - **Successful diagrams flagged as errors.** A defensive check that mistook Mermaid 11's built-in `.error-icon` CSS class for a real error icon was tripping on every successful render. The check is gone. If you've been pasting AI-generated Mermaid into 1DevTool and watching half of it fail to render, that half should now render. ## Before vs After | Workflow | Before v1.18.3 | After v1.18.3 | |---|---|---| | Adjust the layout of a Mermaid diagram | Edit source, render, eyeball, edit source again — repeat for fifteen minutes | Click the diagram, drag nodes on the canvas, hit Save | | Recolor a node | Add a `style nodeId fill:#hex,stroke:#hex` line by hand | Right-click the node, pick from a preset palette | | Change arrow direction or line style | Edit the edge syntax in source by hand | Right-click the edge, pick the new direction and style | | Diagram from an AI agent that uses `\n` in a label | `Invalid syntax` error | Renders with line breaks the way the AI intended | | Save a one-off custom startup command | Bounce into Manage Commands → fill the form → save → return to New Terminal | Type the command in the New Terminal dialog → click `Add ` → launch | ## Also in v1.18.3 **Save Custom Startup Commands On The Fly.** When no preset matches your search in the New Terminal dialog, an `Add ` button now appears under the empty results. One click saves it as a custom preset under the current tab (Terminal or AI Agents), selects it for the new terminal, and you're ready to launch. No more detour through Manage Commands just to add a one-liner. **Markdown outline visibility persists.** Closing the markdown outline panel now stays closed across sessions, so you don't dismiss it every time you open a new markdown file. ![Markdown editor with the '14 headings' outline toggle visible — closing it now persists across sessions](/app-screenshots/markdown_hide_outline.jpg) **Light theme polish.** The Agent Input overlay's default Lowkey persona switches to a soft light-gray palette in light mode instead of forcing a dark navy frame onto a light workspace. And a global CSS rule that was overriding every `transparent` input with a solid background — most visibly in the Agent Input composer and across the Developer Toolkit (JSON Formatter, JWT Decoder, Regex Tester, Diff Viewer, etc.) — is gone, so transparent inputs actually render transparent again. ## Try it Update to v1.18.3, open any markdown file with a Mermaid diagram, and click the rendered output. Drag a node. Right-click another. Hit Save. Watch the source pane fill in with the `style` directives that capture what you just did, and watch your markdown file update on disk in the same beat. The text-only round-trip for tweaking diagrams is over. You can finally fix the layout instead of just settling for it. --- ## Start AI agent workflows from a template — channels in v1.18.0 Source: https://1devtool.com/blog/start-agent-workflows-from-templates Published: 2026-05-05 Tags: multi-agent, channels, templates, ai-workflow, free-tier Multi-agent runs always begin with the same orchestration boilerplate. v1.18.0 ships built-in templates for Fix Bug, Code Review, PR Review, Write Tests, Audit, Refactor, plus a dedicated channel workspace, faster routing, and a friendlier Free tier. Every multi-agent run begins the same way. You open a channel, you pick which agents you want, you remember the prompt that worked last time and try to reconstruct it, you @mention three things, you fix a typo, and only then does the actual work start. The orchestration is repetitive but it isn't reusable — every new task starts from blank, even when the shape of the request is identical to one you ran yesterday. Code Review is always Code Review. Fix Bug is always Fix Bug. The agents change, the files change, the bug changes — but the scaffolding around them is exactly the same paste job you've been doing for weeks. ## What changed In v1.18.0 you no longer rebuild the scaffolding by hand. 1DevTool ships with workflow templates for the things you do most often — Fix Bug, Implement Feature, Code Review, PR Review, Write Tests, Audit, Refactor — so you start from a populated channel, fill in the agent slots and the prompt fields, and run. Direct-mention requests now route through a fast path by default instead of sitting through the heavy planning loop, and the whole channel system has a dedicated floating workspace so it stops competing with your editor for screen real estate. ![1DevTool's Channels modal showing a multi-agent conversation with mentions, attachments, and template scaffolding](https://github.com/user-attachments/assets/cb31648a-fb3c-400c-9e49-350e09a6f83c) ## How it works in practice ### Pick the workflow, not the boilerplate Open the new template gallery and the most common multi-agent shapes are right there: Fix Bug, Implement Feature, Code Review, PR Review, Write Tests, Audit, Refactor. Each template arrives with the agent slots laid out for that workflow and a prompt skeleton wired in. You drop your specific files, your error message, your branch name into the placeholders — and skip the rebuild entirely. The composer also got smarter while you fill it in. As you type `@`, the autocomplete now suggests terminals, files, folders, and special mentions, with active-project results surfaced first. So even when you're not starting from a template, the round-trip from "I want to mention this file" to "file is mentioned" is a few keystrokes shorter. ### Keep channels in their own floating workspace Channels open in a dedicated movable window now. You can park it on a second monitor, minimise it to a bubble while you keep coding, and restore it without rearranging the rest of your workspace. ![Channel bubble pinned to the workspace edge, showing live agent activity without taking over the screen](https://github.com/user-attachments/assets/20ab5305-b6f3-4dc5-a17e-24f17d24c57b) Inside the channel, attachments are first-class. Mention files or directories, paste images, drag screenshots straight into the composer, broadcast with `@all`, or pull the latest clipboard with `@clipboard`. Cross-project mentions still work, so a single channel can pull agents from multiple projects when the task crosses repo boundaries. ### Fast routing by default, smart orchestration when you want it The biggest invisible change: a direct `@mention` request no longer triggers the heavy planning loop by default. Channels route those requests on a fast path so simple asks land on the right agent right away. The Smart Orchestrator mode is still there for open-ended jobs — flip it on per channel, pick the CLI and model, test the setup before you run. And the chat itself reads cleaner. Repeated startup banners, prompt-frame chrome, and narrow soft-wrapped paragraphs are stripped or reflowed before they hit the bubble, so replies look like messages and not terminal dumps. The channel list also sorts by latest activity now, with compact timestamps and a search box for when you have more channels than the list comfortably shows. ### Send a sticky note straight to AI Every sticky note in 1DevTool can now be sent directly to an AI terminal as a prompt. Quick scratch ideas you jotted down between meetings stop being trapped in note format — one click and the agent is working from your scratch. ## Before vs After | Workflow | Before v1.18.0 | After v1.18.0 | |---|---|---| | Start a multi-agent code review | Open channel, pick agents, paste your standard review prompt, @mention each file by hand | Pick the **Code Review** template, drop in the files, run | | Reach for the Channels view | Switches your active panel; coding view goes away | Floating workspace; minimise to a bubble while you keep coding | | Send a `@mention` request | Goes through Smart Orchestrator's planning loop | Fast routing by default; orchestration only when you opt in | | Read agent replies | Mixed with startup banners and frame chrome | Stripped to the actual reply, formatted as chat | | Free tier ceiling | Hard 500-message lifetime cap | No lifetime cap; AI terminals stay usable on Free | ## Who benefits most **Teams who run code reviews through agents** — the Code Review and PR Review templates make the third or fourth review of the day a one-click setup instead of a full-prompt rebuild. **Solo devs juggling several agents at once** — the floating channel workspace plus the bubble means Channels can stay live in your peripheral vision without crowding the editor. **Free-tier users coming back after a break** — the old 500-message lifetime cap was the main reason Free felt like a trial. Removing it lets you keep working on lighter projects without an upgrade prompt looming over every prompt. ## Try it Update to v1.18.0 (status bar will tell you if you're behind), open Channels, and pick any of the built-in templates from the new gallery. Replace the placeholder agents and prompts with the specifics of what you're working on right now. Then minimise the channel to a bubble and keep coding — the agents will surface back when they have something to say. The orchestration is finally something you set up once and reuse, not something you rebuild every time you sit down. --- ## Stop scrolling your sidebar: nested project groups and search arrive in 1DevTool Source: https://1devtool.com/blog/nested-project-groups-sidebar-search Published: 2026-05-03 Tags: project-groups, sidebar, workspace, prompt-formatter, config-export Twenty projects in a flat list is a scroll job. v1.17.4 introduces nested project groups, sidebar search, a Prettier-style prompt formatter, and PRO config export so you can keep all that organization when you move machines. If your 1DevTool sidebar has grown into a wall of project entries, you already know the feeling: you finish a meeting, swing back to the app to pick up the side project you were poking at last night, and you scan a flat list of twenty-plus rows looking for the right one. You scroll, you squint, you eventually click. The list is doing what it was designed to do — listing your projects — but at this scale it stops feeling like a sidebar and starts feeling like a directory. The other version of this same problem: you're switching between client work and personal hacking, and right now they sit shoulder-to-shoulder. There's no visual line between "work" and "not work," so context-switching costs more than it should. The clutter is mostly visual, but visual clutter is what the sidebar is for. ## What changed In v1.17.4 the Projects sidebar gets nested groups, instant search, an export bundle for moving your whole setup to a new machine, and a one-shot prompt formatter for the Agent Input overlay. You can carve your projects into named groups, nest those groups inside other groups, and stop hunting for things visually. ![1DevTool sidebar showing projects organized into named, color-coded groups with avatar badges](https://github.com/user-attachments/assets/40d44508-5b0d-40f6-918f-d9f51ad8fa04) ## How it works in practice ### Group projects by anything that matters to you Right-click an empty area in the Projects section and pick **Create group**. Drag any project header onto the group and it lands inside. Each group gets a name, a colored dot, an optional avatar image, and an emoji badge — so a single glance at the sidebar tells you you're looking at "Work / Acme Migrations" and not "Personal / Side Projects." You can nest a group inside another group by dragging its header onto a parent. Two levels deep is enough to separate "Work / Clients / Acme" from "Work / Internal," and 1DevTool blocks accidental cycles automatically — you can't drag a parent into its own child. When a group isn't in play right now, click the chevron next to its name to fold it away. The collapsed state is remembered per group, so the sidebar stays calm between sessions instead of resetting to fully expanded every time you launch the app. ### Search instead of scroll There is now a search box at the top of the Projects section. Start typing and the list filters projects and groups by name in real time. If a match lives inside a collapsed group, the parent group auto-expands so the result is always visible — you don't have to know where you organized something to find it. Hit `Esc` to clear the query and bring the full sidebar back. The practical effect: if you can remember any fragment of a project's name, you can be inside that project's terminals in two seconds, regardless of how deep it lives or whether you remember which group you put it in. ### Format AI prompts like Prettier The Agent Input overlay now has a one-shot format action. Hit `Cmd/Ctrl+Shift+F` and your prompt is reflowed: markdown headers and lists tighten up, fenced code blocks are detected, and any embedded JSON, XML, or HTML inside the fences is reformatted into a clean shape before it goes to the agent. ![Agent Input overlay with the new prompt-format button visible in the toolbar](https://github.com/user-attachments/assets/a0a1cc75-d77b-4c4e-bc26-88ca7f8984cc) Next to the format action there is a small toggle for auto-format-on-edit. Once on, large pastes and newline-ended edits are reformatted as you go. The setting is remembered so you don't have to flip it on every session. And the formatter is smart about flow: mid-mention (`@file`) and mid-slash-command edits skip auto-format so your autocomplete isn't interrupted by a sudden reflow. ### Move your whole setup to a new machine (PRO) A new **Export** sub-tab under **Settings → General** packages your project list, project groups, sidebar order, custom themes, Obsidian vault path, and supported workspace preferences as a single `1devtool-config-YYYY-MM-DD.json` file. Run Import on the destination machine and a preview dialog walks you through what's in the bundle, flags any local project folders that don't exist on the new machine, and lets you Relink Folder or Skip Project before applying. The import is atomic and the app prompts to restart so everything rehydrates cleanly. Secrets stay home. License activation, GitHub tokens, global database connections with passwords, HTTP client tabs with auth headers, and runtime session state are never written to the export. Only your workspace configuration travels. SSH-mounted projects keep their canonical `ssh://user@host:port/path` identity, not the temporary local mount path, so they still resolve correctly on the destination. ## Before vs After | Workflow | Before v1.17.4 | After v1.17.4 | |---|---|---| | Find a specific project among 20+ | Scroll the flat list, scan names | Type 3 letters in the sidebar search box | | Separate work from personal | Lived side by side; mental overhead | Two named groups, one collapsed | | Format a long AI prompt before sending | Paste into a markdown editor, format, paste back | `Cmd/Ctrl+Shift+F` in the overlay | | Move your 1DevTool setup to a new laptop | Recreate every project, rebuild groups, reimport themes by hand | Export from old machine, Import on new — preview, relink, restart | ## Who benefits most **Consultants and freelancers juggling client work** — the group-per-client model was the obvious organisation, you just couldn't express it before. Now you can collapse the clients you're not on this week and the sidebar reflects what's actually active. **Anyone running a side-project alongside a day job** — putting "Work" and "Personal" in two distinct groups draws a visible line between them, which makes it harder to drift across the boundary by accident. **Developers who switch machines often** — desktop, laptop, work loaner, fresh OS reinstall. Export/Import means your sidebar layout, themes, and project list aren't tied to one specific machine anymore. ## Try it Update to v1.17.4 from the in-app updater (or the status-bar update button — also new in this release). Open the sidebar, right-click an empty area in the Projects section, and create your first group. Drop a project into it. Then try the search box: start typing the name of any project — even one inside a collapsed group — and watch the sidebar reorganize itself around what you actually care about right now. You stop scrolling. You stop hunting. The sidebar starts to feel like yours. --- ## OpenCode Now Runs Inside the 1DevTool Workspace Source: https://1devtool.com/blog/opencode-cli-in-the-workspace Published: 2026-05-02 Tags: opencode, ai-agents, cli, terminal, session-resume OpenCode is now a first-class agent in 1DevTool. Launch the full TUI inside your workspace, resume sessions from the Resume dialog, autocomplete slash commands, and find your OpenCode prompts in Prompt History. OpenCode is a fast, keyboard-driven AI coding CLI with its own session history, slash commands, and a TUI that takes over the terminal. Until now, running it meant opening a separate terminal window or tab, keeping it alive in its own pane somewhere, and `Cmd+Tab`-ing back to 1DevTool whenever you wanted to see your code, your browser, or your database alongside it. If you wanted to resume an OpenCode session, you had to remember the session ID or dig through its own session list in a separate terminal. And if you used Prompt History to search across your AI conversations, OpenCode prompts weren't there — because 1DevTool didn't know they existed. ## OpenCode Runs Inside the Workspace, Like Every Other Agent OpenCode is now a first-class agent in 1DevTool. Pick it from the agents grid in the New Terminal dialog and the full OpenCode TUI launches in a terminal panel inside your workspace — next to your editor, next to Claude Code or Codex, next to your HTTP client or database browser. Mouse support, scroll, full-screen redraws — all of it behaves the way it does in a standalone terminal. The only thing that changes is that you no longer leave 1DevTool to use OpenCode. ## How It Works in Practice ### Launch OpenCode from the agents grid Click the `+` button to open a new terminal and OpenCode appears in the agent picker alongside Claude, Codex, Gemini CLI, and Amp. Select it and a terminal opens running the OpenCode TUI. You can launch multiple OpenCode terminals in different projects, tile them with other agents, or run one in the background while you work in another. ### Slash commands autocomplete in the prompt overlay Hit `Cmd/Ctrl+I` on an OpenCode terminal to open the Agent Input overlay — the same overlay that works for Claude Code and Codex. Start typing `/` and the picker lists every built-in OpenCode slash command: `/models`, `/sessions`, `/init`, `/themes`, `/connect`, `/share`, `/undo`, `/redo`, `/compact`, `/export`, `/exit`, and more, each with a short description pulled from the OpenCode docs. This means you don't need to remember OpenCode's command set. The picker surfaces the right command as you type. ### Resume OpenCode sessions from the Resume dialog The Resume dialog now reads OpenCode's local session database alongside Claude, Codex, Gemini, and Qwen sessions. Filter by "OpenCode", browse by project, or search by content to find any past OpenCode conversation. Picking an OpenCode session spawns a terminal that opens directly into that conversation using OpenCode's native `-s` flag. Reopening the terminal later relaunches into the same session automatically — no stale `--resume` artifacts, no manual session ID lookup. ### OpenCode prompts appear in Prompt History The "Sync local" button in Prompt History and the Resume dialog now imports your OpenCode prompts alongside everything else. Search across every agent's history — Claude, Codex, Gemini, OpenCode — in one place. The prompt you sent last week in an OpenCode session shows up the same way as a Claude prompt from yesterday. ## Before vs After | Task | Before | After | |------|--------|-------| | Run OpenCode | Open separate terminal, `Cmd+Tab` to switch | Open as agent terminal in 1DevTool | | Resume an OpenCode session | Find session ID, run `opencode -s ` manually | Resume dialog → filter by OpenCode → click | | Use slash commands in OpenCode | Type from memory or check docs | `Cmd+I` → `/` → pick from autocomplete | | Search OpenCode prompts in history | Not available in 1DevTool | Sync Local → searchable in Prompt History | | Run OpenCode next to Claude | Two windows, constant switching | Two terminal panels, side by side | ## Who Benefits Most **Developers who use multiple AI coding tools** — If you already run Claude Code and OpenCode in separate terminals, having them both inside 1DevTool means you can keep them side by side, compare responses, and resume either session from the same place. **OpenCode users evaluating other agents** — The Resume dialog's cross-agent resume (added in v1.15.2) applies here too: start a session in OpenCode, resume it in Claude, or vice versa. One click to hand a conversation to a different model. **Anyone who forgets slash commands** — Even if you know OpenCode well, the autocomplete in the prompt overlay removes the "what was that flag again?" moment for less-used commands. ## Try It Open a new terminal in 1DevTool, find OpenCode in the agents grid, and launch it. The TUI comes up in the panel. Hit `Cmd+I` to open the prompt overlay and type `/` to see the command list. When you're done, close the dialog and the session is waiting in your Resume list — ready to pick up in OpenCode or any other agent you prefer. --- ## Open Files from Finder Straight into Your Workspace Source: https://1devtool.com/blog/open-files-from-finder-into-workspace Published: 2026-04-24 Tags: workflow, files, productivity, terminals, finder Set 1DevTool as the default app for .md, .json, .yml, and .txt files, and double-clicking them opens straight into your workspace — in the right project, ready to edit or send to an AI agent. You're reviewing a markdown file someone sent you, or you just downloaded a JSON response you want to inspect. You double-click the file in Finder. It opens in your system's default editor — probably TextEdit, Notes, or VS Code — which is probably not where your active project is or where your AI terminals are running. Getting the file into 1DevTool meant dragging it manually, using the file tree, or copy-pasting the contents in. A small friction, but it interrupts the flow every time. ## Open Files from Your OS Directly into the Workspace You no longer have to drag files into 1DevTool. Set 1DevTool as the default app for `.md`, `.txt`, `.json`, `.yml`, and `.yaml` files, and double-clicking opens them straight into your workspace. The file appears in the editor, inside the right project, ready to edit or send to an AI agent. 1DevTool also handles the project question automatically: if the file lives inside an existing project folder, it switches to that project. If not, it creates a new project from the file's parent folder on the spot. ## How It Works in Practice ### Double-click → straight into your workspace After setting 1DevTool as the default for supported file types (right-click → Open With → Set as default in Finder, or the equivalent in Windows Explorer), opening any `.md`, `.json`, `.yml`, or `.txt` file from the OS routes it directly into 1DevTool's editor. There's no separate "import" step, no dialog to navigate. The file opens where you'd expect it to — in your editor panel, in whatever project it belongs to. ### The right project opens automatically If the file you opened lives inside a folder that 1DevTool already knows as a project, 1DevTool switches to that project before opening the file. You land in the right context without manually navigating. If the file's parent folder isn't a project yet, 1DevTool creates one from it. You can start editing immediately and the project persists for next time. ### Terminals under each project in the sidebar The same release adds a toggle to the Projects section that reveals visible terminals directly under their project in the sidebar. When you have multiple projects open with multiple AI terminal sessions running, this gives you a map: which project has active work, and which terminal is running in it. Click a terminal row in the sidebar and the terminal panel focuses and switches to that session. You no longer have to remember which terminal you left something in — you can see it at a glance. ## Before vs After | Task | Before | After | |------|--------|-------| | Open a `.json` file from Finder | Opens in TextEdit or VS Code | Opens in 1DevTool editor, in the right project | | Open a file from an existing project | Drag into 1DevTool, navigate file tree | Double-click → jumps to project and opens | | Open a file from a new folder | Drag, create project manually | Double-click → project auto-created | | Find which terminal is running what | Check each terminal panel | Terminals listed under projects in sidebar | | Jump to a specific terminal | Click through terminal tabs | Click the terminal row in the sidebar | ## Who Benefits Most **Anyone who handles a lot of files outside their editor** — If you regularly get Markdown docs, JSON payloads, or YAML configs from email, Slack, or downloads, the default-app change eliminates the step of manually bringing those files into your workspace. **Developers with multiple active projects** — When you have five projects open and a dozen AI terminals running, the terminal sidebar gives you a layout overview without clicking around. You can see at a glance which project has an active agent session and jump there directly. **Teams reviewing files together with AI** — Opening a file from Finder and immediately having it inside a project next to your AI terminals makes the "review this file with the agent" workflow a single gesture instead of several. ## Try It In Finder, right-click a `.md` or `.json` file, choose Open With, select 1DevTool, and check "Always Open With." From then on, double-clicking those files routes them into your workspace. For the terminal sidebar, look for the toggle in the Projects panel header — flip it on and your active terminal sessions appear under each project. --- ## Build and Run iOS/Android Apps Without Leaving Your Workspace Source: https://1devtool.com/blog/build-run-ios-android-without-leaving-workspace Published: 2026-04-23 Tags: ios, android, mobile, simulator, build A new Build panel in 1DevTool lets you compile and install iOS or Android apps directly onto the simulator mirror — no switching to Xcode or Android Studio. Write, build, and see the result in one window. Every iOS and Android developer using an AI coding workflow knows the rhythm: write code in your editor, flip to the terminal to run the build, watch the logs scroll in a separate window, wait for the simulator to come up, flip back to look at the result, then flip back again to your AI agent. At any given moment you're managing four or five windows to do something that's logically one thing. That friction compounds when you're iterating fast with an AI agent. You ask the agent to fix a layout bug, it makes a change, and now you need to verify the fix on device. Each verification cycle costs you a context switch. ## Build and Run Without Leaving the Workspace You no longer have to switch to Xcode or Android Studio to build and run your app on a simulator. A new Build panel lives in the Mobile section of 1DevTool — the same panel where the simulator mirror runs. Click Build, watch the log, and the updated app appears on the mirrored device without you going anywhere. The full loop — write, build, see — happens in one window. ## How It Works in Practice ### iOS: from source to running simulator The Build modal scans your project for `.xcodeproj` and `.xcworkspace` files, picks a sensible default scheme, and fills in the destination as the simulator currently mirrored in 1DevTool. Hit Build and `xcodebuild` runs. The Logs tab streams the output in real time: compiler steps, signing, install, launch. When it finishes, the simulator mirror shows the updated app. You can override scheme, configuration (Debug/Release), destination, derived data path, and project root before building. For most projects the defaults are right and you just click Build. ### Android: Gradle build + emulator in one shot The Android Build modal works the same way. It detects `JAVA_HOME` from Android Studio's bundled JBR (or your system Java), runs your `assembleDebug` task, installs the APK onto the selected emulator, and launches the activity by name. If the emulator isn't running, 1DevTool boots it first so you don't have to remember to start the device before building. Override Gradle project path, package name, assemble task, install task, and activity name if you need to. Sensible defaults are inferred from the project structure so most Android projects need zero configuration. ### The build log lives next to the simulator Build output streams into the Logs tab as it runs. A successful build shows `Built MyApp (Debug)`; failures surface inline with the error message. You don't chase errors in a separate Xcode window or terminal — the log is right there, next to the running app, and you can paste it directly into an AI terminal to ask for help. ### Screenshot to AI closes the loop Once the updated app is running, hit the screenshot button on the simulator mirror and the PNG opens in the Send to AI dialog with device metadata pre-filled. Ask your AI agent whether the layout fix looks right, paste the screenshot as evidence of a bug, or describe what you see and let the agent suggest the next change. The whole cycle stays in 1DevTool. ## Before vs After | Step | Before | After | |------|--------|-------| | Build iOS app | Cmd+Tab to Xcode, hit Cmd+R, watch Xcode build pane | Build modal in 1DevTool, log in Logs tab | | See result on simulator | Simulator window opens separately | Simulator mirror in the same panel | | Build Android app | Switch to Android Studio or run Gradle in terminal | Build modal, auto-boots emulator | | Send screenshot to AI agent | Screenshot, save file, attach manually | Screenshot button → opens in Send to AI | | Check build errors | Read Xcode/Gradle output in separate window | Logs tab, inline in the same panel | ## Who Benefits Most **Solo mobile developers working with AI agents** — You're already using an AI to write or fix code. The build-and-run loop is the bottleneck. Keeping it in the same window means your AI agent and your running app are always one glance apart. **React Native and Flutter developers** — Both frameworks require running the app frequently to see changes. The shorter the feedback loop, the faster you can iterate. **Anyone context-switching between Xcode and their dev setup** — If you've ever lost your train of thought because you had to go into Xcode and come back, this removes that switch from the workflow. ## Try It Open a mobile project in 1DevTool, click the Mobile tab, and look for the Build button in the simulator panel. The modal will pre-fill your project's scheme and simulator. Hit Build, watch the log, and see your app update in the mirror — without leaving the window you're already in. --- ## iOS Simulator Mirror and an IDE-Style Database Workspace in 1DevTool Source: https://1devtool.com/blog/ios-simulator-mirror-database-workspace Published: 2026-04-22 Tags: ios-simulator, mobile-testing, database-workspace, query-editor, glide-data-grid, claude-code, codex-cli, gemini-cli, developer-workflow, terminal-focus-mode 1DevTool v1.17.0 brings a live iOS simulator with real input and inspection, plus a tabbed database workspace, global HTTP/DB state, and terminal focus mode. If you build and test apps while running AI coding agents, you probably know this loop too well: write code in one window, switch to a phone simulator, switch again to run SQL, switch again to ask Claude Code or Codex CLI what just broke. The context switching is small each time, but the day disappears in dozens of tiny interrupts. 1DevTool v1.17.0 changes that loop in a practical way. Instead of treating mobile testing and database work as separate tools, it brings both into the same workspace where your terminals already run Claude Code, Codex CLI, Gemini CLI, and your project commands. ## Why this matters The release is not just "more panels." It changes how you debug: - Your iOS simulator can stay visible next to code and terminals, with real input events instead of a passive preview. - Your database client now behaves like an IDE workspace, not a single-query utility. - Core state (connections and HTTP requests) can follow you across projects. - Session-resume data moved to a local SQLite store so long-running agent workflows are harder to lose. The net effect is less friction between code, runtime behavior, and data validation. ## A live iOS simulator inside your coding workspace The new Mobile panel is centered around one goal: keep device interaction in the same place where you write and review code. ### Device pill controls and WDA routing In `MobileEmulatorWrapper.tsx`, the header pill gives one-click access to: - Device selection (grouped by runtime on iOS) - WebDriverAgent host configuration - Launch by bundle ID - Home/Lock actions - Scroll gestures - Screenshot export and Send to AI The iOS path uses WebDriverAgent as the control plane (`ios-adapter.ts`) and can switch hosts without terminal juggling. If WDA is unavailable, the adapter still has fallback behavior for stream/input paths. ### Tap vs swipe logic is explicit and reliable In `iOSSimulatorView.tsx`, gesture classification is deterministic: - Pointer movement over `0.025` normalized distance becomes a swipe. - Anything smaller becomes a tap. That 2.5% threshold avoids accidental swipes while still making intentional drags easy. Coordinates are normalized to the rendered frame and then mapped back to device space in the iOS adapter (`toWDAPoint`), which also tracks screenshot dimensions to avoid high-DPI mismatch issues. ### Keyboard input batches into focused fields `MobileEmulatorWrapper.tsx` batches keyboard input in 150ms windows before sending `type: 'text'` events. Pressing Enter flushes immediately. This gives you natural typing behavior without spamming the simulator bridge one character at a time. ### Inspect Element and interaction logging are actually actionable The Inspect tab parses WDA `/source` XML into a local element map (type, label, value, accessibility ID, frame, enabled/visible state). Hovering highlights the best matching element by smallest containing area. When Log Interactions is on: - Taps are logged with element context (for example, button label) - Swipes are recorded with coordinates - Logs are copyable as plain text for bug reports or AI prompts A subtle but important implementation detail: source refetch is deferred after tap/swipe so `/source` calls do not block WDA action calls on the same session. This directly addresses the class of "tap ripple but no real tap" failures that show up under load. ## Database client now works like an IDE workspace The database side of v1.17.0 is a major structural upgrade. `DatabaseClient.tsx` now composes three clear zones: - `ConnectionRail` on the left for quick connection switching - `WorkspaceSidebar` for schema items, saved queries, and history - `WorkspaceMain` with tabbed query/table workspaces and result panes This is what enables real parallel flow, like keeping one table tab, one migration query tab, and one validation query tab open at once.
1DevTool tabbed database workspace with sidebar and results grid
Tabbed database workspace with sidebar navigation and result tooling.
### Guided connection form plus live URI parsing `ConnectionDraftForm.tsx` and `connection-string.ts` work both directions: - Fill fields and generate connection strings automatically - Paste a connection string and parse it back into fields - Preserve engine families where possible (Postgres/MySQL/Redis variants) - Toggle project-only vs global scope This removes a lot of trial-and-error when onboarding staging/production connections. ### Result grid handles real-world rows `ResultGrid.tsx` now uses Glide Data Grid with custom cell renderers: - JSON-like cells open in structured viewer dialogs - Long text cells show compact previews plus char/line counts - Column widths are resizable and bounded - Multi-row selection and copy flows are built in Long text handling is explicit (`LONG_TEXT_CHAR_THRESHOLD`, `LONG_TEXT_LINE_THRESHOLD`) so massive markdown/JSON fields no longer blow up row height. For deeper inspection, Enter opens `RowDetailDrawer`, which renders full-field values vertically and supports row-to-row navigation. ### Structure view and SQL preview reduce risky edits For table tabs, `TableStructureView.tsx` exposes column metadata and PK/index context in one place. At the same time, `SqlPreviewFooter.tsx` renders the exact generated SQL shape for table browsing actions, with a resizable panel and optional syntax highlighting. This is especially useful when you are editing/filtering data quickly and want to sanity-check query intent before execution. ## State now travels better across projects Two storage upgrades matter for day-to-day work: ### Global HTTP collections/workspace tabs `HttpTabsWrapper.tsx` merges project tabs with globally stored tabs via `useGlobalHttpStore`. Tabs can flip between project and global scope, and persistence routes to the right store automatically. Practical outcome: you can keep shared API requests once and reuse them everywhere. ### Global database connections `DatabaseClient.tsx` merges project-scoped and global-scoped connections with `useGlobalDatabaseStore`, and `StoreManager` persists global connections in Electron store keys (`globalDatabaseConnections`). Practical outcome: add a staging DB once, then access it from every project workspace. ## Terminal focus mode and resume persistence got stronger Two quality-of-life upgrades from the same release are worth calling out: - `TerminalGrid.tsx` adds app-level focus mode (`appFullscreen`) for any terminal pane, with `Esc` exit and automatic fit/focus behavior. - `resumeManager.ts` persists resume sessions/details into `resume-sessions.db` (SQLite via `better-sqlite3`) under app user data, including session/message tables and indexes. So if you run long agent sessions and switch contexts often, the continuity path is more robust across restarts and transient failures. ## Before vs after | Workflow step | Before v1.17.0 | After v1.17.0 | | --- | --- | --- | | iOS interaction while coding | Jump between IDE, terminal, Simulator.app | Live simulator panel with tap/swipe/type inside workspace | | UI element verification | Manual visual checks | Inspect tab with accessibility metadata and hit-tested highlights | | Database investigation | Single-threaded query flow | Connection rail + sidebar + multi-tab query/table workspace | | Large row inspection | Horizontal scroll fatigue | Row detail drawer + JSON/long-text viewers | | Request/database reuse across projects | Recreate or import repeatedly | Global HTTP tabs and global DB connections | | Long AI terminal outputs | Compete with other panels | One-click app-level terminal focus mode | ## Who benefits most - Mobile app developers who need faster simulator-to-fix loops. - Full-stack developers who constantly jump between schema checks, API calls, and AI terminals. - Teams running shared staging environments and wanting consistent request/connection setup across projects. - Anyone driving Claude Code, Codex CLI, or Gemini CLI in long sessions and needing more reliable resume continuity. ## Try it in your own workflow If your current loop involves too many window switches between device testing, data checks, and AI-assisted coding, v1.17.0 is a meaningful upgrade. Start with the Mobile panel and the new database workspace, then move your most-used HTTP requests and DB connections to global scope so every project opens ready to work. See the full product at [1devtool.com](https://1devtool.com). --- ## Switch Multiple Claude Code Accounts, Track Token Usage, and Manage AI Memory in One Workspace Source: https://1devtool.com/blog/ai-account-switcher-usage-memory-manager Published: 2026-04-19 Tags: ai-accounts, token-usage, memory-manager, claude-code, codex, gemini-cli, obsidian, agent-personas Save multiple OAuth logins per AI agent behind your OS keychain, track real tokens and cost per model from local session files, and browse every agent memory across projects as a list or an interactive graph. Most developers running Claude Code, Codex, or Gemini CLI eventually hit the same three walls. The first is account juggling: your personal Claude Max login is not the one your employer pays for, but the CLI only holds one set of credentials at a time, so switching means logging out, logging in again, and re-authenticating in the browser every single day. The second is invisible cost: tokens and model spend stack up inside session files you never open, and by the time a rate limit hits you have no view of where the budget went. The third is forgotten memory: every agent stores its long-term context separately, scattered across `~/.claude`, `~/.codex`, `~/.gemini`, and project-specific subdirectories, with no central way to search, edit, or share them. 1DevTool v1.16.0 turns all three into first-class UI. The new **Accounts** tab holds multiple OAuth logins per agent behind the OS keychain. The new **Usage** dashboard breaks down tokens and cost per agent per model, reading directly from the session JSONL files on disk. The new **Memory Manager** reads every agent memory in every project and lets you browse them as a list or an interactive graph, with one-click export to an Obsidian vault.
{/* eslint-disable-next-line @next/next/no-img-element */} AI account switcher opened from the status bar dropdown listing multiple saved Claude logins
Switch between multiple Claude Code, Codex, Gemini, and Qwen logins from the status bar.
## Switch AI Accounts Without Logging Out If you have ever run `claude /logout` followed by `claude /login` just to copy a conversation from your personal account to your team account, you know how much friction a single browser round-trip can add to an AI coding workflow. v1.16.0 replaces that loop with a dedicated account registry under **Settings → AI → Accounts**. Each agent card — Claude Code, Codex, Gemini, Qwen — holds a list of saved logins that you can switch between with one click. There are two paths into the feature. **Add account** opens a guided terminal pre-running the selected agent's login command; you finish the OAuth flow in the browser, and 1DevTool writes the new credentials into an encrypted snapshot as soon as the CLI reports success. **Save current account** snapshots whatever credentials are live right now, so if you were already logged in when you installed the release, one click turns that login into a reusable, labelled entry ("Personal", "Acme Team", "Client X") without another browser trip. ### Encrypted by Your OS Keychain The account vault lives under `~/.1devtool/ai-accounts/` with per-agent subdirectories (`claude/`, `codex/`, `gemini/`, `qwen/`). Each saved login is stored as a `.enc` file encrypted by **Electron safeStorage** — macOS Keychain on Mac, Credential Vault on Windows, and libsecret or kwallet on Linux. A registry JSON keeps a backup of the previously active credentials under `__previous__.enc`, so a failed switch can roll back without leaving the CLI stranded between two accounts. The practical upshot: tokens never leave your machine, and you do not have to invent a secret-management story on top of your AI subscriptions. The credentials still load from the same paths each CLI expects on disk. The vault is just a safe staging area. ### Drift Detection When a CLI Login Changes Behind Your Back If you log in from a terminal outside 1DevTool — say you run `codex login` in a plain shell — the app notices the live credentials no longer match the saved snapshot and surfaces a **Signed in · not saved** hint next to the agent. One click labels and saves the new login so it joins the vault. Without this, credential drift is invisible until you break something; with it, the UI tells you where the ground truth diverged. The Accounts tab also exposes a **Switch Account** entry in the status bar AI dropdown that jumps straight to Settings → AI → Accounts, because the common case is not "open settings and navigate three clicks deep" — it is "I want a different login right now."
{/* eslint-disable-next-line @next/next/no-img-element */} AI Usage dashboard showing tokens and estimated cost per AI agent across Claude, Codex, Gemini, and Qwen
Tokens and cost per agent per model, parsed from local session files — not estimated.
## Claude Code Token Usage and Cost Tracking The second headline feature is the **Usage** sub-tab under Settings → AI. Until now, if you wanted to know how many tokens your last week of AI coding actually consumed, you had two options: paste a transcript into an external counter, or trust the CLI's own reporting and hope it covered everything. v1.16.0 replaces that with a dashboard that reads the session JSONL files each agent writes locally — the same files the agent itself uses as the source of truth. The result is a per-agent breakdown of sessions, input tokens, output tokens, cache-read tokens, and total cost in USD, further decomposed by model. Cache hit percentage is computed as `cacheReadTokens / (inputTokens + cacheReadTokens)`, so you can see how much of your spend Claude's prompt cache is saving. All of it is real usage, not estimates. ### Codex 5-Hour and Weekly Rate-Limit Windows Codex users get an extra panel. The Usage tab renders both the **5-hour window** and **weekly window** Codex enforces on its cloud plan, showing current utilization and reset times side by side. When you hit a rate limit at 3pm mid-sprint, this is the difference between "I have 90 minutes of headroom" and "I should switch to a different agent for the rest of the afternoon." Performance-wise, the dashboard keeps a per-file mtime cache, so even if you have months of session history across multiple agents, reopening the tab loads in milliseconds. Filter presets cover **All time**, **Last 7 days**, **Last 30 days**, **Last 90 days**, and a custom date range, and the current filter persists when you close and reopen the sub-tab. ## AI Memory Manager with a Graph View The third new feature is the most unusual. Every AI agent now keeps long-term context in Markdown memory files — Claude's `CLAUDE.md`, Codex's notes, Gemini's, and project-scoped memories under `~/.claude/projects//memory/`. Over a year of real use, those memories grow into the developer equivalent of a second brain: past decisions, style rules, incident postmortems, one-off preferences. But they are scattered across four CLIs, dozens of projects, and hundreds of files you rarely open directly. 1DevTool v1.16.0 adds a **Memory Manager** panel that reads all of them in one view. You can filter by agent and by project, search across contents, and open any entry in a Markdown editor with autosave — no hand-editing files on disk, no worrying about frontmatter syntax. The manager parses YAML frontmatter (`name`, `description`, `type`) using a lightweight, dependency-free parser and indexes cross-references — `[text](file.md)` links between memory files — into a relationship graph.
{/* eslint-disable-next-line @next/next/no-img-element */} Memory Manager graph view showing AI memory relationships between Claude Code, Codex, and Gemini entries
Memory Graph view auto-selects a layout — concentric, cose, or grid — based on how your entries reference each other.
### List or Graph, Your Choice The **List** view is what most developers will live in: a searchable, filterable table with a 240-character preview per entry. The **Graph** view is the interesting one. It uses Cytoscape with multiple layouts — concentric (hub-and-spoke memories that reference one central doc), cose (dense cross-reference graphs), breadthfirst (deep chains), and grid (flat catalogs). The app auto-selects a layout based on entry count and edge density, and you can zoom and pan freely without lag even on hundreds of nodes because the Cytoscape bundle is lazy-loaded only when you open the tab. If you use Obsidian, the panel has a first-class export. Pick an Obsidian vault folder and 1DevTool writes every memory entry as a Markdown file, preserving per-agent and per-project folders so your AI memories become browsable, linkable, searchable notes alongside the rest of your second brain. For entries already inside a vault, an **Open in Obsidian** deep link jumps straight to the matching note. ## Agent Input Personas and Other Polish The agent input overlay (`⌘I`) now has nine writing personas: **Lowkey**, **Coder**, **Blogger**, **Novelist**, **Journalist**, **Poet**, **Vibe Coder**, **Researcher**, and **Marketer**. Each ships with its own font stack, color palette, and chrome accents — scanlines for Vibe Coder, halftone for Poet, dotgrid for Researcher, conic-gradient stripes for Marketer — implemented as CSS overlays with `mix-blend-mode` so there is no runtime cost. Pick your favorite once and it persists across restarts. The rest of the release cleans up three smaller things. Settings → AI is restructured into **Storage**, **Usage**, and **Accounts** sub-tabs instead of a single long scroll. The HTTP Client now remembers request/response split and sidebar widths between sessions, stored per project in the layout store. And Vercel deploy's Node-version fallback searches more install locations and logs the exact Node binary it picked and why, which turns a silent fallback into an auditable one. ## Before vs After Workflow Before v1.16.0 After v1.16.0 Switch from personal to work Claude account Logout CLI, login again, re-authenticate in browser One click in the status bar Switch Account menu Check how many tokens you used this week Paste transcripts into an external counter or guess Open the Usage tab for parsed, per-model totals Monitor Codex 5-hour rate-limit window Wait until you hit the limit mid-task See current utilization and reset time in the dashboard Edit a memory entry across four agents Open four different dotfiles in a text editor Search, filter, and edit in one Markdown panel with autosave Visualize how your AI memories reference each other No tooling existed Interactive Cytoscape graph with four auto-selected layouts Turn AI memory into Obsidian notes Manually copy files into the vault One-click export preserving per-agent and per-project folders ## Who Benefits Most Developer Why v1.16.0 helps Consultants and contractors Juggle separate Claude Code or Codex logins per client without the daily OAuth shuffle, all encrypted by your OS keychain. Team-plan Claude and Codex users Keep personal and work logins side-by-side, with drift detection that tells you when a CLI login happened outside 1DevTool. Developers on paid AI plans Track token spend and cost per agent per model in real time, and watch Codex's rate-limit windows before they bite. Long-time agentic coders Finally see all your CLAUDE.md, Codex, Gemini, and per-project memories in one searchable place instead of scattered across dotfiles. Obsidian users Turn your AI memory into first-class vault notes with one-click export and deep-linking back into Obsidian. Writers and prompt crafters Match the mood of your prompts — nine personas tune typography, color, and chrome for coding, blogging, journalism, or research. ## Try It Today v1.16.0 is a release about taking things that were previously invisible — extra accounts, real token spend, long-term memory — and making them directly browseable. If you are on Claude Code or Codex today, the first five minutes after installing are worth a small experiment: open Settings → AI → Usage to see the last 30 days of your actual agent spend, then open the Memory Manager to see how many memory files you had no idea existed. Download the latest build from [1devtool.com](https://1devtool.com), save your current logins as named accounts, and find out how many tokens you burned while you were not looking. --- ## Continue Any AI Session in Any Agent Source: https://1devtool.com/blog/resume-sessions-across-ai-agents Published: 2026-04-18 Tags: ai-agents, sessions, resume, workflow You no longer have to stay locked to the agent that started a conversation. Pick any AI agent when resuming a session — hand a Claude chat to Codex, continue a Gemini thread in Amp, or get a second opinion in one click. You started a long debugging session in Claude. Two hundred messages in, you hit a wall — Claude's context window is straining, and you want a fresh perspective from Codex. But the session is in Claude. You'd have to copy-paste the relevant parts, re-explain the background, re-establish the context. Most of the time you just keep going with the same agent, even when a different one would do better. The same friction showed up whenever you needed a second opinion. "What would Gemini say about this architecture?" means starting from scratch, manually summarizing what you've already built up over the last hour. ## Resume Any Session in Any Agent You no longer have to stay locked to the agent that started a conversation. In the Resume dialog, you now pick not just which session to continue — but which AI agent to continue it in. Claude session → Codex. Gemini thread → Amp. Any past conversation → any agent you've configured. The resumed agent gets the full prior chat as context, so it picks up exactly where the previous one left off. ## How It Works in Practice ### Choose a target agent when resuming Open the Resume panel, find the session you want to continue, and the agent picker now lists every AI agent you have configured — Claude, Codex, Gemini CLI, Amp, and any custom AI commands you've set up. Each agent shows its icon and color so you can spot the right one at a glance. ### The "second opinion" flow is one click If you select a single session to resume, 1DevTool defaults the target to a *different* agent than the one that originally ran it. The most common reason to resume is to get a fresh take — so the default now matches that intent. You don't have to actively deselect the original agent to get a new one. Resuming two or more sessions together still defaults to the most common agent in the selection, which keeps the multi-session "combine and continue" flow consistent. ### The resumed agent gets clean context The generated context prompt adapts to what you're doing. Resuming a single session produces "Here is the chat from a previous session for context." Combining multiple sessions produces "Here are the combined chats from previous sessions for context." A small thing, but it matters: the resumed agent receives language that matches the structure of what it's being handed, so it orients faster. ### Every agent now understands where it's picking up 1DevTool has always let you resume sessions in the same agent. Cross-agent resume extends the same mechanics — the chat history is passed in as structured context, the resumed terminal opens directly in the target agent's native mode, and the handoff is invisible from the inside. ## Before vs After | Task | Before | After | |------|--------|-------| | Get a second opinion from a different AI | Copy transcript, open new terminal, re-explain context | Resume → pick target agent → one click | | Continue a Claude session in Codex | Not possible without manual paste | Resume → select Codex from picker | | Combine two sessions for a fresh agent | Not possible | Multi-select → combine → pick any agent | | Resume with same agent (existing flow) | Works as before | Still works, unchanged | ## Who Benefits Most **Developers working across multiple AI tools** — If you regularly use Claude for architecture and Codex for implementation, cross-agent resume means those two workflows can now share context without you being the copy-paste bridge. **Anyone hitting context limits** — When a session gets long enough that the current agent is starting to lose the thread, resuming in a fresh instance of a different agent gives you a clean context window with the full history pre-loaded. **Teams comparing AI outputs** — Resuming the same session in multiple agents and comparing their responses on the same codebase context is now a defined workflow, not an improvised one. ## Try It Open the Resume dialog (`Cmd+Shift+R`), pick any past session, and look at the agent picker below the session list. Select a different agent than the one shown, hit Resume, and the new terminal opens mid-conversation. Your next prompt lands in Codex, Gemini, or whichever agent you chose — with full context from everything that happened before. --- ## Resume a Previous AI Session in a Different Agent Without Re-Explaining Context Source: https://1devtool.com/blog/resume-session-different-ai-agent Published: 2026-04-18 Tags: session-resume, claude-code, codex, gemini-cli, ssh, vercel, productivity Resume a past Claude Code, Codex, or Gemini session in a different AI agent, get explicit SSH connection status, and avoid Vercel deploy failures on unsupported local Node versions. You resume a previous AI session because the conversation history matters. The problem is that sometimes you do *not* want to resume it in the same agent. Maybe Claude Code did the exploration and now you want Codex to critique it. Maybe Gemini CLI generated a draft and you want Amp to continue with a different style. In most tools, the resume action assumes sameness. Same agent. Same conversation lane. Same execution model. 1DevTool v1.15.1 changes that. The Resume panel can now hand a previous chat to a **different AI agent**, while the rest of the release improves two other parts of the shipping loop that usually fail under pressure: SSH project visibility and Vercel deploy reliability on modern Node versions.
{/* eslint-disable-next-line @next/next/no-img-element */} Resume UI for picking a previous AI session to continue
Resume is now a routing decision, not just a replay button.
## Resume the Conversation, Not the Same Agent The most important change in v1.15.1 is conceptual: a past session becomes reusable context, not a lock-in to the original tool. In the Resume panel source, the combine target list is built from two groups: **visible built-in AI agents** and **custom AI command presets**. That means the same stored session can be continued in Claude Code, Codex, Gemini CLI, Amp, Qwen Code, or one of your own custom AI launches. The defaults are also smarter. If you resume a single session, the UI deliberately picks a *different* built-in agent first when one is available. That is a strong clue about the intended workflow: second opinions, alternate execution styles, and cleaner handoffs. If you combine multiple sessions, the app instead defaults to the most common agent in the selection, which is usually the least surprising target for merged context. ### Why Cross-Agent Resume Is Useful Cross-agent resume helps in at least three real cases: - **Planning vs execution.** Use one agent for architecture and another for patching. - **Second opinions.** Hand the same thread to another model without retyping the brief. - **Custom workflows.** Resume a previous session directly into a preset command you built for your team. Even the generated prompt text adapts to what you selected. For one session, it says "Here is the chat from a previous session for context." For multiple sessions, it says "Here are the combined chats from previous sessions for context." That seems small, but it keeps the next agent from inheriting awkward framing.
{/* eslint-disable-next-line @next/next/no-img-element */} Combining previous AI sessions into one resume flow
Previous sessions are now a reusable context layer that can be handed to the right next agent instead of being trapped inside the original one.
## SSH Project Status at a Glance The second major improvement in v1.15.1 is operational clarity for remote projects. If you open an SSH-backed workspace and the host is slow, unreachable, or still mounting, the old failure mode was uncertainty. Are you connected? Is it hung? Is the filesystem loading? Do you need to wait or retry? The status bar now answers that directly. In the source, SSH-backed projects surface four explicit states: **Checking SSH…**, **Mounting…**, **SSH connected**, and **SSH failed**. The file tree mirrors the same lifecycle with a spinner, phase-specific copy such as **Checking host…** and **Mounting remote workspace…**, plus a visible **Retry** action if the mount fails. That is the difference between a remote project feeling brittle and feeling observable. When the connection path is explicit, you stop guessing and start deciding. ## Vercel Deploys That Survive Modern Node The third part of the release is about delivery. Vercel's CLI does not run correctly on Node 24+, which is exactly the kind of mismatch that produces confusing deploy failures: your local environment is modern, the provider tooling is not, and the terminal output does not always make that obvious. v1.15.1 addresses this in the deploy provider itself. Before running the Vercel flow, 1DevTool resolves a supported runtime and searches common version-manager locations such as `~/.nvm`, `~/.volta`, `~/.asdf`, and `~/.local/share/fnm` for Node 22, 20, or 18. If a supported fallback exists, it is used automatically for the deploy without mutating your shell's default Node. The UI then pairs that with better failure recovery. The deploy error panel can open build logs and preview URLs directly, and it explains when a Vercel failure happened after the prebuilt upload already reached the platform. That means you spend less time spelunking through raw CLI output and more time acting on the right diagnosis. ## Before vs After Workflow Before v1.15.1 After v1.15.1 Resume an old AI conversation Continue in the same agent or retype context elsewhere Send the session to a different agent or custom preset directly Open an SSH-backed project Infer connection state from partial UI behavior Read explicit checking, mounting, connected, or failed states Deploy on a machine using Node 24+ Hit vague Vercel CLI failures Auto-fallback to supported Node 22/20/18 when available ## Who Benefits Most Developer Why v1.15.1 helps Multi-agent users You can move a conversation from one agent to another without rebuilding context from scratch. Remote-first developers SSH projects become legible during connection and mount phases instead of feeling stuck. Frontend teams shipping often Vercel deploys become more resilient on modern local Node setups and easier to debug when they fail. Anyone using custom AI presets Old sessions become inputs to your preferred command model, not just to the tool that created them. ## Try It Today v1.15.1 is a strong example of workflow maturity. It does not just add a feature. It removes assumptions. Resume does not assume the same agent. SSH does not assume you can infer connection state. Deploys do not assume your Node version matches the provider's comfort zone. If you already work across Claude Code, Codex, Gemini CLI, and remote projects, download the latest build from [1devtool.com](https://1devtool.com) and try one simple exercise: resume an old chat in a different agent, then ship the result without leaving the workspace. --- ## Deploys, HTTP Collections, SSH Manager, and Tasks in One AI Developer Workspace Source: https://1devtool.com/blog/deploy-http-collections-ssh-tasks Published: 2026-04-18 Tags: deployments, http-client, ssh-manager, tasks, developer-workspace, productivity Deploy to Vercel or Cloudflare Pages, organize API requests in nested collections, manage SSH connections, and turn project tasks into AI-ready prompts without leaving your workspace. There is a point where "just use another app" stops being practical. Your deploy logs are in one place, API collections in another, SSH connections in another, tasks in another, and the actual code plus AI terminals somewhere else again. You are not short on tools. You are short on one continuous workflow. 1DevTool v1.15.0 is a major answer to that problem. It adds **built-in deploys to Vercel and Cloudflare Pages**, **nested HTTP Collections with import/export and environments**, **a real SSH Manager and Clone tab**, and **project-level task management with Kanban and Pomodoro focus timers**. This is not one feature. It is a release about collapsing the distance between shipping, testing, remote access, and execution planning.
{/* eslint-disable-next-line @next/next/no-img-element */} HTTP request workspace with organized API collections
API work gets dramatically faster when requests, environments, and the rest of your workspace live in the same operating surface.
## Deploy Without Leaving the Workspace Built-in deploys matter because shipping is usually the moment when your workflow falls out of the editor and into terminal scripts, browser tabs, and copy-pasted tokens. v1.15.0 brings that back inside the app with a Deploy dialog that scans the current project, detects whether it looks like Next.js, Vite, Remix, or a static site, and suggests the right build command and output directory before you deploy. The implementation is not hand-wavy. In the desktop source, the deploy manager routes requests to provider-specific implementations for Vercel and Cloudflare Pages. The Vercel provider handles token testing, scope selection, `vercel pull`, `vercel build`, and `vercel deploy --prebuilt`, while the UI keeps a structured log stream and can open build logs or preview URLs directly when things fail.
{/* eslint-disable-next-line @next/next/no-img-element */} Built-in deploy panel for Vercel and Cloudflare Pages
The deploy flow now lives next to the rest of your project context, with live logs and direct actions when something goes wrong.
### Why This Is Better Than a Bare CLI The deploy flow is not just a button that runs a shell command. It remembers provider settings, exposes project and team scope choices, streams logs inline, and gives you actionable recovery paths when Vercel's server-side post-processing fails. The result is that deploy state becomes part of the workspace rather than a transient terminal moment you have to reconstruct later. ## HTTP Collections, Environments, and Import/Export The HTTP Client is the other major pillar of the release. Previously, a flat request list was fine for a few endpoints. It breaks down the moment your API workflow spans multiple services, environments, or teams. v1.15.0 introduces a tree-based Collections model built directly into the sidebar. In the source, request names become tree paths like `"Collection / Folder / Request"`, and the sidebar builds a real nested structure from those flattened names. That enables drag-and-drop reordering, folder movement, collection creation, and a much saner mental model for larger request libraries. The release also adds: - **[Environment variables](https://servercompass.app/features/env-vars-editor)** with `{{var}}` substitution across URLs, headers, query parameters, and request bodies. - **Import from Postman, Insomnia, and Bruno** through dedicated parsers and import actions. - **Export back out** to Postman JSON, Insomnia JSON, or Bruno folder format. - **Inline test scripting** and a structured URL params editor for cleaner request authoring.
{/* eslint-disable-next-line @next/next/no-img-element */} HTTP request builder with URL, method, and request configuration
Collections matter because API work is rarely one request. It is a repeated, environment-aware loop of request, inspect, fix, and retry.
### Why This Is a Real Postman Alternative A Postman alternative is only compelling if it reduces total debugging time, not just if it can send HTTP requests. What makes this release matter is that collections, environments, import/export, and response inspection now live next to your terminals, code, AI prompts, and deploy surfaces. That shortens the loop between API failure and code change. ## SSH Manager, Clone Tab, and Task Execution v1.15.0 also brings remote and execution planning into the same workspace. The Add Project dialog now has an SSH mode with saved connections, key browsing, and an explicit **Configure in SSH Manager** escape hatch when your host list needs work. The same dialog also has a Clone tab that can fetch repositories from a saved GitHub account, show destination previews, and clone directly into the parent directory you selected. This matters because adding a new project stops being a terminal ritual. You do not have to switch contexts just to connect to a server or search one of your GitHub repositories.
{/* eslint-disable-next-line @next/next/no-img-element */} Add Project flow for opening a project over SSH
Remote access is now part of project creation, not a disconnected setup path.
Then there is the Tasks system. The board model is explicit in the code: **Todo**, **In Progress**, **Blocked**, and **Done**. Cards are draggable between columns, WIP limits can be configured, and task details include attachments, subtasks, estimates, spent time, and a **Send to terminal** action that turns selected tasks into a structured prompt for an AI terminal. The focus timer is equally concrete. The Pomodoro component uses a 25 minute focus session, 5 minute short break, and 15 minute long break after four work sessions. Spent minutes are flushed back to the task record, so time tracking and task execution stay linked instead of becoming separate habits. ## Before vs After Workflow Before v1.15.0 After v1.15.0 Deploy a frontend app Leave the workspace and run provider-specific commands manually Scan, configure, deploy, and read logs inside the app Manage large API request libraries Flat list or external API client Nested collections, environments, import/export, and inline testing Open a remote project or clone a repo Switch to shell or separate setup tool Use SSH and Clone directly inside Add Project Turn a task into an AI prompt Rewrite context manually Generate and send a structured prompt from selected tasks ## Who Benefits Most Developer Why v1.15.0 helps Full-stack developers You can deploy, test APIs, inspect responses, and jump back into code without leaving the workspace. Remote-first operators SSH setup, saved connections, and repo cloning become part of the same project onboarding flow. AI-assisted teams Tasks can become structured prompts, which makes execution handoff to Claude Code or Codex much cleaner. Anyone tired of tool sprawl The release removes several reasons to bounce between deployment tools, API clients, SSH utilities, and task apps. ## Try It Today v1.15.0 is what a workspace release looks like when the goal is not to add one isolated feature, but to tighten the whole loop from planning to remote access to API debugging to deployment. If that is how you already work, this release removes a surprising amount of glue code and tool switching. Download the latest build from [1devtool.com](https://1devtool.com) and try one path end-to-end: import an API collection, fix a failing request, send the resulting task to an AI terminal, and deploy the finished project without leaving the app. --- ## Startup Command Manager, Worktree Env Files, and a Full Menu Bar for Faster Terminal Workflows Source: https://1devtool.com/blog/startup-command-manager-worktree-env-files Published: 2026-04-16 Tags: startup-commands, git-worktree, env-files, menu-bar, terminal, productivity Organize startup presets in a dedicated Commands tab, copy gitignored env files into new worktrees, and use a native menu bar that exposes settings sections, layouts, and agent launches directly. Terminal setups decay quietly. One month you have a clean list of startup commands for Claude Code, Codex, Gemini CLI, and your custom shells. A few weeks later, the useful presets are buried, the defaults you never touch are still in the way, and every new worktree needs its environment files copied by hand before the dev server will boot. 1DevTool v1.14.3 fixes exactly that kind of workflow drag. It adds a proper **Startup Command Manager**, copies gitignored `.env` files into new worktrees when you ask for it, and wires a **full native menu bar** so settings sections, layout presets, and new agent terminals are keyboard-reachable instead of hidden behind UI hunting.
{/* eslint-disable-next-line @next/next/no-img-element */} Startup Command Manager in Terminal settings with categorized command presets
The old one-off command manager is now a real Commands tab inside Terminal settings, with categories, counts, icons, and hidden-default support.
## A Real Startup Command Manager The biggest improvement in v1.14.3 is not just that startup commands are editable. It is that they finally live in a *dedicated operating surface*. In the source, Terminal settings now explicitly tell you to manage presets in the **Commands** tab, instead of forcing you through a secondary dialog buried inside general terminal options. That changes how you maintain terminal workflows: - You can browse presets as a collection instead of treating them like a hidden preference. - You can filter by **All**, **AI**, and **Normal** so agent launches do not get lost among shell utilities. - You can assign icons to presets, hide built-ins you never use, and reorganize presets into categories that match how you actually work. If you run multiple agent types daily, this matters. A long preset list becomes usable only when the app helps you distinguish agent launches from normal shell commands, and when the commands you do not care about stop stealing visual space. ### Why Preset Categories Matter Categories sound cosmetic until your launcher grows. Once you have separate commands for "Claude (Skip Permissions)," "Codex (Bypass Approvals)," local dev servers, Docker helpers, test runners, and project boot scripts, the cost of scanning the launcher becomes real. v1.14.3 turns the command list into something you can curate instead of tolerate. ## Env Files Follow New Worktrees Git worktrees are great until your new branch boots into a broken local environment. The repo cloned fine, but the new worktree has no `.env`, no `.env.local`, and no `.env.production`, because of course those files are gitignored. You have the branch. You do not have the runtime. In v1.14.3, 1DevTool fixes that at the Git layer. The worktree creation flow accepts a `copyEnvFiles` list, and the git integration copies only safe plain basenames into the newly created worktree. The implementation is conservative on purpose: no nested paths, no traversal, no overwrite if git already produced a file at the destination. If the source file is missing, the worktree still succeeds and the copy step fails gracefully. That means the workflow becomes predictable: - Create a new worktree from the Git client. - See exactly which `.env*` files will be copied before confirming. - Open the branch with the same credentials and local config the original worktree already used.
{/* eslint-disable-next-line @next/next/no-img-element */} Environment file management inside the workspace
Environment management only becomes practical when your new worktree starts with the same runtime context as the branch you came from.
## A Menu Bar That Exposes the Whole App The third part of the release is easy to underestimate if you mostly click around. But for anyone who drives desktop tools by keyboard, a complete native menu bar is a real upgrade. The main process now builds menus for File, View, Navigate, Terminal, and Tools with direct entries for Templates, the HTTP Client, the Tasks dialog, Resume AI Sessions, Docker, SSH, Prompt History, layout presets, and a dedicated **Settings Sections** submenu. The useful part is not just discoverability. It is speed. You can jump directly to Appearance, Layout, Terminal, IDE, Browser, File Tree, Git, Remote, MCP, Library, License, or About without opening Settings and scrolling manually. And from the Terminal menu you can spawn a new Claude, Codex, Gemini, Amp, bash, zsh, or PowerShell terminal without navigating the mouse through launcher UI.
{/* eslint-disable-next-line @next/next/no-img-element */} Native application menu showing settings sections and navigation commands
The menu bar is now a real control surface, not a thin wrapper around a few generic app actions.
## Before vs After Workflow Before v1.14.3 After v1.14.3 Manage startup presets Hidden behind a smaller side flow Dedicated Commands tab with categories, filters, and icons Boot a new worktree Manually copy env files Offer to copy safe `.env*` basenames automatically Jump to settings subsections Open Settings and hunt manually Use the Settings Sections submenu directly Launch a specific agent terminal Open launcher UI first Spawn it directly from the native Terminal menu ## Who Benefits Most Developer Why v1.14.3 helps Agent-heavy terminal users The Commands tab makes daily launch presets maintainable instead of messy. Git worktree users Branches no longer come up half-configured because the env files were left behind. Keyboard-first operators The native menu now exposes layouts, dialogs, settings sections, and terminal spawning directly. Teams standardizing local workflows Preset categories and safer worktree bootstrapping reduce setup drift between branches and developers. ## Try It Today v1.14.3 is a good example of what mature developer tools should do: remove the quiet manual steps that steal time every day. Startup commands become easier to curate, worktrees become runnable faster, and the menu bar becomes useful enough to trust. If your terminal workflows are growing more complicated, or your Git branches keep starting in a half-configured state, download the update from [1devtool.com](https://1devtool.com) and tighten those edges. --- ## How Vibe Coders Can Switch Between Multiple Projects Without Losing Context Source: https://1devtool.com/blog/vibe-coding-multiple-projects-context-switching Published: 2026-04-15 Tags: vibe-coding, multi-project, context-switching, ai-coding-workflow, session-continuity A practical multi-project workflow for AI-assisted developers: project-scoped sessions, handoff notes, reusable prompts, checkpoint commits, and the 1DevTool features that keep context visible. Vibe coding across one repo feels fast. Vibe coding across five repos quietly turns into a context-switching tax: half-finished prompts in Claude Code, forgotten branch state, stale Codex CLI sessions, and a growing sense that every project restart costs more than the actual work. The fix is not to keep more in your head. The fix is to make each project carry its own durable context: active AI terminals, agent conversation history, reusable prompts, git worktree state, next steps, blockers, and the exact files that matter right now.
1DevTool multi-project workspace with projects organized in one sidebar
Keep projects separated, but available, so switching does not mean rebuilding your setup.
## Why Context Switching Hurts Vibe Coding Workflows Any AI coding workflow creates more state than traditional development. There is the code state, the git state (branches, worktrees, uncommitted changes), the terminal state (running dev servers, test watchers, build logs), and the conversation state inside each coding agent. When those states live in separate windows across separate apps, they drift apart. That drift usually shows up in five ways: - **Prompt replay:** you re-explain the same project constraints to Claude Code or Codex CLI every session. - **Terminal archaeology:** you hunt through tabs to find the AI agent that was running tests. - **Branch confusion:** you forget which repo, branch, or git worktree a terminal belongs to. - **Lost decisions:** the reason behind a change is buried in agent scrollback you cannot search. - **Restart friction:** closing the laptop turns tomorrow into a cold start with no session continuity. ## The Five-Part Project Context Routine ### 1\. Use One Workspace Per Project Do not mix unrelated repos inside one long-running agent conversation. Each project needs a separate workspace with its own terminals, files, default browser URL, git state, and notes. In 1DevTool, [Multi-Project Workspace](/features/multi-project-workspace) keeps each project state separate. When you switch projects, the workspace restores the relevant terminals, files, and layout instead of forcing you to reconstruct them manually.
Color-coded projects in 1DevTool for fast visual identification
Color-coded projects reduce wrong-repo mistakes when several codebases are open.
### 2\. Write a Handoff Note Before You Leave End each session with a short handoff note. This is not a diary. It is a restart contract for your future self and your next AI agent. `Project: Branch: Goal: Changed: Decision: Next step: Blocked by: ` Keep the note close to the work. If the note lives in a random notes app, it becomes one more thing to remember. A markdown note, a terminal sticky note, or a project-local handoff file is easier to reuse. ### 3\. Save Prompts That Work as Reusable Templates Rewriting prompts from memory is where consistency goes to die. Keep a prompt library for common task types: bugfix, failing test, refactor, migration, review, release note, and dependency update. A good reusable prompt captures the task shape, not the specific details: `Role: You are fixing a bug in . Reproduce: Constraint: Do not change the public API. Stay within . Return: root cause, minimal patch, regression test, remaining risk.` [Prompt History](/features/prompt-history) in 1DevTool captures every prompt you send to Claude Code, Codex CLI, or any AI terminal. Search the previous successful run, copy it, then tighten it for the current repo instead of starting from a blank input.
Prompt History in 1DevTool with searchable AI prompts
Treat successful prompts as workflow assets, not disposable chat messages.
### 4\. Checkpoint Small Units with AI Diff Review AI coding agents can change a lot of files quickly. That makes checkpoint commits more important, not less. Commit after meaningful units: failing test added, API contract updated, refactor completed, visual bug fixed, docs refreshed. The checkpoint does two jobs. It lets you roll back safely, and it gives the next agent a clean boundary: "start from this commit and only touch the payment form." Use [AI Diff](/features/ai-diff-panel) to review exactly which files each agent modified before you commit — accept good changes per-file and revert the rest. ### 5\. Track What Finished While You Work Elsewhere The worst context switch is the invisible one: an agent finishes, waits for input, and you do not notice for twenty minutes. Use a cross-project activity feed so background projects can report completions without forcing you to poll tabs. [AI Activity Logs](/features/activity-logs) show terminal completions and generated files across projects. Pair that with [Session Continuity](/features/session-continuity) so each AI terminal can resume with prior conversation visible as scrollback.
1DevTool activity logs showing AI agent completions across projects
A cross-project activity feed replaces the habit of checking every terminal manually.
## Common Mistakes - **One giant AI session for everything:** useful for brainstorming, bad for delivery. - **No session ending ritual:** you leave the next start dependent on memory. - **Prompt improvisation:** every run gets a different contract and a different output shape. - **Late commits:** rollback becomes scary because too much changed at once. - **Visual ambiguity:** identical terminal tabs make wrong-project commands more likely. ## The Routine in One Page 1. Open each repo as its own project workspace. 2. Name terminals by responsibility: app, tests, agent-review, agent-implement. 3. Use saved prompts for common task types. 4. Commit after each coherent unit of progress. 5. Write a six-line handoff note before leaving. 6. Resume from session history and activity logs instead of memory. Multi-project vibe coding works when every project carries its own durable context. Once your terminal manager remembers the state — AI terminals, git branches, prompt history, AI Diff snapshots — your AI coding workflow becomes choosing the next task instead of rebuilding yesterday's mental model. Try this workflow with [1DevTool](/download) when you need multiple repos, Claude Code and Codex CLI terminals, searchable prompt history, activity logs, Git Worktrees, AI Diff review, and resumable sessions in one place. --- ## Trying a New AI IDE Without Killing Your Momentum: A Practical Evaluation Method Source: https://1devtool.com/blog/evaluate-new-ai-ide-without-losing-momentum Published: 2026-04-15 Tags: ai-ide, evaluation, productivity, workflow, scorecard Stop comparing AI IDEs from feature lists. Run a 3-day evaluation sprint that measures time-to-first-commit, context friction, terminal flow, git review, and rollback cost. AI IDEs change fast enough that developers feel constant pressure to try the next one — Cursor, Windsurf, Claude Code in the terminal, Codex CLI, and new entrants every month. The trap is running an AI IDE evaluation from demos, feature lists, or toy tasks. That creates noisy comparisons and burns the same momentum you were trying to protect. A better method is a structured AI IDE evaluation sprint on one real project. Measure outcomes, not vibes: how quickly you make a real commit, how much context you have to re-create, how well your AI coding workflow and git flow work together, and how easy it is to roll back if the tool is not a fit.
Layout presets in 1DevTool for switching workspace arrangements
Evaluate whether the workspace adapts to your real work, not whether the demo looked clean.
## Why Feature-List AI IDE Comparisons Fail Feature lists are easy to compare and hard to trust. Two AI code editors can both claim AI chat, terminal integration, git support, and project context. The difference in any AI coding workflow only appears when you try to ship a real change under real conditions — multiple files, running tests, reviewing diffs, and managing coding agent sessions. The question is not "does this AI IDE have coding agents?" The useful questions are: - Can I make my first meaningful commit without rebuilding my entire setup? - Can I see code, AI terminal output, browser state, and git changes in one view? - Can I review AI agent edits with a proper diff instead of trusting scrollback? - Does prompt history carry over so I do not re-explain the project every session? - Can I leave the tool after three days without damaging the repo? ## The Three-Day Evaluation Sprint ### Day 0: Choose the Test Project Pick one real project with real friction. It should have enough complexity to expose workflow problems: a dev server, tests, git activity, a few files you edit often, and at least one task you would normally do this week. Ideally, it is a project where you already use AI coding agents like Claude Code or Codex CLI so you can compare the orchestration experience directly. Do not use a blank todo app. Toy tasks reward fast onboarding and hide the problems that show up in daily engineering work — session continuity, multi-file review, and context recovery after interruptions. ### Day 1: Measure Time to First Commit Start a timer when you open the new IDE. Stop when you create a commit that you would be comfortable keeping on the branch. Track every setup interruption: missing terminals, unclear project state, broken preview, git friction, or agent context issues. 1DevTool is useful in this test because [project workspaces](/features/multi-project-workspace), [terminal layouts](/features/terminal-grid-layouts), browser preview, and git panels live in one app. You can test whether the integrated setup shortens the first real commit, not just the first prompt.
Terminal grid layout with multiple terminals visible at once
A real trial should include agents, tests, logs, and dev servers running together.
### Day 2: Measure Context Friction and Session Continuity Run one normal implementation task. Count how often you leave the AI IDE to get context: terminal output, browser logs, network errors, [environment variables](https://servercompass.app/features/env-vars-editor), database state, or a screenshot. Each switch is a signal that the tool is not carrying enough of the workflow. Also test prompt context and session continuity. Can you attach files quickly? Can you search and reuse prior prompts from [prompt history](/features/prompt-history)? Can you send browser errors or screenshots to a coding agent without pasting a messy wall of text? When you restart the IDE, does the agent conversation survive or do you start cold? ### Day 3: Measure AI Diff Review and Rollback Ask the coding agent to make a change that touches more than one file. Then review it. This is where many AI IDE evaluations become honest: generating code is one thing, trusting the diff is another. Can you accept good file changes and revert bad ones individually? Or is it all-or-nothing? In 1DevTool, [AI Diff](/features/ai-diff-panel) tracks every file modification made by Claude Code, Codex CLI, or any AI terminal, with per-file Accept and Revert controls. [Git Worktrees](/features/git-worktrees) let you isolate risky agent experiments in a separate working copy. If a tool makes rollback feel expensive, it will push you toward smaller experiments or blind trust — neither is sustainable.
Visual git changes panel in 1DevTool
Review cost matters as much as generation speed when agents edit multiple files.
## The Scorecard Score each category from 1 to 5, then multiply by the weight. Keep notes short and concrete. Category Weight What to Measure Time to first commit 25% Setup time, missing dependencies, first useful diff Context switching 25% How often you leave the IDE for terminals, browser, git, logs, or files Agent control 20% Prompt context, session resume, multi-agent visibility, stop and review flow Review and rollback 20% Diff clarity, per-file revert, git confidence, worktree support Comfort and customization 10% Shortcuts, layouts, themes, fonts, command palette speed ## Common Mistakes - **Testing only greenfield tasks:** real projects expose integration friction. - **Counting features instead of interruptions:** the best workflow removes steps. - **Ignoring review cost:** faster generation is not useful if review slows down. - **No rollback plan:** trial tools should not leave your repo in a confusing state. ## When 1DevTool Is the Right AI IDE Trial Try 1DevTool when your AI coding workflow depends on more than the editor buffer: multiple Claude Code or Codex CLI terminals running in parallel, persistent sessions with full session continuity across restarts, visual git review with AI Diff, browser preview, HTTP client, database tooling, Docker management, and project-specific terminal layouts. It is especially worth evaluating if your current setup — whether Cursor, Windsurf, or VS Code with extensions — is strong at inline editing but weak at orchestrating the surrounding workflow. The three-day trial should answer one practical question: can you finish real work with less setup, less context switching, and clearer AI code review? Download [1DevTool](/download), run the three-day scorecard on one real repo, and keep the tool only if the numbers beat your current setup. --- ## Prompt Fatigue Is Real: Build Reusable AI Execution Playbooks Instead Source: https://1devtool.com/blog/prompt-fatigue-reusable-ai-execution-playbooks Published: 2026-04-15 Tags: prompts, playbooks, ai-coding-workflow, skills, prompt-history If you keep rewriting the same prompts for every bugfix, refactor, and review, you do not need a bigger prompt. You need reusable execution playbooks with outputs, checklists, and feedback loops. Prompt fatigue starts small. You write a good prompt for a bugfix in Claude Code, then rewrite it for a refactor in Codex CLI, then rewrite it again for a review, then spend five minutes explaining your repository rules to the same agent for the fourth time that week. The problem is not that you need a perfect mega-prompt. The problem is that your AI coding workflow needs repeatable execution playbooks: task type, context, constraints, output format, review checklist, and a feedback loop. Think of them as reusable prompt templates with built-in quality gates.
Prompt History in 1DevTool showing reusable prompts across AI sessions
Your best prompts should become searchable building blocks for future work.
## What a Playbook Contains A playbook is a short, reusable contract for one class of work. It should be specific enough to guide an agent and small enough that you will actually maintain it. - **Task archetype:** bugfix, feature, refactor, review, migration, docs. - **Inputs:** files, logs, screenshots, failing tests, linked notes. - **Constraints:** scope, coding style, forbidden files, performance limits. - **Output contract:** plan, patch summary, tests run, risks, follow-ups. - **Review checklist:** what you verify before accepting the work. ## Start With Five Task Archetypes Do not build a prompt library around technology names. Build it around work shapes. Most AI-assisted development falls into a few repeatable patterns. Archetype Useful Output Contract Bugfix Reproduction, root cause, minimal patch, regression test Feature Implementation plan, touched files, user-facing behavior, tests Refactor Preserved behavior, moved code, compatibility risks, verification Review Findings by severity, file references, missing tests, open questions Migration Before and after contract, data risk, rollback plan, validation query ## A Minimal AI Prompt Playbook Template Use this as a starting point for your reusable prompt templates. The important part is the output contract at the end; that is what makes AI responses comparable across runs and reviewable by teammates. `Role: You are helping with . Goal: Context: Constraints: - Stay within - Preserve - Do not touch Process: 1. Restate the goal. 2. Give a concise plan before editing. 3. Make the smallest useful change. 4. Run or recommend verification. Return: - Summary - Files changed - Tests run - Risks - Follow-up questions` ### Filled-In Example: Bugfix Playbook Here is what the template looks like filled in for a real bugfix task. Notice that the constraints and output contract remove ambiguity before the coding agent writes a line: `Role: You are fixing a bug in the payment module. Goal: Stripe webhook returns 400 on subscription renewal events. Context: src/webhooks/stripe.ts, logs from Sentry issue #4821. Constraints: - Stay within src/webhooks/ and src/billing/. - Preserve the existing StripeEvent type contract. - Do not touch user-facing API routes. Process: 1. Restate the bug and confirm the failing path. 2. Show the root cause before patching. 3. Write a minimal fix and a regression test. 4. Run npm test -- --grep "stripe webhook". Return: - Root cause summary - Files changed - Test output - Remaining risk (e.g., other event types) - Follow-up questions` ## Store Prompt Playbooks Where You Use Them A prompt library only works if it is close to the execution surface. If your reusable prompts live in a forgotten Notion doc, you will still improvise under pressure. For Claude Code users, project-level `CLAUDE.md` files are one natural home for durable instructions. For broader workflow storage, you need something searchable. 1DevTool gives you several places to keep AI execution playbooks close to work: - [Prompt History](/features/prompt-history) for finding and reusing past successful prompts. - [Skills Manager](/features/skills-browser) for turning durable workflows into reusable skills. - [Channel Templates](/features/channel-templates) for multi-agent workflows with pre-assigned roles. - [Drag Files Into the AI Prompt](/features/drag-to-agent-input) for attaching the right files without path-copying mistakes.
Skills editor in 1DevTool for writing reusable AI workflow instructions
Durable instructions belong in editable workflow assets, not scattered chat history.
## Use Channel Templates for Multi-Agent Workflows Prompt fatigue gets worse when you coordinate more than one coding agent. Now you are not only writing the task prompt; you are also assigning roles to Claude Code and Codex CLI sessions, setting handoff rules, choosing files, and deciding how far each agent can continue autonomously. [Channel Templates](/features/channel-templates) make those multi-agent choices explicit and reusable. A review workflow can start with a reviewer and fixer. A build workflow can start with a planner and implementer. A test workflow can start with a tester and analyst. You still edit the prompt, but you do not rebuild the coordination structure each time.
Channel templates in 1DevTool for reusable multi-agent workflows
Templates turn repeated coordination work into a one-click starting point.
## Review Your Prompt System Weekly A playbook library should improve. Once a week, review the prompts that failed or caused cleanup work. Look for unclear scope, missing files, weak output contracts, and missing verification. Keep the review practical: - Delete prompts you never reuse. - Promote successful prompts into templates or skills. - Add one missing constraint to each failed playbook. - Keep output formats consistent so responses are easy to review. ## Common Mistakes - **One giant generic prompt:** it becomes too vague and too hard to improve. - **No output schema:** every answer arrives in a different shape. - **No review checklist:** you generate faster but accept work inconsistently. - **No prompt feedback loop:** the same failure repeats every week. Prompt fatigue is a process smell, not a creativity problem. When you notice yourself typing the same setup again — whether in Claude Code, Codex CLI, or any AI terminal — turn it into a playbook, prompt template, or skill. Your AI coding workflow gets faster because reusable prompt templates carry the repetition for you. Use [1DevTool](/download) to capture searchable prompt history, build reusable AI execution skills, and run template-based multi-agent workflows without rebuilding the same instructions every session. --- ## Trust Issues With Coding Agents? Use a Plan-First, Patch-Second Workflow Source: https://1devtool.com/blog/trust-coding-agents-plan-first-patch-second Published: 2026-04-15 Tags: coding-agents, code-review, ai-diff, workflow, trust A low-trust, high-speed workflow for AI coding agents: require a plan, isolate execution, checkpoint changes, review diffs, and capture the decision log before merging. Distrusting coding agents is rational. They can edit quickly, miss local conventions, and create plausible-looking regressions. The answer is not blind trust or total avoidance. The answer is an AI coding workflow that lets coding agents move fast inside clear boundaries. A plan-first, patch-second workflow gives you that boundary. The agent must explain the goal, scope, files, risks, and tests before it edits. Then you review the patch against the plan instead of trying to infer intent from a pile of diffs.
AI Diff panel in 1DevTool showing agent file changes with accept and revert controls
Trust improves when every agent edit is visible, grouped, and reversible.
## The Core Rule Every agent run should have two phases: 1. **Plan first:** explain the intended change, files likely to change, risk, and verification. 2. **Patch second:** edit only inside that scope, then report what changed and how it was checked. This creates a reviewable contract. If the patch touches files the plan did not mention, you have a concrete reason to pause. If the plan misses an obvious risk, you catch it before code changes. ## The Workflow ### 1\. Require a Short Plan Before Edits Make the first response boring and specific. You want a scoped plan, not a motivational essay. Ask for touched files, assumptions, test strategy, and a stop condition. `Before editing, reply with: - Goal in one sentence - Files or modules you expect to touch - Files you will not touch - Main risk - Verification plan - Question if scope is unclear After I approve, make the smallest patch that satisfies the goal.` ### 2\. Keep One Execution Lane Per Task Do not let multiple agents modify the same files unless you deliberately split ownership. One agent can implement, another can review, but two implementers touching the same module usually create merge noise and unclear accountability. If you do run multiple agents, use [Channel Chat](/features/channel-chat) or [Channel Templates](/features/channel-templates) to make roles explicit: planner, implementer, reviewer, tester. Each agent needs a lane. ### 3\. Checkpoint Before Risky Edits Before a large refactor, create a checkpoint commit or worktree. This changes the emotional cost of experimentation. You can let the agent try an approach because rollback is cheap. 1DevTool's [Git Worktrees](/features/git-worktrees) support helps isolate parallel attempts. A hotfix, refactor, or agent experiment can run in its own working copy without disturbing your current branch state. ### 4\. Review Agent Diffs Before Accepting Agent output is not evidence. The diff is evidence. Review changed files directly, with a way to accept good files and revert bad ones. [AI Diff](/features/ai-diff-panel) tracks file modifications made by AI agents and groups them into reviewable sessions. Use per-file Accept and Revert when a run is partially good, and bulk controls only when the whole run is clearly safe or clearly wrong.
AI Diff settings in 1DevTool for enabling agent file change tracking
Turn on AI Diff when you want agent file tracking as part of the review loop.
### 5\. Capture a PR Decision Log The final artifact should explain why the patch exists, not just what changed. This matters for teammates and for your future self when a regression appears later. `PR decision log: Goal: Scope: Out of scope: Tradeoff: Tests: Risk: Rollback: ` ## What to Review Manually Some areas should always get human review, even when the agent looks confident: - Authentication, authorization, permissions, and token handling. - Payment, billing, account deletion, and irreversible user actions. - Database migrations and data transformation scripts. - Shared abstractions used across many modules. - Build, release, deployment, and infrastructure configuration. ## Use Code Intelligence as a Second Signal A diff can look right while the project is still broken. Pair review with diagnostics from a real project-aware language engine. 1DevTool's [Code Intelligence](/features/code-intelligence) runs language servers for projects you opt into, so TypeScript, Python, Go, Rust, and other diagnostics are based on real project files instead of incomplete editor guesses.
Code Intelligence status bar in 1DevTool showing active language engines
Project-aware diagnostics catch issues that a plain text diff can miss.
## Common Mistakes - **Letting agents patch immediately:** you lose the chance to catch bad scope early. - **Huge unscoped prompts:** the agent succeeds at something, but not necessarily your thing. - **Reviewing only summaries:** agent summaries are useful, but the diff is the source of truth. - **No rollback boundary:** fear rises because undo is unclear. The goal is not to make coding agents harmless. The goal is to make their work inspectable, scoped, and reversible. Plan first, patch second, review the AI Diff, and keep a decision log when the change matters. Use [1DevTool](/download) when you want AI terminals, channel workflows, AI Diff, Git Worktrees, and project-aware diagnostics in the same review loop. --- **Related in the StoicSoft network** If you regularly stitch together PDF, image, video, or batch-file workflows like the ones above, [1FileTool](https://1filetool.com) is the StoicSoft network's purpose-built desktop app — 245+ local-first tools, pay-once, files never leave the device. --- ## Linux Dev Environment Alternatives to All-in-One Windows Tooling Source: https://1devtool.com/blog/linux-dev-environment-alternative-all-in-one-windows-tooling Published: 2026-04-15 Tags: linux, terminal, tmux, developer-workspace, workflow A practical Linux-native setup for developers leaving MobaXterm-style workflows: tmux-backed sessions, organized terminals, project restore, SSH naming, diagnostics aliases, and remote monitoring. Developers looking for a MobaXterm alternative on Linux often miss the convenience more than the exact app. A single window had terminals, sessions, saved destinations, file access, and quick diagnostics. On Linux, the pieces are stronger, but they are easier to scatter across your dev environment. The practical replacement for your Linux dev environment is not one magic terminal. It is a small operating model: tmux persistence, a terminal manager with named layouts, clean SSH profiles, per-project startup routines, and one place to monitor long-running work.
1DevTool terminal grid layout with multiple terminal panes
Linux-native workflows work best when terminal state, layout, and project context stay together.
## What You Are Replacing If you are coming from a MobaXterm-style workflow, you are probably replacing several jobs: - Multiple persistent terminals. - Named remote destinations and SSH habits. - Quick file and project navigation. - One-command environment startup. - Diagnostics for ports, containers, logs, and local services. Recreate those jobs directly. Do not chase a visual clone if your actual need is a reliable session strategy. ## The Linux-Native Stack ### 1\. Pair a Terminal Manager With tmux for Session Continuity tmux gives you durability and session continuity. Your terminal manager gives you visibility. Use tmux for the session backbone and a workspace app for layout, naming, and switching. 1DevTool's [Session Persistence](/features/session-persistence) is built around tmux-backed terminals, so app restarts do not wipe scrollback or running processes. That matters for long builds, test watchers, deploy logs, and AI agents.
Session persistence in 1DevTool preserving terminal sessions
Persistent terminals remove the daily ritual of recreating the same shell setup.
### 2\. Centralize SSH Profiles Keep remote naming boring and consistent in `~/.ssh/config`. Use names that encode environment and role, such as `prod-api-01`, `stage-worker-02`, or `client-vpn-bastion`. `Host stage-api-01 HostName 203.0.113.10 User deploy IdentityFile ~/.ssh/work_ed25519 ForwardAgent no ServerAliveInterval 30` Then use your workspace terminals to run those named profiles. The goal is to avoid copying raw IPs, usernames, and flags from old notes. ### 3\. Standardize Per-Project Startup Every serious project should have one startup entry point. It can be a Make target, a package script, or a small shell script. It should start the services you actually need and print the checks you should run next. `make dev npm run test:watch docker compose up api db redis ./scripts/check-local.sh` In 1DevTool, save a project layout with terminals named by job: app, tests, docker, logs, agent. Pair that with [Layout Presets](/features/layout-presets) so the project opens in the shape you expect. ### 4\. Add Quick Diagnostics Aliases All-in-one tools feel fast because common diagnostics are nearby. On Linux, make those checks explicit: `alias ports='ss -ltnp' alias dps='docker ps --format "table {{.Names}}\\t{{.Status}}\\t{{.Ports}}"' alias glog='git log --oneline --decorate -12' alias gst='git status --short --branch' alias disk='df -h .'` 1DevTool covers several of these surfaces directly with [Docker Manager](/features/docker-containers), [Port Manager](/features/port-manager), and visual git tooling, but keeping aliases gives you a portable fallback when you SSH into a plain server.
Docker containers dashboard in 1DevTool
Put frequent diagnostics in the workspace, and keep shell aliases as the portable layer.
### 5\. Restore Session State With One Command Your Linux setup should have a single answer to "how do I get back to work?" That answer might be opening a 1DevTool project, running `make dev`, and resuming the named terminals. It should not be a checklist you reconstruct every morning. If you run AI agents, pair this with [Session Continuity](/features/session-continuity) and [Activity Logs](/features/activity-logs). Long-running agent work needs the same persistence as any other terminal process. ## Remote Monitoring Without Full SSH Sometimes you do not need a full remote shell from your phone. You only need to see whether a build finished or answer an agent prompt. 1DevTool's [Remote Terminal](/features/remote-terminal) lets you stream live output and send commands to running terminals from a paired mobile device.
Mobile remote terminal interaction in 1DevTool
Remote monitoring is useful when a long-running task needs attention away from your desk.
## Common Mistakes - **Rebuilding sessions manually:** if you do it every morning, automate it. - **Unclear SSH names:** raw IPs and ad hoc aliases lead to wrong-host mistakes. - **No portable fallback:** GUI convenience should not replace basic shell commands. - **One giant terminal wall:** name terminals by job and save layouts per project. ## A Sane Starting Setup 1. Keep SSH destinations in `~/.ssh/config` with boring names. 2. Use tmux-backed persistence for long-running local terminals. 3. Create one project startup command. 4. Save a terminal layout per project. 5. Add aliases for diagnostics you use on remote machines. 6. Use activity logs or notifications for long-running tasks. The best Linux dev environment alternative to all-in-one Windows tooling is a workflow that preserves the convenience without hiding the underlying system. Keep the durable pieces portable, then use a terminal manager like 1DevTool to make daily project work faster. Download [1DevTool](/download) when you want tmux-backed terminal persistence, project layouts, Docker and port visibility, AI terminals for Claude Code and Codex CLI, and remote terminal monitoring in one Linux-friendly workspace. --- ## Send to Any AI Terminal Across Projects and Open Templates From the Browser Source: https://1devtool.com/blog/send-to-ai-across-projects-templates Published: 2026-04-14 Tags: multi-project, send-to-ai, app-templates, deep-links, developer-workspace Route files, screenshots, and prompts to AI terminals in any open project, then open the exact starter template you clicked in the browser with deep links, search, filters, and a cleaner two-step create flow. You're working in Project A, but the best Claude Code session for the task is already open in Project B. The file you want to send is ready. The screenshot is ready. The prompt is ready. What slows you down is the handoff itself: switch projects, open the right terminal, re-open the dialog, send the context, then switch back and remember where you were. That is a workflow tax, not a model problem. 1DevTool v1.14.1 removes it with **Send to AI across every open project**, then pairs it with a second improvement that matters just as much when you are starting new work: **browser-driven App Template deep links**. Click a template link on the web and 1DevTool opens the exact starter project inside the Templates dialog instead of forcing you through a manual search. Together, these features tighten two moments that happen constantly in AI-assisted development: handing context to the right running agent, and spinning up the next project without friction.
{/* eslint-disable-next-line @next/next/no-img-element */} Send to AI workflow for handing files and prompt context to an AI terminal
You can now hand files, screenshots, and prompt context to an AI terminal without treating project boundaries like hard walls.
## Why Cross-Project Handoffs Matter Multi-project AI workflows break down when the fastest agent is trapped in the wrong workspace. Maybe your refactor is running in a Codex terminal tied to the library repo, while the UI issue lives in the app repo. Maybe your best Claude Code session already has the right architecture context, but the file you need is open in another project window. If the transfer path is clumsy, you delay the handoff or duplicate context in a fresh session. 1DevTool's updated Send to AI flow fixes this by treating every open AI terminal as a valid destination. In the source, the dialog builds two explicit target lists: `currentProjectAiTerminals` and `otherProjectAiTerminals`. The selector then renders them in two optgroups: **"Terminal AI from this project"** and **"Terminal AI from other projects"**. That sounds small, but it changes the mental model. Instead of navigating to the correct project first, you choose the correct running agent first. ### How the Terminal Picker Stays Fast The dialog still prioritizes your current workspace. Terminals from the active project are listed first, and the component auto-selects the last active AI terminal when it can. That means the common case stays one-click, while the cross-project case becomes a dropdown decision instead of a workspace switch. In practice, this is what it unlocks: - You can keep working in the file tree of one repo while sending a screenshot to a Claude Code session in another repo. - You can hand off a file to a Codex CLI terminal that already has migration context without cloning that context into a fresh conversation. - You can keep long-running agent sessions alive in specialized projects and still route new work to them on demand. ## Template Links That Open the Right Project The other half of v1.14.1 targets the opposite moment: the instant before work begins. You find a starter template in the browser, click "Open in 1DevTool," and the app should take you directly to the exact template you meant to use. Not a blank launcher. Not the top of a long catalog. The exact template. The implementation is direct and reliable. The Electron main process registers the `onedevtool://` protocol, the renderer calls `consumePendingDeepLink()`, and when the deep link resolves to a `templates-install` action, the app opens the Templates dialog with `initialTemplateId` already set. The dialog then: - finds the matching template by ID, - switches to the right category, - clears any active search and tag filters, - auto-selects the template if it is available, and - scrolls the card into view with `scrollIntoView(..., block: 'center')`. If the template is coming soon, the dialog still opens and tells you that clearly instead of failing silently. If the app was already open, it reuses the current window. If it was closed, it launches and preserves the deep-link target until the UI is ready.
{/* eslint-disable-next-line @next/next/no-img-element */} App Templates dialog opening to a preselected template from a deep link
Template deep links no longer dump you into a generic catalog. They open the exact starter you clicked and bring it into view immediately.
### Search, Filters, and a Two-Step Wizard v1.14.1 did not stop at deep links. The Templates dialog also gained search across name, description, and tag, three status filters (All, Available, Coming Soon), clickable technology tag chips, and a one-click "Clear all" reset. When the catalog grows, that matters more than headline announcements do. You are no longer browsing blind. The create flow also became easier to reason about. Instead of mixing selection and project details in one dense panel, the dialog now uses a two-step flow: **Select template**, then **Project details**. The Back button returns you to the catalog without nuking the name and location you already typed. ## Before vs After Workflow Before v1.14.1 After v1.14.1 Send context to another AI session Switch projects first, then find the terminal Pick any open AI terminal directly from the dialog Open a starter template from the web Launch app, browse manually, search again Deep link opens the exact template and scrolls it into view Browse a growing template catalog Mostly scrolling Search, status filters, tag filters, and category switching Create project from template Selection and details mixed together Two-step wizard with state preserved when going back ## Who Benefits Most Developer Why v1.14.1 helps Multi-project AI users You can route files and prompts to the right running agent without leaving your current repo. Template-heavy builders You can jump from a web page straight into the matching starter project instead of searching again. Teams testing stacks quickly Search, filters, and tag chips make it much faster to compare React, Next.js, Tailwind, and other starter combinations. Developers protecting flow state Both features reduce context switching at exactly the moments where momentum usually gets interrupted. ## Try It Today If your AI workflow already spans multiple repos, you should not be paying a project-switch penalty every time you send context to the right terminal. And if starter templates are part of how you begin work, a browser click should take you directly to the right project. 1DevTool v1.14.1 closes both gaps. You can download it from [1devtool.com](https://1devtool.com) and feel the difference the next time you hand work to another running agent or open a project template from the browser. --- ## Go to Definition Across 10 Languages and App Templates for Instant Project Setup Source: https://1devtool.com/blog/go-to-definition-app-templates-ai-code-editor Published: 2026-04-13 Tags: go-to-definition, code-intelligence, app-templates, theme-preview, tmux, productivity, claude-code Cmd+Click any symbol to jump to its definition across TypeScript, Python, Go, Rust, and six more languages with full navigation history. Plus curated starter templates with zoomable previews and real-time theme preview that applies instantly as you browse. You're reading through an unfamiliar codebase. A function call appears on line 47 — `resolveUserPermissions(ctx)` — and you need to know what it does. You highlight the name, open Quick Open, type a guess at the filename, scroll through results, find the file, scan for the function definition, and finally land on it. Thirty seconds of friction for what should be a single click. Meanwhile, starting a new project means hunting for a starter template on GitHub, cloning it, deleting the `.git` folder, renaming things, and hoping the dependencies still resolve. Two separate problems, both solved in [1DevTool](https://1devtool.com) v1.14.0. **Go to Definition** brings Cmd+Click / F12 navigation to 10 languages — click any symbol and land on its definition instantly, even across files. **App Templates** let you spin up a new project from a curated catalog with a live preview lightbox and zero git knowledge required. And a set of real-time preview improvements mean you can browse themes, change fonts, and adjust terminal settings without ever hitting a save button.
{/* eslint-disable-next-line @next/next/no-img-element */} Go to Definition jumping from a function call to its definition in a different file
Cmd+Click a function call and the editor opens the target file, scrolls to the definition, and pushes your current position onto a navigation stack.
## Go to Definition Across 10 Languages If you've used VS Code, you know the workflow: Cmd+Click a symbol and the editor jumps to where it's defined. 1DevTool v1.14.0 brings this same capability to its built-in editor, powered by real language servers running on your machine — not a sandboxed approximation. Hold **Cmd** (or Ctrl on Windows/Linux) and click any function call, import, variable reference, or type annotation. The editor opens the file containing the definition, scrolls to the exact line, and positions your cursor on the symbol. Press **F12** as an alternative shortcut if you prefer the keyboard. It works the same way whether the definition is in the same file, a different file in your project, or deep inside a dependency. ### Supported Languages Go to Definition works across 10 languages, each backed by a real LSP server: Language LSP Server Detected By TypeScript / JavaScript `typescript-language-server` `tsconfig.json`, `package.json` Python `pyright` `pyproject.toml`, `requirements.txt` Go `gopls` `go.mod`, `go.work` Rust `rust-analyzer` `Cargo.toml` C / C++ `clangd` `compile_commands.json` Ruby `solargraph` `Gemfile` PHP `intelephense` `composer.json` Swift `sourcekit-lsp` `Package.swift` Each server runs as a real child process with full filesystem access — it reads your config files, parses your dependencies, and resolves modules the same way your build tool does. When Code Intelligence is disabled for a project, the definition provider returns immediately with zero IPC overhead (two property checks and an early return), so there's no performance cost for projects that don't need it. ### Back and Forward Navigation Every time you jump to a definition, your current position is pushed onto a navigation stack. Press **Ctrl+−** on Mac (or **Alt+Left** on Windows/Linux) to go back. Press **Ctrl+Shift+−** (or **Alt+Right**) to go forward. The stack holds up to 50 entries with FIFO eviction, so you can drill into nested definitions and retrace your steps without losing your place. The editor toolbar shows back and forward arrow buttons that light up when history is available. These are the same shortcuts VS Code uses, so muscle memory transfers directly. ### New Code Intelligence Settings Tab Settings > IDE now has a dedicated **Code Intelligence** sub-tab alongside AI Diff and Built-in TypeScript Checks. For each of the 10 supported languages, you can see: - Whether the language server binary is detected on your machine (green dot) or missing (amber dot with install hints) - Which capabilities are active: **Diagnostics**, **Go to Definition**, and upcoming **Autocomplete** and **Hover** - The installed version and binary path - A per-language enable/disable toggle and a quick-install button for missing servers A **Rescan my machine** button re-detects available servers by scanning your `$PATH`, Homebrew, npm global installs, asdf, and nvm — without restarting the app.
{/* eslint-disable-next-line @next/next/no-img-element */} Enable Code Intelligence dialog showing detected languages with file counts and install status
The Code Intelligence dialog scans your project and shows which language servers are detected, with file counts and quick-install buttons for missing ones.
## Create Projects from Curated Starter Templates Starting a new project shouldn't mean 20 minutes of scaffolding. The new **App Templates** dialog shows a browsable catalog of ready-to-use starter projects organized by category: Landing Pages, Blogs, SaaS Apps, and Desktop Apps. Each template shows a preview image, a description, and technology tags so you can find the right starting point in seconds.
{/* eslint-disable-next-line @next/next/no-img-element */} App Templates dialog showing a browsable catalog of starter projects organized by category
Browse templates by category, preview screenshots, pick a destination folder, and create a new project in one click.
### Click to Zoom Preview Images Click any template's preview thumbnail and it opens in a fullscreen lightbox. Scroll to zoom (0.5x to 4x magnification), drag to pan when zoomed, double-click to toggle between 1x and 2x, and use [keyboard shortcuts](https://servercompass.app/features/keyboard-shortcuts) (`+` / `-` to step, `0` to reset, `Esc` to close). Templates with multiple preview images get left/right navigation arrows and dot indicators at the bottom. Above 200% zoom, the preview switches to crisp pixelated rendering instead of blurry bilinear scaling, so you can verify exact layout details. ### Works Without Git Installed If git isn't on your machine, 1DevTool automatically downloads the template as a compressed archive from GitHub instead of cloning. You get the same files either way — git just won't be initialized in the project folder. The app caches the template manifest for 5 minutes and falls back to a stale cache if the network is unavailable, so the catalog loads fast even on spotty connections. ### From Template Tab in Add Project The Add Project dialog now has three tabs: **Open Existing**, **Create New**, and **From Template**. The template tab uses the same category sidebar and horizontal card layout as the standalone Templates dialog, so you can start from a template without leaving the project creation flow. Pick a template, choose a destination folder, name the project, select an accent color, and click Create. ## Real-Time Theme Preview Choosing a theme used to mean clicking a card, closing settings, checking how it looks, reopening settings, trying another one, and repeating until you find the right fit. Now theme changes apply the instant you click a card. The new colors propagate through 35+ CSS variables injected directly into the document root — every panel, toolbar, sidebar, and editor updates simultaneously with no save step and no restart. ### VS Code Theme Import with Live Rollback Importing a VS Code theme file now shows a live preview before you commit to it. The importer parses the VS Code JSON (including JSONC with trailing commas), maps colors to 1DevTool's theme properties using smart fallbacks (if the sidebar background is missing, it derives one from the editor background), and applies everything as a preview. If you cancel or navigate away, the previous theme is automatically restored. The converter handles automatic light/dark detection based on luminance calculation, so you don't need to specify the theme type manually. ### Font and Display Settings Update Instantly Font family, font size, scrollbar visibility, and unfocused terminal opacity all apply in real time as you change them. The app detects which monospace fonts are installed on your system using `document.fonts.check()`, and you can import custom `.ttf`, `.otf`, or `.woff2` files directly from settings. A live sample text preview shows exactly how your current selection renders before you move on. ## tmux Mouse Scroll Control If you use tmux, you've likely fought with mouse scroll behavior inside terminal apps. 1DevTool v1.14.0 adds a **tmux Mouse Behavior** setting with three explicit modes: Mode Scroll Behavior Best For **Native text selection** Scrollbar moves the terminal viewport Selecting text and scrolling output **Respect tmux config** Follows your `~/.tmux.conf` Users with custom tmux setups **Force tmux mouse on** Scroll moves the tmux pane and enters copy-mode tmux power users No more guessing why scroll doesn't work the way you expect — pick the mode that matches how you use tmux and move on. ## Resume Session Filtering by AI Agent The Resume panel now supports filtering sessions by agent type. If you're running Claude Code, Codex, Gemini CLI, Amp, and Qwen Code across different projects, you can narrow the list to just the agent you want instead of scrolling through every session from every tool. The preview text is also cleaner — system tags and internal XML are stripped, and the last few sentences are extracted as a readable summary instead of raw terminal output. ## Before vs. After Workflow Before v1.14.0 After v1.14.0 Finding a function definition Quick Open → guess filename → scroll → find symbol Cmd+Click the symbol Starting a new project GitHub → clone template → delete .git → rename → install Templates → pick one → Create Choosing a theme Click → close settings → check → reopen → try another Click a theme card, see it live instantly tmux scroll behavior Google "tmux mouse scroll not working in terminal app" Pick one of three modes in settings Finding a past session Scroll through all sessions from all agents Filter by agent type, read clean previews ## Who Benefits Most Developer Profile How This Helps **Multi-language developers** One-click navigation across TypeScript, Python, Go, Rust, C++, Ruby, PHP, and Swift — same shortcut, same history stack **Freelancers starting new client projects** App Templates cut scaffolding time from 20 minutes to 20 seconds **Theme customizers** Live preview means you can try 15 themes in 30 seconds instead of 15 minutes **tmux users** Three explicit scroll modes end the "why doesn't scroll work" frustration **Multi-agent power users** Filter resume sessions by Claude Code vs. Codex vs. Gemini so you find the right conversation fast ## Bug Fixes in v1.14.0 - Fixed Command Palette and Quick Open flickering while typing — results now update smoothly after you pause, with a subtle "Searching..." indicator - Fixed theme not applying until app restart - Fixed file explorer collapsing all open folders on refresh - Fixed tmux mouse scroll not working correctly inside 1DevTool ## Try It Today Go to Definition, App Templates, real-time theme preview, and tmux mouse control are all available now in [1DevTool](https://1devtool.com) v1.14.0. Download the latest version and Cmd+Click your way through any codebase — or start a fresh project from a template and have it running in under a minute. --- ## Per-Project Code Intelligence and an AI Diff Review Panel for Claude Code Sessions Source: https://1devtool.com/blog/per-project-code-intelligence-ai-diff-panel Published: 2026-04-09 Tags: claude-code, codex, gemini-cli, code-intelligence, language-server, typescript, ai-diff, productivity Real per-project language servers (typescript-language-server, gopls, pyright, rust-analyzer, and five more) replace Monaco's false-error squiggles with accurate diagnostics, and a brand new AI Diff panel tracks every file modification any AI agent makes — Claude Code, Codex, Gemini, Amp — with per-file Accept and Revert. You open a TypeScript file in a fresh project. Before you've typed a character, the editor is already lit up with red squiggles. `Cannot find module './Foo.module.css'`. `JSX element implicitly has type 'any'`. `Cannot find module 'react/jsx-runtime'`. Six more on every component you scroll past. The build runs fine. The app loads fine. Every single one of those errors is a lie. This is the experience of running a sandboxed TypeScript worker — like the one Monaco ships with — against a real project. The worker can't read your `node_modules`, can't parse your `tsconfig.json`, can't resolve your `*.d.ts` declarations, and can't see your CSS Modules plugin. So it invents errors for everything it can't verify, and your editor turns into a noise machine that you eventually train yourself to ignore. Which means the day a *real* type error appears, you ignore it too. [1DevTool](https://1devtool.com) v1.13.0 ships the fix for both halves of this problem. **Per-Project Code Intelligence** spawns a real language server — `typescript-language-server`, `gopls`, `pyright`, `rust-analyzer`, and five more — for the projects you opt into, with full access to your filesystem, your config, and your dependencies. And the brand-new **AI Diff Review Panel** tracks every file modification any AI agent makes — Claude Code, Codex, Gemini, Amp, custom — and gives you per-file Accept and Revert buttons so you can review your agents' work before it lands.
{/* eslint-disable-next-line @next/next/no-img-element */} Code Intelligence settings page in 1DevTool listing detected and installed language engines
The new Code Intelligence settings page lists every detected language engine and the version installed on your machine.
## Why Monaco's Built-In TypeScript Lies to You Monaco — the editor component that powers VS Code, 1DevTool's editor strip, and a long list of web-based IDEs — ships with a bundled TypeScript worker. The worker runs in a sandboxed thread inside the renderer, with no filesystem access. It can't read `node_modules`. It can't open your `tsconfig.json`. It can't parse your CSS Modules side-effect declarations. It can't walk your monorepo to find a sibling package's exports. What it *can* do is parse the file you have open and run a subset of TypeScript diagnostics against the in-memory text. That subset is enough for syntax checking, basic flow analysis, and the kind of intra-file type errors that don't cross a module boundary. It is *not* enough for module resolution, declaration files, JSX runtime detection, or anything else that requires reading the disk. So the worker has two options for the diagnostics it can't answer. It can stay quiet and let you discover the import error at build time — at which point you have no idea which file the error came from — or it can speculate. Monaco speculates. Aggressively. Every time it can't resolve a module, it emits `TS2307`. Every time it sees a JSX element it can't type, it emits `TS7026`. Every time it can't find `react/jsx-runtime` — which it can never find from a sandboxed worker — it emits `TS2875`. And every time it sees an import for a file with no `.d.ts`, it emits `TS7016`. Your build is fine. Your types are fine. The squiggles are fake. ## Per-Project Code Intelligence: Real Language Servers, On Demand The right fix is to spawn a real language server — a real `typescript-language-server` process, with real filesystem access, that can read your `tsconfig.json` and `node_modules` and tell you the truth about your code. The reason most editors don't do this in a sandboxed environment is that language servers are heavy: a single TypeScript engine can take 200–500 MB of RAM and 5–30 seconds to do its first index. Spawn one per project automatically and a developer with ten projects open is running five gigabytes of language servers in the background. 1DevTool's answer is *per-project, on-demand, opt-in*. Code Intelligence engines never spawn automatically. They only run for projects you explicitly enable, so memory cost is bounded by your choice instead of automatic background spawning. ### Enable From the Right-Click Menu Right-click any project in the sidebar and pick **Enable Code Intelligence…** A dialog scans the project, lists every language it detects, and shows the file count for each (`55 TypeScript files`, `12 Python files`, etc.) along with the installed engine version. Languages whose binaries are present on your machine are pre-checked; languages it detected but couldn't find an engine for show up in a separate *Detected but not installed* section with a hint for the install command (`npm install -g typescript-language-server`, `pip install pyright`, and friends). A clear inline warning explains the cost — 200–500 MB of RAM per engine, 5–30 seconds for the first index — so nobody opts in by accident. Confirm the dialog and the engines spawn in the background, indexing your project against its real configuration.
{/* eslint-disable-next-line @next/next/no-img-element */} The Enable Code Intelligence dialog in 1DevTool with detected languages and file counts
The Enable Code Intelligence dialog scans the project, counts files per language, and tells you which engines are installed before you opt in.
### Eight Languages Out of the Box Code Intelligence ships with adapters for eight language engines, all detected automatically by file extension: - **TypeScript / JavaScript** — `typescript-language-server` - **Python** — `pyright` - **Go** — `gopls` - **Rust** — `rust-analyzer` - **C / C++** — `clangd` - **Ruby** — `solargraph` - **PHP** — `intelephense` - **Swift** — `sourcekit-lsp` The Code Intelligence settings page in `Settings → IDE → Code Intelligence` is purely a status board: it shows which engines are present on your machine, the version of each, and which projects currently have them enabled. There's a **Rescan my machine** button in the Available Languages header that re-scans your `$PATH` and common install locations (`brew`, `npm i -g`, asdf, nvm) to pick up engines you installed externally without restarting the app. Turning an engine on for a specific project still happens from the right-click menu in the sidebar — there is no "global enable" button, by design. ### Status Bar Brain Icon: One-Click Stop Once at least one project has Code Intelligence active, a green dot, a brain icon, and an active project count appear in the bottom status bar. Click the icon and a popover lists every active project, every engine it's running, the live status (`ready` / `starting` / `crashed`), and a **Disable** button per project. This is the emergency-stop UI: if your machine is under memory pressure, one click frees the entire 200–500 MB an engine is consuming. Right-clicking an enabled project in the sidebar adds two more options: **Restart Code Intelligence** (bounce the child processes if an engine gets stuck or you change a `tsconfig.json` and want a clean reload) and **Disable Code Intelligence** (SIGTERM the processes, free their RAM, clear the persistent flag so they don't auto-respawn next launch).
{/* eslint-disable-next-line @next/next/no-img-element */} Status bar brain icon and popover showing active Code Intelligence projects in 1DevTool
The status bar brain icon shows every active engine and gives you a one-click stop per project.
### Sticky Across App Restarts Once you enable Code Intelligence on a project, the choice persists. Quit and relaunch and the engines respawn automatically for the projects that were enabled — you never re-enable per session. The persistent flag is cleared the moment you Disable, so the opt-in is durable but not sneaky. ### Built-in TypeScript Checks: Three Modes For projects where you don't want to opt into Code Intelligence — small scripts, scratch files, third-party code you're reading — the editor still has Monaco's bundled TypeScript checker. v1.13.0 ships a new **Built-in TypeScript checks** settings page with three modes: - **Full** — semantic and syntax checks with the module-resolution false-positive diagnostics (TS2307, TS7026, TS2875, TS7016, and six others) suppressed. Use this when Code Intelligence is running per-project so the language engine provides authoritative diagnostics - **Syntax only** — parse errors only. No type checking, no module resolution. The default for new installs because it eliminates the entire class of false positives that the sandboxed worker would otherwise invent - **Off** — completely silent. No squiggles. Useful when Code Intelligence is the single source of truth for TypeScript errors and you want to avoid duplicate squiggles
{/* eslint-disable-next-line @next/next/no-img-element */} Built-in TypeScript checks settings in 1DevTool with Full, Syntax only, and Off modes
Three honest modes for the bundled TypeScript checker, plus a clear note about the overlap with Code Intelligence.
## AI Diff Review Panel: See Every File Your Agent Touched The other half of v1.13.0 is the **AI Diff Review Panel**, and it answers a question every **claude code** user has asked at some point: *what actually changed during that twenty-minute run*? AI agents touch dozens of files in a single prompt. You can't safely review all of them in scrollback — by the time the agent finishes, the "edited file: src/components/Foo.tsx" line is buried under 400 lines of subsequent output. Most developers either trust the agent blindly and ship bugs, or burn 20 minutes diff-ing files manually after the fact, or run `git status` and try to mentally reconstruct which change came from which prompt. The AI Diff panel solves this by snapshotting affected files at the moment an AI agent starts a new prompt, watching the agent's file modifications, and grouping every change into a reviewable session.
{/* eslint-disable-next-line @next/next/no-img-element */} AI Diff panel in 1DevTool showing pending file changes from an AI agent run with Accept and Revert buttons
Every file an AI agent touched, grouped by session, with per-file Accept and Revert buttons.
### Per-Prompt Baselines When an AI agent starts a new prompt, the AI Diff system snapshots the affected files before the agent edits them. This is the baseline. As the agent works, every file it modifies is tracked against its baseline. When the agent finishes — or even if you walk away during the run — the panel shows you exactly which files changed and what changed in each one. ### Accept or Revert, Per File or Per Session Each pending change has its own **Accept** and **Revert** buttons. Accept locks the change in and removes it from the pending queue. Revert restores the file to its pre-agent baseline, undoing whatever the agent did to that one file. For when you trust — or distrust — an entire run, the session header has bulk Accept and bulk Revert buttons: ship every file the agent touched in one click, or undo the entire run and start over. ### Inline Diff Overlay in the Editor Click any changed file in the AI Diff panel and 1DevTool opens it in the IDE strip with the diff visible inline as Monaco overlay highlights — added lines in green, removed lines in red, modified ranges in a side-by-side gutter. You can read the agent's work in the actual file, in the actual editor, with the actual surrounding code as context. No external diff viewer. No tab switching. No `git diff` in a terminal. ### Session History Every AI agent run creates an AI Diff session with the agent type (Claude Code, Codex, Gemini, Amp, etc.), the prompt that started it, the start time, and the count of changed files. The Sessions tab in the panel rolls up every past session into a browsable list — expand any session to see its file list, and accept or revert old changes any time. The pattern is the same as a code review queue, but at the granularity of an AI prompt instead of a Pull Request.
{/* eslint-disable-next-line @next/next/no-img-element */} AI Diff settings page in the IDE settings tab in 1DevTool
AI Diff is opt-in — turn it on from Settings → IDE → AI Diff when you're ready to start tracking.
### Off by Default, Opt In When You're Ready The AI Diff panel is off by default. To turn it on, head to `Settings → IDE → AI Diff` and flip the toggle. From that moment forward, every AI agent run is tracked — and the panel populates as you work. ## Settings Reorganization: Sub-Tabs in the IDE Tab Both Code Intelligence and AI Diff live in the IDE settings tab, and the IDE tab has been reorganized with sub-tabs to hold them. AI Diff, Code Intelligence, and Built-in TypeScript checks each get their own focused page so the settings dialog stops being a giant scroll. Click the sub-tab at the top of the IDE tab to switch between them. And for everything that used to be called *Language Server* in the codebase: the feature is now called **Code Intelligence** in every place a user can see it — settings, dialogs, right-click menus, status bar tooltip, install errors. Internally it's still LSP. The rename is purely cosmetic so the feature stops sounding like a protocol spec and starts sounding like the thing it actually does. ## Before vs After The old workflow 1DevTool v1.13.0 Open a TypeScript file → ten red squiggles → ignore them all → miss the real one Enable Code Intelligence on the project → real `typescript-language-server` reads your tsconfig and node\_modules → only real errors show up AI agent runs for 20 minutes → 30 files changed → no idea which → diff manually AI Diff panel shows every file the agent touched, grouped by session, with Accept/Revert per file `git status` shows 30 changed files mixed in with your own work — can't tell which came from the agent AI Diff baselines snapshot files at prompt start, so agent changes are isolated from your manual edits Every CSS module import is a fake error → train yourself to ignore squiggles Suppression list silences TS2307, TS7026, TS2875, TS7016 in the bundled checker; Code Intelligence resolves them for real Spawn a global language server for every open project → 5 GB of RAM Per-project, on-demand, opt-in — only pay for the projects you actually want intelligence on ## Who Benefits Most You Why this release matters Use TypeScript with CSS Modules, Next.js, or any modern bundler The fake-error squiggles you used to see on every import are gone in Syntax-only mode and never appear once Code Intelligence is on Run Claude Code, Codex, or Gemini on multi-file refactors The AI Diff panel finally answers "what just changed" without you trawling scrollback Work in Python, Go, Rust, C/C++, Ruby, PHP, or Swift Each language gets a real per-project engine — pyright, gopls, rust-analyzer, clangd, solargraph, intelephense, sourcekit-lsp Switch between many small projects through the day Per-project opt-in means you never pay 500 MB of RAM for a project you're only opening to read a README Review AI agent changes before shipping them Per-file Accept and Revert with inline diff overlays make "trust but verify" a one-click action instead of a commit-and-rollback dance ## Try It Today Per-Project Code Intelligence and the AI Diff Review Panel both ship in 1DevTool v1.13.0. Download the latest from [1devtool.com](https://1devtool.com), right-click any project in the sidebar and pick *Enable Code Intelligence…* to turn on real language servers for that project. Then head to `Settings → IDE → AI Diff` to flip the AI Diff panel on, and your next Claude Code session will start tracking every file change. And if you haven't seen the v1.12.0 release yet, both features were designed to pair with [Git Worktrees and the Visual Git Graph](/blog/git-worktrees-visual-graph-multi-account-github) — which let you run separate AI agents on separate branches in the same repo, each with its own working copy and its own diff history. --- ## Git Worktrees, Visual Commit Graph, and Multi-Account GitHub for AI Coding Workflows Source: https://1devtool.com/blog/git-worktrees-visual-graph-multi-account-github Published: 2026-04-08 Tags: claude-code, codex, gemini-cli, git, worktree, github, multi-account, productivity Run multiple branches of the same repo side-by-side with a first-class Worktrees tab, navigate your history in a colored lane-based commit graph, and lock projects to specific GitHub accounts so you never push from the wrong identity again. You're mid-feature when an urgent hotfix lands in Slack. The code you have open is half-broken — three new files, two deleted ones, a migration that hasn't been run, a Claude Code session that's been running for twenty minutes and is still going. The standard `git stash` + `git checkout main` dance is going to flatten every one of those things, and an hour later when you come back to your feature branch, you'll have lost the agent's context, your editor state, and your scroll position. Worse: you'll discover that one of the files you stashed had unstaged changes you forgot about, and now you have to remember which lines you'd already written before the interruption. This is the workflow that **git worktrees** were invented to fix. Git itself has supported them since 2015, but the gap between "git supports them" and "a developer can actually use them in their daily workflow without typing `git worktree add` from a terminal" has stayed wide open for ten years. Most GUI git clients still don't expose them. Most editors still don't either. [1DevTool](https://1devtool.com) v1.12.0 closes that gap. The release ships three substantial git features: a brand-new **Worktrees tab** in the Git Client that treats worktrees as first-class workspace objects, a **Visual Git Graph** that renders your repo history as a colored lane-based commit graph, and **Multi-Account GitHub** with token-aware fetch, pull, and push so you never accidentally push your work commits from your personal identity again.
{/* eslint-disable-next-line @next/next/no-img-element */} Git worktree cards in 1DevTool showing branch, dirty state, lock, and running terminals
The new Worktrees tab in the Git Client — every linked working copy gets its own card with branch, dirty state, lock state, and the terminals running inside it.
## Git Worktrees: Side-by-Side Branches Without git stash A worktree is git's answer to the "I need to be on two branches at once" problem. Instead of stashing and checking out, you ask git to create a second working directory linked to the same `.git` folder. The two directories share history, objects, and refs — so they're cheap on disk — but each one has its own checked-out branch, its own files, and its own dirty state. Edit a file in one and it doesn't appear in the other. Run a build in one and the artifacts don't leak across. That's the primitive. The thing 1DevTool adds is treating each worktree as a first-class object in the workspace — visible, switchable, and integrated with the rest of your tools. ### Worktrees Tab: One Card Per Linked Working Copy The new **Worktrees tab** in the Git Client renders every worktree on the repo as a card. Each card shows: - The **branch name** currently checked out in that worktree, plus a colored dot for visual identification across the workspace - A **dirty state badge** (clean / modified / staged) that auto-refreshes every five seconds while the panel is open, so editing a file in one worktree shows up in the others without you clicking refresh - A **lock state** with a one-click toggle — locked worktrees are protected from accidental removal, which matters for the long-running "I'm always on this branch" worktrees you don't want to nuke by accident - The **list of terminals running inside the worktree**, so you can see at a glance which AI agents and dev servers belong to which working copy Each card has a `+ Terminal` button. Click it and the full Add Terminal dialog opens with that worktree pre-selected — so spawning a Claude Code or Codex session inside a specific branch is a single click instead of a multi-step folder navigation.
{/* eslint-disable-next-line @next/next/no-img-element */} Adding a new terminal inside a git worktree from the Add Terminal dialog in 1DevTool
The Add Terminal dialog now has a worktree picker that defaults to whichever worktree your currently focused terminal is using.
### Worktree-Aware Everything The deeper change is that every git command in the Git Client now runs against the *active* worktree, not just the project root. Stage a file from the visual git panel and it stages in the worktree your focused terminal lives in. Commit, fetch, pull, push — all of them honor the active worktree. The Add Terminal dialog's worktree picker even defaults to whichever worktree your currently focused terminal is using, so opening a sibling tab in the same working copy is a single click. Terminals also get labeled with the worktree name in the tab header. If you have one Claude Code session running in `main/` and another running in `feature-billing/`, you'll see both branches in the tab strip and never confuse them.
{/* eslint-disable-next-line @next/next/no-img-element */} A terminal tab labeled with its git worktree name in 1DevTool
Terminals show their worktree name in the tab header — you can run two AI agents on two different branches and never lose track of which is which.
### Real-Time Git State Watcher Worktrees that get created or modified outside the GUI used to require a manual refresh. The new **Real-Time Git State Watcher** tracks every external change to your repo's git directory — commits from a terminal, branches created on the command line, worktrees added by hand — and refreshes the Git Client without you ever clicking refresh. Rapid filesystem events from operations like rebases or `git gc` are debounced into a single coalesced refresh, so the UI stays smooth even during heavy git activity. ## Visual Git Graph: Read History the Way it Actually Looks Reading `git log` in a terminal is fine for the last five commits and useless for the last five hundred. Real merge histories — branches, hotfixes, reverts, multi-parent merges, the squash you regret from last quarter — are nearly impossible to understand from a flat text list. You can build a mental model from `git log --graph --all --oneline`, but it takes practice and it falls apart the moment two long-lived branches diverge and reconverge. The new **Graph tab** in the Git Client renders the entire repository history as a colored, lane-based commit graph with curved merge connectors — like [tig](https://jonas.github.io/tig/), GitKraken, and Sublime Merge. Each commit is a circle on a colored lane. Each merge bends back into its parent lane with a curved connector. Each branch tip is labeled, and each tag and remote ref appears as an inline pill next to the commit it points to. Click any commit and a side panel shows the commit message, author, date, and the list of changed files. The graph supports: - **Branch filtering** — show only commits reachable from a specific branch, to focus on the slice you actually care about - **Live search** by commit message, hash, or author with highlighted matches in the graph - **Zoom from 60% to 180%** with the keyboard or zoom buttons, for projects with thousands of commits where the default density is too tight - **Right-click any commit → New Worktree from Here** — the killer feature for hotfixes off an old release. Find the commit, right-click, name the worktree, and you have a clean working copy at that exact revision without disturbing your current branch ## Multi-Account GitHub: Stop Pushing From the Wrong Identity If you have a personal GitHub account and a work GitHub account, you have done the following at least once: - Pushed work commits from your personal identity - Opened a PR with the wrong author email - Run `git push` on a fresh repo and watched it land in *literally the wrong organization* because the credential helper had cached the wrong token - Spent forty minutes trying to figure out which `~/.gitconfig` include was overriding which The root cause is the same every time: the git CLI is identity-blind. Your machine has a single global config, a single credential helper, and a single set of cached tokens, and whichever one happens to be active when you push is the one git uses. The right fix is per-project identity binding, and that's what 1DevTool v1.12.0 ships. ### Save Every GitHub Identity as an Account, Once In `Settings → Git`, you can now save every GitHub identity as a named account with its own Personal Access Token, display name, and email. The account list shows how many projects are currently using each account, so you know which one is your "main" identity at a glance. There's also a **Save & Set as Default** button on the Machine Default Git panel that ingests whatever `git config --global` already says into a proper account in one click — useful when you're onboarding 1DevTool to a machine that already has a git identity configured.
{/* eslint-disable-next-line @next/next/no-img-element */} Setting up a new GitHub account with a Personal Access Token in 1DevTool Settings
Each saved GitHub account stores its own Personal Access Token, name, and email — so the right identity is always one click away.
### Lock Each Project to a Specific Account The Add Project dialog now has an optional **Git Account picker**. Lock a project to a specific account and every git operation in that project — fetch, pull, push, publish — automatically uses the account's Personal Access Token instead of falling back to whatever credential helper your machine has cached. The bug where you accidentally push work commits from your personal identity becomes structurally impossible.
{/* eslint-disable-next-line @next/next/no-img-element */} Selecting a git account for a repo in the Add Project dialog in 1DevTool
Lock a project to a specific GitHub identity at the moment you add it to your workspace.
### Publish Repository: Live Token Verification The Publish Repository dialog used to be the most common place where wrong-account publishes happened — you'd build a fresh local repo, click Publish, and discover an hour later that it landed under the wrong organization. The new dialog re-verifies the token live before you click Publish, shows **"token belongs to actual-login"** in the header, displays a destination URL preview (`github.com/actual-login/repo-name`), and hard-blocks the Publish button until verification succeeds. The wrong-account-publish bug is fixed by construction.
{/* eslint-disable-next-line @next/next/no-img-element */} Git Client push dialog with live token verification and destination URL preview
The Publish dialog verifies your token live and shows the destination URL — no more wrong-org accidents.
## Bonus: Drag Files Into the AI Prompt Box v1.12.0 also ships a small but disproportionately useful change for anyone using **claude code** or Codex inside 1DevTool: you can now drag files, folders, or entire projects from the sidebar straight into the AI prompt box (Cmd+I), and the path drops in as a proper `@mention` insertion at your cursor. Drag five files in a row and they stack as five mentions. Drag an image file and it automatically attaches as a preview instead, so screenshots and design references skip the copy-paste-encode dance entirely. ## Who Benefits Most You Why this release matters Get pulled off feature work for hotfixes Worktrees let you keep your feature branch alive — Claude Code session and all — while you fix the urgent bug in a sibling working copy Have separate work and personal GitHub accounts Lock each project to its account once and never push from the wrong identity again Maintain long-lived branches (release/staging/hotfix) Lockable, persistent worktrees let you keep one working copy per long-lived branch with no juggling Need to read complex merge histories The Visual Git Graph turns multi-branch history into a glance instead of a 20-minute archeology session Run multiple AI agents in parallel on the same repo One worktree per branch, one AI agent per worktree, every agent labeled with its branch in the tab strip Onboard new repos frequently Live token verification on Publish means you never have to clean up a wrong-org repo again ## Try It Today Git Worktrees, Visual Git Graph, and Multi-Account GitHub all ship in 1DevTool v1.12.0. Download the latest from [1devtool.com](https://1devtool.com), open any repo, and click the Git Client tab — the Worktrees and Graph tabs are right there alongside Changes. To enable multi-account, head to Settings → Git and add your first identity. And once you're running multiple agents across multiple worktrees, the next thing you'll want is [Code Intelligence and the AI Diff Panel](/blog/per-project-code-intelligence-ai-diff-panel) — both shipped one day later in v1.13.0 — so the editor stops inventing false errors and you can review every file your agents touched, per session, before you accept the changes. --- ## Whip, Hammer, and Trump Mode: 18 Silly Animations to Cheer On Your AI Agent Source: https://1devtool.com/blog/fun-ai-agent-terminal-animations Published: 2026-04-07 Tags: claude-code, codex, gemini-cli, terminal, fun, customization, productivity A new Fun Agent Animation setting layers eighteen silly visual overlays — magic wand, rubber duck, whip crack, finger poke, walking cat, and more — on top of any AI terminal while Claude Code, Codex, Gemini, or Amp is actively generating output. Pure SVG, zero performance cost, vanishes the instant the agent goes idle. Watching **Claude Code** grind through a 30-step refactor is, mechanically speaking, watching a status line that says `Kneading... (3s)` tick upward forever. It works. It's great. But minute four of staring at the same blinking dots starts to feel like waiting for a pot of water to boil while your ADHD whispers *just touch the keyboard, just type one character, the agent will appreciate your input*. [1DevTool](https://1devtool.com) v1.11.4 ships a feature for that exact moment. It's called **Fun Agent Animation**, and it gives your **ai terminal** 18 silly visual overlays that ride along on top of any active AI agent session — Claude Code, Codex, Gemini, Amp, or any custom wrapper — and vanish the moment the agent goes idle. No tokens consumed. No CPU spent. No agent output altered. Pure whimsy, layered on top of the work. This is also a writeup about a tiny piece of design polish that took surprisingly long to get right: making the animation actually *land on the running text* as the terminal scrolls, instead of just floating in a fixed corner of the pane.
{/* eslint-disable-next-line @next/next/no-img-element */} A fun animation overlay playing on top of an active AI agent terminal in 1DevTool
A Fun Agent Animation overlay playing on top of an actively running AI agent.
## Why an Animation Instead of a Spinner? Spinners answer the question *is it still alive*. They're a binary signal — animating means alive, frozen means dead. That works fine for a 200-millisecond network request. It does not work for a Claude Code session that's been running for nine minutes while it edits forty files. At minute nine, your brain has fully tuned out the spinner. You've checked Twitter, you've refilled your coffee, you've started editing a file in another project, and the agent is doing real work that you should be paying attention to but the visual signal has gone invisible. The spinner is technically still spinning. You just can't see it anymore. Fun Agent Animation solves this with a different category of feedback: not *is it alive* but *is it still working hard for me*. A whip cracking. A hammer pounding. A magic wand bobbing and sparkling. A rubber duck blinking patiently. A small cartoon cat walking across your status line and parking on top of it. These are exactly the kind of novel motions your visual cortex doesn't tune out, even after nine minutes — because they're weird, they're overlaid on the actual running text, and they look like nothing else in your normal coding environment. ## Three Moods, Eighteen Animations The animation picker in `Settings → Terminal → Fun Agent Animation` is grouped into three moods, plus an Off setting for people whose taste is too refined for cartoon whips. Pick whichever fits your week. ### Kind ✨ — For When You're Grateful The Kind mood is for the days when your AI is doing the work and you want to thank it like a houseplant. Six animations, all gentle: - **Magic Wand** — a wand bobs over the running line and sprinkles tiny sparkles that fade after a beat - **Feed Coffee** — a steaming mug tips toward the agent and pours invisible espresso into the running text - **Rubber Duck** — a yellow rubber duck sits next to the line and blinks at you patiently - **Handshake** — two cartoon hands meet over the line and shake on a job you both know isn't done yet - **Rub AI Head** — a hand reaches in from the side and pets the running text like a good dog - **Good Dog** — a small star pulses next to the line every few seconds with a gentle "good dog" vibe ### Motivational 💪 — For When It Needs Encouragement The Motivational mood is for the long runs where you start thinking *is it actually going to finish*. Eight animations, all loud: - **Whip Crack** — a cartoon whip arcs across the line and snaps a tiny shockwave on every loop - **Hammer** — a wooden mallet rises and falls onto the running text with a thunk visual - **Cooling Fan** — a desk fan spins above the line, blowing the agent metaphorically cooler - **Finger Poke** — a fingertip jabs the running line repeatedly like a coworker checking if you're awake - **Electric Shock** — small lightning bolts crackle on top of the line at random intervals - **FASTER Rain** — the word `FASTER` rains down from the top of the pane and disintegrates near the line - **Manager Shouting** — a tiny boss head appears with a speech bubble cycling motivational management quotes - **Trump Mode** — see below ### Trump Mode Trump Mode deserves its own subhead because it cycles through twenty hand-written catchphrases, including **"MAKE CODING GREAT AGAIN"**, **"WRONG. VERY WRONG."**, **"HUGE PERFORMANCE BOOST"**, **"NOBODY WRITES CODE BETTER THAN ME"**, and the inevitable **"MAKE TERMINALS GREAT AGAIN"**. They cycle on a fixed rotation while the agent runs, and they vanish the second it goes idle. It is, by some margin, the dumbest feature 1DevTool has ever shipped, and people will not stop turning it on. ### Chaos 🌪️ — For When You've Stopped Caring The Chaos mood is for Friday afternoons. Four animations, all unhinged: - **Bug Swarm** — a procession of tiny black bugs crawls along the running line and disappears off the edge of the pane - **Firefighting Mode** — flames lick the edges of the line and a foam burst puts them out, on a loop - **Cat on Keyboard** — a small walking cat strolls across the status line and parks on top of it - **Agent Meeting** — three tiny speech bubbles pop up around the line and argue with each other in different colors ## The Design Detail That Took the Longest The hard part wasn't drawing eighteen animations. The hard part was making them actually *land* on the running line. AI agents like **claude code** render a status line at the bottom of their active output that looks like `Kneading... (3s)` or `Pondering... (12s)` or whatever cute participle the model decided on this week. That status line moves up the terminal pane as the agent streams new output above it. If a fun animation just sits in a fixed corner of the pane, it's a sticker. If it tracks the moving status line as new output pushes it up, it becomes a real interaction — the whip cracks *onto* the line that's currently animating, the cat walks *onto* the running text, the hammer thunks *onto* the work in progress. The terminal renderer in 1DevTool watches every screen update for the active AI status line — both the cute participle and the parenthesized seconds — and reports its current pixel position to the animation overlay. Every animation hooks into that position and re-renders its anchor point on every frame. When you scroll, the animation scrolls. When the agent outputs a new chunk and the status line jumps down by a row, the animation jumps with it. When the agent finishes and the status line vanishes, the animation fades out a half-second later so you don't miss the completion signal. That's what makes the feature feel like it belongs in your **ai code editor** instead of feeling like a screensaver pasted on top of your terminal. ## Zero Cost, Zero Distraction Three deliberate constraints made this feature shippable instead of annoying: - **Pure SVG and CSS.** Every animation is a pure SVG plus CSS keyframes. No canvas redraws. No GPU shaders. No network calls. No JavaScript animation loops fighting for the main thread with the terminal renderer. The CPU cost of running any of the eighteen animations is indistinguishable from idle. - **Only while the agent is working.** The overlay kicks in the exact moment an AI terminal starts generating output and vanishes the instant it goes idle. There is no animation while you're typing your prompt. There is no animation while you're reading the finished response. The animation is a signal that the agent is busy, not decoration. - **Never on the wrong terminal.** Open a bash tab, an htop tab, a ssh tab, a Postgres shell — none of them get the animation. Only terminals that 1DevTool knows are AI agent sessions render the overlay. You won't accidentally find a cartoon hammer thunking on top of your production database query. ## Who This Is For You Why this is for you Run Claude Code or Codex on long tasks You need a *visual heartbeat* stronger than a spinner so you don't check Twitter for nine minutes Work in parallel across multiple AI terminals The animations make it instantly clear which terminal is currently running, even from across the room Make videos or stream your AI workflow Everyone watching loves the rubber duck. Everyone watching loves Trump Mode more. Have coworkers who walk by your screen The number of conversations that start with "why is there a whip on your terminal" is, statistically, very high Have refined taste The Off setting is right at the top of the picker. We won't judge you. (We will.) ## Try It Today Fun Agent Animation ships in 1DevTool v1.11.4. Download the latest from [1devtool.com](https://1devtool.com), open Settings → Terminal → Fun Agent Animation, pick a mood, and start your next Claude Code session. The whip will be waiting. And if you like what you see, the same release also ships [Terminal Record](/blog/record-claude-code-sessions-mp4-replay) — so you can capture your favorite AI session, with the cartoon hammer thunking along on top of it, and share the whole thing as an MP4 sized for Twitter. --- ## Record AI Terminal Sessions and Share Them as MP4 Videos with Terminal Record Source: https://1devtool.com/blog/record-claude-code-sessions-mp4-replay Published: 2026-04-07 Tags: claude-code, codex, gemini-cli, terminal-record, sticky-notes, video-export, productivity One-click recording on every AI agent terminal, chat-style replay with word-by-word reveal, and MP4 video export sized for Twitter, TikTok, and YouTube Shorts. Plus sticky notes pinned to terminal reader mode and a searchable notes history across every project. Your Claude Code session just nailed a really hard bug. Forty-five minutes of reasoning, three failed attempts, a careful root-cause investigation, and a clean fix. You want to share it — with your team, on Twitter, in a blog post, in a tutorial — and the only tools you have are screenshots and copy-paste. Screenshots lose the streaming flow. Copy-pasted text loses the visual rhythm. Recording your screen with QuickTime gives you a 12-minute file that's impossible to share anywhere because the platforms have hard limits and your viewers won't watch twelve minutes of terminal output. The whole magic of watching an AI agent work — the word-by-word reveal, the pauses while it thinks, the back-and-forth — gets flattened. [1DevTool](https://1devtool.com) v1.11.3 introduces **Terminal Record** — one-click recording on every AI terminal, a chat-style replay viewer that captures the feel of watching an agent work, and three export formats including MP4 video sized for Twitter, TikTok, and YouTube Shorts. Plus **Sticky Notes in Reader Mode**, a new way to pin reminders, TODOs, and snippets directly onto AI terminal output. This is the share-and-document layer that **claude code** users have been improvising their way around for months. ## Terminal Record: One Click to Capture an AI Agent Session Every AI terminal in 1DevTool — Claude Code, Codex CLI, Gemini CLI, Amp, OpenCode, Cline, and any custom wrapper around those tools — now has a recording button right next to its fullscreen control. Click once to start. Click again to stop. That's it.
{/* eslint-disable-next-line @next/next/no-img-element */} The Terminal Record trigger button on an AI terminal tab in 1DevTool
The recording button sits on every interactive AI terminal — one click to start capturing.
### Visual Feedback You Can't Miss Once recording is active, three things happen at the same time so you never lose track of which terminal is being captured: - A **pulsing red REC pill** with a live `M:SS` timer replaces the recording button. The pulse is a real CSS animation, not a static dot — it's deliberately impossible to forget you're recording. - A thin **red frame stripe** appears at the top of the terminal pane, framing the entire output area in red. From across the room, you can tell at a glance which of your terminals is rolling. - The timer increments every second, so you always know exactly how long the recording has been running before you stop it.
{/* eslint-disable-next-line @next/next/no-img-element */} A pulsing red REC indicator and live timer on a recording AI terminal in 1DevTool
The pulsing REC pill, frame stripe, and live timer make it impossible to forget you're recording.
### What Actually Gets Captured Terminal Record isn't a screen recording. It's a structured capture of the entire agent session: every prompt you typed, every chunk of output the agent streamed back, and the exact timing between them. Each user prompt gets a timestamp. Each output chunk lands in an array attached to the recording. When you stop, 1DevTool walks both arrays and rebuilds the conversation as a clean sequence of messages — your prompts on one side, the agent's responses on the other, in the original order. This is the key design choice that makes the rest of the feature possible. Because the recording is structured data, not pixels, 1DevTool can replay it as a chat conversation, export it as Markdown, or render it into a video — all from the same source. A screen recording locks you into one shape; structured capture lets you choose the shape later. ## Chat-Style Replay: Like Watching the Conversation Happen Live The moment you stop recording, the chat-style replay viewer opens automatically. This is not a terminal scrollback dump — it's a Discord-style chat view of the session.
{/* eslint-disable-next-line @next/next/no-img-element */} The chat-style replay viewer showing user prompts as blue bubbles and AI responses as gray bubbles with model labels
Replay your AI session as a chat — blue prompt bubbles, gray AI responses with model name, word-by-word reveal.
### Prompts and Responses as Bubbles Your prompts appear as right-aligned blue bubbles. The AI's responses appear as left-aligned gray bubbles, each with a small uppercase label above it identifying the model — **CLAUDE CODE**, **CODEX**, **GEMINI**, **AMP**, and so on. 1DevTool detects the model from the agent type when it can, and falls back to scanning the terminal name and startup command when the agent is a custom wrapper. A terminal launched as `claude --my-custom-flags` will still get labeled as Claude Code in the replay. ### Word-by-Word Reveal With a Blinking Cursor The replay isn't a static log. The AI responses unfold word by word, just like they did the first time. A blinking vertical cursor follows the reveal, mimicking the streaming cursor your agent uses live. There's a minimum reveal time on each assistant message — about 1.5 seconds — so short messages don't flash by, and long messages cap at a readable speed instead of dumping all at once. The whitespace and indentation are preserved exactly. If Claude Code wrote a code block with indented Python, the replay reveals it indented and monospaced, line by line, the way you actually read it during the session. This is the part that makes the replay feel less like a transcript and more like watching the conversation happen again. ### 1×, 2×, 4× Playback and a Scrubber The replay viewer has playback controls at the bottom: **1×**, **2×**, and **4×** speeds, plus a draggable scrubber for jumping to a specific point in the conversation. The scrubber and the auto-scroll work together — as the replay plays, the messages scroll into view automatically. There's also a Reset button so you can rewind to the start without dragging the scrubber back to zero. 4× speed is the right setting for sharing a 5-minute session in 75 seconds. 1× is the right setting for showing a teammate exactly how the agent reasoned through a problem. The same recording supports both. ## Three Export Formats: Markdown, Standalone HTML, and MP4 Once you have a recording, the share menu offers three completely different export paths. Each one targets a different audience.
{/* eslint-disable-next-line @next/next/no-img-element */} The Terminal Record export dialog showing Markdown, standalone HTML, and MP4 video options
Export the same recording as Markdown, standalone HTML with playback, or a rendered MP4 video.
### Markdown Transcript for PRs and Blog Posts The Markdown export builds a clean transcript: a header with the model name and project name, then the full conversation with your prompts as block quotes (`>` ) and the agent's responses as plain text. It copies straight to your clipboard, so you can paste it into a GitHub pull request description, a Linear ticket, or a blog post draft without thinking about formatting. This is the format you want when text is the right medium — async review, async documentation, async knowledge sharing. ### Standalone HTML With Built-In Playback The HTML export is the cleverest of the three. 1DevTool generates a single self-contained HTML file with the entire recording embedded as a JSON payload, plus the chat-style replay viewer rendered in pure CSS and JavaScript. No external dependencies, no remote assets, no servers. Save it to `/.1devtool-recordings/{terminal-name}-.html` and you can open it in any browser, anywhere — the replay just works, with the same word-by-word reveal and speed controls as the in-app viewer. This is the format for sharing with someone who doesn't use 1DevTool. Email it. Attach it to a Slack message. Drop it in a shared drive. Anyone with a browser can hit play and watch the conversation unfold. ### MP4 Video for Twitter, TikTok, and YouTube Shorts The MP4 export is the marquee one. 1DevTool renders the chat-style replay into a real H.264 video file using hardware acceleration, with format presets sized for the platforms developers actually share on: - **Square (1:1, 1080×1080)** — the default Twitter and LinkedIn embed format. - **Portrait (9:16, 1080×1920)** — TikTok, Instagram Reels, and YouTube Shorts. - **Standard (720p)** — about 12 MB, fast to upload, fine for most platforms. - **HD (1080p)** — about 22 MB, sharp on big screens. - **Speed presets:** 1×, 2× (recommended for most clips), and 4×. And here's the part that makes it actually shippable to social platforms: **smart compression**. Anything longer than sixty seconds gets automatically time-compressed to fit a 60-second window. Twitter's video limit, TikTok's sweet spot, the YouTube Shorts cap — all the same. Your 5-minute Claude Code session becomes a 60-second clip without you doing any editing, and without the conversation getting cut off mid-sentence. The smart-compression algorithm scales reveal speed across the timeline so the full session fits while still feeling readable. Every exported video ends with a branded credit screen — a quick 1DevTool watermark and product link. If you're a PRO user, you can disable the watermark from the export dialog with a single toggle. Free users see the toggle disabled with a PRO badge and a short upsell, no nagging. ### A Per-Project Library of Your Last 24 Recordings Recordings don't disappear after you close the replay viewer. Each project keeps its last 24 recordings in a per-project recording library, accessible from a session recordings dialog. You can browse old captures, replay them, and re-export any of them in any of the three formats. Delete a recording by hand if you want to free the slot, or just let new recordings push out the oldest one. The 24-recording cap is intentional — large enough to keep a week or two of meaningful sessions, small enough that the recording library doesn't silently bloat your project folder. ## Sticky Notes in Reader Mode: TODOs and Snippets Pinned to AI Output The other half of v1.11.3 is a much smaller feature with a much different purpose: **Sticky Notes** in **terminal reader mode**. If you're not familiar with reader mode, it's 1DevTool's rendered-markdown view of long-form terminal output — Claude Code conversations, Codex sessions, agent reports — formatted as if you were reading a clean markdown document instead of staring at raw ANSI. Now you can pin sticky notes directly onto reader mode, alongside the agent output. Click the sticky-notes button in the bottom toolbar, and a movable, resizable note appears next to the document. Type into it. Drag it. Resize it. Color-code it. Repeat until your reader mode looks like a real wall of post-its. Each note has a header you can drag from, a bottom-right corner you can resize from, and a color picker offering eight presets — blue, yellow, pink, green, orange, purple, red, and gray. The transform during drag is a subtle `rotate(-1deg) scale(1.02)`, which gives the notes a tactile, paper-like feel as you move them. They auto-save every 500 milliseconds, so you can't lose work by accident. ### Scoped to the Right Context Automatically Notes aren't global. They're scoped by source, project, and either the specific terminal ID or the specific markdown file you pinned them to. A sticky note pinned to a Claude Code session in your auth refactor lives with that session. A note pinned to a markdown file in your design notes folder lives with that file. Switch projects, switch terminals, switch files — the right notes appear in the right context. Storage happens through 1DevTool's notes API rather than as text files in your project, so the notes don't pollute git history or show up in code search. ## Notes History: Every Note Across Every Project, Searchable Stickies-on-output is great until you have hundreds of them spread across a dozen projects and need to find "that snippet I saved six weeks ago." v1.11.3 adds a new **Notes** tab to the Prompt History panel that aggregates every sticky note you've ever created, across every project, into one searchable view. The Notes History panel includes: - **Full-text search** across every note, with a 300-millisecond debounce so typing is smooth. - **Filters** by project, by source (markdown file vs. terminal), and by date range. - **Pagination** — 50 notes per page with prev/next, so you don't hit performance walls. - **Grouping** by project and by file/terminal, with a count next to each group so you know where the activity is. - **Inline editing** — edit a note in place, copy its contents to the clipboard, or delete it permanently. All without leaving the panel. This turns sticky notes from a single-session annotation tool into a personal knowledge base. Pin a snippet today; find it three weeks from now by searching for two words you remember. ## Who Benefits Most Developer Profile Pain Point What v1.11.3 Fixes Developer building in public Wants to share Claude Code wins on Twitter without screen-recording software One-click MP4 export with square and portrait presets, smart 60-second compression Tech lead documenting agent workflows Screenshots and copy-paste lose the streaming experience Standalone HTML export with built-in chat replay, shareable to anyone Engineer writing PR descriptions Hard to capture the AI session that produced the change Markdown transcript that copies straight into the PR body Solo dev tracking long-running agents Forgets which TODOs to follow up on after a long session Sticky notes pinned to reader mode, scoped per terminal, searchable across projects Researcher comparing agents Needs side-by-side replays of Claude vs Codex on the same prompt Per-project library of last 24 recordings, replayable in chat-style viewer Content creator on TikTok / Shorts Long-form terminal recordings don't fit short-form video formats Portrait 9:16 export with smart compression to 60 seconds ## Before vs After: Sharing an AI Coding Session ### Before v1.11.3 1. Have a great Claude Code session. 2. Try to capture it. Open QuickTime. Position the window. Hit record. 3. Realize you started recording too late and missed the first prompt. 4. Rerun the session, hope for the same magic. 5. Get a 12-minute MOV file. No platform accepts it as-is. 6. Trim it in iMovie. Re-export. Cross fingers. 7. Eventually post a static screenshot instead. ### After v1.11.3 1. Click the record button before you start. (Or after — it captures the rest cleanly.) 2. Run your session normally. 3. Click stop. The chat replay opens automatically. 4. Click Export → MP4 → Portrait 9:16, 1080p, 2× speed. 5. Get a polished 60-second video with a branded end card. 6. Drag it into Twitter. Done. ## Full Changelog: v1.11.3 The headline features: - **Terminal Record** — one-click recording on every AI terminal (Claude Code, Codex, Gemini, Amp, custom wrappers) with a pulsing red REC pill, frame outline, and live timer. - **Chat-style replay viewer** — prompts as blue bubbles, AI responses as left-side bubbles with model name, word-by-word reveal, blinking streaming cursor, and 1×/2×/4× playback. - **Markdown / HTML / MP4 export** — share recordings as a clean transcript, a self-contained HTML file with built-in playback, or a rendered MP4 video. - **MP4 video export** with hardware-accelerated H.264, square (1:1) and portrait (9:16) presets, 720p/1080p, 60-second smart compression, and a branded end-credit screen. - **PRO watermark removal** — PRO users can disable the 1DevTool watermark on exported MP4s; free users see a PRO badge and upsell in the export dialog. - **Per-project recording library** — browse the last 24 recordings for each project in the session recordings dialog. - **Sticky Notes in Reader Mode** — pin reminders, TODOs, and snippets alongside terminal output; movable, resizable, color-coded, auto-saved. - **Notes History panel** — a new Notes tab in Prompt History showing every sticky note across all projects, searchable and copyable. And the supporting improvements and fixes: - Record button flips to active state instantly on click — no more waiting for a mouse move or keypress. - Stale terminal state cleanup — terminal panes refresh correctly after project switches and layout changes. - Fixed duplicate terminal instances appearing after switching projects or layouts. - Fixed record button getting stuck in idle state after the first click. - Fixed word spacing lost in Terminal Record playback when streaming agents wrapped lines with cursor positioning. ## Try It Today Terminal Record and Sticky Notes are available now in [1DevTool](https://1devtool.com) v1.11.3. Download the latest release, hit the record button on your next Claude Code or Codex CLI session, and have a shareable MP4 in less than a minute when you're done. Pin a sticky note to a long agent output and find it again next month from the Notes History panel. AI coding sessions are some of the most interesting things developers do all week, and up until now there was no good way to capture and share them. Terminal Record fills that gap without forcing you to learn a new tool — it's already in the terminal you're already using. **Record the magic. Replay the reasoning. Share the wins.** --- ## Terminal Notifier for AI Agents: Native Alerts + Activity Logs in 1DevTool Source: https://1devtool.com/blog/terminal-notifier-for-ai-agents Published: 2026-04-07 Tags: terminal-notifier, notifications, activity-logs, agentic-coding Classic terminal-notifier breaks the moment you run Claude Code, Codex CLI, or Gemini CLI — the agent process never exits. Here is how 1DevTool detects AI agent completions, fires native OS notifications, and keeps a cross-project activity log that actually understands what your agents are doing. If you have ever Googled **terminal notifier**, you were probably trying to solve one specific problem: a long-running command finished in a background terminal and you had no idea. Maybe you installed the classic `terminal-notifier` Homebrew package and piped `; terminal-notifier -message done` to the end of every command. Maybe you wired up `osascript` or `notify-send`. It works — until you start running Claude Code, Codex CLI, and Gemini CLI side by side. Then it falls apart. AI agents are not `make build`. They pause to think, ask for permission, write files, and resume. A simple "notify when the process exits" hook fires at all the wrong moments — or never fires at all, because the agent process is still alive, just idle. This post is about a different kind of terminal notifier — one built specifically for AI coding agents. We'll show you how 1DevTool's **Terminal Notifications**, **Activity Logs**, and native OS notifications work, why they don't fire on the wrong signals, and how the underlying detection actually distinguishes "the agent finished" from "the agent is thinking." ## Why a Classic Terminal Notifier Fails for AI Agents The original `terminal-notifier` on macOS, plus its Linux/Windows cousins, all share the same model: *you* append a notification command to the end of your shell line. `npm test && terminal-notifier -title "Done"`. The shell exits, the notifier fires, you get a desktop alert. Clean for builds and test runs. AI agents break this model in three ways: - **The agent process never exits.** Claude Code, Codex CLI, Gemini CLI, and Amp all run as long-lived REPLs. The shell hook never gets a chance to fire because the agent is sitting at its own prompt waiting for your next message. - **"Done" is ambiguous.** An agent might be done with a task, or paused to ask for permission, or stuck mid-tool-call waiting for a network response. A process-exit notifier has no way to tell these apart. - **You have more than one terminal.** Even if you wire up notifications per shell, you still need to know *which* terminal in *which* project finished — and you need to be able to click the notification to jump straight there. Plain `terminal-notifier` just shows you a toast. What you actually want is a notifier that watches the terminal output stream itself, knows what an AI agent looks like, and can fire a click-to-navigate alert that lands you in the exact pane that finished — across every project you have open. ## Terminal Notifications: Native Alerts, Built for Agents 1DevTool ships a built-in terminal notifier that fires native macOS, Windows, and Linux notifications the moment an AI agent finishes. There's nothing to install, nothing to pipe at the end of your commands, and nothing to configure per-shell. It works on every terminal in every project the moment you open the app. Two notification types fire automatically: - **Command Finished** — fires when a command in any terminal completes and ran longer than your threshold (default: 10 seconds). The body reads `"{terminal name}: Command completed after s"`. - **Agent Idle** — fires when an AI agent (Claude, Codex, Gemini, Amp) has produced no new output for a configurable window (default: 15 seconds), which is the most reliable signal that the agent has actually stopped working rather than just thinking mid-step. The body reads `"No new output after s of activity"`. Notifications only fire when the 1DevTool window is unfocused — if you're already looking at the terminal, you don't need a popup telling you what you can already see. Click any notification and 1DevTool jumps to the exact terminal in the exact project that produced it, even if that project isn't the one you currently have open.
{/* eslint-disable-next-line @next/next/no-img-element */} Native notification stack from 1DevTool's terminal notifier showing Command Finished and Claude Code finished alerts with elapsed times
The macOS Notification Center after a coding session — every terminal completion logged with project, agent, and elapsed time. Click any alert to jump directly to that terminal.
## Activity Logs: A Notifier That Remembers Native OS notifications are great when you're away from the app, but they disappear. Did Claude Code finish 4 minutes ago or 14 minutes ago? Did Codex generate a file you missed? That's where the second half of the terminal notifier comes in: the **Activity Logs** panel. Activity Logs is a persistent feed pinned to the 1DevTool status bar. Every time the notifier fires — for any terminal in any project — the event is also written to this feed. Two event types are tracked: - **terminal-finished** — an agent or command completed. The card shows the project name with a color-coded dot, the terminal name (e.g. `Claude Code generated` or `readme-landing`), the agent type, and the elapsed run time formatted as `2m 34s`. - **file-generated** — an AI agent created a file in a watched directory. The card shows the file name (e.g. `changelog.md`, `api-spec.md`), the source agent, and the project. Click it to open the file — Markdown opens in a reader view, code opens in the editor.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool Activity Logs panel pinned in the status bar showing Claude Code generated changelog.md, api-spec.md, notes.md across multiple projects
The Activity Logs popup anchored in the status bar — every completion and every generated file from every project, ordered newest first.
The feed holds a rolling buffer of the most recent events (capped to keep memory tidy), and events auto-dismiss after a configurable timeout (default: 5 minutes) so the panel never accumulates stale noise. You can clear individual events or clear all from the popup header. A small badge appears on the status-bar trigger when there are unread events; once you've seen them, the badge clears but the trigger stays so you can always re-open the history. ## How the Detection Actually Works The reason this terminal notifier doesn't false-positive on agents the way a generic one would is that it doesn't watch the process — it watches the PTY data stream itself, with two separate idle thresholds. When new bytes arrive on a terminal, 1DevTool starts (or refreshes) a per-terminal idle timer. If 500ms pass with no new output, the system checks whether a shell prompt has been seen since the command started. If yes, that's a **Command Finished** event. If the terminal belongs to an AI agent and a longer window of silence passes (the agent-idle threshold, default 15 seconds), the system fires an **Agent Idle** event instead. AI agents are detected by their CLI name — claude, codex, gemini, amp — so regular bash sessions never get Agent Idle alerts (only Command Finished ones). Both signals run through a deduplication step so you don't get a Command Finished notification followed two seconds later by an Agent Idle notification for the same run. If the same terminal fires twice within a 5-second window with similar elapsed times, the second event is collapsed. For **file-generated** events, the file watcher only attributes a new file to an AI agent if a terminal in that project running an AI agent was actively producing output within the last 60 seconds. This is the key trick: it filters out files you create manually, files git checkout drops on disk, and files from agents that finished long ago. Only files that an active agent likely produced make it to the feed. ## Settings: Tune Your Terminal Notifier in One Place Everything lives in **Settings > Behavior** and **Settings > Terminal**. The notification side controls native alerts: - **Notify on command finish** — toggle Command Finished notifications on/off, plus a slider for the minimum command duration (5-120s, default 10s) so quick commands like `ls` never spam you. - **Notify on agent idle** — toggle Agent Idle notifications on/off, plus the idle threshold (5-120s, default 15s). - **Play notification sound** — pair every alert with a system beep so you notice it even with notifications muted in Focus mode. The Activity Logs side controls the in-app feed: - **Activity log enabled** — master switch for the popup and badge. - **Watched file extensions** — which file types count for `file-generated` events. Defaults to `.md` (the most common AI-generated artifact); add `.sql`, `.json`, `.yaml`, `.ts`, or anything else you care about. - **Auto-dismiss timeout** — how long events stay in the feed before being marked read (0-900 seconds, default 300, set to 0 to never auto-dismiss). ## Side-by-Side: Classic terminal-notifier vs 1DevTool Capability Classic terminal-notifier 1DevTool Terminal Notifier Setup Install via Homebrew, append `; terminal-notifier` to every command Built in, zero config, works on every terminal Detects long-running AI agents No — agent process never exits Yes — Agent Idle fires after a silence window Distinguishes "done" from "thinking" No Yes — separate command-finish and agent-idle thresholds Click to jump to terminal No Yes — opens the exact terminal in the exact project Tracks generated files No Yes — Markdown by default, configurable extensions Persistent activity feed No (notifications disappear) Yes — status-bar popup with rolling history Cross-project view No Yes — every project, one feed Deduplication No Yes — collapses duplicate signals within 5s ## A Real Multi-Agent Session With the Notifier On Here's what a typical session looks like once Terminal Notifications and Activity Logs are running together. You open three projects in 1DevTool: - **marketing** — Claude Code working on a landing page rewrite - **1devtool-landing** — Claude Code generating a changelog and API spec - **theme** — bash running a long build You kick off all three, switch to your browser, and start reviewing a PR. Two minutes later, a native notification slides in: `Command Finished — marketing: Command completed after 48s`. Click it. 1DevTool focuses, switches to the marketing project, and lands you on the exact Claude Code pane that just finished. You review, approve, send the next prompt, and keep reading the PR. A minute later, another notification: `Claude Code finished — No new output after 28s of activity`. That's the agent-idle signal for 1devtool-landing — Claude is done. Open the Activity Logs popup from the status bar and you see the full history laid out: the marketing run, the landing run, the theme build that completed at 115 seconds, and a cluster of `file-generated` entries showing that Claude wrote `changelog.md`, `api-spec.md`, and `notes.md`. You click `changelog.md` in the feed. It opens in Markdown reader view. You scan it, ship it, and clear the feed. Total time spent "checking on agents": *zero*. ## Who Needs an AI-Aware Terminal Notifier - **Anyone running more than one AI agent in parallel.** The moment you have two agents going, you need notifications — otherwise you serialize your attention and throw away the whole point of parallelism. - **Freelancers and indie hackers juggling multiple projects.** The cross-project feed catches completions in projects that aren't even visible. - **Anyone tired of writing** `; terminal-notifier -message done` **at the end of every command.** The built-in detector handles it for every terminal automatically. - **Developers who keep missing** `changelog.md` **or** `NOTES.md` **files Claude drops in the repo.** File-generated events surface them immediately. ## Try the Built-In Terminal Notifier Terminal Notifications and Activity Logs are on by default in [1DevTool](https://1devtool.com). Download the app, open a project, run an AI agent, and tab away. You'll get the alert, the activity entry, and a one-click path back to the terminal that fired it. No Homebrew install, no shell hooks, no per-command boilerplate — just a terminal notifier that actually understands what your AI agents are doing. **One workspace. Every agent. Every notification, in one feed.** --- ## Pop-Out AI Terminals, Slash Command Autocomplete, and Memory Monitor for Claude Code Source: https://1devtool.com/blog/pop-out-terminals-slash-commands-memory-monitor Published: 2026-04-06 Tags: claude-code, codex, gemini-cli, terminal, productivity, agentic-coding Drag any AI agent terminal onto a second monitor with one click, browse every Claude Code, Codex, and Gemini slash command with fuzzy search, and watch system memory pressure from the status bar — three workflow upgrades for anyone running multiple AI agents in parallel. It's 4 PM. Claude Code has been refactoring your auth layer for forty minutes. You want to drag that terminal onto your second monitor so you can keep an eye on it while you work in the main window. You can't. Terminal panes in every **ai code editor** you've tried are locked inside the main window — you either alt-tab away or accept that the agent disappears the moment you focus on something else. Meanwhile, you're trying to remember whether the command to compact a Claude Code conversation is `/compact`, `/condense`, or something else entirely. And the laptop fans just spun up because four AI agents are streaming output simultaneously and you have no idea which one is actually pegging your RAM. Three small frictions that ruin a perfectly good agentic coding session. [1DevTool](https://1devtool.com) v1.11.2 fixes all three: **Pop-Out Terminals**, **Slash Command Autocomplete**, and a **Memory & Performance Monitor** that lives in the status bar. This release is a love letter to anyone running Claude Code, Codex CLI, Gemini CLI, or Amp on a single laptop and feeling the heat. ## Pop-Out Terminals: Drag Any AI Agent to a Second Monitor The pop-out feature is the smallest UI change with the biggest workflow impact. Every terminal in 1DevTool now has a tiny "Pop Out to New Window" button in its toolbar — a 12-pixel arrow icon sitting between the fullscreen and recording controls. Click it, and the terminal detaches into its own resizable window.
{/* eslint-disable-next-line @next/next/no-img-element */} A 1DevTool terminal popped out into its own resizable window with a custom titlebar
Pop any terminal — Claude Code, Codex, Gemini — into a standalone window with one click.
### How Pop-Out Actually Works (No Lost State) This is harder than it sounds, because terminals are stateful. Naive implementations of pop-out either lose all the scrollback, restart the underlying process, or worse — leave a ghost terminal behind in the original window. 1DevTool handles it cleanly: when you click the pop-out button, the renderer disposes the xterm view in the main window, the main Electron process spawns a new BrowserWindow with the terminal's ID in the URL, and the new window re-mounts the same terminal record from the Zustand store. The PTY process never restarts. Your scrollback is preserved. Claude Code keeps running. The popped-out window inherits your font size and zoom factor instantly. There's a compact titlebar at the top with three controls: `−`, the current font size, and `+`. Cmd++, Cmd+−, and Cmd+0 work exactly like they do in the main window — and because the terminal store is global, changing the font size in the popout updates every other terminal in the app at the same time. ### Anchor It Back When You're Done Done with the popped-out terminal? Click the **Anchor** button in the popout's titlebar. The window closes, the main process notifies the renderer, and the terminal re-mounts in its original slot in the main 1DevTool window — exactly where you left it. No configuration, no "Window" menu hunting, no manual reattach. The same terminal instance, the same scrollback, the same agent session. The killer use case is multi-monitor workflows. Pop your long-running Claude Code session onto a side monitor, leave it streaming in your peripheral vision, and use the main window for a Codex CLI session that's actively waiting on your input. You finally get the focus split that physical monitors were designed for — without losing the integration benefits of an all-in-one workspace. ## Slash Command Autocomplete for Claude Code, Codex, and Gemini Modern AI agents have a lot of slash commands. Claude Code alone ships with more than sixty of them — `/compact`, `/clear`, `/model`, `/login`, `/cost`, `/doctor`, `/init`, `/permissions`, the list goes on. Codex CLI has its own set. Gemini CLI has yet another. Nobody remembers all of them, so people fall back to the same five or six commands and never discover the powerful ones. Slash Command Autocomplete fixes that. Type `/` in the AI input overlay above any terminal, and a dropdown appears showing every command available for that specific agent type, grouped by category, with fuzzy search.
{/* eslint-disable-next-line @next/next/no-img-element */} The slash command autocomplete dropdown showing categorized Claude Code commands with descriptions
Type / in the AI input to see every slash command for the active agent — built-in or installed.
### Agent-Aware Command Lists The autocomplete is agent-aware. When you're typing into a Claude Code terminal, you see Claude commands grouped into categories like *conversation*, *model*, *config*, *tools*, *git*, and *debug*. Switch to a Codex CLI terminal, and the dropdown immediately shows Codex's ~15 commands instead. Open a Gemini CLI terminal, and you see the 30+ Gemini-specific commands. The detection is automatic — 1DevTool knows what agent each terminal is running, so the dropdown always matches the context. Each command appears as a monospace label (`/compact`) followed by a short description in muted text. As you type, fuzzy matching surfaces commands by name first, then by description. Press ↑/↓ to navigate, Enter or Tab to insert the selected command, and Esc to dismiss. The whole interaction takes under a second once you build the muscle memory. ### Installed Skills Show Up Too Beyond built-in commands, the autocomplete also surfaces your installed skills. If you've set up GStack skills or installed any custom skills via 1DevTool's Skills Manager, they appear in the same dropdown — tagged with a colored badge so you can tell at a glance whether you're inserting a built-in command or a custom skill. Built-in commands take precedence on name collisions, so your shipped agent commands never get shadowed by a custom skill that happens to share a name. This turns the autocomplete into something more interesting than a typing aid: it's a discovery layer. The next time you wonder "does Claude Code have a way to do X?", type `/` and search. If it exists, you'll see it. If your team has built a custom skill for it, you'll see that too. ## Memory & Performance Monitor: Watch Your Laptop Survive Multi-Agent Day Running multiple AI agents in parallel is the fastest way to discover the limits of your machine. Each Claude Code or Codex session can hold gigabytes of context. Each terminal holds a scrollback buffer. Each browser tab in the embedded browser eats more RAM. And the symptoms of memory pressure are subtle — micro-stutters, delayed keystrokes, fans suddenly spinning up — long before you actually crash. v1.11.2 adds a status-bar indicator that watches your system RAM in real time and surfaces a warning before things get bad. By default it stays hidden when memory pressure is *low*. When usage crosses 75%, a yellow indicator with a memory icon and percentage appears in the status bar. Above 90%, it turns red.
{/* eslint-disable-next-line @next/next/no-img-element */} System performance and memory monitor popover in the 1DevTool status bar showing RAM, app usage, and CPU load
The status-bar memory indicator turns yellow at 75% RAM and red at 90% — click for the breakdown.
### Three Numbers That Actually Matter Click the indicator and a compact panel slides up showing exactly the three numbers a developer running multiple agents needs: - **System RAM:** total used vs. total installed, e.g., `14.2 GB / 16 GB`, with a colored progress bar. - **1DevTool usage:** the resident set size of the 1DevTool process itself, so you can tell whether the pressure is coming from your editor or from something else running on the machine. - **CPU load:** the one-minute load average normalized against your core count — instantly tells you whether you're CPU-bound, memory-bound, or both. The metrics refresh every thirty seconds in the background, but the popup re-fetches the moment you open it so you always see fresh numbers when you're looking. ### One-Click "Clear Terminal Buffers" The popup includes a single action button: **Clear Terminal Buffers**. Click it, and 1DevTool walks every active PTY in the app, drops its in-memory output buffer, and reports back how many buffers it cleared. Your live agent sessions keep running — only the scrollback history gets pruned. For a developer who's been running ten Claude Code sessions for six hours, this can recover hundreds of megabytes in a single click. It pairs nicely with another v1.11.2 improvement: terminal output buffers are now capped at 2 MB by default (down from 5 MB), and they expire automatically when a terminal is detached. The combination means your typical multi-agent workspace runs noticeably lighter without you doing anything. ## MCP Feature Toggles: Channels, Design, and Prototype on Demand 1DevTool ships three first-party MCP servers: **Channels** (multi-agent orchestration), **Design** (the AI design canvas), and **Prototype** (the prototype tool). Up until v1.11.2, they were either always enabled or always disabled based on your config. v1.11.2 turns each one into a feature card in MCP settings with a toggle switch and a one-click reinstall button. Each card shows a status dot (green when installed, gray when not), the feature name, the MCP config key it registers, and a short description. Toggle the switch and 1DevTool writes the appropriate entry to your `~/.claude.json` file. If something goes wrong — Node missing, permissions issue, broken install — the card surfaces diagnostics with a "Copy debug logs" button so you can share the exact platform, paths, and file accessibility info instead of guessing. The reinstall button is the secret weapon. If a feature shows up as "failed" or "disconnected" in your agent, one click rewrites its config entry from scratch. You don't have to leave the app, edit JSON by hand, or restart anything — just click and the next agent session picks up the fresh config. ## Quality-of-Life Changes Worth Knowing About v1.11.2 also includes a stack of smaller improvements that compound across a long workday: - **Skip Version button** on the auto-update dialog — dismiss an update permanently if you're not ready for it. - **Cmd+W closes the focused panel** — editor file, browser tab, or terminal — based on which panel has focus, rather than always closing the same thing. - **Esc closes the Git panel** — small thing, but the kind of keyboard shortcut you reach for thirty times a day. - **Smarter reader mode formatting** — bold text, indentation, and trailing status-bar lines from streaming agents are cleaned up more reliably when rendering terminal output as markdown. - **Mermaid diagram validation** — invalid syntax is caught before rendering, so you no longer get broken SVGs from AI-generated diagrams. - **Faster terminal rendering** — buffer trimming is deferred off the main thread, so heavy output streams no longer cause UI micro-stutters. - **Dark-mode caret fix** — the cursor in the AI input field is now actually visible in dark themes. - **Auto-update dialog** now actually checks for updates the moment you open it, instead of waiting for a manual click. ## Who Benefits Most Developer Profile Pain Point What v1.11.2 Fixes Multi-monitor power user Can't move a single terminal to the side display Pop-Out Terminals — drag any agent to any monitor Claude Code newcomer Doesn't know what slash commands exist Slash Command Autocomplete — discoverable and searchable Developer on a 16 GB laptop Random fan spin-up and stutters during multi-agent days Memory monitor + 2 MB buffer cap + clear-buffers action MCP power user Channels or Design MCP keeps disconnecting One-click reinstall from feature cards Keyboard-driven dev Scattered [keyboard shortcuts](https://servercompass.app/features/keyboard-shortcuts) Context-aware Cmd+W + Git panel Esc ## Before vs After: A Multi-Agent Workflow Pull the three headline features together and a typical day looks meaningfully different. ### Before v1.11.2 1. Open Claude Code, Codex, and Gemini in three terminals. 2. Want to glance at Claude on your second monitor — you can't. Alt-tab instead. 3. Try to remember which Claude command compacts the conversation. Google it. 4. Notice the fans spinning up. No idea why. Quit a random app. 5. Keep working until something stutters. Restart the editor to recover memory. ### After v1.11.2 1. Open the same three terminals. 2. Pop Claude onto your second monitor with one click. Anchor it back when you're done. 3. Type `/comp` — fuzzy search surfaces `/compact` instantly. 4. The status bar shows yellow at 78% RAM. Click it, see the breakdown. 5. Click "Clear Terminal Buffers" — back to 62%, no restart needed. ## Full Changelog: v1.11.2 The headline features: - **Pop-Out Terminals** — pop any terminal into its own resizable window with one click, inheriting font size and zoom, and anchor it back at any time. - **Slash Command Autocomplete** — type `/` in the AI input to browse every built-in command for your agent (Claude, Codex, Gemini, etc.) plus your installed skills, grouped by category with fuzzy search. - **Memory & Performance Monitor** — a status-bar indicator turns yellow or red under memory pressure; click for a breakdown of system RAM, 1DevTool usage, CPU load, and a one-click "Clear terminal buffers" action. - **MCP Feature Toggles** — enable or disable Channels, Design, and Prototype as feature cards in MCP settings, with one-click reinstall if something goes wrong. And the supporting improvements and fixes: - Skip Version button on the update dialog. - Cmd+W closes the focused panel — editor file, browser tab, or terminal. - Esc closes the Git panel. - Smarter reader mode formatting for bold text, indentation, and trailing status-bar lines. - Mermaid diagrams validate before rendering. - Lower memory footprint — 2 MB terminal output buffers (down from 5 MB) that auto-expire when detached. - Faster terminal rendering — buffer trimming deferred off the main thread. - Dark-mode caret fix in the AI input field. - Auto-update dialog checks for updates automatically when opened. - Reader mode no longer loses formatting at the bottom of Claude conversations. ## Try It Today Pop-Out Terminals, Slash Command Autocomplete, and the Memory Monitor are available now in [1DevTool](https://1devtool.com) v1.11.2. If you're running multiple AI agents on a single machine — especially Claude Code, Codex CLI, or Gemini CLI in parallel — download the latest release and feel the difference within the first hour. These three features are the kind of small workflow improvements that don't look like much in a changelog and then quietly become indispensable. Pop a terminal to your second monitor once and you'll never go back. Type `/` and discover commands you didn't know existed. Watch your laptop survive a six-agent afternoon. **One workspace. Every agent. Every key shortcut and every megabyte where you expect them.** --- ## Warp Terminal vs 1DevTool: Which AI Terminal Is Better in 2026? Source: https://1devtool.com/blog/warp-terminal-vs-1devtool-ai-terminal-comparison Published: 2026-04-06 Tags: warp, comparison, ai-terminal, productivity Warp is polished for command-line productivity, but AI-first coding introduces new requirements like session continuity, multi-agent orchestration, and readable long-form outputs. This comparison breaks down where each terminal wins. Developers searching for a **Warp alternative** are usually trying to optimize one of two things: command-line speed or AI workflow control. Warp is strong at terminal UX, but AI-first coding introduces requirements that traditional terminal comparisons miss. If your workflow now includes multiple coding agents, long-form AI output, and restart-safe operations, the right terminal should be evaluated as an orchestration system, not only a shell UI. ## What Changed in AI Terminal Workflows - Terminal outputs are now multi-paragraph plans, diffs, and markdown-heavy responses. - You often run several agent sessions in parallel instead of one shell task. - Losing session state after restart can wipe hours of useful context. ## Warp vs 1DevTool Comparison Table Capability Warp 1DevTool Fast terminal UX Strong Strong AI output readability mode Limited Built-in [Reader Mode](/features/terminal-reader-mode) Multi-agent status visibility Manual tab scanning [Dashboard view](/features/terminal-dashboard) Session continuity across restarts Depends on setup Native persistence + resume ![Terminal reader mode displaying formatted AI coding output](/app-screenshots/terminal-reader-mode.jpg) ## Where Warp Wins Warp remains a strong choice for command-line-centric developers who prioritize polished shell interactions, command blocks, and lightweight productivity improvements around terminal usage. ## Where 1DevTool Wins for AI-First Teams If your bottleneck is coordinating multiple AI agents and reviewing long AI outputs quickly, 1DevTool usually wins on throughput. Features like [Session Persistence](/features/session-persistence), [Activity Logs](/features/activity-logs), and [Multi-Agent Terminals](/features/multi-agent-terminals) are built for that exact workflow. ![Terminal dashboard showing multi-agent status across a project](/app-screenshots/terminal-dashboard.jpg) ## Decision Rule Choose Warp if your primary job is shell interaction. Choose 1DevTool if your primary job is AI orchestration and delivery across multiple active agent sessions. --- ## Claude Code vs Codex CLI: Which Agent Fits Your Workflow in 2026? Source: https://1devtool.com/blog/claude-code-vs-codex-cli-which-agent-fits-workflow Published: 2026-04-05 Tags: claude-code, codex, comparison, agentic-coding Claude Code and Codex CLI are both strong coding agents, but they excel in different operating models. Learn how to choose based on task type, review style, and team orchestration patterns. The **Claude Code vs Codex** question is not about which model is globally “better”. It is about workflow fit. Different agents perform differently depending on task shape, prompting style, and how your team reviews output. ## Quick Comparison Dimension Claude Code Codex CLI Planning and explanation depth Strong Good Execution speed on focused edits Good Strong Prompt-style sensitivity Moderate Moderate Best use pattern Planner/reviewer lane Builder/verify lane ## Recommended Team Pattern Run both agents in parallel lanes and assign roles intentionally. A common pattern is: - **Claude lane:** planning, architecture notes, and risk analysis. - **Codex lane:** implementation passes and focused refactors. - **Reviewer lane:** diff checks and test verification. ![Claude Code and Codex CLI running in separate agent terminals](/app-screenshots/multi-agent-terminals.jpg) ## How to Avoid Agent Conflicts - Never let both agents edit the same file range simultaneously. - Use explicit ownership in prompts (who edits, who reviews, who tests). - Track completions with [Activity Logs](/features/activity-logs) to stop polling loops. ![Activity logs view for monitoring AI terminal completion events](/app-screenshots/activity_logs.jpg) ## Final Recommendation For most teams, the winning strategy is not either-or. Run Claude Code and Codex CLI together in a structured multi-agent workflow, then choose default ownership by task type. --- ## How to Run Multiple AI Agents in One Workspace (Without Chaos) Source: https://1devtool.com/blog/how-to-run-multiple-ai-agents-in-one-workspace Published: 2026-04-05 Tags: multi-agent, workflow, agentic-coding, productivity Most multi-agent setups fail because context gets lost between terminals. Here's a repeatable workflow to run Claude Code, Codex CLI, and Gemini in parallel with channel coordination, dashboard visibility, and persistent sessions. Running one AI agent is easy. Running four AI agents across two projects without losing context is where most teams fail. The problem usually is not model quality. The problem is coordination. If you are targeting **multi agent coding** workflows, you need an operating system for handoffs: who is implementing, who is reviewing, who is testing, and where each output goes. This guide gives you a simple system you can run daily. ## Why Multi-Agent Coding Breaks - **Role overlap:** two agents edit the same files and create merge noise. - **Context loss:** evidence from logs, screenshots, and diffs lives in different windows. - **Polling loops:** you manually check terminals to see which agent finished. - **No continuity:** after restart, session history is gone and work restarts from zero. ![Multiple AI agent terminals running side by side in one workspace](/app-screenshots/multi-agent-terminals.jpg) ## A Practical 4-Step Workflow ### Step 1: Assign Agent Roles Before Prompting Name each terminal by responsibility, not model name. For example: *planner*, *implementer*, *reviewer*, and *tester*. This prevents duplicated work and gives each prompt a clear owner. A useful pattern is one planning agent and multiple execution agents. Keep planning output short, then forward only relevant chunks to implementation terminals. ### Step 2: Track Status in One Place Keep a live board of terminal states so you do not alt-tab through each session. In 1DevTool, the [Terminal Dashboard](/features/terminal-dashboard) gives a Kanban view of Idle, Running, and Review states across projects. ![Terminal dashboard showing idle, running, and review states for AI agents](/app-screenshots/terminal-dashboard.jpg) ### Step 3: Use Structured Handoffs Avoid copy-paste relays. Use a shared channel model so agents can coordinate directly. The [Channel Chat](/features/channel-chat) feature lets you @mention specific terminals, while [Send File to Terminal](/features/send-file-to-terminal) moves files, logs, and screenshots with context attached. ![Channel chat interface coordinating multiple AI agents](/app-screenshots/channel-chat.jpg) ### Step 4: Preserve Context Across Restarts A reliable **agentic coding workflow** must survive laptop restarts and interruptions. Pair [Session Persistence](/features/session-persistence) with [Session Continuity](/features/session-continuity) so each terminal resumes exactly where it stopped. ## Prompt Template for Operators Use this when delegating work from an operator terminal: `Goal: Context: Constraints: Owner: Done when: Handoff to: ` ## Final Checklist - Every terminal has one role and one owner. - All handoffs include files and evidence, not just plain text summaries. - Status is visible in one dashboard, not hidden in tabs. - Sessions are resumable so interrupted work is not lost. If your current setup cannot satisfy all four, you do not have a scalable multi-agent system yet. You have a set of terminals. Start with one workspace that supports orchestration end-to-end, then add agent count. Want to apply this workflow directly? Download [1DevTool](/download) and run your first four-agent setup in one project workspace. --- ## Best Postman Alternative for Developers in 2026 Source: https://1devtool.com/blog/best-postman-alternative-for-developers-2026 Published: 2026-04-04 Tags: postman-alternative, http-client, api-testing, comparison If your API workflow lives in one app and your debugging context lives in another, you are paying a context-switch tax. Compare Postman alternatives and see how a workspace-native HTTP client changes API development speed. Searching for the **best Postman alternative** usually means one thing: your API testing workflow is split across too many tools. Requests are in one app, logs are in another, and code changes are in your editor. The core issue is not request syntax. It is context switching. Every switch from request builder to terminal to editor adds delay and drops debugging context. ## What Developers Actually Need From an API Client - Fast request construction with reusable headers, auth, and environments. - Response visibility that highlights status, headers, payload, and timings. - Direct links to source files, logs, and local services while debugging. - A workflow that stays in the same workspace as coding and testing. ![HTTP request builder with method, URL, headers, and body inputs](/app-screenshots/http-request-builder.jpg) ## Postman vs Workspace-Native HTTP Client Capability Standalone API app Workspace-native API client Request building speed Good Good Jump to code and terminal context Manual Direct and immediate Share debugging artifacts with AI agents Copy-paste workflow Built-in context transfer End-to-end flow (build, test, fix, retest) Multi-app Single workspace ## Three Features That Matter Most ### 1\. Request Builder A strong [Request Builder](/features/http-request-builder) should support fast method switching, environment values, and structured body editing without hiding raw control. ### 2\. Response Inspection The [Response Inspector](/features/response-inspector) should make failures obvious: status code patterns, response timings, JSON formatting, and error payload readability. ![Response inspector showing status code, headers, and JSON payload](/app-screenshots/response-inspector.jpg) ### 3\. Request Workspace Organization When APIs scale, structure matters. A dedicated [Request Workspace](/features/request-workspace) lets teams group endpoints by service and keep local debug requests separate from production-safe collections. ![Organized request workspace with grouped API requests](/app-screenshots/request-workspace.jpg) ## Decision Framework Choose a Postman alternative based on your bottleneck: - If request authoring is slow, optimize builder UX and environments. - If bug triage is slow, prioritize response diagnostics and log adjacency. - If iteration is slow, prioritize one-workspace integration with code and terminals. For teams running AI-assisted development, the third point usually wins. The fastest API client is the one that stays next to your editor, terminal, and agents. You can test this workflow in practice with [1DevTool](/download), which combines API testing, coding, and terminal orchestration in one desktop workspace. --- ## Persistent Terminal Sessions for Coding: Complete Guide (2026) Source: https://1devtool.com/blog/persistent-terminal-sessions-for-coding-guide-2026 Published: 2026-04-04 Tags: terminal, session-persistence, guide, productivity Persistent sessions are no longer optional when AI agents run long workflows. This guide shows how to structure resilient terminal operations with restart-safe history and fast re-entry. Reliable **persistent terminal sessions** are now a core requirement for AI coding. Agent workflows often run longer than a single workstation session, so continuity must survive restarts, sleep cycles, and handoffs between team members. ## Why Persistence Matters - AI conversations contain critical context not captured in commit messages. - Long-running tasks should resume instead of restarting from scratch. - Reviewers need scrollback history to validate decisions. ![Session persistence showing restored terminal tabs and history](/app-screenshots/session-persistence.jpg) ## Setup Pattern 1. Create role-based terminals (\`planner\`, \`builder\`, \`reviewer\`, \`tests\`). 2. Enable [Session Persistence](/features/session-persistence) for all critical lanes. 3. Use [Session Continuity](/features/session-continuity) for restart-safe re-entry. 4. Recover from interruption using [Resume UI](/features/resume-ui). ![Session continuity flow restoring prior AI sessions](/app-screenshots/session-continuity.jpg) ## Operational Best Practices - Keep one branch focus per persistent lane. - Store checkpoint notes at major handoff points. - Use activity events to identify stale sessions quickly. ![Resume interface for selecting and reopening previous terminal sessions](/app-screenshots/resume-ui.jpg) ## Final Takeaway Session persistence is a compounding productivity feature. Each day of saved context reduces repeat prompts, lowers errors, and shortens the path from issue to merged fix. --- ## AI Code Review Workflow: Diff Viewer, Agent Handoffs, and Faster Merges Source: https://1devtool.com/blog/ai-code-review-workflow-with-diff-viewer-and-agents Published: 2026-04-03 Tags: code-review, diffs, workflow, ai-coding-assistant AI-generated changes are only as good as your review process. Build a repeatable AI code review workflow using structured diff inspection, reviewer agents, and traceable handoffs. A strong **AI code review workflow** starts with one rule: always review diffs before trusting generated code. AI agents can move quickly, but speed without verification increases regression risk. ## Review Loop Architecture 1. Implementation agent proposes a change set. 2. Reviewer agent checks logic, tests, and edge cases. 3. Operator approves or requests revision. Keep these lanes separate to avoid self-approval bias. Use one reviewer terminal that never edits files directly. ![Diff viewer highlighting AI-generated code changes](/app-screenshots/diff-viewer.jpg) ## Tools That Improve Review Quality - [Diff Viewer](/features/diff-viewer) for line-level validation. - [Git Visual Changes](/features/git-visual-changes) for branch-level awareness. - [Send File to Terminal](/features/send-file-to-terminal) for context-rich handoffs. ![Git visual changes panel showing modified files and change status](/app-screenshots/git-visual-changes.jpg) ## Review Checklist - Does the diff satisfy the original acceptance criteria? - Are tests updated or added where behavior changed? - Did the change introduce hidden coupling or side effects? - Can you roll back safely if production behavior regresses? ## Visibility Matters In multi-agent setups, quality drops when operators poll tabs manually. Use [Activity Logs](/features/activity-logs) so review-ready events appear immediately. ![Activity log feed showing completed AI tasks ready for review](/app-screenshots/activity_logs.jpg) ## Final Rule Treat AI-generated code exactly like human-generated code: no merge without review. Structured diffs, reviewer lanes, and explicit handoffs are the fastest route to safe velocity. --- ## VS Code vs 1DevTool: When You Need More Than an Editor Source: https://1devtool.com/blog/vscode-vs-1devtool-when-you-need-more-than-editor Published: 2026-04-03 Tags: vs-code, comparison, workspace, ai-ide VS Code is excellent for text editing, extensions, and debugging. But if your workflow now includes multiple AI agents, databases, API clients, and terminals, you may need a workspace-level tool instead of another extension. The **VS Code alternative** conversation is often framed as extension count versus UI polish. That misses the real shift in 2026: many developers now run multiple AI agents, not just autocomplete. VS Code remains excellent for editing and debugging. But if your daily loop includes AI terminal orchestration, API testing, database queries, and cross-project monitoring, you may outgrow an editor-first model. ## Where VS Code Is Still Excellent - Fast editing and refactoring for local file workflows. - Massive extension ecosystem and language coverage. - Mature debugging, source control, and remote development support. ## Where Editor-First Workflows Break - Running several AI agents across projects creates terminal tab sprawl. - Request testing and database checks live in separate tools. - Operational context is fragmented across windows and desktops. ![Multi-project workspace view with status indicators and active terminals](/app-screenshots/multi-project-workspace.jpg) ## VS Code vs 1DevTool: Practical Comparison Workflow Need VS Code 1DevTool File editing Excellent Good + integrated context tools Multi-agent terminal management Possible with setup Native workspace model API and DB workflows next to code Extension-dependent Built in Cross-project operational visibility Limited First-class ## When to Stay With VS Code Stay with VS Code if your work is primarily single-project editing and you are happy composing your own toolchain. It is a strong default and remains one of the best coding editors. ## When to Switch to a Workspace Model Switch when your bottleneck is orchestration rather than typing speed. If you spend more time coordinating AI outputs, logs, API checks, and terminal states than writing raw code, a workspace model gives immediate ROI. In that model, features like [Multi-Agent Terminals](/features/multi-agent-terminals), [HTTP Request Builder](/features/http-request-builder), [Query Editor](/features/query-editor), and [flexible layouts](/features/terminal-grid-layouts) are not nice-to-haves. They are the core product. ![Terminal grid layout with multiple development and AI sessions](/app-screenshots/terminal-grid-layout.jpg) ## Bottom Line This is not an anti-VS Code argument. It is a workflow-fit argument. Choose an editor when editing is the center. Choose a **developer workspace** when orchestration is the center. If your team is entering AI-first delivery, test both side by side for one sprint and compare cycle time, bug turnaround, and context-switch count. --- ## Best AI Coding Assistant for Teams in 2026: What Actually Matters Source: https://1devtool.com/blog/best-ai-coding-assistant-for-teams-2026 Published: 2026-04-02 Tags: ai-coding-assistant, teams, comparison, multi-agent For teams, the best AI coding assistant is not just the smartest model. It is the system that supports collaboration, visibility, approvals, and reliable delivery across multiple agents. The **best AI coding assistant** for teams is not the one with the most impressive demo. It is the one that improves coordination, review quality, and predictable delivery under real constraints. ## Team Evaluation Framework - **Coordination:** can multiple agents collaborate without operator overload? - **Visibility:** can leads see what finished and what is blocked? - **Governance:** are approvals and handoffs explicit? - **Recovery:** can sessions resume after interruptions? ![Channel chat showing coordinated multi-agent workflow for a team](/app-screenshots/channel-chat.jpg) ## Must-Have Team Capabilities For production teams, prioritize [Channel Chat](/features/channel-chat), [Channel Templates](/features/channel-templates), and [Activity Logs](/features/activity-logs). These reduce coordination latency more than incremental improvements in single-agent completion speed. ![Channel templates for repeatable team workflows with predefined agent roles](/app-screenshots/channel_templates.jpg) ## Common Team Failure Modes - No role separation between planning, implementation, and review. - No event stream for completion notifications. - Prompts not standardized, causing inconsistent output quality. ![Cross-project activity logs for tracking agent progress and completion](/app-screenshots/activity_logs.jpg) ## Final Guidance For teams, choose an assistant platform that behaves like a coordinated workspace, not just a chat box. Collaboration mechanics decide whether AI accelerates delivery or introduces operational noise. --- ## Chat Interface: Discord-Style AI Terminals in Your Code Editor Source: https://1devtool.com/blog/chat-interface-discord-style-ai-terminals Published: 2026-04-02 Tags: chat-interface, workspace, productivity, agentic-coding Managing multiple AI agents across anonymous terminal tabs is broken. 1DevTool v1.11.1 introduces a Discord-style Chat Interface that turns your AI terminals into named channels in a sidebar — grouped by type, with drag-and-drop reordering, project avatars, and one-click workspace presets. You have Claude Code refactoring your API layer. Codex is rewriting your React components. Gemini CLI is generating test suites. Each one lives in its own terminal tab, and you're Alt-Tabbing between them trying to remember which tab is which. The tab titles all say "bash" or "zsh" because terminals don't know what's running inside them. This is the default experience for every developer running multiple AI agents in 2026. And it's broken. Not because the agents are bad — they're incredible — but because the interface around them was never designed for **managing a fleet of AI coding agents**. With [1DevTool](https://1devtool.com) v1.11.1, we're introducing the **Chat Interface** — a Discord-style layout that turns your AI terminals into named channels in a sidebar, grouped by type, with drag-and-drop reordering and one-click workspace presets. This is what an **AI code editor** should look like when you're chatting with AI agents all day. ## Why Your AI Workspace Needs a Chat Interface Think about how you use Discord or Slack. You don't have a row of identical tabs across the top of the screen. You have a sidebar with named channels, organized by category, and you can see at a glance which ones have activity. You click a channel name and the conversation appears in the main content area. Now think about how you manage AI terminals. You have a row of identical tabs, often labeled "Terminal 1," "Terminal 2," "Terminal 3." Maybe you renamed some of them — but the tabs are tiny, and when you have more than four or five, they start truncating. You can't tell at a glance which terminal is running Claude Code, which is running Codex, and which is just a plain bash shell you use for git commands. The problem gets worse the more productive you become. The more AI agents you run in parallel, the more terminals you accumulate, and the harder it gets to navigate between them. A **code editor with AI chat** needs a better navigation model — one designed for conversations, not processes. ## How the Chat Interface Works The Chat Interface is a new layout mode in 1DevTool that replaces the traditional tab bar with a 220px fixed sidebar. Every terminal appears as a named item in this sidebar, grouped into two sections: **AI Agents** and **Terminals** (shells). Click any item and the conversation fills the main content area — exactly like clicking a channel in Discord.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool Chat Interface showing Discord-style sidebar with AI agent channels and terminal conversations
The Chat Interface layout — AI agents and shells grouped in a sidebar, with the active conversation in the main panel.
### Automatic Grouping by Agent Type 1DevTool automatically detects the type of each terminal and groups them accordingly. When you open a Claude Code session, a Codex CLI instance, a Gemini CLI session, or an Amp terminal, it appears under the **AI Agents** section. Plain bash, zsh, fish, and other non-agent shells appear under **Terminals**. This grouping is automatic — you don't configure anything. 1DevTool uses an internal `isInteractiveAgentType()` check to classify each terminal, so your agents are always visually separated from your utility shells. No more scanning through a row of identical tabs to find the right Claude Code instance. Each terminal entry in the sidebar shows three things: an **agent icon** (different for Claude, Codex, Gemini, Amp, and generic shells), the **terminal name** you assigned, and a **status dot** indicating whether the session is active, idle, or finished. At a glance, you see your entire AI workforce and its status. ### Drag-and-Drop Reordering Your workflow has a natural order. Maybe you always want the backend agent on top, followed by the frontend agent, then the test writer. The Chat Interface supports full drag-and-drop reordering within each section. Grab a terminal entry, drag it up or down, and drop it where you want. A blue highlight indicator shows exactly where the item will land. The ordering persists across sessions. When you close and reopen 1DevTool, your carefully arranged sidebar stays exactly how you left it. This sounds small, but when you're switching between 5-8 AI agent conversations throughout the day, having them in a consistent, predictable order eliminates a surprising amount of cognitive friction. ### Project Avatars and Identity The Chat Interface introduces a new feature that makes multi-project workflows significantly easier: **project avatars**. You can assign a custom image — PNG, JPG, or SVG — to any project. The avatar appears in the sidebar header alongside the project name and an optional emoji badge.
{/* eslint-disable-next-line @next/next/no-img-element */} Adding custom emoji and avatar to a project in 1DevTool for quick visual identification
Assign a custom avatar and emoji badge to any project for instant visual recognition.
This matters because when you're juggling 3-5 projects, visual identity is faster than reading text. A blue logo for your SaaS backend, a green icon for the mobile app, a red badge for the client project — your brain recognizes these patterns instantly, before you even read the project name. Avatars are stored directly on the project object as a data URL, so they work offline and don't depend on any external service. If you don't set an avatar, 1DevTool falls back to a colored circle with the project's initial — still visually distinct, just less personalized. ### Compact Sidebar Mode When the project sidebar is narrowed below 80px, 1DevTool automatically switches to **compact mode** — a Discord-style icon column showing 40x40 rounded tiles. Each tile displays the project avatar or the project's initial letter, and the currently active project gets a pill-shaped indicator. This is designed for developers who work on many projects simultaneously and want maximum screen space for the chat conversation. The compact sidebar takes up just 60px — enough to see all your projects at a glance while giving the terminal conversation 95% of the horizontal space. ### One-Click Workspace Preset Don't want to configure the layout manually? 1DevTool v1.11.1 ships with a dedicated **Chat Interface workspace preset** that arranges everything for you in one click: - **Left panel:** Compact project sidebar (60px) — Discord-style icon tiles for switching between projects - **Center panel:** Chat Interface layout — your AI terminals as channels in a sidebar with the active conversation in the main area - **Right panel:** Browser, database, or HTTP client (400px) — for previewing your app, querying data, or testing APIs alongside your agents
{/* eslint-disable-next-line @next/next/no-img-element */} Applying the Chat Interface workspace preset across all projects in 1DevTool
Apply the Chat Interface workspace preset to all projects at once from the layout menu.
The preset can be applied to a single project or to all projects at once. If you decide the chat layout is how you want to work, one click and every project adopts it. ### Session Previews and Resume One of the smaller but impactful improvements in v1.11.1 is better session management within the Chat Interface. When you hover over a terminal in the sidebar, you see a preview of the conversation — the last few messages exchanged with the AI agent. This lets you recall context without switching away from your current conversation.
{/* eslint-disable-next-line @next/next/no-img-element */} Previewing and resuming previous chat sessions in the 1DevTool Chat Interface sidebar
Preview recent conversations and resume any session directly from the sidebar.
Previous sessions can be resumed directly from the sidebar. Closed a Claude Code conversation yesterday but want to continue where you left off? The session history is right there — click to resume. This release also fixes a bug where empty session previews would appear for terminals that had no conversation history. ## Before vs After: Managing Multiple AI Agents The Chat Interface isn't just a visual refresh. It fundamentally changes how you navigate a multi-agent **AI coding workspace**. ### Before: Traditional Terminal Tabs 1. Open 5 terminal tabs. They all look identical. 2. Rename each tab manually. Forget which is which anyway. 3. Click through tabs one by one to find the Claude Code instance you need. 4. Lose track of which tabs are AI agents and which are regular shells. 5. Can't see status without switching to each tab. 6. Reordering requires closing and reopening tabs in the right order. 7. Switching projects means losing all context about the current layout. ### After: Chat Interface Layout 1. AI agents are grouped under "AI Agents" with individual icons and status dots. 2. Regular shells are grouped under "Terminals" — visually separated. 3. Click any channel name to open the conversation. No guessing. 4. Drag and drop to arrange your preferred order. It persists. 5. Status dots show active/idle/finished at a glance — no tab switching. 6. Project avatar in the header tells you which project you're in instantly. 7. Workspace preset applies the same layout across all projects in one click. ## Who Benefits Most Developer Profile Without Chat Interface With Chat Interface Solo dev running 3+ AI agents Tabs blur together, constant context switching Named channels with type grouping and status indicators Freelancer with multiple client projects No visual distinction between projects or agent types Project avatars + compact sidebar for instant recognition Team using Claude, Codex, and Gemini together Can't tell which agent is which without clicking each tab Agent icons and automatic grouping separate them visually Power user with 8+ terminals open Tab bar overflows, titles truncate, navigation is guesswork Scrollable sidebar shows every terminal with full names Developer who values workspace consistency Rebuilds layout every time the editor restarts Workspace preset restores the exact layout on every launch ## Full Changelog: v1.11.1 The Chat Interface is the headline feature, but v1.11.1 includes several supporting improvements: - **Chat Interface layout:** Discord-style view with terminals as channels in a sidebar, grouped by type, with drag-and-drop reordering - **Chat Interface workspace preset:** One-click layout with compact project sidebar, chat terminal layout, and browser panel on the right - **Project avatars:** Custom PNG, JPG, or SVG images for any project, with colored-circle fallback - **Compact sidebar mode:** Discord-style icon tiles when the sidebar narrows below 80px, showing avatar or project initial with active pill indicator - **Bug fix:** Resume panel now correctly restores previous sessions - **Bug fix:** Empty session previews no longer appear for terminals with no conversation history ## Try It Today The Chat Interface is available now in [1DevTool](https://1devtool.com) v1.11.1. Download the app, open a project, and switch to the Chat Interface layout from the layout menu — or apply the workspace preset to get the full Discord-style experience in one click. If you're running Claude Code, Codex CLI, Gemini CLI, or any other **AI terminal** agent, the Chat Interface is the navigation layer those tools have been missing. Stop managing AI agents through a row of anonymous tabs. Give them names, icons, groups, and a proper sidebar — the way every modern chat application already works. **One workspace. Every agent. Every conversation — right where you expect it.** --- ## Claude Code Terminal Setup Guide: Persistent Sessions, Named Tabs, Multi-Project Source: https://1devtool.com/blog/claude-code-terminal-setup-guide-persistent-sessions Published: 2026-04-02 Tags: claude-code, terminal, setup, session-persistence A complete Claude Code terminal setup guide for 2026. Learn the exact workspace pattern for named sessions, persistent history, and project-safe multi-agent orchestration. A good **Claude Code terminal** setup should optimize for continuity, not novelty. The command is easy. The hard part is keeping multiple sessions organized over days of real work. This guide uses a practical pattern: named tabs, per-project boundaries, persistent history, and quick resume after restarts. ## Step 1: Install and Verify Claude Code `npm install -g @anthropic-ai/claude-code claude --version` Once installed, run a smoke prompt in a throwaway repo to validate auth and basic command execution. ## Step 2: Create Role-Based Terminals Do not keep one generic Claude terminal. Create at least three named sessions: - **claude-planner** for planning and task decomposition. - **claude-builder** for implementation passes. - **claude-reviewer** for diff and test validation. In 1DevTool, this maps naturally to [Multi-Agent Terminals](/features/multi-agent-terminals) with color-coded identity for faster scanning. ![Color-coded project and terminal organization for AI agent sessions](/app-screenshots/color-coded-projects.jpg) ## Step 3: Enable Persistence and Continuity Your setup is not production-ready until sessions survive restarts. Enable [Session Persistence](/features/session-persistence) and [Session Continuity](/features/session-continuity) so scrollback and conversation context are still there tomorrow. ![Session persistence view showing terminal history retained after restart](/app-screenshots/session-persistence.jpg) ## Step 4: Use Resume UI for Fast Re-Entry After an interruption, use the [Resume UI](/features/resume-ui) to reopen the exact session you need. This avoids wasting prompts on context rebuilding. ![Resume UI showing previous AI sessions ready to continue](/app-screenshots/resume-ui.jpg) ## Operating Rules for Daily Use - One terminal role, one branch intent. - Review all generated diffs before merge. - Use short, constraint-rich prompts with clear completion criteria. - Keep one terminal dedicated to tests and verification only. ## Final Takeaway A stable Claude Code setup is less about a single command and more about workspace operations. If you enforce naming, persistence, and resume hygiene, Claude becomes predictable under pressure. For teams running Claude daily, this is the difference between occasional wins and a repeatable delivery system. --- ## AI Session Continuity: Resume Claude Code, Codex & Gemini Sessions in 1DevTool v1.11.0 Source: https://1devtool.com/blog/ai-session-continuity-resume-claude-code Published: 2026-04-01 Tags: claude-code, codex, gemini, session-resume, productivity Close your laptop, reopen it, and your AI conversations resume where you left off. 1DevTool v1.11.0 adds session persistence with smart detection, one-click resume, and auto-resume for Claude Code, Codex, Gemini CLI, and Amp. You close your laptop at the end of the day. Claude Code is mid-refactor, Codex is halfway through a migration, and Gemini CLI just started generating tests. You reopen your machine the next morning, launch your terminals, and… everything is gone. Fresh prompts. Empty buffers. No memory of what any agent was doing. You spend the next ten minutes re-explaining context that your AI already understood. This is the silent tax of agentic coding in 2026: **AI conversations vanish the moment you close the app.** Every restart means lost context, re-typed prompts, and wasted time rebuilding momentum. 1DevTool v1.11.0 fixes this with **AI Session Continuity** — close and reopen the app, and your AI conversations resume exactly where you left off. Here's how it works and why it matters. ## Why Session Continuity Matters for AI Coding Traditional terminals are stateless by design. You open a shell, run commands, close the shell, and the history lives only in `~/.bash_history` as flat text. That was fine when you were the one typing every command. But AI agents are different. When you give Claude Code a prompt like "refactor the authentication module to use refresh tokens," the agent builds up an internal conversation context: it understands your codebase, the files it has already read, the decisions it has made, and the changes it has applied. That context is *expensive* — both in tokens and in the time you spent explaining your intent. Losing it on every restart is like asking a contractor to re-read the blueprints every morning. Session continuity solves three concrete problems: - **No more re-prompting.** Your agent already knows what it was working on. Resume the session and it picks up mid-task — no need to re-explain the goal, the constraints, or the files involved. - **No more lost scrollback.** The full conversation history — every prompt, every response, every code block — is restored as scrollback in your terminal. You can scroll up, review what happened, and continue seamlessly. - **No more context window waste.** Re-prompting forces the AI to re-read files and rebuild understanding. Resuming skips all of that. You get back to productive work in seconds, not minutes. For developers running multi-agent workflows across multiple projects, this compounds. If you have four agents across two projects, restarting without session continuity means re-prompting *all four*. With continuity, you reopen 1DevTool and every terminal is exactly where you left it. ## How It Works AI Session Continuity in 1DevTool is built on four layers: smart session detection, one-click resume, auto-resume on restart, and project-aware filtering. Each layer solves a distinct part of the problem. ### Smart Session Detection The foundation of session continuity is knowing *which* session belongs to *which* terminal. This is harder than it sounds. AI agents store their history files in different locations and formats: - **Claude Code** writes JSONL files to `~/.claude/projects/*.jsonl` - **Codex** stores sessions at `~/.codex/sessions/YYYY/MM/DD/*.jsonl` - **Gemini CLI** keeps session JSON at `~/.gemini/tmp/{project}/chats/session-*.json` 1DevTool's Resume Manager scans these history files and uses a `detectSessionForTerminal()` function that filters by three criteria: the agent type running in the terminal, the project path the terminal is associated with, and the timestamp (using a 10-second grace period to handle minor clock drift between process start and file creation). This means even if you have five Claude Code terminals across three projects, each terminal finds its own session — not someone else's. To prevent race conditions, 1DevTool uses an **atomic claim mechanism**. When a terminal binds to a session, it claims it exclusively. Two terminals can never bind to the same session, even during rapid restarts or if multiple instances of 1DevTool are running simultaneously. ### One-Click Resume When 1DevTool detects a previous session for a terminal, a **Resume button** appears directly in the terminal chrome. Click it, and 1DevTool calls the agent-specific resume command: - `claude --resume {session-id}` for Claude Code - `codex resume {session-id}` for Codex - Agent-specific variants for Gemini and other supported agents Under the hood, the Resume button calls `window.api.resume.getCommand(agentType, sessionId)`, which returns the correct CLI invocation for whichever agent ran in that terminal. You don't need to remember command flags or hunt for session IDs — one click and you're back. ### Auto-Resume on Restart One-click is good. Zero-click is better. For agents that support it, 1DevTool can **automatically resume sessions** when you restart the app — no button press needed. Here's how it works: each terminal stores a `lastSessionId` and `lastSessionAgentType`. When 1DevTool starts and initializes its terminals, it checks the `canAutoResume` flag on each agent's contract. If auto-resume is supported (currently Claude Code and Codex), the terminal automatically sends the resume command and updates the tab name to reflect the resumed session. The result: you close 1DevTool with three agent terminals running. You reopen it. All three terminals are back in their previous conversations, scrollback intact, ready for your next prompt. No clicking, no typing, no re-explaining. ### Project-Aware Filtering The **Resume Panel** gives you a bird's-eye view of all resumable sessions across your machine. But raw session lists are noisy — you might have dozens of sessions from different projects, different days, different agents. The Resume Panel solves this with intelligent filtering: - **Auto-selects the active project** so you immediately see sessions relevant to what you're currently working on - **Filters by project path** so sessions from `~/projects/backend` don't mix with sessions from `~/projects/frontend` - **Shows agent type, session ID, and timestamp** for each entry so you can identify exactly which conversation you want to resume When resuming, the terminal's scrollback is restored from the saved buffer — complete with a visual separator and dimmed text so you can clearly distinguish previous conversation from new output. The session ID is displayed in the terminal chrome for reference. ## Supported AI Agents Session continuity is not a one-size-fits-all feature. Each AI agent has different capabilities around session persistence. 1DevTool defines **agent contracts** that specify exactly what each agent supports: Agent Session Detection One-Click Resume Auto-Resume Transcript Restore Claude Code Yes Yes Yes Yes Codex Yes Yes Yes Yes Gemini CLI Yes Yes No Partial Amp Yes Yes No No The agent contract system is extensible. As new CLI agents ship resume capabilities, 1DevTool can add support without changes to the core architecture — just define the contract (does this agent support detection? resume? auto-resume? transcript restore?) and the Resume Manager handles the rest. ## Before vs After To see why this matters, compare the daily workflow with and without session continuity: ### Before: Every Restart Is a Cold Start 1. Close laptop at end of day with 3 agent terminals running 2. Open laptop next morning, launch 1DevTool 3. All terminals show fresh shells — no history, no context 4. Try to remember what Claude Code was working on. Was it the auth refactor or the API migration? 5. Re-prompt Claude Code: "Continue the auth module refactor from yesterday, here are the files..." 6. Re-prompt Codex: "You were migrating the database schema, pick up where you left off..." 7. Re-prompt Gemini: "Generate tests for the endpoints we built yesterday..." 8. Wait for each agent to re-read files and rebuild context 9. 15 minutes later, you're finally back to productive work ### After: Seamless Continuity 1. Close laptop at end of day with 3 agent terminals running 2. Open laptop next morning, launch 1DevTool 3. All three terminals auto-resume: Claude Code picks up the auth refactor, Codex continues the migration, Gemini resumes test generation 4. Scrollback shows the full previous conversation — you can see exactly where each agent stopped 5. Type your next prompt. Zero re-explaining. Zero context rebuilding. 6. 30 seconds from laptop open to productive work The difference is stark: **15 minutes of re-prompting and waiting** versus **30 seconds to full productivity**. Over a week, that's over an hour saved just on session recovery — time that goes back into building. ## Scrollback Restoration: The Underrated Detail One detail worth highlighting: when a session resumes, 1DevTool doesn't just send the resume command and hope for the best. It restores the **full terminal scrollback** from the previous session. This means you can scroll up and read the entire previous conversation — every prompt you sent, every response the agent gave, every code block it produced. The restored content is visually distinct: it appears with dimmed text and a clear separator line so you always know where the previous session ends and the new one begins. The session ID is also displayed so you can reference it if needed. This is possible because 1DevTool saves terminal buffers when `resumeHydration` is enabled. On restart, the saved buffer is restored into the terminal before the resume command runs. The result is a terminal that looks and feels like you never closed the app. ## Under the Hood: Agent-Specific Resume Commands Different AI agents implement session resumption differently, and 1DevTool abstracts this complexity away. When you click Resume or auto-resume triggers, 1DevTool calls `window.api.resume.getCommand(agentType, sessionId)`, which maps to the correct CLI invocation: - **Claude Code:** `claude --resume {session-id}` — Claude Code natively supports session resumption via its `--resume` flag, picking up the full conversation context from its JSONL history files. - **Codex:** `codex resume {session-id}` — Codex uses a `resume` subcommand rather than a flag, loading session state from its date-organized session directory. - **Gemini CLI:** Uses its own session identifier scheme with project-scoped session files. Resume support is available via one-click, though auto-resume is not yet supported. - **Amp:** Session detection is supported, enabling one-click resume. Full auto-resume and transcript restore are on the roadmap. You never need to know these details. 1DevTool handles the mapping and gives you a single, consistent experience regardless of which agent is running. ## Tips for Getting the Most Out of Session Resume Here are practical tips to maximize the value of AI session continuity in your workflow: - **Name your terminals.** When you have multiple agent sessions, descriptive tab names ("Claude - Auth Refactor," "Codex - DB Migration") make it instantly clear which session is which on resume. - **Use project-specific terminals.** Sessions are filtered by project path. Keeping agents scoped to their project directory ensures clean session detection with no cross-project interference. - **Let auto-resume handle the common case.** For Claude Code and Codex, auto-resume works out of the box. You don't need to do anything — just close and reopen 1DevTool. The Resume button is there for cases where auto-resume isn't available or you want to resume a different session. - **Check scrollback before prompting.** After a resume, scroll up to review where the agent stopped. Sometimes the agent was mid-thought or waiting for a decision. Seeing the full context helps you write a better follow-up prompt. - **Use the Resume Panel for older sessions.** The Resume Panel shows all resumable sessions for the current project, not just the most recent one. If you want to pick up a session from two days ago, it's there. ## Try It Today AI Session Continuity is available now in [1DevTool v1.11.0](https://1devtool.com). Update the app, run your AI agents, close the app, reopen it, and watch your sessions resume automatically. It is the kind of feature that feels obvious once you have it — and unbearable once you try to go back. No more re-prompting. No more lost context. No more cold starts. **Close your laptop, reopen it, and keep building.** [Download 1DevTool](https://1devtool.com) and try session continuity with Claude Code, Codex, Gemini CLI, or Amp. One workspace. Every agent. Every session — resumed. --- ## API Client and Terminal in One Workspace: Faster Debugging Guide Source: https://1devtool.com/blog/api-client-and-terminal-in-one-workspace-guide Published: 2026-04-01 Tags: http-client, terminal, debugging, workspace Combining API requests, terminal logs, and code context in one interface eliminates a major source of debugging latency. Here's how to run a tighter request-fix-verify loop. A common bottleneck in API-heavy projects is context switching: request in one app, logs in another, code in another. Combining API and terminal workflows in one surface speeds up every debug cycle. ## The Fast Request-Fix-Verify Loop 1. Send request and inspect status, payload, and timing. 2. Jump to terminal logs to trace service behavior. 3. Edit code, rerun service, and retest immediately. This loop should take minutes, not context-switch-heavy half-hours. ![HTTP request builder used for fast API testing iterations](/app-screenshots/http-request-builder.jpg) ## Features That Unblock Speed - [Request Workspace](/features/request-workspace) for endpoint organization. - [Response Inspector](/features/response-inspector) for failure triage. - [Terminal Grid Layouts](/features/terminal-grid-layouts) for side-by-side visibility. ![Response inspector with API status, headers, and JSON body](/app-screenshots/response-inspector.jpg) ![Terminal grid layout showing backend logs during API debugging](/app-screenshots/terminal-grid-layout.jpg) ## When This Model Pays Off This setup has the biggest impact when you maintain multiple services, run AI-generated changes, or debug integration issues that require logs and request context together. ## Final Takeaway The best API client for developers is the one that stays attached to code and terminal context. Unified workflows reduce time-to-fix and improve repeatability across the team. --- ## Codex CLI Workflow Guide: Multi-Project Setup for Faster AI Coding Source: https://1devtool.com/blog/codex-cli-workflow-guide-multi-project Published: 2026-04-01 Tags: codex, workflow, multi-project, agentic-coding Codex CLI is fast, but speed disappears when sessions get scattered across projects. This guide shows a multi-project Codex workflow with prompt history, continuity, and predictable handoffs. **Codex CLI** is capable and fast, but many teams underuse it because their workflow is still single-terminal and single-project. The result is frequent context resets and messy handoffs. This guide shows a simple multi-project operating model so Codex can run continuously without losing control. ## Core Principle: Separate Project Context Keep each project in its own workspace with dedicated terminal lanes. Do not mix prompts from unrelated repositories in the same session. Isolation is the easiest way to reduce accidental cross-project actions. ![Multiple Codex and AI agent terminals organized by project](/app-screenshots/multi-agent-terminals.jpg) ## Recommended Codex Lane Structure - **codex-plan:** architecture and change sequencing. - **codex-build:** implementation and refactors. - **codex-verify:** tests, lint, and regression checks. If you also run Claude or Gemini, keep one operator terminal that only coordinates tasks and approves merges. ## Use Prompt History as Operational Memory When a task fails mid-way, teams often rewrite instructions from scratch. Instead, keep a searchable record with [Prompt History](/features/prompt-history) and reissue improved prompts from previous runs. ![Prompt history panel with searchable AI prompt records](/app-screenshots/prompt-history.jpg) ## Make Codex Sessions Resumable Long-running AI work should not die with your laptop lid. Use [Session Continuity](/features/session-continuity) to reopen Codex sessions with full context. This is critical for multi-day tasks and branch-heavy work. ![Session continuity flow for resuming previous AI coding sessions](/app-screenshots/session-continuity.jpg) ## Codex CLI Checklist for Teams - One Codex lane per function: plan, build, verify. - One branch focus per lane to limit merge conflicts. - Prompt history enabled and reviewed during retries. - Session continuity enabled before production rollouts. ## Final Note Most Codex performance issues are workflow issues, not model issues. Fix lane structure and context persistence, and Codex becomes a reliable daily contributor instead of an occasional assistant. --- ## Best AI Terminal Emulator for Developers in 2026 Source: https://1devtool.com/blog/best-ai-terminal-emulator-for-developers-2026 Published: 2026-03-31 Tags: ai-terminal, comparison, claude-code, codex AI coding changed what a terminal must do. It is no longer only about shell speed. Compare terminal options based on session continuity, readability, multi-agent control, and workflow ergonomics. Choosing the **best terminal for AI coding** now requires different criteria than traditional shell workflows. AI sessions are longer, more verbose, and often run in parallel. If your terminal cannot handle readability, session continuity, and multi-agent context transfer, your model quality will not matter. The interface becomes the bottleneck. ## How AI Workloads Change Terminal Needs - Outputs are long-form markdown, tables, and diffs, not just command lines. - You need quick switching between coding, review, and debug sessions. - Agent outputs must remain searchable and resumable over time. - Keyboard-driven throughput matters more than visual novelty. ## Evaluation Framework Criterion Why it matters for AI Readable output mode Prevents scanning fatigue on long agent responses. Session persistence Protects context during restarts and interruptions. Terminal organization Keeps multi-agent roles clear and recoverable. Shortcut and font control Improves speed and reduces cognitive friction. ## Features That Decide the Winner For AI-heavy workflows, prioritize [Terminal Reader Mode](/features/terminal-reader-mode), [Session Persistence](/features/session-persistence), and [Hide & Restore Terminals](/features/hide-terminal) before cosmetic features. ![Terminal reader mode rendering AI output in a clean readable layout](/app-screenshots/terminal-reader-mode.jpg) Add [Keyboard Shortcuts](/features/keyboard-shortcuts) and [Terminal Fonts](/features/terminal-fonts) customization to reduce repetitive interaction overhead. Small ergonomics compound over thousands of prompts. ![Hide terminal feature decluttering active workspace without stopping processes](/app-screenshots/hide-terminal.jpg) ## Practical Recommendation If your work is primarily shell command execution, a standard terminal is enough. If your work is AI orchestration, choose an **AI terminal emulator** that treats context, readability, and continuity as first-class features. This is the difference between “running an agent” and running a repeatable AI coding system. --- ## Self-Hosted AI Coding Assistant Workflow: Practical Setup Guide Source: https://1devtool.com/blog/self-hosted-ai-coding-assistant-workflow-guide Published: 2026-03-31 Tags: self-hosted, ai-coding-assistant, mcp, security A self-hosted AI coding workflow needs more than model hosting. You need environment control, connector governance, and reproducible operations. This guide covers the practical stack. A **self-hosted AI coding assistant** setup is not only about where models run. It is about operational control: environment integrity, connector governance, and reproducible workflows. ## Core Design Goals - Keep sensitive code and credentials inside controlled boundaries. - Enforce predictable [environment variables](https://servercompass.app/features/env-vars-editor) per project. - Audit which external tools/connectors agents can call. ![MCP settings panel for configuring agent connectors](/app-screenshots/mcp_settings.jpg) ## Practical Stack 1. Use [Environment Manager](/features/env-manager) for project-scoped secrets. 2. Use [MCP Settings](/features/mcp-settings) to control external tool access. 3. Run role-based agent terminals for planning, building, and review. ![Environment manager showing project-specific variable controls](/app-screenshots/env-manager.jpg) ![Multi-agent terminals used in a controlled self-hosted workflow](/app-screenshots/multi-agent-terminals.jpg) ## Safety Practices - Separate read-only analysis agents from write-capable execution agents. - Require explicit approvals for destructive operations. - Review generated diffs before merge every time. ## Final Take Self-hosted AI success comes from operational discipline. The more explicit your environment and connector controls, the more trustworthy and repeatable your agent workflows become. --- **Related in the StoicSoft network** If you're self-hosting on a VPS or working through a deployment guide like the one above, [DeployToVPS](https://deploytovps.com) is the StoicSoft network's handbook for VPS deployment recipes — docker-compose, nginx, traefik, and common app self-hosts. --- ## Terminal Reader Mode: Turn AI Agent Output into Clean, Readable Documents Source: https://1devtool.com/blog/terminal-reader-mode-ai-output Published: 2026-03-31 Tags: reader-mode, terminal, productivity, agentic-coding AI agents produce walls of markdown, tables, and code in your terminal — but terminals are built for commands, not reading. Terminal Reader Mode transforms raw AI output into a formatted reading view with themes, search, and built-in chat. AI coding agents are brilliant at solving problems, but they have a readability problem. When Claude Code refactors your authentication module or Codex CLI generates a test suite, the output lands in your terminal as a wall of raw text: ANSI escape codes, box-drawing characters, markdown syntax rendered as plain strings, and hundreds of lines scrolling past faster than you can read. You squint at the terminal, scroll up, lose your place, scroll again. The agent did great work — you just can't comfortably read it. This is the gap between AI agent *output* and human *comprehension*. Your terminal was designed for running commands, not for reading long-form explanations, code reviews, or documentation that AI agents routinely produce. 1DevTool v1.10.1 closes that gap with **Terminal Reader Mode** — a single keyboard shortcut that transforms any terminal's output into a clean, formatted reading view with full markdown support, configurable themes, search, and the ability to continue chatting with your AI agent without leaving the reader.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool Terminal Reader Mode showing formatted markdown output from an AI agent with clean typography and a warm Sepia reading theme
Terminal Reader Mode in 1DevTool — AI agent output rendered as clean, formatted markdown with a comfortable reading theme.
## Why Terminal Output Needs a Reading Mode Terminals are optimized for *interaction*, not *consumption*. Monospaced fonts, fixed-width columns, raw control sequences — these are the right defaults for running commands and watching logs. But AI agents have fundamentally changed what appears in your terminal. A typical Claude Code session might produce an explanation of architectural decisions spanning 500+ words, a code diff with inline comments, a bulleted list of changes made across 12 files, and a summary table comparing before-and-after performance metrics. That content is *documentation*, not terminal output. It deserves document-quality rendering. The problems with reading AI output in a raw terminal compound quickly: - **ANSI escape codes clutter the text.** Terminal control sequences for colors, cursor movement, and formatting are invisible in a running terminal but create noise when you try to copy, search, or re-read output. - **Markdown renders as syntax, not formatting.** When an AI agent writes `## Architecture Decision`, you see the literal hash marks instead of a heading. Bold markers like `**important**` stay as asterisks. Lists lose their visual hierarchy. - **Box-drawing tables are fragile.** AI agents frequently output tables using Unicode box-drawing characters (`+---+`, `|`). These look fine at one terminal width but break when you resize, and they're impossible to copy cleanly. - **No search.** Your terminal's built-in search (if it has one) matches against raw buffer content including control sequences, producing unreliable results. Finding a specific function name in 200 lines of AI output becomes a manual scroll-and-scan exercise. - **Eye strain.** Monospaced fonts at typical terminal sizes (12-14px) are designed for code, not for reading paragraphs. After reviewing three or four long AI agent responses, your eyes are fatigued. Reader Mode solves all of these problems with a single shortcut: `Cmd+Shift+E` on macOS or `Ctrl+Shift+E` on Windows and Linux. ## How Reader Mode Works When you activate Reader Mode, 1DevTool takes the raw terminal buffer and transforms it through a multi-step pipeline designed specifically for AI agent output. The result is a reading experience closer to a well-formatted blog post than a terminal window. ### Clean Formatting with Markdown Rendering The first step strips all ANSI terminal control sequences from the buffer — color codes, cursor positioning, scroll regions, and other escape sequences that exist for the terminal emulator but add nothing to the content. The underlying function, `stripTerminalControlSequences()`, handles the full range of ANSI/VT100 sequences so the output is pure text. Next, 1DevTool detects and converts visual tables. AI agents love to output tables using box-drawing characters like `+`, `-`, `|`, and Unicode borders. The `convertVisualTablesToMarkdown()` function recognizes these patterns and converts them into standard markdown pipe tables, which then render as clean HTML tables in the reader view. Finally, the cleaned content is rendered as full markdown. Headings, bold and italic text, code blocks with syntax highlighting, ordered and unordered lists, links, blockquotes, and tables all render with proper formatting. AI agent output is always treated as markdown, so you get the formatted version from the start — no configuration needed.
{/* eslint-disable-next-line @next/next/no-img-element */} Close-up of Reader Mode showing rendered markdown with headings, code blocks, and formatted tables converted from box-drawing characters
Markdown rendering in action — headings, code blocks, and tables all formatted for comfortable reading.
### Five Reading Themes Everyone has a preferred reading environment. Reader Mode ships with five themes designed for extended reading sessions: - **Sepia** — A warm, paper-like background (`#fdf6e3`) that reduces blue light and feels like reading a printed book. Ideal for long documentation reviews. - **White** — Clean and bright (`#ffffff`), matching the style of modern documentation sites. Best for daytime use in well-lit environments. - **Dark** — A deep dark background (`#1a1a2e`) for night coding sessions. Pairs well with a dark editor theme to keep your eyes adapted. - **Green** — A low-light forest theme (`#0d1f0d`) that minimizes eye strain for late-night sessions. The warm green tones feel easy on the eyes without the harshness of pure black. - **Custom** — Pick your own background color and let Reader Mode adapt the text and accent colors automatically. Each theme works with three font families: **Georgia** (Serif) for a book-like reading experience, **System sans-serif** for a clean modern feel, and **JetBrains Mono** for developers who prefer monospaced text even in a reading view. The default font size is 15px and is fully adjustable — bump it up for comfortable reading or down for higher information density.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool Reader Mode font size adjustment controls with a preview of different font sizes applied to AI agent output
Adjustable font size and font family controls let you customize the reading experience to your preferences.
### Search with Match Highlighting Reader Mode includes a built-in search that works on the rendered content, not the raw terminal buffer. When you search for a term, the `highlightMatches()` function uses a DOM TreeWalker to traverse the rendered document tree, find every occurrence of your search term, and wrap each match in a `` tag with amber highlighting. This means search results are visually prominent and accurate. You're searching the text as you see it, not a hidden buffer full of escape codes. Navigate between matches to jump through the document quickly — especially useful when an AI agent produces a long explanation and you need to find where it discusses a specific function or file. ### Chat with Your AI Agent from Reader Mode Reader Mode is not just a passive viewer. You can continue your conversation with the AI agent directly from the reading view. Type a follow-up prompt, and it gets sent to the same terminal session. The agent's response appears in the reader, formatted with the same clean markdown rendering. The chat input supports **@mentions with file autocomplete** — type `@` and start typing a filename to see up to 15 suggestions pulled from your project. This lets you reference specific files in your follow-up prompts without leaving the reader to look up paths. The autocomplete respects your `.gitignore`, so you won't see `node_modules` or build artifacts cluttering the suggestions. You can also **drag and drop files** or **paste images** directly into the chat input. Need to share a screenshot of a UI bug with the agent? Drop it in. Want to attach a config file for the agent to review? Drag it from your file explorer. Reader Mode becomes a comfortable workspace for extended back-and-forth with your AI agent — reading the output, asking questions, and refining the result. ## Before vs After The difference is immediate and dramatic. Here is what the same AI agent output looks like with and without Reader Mode: ### Before: Raw Terminal - Monospaced font at 13px, optimized for code not prose - Markdown syntax visible as literal characters (`##`, `**`, `-`) - ANSI color codes rendered by the terminal but lost on copy-paste - Box-drawing tables that break on resize - No search that understands the content - Scroll up 200 lines to re-read the beginning, lose your place on the way back ### After: Reader Mode - Proportional serif font at 15px, optimized for sustained reading - Markdown rendered as formatted HTML — real headings, bold, code blocks, lists - All control sequences stripped, pure content - Box-drawing tables converted to clean HTML tables - Full-text search with amber highlighting - Estimated reading time (calculated at 220 words per minute, minimum 1 minute) - Continue chatting with the agent without switching views The reading time indicator is particularly useful for planning. When Claude Code produces a long architectural explanation, seeing "4 min read" at the top helps you decide whether to read it now or bookmark it for later. ## Who Benefits Most Developer Profile Without Reader Mode With Reader Mode Solo dev using Claude Code daily Squints at raw markdown in terminal, copies output to a separate app to read One shortcut to a formatted reading view with search and chat Tech lead reviewing AI-generated plans Scrolls through 500+ lines of monospaced text, loses context Reads a properly formatted document with headings, tables, and navigation Developer doing code review via AI agent AI agent's diff explanations are buried in terminal noise Clean rendered diffs and explanations with syntax-highlighted code blocks Late-night coder on a dark setup Bright terminal strains eyes during long reading sessions Dark or Green theme with adjustable font size reduces fatigue Developer who iterates on AI output Switches between terminal and editor to refine prompts Reads output and sends follow-up prompts in the same view ## What Else Is New in v1.10.1 Reader Mode is the headline feature, but v1.10.1 also ships several improvements that sharpen the overall 1DevTool experience: - **Smarter command palette search:** The command palette now uses improved fuzzy matching that surfaces relevant commands faster, even with partial or misspelled queries. - **Faster file search:** File search performance has been optimized for large monorepos. Projects with 50,000+ files see noticeably faster results. - **@mention respects .gitignore:** When you type `@` in the terminal chat to reference a file, the autocomplete now filters out files matched by your `.gitignore`. No more `node_modules` or `dist` cluttering your suggestions. ## Try It Today Terminal Reader Mode is available now in [1DevTool v1.10.1](https://1devtool.com). Update the app, open any terminal running an AI agent, and press `Cmd+Shift+E` (or `Ctrl+Shift+E` on Windows/Linux). You can also click the Reader Mode button that now appears on every terminal panel. Once you read your first AI agent response in Reader Mode — with proper headings, clean tables, syntax-highlighted code blocks, and a warm Sepia background — you will not want to go back to squinting at raw terminal output. **Your AI agent writes great output. Reader Mode lets you actually read it.** --- ## Claude Code Mobile, Codex Mobile, Gemini CLI Mobile: How to Code From Your Phone in 2026 Source: https://1devtool.com/blog/claude-code-mobile-codex-mobile-gemini-mobile-remote-coding Published: 2026-03-30 Tags: claude-code, codex, gemini, mobile, remote, productivity AI coding agents like Claude Code, OpenAI Codex, and Gemini CLI all run in terminals — which means they run on your phone. But a terminal is not a workspace. Learn how 1DevTool Remote turns your phone into a full development control center. The biggest shift in software development in 2026 isn't a new language or framework — it's that **AI agents now do the coding for you**. Claude Code, OpenAI Codex CLI, and Gemini CLI all run in terminals, which means they technically run on your phone too. Developers are already kicking off builds from the couch, approving diffs on the train, and monitoring agents from bed. But there's a problem. Running a terminal on your phone gives you a keyhole view of one session. When you're managing 3-5 AI agents across multiple projects, a single terminal window isn't enough. That's where **1DevTool Remote** comes in — turning your phone into a real development control center connected to your desktop workspace. ## The Mobile AI Coding Landscape in 2026 Three major AI coding agents now dominate the terminal-based workflow. All three are CLI-first, which makes them portable — but each has different strengths on mobile. ### Claude Code on Mobile **Claude Code** is Anthropic's agentic coding CLI. It reads your codebase, writes files, runs commands, manages git, and executes multi-step tasks autonomously. On mobile, you can run it via: - **Termux (Android):** Install Node.js, then `npm install -g @anthropic-ai/claude-code` - **a-Shell / iSH (iOS):** Limited Node.js support, but functional for basic prompts - **SSH into a remote server:** The most reliable option — run Claude Code on your dev machine, control it from your phone - **Claude Code web app:** Anthropic now offers claude.ai/code for browser-based access Claude Code on mobile is great for **quick prompts** — "fix the login bug," "add input validation to the signup form." But reviewing the multi-file diffs it produces on a 6-inch screen is a different story. ### OpenAI Codex CLI on Mobile **Codex CLI** is OpenAI's open-source terminal agent. It uses GPT-4.1 and o3-mini under the hood and runs locally in your terminal. On mobile: - **Termux (Android):** Install Node.js 22+, then `npm install -g @openai/codex` - **SSH:** Same remote approach as Claude Code — SSH into your machine and run `codex` - **iOS:** No native option yet. SSH is the only reliable path. Codex has three operating modes — *suggest*, *auto-edit*, and *full-auto* — which matter on mobile because full-auto mode means less manual approval friction on a small screen. But you still can't see what it's actually doing across your project without flipping between terminal sessions. ### Gemini CLI on Mobile **Gemini CLI** is Google's AI coding agent powered by Gemini 2.5 Pro. It's the newest entrant and features a generous free tier (60 requests/minute for individual developers). On mobile: - **Termux (Android):** Install Node.js 18+, then `npx @anthropic-ai/gemini-cli` or install globally - **SSH:** Same remote pattern — Gemini CLI runs on your dev machine - **Google Cloud Shell:** Access via browser for a zero-install mobile experience Gemini CLI supports multi-modal inputs (images, screenshots) which is interesting on mobile — you could snap a photo of a UI bug and send it directly. But the core problem remains: one terminal, one session, one project at a time. ## The Real Problem With Mobile AI Coding Every blog post about "coding from your phone" shows the same thing: a single terminal running one AI agent on one project. It looks cool in a tweet. In practice, it falls apart because modern agentic coding workflows involve: - **Multiple agents running in parallel:** Frontend agent, backend agent, test agent — all on different projects or branches - **Approval queues:** Agents pause and wait for your approval before making destructive changes - **Diff review:** You need to see exactly what changed across multiple files before accepting - **Context from your dev environment:** Database state, API logs, git status — not just terminal output - **Coordination:** Telling one agent to wait while another finishes, or redirecting priorities on the fly A terminal app on your phone — whether it's Termux, Happy, or any SSH client — gives you exactly **one window into one session**. That worked when coding meant typing code yourself. It doesn't work when coding means managing a fleet of AI agents. ![Multiple AI agent terminals running in parallel on 1DevTool desktop](/app-screenshots/multi-agent-terminals.jpg) This is what multi-agent coding actually looks like on desktop — multiple agents across multiple projects. A single mobile terminal can't show you any of this. ## 1DevTool Remote: Your Desktop Workspace on Your Phone **1DevTool Remote** is a completely different approach to mobile coding. Instead of running a terminal on your phone, it connects your phone to your desktop 1DevTool workspace — giving you visibility and control over everything running on your machine. ![1DevTool Remote Control settings with QR code pairing and device management](/app-screenshots/remote_control_settings.jpg) ### How It Works 1. **Open 1DevTool on your desktop** — your projects, terminals, and agents are running as usual 2. **Enable Remote Access** — 1DevTool generates a QR code 3. **Scan from your phone** — a secure, encrypted connection pairs your phone to your desktop 4. **Your full workspace appears on your phone** — every project, every terminal, every agent No app to install. No SSH keys to configure. No Node.js on your phone. Just scan and go. ![1DevTool Remote Control settings with QR code pairing](/app-screenshots/remote_control_settings.jpg) ### Real-Time Project Dashboard The moment you connect, you see **every project** on your desktop — not just the one terminal you happened to SSH into. Each project card shows: - **Project name and status indicator** — color-coded so you can spot issues instantly - **Git branch and dirty state** — see which branches have uncommitted changes - **Terminal count** — how many terminals are running (alive vs total) - **AI agent status badges** — which agents are running, waiting, or finished - **Active dev server URL** — tap to preview your running app Expand any project to see its individual terminals and jump into any one of them. ![1DevTool multi-project workspace with color-coded projects](/app-screenshots/multi-project-workspace.jpg) Your desktop workspace — every project, every terminal — now accessible from your phone via Remote. ### Full Remote Terminal When you tap into a terminal, you get a **real terminal emulator** — not a stripped-down text view. Powered by xterm.js with 10,000 lines of scrollback, it supports: - Full ANSI color and formatting - Quick-key buttons for Tab, Escape, Ctrl+C, arrow keys, and more - Text input with command sending - Auto-scroll with manual scroll detection - Real-time streaming — see output as it happens ![1DevTool Remote terminal interaction on mobile](/app-screenshots/mobile_remote_terminal_interaction.jpg) This means you can interact with Claude Code, Codex, or Gemini CLI — whatever agent is running in that terminal — with the same fidelity as sitting at your desk. Approve changes, send follow-up prompts, or Ctrl+C to stop a runaway task. ### Browser Proxy: Preview Your App on Mobile Running a dev server on localhost:3000? 1DevTool Remote proxies it to your phone. You can: - **Browse your running web app** directly from your phone - **Take annotated screenshots** — draw arrows, circles, and text on the screen - **Send screenshots to your AI agent** — "fix this layout issue" with the annotated screenshot as context This is especially powerful for responsive design. Your AI agent builds a feature on desktop, and you immediately see how it looks on an actual mobile device — then send visual feedback directly to the agent. ![1DevTool screenshot annotator with drawing tools for visual feedback](/app-screenshots/screenshot-annotator.jpg) Annotate screenshots with arrows, circles, and text — then send them directly to your AI agent as context. ### Enterprise-Grade Security Remote access to your development environment needs to be secure. 1DevTool Remote uses: - **ECDH elliptic curve key exchange** (P-256) for pairing - **AES-256-GCM encryption** for all sensitive data - **HMAC-SHA256 challenge-response** authentication - **Permission levels:** Viewer, Approver, Operator, and Admin — control exactly what your phone can do - **Session expiration** — connections expire automatically (7-day default) - **No credentials stored on device** — pairing keys are held in memory only Your code never leaves your machine. The phone is a remote control, not a storage device. ## Mobile AI Coding: Terminal App vs 1DevTool Remote Capability Terminal App (Termux/SSH/Happy) 1DevTool Remote Run Claude Code / Codex / Gemini One session at a time See all sessions across all projects Multiple projects Switch manually between SSH sessions Dashboard with all projects at once Agent status Read terminal output Status badges and activity indicators Approve/reject changes Type in terminal Dedicated controls per agent Git status Run git commands manually Branch + dirty state visible per project Preview dev server Not possible without tunneling Built-in browser proxy Screenshot + annotate Not available Draw on screenshots, send to AI agent Security SSH keys or password ECDH + AES-256-GCM + permission levels Setup Install Node.js, configure SSH, manage keys Scan a QR code ## When to Use What ### Use a Terminal App When: - You're running a single agent on a single project - You don't have 1DevTool running on your desktop - You need to SSH into a production server for an emergency fix - You're experimenting with AI coding agents for the first time ### Use 1DevTool Remote When: - You have multiple projects and agents running in parallel - You need to approve or reject changes across several agents - You want to preview your running app on an actual mobile device - You want to send visual feedback (annotated screenshots) to your AI agents - You need to monitor what's happening across your entire workload — not just one terminal - Security matters — you don't want to expose SSH ports or store keys on your phone ## Getting Started: Mobile AI Coding Setup Guide ### Claude Code 1. Install on your desktop: `npm install -g @anthropic-ai/claude-code` 2. Set your API key: `export ANTHROPIC_API_KEY=your-key` 3. Run `claude` in your project directory ### OpenAI Codex CLI 1. Install on your desktop: `npm install -g @openai/codex` 2. Set your API key: `export OPENAI_API_KEY=your-key` 3. Run `codex` in your project directory ### Gemini CLI 1. Install on your desktop: `npm install -g @anthropic-ai/gemini-cli` or use `npx` 2. Authenticate with Google: `gemini auth` 3. Run `gemini` in your project directory ### 1DevTool Remote 1. Download [1DevTool](https://1devtool.com) for desktop 2. Open your projects and start your AI agents in integrated terminals 3. Go to Settings and enable Remote Access 4. Scan the QR code from your phone's camera 5. Your workspace is now on your phone ## What You're Actually Controlling Remotely 1DevTool Remote isn't a standalone mobile app — it's a window into your full desktop workspace. Here's what that workspace looks like on your machine: ![1DevTool activity logs showing real-time agent progress across projects](/app-screenshots/activity_logs.jpg) Activity logs track every agent action across all projects — see who finished, who's waiting, and who hit an error. ![1DevTool diff viewer showing AI-generated code changes](/app-screenshots/diff-viewer.jpg) Review exactly what your AI agents changed with a proper diff viewer — not raw terminal output. ![1DevTool terminal notifications alerting when agents finish tasks](/app-screenshots/notifications.jpg) Get notified the moment an agent finishes, errors out, or needs your approval — no more checking terminals manually. ## The Future: Agents Don't Sleep, and Neither Should Your Workspace The shift from "coding on mobile" to "managing agents on mobile" is already happening. When your AI agents are running 24/7 — writing code, running tests, deploying changes — you need more than a terminal window to stay in control. Claude Code, Codex, and Gemini CLI are all incredible tools. But running them through a mobile terminal app is like monitoring a factory through a single security camera. You can see one thing at a time, and you miss everything else. **1DevTool Remote** gives you the full control room. Every project, every agent, every terminal — live on your phone with the security and fidelity you'd expect from a professional development tool. ## The Verdict **Terminal apps** give you one window into one agent. **1DevTool Remote** gives you your entire desktop workspace in your pocket — with real-time dashboards, full terminal emulation, browser previews, screenshot annotation, and enterprise-grade encryption. The question isn't whether AI coding agents work on mobile. They do. The question is whether a single terminal window is enough to manage what modern agentic development demands. It isn't. **Ready to take your AI coding workflow mobile?** [Download 1DevTool](https://1devtool.com) for desktop and enable Remote Access to turn your phone into a development control center. --- ## Mobile Remote Terminal Control for AI Agents: A Practical Playbook Source: https://1devtool.com/blog/mobile-remote-terminal-control-for-ai-agents Published: 2026-03-30 Tags: mobile, remote, ai-agent, terminal Running AI agents from your phone is useful only when you can see project state, terminal status, and live output in context. This guide covers a practical mobile remote control workflow. Mobile coding is useful only when your phone can control real project context, not just display one [SSH terminal](https://servercompass.app/docs/ssh-terminal-guide). For AI workflows, you need status visibility, fast terminal access, and secure remote control. ## Pairing and Connection Start with [Remote Control](/features/remote-control) pairing, then validate terminal streaming and project list visibility before relying on mobile workflows for critical tasks. ![Remote control settings showing secure mobile pairing options](/app-screenshots/remote_control_settings.jpg) ## What to Do From Mobile - Monitor active projects and agent status. - Approve or interrupt long-running agent tasks. - Check logs and run light follow-up commands. ![Mobile remote interface listing active development projects](/app-screenshots/mobile_remote_list_projects.jpg) ![Mobile terminal interaction view controlling AI agent sessions](/app-screenshots/mobile_remote_terminal_interaction.jpg) ## Operating Guidelines - Keep destructive actions desktop-only unless urgent. - Use mobile primarily for approvals, interrupts, and monitoring. - Attach screenshots and notes for clear desktop follow-up. ## Final Guidance Mobile remote control works best as an extension of a structured desktop workflow. Treat it as a control plane, not a full replacement for deep implementation work. --- ## One-Time Purchase Code Editor Alternatives in 2026 Source: https://1devtool.com/blog/one-time-purchase-code-editor-alternatives-2026 Published: 2026-03-30 Tags: pricing, alternatives, ai-ide, comparison Subscription fatigue is real for individual developers and small teams. Here is a framework for evaluating one-time purchase code editor alternatives without sacrificing AI workflows. Interest in **one-time purchase code editor** options keeps rising for one reason: subscription stacking. Many developers pay monthly for an editor, an API client, a DB client, and extra terminal tooling. A fair comparison is not monthly price alone. It is workflow coverage per dollar over 12-24 months. ## Why Subscription Fatigue Happens - Core coding tool plus add-ons becomes a hidden tool stack tax. - Each tool has separate onboarding and team setup overhead. - Context switching across apps lowers output even when each app is good. ## A Cost Model You Can Use `annual_tool_cost = sum(monthly_subscription * 12) + annual_addons productivity_cost = context_switch_time_per_day * work_days * hourly_rate true_cost = annual_tool_cost + productivity_cost` This is why developers searching “**cursor alternative**” often end up comparing workflow models, not only interface design. ![Layout presets showing custom workspace configurations for different tasks](/app-screenshots/layout-presets.jpg) ## What to Check in an Alternative - Does it combine terminal, API, and database workflows in one place? - Can it support multi-project and multi-agent work without plugin sprawl? - Are sessions and layouts persistent so setup time stays low? In 1DevTool, this maps to [Multi-Project Workspace](/features/multi-project-workspace), [HTTP Request Builder](/features/http-request-builder), [Query Editor](/features/query-editor), and [Layout Presets](/features/layout-presets). ![Multi-project workspace consolidating coding tools in one window](/app-screenshots/multi-project-workspace.jpg) ## Final Decision Rule Choose the option that minimizes total operational cost, not just headline price. For many teams, a consolidated **all in one IDE** workflow outperforms a cheaper-but-fragmented stack. --- ## Developer Workspace Consolidation: From 10 Tools to One Workflow Source: https://1devtool.com/blog/developer-workspace-consolidation-from-10-tools-to-one Published: 2026-03-29 Tags: developer-workspace, productivity, workflow, all-in-one Tool sprawl slows delivery more than most teams realize. This guide shows how to consolidate editor, terminal, API, database, and review workflows into one operating surface. Most teams do not have a coding speed problem. They have a tool orchestration problem. Moving between editor, terminal, API app, database client, and review tabs creates hidden throughput loss. ## Where Tool Sprawl Hurts - Context is fragmented across apps and windows. - Onboarding takes longer because workflows are undocumented and scattered. - Handoffs are manual and often lose key evidence. ![Developer workspace consolidating multiple projects and tools](/app-screenshots/multi-project-workspace.jpg) ## Consolidation Checklist 1. Standardize workspace layouts with [Layout Presets](/features/layout-presets). 2. Centralize frequent actions with [Command Palette](/features/command-palette). 3. Keep API, DB, and terminal workflows in one operating surface. ![Layout presets enabling consistent team workspace configurations](/app-screenshots/layout-presets.jpg) ![Command palette for quick access to workspace actions](/app-screenshots/command-palette.jpg) ## How to Measure Impact - Issue-to-fix cycle time - Time spent switching apps during debugging - Number of blocked handoffs per sprint ## Final Take Consolidation is worth it when it reduces switching costs and improves delivery predictability. If your team spends more time coordinating tools than shipping code, this is likely your highest-leverage fix. --- ## Docker Desktop Alternatives for Developers in 2026 Source: https://1devtool.com/blog/docker-desktop-alternatives-for-developers-2026 Published: 2026-03-29 Tags: docker, comparison, developer-tools, workspace Developers want a Docker workflow that stays close to code, logs, and AI agents. This comparison breaks down Docker Desktop alternatives by performance, observability, and daily usability. Developers searching for a **Docker Desktop alternative** are usually optimizing one of three things: performance, licensing flexibility, or tighter integration with coding workflows. The right choice depends on how often you inspect containers, debug logs, and clean up images during daily work. ## What Matters in a Docker GUI - Container list clarity with status visibility and quick actions. - Real-time logs with easy filtering and copy support. - Image and volume management that prevents machine bloat. - Adjacency to terminal and code context for faster debugging. ![Docker containers panel with running status and quick actions](/app-screenshots/docker-containers.jpg) ## Comparison Framework Capability Standalone Docker app Workspace-integrated Docker manager Container lifecycle controls Yes Yes Context with code and terminals Separate window Same workspace Logs to AI handoff Manual copy flow Direct share workflow Operational speed in debugging loops Medium High ## Core Workflows to Test Evaluate any tool using these workflows: restart failed containers, inspect live logs, and remove stale images. In 1DevTool this maps to [Docker Containers](/features/docker-containers), [Docker Logs Inspect](/features/docker-logs-inspect), and [Docker Images & Volumes](/features/docker-images-volumes). ![Docker log inspector showing filtered container logs](/app-screenshots/docker-logs-inspect.jpg) ![Docker images and volumes management view](/app-screenshots/docker-images-volumes.jpg) ## Bottom Line The best Docker Desktop alternative is the one that fits your full delivery loop. If containers are only part of a larger AI coding workflow, integrated tooling usually wins on cycle time and error recovery. --- ## AI Code Editor for React Developers: Practical Guide (2026) Source: https://1devtool.com/blog/ai-code-editor-for-react-developers-guide-2026 Published: 2026-03-28 Tags: react, frontend, ai-code-editor, guide React workflows benefit from tight loops between code, browser preview, DevTools, and AI agent prompts. This guide shows what to look for in an AI code editor built for frontend speed. React teams need fast frontend feedback loops: edit code, preview UI, inspect DevTools, send context to AI, and repeat. The best AI editor for React supports this loop without extra setup friction. ## React Workflow Requirements - Built-in app preview for quick visual validation. - DevTools access for console, network, and layout debugging. - Direct handoff of code and screenshots to AI agents. ![Embedded browser preview used for React interface testing](/app-screenshots/embedded-browser.jpg) ## Feature Stack for React Speed In 1DevTool, the high-leverage stack is [Embedded Browser](/features/embedded-browser), [DevTools Access](/features/devtools-access), and [Send File to Terminal](/features/send-file-to-terminal) for quick AI handoffs. ![DevTools access panel for debugging frontend React behavior](/app-screenshots/devtools-access.jpg) ![Send file to terminal dialog sharing frontend context with AI agents](/app-screenshots/send-file-to-terminal.jpg) ## Visual Debugging Loop For layout bugs, capture and annotate UI state with [Screenshot Annotator](/features/screenshot-annotator), then send to the active AI terminal. This reduces ambiguous bug reports and shortens fix cycles. ![Screenshot annotator used for visual bug reporting in React workflows](/app-screenshots/screenshot-annotator.jpg) ## Final Advice For React developers, the right AI editor is the one that keeps preview, debugging, and agent collaboration tightly connected. That integration is where most frontend productivity gains come from. --- ## Database GUI Clients Compared: Built-In vs Standalone in 2026 Source: https://1devtool.com/blog/database-gui-clients-compared-built-in-vs-standalone-2026 Published: 2026-03-28 Tags: database, comparison, sql, developer-workspace Should you keep a separate database GUI client or use one built directly into your coding workspace? This guide compares speed, context, and query quality in real development workflows. The “**database GUI**” decision in 2026 is no longer only about SQL features. It is about workflow adjacency: how quickly you can move from query results to code changes and back. Standalone database apps are powerful, but [built-in database](https://servercompass.app/blog/database-admin-panel-vps) tooling can be faster for daily engineering loops. ## Evaluation Criteria - Engine coverage and connection reliability. - Query editor speed with formatting and history. - Schema browsing depth and navigation. - Distance between DB insight and code implementation. ![Multi-database support dashboard listing supported database engines](/app-screenshots/multi-database-support.jpg) ## Built-In vs Standalone Need Standalone DB client Built-in DB workspace Deep administration tasks Usually stronger Depends on product scope App debugging with code context Context switching required Direct and fast Schema to code iteration speed Medium High Toolchain complexity Higher Lower ## Key Workflows For daily development, focus on query-run-debug cycles. In 1DevTool this means [Query Editor](/features/query-editor) for execution and history, plus [Schema Browser](/features/schema-browser) for object exploration. ![SQL query editor with result grid and execution controls](/app-screenshots/query-editor.jpg) ![Database schema browser showing tables and columns](/app-screenshots/schema-browser.jpg) ## Decision Rule If your team does heavy administration, keep a specialized client in the stack. If your priority is delivery speed inside a coding loop, built-in tooling usually provides better flow. --- ## Terminal Manager & Diagram Export: Control Every AI Agent From One Dashboard Source: https://1devtool.com/blog/terminal-manager-diagram-export Published: 2026-03-28 Tags: terminal, dashboard, productivity, diagrams, agentic-coding Running six AI terminals across three projects? The Terminal Manager gives you a Kanban board of every terminal across every project — plus one-click Mermaid diagram export to PNG, JPEG, and SVG. You're running Claude Code on the backend, Codex on the frontend, a Bash terminal compiling assets, and Gemini CLI writing docs. That's four terminals in one project. Multiply by three projects and you have twelve terminals scattered across your workspace. Which ones are still running? Which finished five minutes ago? Which one threw an error you haven't noticed yet? Without a centralized view, your **AI coding workflow** becomes a guessing game. You Alt-Tab between terminals, scroll through output hoping to spot the one that needs attention, and waste time on terminals that are already idle. 1DevTool v1.9.3 introduces the **Terminal Manager** — a unified dashboard to view, search, and control every terminal across all your projects — plus **Diagram Export** to save Mermaid diagrams as PNG, JPEG, or SVG. ## Why You Need a Terminal Manager Modern AI code editors encourage running multiple agents simultaneously. You kick off Claude Code for a refactor, Codex for tests, and Gemini CLI for documentation — all in parallel. The problem isn't running them. The problem is *knowing what they're doing*. Traditional terminal setups give you tabs or panes. That works for two or three terminals. But agentic coding workflows routinely hit six, eight, or twelve terminals across multiple projects. Tabs don't scale. You need a bird's-eye view. ## How the Terminal Manager Works The Terminal Manager is a full-screen overlay that shows **every terminal across every project** in a single, searchable view. It's organized as a Kanban board with three columns: **Idle**, **Running**, and **Needs Review**. ### Kanban Board: See Everything at a Glance Each terminal appears as a card with the project name (color-coded), terminal name, agent type, and a live status indicator. The three columns tell you instantly: - **Idle** (gray dot) — terminals waiting for input or finished - **Running** (green dot) — AI agents actively processing - **Needs Review** (amber dot) — agents that finished and generated output worth reviewing Click any card to jump directly to that terminal in its project. The dashboard polls every 10 seconds to keep statuses fresh, and you can navigate entirely with arrow keys and Enter. ### Live Preview Pane Click a terminal card to see its recent output in a preview pane — without leaving the manager. This lets you quickly triage which terminals need attention. If the preview shows the agent is still mid-task, you move on. If it shows an error or a completion message, you click through to the full terminal. ### Full-Text Search Across All Terminals Type in the search bar to filter terminals by name, project, agent type, or even buffer content. Looking for the terminal where Claude Code mentioned a migration file? Search for "migration" and the manager filters to matching terminals instantly. ### Bulk Actions: Close, Send Commands, Create The Terminal Manager isn't just for viewing — it's for controlling: - **Bulk close:** Select multiple terminals with checkboxes, or use "close idle" to clean up all inactive terminals in a project with one click - **Quick actions:** Send Ctrl+C, Ctrl+D, or Clear to any terminal directly from its card — no need to switch to the terminal first - **Create terminals:** Launch new Bash, Claude Code, Codex, or Gemini CLI terminals in any project without leaving the manager
{/* eslint-disable-next-line @next/next/no-img-element */} Terminal Manager showing all terminals grouped by project with color-coded headers and live status indicators
The Terminal Manager — every terminal across every project in one searchable Kanban board.
## Diagram Export: Mermaid to PNG, JPEG, SVG AI agents frequently generate Mermaid diagrams — architecture diagrams, sequence diagrams, flowcharts. 1DevTool already renders these inline in the markdown editor. Now you can **export any diagram** as a high-resolution image. - **PNG** — for docs, Slack, and presentations (2x Retina resolution by default) - **JPEG** — for smaller file sizes when transparency isn't needed - **SVG** — for scalable graphics in web pages and design tools Click any rendered diagram in the editor and select your export format from the menu. The 2x Retina support means exported images look crisp on high-DPI displays without any extra configuration.
{/* eslint-disable-next-line @next/next/no-img-element */} Diagram export menu showing PNG, JPEG, and SVG options for a Mermaid flowchart
Export Mermaid diagrams to PNG, JPEG, or SVG with one click.
## Under the Hood: Faster and Lighter v1.9.3 also includes significant performance improvements that make the entire app snappier: - **Smarter terminal resource management** — inactive terminals release rendering resources and auto-detach background tmux sessions, reducing memory usage - **Faster git status** — refreshes only when files actually change instead of polling every 10 seconds - **Faster file change detection** — instant refresh from file system events instead of polling every 2 seconds - **No more file watcher leaks** — watchers are properly cleaned up when switching between projects ## Before vs After Task Without Terminal Manager With Terminal Manager Check which agents are running Click through each terminal tab Open dashboard — see all statuses at once Find a specific terminal Scroll through tabs, guess which project Search by name, project, or output content Clean up idle terminals Close them one by one One-click "close idle" per project Preview terminal output Switch to terminal, scroll up Click card to see preview inline Export a Mermaid diagram Screenshot and crop manually Click → Export → PNG/JPEG/SVG ## Who Benefits Most Developer Profile Without Terminal Manager With Terminal Manager Multi-agent power user (6+ terminals) Loses track of which agents finished Kanban board shows all statuses at a glance Multi-project freelancer Terminals from different projects blend together Color-coded project grouping with search Team lead reviewing agent output Opens each terminal to check results Preview pane for quick triage Documentation writer Screenshots and crops Mermaid diagrams One-click SVG/PNG export at 2x resolution ## Try It Today The Terminal Manager and Diagram Export are available now in [1DevTool v1.9.3](https://1devtool.com). If you're running more than a handful of AI agents, the dashboard will change how you work — no more hunting through tabs to find the terminal that needs your attention. **Every terminal. Every project. One dashboard.** --- ## All-in-One IDE for AI Coding in 2026: What to Look For Source: https://1devtool.com/blog/all-in-one-ide-for-ai-coding-2026 Published: 2026-03-27 Tags: ai-ide, workspace, buyer-guide, productivity An all-in-one IDE should reduce tool-switching, not just bundle random panels. Use this checklist to evaluate AI coding workspaces across terminals, APIs, databases, browser preview, and collaboration. The promise of an **all-in-one IDE** is simple: fewer windows, less context switching, faster output. In practice, many products bundle tools but fail to improve real delivery flow. For AI-first teams, the right question is not “how many panels are included?” It is “how quickly can we move from idea to tested change across code, infra, and review?” ## All-in-One IDE Checklist for AI Coding - Multi-agent terminal orchestration with clear status visibility. - Integrated API and database workflows for rapid debugging. - Built-in browser preview with developer tooling access. - Diff and context sharing that supports AI review loops. - Project-level organization and persistent sessions. ![All-in-one workspace view showing multiple projects and active tooling](/app-screenshots/multi-project-workspace.jpg) ## What Good Integration Looks Like A strong **AI IDE** should let you inspect logs, edit code, test endpoints, and validate DB state without breaking focus. In 1DevTool that path includes [Multi-Agent Terminals](/features/multi-agent-terminals), [HTTP Request Builder](/features/http-request-builder), [Query Editor](/features/query-editor), and [Embedded Browser](/features/embedded-browser). ![Embedded browser preview inside the development workspace](/app-screenshots/embedded-browser.jpg) ## Where Most Stacks Fail - Tool overlap without a shared workflow model. - No common event stream for agent activity and task status. - Weak handoff paths between code, logs, screenshots, and diffs. ![Diff viewer for reviewing code changes in an AI-assisted workflow](/app-screenshots/diff-viewer.jpg) ## Final Take An all-in-one IDE is valuable only if it shortens the full delivery loop. Evaluate products on cycle time, handoff quality, and recovery speed after failures. If those metrics improve, consolidation is working. If they do not, you only replaced many icons with one icon. --- ## Search Text in Files & Find-Replace: Verify AI Agent Changes Instantly Source: https://1devtool.com/blog/search-text-in-files-find-replace Published: 2026-03-27 Tags: search, file-explorer, productivity, agentic-coding AI agents rename functions and refactor code fast — but did they catch every reference? Content search with find-and-replace in 1DevTool lets you verify changes across your entire project without leaving your workspace. Claude Code just refactored your authentication module. Codex renamed a bunch of variables. Gemini CLI updated imports across twenty files. Now you need to find every instance of the old function name to make sure nothing was missed. In a traditional terminal workflow, you'd switch to a separate editor or run `grep` manually. In 1DevTool, you search right where you work. v1.9.1 adds **content search with find and replace** directly in the file explorer, plus local image preview in markdown and zoomable image attachments in the agent input overlay. ## Why Search in Files Matters for AI Coding AI agents modify files fast — often faster than you can review. When Claude Code renames a function, it usually gets every reference. *Usually.* The exceptions are what break your build: a dynamic import, a string reference in a config file, a comment with the old name. Having search built into the same workspace where your AI agents run means you can verify changes without context-switching. The agent finishes, you search, you confirm. All in one window. ## How Content Search Works ### Search with Line Previews Open the file explorer and click the search icon. Type any text or pattern and 1DevTool searches across your entire project using ripgrep under the hood. Results appear as a tree grouped by file, with line previews showing the matching text in context. Each result shows the line number and a snippet of surrounding code. Click any result to jump directly to that line in the editor. Match counts appear next to each file so you know at a glance how many occurrences exist.
{/* eslint-disable-next-line @next/next/no-img-element */} Search text in files with results grouped by file, showing line previews and match counts
Content search results with line previews and click-to-jump navigation.
### Find and Replace Across Files Need to rename something across your entire project? Expand the replace field, type the replacement text, and preview every change before applying. 1DevTool shows you exactly which lines will change in which files. Apply replacements selectively or all at once, with a status message confirming how many replacements were made. This is especially useful after AI agents make bulk changes — you can verify the rename was complete, or catch the files the agent missed.
{/* eslint-disable-next-line @next/next/no-img-element */} Find and replace across files with preview of changes before applying
Preview every replacement before applying — no surprises.
## Local Images in Markdown AI agents like Claude Code frequently reference images with relative paths in markdown files — architecture diagrams, screenshots, wireframes. Previously, you'd need to open those images separately to see what the agent was referencing. Now, images with relative paths render inline in both the split editor and reading mode. This means when Claude Code generates a `CHANGES.md` that references `./screenshots/before.png`, you see the image right there in the document — no extra clicks. ## Zoomable Image Attachments When you attach screenshots to the agent input overlay (the Cmd+I dialog), thumbnails used to be tiny and hard to verify. Now you can click any thumbnail to see a full-size lightbox view. Press Escape to close and get back to writing your prompt. Small change, big quality-of-life improvement when you're sending annotated screenshots to AI agents. ## Other Improvements in v1.9.1 - **.env files now visible** — the file explorer shows .env files regardless of gitignore settings, so you can always find your environment configuration - **Auto-paste clipboard toggle** — new setting in Settings > Terminal to control whether multi-line clipboard content is automatically pasted into terminals ## Before vs After Task Before v1.9.1 After v1.9.1 Search project for a string Switch to VS Code or run grep in terminal Search in file explorer with line previews Rename across files Manual find/replace in external editor Preview and apply replacements in-place View images in markdown Open image file separately Inline rendering with relative paths Verify screenshot attachment Squint at tiny thumbnail Click to zoom full-size lightbox ## Try It Today Content search and find-replace are available in [1DevTool v1.9.1](https://1devtool.com). Next time an AI agent finishes a refactor, search your project to verify the changes before you commit. **Trust, but verify. Now you can do both without leaving your workspace.** --- ## Chat Channels: Multi-Agent Orchestration for AI Code Editors Source: https://1devtool.com/blog/multi-agent-chat-channels-orchestration Published: 2026-03-26 Tags: multi-agent, orchestration, chat-channels, productivity, agentic-coding Running multiple AI agents but manually relaying context between them? Chat Channels in 1DevTool v1.9.0 let one operator agent coordinate Claude Code, Codex, and Gemini CLI from a single conversation with @mentions, terminal locking, and built-in templates. You have three AI agents running. Claude Code is refactoring your backend. Codex is building a new React component. Gemini CLI is writing tests. They are all working at the same time, in the same project, touching overlapping files — and they have absolutely no idea the others exist. You are the message bus. You copy output from one terminal, paste context into another, and try to keep three independent conversations coherent in your head. When Agent A finishes and its output affects what Agent B should do next, you manually relay the information. This works with two agents. It falls apart at three. **Chat Channels** in 1DevTool v1.9.0 change this entirely. One conversation. Multiple agents. One operator coordinating them all. Here is how multi-agent orchestration actually works — and why it matters for every developer running AI coding agents in 2026. ## Why Multi-Agent Orchestration Matters The AI coding landscape in 2026 is fragmented by design. Claude Code excels at complex refactors. Codex is fast at focused edits. Gemini CLI handles broad codebase analysis. No single agent is best at everything, so serious developers run multiple agents — often in the same session. The problem is coordination. Without orchestration, multi-agent coding is just multiple single-agent sessions running in parallel with a human router in the middle. You lose time relaying context. You lose accuracy when agents make conflicting changes. You lose the compounding benefit that should come from specialization. True multi-agent orchestration means one place to issue instructions, one system that decides which agent handles what, and one conversation history that every participant can reference. It turns parallel isolation into coordinated teamwork. This is what Chat Channels deliver. Not a theoretical framework — a working implementation built on top of the AI terminals you already use in 1DevTool. ## How Chat Channels Work A Chat Channel is a named conversation that can talk to one or more AI terminals. You type messages in the channel. An operator agent reads your messages, decides which terminals need instructions, and sends prompts to each one. The terminals execute, and their output flows back into the channel as context for the next turn. ### Create a Channel Creating a channel takes two clicks. Open the Chat Channels panel, hit the create button, and name your channel — "Backend Refactor," "Bug Fix Sprint," or anything that describes the task. Each channel gets a unique ID and its own conversation history. You can have as many channels as you need, reorder them by dragging, and rename or delete them at any time. 1DevTool ships with **11 built-in templates** to get you started fast: Plan Review, Code Review, Fix Bug, Multi-Agent Build, and more. Templates pre-configure the channel with a system prompt and suggested agent assignments so you can start working immediately instead of setting up from scratch. ### @Mention Agents The core interaction model is `@mention`. Type `@` in the channel input and an autocomplete menu appears, triggered at word boundaries. You can mention: - **A specific terminal:** `@project/claude-code` sends the prompt to that exact terminal - **A file path:** `@src/lib/auth.ts` attaches the file as context - **All terminals:** `@all` broadcasts to every terminal in the channel - **Clipboard:** `@clipboard` inlines your clipboard content as context You can also drag and drop images directly into the channel input. Screenshots of bugs, design mockups, error logs — anything visual becomes part of the conversation context that the operator can reference when coordinating agents. ### Operator Orchestration Every channel has a configurable **operator agent**. The operator is the brain of the channel — it reads your messages, decides which terminals need instructions, formulates the right prompts, and sends them. You talk to the operator; the operator talks to the agents. Under the hood, operators are spawned as headless CLI processes using a spawn-per-message architecture. Each message turn gets a fresh process for clean context — no state leakage between turns. The operator writes prompts to the target terminals via a PromptRouter that handles timing (write text, wait 120ms, send enter) to ensure reliable delivery. You can choose which model powers your operator. Claude Code is the default and the only operator currently marked as **verified** — meaning it has been extensively tested and is production-ready. Codex, Gemini, and others are available as **experimental** operators. Each conversation loop supports up to 20 turns, giving the operator room to coordinate complex multi-step tasks. ### Terminal Locking When a channel is actively using a terminal, that terminal gets **locked**. A yellow banner appears at the top of the terminal indicating which channel owns it. This prevents you from accidentally typing into a terminal that the operator is currently controlling, and it prevents two channels from sending conflicting prompts to the same terminal simultaneously. Terminal locks are tracked in a map of terminal IDs to channel metadata. They are acquired when a channel run starts and released when the run completes or is stopped. You can always stop a channel to release its locks immediately. ### Built-in Templates Templates are pre-configured channel setups for common multi-agent workflows. The 11 built-in templates cover the most frequent patterns: - **Plan Review:** One agent drafts, another reviews and critiques - **Code Review:** Submit code for AI-powered review across multiple perspectives - **Fix Bug:** Reproduce, diagnose, and fix with coordinated agents - **Multi-Agent Build:** Split a feature across frontend, backend, and test agents Templates save you from the cold-start problem. Instead of figuring out which agents to assign and how to prompt the operator, you pick a template and start typing. You can always customize after the channel is created.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool Chat Channels interface showing multi-agent orchestration with @mention autocomplete, operator agent coordination, and terminal locking
Chat Channels in 1DevTool — one conversation orchestrating multiple AI terminals with @mentions, drag-and-drop images, and operator coordination.
## Example: Multi-Agent Bug Fix Let's walk through a real scenario. You have a bug: users are seeing a 500 error on the `/api/payments` endpoint after a recent deploy. You have three terminals open — Claude Code on the backend, Codex on the frontend, and another Claude Code instance for tests. **Step 1: Create the channel.** You open Chat Channels, select the "Fix Bug" template, and name it "Payment 500 Error." The template pre-assigns your backend Claude Code terminal as the primary agent. **Step 2: Describe the bug.** You type: `Users are getting 500 errors on POST /api/payments. Started after the last deploy. @project/claude-backend check the payments controller and recent git changes.` The operator reads your message and sends a focused prompt to the backend terminal. Claude Code runs, identifies that a recent migration changed a column name from `amount` to `total_amount` but the controller still references `amount`. It reports back through the channel. **Step 3: Coordinate the fix.** You see the diagnosis in the channel and type: `Fix the controller. @project/codex-frontend also update the frontend PaymentForm component — it sends "amount" in the payload, needs to be "total_amount."` The operator now sends two prompts simultaneously — one to the backend terminal to fix the controller, one to the frontend terminal to update the form. Both terminals lock with yellow banners. Both agents work in parallel. **Step 4: Verify.** Both agents finish. You type: `@project/claude-tests write integration tests for the payment endpoint covering the renamed field.` The test agent runs, writes the tests, and they pass. Total time: one conversation, three agents, four messages. Without Chat Channels, this same workflow would require you to manually context-switch between three terminals, copy-paste the diagnosis from one to another, and keep track of which agent is doing what. The channel held the shared context, and the operator handled the routing. ## Before vs After To make the difference concrete, here is the same multi-agent workflow with and without Chat Channels: ### Without Chat Channels 1. Open Terminal 1 (Claude Code). Type the bug description. Wait for output. 2. Read the diagnosis. Mentally note the root cause. 3. Open Terminal 2 (Codex). Retype the context plus the fix instructions. 4. Switch back to Terminal 1. Give it the fix instructions separately. 5. Alt-Tab between terminals to check progress. Repeat. 6. Open Terminal 3. Retype the context again for test generation. 7. Manually verify that all three agents' changes are consistent. You are the router, the context store, and the coordinator. Every handoff between agents requires your manual intervention. Context degrades with every copy-paste because you inevitably leave out details. ### With Chat Channels 1. Create a channel. Describe the bug once. 2. The operator sends the prompt to the right terminal. Diagnosis comes back. 3. You reply with fix instructions and @mention both terminals. Both work in parallel. 4. You @mention the test terminal. Tests are generated against the same shared context. 5. Done. One conversation. Full history. Zero copy-paste. The channel is the single source of truth. Every agent's output is visible in the same thread. The operator handles prompt routing so you write instructions in plain language instead of managing terminal windows. ## Who Benefits Most Developer Profile Without Chat Channels With Chat Channels Solo dev running 2-3 agents Manual context relay between terminals One conversation, operator handles routing Tech lead coordinating a fix Verbally describing agent output to teammates Shared channel history as documentation Indie hacker shipping features fast Sequential agent usage (one at a time) Parallel agents with coordinated output Developer learning new codebase Asking the same question in multiple terminals Ask once, @all broadcasts to every agent Agency handling multiple clients Separate terminal sessions per project Channels per task with template quick-start ## Channel Lifecycle and Management Channels are not throwaway chat windows. They have a full lifecycle that gives you control over long-running multi-agent workflows: - **Create:** Each channel gets a UUID and appears in the sidebar. Choose a template or start blank. - **Run:** When you send a message, the operator spawns as a headless process and begins coordinating. Terminals lock. - **Pause:** Pause a channel to temporarily halt the operator without killing it. Useful when you need to manually intervene in a terminal. - **Stop:** Stop kills the operator process and releases all terminal locks immediately. The conversation history is preserved. - **Resume:** Resume a paused channel to continue where you left off. You can also rename channels, reorder them by dragging in the sidebar, copy the full conversation history to your clipboard, and delete channels you no longer need. The channel list is your command center for multi-agent work. ## Security and Isolation Chat Channels communicate with terminals through a local MCP bridge — an HTTP server bound exclusively to `127.0.0.1`. No data leaves your machine through the bridge. Each operator process is spawned fresh per message turn, so there is no persistent state that could leak between conversations. Terminal locks ensure that only one channel can control a terminal at any given time, preventing prompt injection across channels. ## Bonus: Redesigned File Explorer Alongside Chat Channels, v1.9.0 ships a completely redesigned file explorer with git status indicators. Every file in the explorer now shows its git state — **M** for modified, **U** for untracked, **A** for added, **D** for deleted. When your agents are making changes across the codebase, you can see at a glance which files were touched and what kind of change was made, without running `git status` in a terminal. ## Try It Today Chat Channels and multi-agent orchestration are available now in [1DevTool v1.9.0](https://1devtool.com). Download the latest release, open a project with multiple AI terminals, and create your first channel. Start with a built-in template if you want a guided experience, or create a blank channel and @mention your way through a task. If you have been running multiple AI agents and wishing they could talk to each other — this is it. One conversation. Every agent. Full coordination. **Stop being the message bus. Let the operator handle it.** --- ## Send Code to AI: Right-Click Context Menus for Terminal and Editor Source: https://1devtool.com/blog/send-code-to-ai-terminal-context-menu Published: 2026-03-25 Tags: terminal, context-menu, productivity, agentic-coding Stop copying and pasting code between terminals. Select text in any AI terminal or code editor, right-click, and send it to another agent with file path, line numbers, and language context attached automatically. You're reading Claude Code's output in one terminal and spot a code snippet you want Codex to refactor. Or you're editing a file and want to send a function to Gemini CLI for review. In a traditional setup, you'd copy the text, switch terminals, type a prompt that includes the code, and paste. That's four steps when it should be one. 1DevTool v1.8.3 makes your **AI terminals and code editor talk to each other**. Select text, right-click, send — with full context automatically attached. ## Why Context Sharing Between Terminals Matters AI coding agents work best with context. When you paste a code snippet into Claude Code without saying where it came from, the agent has to guess the language, the file, the purpose. When you send code *with* the file path, line numbers, and language tag, the agent understands immediately and gives better answers. The problem is that building that context manually is tedious. You have to format the prompt, include the file path, add line numbers. Most developers just paste the raw code and hope for the best. 1DevTool automates the context. ## Terminal Context Menu: Right-Click to Send Select any text in an AI terminal and right-click. The context menu now includes a **Send to AI** option that lets you choose which terminal receives the selection. The selected text is wrapped with the terminal name and running command as context, so the receiving agent knows exactly where the text came from. This is especially powerful when one agent produces output that another agent needs to act on. Claude Code finds a bug? Select the error, right-click, send to Codex to fix it. Gemini CLI generates a migration? Select it, send to Claude Code to review.
{/* eslint-disable-next-line @next/next/no-img-element */} Right-click context menu in terminal showing Send to AI option with terminal targets
Select text in any AI terminal, right-click, and send it to another agent with full context.
## Send to AI from the Code Editor The same workflow works from the code editor. Select a function, a block, or even a single line in any file. Click "Send to AI" and choose which terminal receives it. 1DevTool automatically includes the file path, line numbers, and language — so the AI agent gets perfect context without you typing a single character of prompt.
{/* eslint-disable-next-line @next/next/no-img-element */} Send to AI button in file explorer with terminal selection dropdown
Send code from the editor to any AI terminal — file path, line numbers, and language included.
## Redesigned Add Terminal Dialog Adding terminals also got an overhaul. The new dialog has two tabs — **AI Agents** and **Shells** — with both grid and list views. AI agents show their icons and descriptions, making it easy to pick the right tool for the job. You can also create **custom terminal commands** with emoji icons. If you have a custom agent or a frequently-used shell script, save it as a command and it appears alongside Claude Code, Codex, and Gemini CLI in the dialog.
{/* eslint-disable-next-line @next/next/no-img-element */} Redesigned Add Terminal dialog with AI Agents tab showing grid layout
The redesigned Add Terminal dialog — AI Agents and Shells in separate tabs with grid/list views.
## Crash-Resilient Terminal Buffers Terminal output is now saved periodically in the background. If 1DevTool crashes (GPU issue, system service failure), your terminal buffers survive. When the app restarts, you see your previous terminal output instead of a blank screen. No more losing hours of AI agent output to an unexpected crash. ## Before vs After Task Before After Send code to an AI agent Copy, switch terminal, type prompt, paste Select, right-click, Send to AI Share context between agents Copy output, manually format as prompt Context auto-attached (file, line, language) Add a custom terminal command Not possible Manage Commands in settings with emoji icons Recover from a crash Terminal buffers lost Buffers restored automatically ## Try It Today Terminal context menus and Send to AI are available in [1DevTool v1.8.3](https://1devtool.com). Stop manually copying code between terminals — let your AI agents share context with one right-click. **Select. Right-click. Send. Context included.** --- ## AI Terminal Notifications & Activity Logs: Stop Polling Your Agents Source: https://1devtool.com/blog/ai-terminal-notifications-activity-logs Published: 2026-03-23 Tags: productivity, agentic-coding, notifications, workspace Running multiple AI agents but constantly Alt-Tabbing to check which ones finished? Activity logs and real-time terminal notifications eliminate the polling loop and unlock true parallel agentic workflows. You kick off Claude Code on the backend. Codex is refactoring the frontend. Gemini CLI is generating docs. You Alt-Tab to your browser to check something — and when you come back ten minutes later, you have no idea which agents finished, which are waiting for input, and which are still running. This is the hidden productivity killer of agentic coding: **you don't know when your AI agents are done.** In this post, we break down why terminal notifications and activity logs are the missing piece in multi-agent workflows, and how 1DevTool's new AI Activity Logs feature solves it. ## The Problem: AI Agents Work in Silence Traditional terminals were built for human-driven commands. You type `ls`, you get output, you type the next command. The feedback loop is instant because *you* are the one driving. AI agents are different. You give Claude Code a prompt like "refactor the authentication module to use JWT" and it works autonomously for 2, 5, maybe 15 minutes. During that time, you naturally context-switch — check Slack, review a PR, grab coffee. The problem is that when the agent finishes, nothing happens. No notification. No sound. No badge. The terminal just sits there with a blinking cursor, silently waiting for you to notice. Now multiply this by 3-4 agents across 2-3 projects. You're running: - Claude Code on the API layer - Codex CLI on the React components - Another Claude Code instance writing tests - Gemini CLI generating OpenAPI docs Without notifications, your workflow becomes a polling loop: check terminal 1, check terminal 2, check terminal 3, repeat. You're doing the computer's job — monitoring processes — instead of your own job: making decisions about what to build next. ## Why Knowing "Terminal Finished" Changes Everything This isn't a nice-to-have. Real-time terminal completion notifications fundamentally change how you work with AI agents: ### 1\. Eliminate Idle Time Between Agent Tasks The average developer using AI agents wastes 5-10 minutes per session just checking if agents have finished. Over a day of multi-agent coding, that adds up to 30-60 minutes of wasted time — not coding, not thinking, just *checking*. With instant notifications, the moment Claude Code finishes refactoring your auth module, you see it. You review the changes, approve or adjust, and immediately send the next task. Zero idle time between agent runs. ### 2\. Unlock True Parallel Workflows The promise of agentic coding is parallelism: multiple AI agents working simultaneously on different parts of your codebase. But parallelism only works if you can respond to completions quickly. Without notifications, you serialize your attention. You watch one terminal, wait for it to finish, then check the others. With notifications, you can genuinely focus on something else — writing a design doc, reviewing code, or even running a manual test — and respond to whichever agent finishes first. ### 3\. Cross-Project Awareness If you're a freelancer or indie hacker juggling multiple projects, the notification problem gets worse. You might have Claude Code running on your SaaS backend while Codex is fixing a bug on a client project. These are in different project directories, maybe different terminal windows entirely. Activity logs that work **across all projects** — not just the one you're currently looking at — mean you never miss a completion, regardless of which project you're focused on. ### 4\. Know What Your Agents Created AI agents don't just run commands — they create files. Claude Code might generate a migration file, a test suite, or a markdown document summarizing its changes. Without activity tracking, these files appear silently in your project directory, and you might not notice them for hours. An activity log that tracks file generation alongside terminal completions gives you a complete picture: "Claude Code finished on the backend project, and it generated `migration_002.sql` and `CHANGES.md`." ## What Exists Today (And Why It Falls Short) Let's look at what developers currently use to work around this problem: ### tmux / iTerm2 / Terminal.app Standard terminals have zero awareness that you're running AI agents. They don't know when a command finishes (unless you manually configure shell hooks), and they definitely don't know when an AI agent completes a task versus just pausing for input. You can set up `tmux` with custom scripts to detect idle terminals, but it's fragile and requires significant configuration. ### Cursor / Windsurf / Copilot AI-focused IDEs are built around inline completions, not agent-based workflows. Cursor has excellent AI integration, but it's designed for a single AI model working within the editor. If you're running Claude Code, Codex CLI, and Gemini CLI simultaneously in terminals, Cursor has no visibility into what those agents are doing. ### Warp Terminal Warp is the closest to solving this — it has command-level awareness and can notify on long-running command completion. But it's still a general-purpose terminal. It doesn't understand AI agent lifecycles, doesn't track generated files, and doesn't work across multiple projects in a unified view. ### DIY Shell Scripts Some developers cobble together shell scripts with `notify-send` or `osascript` to send desktop notifications when a command finishes. This works for simple cases but breaks down with AI agents that have interactive prompts, multi-step workflows, and unpredictable runtimes. ## AI Activity Logs: The Right Solution What developers actually need is a purpose-built system that understands AI agent workflows. Not a generic terminal notification, but an intelligent activity feed that knows: - When an AI agent **finishes a task** (not just when a command exits) - When an AI agent **generates a file** - Which **project** the event belongs to - How **long the agent ran** - How to **navigate directly** to the finished terminal or generated file This is exactly what we built in 1DevTool: **AI Activity Logs**.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool sending native macOS notifications when AI terminals finish — Command Finished alerts stacked in Notification Center
Native OS notifications from 1DevTool — every terminal completion surfaces instantly, even when the app is in the background.
## How 1DevTool's Activity Logs Work 1DevTool's activity log system is a unified notification feed anchored in the status bar. It replaces the "check every terminal" polling loop with an event-driven stream of AI activity across all your projects. ### Real-Time Terminal Completion Detection Unlike polling-based solutions that check terminal status every 30 seconds (and miss short runs entirely), 1DevTool detects terminal completions in real time by hooking directly into the underlying PTY (pseudo-terminal) process. The moment an AI agent finishes — whether it's Claude Code, Codex CLI, Gemini CLI, or any other CLI agent — you see it instantly. Each notification shows: - The **project name** with a color-coded dot so you know which project it belongs to - The **terminal name** (e.g., "Claude - Backend" or "Codex - Frontend") - The **elapsed time** ("Completed in 2m 34s") - A **click-to-navigate** action that switches you directly to that terminal, even if it's in a different project ### File Generation Tracking When an AI agent generates a file — a markdown doc, a SQL migration, a config file — 1DevTool detects it and adds it to the activity feed. You see exactly which agent created which file, in which project. Click the notification to open the file instantly: markdown files open in a reading mode for quick review, code files open in the editor. The file types are configurable. By default, 1DevTool watches for `.md` files (the most common AI-generated artifact), but you can add `.sql`, `.json`, `.yaml`, and other extensions in settings. ### Cross-Project by Default This is the key differentiator. 1DevTool's activity logs monitor **every project you have open**, not just the one you're currently looking at. If you're focused on Project A and a Claude Code instance finishes in Project B, the notification appears immediately. Click it, and 1DevTool switches you to Project B and focuses the exact terminal that finished. For freelancers and indie hackers managing 3-10 projects, this is transformative. You can kick off agents across multiple projects and work on whichever project needs your attention right now, confident that you won't miss a completion on any other project. ### Always Accessible, Never Intrusive The activity log trigger lives in the status bar and is always visible — even when there are no unread events. When events come in, a badge count appears. When you've cleared everything, the badge disappears but the button stays, so you can always open the history and review recent activity. Events auto-dismiss after 5 minutes (configurable), so the feed doesn't accumulate stale noise. And you can dismiss individual events or clear all at once. ## Workflow: Before vs After Activity Logs ### Before (Without Activity Logs) 1. Start Claude Code on backend, Codex on frontend, Gemini on docs 2. Switch to browser to review a PR 3. 5 minutes later: "Are my agents done?" 4. Alt-Tab to terminal app, check terminal 1 — still running 5. Check terminal 2 — finished 3 minutes ago (wasted 3 minutes) 6. Check terminal 3 — waiting for input (missed the prompt) 7. Switch back to work, repeat the polling loop in 5 minutes ### After (With 1DevTool Activity Logs) 1. Start Claude Code on backend, Codex on frontend, Gemini on docs 2. Work on whatever needs your attention 3. Badge appears: "Codex - Frontend finished (45s)" — click to review 4. Review, approve, send next task to Codex 5. Continue working 6. Badge appears: "Claude - Backend finished (2m 34s), generated CHANGES.md" 7. Click to jump to backend project, review changes, ship The difference is that you never waste time checking. You respond to completions the moment they happen, then immediately refocus on productive work. ## Who Benefits Most Developer Profile Without Activity Logs With Activity Logs Solo dev with 2-3 agents Constantly Alt-Tabbing to check terminals Instant notifications, zero polling Freelancer with 5+ projects Misses completions on background projects Cross-project feed catches everything Indie hacker shipping fast Wastes 30-60 min/day on terminal checking Redirects that time to building Team lead coordinating agents No visibility into agent status Activity history shows what happened and when ## Configuring Activity Logs in 1DevTool Activity logs work out of the box with sensible defaults, but you can customize them in Settings > Terminal > AI Activity Alerts: - **Enable/disable:** Toggle activity notifications entirely - **File types to watch:** Choose which file extensions trigger alerts ( `.md`, `.sql`, `.json`, `.yaml`, etc.) - **Auto-dismiss timeout:** How long events stay in the feed before disappearing (default: 5 minutes, set to 0 for never) The settings are accessible directly from the activity log popup footer — no hunting through menus. ## Under the Hood: Why This Is Hard to Build Detecting when an AI agent "finishes" isn't as simple as detecting when a process exits. AI agents like Claude Code are interactive — they might pause to ask for permission, wait for user input, or run multi-step tasks with gaps between steps. A naive "process exited" check would fire false positives constantly. 1DevTool solves this by hooking into the PTY layer and using agent-aware idle detection. It distinguishes between: - **Command finished:** The AI agent completed its task and returned to a prompt - **Agent idle:** The AI agent has been idle for a threshold period (10+ seconds), indicating it's done rather than just pausing between steps - **Waiting for input:** The agent is prompting the user for a decision These signals are deduplicated so you get one clean notification per completed run, not a flurry of false alarms. The same intelligence applies to file detection — 1DevTool only attributes a new file to an AI agent if that agent's terminal was recently active, preventing false positives from manual file operations. ## Beyond Notifications: The Activity-Driven Workflow Activity logs aren't just notifications — they're a new way to interact with your AI agents. Instead of organizing your work around terminals (check terminal 1, check terminal 2), you organize it around events (something finished, something was created). This is fundamentally more efficient because: - Events come to you — you don't go looking for them - Events carry context (project, terminal, elapsed time, generated files) - Events are actionable (click to navigate directly to the source) - Events work across project boundaries As agentic coding matures and developers run more agents on more projects, this event-driven model will become the standard. Terminal polling doesn't scale. Activity feeds do. ## Try It Today AI Activity Logs are available now in [1DevTool](https://1devtool.com). Download the app, open a project, run a few AI agents, and watch the activity feed light up as they finish. It's the feature you didn't know you needed — until the first time a notification saves you from a 10-minute polling cycle. **One workspace. Every agent. Every notification.** --- ## Customizable Workspace Layouts & Presets: Make 1DevTool Truly Yours Source: https://1devtool.com/blog/customizable-workspace-layouts-presets Published: 2026-03-22 Tags: workspace, layout, productivity, customization Every developer works differently. Drag panels between sidebars, save named layout presets, toggle UI elements on and off, and switch between workspace configurations with one click. Every developer works differently. Some want terminals front and center with the browser panel on the right. Others want a code editor with a narrow sidebar. When you're switching between frontend work, API debugging, and database queries throughout the day, a fixed layout slows you down. 1DevTool v1.8.1 introduces **fully customizable workspace layouts** — drag panels anywhere, save presets, and switch between configurations instantly. ## Why Layout Customization Matters AI-powered coding involves more tools running simultaneously than traditional development. You might have terminals, a browser preview, a database client, and a file explorer all visible at once. A one-size-fits-all layout forces you to constantly resize and rearrange panels. With presets, you configure each workflow once and switch with a single click. ## Drag-and-Drop Layout Settings Open Layout Settings and you see three zones: **left sidebar**, **center**, and **right sidebar**. Every panel in 1DevTool — terminals, browser, database, file explorer, git client, HTTP client, and more — can be dragged between these zones. Want the browser panel on the left instead of the right? Drag it. Want to hide the file explorer entirely? Remove it. The layout saves automatically and persists across sessions.
{/* eslint-disable-next-line @next/next/no-img-element */} Workspace layout settings showing draggable panels between left sidebar, center, and right sidebar
Drag panels between three zones to create your ideal workspace layout.
## Show or Hide Any UI Element Beyond panel placement, you can toggle individual items in the header and status bar. Don't use Docker? Hide it. Don't need the port manager in the status bar? Remove it. The controls cover Skills, Dashboard, Docker, Ports, Theme Picker, and more — so you see only what you actually use. ## Save and Manage Layout Presets Once you've arranged your workspace, save it as a **named preset**. 1DevTool includes built-in presets for common workflows, and you can create unlimited custom ones. Switching presets is instant — click the preset name and your entire workspace reconfigures. This is powerful when your work shifts throughout the day: - **Morning:** "Terminal Focus" preset — terminals maximized, browser minimized - **Afternoon:** "Web Dev" preset — browser on the right, terminals on the left - **Debugging:** "API Dev" preset — HTTP client prominent, database panel visible Each preset can be updated (save current layout over it) or deleted. Your presets persist across app restarts. ## Auto-Recovery After Crashes v1.8.1 also adds automatic crash recovery. If the app crashes due to a GPU issue or system service failure, 1DevTool detects it on restart and automatically reloads — no manual intervention required. Your layout, terminals, and workspace state are restored to where you were before the crash. ## Before vs After Task Before After Rearrange workspace Resize panels manually each time Drag panels in Layout Settings Switch between workflows Manually rearrange every panel One-click preset switching Hide unused UI elements Not possible Toggle individual header/status bar items Recover from crash Manual restart, layout lost Auto-recovery with state preserved ## Try It Today Customizable layouts and presets are available in [1DevTool v1.8.1](https://1devtool.com). Set up your workspace once, save it as a preset, and never drag a panel again. **Your workflow. Your layout. Saved and ready.** --- ## File Preview Popups, Send to AI & Drag-and-Drop Projects Source: https://1devtool.com/blog/file-preview-popup-send-to-ai Published: 2026-03-22 Tags: file-explorer, productivity, workspace, agentic-coding Preview files in floating popups instead of tabs, send selected code to AI agents with full context, drag folders from Finder to add projects, and import custom fonts. Claude Code just generated three new files. You want to glance at each one without opening them in full tabs that clutter your workspace. In VS Code, every file you peek at becomes a tab. In 1DevTool v1.8.0, files open in **floating preview popups** — draggable, resizable windows that you can dismiss with one click. ## File Preview Popups Click any file in the explorer and it opens in a floating window instead of a tab. The popup includes syntax highlighting for code files, markdown preview for .md files, and auto-save. Drag it anywhere on screen, resize it, and close it when you're done — no tab clutter. A new **File open mode** setting lets you choose between popup and traditional tab behavior, so you can use whichever fits your workflow.
{/* eslint-disable-next-line @next/next/no-img-element */} Floating file preview popup with syntax highlighting and resize handles
File preview popup — draggable, resizable, and dismissable without creating a tab.
## Send Code to AI from Preview and Editor Select any code in the file preview or markdown editor, click "Send to AI", and choose which terminal receives it. The file path, line numbers, and language are included automatically. This closes the loop between reviewing AI-generated code and sending feedback back to the agent. ## Drag-and-Drop Project Management Adding new projects is now as simple as dragging a folder from Finder onto the project sidebar. 1DevTool detects it as a project folder, adds it to your workspace, and you're ready to go. No more navigating through file dialogs. ## Custom Font Import Want your favorite coding font in 1DevTool? Browse and load .ttf, .otf, or .woff2 font files directly. Imported fonts appear in a dedicated "Imported" group in the font picker, alongside system fonts grouped by "Available" and "Not Installed". ## Other Improvements - Links in the browser panel open in new tabs instead of replacing the current page - File explorer supports copy, cut, and paste via right-click context menu - Breadcrumb dropdowns for quick navigation in the header - Markdown code blocks now use your configured terminal font - Reset appearance settings to defaults with one click ## Try It Today File preview popups and drag-and-drop projects are available in [1DevTool v1.8.0](https://1devtool.com). Preview files without the tab explosion. **Click to preview. Drag to arrange. Send to AI. Close when done.** --- ## Claude Code on Desktop vs Mobile: Where Real Development Happens Source: https://1devtool.com/blog/claude-code-desktop-vs-mobile Published: 2026-03-21 Tags: claude-code, workspace, productivity, comparison Claude Code works on mobile via Termux and SSH, but a terminal is not a workspace. We compare desktop vs mobile, explain why apps like Happy fall short, and reveal how 1DevTool Mobile will bring your full workspace to your pocket. Claude Code has exploded in popularity — and with it, a wave of developers asking the same question: **can I run Claude Code on my phone?** The short answer is yes, through terminal apps. But the real question is whether mobile is actually a productive way to use it, or if a proper desktop workspace gives you a massive edge. In this guide, we break down exactly how Claude Code works on desktop vs mobile, what you gain (and lose) on each platform, and how tools like **1DevTool** are making the desktop Claude Code experience dramatically better. ## What Is Claude Code? Claude Code is Anthropic's agentic coding tool that runs directly in your terminal. Unlike traditional AI assistants that sit inside an IDE, Claude Code operates as a CLI agent — it can read your files, write code, run commands, manage git, and execute multi-step development tasks autonomously. Because it's terminal-based, it's technically runnable on any device with a shell. That includes mobile phones via apps like Termux (Android) or iSH/a\]Shell (iOS). But "runnable" and "productive" are two very different things. ## Claude Code on Mobile: What You Get The viral trend of running Claude Code on mobile has captured developer Twitter for good reason — there's something magical about kicking off a coding task from your couch or commute. Here's what the mobile experience looks like: ### How It Works - **Android:** Install Termux, set up Node.js, and run Claude Code via npm - **iOS:** Use a-Shell or iSH to get a terminal environment, then install Claude Code - **Both:** Connect to a remote dev server via SSH and run Claude Code there ### What Mobile Does Well - **Quick prompts on the go:** Fire off a task like "fix the login bug" while away from your desk - **Code review anywhere:** Ask Claude to explain or review code from your phone - **SSH into remote machines:** If your project lives on a server, mobile works as a lightweight terminal - **The cool factor:** Let's be honest — shipping code from your phone feels futuristic ### Where Mobile Falls Short - **No file tree or visual context:** You're working blind without seeing your project structure - **Tiny screen, big problems:** Reading diffs, reviewing multi-file changes, and debugging are painful - **Single session only:** You can't run multiple Claude Code instances side by side - **No IDE integration:** No syntax highlighting, no code navigation, no extensions - **Keyboard limitations:** Even with an external keyboard, the experience is clunky - **Copy-paste friction:** Moving code between apps on mobile is tedious ## Claude Code on Desktop: The Full Experience Desktop is where Claude Code was designed to shine. A proper terminal on macOS, Linux, or Windows gives you the full power of the CLI agent with none of the mobile compromises. ### Desktop Advantages - **Full terminal power:** Multiple tabs, split panes, command history, and proper key bindings - **Run multiple sessions:** Work on different tasks in parallel across multiple Claude Code instances - **IDE alongside:** Have your editor open next to the terminal to see changes in real time - **File system access:** Browse, search, and navigate your entire codebase - **Git integration:** Full git workflow — branches, diffs, merges — right alongside Claude Code - **Copy-paste and editing:** Seamless text manipulation between terminal and other tools ### Desktop Pain Points (Without the Right Tool) Even on desktop, running Claude Code in a plain terminal has friction: - Switching between terminal and IDE constantly - [Managing multiple](https://servercompass.app/docs/manage-multiple-servers) terminal windows or tmux sessions - No unified view of what Claude Code is doing across your project - Context switching between Claude Code output, your editor, and your browser ## Desktop vs Mobile: Side-by-Side Comparison Feature Mobile Desktop Run Claude Code Yes (via Termux/SSH) Yes (native terminal) Multiple sessions Difficult Easy — tabs, splits, windows File browsing CLI only Full GUI + CLI Code review Basic (small screen) Full diff view Multi-file editing Painful Seamless Debugging Very limited Full debugger access Git workflow Basic commands Full GUI + CLI Database access CLI only GUI clients available Screen real estate 6" phone screen Full monitor(s) Portability Always with you Desk-bound ## 1DevTool: The Best Desktop Workspace for Claude Code This is where **1DevTool** changes the game. Instead of juggling a terminal, an IDE, a database client, and an HTTP tool — 1DevTool puts everything in one window with Claude Code at the center. ### Why Developers Choose 1DevTool for Claude Code - **Multiple Claude Code sessions:** Run several Claude Code instances side by side in integrated terminals. Work on the frontend in one session while Claude fixes the API in another. - **Built-in code editor:** See your files update in real time as Claude Code makes changes — no need to switch to a separate IDE. - **Integrated database client:** Query your database right next to your terminal. When Claude Code modifies a migration, verify it instantly. - **HTTP client:** Test your API endpoints without leaving the workspace. Claude Code fixes a route? Hit it immediately to verify. - **Git integration:** Visual diff viewer, branch management, and commit history — all in the same window where Claude Code is running. - **AI-powered everything:** Beyond Claude Code in the terminal, 1DevTool adds AI assistance to the editor, database queries, and API testing. ### The 1DevTool + Claude Code Workflow Here's what a typical development session looks like: 1. **Open 1DevTool** — your project loads with editor, terminal, and tools ready 2. **Launch Claude Code** in the integrated terminal — "Add user authentication with JWT" 3. **Watch the editor** update in real time as Claude Code writes files 4. **Test the API** with the built-in HTTP client 5. **Check the database** to verify the migration ran correctly 6. **Review the diff** in the integrated git panel 7. **Commit and push** — all without leaving 1DevTool This is the workflow that mobile simply cannot replicate. And it's the workflow that a plain terminal + separate IDE can only approximate with constant context switching. ## Coming Soon: 1DevTool Mobile — A Workspace, Not Just a Terminal Here's the thing about running Claude Code on your phone today: apps like Happy give you a terminal. That's it. A single terminal window on a small screen. It works for quick prompts, but it's fundamentally the same limited experience as SSHing from Termux. **1DevTool Mobile** is coming soon — and it's a completely different product. Instead of giving you a terminal, it gives you your entire workspace in your pocket. ### What Makes 1DevTool Mobile Different - **See all your projects at once:** Monitor 5-6 projects simultaneously — not just one terminal session. See what every agent is doing across your entire workload. - **Monaco diff viewer on mobile:** Review the actual code changes your agents made with a proper diff view — syntax highlighted, side-by-side — not raw terminal output. - **Approve or reject across multiple agents:** Your agents are waiting for permission? Approve or reject changes across all of them in one swipe. No switching between terminal sessions. - **HTTP client logs:** See exactly what API calls your agents are making. When Claude Code hits an endpoint, you see the request and response in real time. - **Git status across all projects:** One glance shows you the git state of every project — which branches changed, what's staged, what's committed. - **Skills Manager:** Push new instructions to running agents from your phone. Change priorities, add context, or redirect an agent's work without stopping it. - **Full tmux session tree:** Not one terminal — the entire session tree. Navigate between panes, see output from every session, all from your mobile screen. **The difference is simple:** other mobile apps show you a terminal. 1DevTool Mobile shows you a workspace. It's the difference between peeking through a keyhole and opening the door. ## When Mobile Actually Makes Sense (Today) Until 1DevTool Mobile launches, there are still legitimate reasons to use Claude Code on your phone: - **Emergency hotfixes:** Production is down, you're away from your desk. SSH in, run Claude Code, fix the critical bug. - **Quick code review:** Someone tags you on a PR. Pull up Claude Code to get a quick AI-powered review. - **Monitoring long-running tasks:** Kicked off a big refactor from desktop? Check progress from your phone. - **Learning and experimentation:** Exploring Claude Code's capabilities during downtime. But for anything beyond quick checks — managing multiple agents, reviewing diffs, coordinating across projects — you're going to want 1DevTool Mobile. ## Setting Up Claude Code on Desktop (The Right Way) If you're ready to get the most out of Claude Code today, here's the optimal setup: ### Basic Setup 1. Install Node.js 18+ on your machine 2. Run `npm install -g @anthropic-ai/claude-code` 3. Set your Anthropic API key: `export ANTHROPIC_API_KEY=your-key` 4. Navigate to your project directory and run `claude` ### Optimal Setup with 1DevTool 1. Download **1DevTool** from [1devtool.com](https://1devtool.com) 2. Open your project — editor, terminal, and tools load automatically 3. Run `claude` in the integrated terminal 4. Split terminals to run multiple Claude Code sessions 5. Use the database client, HTTP client, and git tools alongside Claude Code ## The Future: Desktop Power, Mobile Control The future of Claude Code isn't desktop *or* mobile — it's both. Your heavy development happens on desktop with 1DevTool's full workspace. Then you step away, and 1DevTool Mobile keeps you connected to everything — approving changes, monitoring agents, reviewing diffs, pushing new instructions. This is the workflow that agentic coding demands. Your AI agents don't stop working when you leave your desk. With 1DevTool on desktop and mobile, neither do you. ## The Verdict **Terminal-only mobile apps** like Happy give you a keyhole view of one session. **Desktop Claude Code** is where real development happens. And **1DevTool** is the best way to run Claude Code on both — a full workspace on desktop today, and a full workspace on mobile coming soon. Other mobile apps show you a terminal. 1DevTool Mobile will show you everything. **Ready to supercharge your Claude Code workflow?** [Download 1DevTool](https://1devtool.com) for desktop now and be the first to know when 1DevTool Mobile launches. --- **Related in the StoicSoft network** If you regularly stitch together PDF, image, video, or batch-file workflows like the ones above, [1FileTool](https://1filetool.com) is the StoicSoft network's purpose-built desktop app — 245+ local-first tools, pay-once, files never leave the device. --- ## AI Skills Manager & Docker Deep Dive: Extend Your Agents, Monitor Your Containers Source: https://1devtool.com/blog/ai-skills-manager-docker-deep-dive Published: 2026-03-19 Tags: skills, docker, security, productivity Browse, create, and install AI agent skills with built-in security scanning. Plus a redesigned Docker manager with live CPU, memory, and network monitoring for every container. AI coding agents are powerful out of the box, but they become *much* more powerful with skills — reusable prompt templates that encode domain knowledge, workflows, and guardrails. The problem is managing them. Skills live in scattered markdown files, there's no way to browse what's available, and no way to check if a skill from the internet is safe to run. 1DevTool v1.7.0 introduces the **Skills Manager** — a full browser and editor for AI agent skills with built-in security scanning — plus a completely redesigned **Docker Manager** with live [resource monitoring](https://servercompass.app/features/resource-monitoring). ## AI Skills Manager ### Browse, Create, and Organize Skills The Skills Manager shows all skills in your project organized by category, tool, and collection. Each skill appears as a card with its name, description, and which AI agent it's designed for — Claude Code, Codex, Gemini, Amp, or any custom agent. Create new skills directly in the built-in Monaco editor with syntax highlighting and distraction-free reader mode. Organize skills with collections, favorites, and filter by tool. ### Built-in Security Scanning Every skill — whether you created it or installed it from the community — is automatically scanned for risky patterns. The scanner checks for file system operations, network access, shell commands, and other potentially dangerous instructions. Each skill gets a color-coded risk badge so you can see at a glance whether it's safe to run. This is critical for teams where developers share skills. You don't want a well-meaning skill that happens to include `rm -rf` in a cleanup step. ### Install from Community Registry Browse skills from the community remote registry and install them directly into your project. Preview remote skills in a live embedded browser before installing. You can review the skill content, edit it, or choose which project to install it in.
{/* eslint-disable-next-line @next/next/no-img-element */} AI Skills Manager showing skill cards with security risk badges and category organization
Skills Manager with security scanning, category organization, and community registry.
## Docker Manager: Complete Container Control ### Container Detail Panel The redesigned Docker Manager gives you deep visibility into every container. Click any container to see logs, [environment variables](https://servercompass.app/features/env-vars-editor), resource stats, and raw inspect data. Logs stream live and you can filter them by timestamp or content. ### Live Resource Monitoring Visual gauges show CPU, memory, and network usage for each container in real time. No more switching to `docker stats` in a terminal — the dashboard shows resource consumption at a glance. ### Image and Volume Management Browse Docker images with detail panels, manage volumes, and inspect JSON data with a collapsible tree viewer. Everything you'd normally do in the Docker CLI is available in the GUI. ## Performance Improvements - Global shortcuts no longer cause micro-stutters - Editor auto-save fires exactly 1 second after you stop typing - Terminal scrollback buffer reduced from 5,000 to 3,000 lines for lower memory - File system checks cut by 60% for less CPU usage - Fewer unnecessary redraws across file explorer, terminal, and editor ## Before vs After Task Before After Find a skill for your agent Search GitHub, copy markdown files Browse and install from the registry Check if a skill is safe Read the entire file manually Color-coded security risk badge Check Docker [container logs](https://servercompass.app/docs/viewing-container-logs) Run docker logs in terminal Live streaming logs in detail panel Monitor container resources docker stats in terminal Visual CPU/memory/network gauges ## Try It Today The Skills Manager and Docker deep dive are available in [1DevTool v1.7.0](https://1devtool.com). Manage your AI skills with security scanning, and monitor your containers without leaving your workspace. **Skills for your agents. Visibility for your containers. Security for both.** --- ## Import VS Code Themes & Resume AI Sessions in 1DevTool Source: https://1devtool.com/blog/vscode-theme-import-resume-ai-sessions Published: 2026-03-19 Tags: themes, session-resume, productivity, customization Bring your favorite VS Code theme into 1DevTool with one click, and resume past AI conversations across Claude Code, Codex, Gemini CLI, and Amp — even combine multiple sessions. Two common complaints when switching to a new code editor: "I miss my theme" and "I lost my AI conversation." v1.7.2 fixes both. Import your favorite VS Code theme with one click, and resume past AI conversations across Claude Code, Codex, Gemini CLI, and Amp. ## Import VS Code Themes If you've spent time customizing your VS Code color scheme — or you rely on popular themes like Dracula, One Dark Pro, or Catppuccin — you can now bring them directly into 1DevTool. Select any VS Code `.json` theme file and preview it live before applying. The theme maps VS Code color tokens to 1DevTool's UI, including the editor, terminal, sidebar, and status bar. A new **theme picker in the status bar** lets you quick-switch between themes. Themes are grouped by Dark and Light with color swatches, so you can pick at a glance. Hover over any imported theme in Settings to delete it.
{/* eslint-disable-next-line @next/next/no-img-element */} VS Code theme import dialog with live preview and theme picker in status bar
Import VS Code themes with live preview — Dracula, One Dark Pro, Catppuccin, or any custom theme.
## Resume Past AI Conversations AI conversations contain valuable context — debugging sessions, architecture discussions, multi-step refactors. Losing that context when a terminal closes means re-explaining everything from scratch. The new **Resume panel** lets you browse, search, and continue previous sessions across all AI agents. Every conversation is listed with the first prompt, timestamp, and agent type. Click Resume to continue exactly where you left off with the correct agent-specific resume command. ### Combine Multiple Sessions Sometimes the context you need is split across several past conversations. Select multiple sessions and merge them into a single new conversation. This is powerful when you're picking up a multi-day task — combine Monday's architecture session with Tuesday's implementation session and continue on Wednesday with full context. ## Agent Input Improvements - **Clear All** (Cmd+Shift+Backspace) — clears text, images, and file attachments at once - **Smarter clipboard paste** — pasted text summaries resolve automatically - **Natural scrolling** — textareas and scrollable areas scroll correctly - **Configurable Clear All shortcut** in Settings > Terminal ## Before vs After Task Before After Use your VS Code theme Manually recreate colors Import .json file, preview live, apply Switch themes quickly Open Settings, scroll to themes Click theme picker in status bar Resume a past AI conversation Copy session ID, manually run resume command Browse, search, click Resume Combine context from multiple sessions Not possible Select multiple sessions, merge into one ## Try It Today VS Code theme import and AI session resume are available in [1DevTool v1.7.2](https://1devtool.com). Bring your theme. Keep your conversations. **Your colors. Your conversations. Nothing lost in the switch.** --- **Related in the StoicSoft network** If you regularly stitch together PDF, image, video, or batch-file workflows like the ones above, [1FileTool](https://1filetool.com) is the StoicSoft network's purpose-built desktop app — 245+ local-first tools, pay-once, files never leave the device. --- ## 1DevTool v1.6.0: AI Design Tool, 13+ Database Engines, Mermaid Diagrams, and Send-to-AI Debugging Source: https://1devtool.com/blog/ai-design-tool-database-client-mermaid Published: 2026-03-18 Tags: release, design-tool, database, mermaid, ai, productivity The biggest 1DevTool release yet — a full visual design tool with AI generation, a database client for 13+ engines, Mermaid diagram rendering, and one-click Send-to-AI debugging. 18 features that replace Figma, DBeaver, and Postman in a single AI-powered workspace. How many apps do you have open right now? If you're like most developers, the answer is painful: Figma for mockups, DBeaver or pgAdmin for databases, Postman for APIs, a terminal for Claude Code, and maybe another terminal for Docker. Five apps, five contexts, five mental models. Every Alt-Tab is a context switch, and every context switch costs you time and focus. What if your **AI code editor** could replace all of them? 1DevTool v1.6.0 is the biggest release we've ever shipped. It adds a full visual design tool with AI generation, a database client supporting 13+ engines, Mermaid diagram rendering, Send-to-AI debugging for database errors, and a dozen more features that turn 1DevTool into a true all-in-one **AI-powered development workspace**. This is not an incremental update — it's a category expansion. ## One Workspace for Everything The premise behind 1DevTool has always been simple: **developers should not need ten apps to do one job.** Your code editor, your terminal, your AI assistant, your database client, your design tool, your API tester, and your diagram viewer should all live in the same workspace — sharing context, sharing intelligence, and sharing a single keyboard shortcut away from each other. With v1.6.0, that vision takes a massive leap forward. Here's what 18 new features look like when they all ship at once. ## AI-Powered Visual Design Tool The headline feature of v1.6.0 is a built-in design tool that lets you create UI mockups and high-fidelity prototypes without leaving your code editor. This is not a stripped-down wireframing widget — it's a full canvas-based design surface with 21 placeable components, AI generation, device previews, and MCP integration that lets your AI agents design alongside you.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool visual design tool canvas showing UI components placed on an 8px grid with device preview controls
The design tool canvas with component palette, grid snapping, and device preview controls.
### Component Canvas The canvas supports **21 component types** that cover the building blocks of any modern UI: Container, Separator, Heading, Paragraph, Link, TextInput, Checkbox, Select, Toggle, Button (with primary, secondary, ghost, and danger variants), Navbar, TabBar, Breadcrumb, Table, List, Card, Alert (info, success, warning, error), ProgressBar, Image, Icon, and Avatar. Components snap to an **8px grid** for consistent spacing. The canvas supports zoom from 0.25x to 3x, marquee selection for grabbing multiple elements at once, and resize handles on all four corners of every component. You get undo/redo with a 50-item history stack, so experimentation is risk-free. ### AI Generation via MCP Here's where the design tool becomes uniquely powerful inside an **AI coding workspace**. The design tool exposes an MCP (Model Context Protocol) server with 11 tools that let your AI agents interact with the canvas directly. Your AI can call `add_component` to place elements, `create_screen` to generate entire screens, `get_canvas_state` to read the current layout, and `set_design_mode` to switch between mockup and fidelity rendering. The `search_design_knowledge` tool is particularly powerful — it gives your AI access to a built-in library of **50 design styles, 161 color palettes, 57 font pairings, and 99 UX guidelines**. Ask Claude Code to "design a dashboard for a fintech app" and it doesn't just guess — it queries the knowledge base for appropriate color palettes, typography, and layout patterns before placing a single component. ### Device Preview The canvas includes **device presets** for Mobile (375x812), Tablet (768x1024), Desktop (1366x768), and Custom dimensions. Toggle between them to see how your design responds at different breakpoints. You can also create multiple screens using the tab system and switch between them — designing a full multi-screen flow without leaving the editor. Two rendering modes — **Mockup** and **Fidelity** — let you switch between low-fi wireframe aesthetics (great for early ideation and stakeholder reviews) and high-fi pixel-perfect rendering (great for developer handoff and final approval). ## Database Client for 13+ Engines The second major pillar of v1.6.0 is a [built-in database](https://servercompass.app/blog/database-admin-panel-vps) client that connects to virtually every database you'd encounter in modern development. No more switching to DBeaver, pgAdmin, MongoDB Compass, or RedisInsight. Query your data where you write your code.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool database engine selection grid showing PostgreSQL, MySQL, MongoDB, Redis, ClickHouse, Elasticsearch, and more
Choose from 13+ database engines — relational, document, key-value, time-series, vector, and streaming.
### Connect to Anything The database client supports **16+ engines** across every major category: - **Relational:** PostgreSQL (plus CockroachDB, Redshift, TimescaleDB, Neon, Hydra, and Supabase compatibility), MySQL/MariaDB, and Microsoft SQL Server - **Columnar/Analytics:** ClickHouse - **Document:** MongoDB, CouchDB, SurrealDB - **Key-Value:** Redis, Valkey, KeyDB - **Search:** Elasticsearch - **Vector:** Weaviate - **Time-Series:** InfluxDB - **Streaming:** Kafka - **Wide-Column:** Cassandra Each engine uses its native connection protocol — no ODBC wrappers or generic adapters. You get the full capabilities of each database, not a lowest-common-denominator abstraction. ### Smart Query Editors This is where most database clients fall flat. They give you a SQL editor for everything, even databases that don't speak SQL. 1DevTool provides **engine-specific query editors** that match how each database actually works: - **MongoDB** gets a JSON-based query editor for aggregation pipelines and find operations - **Redis** gets a command editor that understands Redis commands and data types - **Elasticsearch** gets a DSL editor for search queries and aggregations - **SurrealDB** gets a SurrealQL editor with syntax highlighting - **Cassandra** gets a CQL editor - **InfluxDB** gets a Flux query editor Results render in **specialized viewers** that understand the structure of each engine's output. MongoDB documents display as expandable JSON trees. Redis keys show their types and TTLs. Elasticsearch hits display relevance scores. You can also **export results as CSV, JSON, or NDJSON** and import data in those same formats. ### Send Errors to AI This is the feature that makes the database client feel like it belongs in an **AI-powered IDE** rather than being bolted onto one. When a query fails or returns unexpected results, you can **send the query, the error message, and the schema context directly to your AI terminal** with one click.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool sending a database error to AI terminal for debugging — query context and error message forwarded to Claude Code
One click sends your failed query and error to the AI terminal — no copy-pasting error messages.
Instead of copying the error, switching to a browser, pasting it into ChatGPT, and losing all context, you press one button and Claude Code (or whichever AI agent you're running) sees the full picture: the query, the error, the engine type, and the table schema. It can diagnose the issue, suggest a fix, and even run the corrected query — all within the same workspace. This same Send-to-AI flow works for HTTP responses from the API tester, making debugging truly seamless. ## Mermaid Diagrams & More v1.6.0 adds native **Mermaid diagram rendering** inside the editor. Flowcharts, sequence diagrams, entity-relationship diagrams, Gantt charts, class diagrams — if Mermaid can render it, 1DevTool can display it. This is particularly powerful for AI agents that generate architecture diagrams or data flow charts as part of their output. Instead of copying the Mermaid syntax into a browser tool, it renders inline. But Mermaid is just one of a wave of quality-of-life improvements in this release: - **Drag-and-drop images** into the editor with automatic persistence — images are stored locally and survive restarts - **Multiple browser tabs** — the built-in browser now supports tabbed browsing, so you can keep your localhost preview, docs, and API reference open simultaneously - **Notification bell** with a unified activity feed for terminal completions, file generations, and system events - **Kanban terminal dashboard** — a board view for your terminal sessions that shows agent status at a glance - **Environment variable manager** — view, edit, and switch environment configurations without touching `.env` files directly
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool terminal layout dashboard with kanban-style agent monitoring showing running and completed terminals
The kanban terminal dashboard — see all your AI agents and terminal sessions at a glance.
{/* eslint-disable-next-line @next/next/no-img-element */} 1DevTool built-in browser with multiple tabs open showing localhost preview and documentation side by side
Multi-tab browser — keep localhost, docs, and API references open in parallel without leaving the editor.
## Who Benefits Most v1.6.0 is a broad release that touches almost every part of the development workflow. Here's a breakdown of which features matter most for different developer profiles: Developer Profile Key v1.6.0 Features What Changes Full-stack solo developer Design tool + DB client + Send-to-AI Drop Figma, DBeaver, and Postman from your workflow entirely Backend / data engineer 13+ DB engines + engine-specific editors + CSV/JSON export Query Postgres, Mongo, Redis, and Kafka from one interface Frontend developer Design tool + AI generation + device preview + multi-tab browser Prototype UI and preview responsive layouts without context-switching Indie hacker shipping fast AI design via MCP + Send-to-AI debugging + kanban dashboard AI designs your UI while you build the backend — true parallel work Team lead / architect Mermaid diagrams + design tool + env manager Document architecture visually and manage configs in one place DevOps / SRE 16+ DB connections + Kafka + InfluxDB + env manager Monitor time-series data and streaming systems alongside your code ## The Full v1.6.0 Changelog For completeness, here are all 18 features and improvements in this release: 1. Visual design tool with 21 component types and canvas controls 2. AI design generation via MCP server (11 tools, design knowledge base) 3. Screen tabs for multi-screen design workflows 4. MCP integration for external AI agents to control the design canvas 5. 13+ database engine connections (PostgreSQL, MySQL, MongoDB, Redis, and more) 6. Engine-specific query editors (MongoDB JSON, Redis commands, Elasticsearch DSL, SurrealQL, CQL, Flux) 7. Specialized result viewers per engine 8. CSV, JSON, and NDJSON import/export for database results 9. Mermaid diagram rendering 10. Send database results and errors to AI terminal 11. Send HTTP responses to AI terminal 12. Drag-and-drop image support with persistence 13. Image persistence across restarts 14. Multiple browser tabs 15. Notification bell with unified activity feed 16. Kanban terminal dashboard 17. Environment variable manager 18. Performance and stability improvements ## Try It Today 1DevTool v1.6.0 is available now. Download it from [1devtool.com](https://1devtool.com), open a project, and explore what happens when your design tool, database client, diagram renderer, and AI terminal all live in the same workspace. The **AI code editor** category is evolving fast. Cursor and Windsurf made AI completions mainstream. GitHub Copilot brought AI to the masses. But the next frontier is not better autocomplete — it's **fewer apps**. It's giving developers a single workspace that understands code, design, data, APIs, and infrastructure. v1.6.0 is a major step in that direction. **One workspace. Design, query, diagram, debug — all with AI.** --- ## Device Emulation, Image Viewer & Crop Tool: Preview AI-Generated UIs on Any Screen Source: https://1devtool.com/blog/device-emulation-image-viewer-crop-tool Published: 2026-03-16 Tags: browser, device-emulation, productivity, screenshots Preview responsive layouts on iPhone, iPad, and custom sizes in the built-in browser. Crop screenshots with rule-of-thirds guides and send annotated images to your AI agent. You ask Claude Code to build a responsive landing page. It generates the HTML and CSS, but you need to check how it looks on an iPhone, an iPad, and a desktop — without leaving your editor. You also want to screenshot the result, crop it, and send it back to the agent for adjustments. Previously, that meant Chrome DevTools, a screenshot tool, and an image editor. Now it's all built in. ## Device Emulation in the Built-in Browser The embedded browser now supports device emulation. Preview your site on iPhone, iPad, Samsung Galaxy, or any custom screen size with one click. Rotate between portrait and landscape, and zoom in or out with Cmd+Plus/Minus. This is especially valuable for AI-assisted web development. Your agent generates responsive code, and you verify it across devices without opening Chrome or Safari DevTools.
{/* eslint-disable-next-line @next/next/no-img-element */} Device emulation showing a website preview on iPhone and iPad side by side
Preview responsive layouts on iPhone, iPad, Samsung Galaxy, or custom sizes.
## Built-in Image Viewer Click any image file in the file explorer and see it rendered with zoom controls and a transparency checkerboard background. No more opening images in Preview or Finder — inspect AI-generated assets right where you work. ## Screenshot Crop Tool Take a screenshot of the browser panel, then crop it with rule-of-thirds guides. The crop tool remembers your preferences. This workflow is designed for the AI feedback loop: screenshot the result, crop the relevant area, and drag it into the agent input overlay to say "fix this part."
{/* eslint-disable-next-line @next/next/no-img-element */} Screenshot crop tool with rule-of-thirds overlay guides
Crop screenshots with rule-of-thirds guides for precise visual feedback.
## Searchable Settings 1DevTool has a lot of settings. Finding the right one used to mean scrolling through tabs. Now you can type to filter across all settings tabs with keyboard navigation. Start typing "font" and see every font-related setting instantly. ## AI Run Timer Terminal tabs now display elapsed time while an AI agent is processing. You can see at a glance that Claude Code has been running for 2 minutes and 34 seconds — useful for knowing when to check back versus when to wait. ## Other Features in v1.5.0 - Drag-and-drop reordering for terminal tabs and sidebar projects - Resizable canvas cards for terminal layout - Smarter auto-scroll that only scrolls when at bottom - Live file tree updates from AI agents, git, or external editors - New shortcuts: Cmd+Shift+H to hide terminal, Cmd+Shift+X for browser screenshot ## Try It Today Device emulation, image viewer, and crop tools are available in [1DevTool v1.5.0](https://1devtool.com). Preview on any device, crop for feedback, and send it back to your AI agent — all without leaving your workspace. **Preview. Crop. Send to AI. Iterate.** --- ## Canvas Layout, Prompt History & AI File Detection Source: https://1devtool.com/blog/canvas-layout-prompt-history-ai-file-detection Published: 2026-03-15 Tags: canvas, prompt-history, productivity, agentic-coding Drag terminals anywhere on a freeform canvas, browse every prompt you have sent to AI agents, and get notified when agents create files. Grid layouts and tab bars work for two or three terminals. But when you're running six AI agents across different tasks — a refactor here, tests there, docs on the side — you want to arrange them spatially, like sticky notes on a whiteboard. v1.4.0 introduces a **freeform canvas layout** where you drag terminals anywhere, plus **prompt history** to revisit every prompt you've sent to AI agents. ## Freeform Canvas Layout Drag terminals anywhere on an infinite canvas with full zoom and pan support. Position related terminals near each other — put your Claude Code backend terminal next to its test terminal, and your frontend Codex terminal in a separate cluster. The spatial arrangement gives you a visual map of your entire workflow.
{/* eslint-disable-next-line @next/next/no-img-element */} Freeform canvas layout with terminals arranged spatially on an infinite canvas
Drag terminals anywhere on the canvas — zoom and pan to navigate.
### Vertical Tabs Layout Not everyone wants a freeform canvas. v1.4.0 also adds a **vertical tabs layout** with side-by-side tabs and full-height terminals. Useful when you want two terminals visible simultaneously without the overhead of canvas positioning. ## Prompt History: Every Prompt, Searchable Ever sent a great prompt to Claude Code last week and can't remember the exact wording? Prompt history saves every prompt sent to every AI agent. Browse them in a searchable list, filter by project, agent, or date, and reuse any prompt with one click.
{/* eslint-disable-next-line @next/next/no-img-element */} Prompt history panel showing all prompts sent to AI agents with search and filters
Browse, search, and reuse every prompt sent to your AI agents.
## AI File Detection When an AI agent creates a markdown file — a CHANGES.md, a README update, or a design doc — 1DevTool detects it and notifies you. Click the notification to open the file in a clean reading mode. You never have to wonder "did Claude generate something?" — the notification tells you exactly what was created and where. ## Try It Today Canvas layout, prompt history, and AI file detection are available in [1DevTool v1.4.0](https://1devtool.com). Arrange your agents spatially, revisit any prompt, and never miss a file your AI creates. **Your agents. Your canvas. Your prompt history.** --- ## Agent Input Overlay & Tmux Integration: The Proper Way to Prompt AI Agents Source: https://1devtool.com/blog/agent-input-overlay-tmux-integration Published: 2026-03-14 Tags: terminal, agent-input, tmux, productivity Press Cmd+I to open a rich prompt editor with @file mentions, image drag-and-drop, markdown preview, and formatting — all without leaving the terminal. Plus tmux-backed persistent terminals. Typing prompts directly into an AI terminal feels wrong. You're sending multi-line prompts with file references, code snippets, and images — but the terminal input is a single-line box designed for shell commands. You need a proper input surface. v1.1.2 introduces the **Agent Input Overlay** — press Cmd+I to open a full-featured prompt editor without leaving the terminal. ## Agent Input Overlay (Cmd+I) Press Cmd+I on any AI terminal and an overlay appears with a rich text area. Write multi-line prompts with formatting (bold, italic, code blocks), @mention files with fuzzy search, drag and drop files and images, and preview your prompt in live markdown before sending. The overlay doesn't replace the terminal — it floats above it. You can still see the terminal output underneath, reference it in your prompt, and dismiss the overlay when you're done. ### @Mention Files with Fuzzy Search Type `@` in the overlay and a fuzzy file search appears. Select any file in your project and its path is included as context for the AI agent. This is how you tell Claude Code "look at this specific file" without manually copying the file path. ### Drag, Drop, and Paste Images Drag images from Finder, paste screenshots from the clipboard, or drop files directly into the overlay. Images appear as thumbnails you can verify before sending. This is essential for visual feedback — screenshot a UI bug, paste it into the overlay, describe the fix, send. ## Tmux Integration: Persistent Terminals Terminals in 1DevTool are backed by tmux, which means they survive app crashes and restarts. v1.1.2 adds one-click tmux installation with a live progress indicator. If tmux isn't installed, 1DevTool prompts you to install it and handles the setup automatically. ## React Component Inspector The embedded browser now includes a React component inspector. Click any element on the page to see its component name, props, and position in the component tree. Useful when an AI agent generates React code and you want to verify the component structure. ## Try It Today The Agent Input Overlay is available in [1DevTool v1.1.2](https://1devtool.com). Press Cmd+I, write your prompt with @mentions and images, preview it, and send — all without leaving your terminal. **Cmd+I. Write. @Mention. Send. Stay in the flow.** --- ## Content Search, Rows Layout & Markdown Reading Mode Source: https://1devtool.com/blog/content-search-rows-layout-markdown-reading Published: 2026-03-14 Tags: search, layout, markdown, productivity Search text inside files with ripgrep, stack terminals vertically with the rows layout, and read AI-generated markdown in a distraction-free view with multiple themes. A week into using AI coding agents, you realize you need three things your workspace doesn't have: a way to search *inside* files (not just filenames), a terminal layout that stacks vertically, and a clean way to read the markdown files your AI agents keep generating. v1.3.0 delivers all three. ## Content Search with Ripgrep Search text inside files across your entire project, powered by ripgrep. Results appear with line previews and match counts per file. Click any result to jump to the exact line. This is the foundation for the find-and-replace feature that arrives in v1.9.1 — but even as search-only, it's invaluable for verifying AI agent changes across large codebases. ## Rows Layout: Vertical Terminal Stacking The new rows layout stacks terminals vertically with resizable heights. This is ideal when you want to see two or three terminals at once — one running Claude Code at the top, one with Codex in the middle, and a Bash shell at the bottom. Each row is independently resizable. ## Markdown Reading Mode AI agents generate a lot of markdown — changelogs, design docs, code explanations. The new reading mode strips away the editor chrome and presents markdown in a distraction-free view with your choice of background: sepia, white, dark, or green. It's like reader mode in Safari, but for AI-generated documents. ## Screenshot Annotator Take a screenshot of the browser panel and annotate it with circles, rectangles, and text labels before sending it to an AI agent. This is essential for visual feedback — circle the button that's misaligned, draw a box around the section that needs rewriting, and send the annotated image to Claude Code with your fix request. ## Other Features - Toggle hidden files and gitignore visibility in the file explorer - Custom names for preset agent terminals - Auto-save agent input drafts with restore on reopen - Auto-retry terminal reconnection with exponential backoff - Terminal scroll position preserved during resize - Editor file tabs scroll horizontally on overflow ## Try It Today Content search, rows layout, and markdown reading mode are available in [1DevTool v1.3.0](https://1devtool.com). Search your code, stack your terminals, and read your docs — all in one workspace. **Search. Stack. Read. All in one place.** --- ## Best AI Code Editors in 2026: Complete Guide Source: https://1devtool.com/blog/best-ai-code-editors-2026 Published: 2026-03-13 Tags: ai-editor, comparison, ide Compare the top AI-powered code editors of 2026 including Cursor, Windsurf, 1DevTool, and more. Find the perfect AI IDE for your development workflow. The landscape of code editors has transformed dramatically with AI integration. In 2026, developers have more choices than ever for AI-powered development environments. This guide compares the best AI code editors to help you find the perfect tool for your workflow. ## What Makes a Great AI Code Editor? Before diving into specific tools, let's understand what separates good AI editors from great ones: - **AI Model Quality:** Access to capable models like Claude, GPT-4, or specialized coding models - **Context Awareness:** Understanding your entire codebase, not just the current file - **Speed:** Fast completions that don't interrupt your flow - **Integration:** Seamless fit with your existing tools and workflows - **Customization:** Ability to tune AI behavior to your preferences ## Top AI Code Editors in 2026 ### 1\. Cursor Cursor has established itself as a leading AI-native IDE built on VS Code. It offers deep AI integration with features like Composer for multi-file editing and Chat for code explanations. - Built on VS Code (familiar interface) - Composer for AI-assisted multi-file edits - Claude and GPT-4 integration - $20/month Pro plan ### 2\. Windsurf (Codeium) Windsurf, powered by Codeium, offers a polished AI coding experience with their proprietary AI models optimized for code completion. The free tier is generous, making it accessible to all developers. - Free tier with substantial features - Fast, optimized completions - Cascade AI for multi-step tasks - Cross-IDE availability ### 3\. 1DevTool 1DevTool takes a unique approach by combining AI coding assistance with an integrated development workspace. It includes terminals, database client, HTTP client, and Git integration—all with AI capabilities built in. - All-in-one developer workspace - Multiple AI model support (Claude, GPT-4, etc.) - AI-powered terminals with natural language commands - [Built-in database](https://servercompass.app/blog/database-admin-panel-vps) and API testing tools - Workflow automation with Pipes ### 4\. GitHub Copilot (VS Code) The original AI coding assistant, GitHub Copilot remains a solid choice for developers who want AI features without switching editors. It integrates directly into VS Code and other IDEs. - Works in your existing IDE - Copilot Chat for conversations - Strong enterprise features - $10/month individual plan ### 5\. Zed Zed focuses on performance while adding AI capabilities. Built in Rust, it's incredibly fast and includes AI features through their Assistant panel. - Extremely fast performance - Native collaboration features - AI Assistant with multiple model support - Open source (community edition) ## Feature Comparison Feature Cursor Windsurf 1DevTool Copilot Multi-file AI edits Yes Yes Yes Limited Free tier Limited Generous Yes No Built-in terminal Yes Yes Advanced Yes Database client No No Yes No HTTP client No No Yes No ## How to Choose the Right AI Editor Consider these factors when selecting your AI code editor: - **Budget:** Free options like Windsurf vs. premium features in Cursor - **Workflow:** Do you need just code completion or a full development workspace? - **Team:** Enterprise features and collaboration requirements - **Languages:** Some tools excel at specific programming languages ## Conclusion The best AI code editor depends on your specific needs. Cursor excels at pure AI coding features, Windsurf offers great value with its free tier, and 1DevTool provides the most comprehensive workspace for developers who want everything in one place. Try a few options to see which fits your workflow best. --- ## Workspace Layout Presets & Git Status Bar Source: https://1devtool.com/blog/workspace-layout-presets-git-status-bar Published: 2026-03-13 Tags: workspace, layout, git, productivity Switch between six built-in layout presets — Default, Focus, Terminal, Web Dev, API Dev, Database — with one click. Save custom layouts per project and see git branch and change count in the status bar. Your first day with 1DevTool: you have terminals, a browser panel, file explorer, and a database client all visible. But the default arrangement doesn't match how you work. Maybe you want terminals maximized for an AI-heavy session, or browser and HTTP client side-by-side for API development. v1.0.1 introduces **layout presets** so you can switch workspace configurations in one click. ## Built-in Layout Presets Six presets ship out of the box, each optimized for a different workflow: - **Default** — balanced view with all panels visible - **Focus** — minimal distractions, terminals and editor only - **Terminal** — terminals maximized, everything else hidden - **Web Dev** — browser on the right, terminals and editor on the left - **API Dev** — HTTP client and terminal side-by-side - **Database** — query editor and results front and center Save custom layouts per project. Your frontend project can use the Web Dev preset while your backend project uses the Terminal preset — each one remembers independently. ## Resizable Sidebars with Smart Collapse Drag sidebar edges to resize them. Drag far enough and they collapse entirely, giving you maximum space for your active panels. The collapse is smart — it remembers your preferred width and restores it when you expand again. ## Git Branch and Change Count in Status Bar The status bar now shows your current git branch and the number of uncommitted changes at a glance. No need to open a git panel or run `git status` — the information is always visible at the bottom of your workspace. ## Terminal Status Indicators The status bar also shows terminal status counts: how many terminals are running, idle, or errored. Combined with git status, you get a constant overview of your workspace health without opening any panels. ## Try It Today Layout presets and git status are available in [1DevTool v1.0.1](https://1devtool.com). Switch between workflows in one click and always know your git status. **One click to your perfect layout. Always know your branch.** --- ## GitHub Copilot Alternatives: 10 Best Options in 2026 (Free & Paid) Source: https://1devtool.com/blog/github-copilot-alternatives Published: 2026-03-12 Tags: copilot, alternatives, ai-assistant Looking for GitHub Copilot alternatives? Compare the best AI coding assistants including free options like Codeium, and premium tools like Cursor and 1DevTool. GitHub Copilot revolutionized AI-assisted coding, but it's not the only option. Whether you're looking for a free alternative, better features, or different AI models, this guide covers the best GitHub Copilot alternatives in 2026. ## Why Consider Copilot Alternatives? Developers switch from Copilot for various reasons: - **Cost:** Copilot costs $10-19/month with no free tier - **AI Models:** Access to Claude, GPT-4, or other models - **Features:** Multi-file editing, chat, and deeper integration - **Privacy:** Concerns about code being used for training - **Integration:** Better fit with specific workflows ## Best GitHub Copilot Alternatives ### 1\. Cursor - Best Overall Alternative Cursor is a full AI-native IDE that offers everything Copilot does and more. Built on VS Code, it feels familiar while providing superior AI capabilities. - **Pros:** Composer for multi-file edits, Claude/GPT-4 support, excellent UX - **Cons:** $20/month, requires switching editors - **Best for:** Developers wanting the most advanced AI features ### 2\. Codeium/Windsurf - Best Free Alternative Codeium offers a generous free tier that rivals Copilot's paid features. Their Windsurf IDE takes it further with advanced AI capabilities. - **Pros:** Free tier, fast completions, works in VS Code - **Cons:** Proprietary models only - **Best for:** Budget-conscious developers, students ### 3\. 1DevTool - Best All-in-One Alternative 1DevTool combines AI coding assistance with a complete development workspace. Get AI-powered code editing plus terminals, database client, and more in one app. - **Pros:** Multiple AI models, integrated workspace, AI terminals - **Cons:** New to market - **Best for:** Full-stack developers wanting unified tools ### 4\. Tabnine - Best for Privacy Tabnine focuses on privacy with options for self-hosted AI models. It works entirely offline if needed, making it ideal for enterprise environments with strict data policies. - **Pros:** Privacy-focused, self-hosted option, offline mode - **Cons:** Less capable than cloud models - **Best for:** Enterprise, regulated industries ### 5\. Amazon Q Developer - Best for AWS Amazon Q Developer (formerly CodeWhisperer) is excellent for AWS-focused development. It understands AWS services deeply and offers a free tier. - **Pros:** Free tier, excellent AWS integration, security scanning - **Cons:** AWS-focused, less general coding knowledge - **Best for:** AWS developers, cloud infrastructure ### 6\. Claude Code - Best for Complex Tasks Claude Code brings Anthropic's Claude model to your terminal. It excels at understanding complex codebases and making multi-file changes. - **Pros:** Powerful Claude model, understands full codebase - **Cons:** Terminal-based, requires API access - **Best for:** Complex refactoring, codebase exploration ## Free Copilot Alternatives If budget is your main concern, these options offer substantial free tiers: 1. **Codeium:** Unlimited completions, free forever 2. **Amazon Q Developer:** Free tier with 50 AI completions/month 3. **Tabby:** Open source, self-hosted 4. **Continue:** Open source VS Code extension ## Quick Comparison Table Tool Price AI Models IDE Support Copilot $10-19/mo GPT-4 VS Code, JetBrains Cursor $20/mo Claude, GPT-4 Cursor IDE Codeium Free Proprietary All major IDEs 1DevTool Free tier Claude, GPT-4+ 1DevTool App Tabnine $12/mo Proprietary All major IDEs ## How to Choose the Right Alternative Consider these questions when evaluating alternatives: - Do you need a free option? → Try Codeium or Amazon Q - Want the best AI capabilities? → Consider Cursor or 1DevTool - Privacy concerns? → Look at Tabnine or self-hosted options - Need to stay in VS Code? → Codeium extension or Amazon Q ## Conclusion GitHub Copilot is great, but it's no longer the only game in town. Cursor offers superior AI features, Codeium provides excellent free access, and 1DevTool combines AI with a complete workspace. The best choice depends on your budget, workflow, and feature requirements. --- **Related in the StoicSoft network** If you're self-hosting on a VPS or working through a deployment guide like the one above, [DeployToVPS](https://deploytovps.com) is the StoicSoft network's handbook for VPS deployment recipes — docker-compose, nginx, traefik, and common app self-hosts. --- ## Cursor vs Windsurf vs Copilot: Which AI Coding Tool Wins in 2026? Source: https://1devtool.com/blog/cursor-vs-windsurf-vs-copilot Published: 2026-03-11 Tags: cursor, windsurf, copilot, comparison In-depth comparison of Cursor, Windsurf, and GitHub Copilot. Pricing, features, AI capabilities, and which one is best for your development needs. The three titans of AI coding tools—Cursor, Windsurf, and GitHub Copilot—each take different approaches to AI-assisted development. This comprehensive comparison helps you understand the strengths and weaknesses of each. ## Quick Overview - **Cursor:** AI-native IDE with advanced multi-file editing - **Windsurf:** Free-tier focused IDE with Cascade AI - **Copilot:** Extension-based AI assistant for existing IDEs ## Cursor: The AI-Native IDE Cursor started fresh with AI at its core. Built on VS Code, it feels familiar but offers capabilities no extension can match. ### Cursor Strengths - **Composer:** Edit multiple files simultaneously with AI - **Chat:** Conversational AI that understands your codebase - **Model Choice:** Switch between Claude and GPT-4 - **@ Mentions:** Reference files, docs, or web content in prompts ### Cursor Weaknesses - $20/month is pricier than alternatives - Limited free tier - Requires switching from your current IDE ## Windsurf: The Value Champion Windsurf (by Codeium) offers impressive AI features with a generous free tier. Their Cascade feature brings agent-like capabilities to coding. ### Windsurf Strengths - **Free tier:** Substantial features at no cost - **Cascade:** Multi-step AI workflows - **Speed:** Optimized for fast completions - **Cross-IDE:** Extensions for VS Code, JetBrains, etc. ### Windsurf Weaknesses - Proprietary models only (no Claude/GPT-4) - Newer, less battle-tested - Some advanced features require paid plans ## GitHub Copilot: The Established Player Copilot pioneered AI coding assistance and benefits from deep [GitHub integration](https://servercompass.app/docs/github-setup). It works in your existing IDE without major workflow changes. ### Copilot Strengths - **Integration:** Works in VS Code, JetBrains, Vim, etc. - **GitHub:** Deep integration with repositories and issues - **Enterprise:** Strong business features and compliance - **Stability:** Mature, well-tested product ### Copilot Weaknesses - No free tier - Limited to GPT-4 (no Claude option) - Multi-file editing less capable than Cursor - Extension limitations vs. native AI IDE ## Feature-by-Feature Comparison Feature Cursor Windsurf Copilot Code Completion Excellent Excellent Excellent Multi-file Edit Best Good Limited Chat/Explain Excellent Good Good Free Tier Limited Generous None Model Options Claude, GPT-4 Proprietary GPT-4 IDE Flexibility Cursor only Multiple Multiple Price (Pro) $20/mo $15/mo $10-19/mo ## Best Tool for Each Use Case ### Choose Cursor If: - You want the most advanced AI editing features - Multi-file refactoring is important - You value having Claude as an option - You're willing to pay for the best experience ### Choose Windsurf If: - Budget is a primary concern - You want to try AI coding without commitment - Fast completions matter most - You prefer staying in VS Code ### Choose Copilot If: - You need enterprise compliance features - Deep GitHub integration is valuable - You use JetBrains or other non-VS Code IDEs - You prefer the established, stable option ## Consider 1DevTool If you need more than just code completion—like integrated terminals, database clients, and HTTP testing—1DevTool combines AI coding with a complete workspace. It supports multiple AI models and offers unique features like AI-powered terminals and workflow automation. ## Conclusion There's no universal winner. Cursor leads in AI capabilities, Windsurf wins on value, and Copilot excels in enterprise integration. The best choice depends on your budget, workflow, and what you prioritize in an AI coding tool. Many developers try multiple options—most offer trials or free tiers to help you decide. --- ## GitHub Copilot vs Cursor: The Definitive Comparison (2026) Source: https://1devtool.com/blog/github-copilot-vs-cursor Published: 2026-03-10 Tags: copilot, cursor, comparison GitHub Copilot vs Cursor head-to-head comparison. Features, pricing, AI models, and which one is better for your workflow. GitHub Copilot and Cursor represent two different philosophies in AI-assisted coding. Copilot enhances your existing IDE, while Cursor rebuilds the IDE experience around AI. This definitive comparison helps you decide which approach fits your development style. ## The Fundamental Difference **GitHub Copilot** is an AI assistant that plugs into your IDE. It adds AI features to VS Code, JetBrains, or Vim without changing how you work. **Cursor** is an AI-native IDE. It's built from the ground up with AI at the center, offering capabilities that extensions simply can't match. ## AI Capabilities Compared ### Code Completion Both tools excel at inline code suggestions, but they work differently: - **Copilot:** Ghost text suggestions as you type, Tab to accept - **Cursor:** Same ghost text, plus Cmd+K for inline generation with instructions **Winner:** Tie - both provide excellent completions ### Multi-File Editing This is where Cursor pulls ahead significantly: - **Copilot:** Limited to suggestions in the current file - **Cursor:** Composer can edit multiple files simultaneously, understanding how changes propagate across your codebase **Winner:** Cursor - Composer is a game-changer for refactoring ### Chat & Conversation - **Copilot Chat:** Good for explaining code and answering questions - **Cursor Chat:** Same capabilities, plus @ mentions for files, docs, and web content **Winner:** Cursor - @ mentions add powerful context control ### AI Models - **Copilot:** GPT-4 only (Microsoft/OpenAI) - **Cursor:** Choice of Claude or GPT-4 **Winner:** Cursor - model choice is valuable as each has strengths ## Pricing Comparison Plan Copilot Cursor Free No Limited (2 weeks Pro trial) Individual $10/month $20/month Business $19/month $40/month Copilot is cheaper, but Cursor's additional capabilities may justify the price for many developers. ## IDE Experience ### Using Copilot - Stay in your familiar IDE (VS Code, JetBrains, etc.) - All your extensions and settings remain - AI is additive, not transformative - Easy to start - just install an extension ### Using Cursor - VS Code-based, so it feels familiar - Most VS Code extensions work - AI deeply integrated into every workflow - Requires switching editors ## Real-World Scenarios ### Scenario 1: Adding a New Feature **With Copilot:** Write code file by file, Copilot suggests completions as you go. **With Cursor:** Describe the feature in Composer, let it scaffold multiple files at once, then refine. ### Scenario 2: Refactoring a Function **With Copilot:** Rename, update callers manually with some AI help. **With Cursor:** Select code, Cmd+K, describe the refactor, Composer updates all affected files. ### Scenario 3: Understanding Legacy Code **With Copilot:** Copilot Chat explains selected code well. **With Cursor:** Chat with @ mentions lets you reference multiple files and documentation in one conversation. ## Who Should Choose What? ### Choose GitHub Copilot If: - You're happy with your current IDE setup - You use JetBrains IDEs (Cursor is VS Code-based) - You need enterprise compliance features - Budget is a primary concern ($10 vs $20) - Deep [GitHub integration](https://servercompass.app/docs/github-setup) matters to you ### Choose Cursor If: - Multi-file editing and refactoring is important - You want access to Claude (Anthropic's model) - You're willing to invest more for better AI features - You primarily use VS Code anyway - You want the most advanced AI coding experience ## Consider: 1DevTool If you need more than just AI code completion, 1DevTool offers a complete developer workspace with AI built in. Beyond code editing, it includes AI-powered terminals, database client, HTTP testing, Git integration, and workflow automation—all with multi-model AI support. ## The Verdict **For pure AI coding capabilities**, Cursor is the better choice. Composer, model flexibility, and deep AI integration make it the more powerful tool. **For seamless integration with existing workflows**, Copilot wins. It adds AI to your setup without disruption and costs less. Many developers actually use both—Copilot in JetBrains for certain projects, Cursor for heavy AI-assisted work. Try both (Cursor offers a trial, Copilot has a free student tier) to see which fits your style. --- ## Introducing 1DevTool: The AI-Powered Code Editor for Developers Source: https://1devtool.com/blog/introducing-1devtool Published: 2026-03-09 Tags: launch, ai, productivity Meet 1DevTool, the AI code editor that combines the power of multiple AI models with a beautiful, developer-friendly interface. Built for productivity, designed for developers. We're excited to introduce **1DevTool**, an AI-powered code editor designed from the ground up to help developers write better code faster. Built with modern development workflows in mind, 1DevTool combines the power of multiple AI models with a beautiful, distraction-free interface. ## Why We Built 1DevTool As developers ourselves, we've experienced the frustration of context-switching between tools, waiting for slow autocomplete, and dealing with AI assistants that don't understand our codebase. We wanted something better—an editor that feels like an extension of our thinking. 1DevTool is our answer to these challenges. It's not just another code editor with AI bolted on; it's a thoughtfully designed workspace where AI enhances every aspect of your development workflow. ## Key Features ### Multiple AI Models Choose from leading AI models including Claude, GPT-4, and more. Switch between models seamlessly based on your task—use faster models for quick completions and more capable models for complex refactoring or architecture decisions. ### Context-Aware Assistance 1DevTool understands your entire project, not just the file you're editing. Ask questions about your codebase, get explanations of unfamiliar code, and receive suggestions that fit your project's patterns and conventions. ### Beautiful Dark Theme Our carefully crafted Dracula-inspired theme reduces eye strain during long coding sessions. Every color has been chosen for optimal readability and visual hierarchy. ### Fast and Lightweight Built with performance in mind, 1DevTool launches instantly and stays responsive even with large codebases. No more waiting for your editor to catch up with your thoughts. ## Getting Started Ready to try 1DevTool? Download it for free and start coding smarter today. We offer builds for macOS, Windows, and Linux, so you can use 1DevTool on your preferred platform. 1. Download 1DevTool for your operating system 2. Install and launch the application 3. Open your project folder or create a new one 4. Start coding with AI assistance ## What's Next This is just the beginning. We have an exciting roadmap ahead, including: - More AI model integrations - Advanced code search and navigation - Team collaboration features - Custom AI model fine-tuning - Plugin ecosystem We're building 1DevTool in public and would love your feedback. Join our community, report issues, and help shape the future of AI-powered development. ## Conclusion 1DevTool represents our vision for the future of software development—where AI amplifies human creativity rather than replacing it. We believe the best code is written when developers can focus on solving problems while AI handles the tedious parts. Download 1DevTool today and experience the difference. Happy coding!