If I ask an LLM, it tells me “your usage is pretty low for an apartment, good job!”

The latter is exactly the question I had in mind. Not even close.

I don’t know, I find myself doing things I would’ve never done before AI.

I find myself doing more projects outside of work.

I discover new problem domains and are less afraid of tackling the unknown.

I code in languages I don’t know and start learning how they work.

I can get anything explained to me, at any time, in a somewhat coherent manner, by a tutor that won’t get tired or annoyed.

Look— I’m not exactly thinking AI is free of criticism, but it’s definitely a revolution in access to information and at least to me that’s a big deal.

The only way to receive news or bulletins for weeks was just one remaining AM radio station that kept broadcasting even as the storm hit and their building began to flood.

Comments URL: https://news.ycombinator.com/item?id=48021142

Points: 2

# Comments: 0

I've been struggling to figure out what "slower" would look like when working in industry. If everyone's working 2x faster, how do you slow down meaningfully without getting axed?

I will say, I do wish there was a conversation list when looking at folders--having conversations listed on the sidebar can get a bit busy.

We are commenting on a submission linked to the New York Times.

No serialization/JSON-RPC layer between a TS CLI and Elixir server. TS TUI libraries utilities are really nice (I rewrote the Elixir-based CLI prototype as it was slowing me down). Easy to extend with custom tools without having to write them in Elixir, which can be intimidating.

But you're right that Erlang's computing vision lends itself super well to this problem space.

[1]: https://github.com/matteing/opal

Over the past couple of weeks, I got pretty intrigued by the rise of OpenClaw and agent harnesses like Pi.

At some point, I decided I wanted to make my own in order to learn how these things work. I learn by doing, and it seemed like a fun project. So I started building my own OpenClaw in TypeScript--but at some point realized I'd rather start from first principles, so instead I shifted focus towards building my own agent harness.

Something curious happened though: the more I looked at the problem space (agent system, running tools, etc)--the more it looked like Erlang/OTP to me. I had a hunch that Elixir would be a great fit for this problem.

I started building it and effectively, yes! It was a great fit. The agent loop maps perfectly to an Erlang GenServer/gen_fsm, parallel tool execution is easy by just spawning cheap Erlang processes, and multiple agents/subagents can be isolated in one system as separate supervision trees. This is all a lot of stuff I would've had to reinvent if another language was used.

Erlang/OTP is an amazing system. This setup gives me incredible observability into running agent systems--I can remote iex to the server binary and manipulate the system, end tool execution. The agent can debug itself by connecting to its own running instance. And, in the future, you can probably network these using Erlang distribution as well!

So far, in terms of features, the harness is minimal but packs a punch.

- Read/write files

- Shell calls

- Multiplatform

- Subagent support

- Asking questions

- Nice CLI :)

All in all, this project has been very fun to build. It's finally at the point where it's building itself and that's very rewarding to watch.

https://github.com/matteing/opal

Take a look at the GitHub, drop a star, and let me know any feedback? It's my first time building an agent system, so any input is welcome. Thank you!

Comments URL: https://news.ycombinator.com/item?id=47138518

Points: 3

# Comments: 0

First thoughts: it seems the broader community is moving towards Agent Skills as a "replacement" for MCPs to tackle the context pollution problem.

Agent harnesses like Pi don't ship with MCP support as an intentional design choice. MCP servers[0] are being rewritten as pure CLIs in order to support this new scenario.

Thoughts on this?

[0]: https://github.com/microsoft/playwright-cli

Comments URL: https://news.ycombinator.com/item?id=47099585

Points: 2

# Comments: 0

Skimming through conclusions and results, the authors conclude that LLMs exhibit failures across many axes we'd find to be demonstrative of AGI. Moral reasoning, simple things like counting that a toddler can do, etc. They're just not human and you can reasonably hypothesize most of these failures stem from their nature as next-token predictors that happen to usually do what you want.

So. If you've got OpenClaw running and thinking you've got Jarvis from Iron Man, this is probably a good read to ground yourself.

Note there's a GitHub repo compiling these failures from the authors: https://github.com/Peiyang-Song/Awesome-LLM-Reasoning-Failur...

The tasks tool is designed to validate a DAG as input, whose non-blocked tasks become cheap parallel subagent spawns using Erlang/OTP.

It works quite well. The only problem I’ve faced is getting it to break down tasks using the tool consistently. I guess it might be a matter of experimenting further with the system prompt.

[1]: https://github.com/matteing/opal

Great work.

I spend tons of time handholding LLMs--they're not a replacement for thinking. If you give them a closed-loop problem where it's easy to experiment and check for correctness, then sure. But many problems are open-loop where there's no clear benchmark.

LLMs are powerful if you have the right ideas. Input = output. Otherwise you get slop that breaks often and barely gets the job done, full of hallucinations and incorrect reasoning. Because they can't think for you.