r/agenticAI

Every time I wanted to build a small web tool, I ended up dealing with the same stuff: authentication, communication, WebSockets, ports, and infrastructure.

Even with Claude and Codex, I was still spending time on things that had nothing to do with the actual tool I wanted to build.

So I spent around 6 months building PhreshOS.

The idea was simple: build the infrastructure once, then use AI agents to build applications on top of it without having to deal with all that stuff again.

It's a self-hosted, open-source system with a web-based desktop where applications can run in windows, much like a regular OS. Authentication and two-way communication are already handled, so applications don't need to implement them separately.

Apps can also run in Node.js worker threads instead of each needing a separate Node.js process, which helps keep resource usage low. This makes it possible to run dozens of applications on a relatively small server.

Another thing I wanted was for AI agents to be able to use these applications directly. They can access application services and interact with the same state the desktop interface displays, without needing a separate interface built specifically for them.

The biggest benefit for me is that I can now sit down with an AI agent and build dozens of small applications in a single day, without setting up authentication, communication, or infrastructure for each one.

The whole project, including its packages, is open source under the MIT license.

GitHub: https://github.com/PhreshOS/system

Live demo: https://demo.phreshos.com/

I'd love to hear what you think, including criticism.

I'm Eren, the solo founder and developer of Skillfully. It helps book authors, course creators and other experts turn their methods into agent skills: guides that ChatGPT, Claude and other AI tools can follow.

Authors can sell access by subscription and keep improving those guides using feedback and analytics.

I'd like feedback on the subscription model. If you subscribed to an expert's method this way, what ongoing improvements would make it worth keeping: better examples, fixes when an agent applies the method poorly, or updates to the method itself?

I'd especially value perspectives from people who have sold knowledge products or maintained a small subscription business.

Skillfully: https://skillfully.sh

A large language model can only use the text that fits in its context window, and it recomputes its internal key-value (KV) state for a prompt every time the prompt is sent. We test a memory layer, the public package galahad-kv, that saves the KV state of each block of about 16,000 tokens to encrypted local NVMe disk and loads it back later, byte-exact, without recomputing it. We ran it on 50,000,000 tokens of real public text, served through vLLM on one NVIDIA H100, with Gemma 4 12B and Gemma 4 31B

https://huggingface.co/papers/2610.10845

TL;DR: DHH argues December flipped coding from autocomplete to agent workflows — and if you built your value on being the tight resource, that flip makes you optional, not promoted.

I don’t know why this memory came up.

But do you remember this Italian guy on Youtube explaining about how to “magically” rebrand a handbag from Made-In-China to Made-In-Italy?

Unbelievable, isn’t it?

And yet, it’s apparently legitimate – like EU-regulation-legitimate.

Or so he claimed.

To legally origin-launder the handbag, the last “substantial transformation” of the handbag has to be carried out in Italy. And so, he took out an Italian-made zipper, and sew it onto the China-made handbag. And Voilà! The end product can now be officially labelled as Made-In-Italy.

If you’re interested to find out more, the EU-regulation is Article 60(2) of the Union Customs Code (Regulation (EU) No 952/2013).

A China-factory-made handbag may have cost just €53 or so. But with a touch of "zipper magic", it can now be priced at €400 or €4,000.

The absurdity of it is absolutely bonkers.

No surprise if the Italian craftsmen went out of business.

I know. I know. It’s wildly inappropriate for me to compare AI coding with “Origin-Laundered-Handbags”.

But the parallel, real or not, is hard to pass up.

On the other hand, branded watches, the likes of Rolex, IWC, etc., are a totally different thing. Swiss made ones enjoy world-wide-recognition, like no other.

These are genuine articles that tend to hold their value over time.

That’s why contrabands and counterfeits of such watches are used to swindle the gullible for money – because they say imitation is the sincerest form of flattery, …

…which brings me to this passage:

"For my people have committed two evils: they have forsaken me, the fountain of living waters, and hewed them out cisterns, broken cisterns, that can hold no water."

I kept hitting the same thing building agents, so I went and measured it against other people's code rather than arguing about it.

Four published agent codebases, each pinned at a commit, each killed partway through an action, then retried the way a supervisor or worker pool would. Nothing reimplemented. Where I had to substitute something, I used the project's own documented extension points. Counts come from a ledger the fake service fsyncs before it responds, so a process that dies the instant after acting still counts as having acted. The agent is never asked what it did.

What happened:

• Cua (computer-use): Kill it mid-checkout and the retry charges the card again. Both crash positions, every run. Measured on cua-agent 0.8.4 and again on 0.9.0, with identical results.
• Skyvern: Any process death during a step strands the task in running forever. Not failed, not errored, so nothing alerting on failure notices. The only way out is a new run, which orders again.
• Corsair: Two replicas spend the same rotating OAuth refresh token. A crash leaves the stored credential broken, every run, so the user has to reconnect the integration.
• Inconvo: An interrupted answer costs 60% more in model calls because the checkpointer records the graph node but not the fifteen model calls underneath it.

Four different failures, one shared cause: none of them records which actions already completed. The retry is a fresh process with an empty history, so it does the work again.

The part I found most useful: a study of 25,930 agent episodes found that agents reported success in 90% of episodes where they had duplicated an effect. So you can't ask the agent, and anything graded on self-reported traces scores "duplicated and lied about it" as a pass.

One thing I won't claim to fix: if a process dies between the action landing and the record of it committing, it still repeats. The effect and the record live in different systems, and nothing closes that gap. It's also the row any benchmark reporting zero duplicates has quietly excluded by only crashing at already-committed boundaries.

Harnesses and raw ledgers: https://github.com/cellaflow/cellaflow-benchmarks

No API key needed. Every call goes to a local fake, so it costs nothing to run.

Disclosure: I build a runtime for this, so I'm not neutral. The measured arm is their code at a pinned commit.

What I'd actually like to know:

1. If you run more than one agent against shared state, what actually stops two of them taking the same action? Every answer I've seen in the wild is a lock, a dedupe table, or nothing. I'd like to know whether there's a fourth.
2. And if you're running agents that touch money or send things, how do you handle the retry today? Keys you pass in yourself, or do you just accept the occasional double?

I am building a Task Tracker because I wanted a task manager that gets simpler as AI gets more capable, not more complex.

Most task apps are either cloud-hosted and heavy, or plain text and bare. None were built for agents and my personal progress. So I built one that is.

What makes it different:

- Local-first : One SQLite file. No account. No cloud. No telemetry. Point it at Ollama or any local LLM engine and nothing leaves your machine.

- Native MCP support (18 tools) : Claude, Cursor, Windsurf can plan work, create tasks, log progress, and complete work directly on your board.

- Installable PWA: with reminders that work even when the app is closed.

- Approval-based Chat AI : Ask the assistant to move overdue tasks, create subtasks, or reprioritize. It proposes changes on an approval card. Untick what you don't want. Apply. Everything is checked against board rules and applied all-or-nothing. AI can't delete anything.

- Voice : Talk to the assistant and hear it answer. Hands-free.

- Timeline (Gantt) : Drag bars to reschedule, drag deadlines into start dates. Across individual projects or all of them at once.

- Low cognitive load by design.

GitHub: https://github.com/Parv17k/tasktracker

Built it because I wanted a task manager that gets simpler as AI gets more capable, not more complex.

Would love feedback and stars, especially from people working with agentic AI tools.

Your agent signs up with one API call, sends markdown and gets a live URL back. No login page, no dashboard. The only thing it needs from you is an email, since that's how you get the key back.

I wanted something dead simple and super fast for agents to blog online. Tech people have been doing this kind of thing with OpenClaw and Hermes Agent for a while, but it was hard for normal people to set up.

Now with Muse, Grok Bot and the rest, everyone's getting an agent, and most of the internet still assumes a human is clicking.

To try it, tell your Muse or Grok Bot or claude or whatever you use to just check out SlopIt and signup to it, create a post about something.

https://blog.slopit.io/hey-agents/

I built MasterMNG because coordinating several AI agents was becoming a job of its own: assigning work, moving context between tools, reviewing outputs, and deciding what should happen next.

MasterMNG organizes that work around a company structure, with agent roles, shared goals, tasks, and a command center for the human owner.

The workflow is: define an objective, assign responsibilities, follow the work, and review the results and decisions that need your attention.

The website and platform are live: https://mastermng.com/

I’m the founder, and I’d appreciate candid feedback—especially from people already using multiple agents for real projects.

Where does coordination break down for you most often: handoffs, keeping track of tasks, reviewing outputs, or controlling what agents can do?

Coding agents are getting smarter and smarter at writing code. A new idea has been gaining traction: what if instead of giving a task to a single agent, you give it to a team of agents working collaboratively to solve the problem? It sounds complex, but there's a surprisingly simple solution.

Herder already gives you the core ability you need: one agent can talk directly to another agent. Combined with the coding tools you already have — Claude Code CLI, Codex CLI, or whatever's in your stack — you've got everything for a full multi-agent workflow.

Here's the pattern:

1. One agent leads — takes ownership and coordinates using Herder's agent-to-agent communication
2. Delegation — passes work to other agents through Herder
3. Review loop — completed work cycles through peer review
4. Iteration — repeats until requirements are met

No extra subscriptions, no API key juggling — just leverage Herder's built-in agent-to-agent messaging and the tools you've already got.

I built a repository showing this in practice with a Claude Code skill:
https://github.com/alexstrilets/panel

It demonstrates how simple and effective this approach can be when you use what's already at your fingertips.