Here's a workflow that has quietly become normal in 2026: you open a terminal, type claude (or fire up Grok, Kimi, or whatever agent you run), and start delegating. The agent reads files, edits files, writes files. You supervise.
And here's the part nobody talks about: the supervision experience is terrible.
Your agent lives in a terminal window. Your files live in Finder, or your editor's sidebar. Your agent's output (plans, reports, summaries, README updates) lands on disk as Markdown that Finder renders as a wall of # and *. So you sit there alt-tabbing between a terminal, a file browser, and an editor, playing air traffic controller for a process that's supposed to be saving you time.
I spent months doing exactly this before admitting the tooling was wrong. Not the agent... the agent is great. The environment around the agent was designed in 2001.
Full disclosure before we go further: I'm the developer of the app this article ends with. But the problem is real regardless of whose tool you use to fix it, so let's start there.
The three frictions of agentic coding
Friction 1: the cd dance. Your agent works in the terminal's current directory. Your attention works wherever you're browsing. These drift apart constantly. You're looking at components/auth/ in your file browser while your agent session sits in the repo root, and every task starts with re-aiming it: "look at the file in components/auth/...". You are a human path-resolver.
Friction 2: invisible changes. The agent says "I've updated the config and refactored the handler." Did it? What does it look like now? Your options: ask the agent to cat the file (burning tokens to see your own disk), switch to your editor and navigate to it, or trust blindly. None of these are glancing at the file, which is what you actually want.
Friction 3: the Markdown pile. Agents narrate in Markdown. Plans, migration guides, analysis reports, CHANGELOGs — my projects have accumulated dozens of agent-written .md files. These are documents, written to be read. Every mainstream file manager shows them as raw markup, because in 2001 nobody's disk was full of Markdown.
None of these frictions is huge. But you hit each of them dozens of times per session, and agentic coding is supposed to be about eliminating exactly this kind of overhead.
What the environment should do instead
Work backwards from the workflow and the requirements are obvious:
The terminal and the file browser should share a location. Browse to a folder, and the shell — and therefore your agent — is already there. Point at things by navigating to them, not by typing paths into a prompt.
Files should be readable the moment you select them. Markdown as a formatted document. CSV as a grid. Code with syntax highlighting. Zero clicks, zero app switches. You're reviewing an agent's work, not archaeology.
Small fixes should happen in place. The agent left a wrong value in a config? Click, fix, save. Round-tripping through the agent ("please change line 14...") for a two-character edit is absurd; so is opening an IDE for it.
And the loop should end where it starts: see the git status, commit, push —> from the same window.
This is not a radical vision. It's roughly what KDE's Dolphin gave Linux users twenty years ago (minus the AI, the previews, and git). It just never existed on macOS.
So I built it
Iruka (イルカ — "dolphin" in Japanese, named for its inspiration) is a native Swift file manager for macOS built around exactly this loop. The agentic workflow in practice:
I browse to a project. The integrated terminal is already there — no cd, ever. I type claude and start a session. As I click around the project, the session's context and my visual context stay glued together: when I say "fix the bug in this file," this file means the one I'm looking at.
While the agent works, I watch files change in the preview pane next to the terminal - rendered Markdown, highlighted code, CSV grids. When it writes MIGRATION-PLAN.md, I read it as a document, immediately, without leaving the window.
One detail I'm particularly happy with: follow-mode pauses itself during long-running commands. If the agent is mid-task (or you're mid-npm install), navigating around won't yank the shell's directory out from under it — Iruka detects the running process, pauses the sync, and offers to resume when it's done. This is the feature that makes the synced terminal actually usable with agents rather than just a demo trick; a stray click can't corrupt a 20-minute session.
When the agent's done: git status is right there in the browser — branch, staged files — and I commit and push without touching another app. If something's slightly off, the Edit button in the preview pane fixes it in place. If I want to verify a change landed everywhere, Power Search greps the whole tree with regex, no indexing.
The whole supervision loop (aim, delegate, watch, read, fix, commit) happens on one continuous surface.
And it extends past your own machine. Saved SSH hosts connect from the sidebar with one click —> the terminal opens already connected, so running an agent session on a remote server is the same workflow, minus typing IPs from memory. Right-click any local file to SCP it over; mount S3, SFTP (even as sudo), or WebDAV and browse them like local folders.
To be clear, none of this rides on a stripped-down browser: Iruka is a full Finder replacement first — dual-pane browsing, batch rename with preview, an operations queue for big transfers, list/column/icon views, symlink support. The agent workflow is what's new; the file manager underneath is complete.
The honest caveats
Iruka is not an IDE and doesn't try to be — for serious editing you'll still want your editor, and the in-place editing is deliberately scoped to quick fixes. It's macOS-only (14+, native Swift, no Electron), and it's paid: $19.99 one-time, no subscription, with a 30-day trial and no credit card. If your agent workflow lives entirely inside VS Code with an extension, you may not need any of this. Mine never did. I think in folders and shells, and if you've read this far, you probably do too.
The roadmap is community-driven through GitHub Discussions. Several shipped features came straight from user requests, and "make it better for agent sessions" is currently the loudest theme.
Agents got a generational upgrade in the last two years. The room they work in didn't. It's time.
Top comments (0)