"Show HN: What should the GUI for AI agents look like?" is the actual title a developer named Akilan posted to Hacker News on July 31, 2026, alongside a demo called MarbleOS — and by the time I checked back, it had 80 points and roughly 48 comments arguing about the answer. The short version to come out of that thread: a good agent GUI stops treating the agent's work as a chat log you scroll through and starts treating it as something you can watch, click into, and interrupt. MarbleOS, built by Akilan and Miguel, pitches itself as "a workspace with visible files, tools, tasks, and outputs — not buried in chat threads," and it's currently a downloadable beta with no pricing published yet. Whether or not that specific project wins, the debate underneath it is one I've been tracking across every agent tool I use day to day, so here's what I found when I actually compared the interfaces instead of just reading opinions about them, plus a few copy-paste prompts that force more visibility out of whatever tool you're already on.
Short answer: Based on the Show HN thread and MarbleOS's demo, the emerging answer is: not chat. Better agent GUIs show live, interruptible task cards or a visible action feed instead of a scrolling transcript, let several tasks run in one workspace at once, and make it easy to jump in mid-task. Claude Code, Cursor, and ChatGPT's Agent Mode already do pieces of this today.
What you'll need
You don't need to write any code for this — you're evaluating interfaces, not models. Grab an AI agent tool you already use: Claude Code, Cursor, or ChatGPT with Agent Mode turned on. Pick one real multi-step task, something with at least three or four sub-steps, not a single-shot question. Optionally download the MarbleOS beta so you have a workspace-style interface to compare against your default chat window. Set aside about 15 minutes: five to run the task, ten to actually watch what the interface shows you while it runs.
How to evaluate an AI agent GUI for your own workflow
1. Watch what happens between your prompt and the result
Don't read the final answer first. Watch the middle. In my testing, this is where interfaces diverge the most — some print a wall of text describing tool calls, others show a live diff or a browser pane, and some show almost nothing until the task finishes.
2. Count how many places you have to look
Open a second monitor or window if the tool needs one. Cursor's Agent mode keeps file diffs inline in the editor next to a chat sidebar, so you're watching two panes. Claude Code runs its plan, commands, and diffs in one scrolling terminal or IDE transcript. ChatGPT's Agent Mode opens a visible browser pane alongside the chat, closer to the "screenshot as the agent's eyes" pattern Anthropic documents for its own computer use tool. More panes isn't automatically worse, but if you can't tell where to look next, that's a real cost.
3. Test the interrupt, not just the launch
Mid-task, try to stop the agent, correct one instruction, and let it keep going without restarting from scratch. This is the single biggest gap the Show HN thread called out: most agent tools make starting a task effortless and correcting one mid-flight clumsy.
4. Run the same task through two interfaces back to back
When I ran the same three-step refactor through Claude Code and then through Cursor's Agent mode this week, the work itself came out nearly identical — what differed was how much I had to hold in my head to trust it. Claude Code's running to-do list told me what step it was on without asking; Cursor's inline diffs made the "what changed" question easier but the "what's it planning next" question harder.
5. Check whether outputs land somewhere you can reuse them
A workspace model like MarbleOS's pitch — files, tools, and outputs visible as objects, not just text in a thread — matters most here. If your agent's output is a spreadsheet, a deploy, or a set of file edits, check whether the interface hands you that artifact directly or makes you dig it out of a chat transcript.
Example prompts you can copy
These are prompts I use to force whatever interface I'm in to be more transparent about agent work, regardless of whether the GUI itself was built for it:
- "Before you start, list every tool you're about to use and why, so I can see the plan before you run it."
- "Give me a short checklist of the steps in this task, and tell me which one you're on as you go."
- "If you need my input mid-task, stop and ask instead of guessing — tell me exactly what's blocking you."
- "When you're done, tell me exactly where each output file or change lives, so I don't have to search the conversation for it."
- "Summarize what you changed in one paragraph before you show me the full diff."
The common thread: none of these require a fancier interface. They just make a plain chat window behave more like the visible, checkable workspace the Show HN thread was asking for.
Common mistakes to avoid
The mistake I see most: assuming a tool is "transparent" just because it prints its tool calls as text. A 40-line wall of function-call logs is not the same as a checklist you can glance at, and in my testing it's just as easy to tune out as a plain "working…" spinner. Second, ignoring the interrupt or pause control until something breaks — most tools have one, but you won't know how it behaves under a real correction until you've tried it once, deliberately, on a task that doesn't matter. Third, judging a brand-new workspace-style tool like MarbleOS against a chat tool's years of integrations; a beta with a better interface can still lack the connectors your current tool already has. Fourth, forgetting that more visual panes can add cognitive load instead of removing it — a live browser view is only useful if you're actually watching it.
How the interface patterns compare
| Pattern | Example | What you actually see | Best for | How mature it is |
|---|---|---|---|---|
| Plain chat transcript | Base ChatGPT, most chatbots | Text log of the conversation only | Single-shot questions, no side effects | Very mature |
| Chat + live action feed | Claude Code | Running to-do list, commands, and diffs in one scrolling view | Coding tasks with many small steps | Mature |
| Chat + live browser/computer pane | ChatGPT Agent Mode, Anthropic's computer use tool | A visible screen the agent is clicking and typing into | Web tasks, form-filling, research | Mature but still beta-labeled by most vendors |
| Workspace / task-card canvas | MarbleOS | Tasks as cards, tools and files visible as objects, not chat | Running several agent tasks in parallel | Early beta |
Tools that make this easier
If you're new to any of the tools named in that comparison, my how to use Claude AI guide covers the basics before you get into agentic work, and my ChatGPT Agent Mode guide walks through the live browser pane specifically. If you're deciding between chat-plus-diffs tools for coding, Cursor vs Copilot and my broader best AI tool for code roundup cover how their interfaces actually differ, not just their model quality. Once you're running more than one agent at a time, the interface problem compounds fast — my /mission for Claude Code piece covers giving agents consistent standing context, and my write-up on a local merge queue for parallel Claude Code agents covers the related problem of keeping several agents from colliding once their outputs land somewhere real.
My take
None of the interfaces I tested this week fully answer the Show HN thread's question, and I don't think MarbleOS does either yet — it's an early beta making a real architectural bet (tasks and tools as visible objects) that current chat-first tools haven't made. What I'd actually tell a reader: don't wait for the "right" GUI to show up. Pick the tool whose default view already tells you what step it's on and where its output landed, and use the copy-paste prompts above to force more visibility out of anything that doesn't. The interface will keep changing under you either way.
Frequently Asked Questions
Is there one correct GUI for AI agents?
No. The Show HN thread didn't land on a single winner — commenters split between task-card workspaces like MarbleOS, asset-centric views that bring the agent to your existing files, and graph-based views for complex, dependent tasks. Which one fits depends on whether your work is mostly single tasks, ongoing documents, or multi-step pipelines.
Is MarbleOS free to use?
No pricing is published on its demo page as of this writing. It's available as a downloadable beta with no sign-up or waitlist listed, but that's not the same as confirmed free pricing — check the current page before assuming.
What's the easiest way to try a workspace-style agent GUI today?
Download the MarbleOS beta from its demo page and run one real task through it, then run the same task through whatever chat-based agent tool you already use. The comparison is more useful than reading about either one in isolation.
Does a better GUI make the agent itself smarter?
No. The interface changes how much you can see and correct, not the model's underlying capability. A great GUI on a weak model still gives you a weak result — it just makes the failure easier to catch mid-task instead of after.
Do I need to build my own GUI, or can I use what's built into Claude Code, Cursor, or ChatGPT?
For most people, no. Claude Code's running to-do list, Cursor's inline diffs, and ChatGPT Agent Mode's live browser pane already cover a lot of the visibility the Show HN thread is asking for. A dedicated workspace tool like MarbleOS matters more once you're running several agent tasks in parallel and need to see them all at once.