The GUI is less verbose with the nitty gritty hidden in expandable sections, which makes history easier and cleaner to scroll through, also no scrolling bugs, rich text is easier to read with tables, and images integrated into the chat, resources like browsers in the context of the session. Drag and drop session organization (pins), scheduled tasks, etc.. all that in the side bar.
Usually a TUI would be open in VS Code and scoped to whatever repo I'm working with so 10 projects, 10 VS Code instances open, not super scalable. With the GUI desktop app it's one app, and I can start sessions in an repo and switch between them easily, no need to open VS Code for each. I don't see what could make me want to go back to using a TUI.
Who else is just using the GUI nowadays, or are you still on the TUI, and why, have you tried the GUI interfaces?
After testing several options at the moment I'm using Orca IDE as my daily driver - effectively as a layer on top anthropic / openai
- Supports both anthropic and openai with subscriptions and can you swithc easily between those two + other LLms
- Its a bit hidden / non intuitive to setup but it does support running everything on remove host -> I run (95%) of my jobs on remote hosts that I can both access from my laptop + their native app via a wirguard vpn
- You can switch between chatview + TUI on the same conversation - very useful if you move e.g. from desktop session to mobile view.
- For repeating LLM tasks Orca also suports a kind of scheduler - but I prefer currently to have the agent set things up via chronjobs on the remote machine (not super happy with this ...)
Key reason I dont want to go fully ChatGPT/Claude is also I dont want to build a super strong dependency on those mega players and remain the ability to switch to other interefernce providers / models.
As LLM usage is already a core workflow in our company - a sudden unavailability of one or a massive price increase - makes it absolutely necessary to build out alternatives.
We all know the downsides of SAAS Lock in too well from the 2010s. In that sense Fool me once, fool me twice..
It solves the crappy user experience of the CLI vs using an SSH terminal in VS code. (Easy copy pasting, everything formatted correctly, etc.) I created my own version of artifact hosting with a simple "mailbox" page on the box - every session can drop it's html reports off there nicely.
Completely agree on being able to flex out to different models. I'm using Claude Code as daily driver given the insane subsidies we are getting. But want something where I can switch easily onto the open weights, etc.
I guarantee they're just starting a bunch of half baked random projects, abandoning them half way through and starting 12 new ones.
You cannot put them next to code being changed but the code viewers are contextual to the session.
I am struggling to see a major difference let alone major advantage of herdr
I was a long term user of the TUI and tools like cmux / herdr but now I find it much easier to actually focus
(Edited after research: I picked up your ideas of search and versioning. Very nice! Thank you!)
T3Code can do anything I might need such a tool to. It supports a bunch of different harnesses, therefore also subscriptions. It supports running agents on different servers, from the same GUI. Mobile app that works well. Orchestration that allows any agent to orchestrate others in T3Code directly.
Not only it's a GUI in client-server topology, it can also orchestrate the agents to work for you.
Haven't tried it yet.
Fully switched from TUI 4 weeks back while testing it out for another use case.
Wrote about my setup here: https://chrlschn.dev/blog/2026/10/larping-with-agents-and-wh...
Imagine a local GitHub PR web UI (thanks to difit), married to your agent for real time in-context discussions, and built-in skills to teach agents how to write easy to follow PR, focusing on both why's and hows.
Last night I released gavel that scratches this itch: it's open source, so fork and enjoy. https://photostructure.com/coding/gavel/
Take a look at the Codex App Server or the Claude Agent SDK as a way to communicate with harnesses running headlessly and build your own UI on top. I’m sure Pi can be set up in a similar fashion.
I wanted more control over the harness itself, especially tool execution, sandboxing, approvals, and context management.
Recently built a native macOS app with GPUI on top of the same agent runloop. It's been interesting exploring how the same engine works across terminal and desktop workflows.
I have 2 versions that are just for working on unity projects. One that is for working on the client project. There is also one that I refer to as the ring of power / Death Star that I keep mostly to myself. Eventually, the client saw what I was doing and decided they wanted a custom ChatGPT.com experience for the whole team, so I got paid to build the most recent one.
Using AI to assist with the development of this stuff is the RSI you've been looking for. I'm in a situation where I was only able to solve a problem due to two levels of bootstrapping enabled by custom harnesses. The product the client uses cannot be "one shot" using the latest frontier tools. I had to build an ad-hoc agent loop fit for just that one purpose using another tool that was possible to build via copilot. For example, using copilot in VS over a unity project's scripts might as well be a drunk person throwing darts from a boat compared to a purpose built harness that can execute ad-hoc scripts in the editor environment as often as it pleases.
The client's custom experience is better than ChatGPT.com in many important ways now. It certainly performs better. It will run on safari without doing horrific things to layout and my CPU. You can easily exceed the capabilities of the frontier AI companies in ways that are important if you use their tools cleverly. These companies are great at making AI models. Not harnesses, websites, apps, etc.
(I found it's still quite some work to polish it so that it's actually good. Therefore, sharing it could still benefit others, so I did: obeya.si, free, open-source)
I use:
claude agents
Granted, I run it as a terminal tab in my editor so that I can look at files. I prefer the TUI in a tab instead of the editor’s half-assed plugin. These days, however, I mostly look at PRs in the browser.
For my personal work I still prefer to let the agent edit the local files so I can preview the changes in my editor. I avoid PRs in my personal work.
Same, it's lovely software for that mode of work!
I also briefly tried out other ADEs, like:
- Kepler (by the GitKraken folks) - https://www.gitkraken.com/kepler
- Paseo - https://paseo.sh/
Kepler had a really nice issue tracker integration but the UI was very vibey and not quite as to the point as I'd like (who needs graph visualization of what the agents do, just give me tools that work), and Paseo had a really nice UI that I could use to drive both Codex and Claude Code, but some OpenCode agents would sometimes hang and I didn't have tools to really do anything about it.
Maybe I should also give JetBrains Air a look again, if I ever end up subscribing to them again (I just moved to Zed for my code editing): https://www.jetbrains.com/air/
Interesting space, with so many additional tools popping up! That said, the OpenCode TUI was really pleasant too.
I went to my Jetbrains Toolbox, and it's not there.
I went to the site, and there are 3 options:
Install it as a plugin to one of their other IDEs. This feels really stupid to me.
Air Teams. This isn't widely available yet, and you have to ask nicely and be put on a list. No go.
Air CLI. I honestly don't know WTF this is doing that I couldn't just do from the CLI with my existing agents. I already have Antigravity (for planning) using Claude for implementation and all I had to do was ask Antigravity to set it up.
They really need to get their stuff together over there at Jetbrains.
There's a school of thought that says IDEs are history, their functionality is now worthless etc. But apparently lots of people don't think that.
I guess I'm one of those people too, because I tried the Air standalone app but it didn't gel for me for some reason. But I tried Air in IntelliJ and it immediately clicked. If models were always perfect and their work never benefited from reviews or changes, fine, you could argue the IDE is pointless. But it's been years and I've not yet found a model where that's true. You can slop for a while if the project isn't that important but for the stuff that matters, human intervention still changes the quality slope quite a lot.
Oh to make things more interesting, Air also has a mobile option too, adding to the list. Odd to couple it with an IDE though since you have various IDEs for various stacks (e.g. IntelliJ IDEA vs WebStorm vs GoLand, unless you just shove a crapload of plugins into IDEA) and agentic tools don't always need all of that.
To be fair though, they're probably scrambling to keep up with the AI craze because it cuts into their margins A LOT and throwing everything they can at the wall. Shame they killed Fleet, could have been a cool basis to compete with Zed (or VS Code, more directly) and integrate Air there or something.
? The GUI has nothing to do with that.
If you use Chat / Work / Code <- that's the differentiation.
So 'Code' in 'Gui' is identical to Claude Code except for the visual layout.
If you use Work or Chat, which are not optimized for Coding you'll see a different experience.
If you use iTerm or Ghostty and set a key combo to switch tabs you can very easily switch between tabs and the TUI generally gives more dense information.
Usually people migrate to TUI not the other way around.
I think that there are reasons to use GUI - if there is deeper integration with Git or an issue tracker - or - in VSCode - for navigating files etc. - definitely those things are valid.
But for raw AI the getting a TUI to work the way you want it is ideal.
A GUI is strictly more powerful than a TUI (because a GUI could just show plain text in cases where that is the most appropriate mode of interaction, E.G. Bloomberg, AMadeus), but it could also do so much more in cases where it is not.
I do love terminals, don't get me wrong. When what you're interacting with is CLIs and Unix tools in a shell, a terminal is exactly what you want. I do love the Unix philosophy, I like small and composable tools that you can use together, and I think the interactive way of working that a shell or REPL can give you is great (though notebooks would have been better, but that's beside the point). Those are things that the terminal shines at. Pretending to be a GUI is not one of those things.
The other problem is that all the GUI apps look different. I really want one extremely powerful, composable GUI “framework” that all apps sit within. Ideally I could even decompose and recombine parts of different apps into new tools or workspaces.
Now that anyone can build a GUI by prompting LLMs, maybe we’ll get actually good GUIs, or at least be able to build our own, but up to now the direction of travel has been disappointing to say the least.
The point is that I agree with the OP, terminals are fundamentally unfit for applications like agents that are not REPL and need complex interfaces. All attempts to fit them into it I've seen are 99% cargo cult, like the entire TUI zoo that keeps layering the cruft just because people are culturally averse to clean first-principle designs or put pretentious "aesthetics" first. Just look at the amount of misconceptions voiced ITT. This incidental complexity is destined to snowball into web/Electron-like Rube Goldberg machines pretty fast, and I guarantee you will hate it. It's already spinning out of control with agents.
Good GUIs with full keyboard functionality are definitely better than TUIs though. There's just no guarantee that some solo dev'd GUI for a brand new workflow can meet that standard.
1. Lower resource consumption (ram, binary size)
2. Usable over the network (ssh)
3. Often much easier to drive with automation software (agents/scripts)
4. Ui tends to be dense, matches your font perferences
Have you used Claude TUI? :-)
> 3. Often much easier to drive with automation software (agents/scripts)
TUIs? Not really. TUIs aren't composable, CLIs are. Now, many TUIs also have a separate CLI mode built-in, but guess what, many good GUIs also have a built-in CLI.
TUIs are also frequently harder to automate via click-click than decent GUIs, since mature GUI toolkits tend to have built-in accessibility and I doubt anyone has ever programmed extra accesibility into any TUI in history, outside of the default keyboard access they get because they're inherently character driven (though that can take you quite far).
You can't even have 'tabs' inside of Claude Desktop, which is a dealbreaker for most power users.
GUIs are great when you're sitting in front of the computer it's running on. Trying to do anything remotely with them is terrible. RDP is pretty great at making that experience suck less tho.
Spawn a Claude TUI where you need it and take remote control with no friction.
I tried it in codex and they messed up the flow so bad. You need to add a device oauth token every time you set it up even though it's already logged into your account.
TUIs are superior in that case because they cuts the attack surface down to a regular SSH session.
I think there's 2 clear layers in these coding tools: the runtime engine that lives ON the system, can execute commands, read/write files, make network calls and the UI, which can be a local (TUI) or remote.
A remote UI allows you to manage multiple remote runtimes concurrently and can even be on your phone.
Anyone preferring Desktop vs TUI is not managing multiple systems I would guess.
I live my life in the terminal.
I use lazygit all the time. I integrate delta with it.
But I use vscode GitLens for diffs.
I always find the view port in lazygit to be too narrow. My feeble brain cannot work with so few context.
Isn't the CC TUI written in React?? I mean my web dev "all i have is this hammer" brain is intrigued, but surely, there's better things to do? Like you said, the terminal is great for piping inputs and outputs, for scripting, for bulk operations. It's really not great for real time interaction across many files, which is how i use CC and kind of wonder how you would use it any other way. (I guess if you literally just prompt and pray, the UI literally doesn't matter?)
The outputs of Opus 5.5 were so much easier to read, but I do find the the deepseek web based tool much easier to comprehend for some reason. Plus I can access it from phone (over tailscale) as well when out and about and continue sessions very easily. AND it is all open source/weights. I'm pretty thrilled, but it's been less than a week.
I have a project folder which is my default environment, and within it I have my many repo clones. That way I can work on any project from my prompt and reference elements in one project to include in another.
I continue to get good results using lifeOS (though I don't use the entire setup) https://github.com/danielmiessler/LifeOS
It fits most definitions of a TUI, though. Just with lots of scrolling text.
Don't confuse TUI with CLI.
Look, it's just a tool, you are a developer, you've used TUIs all your career, this is just one more TUI, no different than your beloved Vim or Emacs. No need to be scared, this won't replace you because mere mortals won't know what to do with a TUI, so you can use it freely and get more work done, just as you were always obsessed with doing when configuring your Vim bindings.
Then, a year in, when everybody is hooked line and sinker, people start to understand that the TUI is the least important part of the whole thing, and the model and harness are what really matters.
The UI can be made to fit exactly the workflow you want to have.
I switched to it recently - my previous workflow was managing many terminals in a tiling window manager but I just kept losing track of stuff.
From the text rendering and scrolling alone, they are much more pleasant to work with.
Conversations with activity and MR status indicators, nested sessions, images in the chat, and generally more information and functionality on the screen.
One negative is that it gives Claude, and particularly Codex, room to mess up with auto-opening artifacts.
Codex, when I was still using it, kept opening report or comparison pages in fullscreen when I did not ask for artifacts.
Claude loves to open its iOS simulator pane, but somehow never displays the one it's actually using, instead showing a simulator that is idle. It might be related to my custom tooling.
Use something like Rex, Ghostty, kitty or whatever floats your boat.
You will have a much better experience.
I use the terminal for most of my agentic workflows.
I still use vscode, but only for diffing and the proprietary devcontainer stuff.
OpenChamber (the desktop app, not the VSC extension) for OpenCode currently works best for me. Especially because of its seamless remote control via their iOS app.
I generally prefer GUIs but I'm OK with a TUI harness. Anyway, there's a web frontend for Pi (https://github.com/agegr/pi-web) which looks very promising although it still has some rough edges. They even have an interactive demo: https://agegr.github.io/pi-web/
I'm not associated with the project.
But that mentality doesn't leave room for a lot of nuance. Even the most hard core TUI proponents and neovim gurus probably do not use Lynx as their browser (well maybe they use a vibe coded hacker news TUI client instead)
I use whatever IDE to review the code, read tests, etc. I used to use the terminal for everything prio AI, but not anymore.
I often need agents on one server to talk to a different agent on another server through tmux, and it's just much easier with TUI.
How do you handle the potential errors that might be hidden in parts of the code you don’t understand anymore?
Or do you have 100% understanding of the generated code?
At that time, Gemini was offering a similar tool, so I decided to compare the two. Honestly, Gemini struggled to generate even a single working function without errors and kept apologising for its mistakes. Claude, on the other hand, was significantly better, even in its early days.
Since then, I haven't switched to another LLM for coding.
Now we're discussing Pi, which supports BYOK. My take is that no third-party alternative can fully replace a native solution, especially when it comes to getting access to new features as soon as they're released. I believe this applies to almost every type of software.
1. Potential ban due to ToS violation;
2. It doesn't follow all Anthropic's communication mechanisms out-of-the-box, they heavily use custom headers, hidden flags, and undocumented API features that affect models' behavior;
3. Compact is better in CC (significantly);
4. Cache related nuances (I mean, A\ regularly messes up with cache even in CC, their caching is non-trivial);
5. It's almost unavoidable to use Pi's extensions, and I wouldn't trust my oauth token to anything third-party (take a look at regular reddit/X posts where people getting banned due to such leaks and abuse) -> it takes enormous amount of hacking on top of Pi to get closer to CC abilities.
CC has hooks and mods, even ui_* (undocumented) protocol if you need some big customization, those are enough to implement whatever you want on top of CC.
Also, I'm working with CC from the very first versions, as for me - it's the best harness (as-is) on the market. I have zero clue what problems people are talking about (except known big issues, 3-4 over the years, I've never had serious problems, at all). Seamless and smooth experience, optimized for Anthropic models.
P.S. You can consider this as Stockholm syndrome effect, but... you have close to zero chances to get unbanned with Anthropic, and it's the best coding model(s) available today.
When making a harness, it is so, so easy to do the "web thing" and have your system prompt be a template where you dynamically inject variables like the current date or the contents of the current working directory, and then just re-render that template on every request. THis is a bad, doubleplusungood, terrible, awful idea, and you should never do this under any circumstances. Anthropic will soon force you not to by literally refusing conversations that "break continuity" in this way and do anything but append new user messages at the end, but other providers at least appear to work.
I cannot get behind CC is the best harness. Once u switched to pi I knew I was never going back and occasionally I need to use CC for my subscription and find it unpleasant. CC is just this incoherent hodge podge of functionality that seems to have no vision. Subjective, of course.
I can include any custom programs I need in a skill, and the SKILL.md file is just a doc of how to use those. It helps me save tokens and ensures determinism with repeated workflows since redoing a task is just calling a skill's program.
I also load only skills that are necessary for a project. I don't want to pollute the context window with unneeded skills.
According to the article you can ask Pi to write ssuch extensions, so you don't have to, right?
When I was using anthropic subs, my "equivalent usage" was $6k/month.
On the open models (specifically deepseek flash), it's < $100/month.
Same work, maybe more.
If you see no difference at all in between Opus and Deepseek Flash for your work, that is great! Personally, I found the latter to be unusable for the projects I was working on.
For what it's worth, I use DS flash for statistical analysis, design (C++, Python), scripting, server maintenance. The same I used for Opus.
Exactly, yeah. The subscriptions are insanely generous and far better value than open models.
Works.
Anything extra you can add yourself. You just ask whatever model you’re using to query the documentation included in the pi application and then its away.
I feel like the max CC plans are incredible value.
I personally don't use Pi but Zed, but Claude is plugged using ACP on my Pro plan. I would never pay the API prices that's way too expensive.
I was under the impression that using Pro or Max from any harness but Claude Code was clamped down upon and likely to result in a ban so haven’t pursued it.
Huh, I guess not.
You can still use harnesses/adapters that use ‘claude -p’ to connect behind the scenes. But the billing is extremely unclear, and it sounds like they use ‘more plan per token’ than just using Claude Code.
The Support page is very unclear, mentioning that you now get an allowance of tokens (and not mentioning the Pro plan at all in that section), and also saying that they’re backing off on plans they previously announced in June without saying what those those plans were, or what the status quo before them was:
https://support.claude.com/en/articles/15036540-use-the-clau...
…and there’s also this GitHub issue showing that tokens are ‘more expensive’ when using `-p`:
[0]: https://pi.dev/packages/pi-claude-bridge?name=claude-bridge [1]: https://pi.dev/packages/@sting8k/pi-vcc?name=pi-vcc
I use a cheap deepseek model for compaction on purpose since it costs a penny or two and does not use any of my Anthropic quota.
I'd be curious to know the background around this. At work, I've used @anthropic/Opus 5.5 through Portkey with Pi, and ended up with $10 within less than 10 message exchanges, on a fairly trivial topic. OTOH, when using Claude Code directly with Opus 5.5, I basically spent $30 for a good back-and-forth across a full chat, reaching the point where CC kicked off compaction.
My interruptions and frustration with llms has gone down a cliff. It’s amazing to see what just a few lines of system prompt really can do to keep agents doing the correct thing much more often.
So there are many wonderful dev experiences, but generally relying on something relatively simple like pi makes a lot of sense, for my use cases.
Obviously you can add skills/rules/prompts/etc, but I don't find those are particularly great at being stuck to.
Pi is much more minimal, so if you have strong opinions about how you want to work with LLMs, you'll have a much better chance of bending the to your will.
But with Pi being barebones and intended to be customized, there are a million extensions to choose from compared to OpenCode. This means not only can you write your own extension easily, 5 other people already have. I forked one popular question-asking tool and added support for an external ui (Zenity). And an LLM provider (Synthetic) had a bug which I helped get fixed in a 3rd party extension for the provider. Both I got done in days, because I didn't have to go through some official Pi team; extensions distribute the work better. It's still hard to manage all the extensions, but better than the alternative.
You can do this with any harness. I really dislike the Node.js ecosystem and avoid Pi and the like. I started with another one written in Go that has all the basics and I can extend it in minutes for anything I need while keeping track of upstream.
Another one written in Go is Crush
I wrote Juggler (https://github.com/juggler-ai/juggler) because I liked Pi's approach to everything being customisable and controllable, but I wanted a slick, navigable GUI rather than terminal hell.
...BUT: having gone to great pains to build an architecture around customisation, where every possible pluggable thing is a plugin, I'm starting to feel jaded on the whole "we need to customise it all" mentality. The models have got so good over the last year that I just don't think that tweaking the harness is something many people will need to do as things progress. The models only need a bare-bones set of tools to do everything they need, and I'm starting to think that UX and UI are the only really important things to focus on in an agent.
(Although from the perspective of coding a harness, making things plugins and having a plugin API does help to keep things clean and stops the codebase getting sloppy)
There is contest.
With minimal work, you can get DSH web to be exposed to your internet behind Cloudflare Access (or similar) and have a harness running on your computer at home from any browser, including your phone's.
Do I understand correctly that this decision was taken based on something that's not accurate? Claude has been reading AGENTS.md files for a while now.
No it hasn’t, this is a very recent addition. Previously you had to symlink CLAUDE.md to AGENTS.md, or include a @AGENTS.md in your Claude file, but by itself it would not read it
When I'm doing work stuff I'm really not liking claude and only using it because anthropic doesn't allow other harnesses. If work would give me a $20 ollama cloud subscription in place of the $200 claude one I would be much more happy at work, that's how much I dislike it.
You're not able to use the API credit and hook it up to another harness?
https://platform.claude.com/docs/en/about-claude/api-credits...
The subscription now comes with API credits. That's what I linked to.
I don't think this is true. They never went through with this change. If you use the SDK it appears ToS compliant. You just can't sell it or distribute it, hence why pi doesn't support it.
they do though?
edit: i guess the parent comment meant subscriptions specifically.
The bit I was instantly drawn to was how much access you are given to change every part of it. Its similar to the text buffer in emacs where every cell in the buffer is fully accessible to any edits you need to make. My configurations are fairly minimal, but for instance I match the accept cli calls that could be destructive and edits to files in the same way copilot is set up.
Currently my pi config turns it into a tutor. It no longer makes edits, just advises and is designed to teach. I make all the code edits by hand. Use deepseek flash with it because its stupid cheap. It works for me, but honestly you can set up pi in any way you want which is why I personally think its the best harness by virtue of anything being possible as long as you can dream it up!
Repo: https://github.com/MauriceElliott/PiCal
System.md: https://github.com/MauriceElliott/PiCal/blob/main/agent/SYST...
It has a break out phrase for when I have a deadline but its pretty useful in the normal mode so I’ve only had to use it a hand full of times.
Also it's nice that it is a self referential setup that can be easily developed and enhanced right while working on things in Claude Code.
I'm sure many of you are building similar personalized setups.