Show HN: What should the GUI for AI agents look like?

The inspiration for Marble comes from the GUI work at Xerox PARC, the 1984 Macintosh, and later NeXTSTEP, which became the foundation for Mac OS X. Before GUIs, interacting with a computer was limited to strange terminal commands:

C:\> DIR

C:\> COPY FILE.TXT A:

You had to remember the command, syntax, paths, and parameters.

The GUI made those capabilities visible. Instead of remembering commands, you could point at files, drag them, click buttons, and select actions from menus. It didn't necessarily make entirely new things possible; it just made existing capabilities much easier to understand and use. We feel like AI is still somewhere around this command-line stage.

Even though the strict syntax has been replaced with natural language, the interaction can still be quite stiff and depend on heavily recall. Tools like Claude Cowork still look surprisingly terminal-like: /skill-name [param1] [param2]. The parameters are written in natural language, but the user still needs to know the capabilities that exist, and how to invoke it. Command-line flags and arguments have just been replaced with tools, skills, and context.

ChatGPT works very well for asking questions, but we aren't convinced that it's the final interface for delegating work across multiple agents. A blank text box and a list of chat threads feels limiting. An agent's capabilities are mostly invisible. With Marble, we're exploring an interface that treats AI more like a workspace than another chat app. Each delegated task becomes a card. Multiple jobs can sit next to each other and run at once. Files, tools, and finished artifacts are visible at once. Before a task runs, Marble also shows which tools it expects to use. The basic idea is that the user should not have to hold the entire structure of the task in their head. And the result should be something directly usable, like a spreadsheet, PowerPoint, or other file, rather than something buried in a transcript.

Marble is our attempt at exploring interaction models beyond the chat box. The product is mainly for people who already use ChatGPT or Claude, but haven’t really adopted agent workflows yet. We’ve found that when the tools and possible actions are made more visible, people start delegating work they would not have thought to do through normal chat.

The site includes a downloadable beta if you want to try it. Does Marble feel like a genuinely novel interface?

Show HN: What should the GUI for AI agents look like?
marbleos.com

The problem is that AI workflows are inherently different for each person.

The current approach feels like it's forcing a CLI-based model on users. I also don't think chat is a suitable fundamental unit for task delegation.

I've worked on writing a compiler using both hand-written code and AI. Once the project exceeds a certain size, the chat itself becomes a bottleneck. In those cases, I needed proof and gates like Rocq. So in essence, AI coding requires clear negative gates that should be rejected when approaching the goal.

I think something like Figma's canvas model might become the new interface.

Because no matter how meta you make it, agent workflows are ultimately optimized for the individual. My settings often don't match someone else's.

Computers also have this problem, but in that case, you can enforce defaults. With AI agents, it's different.

That's why I think we need a canvas—something like a workspace next to the user space where agent workflows can be dynamically adjusted.

I focus most of my coding effort on building gates that AI-generated code must pass through when it's being produced. That approach has allowed me to handle much larger volumes of code.

The future agent GUI will be about supervising multiple asynchronous tasks.

In a way, this might end up resembling object-oriented programming—just with task graphs instead of object graphs.

Once AI starts generating code, it flows out like water through a burst dam. It's impossible for any human to fully understand it all. At first, I tried to understand every line, but that actually turned out to be less efficient than just writing the code myself. There's a clear fundamental mismatch between the way AI thinks about code and the way I do.

This mismatch seems like an unsolvable impedance mismatch problem—similar to the one between ORM and SQL. So once you decide to use AI agent code, you have no choice but to shift your focus from reviewing the code itself to trusting the gates you've built around it.

The key question is how tightly you can build those gates. And I don't think chat-based interfaces are capable of providing that level of control.

I'm not so sure about that tool toolbar. It might as well just be a tool selector dropdown in a typical chat window.