Hacker Newsnew | past | comments | ask | show | jobs | submit | rsyring's commentslogin

Context will be important for answers to be meaningfully comparable:

- LLM expense budget

- What type of dev: work, personal, real time spaceship thrust vectoring, html contact forms for family, etc.

- human in the loop with short as possible turns, software factories that can run for days, or something in the middle

Just off the top of my head. I'm sure there are others I'm missing.


They've basically come up with what exe.dev has been doing for awhile now?

Except, exe.dev is more about, you have a VM and can do LLM work on it. Orbs seems to be minimizing the VM machinery more and making it about the "agentic experience."


A bunch of people are in this space. I have my own personal cloud stack.


Care to share more about how/what you built?

It's common for different models to find holes in another's work. There are various good reasons for that.

FWIW, we use ChatGPT for our primary model and use Claude to do the reviews. This works better than ChatGPT doing it's own review even with a clean session/context.


Agree, but the point is not because Fable is better than Sol, it's because it's .. different .. it just looks at the problem through a different angle.


It's beyond common for a model to find holes in its own work, as well. I have an iterative review as the part of all agentic work, and it always finds something to fix, and will sometimes spend hours fixing its own work.


Same here. Grok Build 4.6 for me, given how cheap Grok is and how Sol is supposed to be "the" SOTA, it finds a surprising amount of bugs. Most of which Sol agrees with needs to be fixed or improved.

I've done this tens of times between these two models and it works great in my experience. Sol initial back and forth with me. Commit. Let Grok review. Sol fix. Only then do I start reading the code.


I suspect it would work with the models swapped too, or even with one model and a blank context for the second run.


For all the people asking "Why?", it seems like TFA has a pretty good list of features/attributes that it thinks sets it apart:

- fx is a coding agent harness and CLI written in Zig, optimized for research and embeddability as part of larger systems.

- It focuses on minimalism and performance across the board, from system prompt design, to its tools, feature set, and 6.39mib binary.

- For end users, its CLI output style and form factor aims to be closer to a Unix shell than a heavy "IDE in the terminal" TUI.

- It's open source (Apache-2.0), model-agnostic, and suitable for both local and cloud inference.

- Designed for instant installation and embedding in resource constrained environments and agent sandboxes.

- fx cold starts in 10µs and does no unnecessary work or I/O prior to accepting user input, making it ideal for programmatic use.

- Optimal fx.wasm builds produced by the Zig toolchain, which further reduce fx's size, making the network stack pluggable.

- fx contributes single-digit megabytes of memory baseline, allowing you to pack many instances in one machine.

- fx preserves scroll history by default, produces minimal output, and makes sparing use of complex TUI or paints

- Minimal system prompt and tools, to save on token costs and to yield optimal time-to-first-token performance (TTFT).

- Small core, extended via skills, plugins, MCPs, with a Unix-like philosophy to extensibility.

- Designed to work with local models, gateways, direct provider API access or subscriptions.


If you like this list of "why?", you might also like this: https://usehax.dev/ (I am the author). Most of the list applies, similar minimalist Unix tool approach, with some differences. Hax is written in C, the dynamically linked binary is even smaller (0.6 MB), MIT-licensed. No wasm though.

Important difference - fx is currently Vercel AI Gateway only - while hax does support multiple providers already (OpenAI API, ChatGPT/Codex subscription, Anthropic API, OpenRouter, OpenCode Zen/Go), and integrates well out of the box with local llama-server.


It’s funny what “tiny” means for different people depending on their background. I expected it to be under an MB as well and was surprised by 6MB.


Basically, for me tiny means it fits on a floppy 1.44 HD.

Naturally meaningless when people carry around USB sticks that might even hold a 1 TB, but alas.


> Naturally meaningless when people carry around USB sticks

Do people do that? I think it was a decade ago, I thought people download from web nowadays.


Not everyone lives in areas where that is a convenient option.


Pretty much my baseline as well. Good example how experiences shape our thinking.


[cries in TRS-80 Model III]


Ok, lets make it 178 KB then. :)


For comparison, I publish a CLI tool written in Dart, can compile to native anything including Wasm , the Linux binary is around 5MB and it does quite a lot.


A typical Go binary would be 2-3 times larger. A typical Node project would easily pull more than 6 MiB of just code, not counting the runtime.



this looks great! what are you using it for? i like the idea of being able to use one of these (sandboxed) within a larger program kind of like how I use LLM's to do small tasks within my apps now but with a few tools (web search). my current way of doing that is like building a mini-harness with a couple tools within the app, but something more drop-in would be better obviously.


I was going to ask if there's any plans to integrate something like the fx's ACP server[1] or pi's RPC mode [2].

I'm making something like Paseo and hax is very interesting as a Pi replacement.

[1] https://fx.sh/docs/using-fx/acp

[2] https://pi.dev/docs/latest/rpc


I really like the philosophy document! https://github.com/OleksandrChekhovskyi/hax/blob/master/docs...

I don’t know if I am ready to use a new tool written in C and using libcurl but I will give it a shot.


that's an amazing project! people always say why 6mb vs CC's 250mb even matter when you are calling out to LLMs hosted in the cloud. But... I regularly run hierarchies of agents with say 50-100 on a regular basis. So 650 vs 25050 ... is "can do" vs "cannot"


Is that real memory taken? If it's shared code from the same executable surely the multiples are not very relevant?


50-100? How do you do this and for what purpose?


For eg. on a large codebase I do hierarchical review where higher level agents focus on modules and leafs on files. Each reports upwards a summary of its findings incl children summaries.


It looks really nice. Do you have any plan to support Claude subscriptions (pro/max)?


Technically, this would be straightforward. The problem is that Anthropic seems to be really against using Claude subscriptions with anything other than Claude Code - you might even risk your account getting banned for doing so. You could search online for the "openclaw claude banned" for more details on that story.


Didn't Anthropic stop allowing it, can only use the subscriptions with first-party tools?


anthropic hate freedom. what makes you think they want you thinking?


I've only done a little of the new opencode v2 "mini" but it too offers a nice preserve-scroll by default.

OpenCode is the best behaved TUI i've seen by far (they invented OpenTUI to make it so good, also in Zig), so it feels less crucial. But it's nice to have there!

The "small core" model is very popular all of a sudden. DeepSeek's new harness is famously like that. https://news.ycombinator.com/item?id=49285244

OpenCode isn't quite as small, but there's very much been a deliberate attempt to drive much more into a plugin-based system. I enjoyed Dax talking about the new constitution of opencode, and the results of his agent comparing OpenCode & the new DeepSeek. https://bsky.app/profile/thdxr.com/post/3msy4gjttoc2f https://bsky.app/profile/thdxr.com/post/3msygiqyg6v2y

> an architectural change we made in opencode2 is nearly everything is an internal plugin / there's 68 of them that cover our built in agents, integrations, config loading, etc

i also think this is such a brilliant fun architectural twist too:

> OpenCode is the first time i could justify event sourcing in a real system / everything that happens is an event which gets projected into the sqlite db

https://bsky.app/profile/thdxr.com/post/3mt2qx3ktib2c

it's so fun seeing new malleable software cores emerge, try to figure out how to augment agency. agentic software striving itself to extend the agency it itself offers. it's been way too long since we've had ambitions to build general system, architectures that serve more than the user. this has held computing back for far too long. this is such an excellent interesting field, of such a more ambitious computing, opening up.


Thanks for the links on opencode 2! I’ve been meaning to get into this as I’ve been frustrated about some opencode 1’s behavior and design. Many of the encounters made me come up with ideas I’m happy to see they also had! As much fun as it may have been to build my own harness, I feel like the core primitives should be pretty well understood by now (in fact I envision a standard core library / API design taking shape).


This sound exactly like the new DeepSeek Harness cli.

But I switched to oh-my-pi and crof.ai recently (cheap deepseek). Behaves better than opencode, and I love their /collab remote control.


Does it have anything co-designed around Vercel infrastructure? This is what happened to NextJS and why I will likely never touch Vercel open source again


Yeah, I see the Vercel logo, and I am instantly out.


and like Barbara, i'm out.


Most of all what you have said is not really any clear differentiation against the rest of the 100s of other agents. Just minuscule or non-negligible implementation details and I'm afraid it is sadly yet another experimental slop project.

It is a branded "mee too" coding agent that we have seen hundreds of them already.


I can't say I'm super into all the agents that are being created. But I do try to keep up here on HN and I can't say that I can remember any with this particular set of attributes.

In particular, aiming to be embeddable into other projects seems rather notable. At least, not something I've remembered of other projects that have made there way across the HN front page.


Pi is a composition of libraries that can be used to build agents. That seems far more interesting than this “minimal” agent.

This was written in zig and built by vercel. That’s the only notable characteristics about this project.

All code agents look the same and this one is no different.


I don't think Pi is tiny because it's written in typescript and requires a javascript runtime. I definitely want a "tiny" compiled agent with no runtime requirements.

I don't think Zig is that great of a language for this, but it's better than typescript. I don't want to use Vercel software so will pass, but would love to see a more community driven effort.


For people working with small local models like Qwen 35b what's even more important us that the LLM is good at coding in the language in which the agent harness is written so that it can write skills. I really like pi but had a few instances now where Qwen wasn't able to extend it because it isn't very good at writing typescript. Does that sound familiar to anyone, and did you find any fixes?


What’s a better lang in your opinion?


Go or Rust or C++


Almost every harness has an SDK now, it seems part of the "mvp" at this point, both open and closed source

https://learn.chatgpt.com/docs/codex-sdk

https://code.claude.com/docs/en/agent-sdk/overview

https://opencode.ai/docs/sdk/

https://pi.dev/docs/latest/sdk

or if you want SDK first, my recommendation is https://adk.dev/


Very neat. The demo on the page feels very intuitive to me! (if you're used to bash at least)


"- For end users, its CLI output style and form factor aims to be closer to a Unix shell than a heavy "IDE in the terminal" TUI."

I've actually been wondering lately why coding agent functionality isn't just... part of my shell already. Just another kind of interaction modality with an existing shell. Could probably even be an extension to fish or nu-shell even.

Please stop me from forking off on yet another project though.


Originally, Warp was doing just that. Reimagining the terminal including making AI a part of it. I don't think they really found much purchase there because they ended up needing to make a platform out of it:

https://www.warp.dev/


Yeah terminal window is a bit of a different story, though. I mean the actual shell binary.

With some ... intensive ... security/sandboxing/containerizing of some kind though, I guess.



Not exactly:

> Forgejo is self-hostable free software for software development, built on top of Git. Codeberg is powered by Forgejo, which is in turn a hard-fork of Gitea. Compared to Codeberg, Forgejo is not one service, but free software to help you build your own. Everyone can install their own Forgejo instance to host their own projects. There are also public Forgejo instances as well as Codeberg you can use, but make sure you find a site that is actively maintained and updated, and that you trust the provider.

https://docs.codeberg.org/getting-started/what-is-codeberg/#...


> How people managed to put all their eggs in one intermittently available service is beyond me.

It's beyond me how people on HN can be ignorant to why GitHub gained so much market share. It's because for most dev teams, the things they add to the easily decentralized git core is *very valuable.* Arguing it's not valuable or ignoring that value doesn't help anyone.

If decentralized is really going to win, then you have to have the features and DevX to match the basics GitHub provides. Because that's what people need/want. And not just the candy-ass-not-as-good-as-the-kernel-devs devs. Lots of very talented people and very well engineered projects use GitHub because it's better for what they need. Even with all the outages, people are still there. If it was so easy to move away, people would. The fact that they aren't says something important. Please consider not ignoring it.


That's not next...it's now. Through at least LLMs and languages that compile to JS.


Word.


But you're probably better off with Ruff these days: https://docs.astral.sh/ruff/

Similar to black but faster, written in Rust, by the same team who created uv.


So... A: not trivial. And B: not part of the language.

> mean this isn't true, formatting is the most trivial part. And so many languages have an opinionated formatter these days (e.g. Black)

I don't think this is correct


    B: not part of the language.
1) Some would call this a perk.

2) When your tooling around a language works better when it's not actually written in the language... That should tell you something. And yet...


This back-and-forth is a good example of why Go benefits from having a centralized linter. And uv isn't the official Python package manager even though it should be.


I don't get why this is a big issue. This isn't some recurrent decision to be made. It's something a lead decides once and the project follows. That's it. Many companies have style guides anyway (eg Google[1]); the choice of a formatter is much simpler.

[1] https://google.github.io/styleguide/go/


Because at some point you have to interact with some other team or project that made a different decision. And whatever you picked might fall out of favor and lose support. There's already a graveyard of Python type linters, including Google's pytype.

Especially the uv thing. You clone some non-uv git repo that has no pyproject.toml and you don't know what to install. Maybe has requirements.txt but it's partially wrong.


I guess the difference in compile times doesn't matter enough?


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: