Its an Elixir agent runtime with a thin Go TUI (bubble-tea). Im building it mostly to explore agent orchestration: planner/workers/finalizer flows, local file/code-edit tools, MCP tools, permission gates, run context, compaction, and eventually larger swarms. Erlang/Elixir is interesting for this because the actor/supervision model maps pretty naturally to lots of isolated agents and long-running supervised tasks.

As i said, The main lesson so far is that everything around contracts is much more fragile than I expected unless you use a very strong model. Planners return Markdown instead of JSON, tools get called with subtly wrong args, subagents repeat broken tool calls, finalizers lie about success after workers failed. And various permissions may be interpreted by agents in unexpexted way

I also started with too many modes too early instead of making agentic path extremely solid. That made me understand better why these codebases become huge: there are endless corner cases if you want a harness to work across models, providers, tools...

Stronger models hide a lot of harness weakness and weaker models expose. Making weaker models good enough requires a surprising amount of contract hardening. But that hardening tends to make the system better for stronger models too.

Also elixir http stack was causing a lot of problems (needed to use gun eventually)

From what I see while building my own agentic system in Elixir, the problem is in training for your specific harness/contracts. Claude/GPT-style models seem to be trained around very specific contracts used by the harness like tool call formats, planning structure, patching, reading files, recovering from errors, and knowing when to stop.

In practice, you either need a very strong general model that can infer and follow those contracts (expensive), or a weaker model that has been fine-tuned / trained specifically on your own agent contracts. Otherwise, the whole thing becomes flaky very quickly. And I suspect with Deepseek V4 you may get last options.

Writing -> We stopped needing to remember everything (outsourced memory)

Printing Press -> We stopped needing to copy knowledge by hand

Calculators -> We stopped doing math in our heads

The Internet -> We stopped needing to "know" facts. We just look them up

LLMs -> We are starting to give away reasoning and combining ideas

What is next?

Soon, AI will likely handle:

- Planning

- Ideas

- Execution

What remains for us?

If AI does the "thinking" and the "doing," maybe humans are left with only:

- Experiencing: Feeling what it is like to be alive

- Choosing: Deciding what we actually want

- Valuing: Deciding what is important or "good."

- Being aware: Just being a witness to the process

And not sure if these are "safe" human roles? Or will AI eventually take over "choosing" and "valuing" too? If an algorithm knows what you want before you do, is our consciousness still in control?

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

Points: 2

# Comments: 1

Also, in a world where AI output is abundant, we humans become the scarce resource the "tools" in the system that provide some connectivity to reality (grounding) for LLM

Mini paper: that future isn’t the AI replacing humans. its about humans drowning in cheap artifacts. New unit of measurement proposed: verification debt. Also introduces: Recursive Garbage → model collapse

a little joke on Prism)

32767 moves in a single prompt. That's not testing reasoning. That’s testing whether the model can emit a huge structured output without error, under a context window limit.

The authors then treat failure to reproduce this entire sequence as evidence that the model can't reason. But that’s like saying a calculator is broken because its printer jammed halfway through printing all prime numbers under 10000.

For me o3 returning Python code isn’t a failure. It’s a smart shortcut. The failure is in the benchmark design. This benchmark just smells.