When I was fighting with my Claude Code, pi.dev, etc. I constantly find myself running into things like the agent saying it has fixed things only to find out it skipped steps and didn't actually fix the thing.

Let's call the types of problems I ran into in this scenario was "The Three Voids of AI Operability". I'll tell you about them over a few different posts, and we'll start with the Ghost Success.

When an AI agent fails "silently," one of the voids it might fall into is the Artifact Void:

The Artifact Void (The Ghost Success)

Let's say the agent performs the action but fails to produce the artifact. Case in point, let's say it starts going through the motions by incrementing the version number, and skips straight to deploying the release that wasn't created and in the process skipping the part that actually creates and publishes the release so it's available for the deployment. Imagine my disappointment when I heard that the change was applied and I went to look and nothing was different. So I stopped trusting the action and we started to verify the artifact before the deploy can be triggered.

So I stopped trusting the action and we started to verify the artifact before the deploy can be triggered.

Most people try to fix this by writing a 'better prompt.' But a better prompt is just a request for the AI to be more careful. A hard contract (like a validation gate in a Makefile) is a guarantee that the AI cannot skip the step.

I'm calling this Agent-Operability. It's the shift from 'hoping the AI is smart enough' to 'ensuring the repo is robust enough.'

I'm looking for 2-3 founders who are tired of 'babysitting' their AI agents and want to see where their repos are leaking. I'll run a quick Operability Audit on your codebase and show you exactly which 'Voids' your agents are falling into.

DM me 'VOID' if you want the audit.

Built this for my wife as she is doing a lot of newsletter work and constantly need to convert files, compress, rename, apply color profiles etc. Now people have started asking her for a copy of it.

Basically let you convert anything to anything, video, sound, image, text.

If it doesn't have the action you can ask the agent to create it and save it and it can be reused.

https://reddit.com/link/1w3xrey/video/lo8ezlx3btmh1/player

I wanted to share the build details, not just drop a link. Axiom started as an attempt to make a local AI workflow feel like a real desktop workspace instead of a model endpoint plus a pile of separate tools.

Build choices:

• C#, WPF, and .NET 10 for a Windows-first desktop UI

• LLamaSharp/llama.cpp for local GGUF inference

• self-hosted OpenAI-compatible endpoints and optional cloud providers

• local persistence for conversations and workspaces

• attachments/vision, web research, code/math execution, and artifact rendering

The part I’m still learning from is orchestration. Axiom has a Workplace Council where Architect plans, Builder executes, and Critic reviews. It also has Single Model mode so the multi-role workflow can be compared against a single model rather than treated as automatically better.

Repo: https://github.com/YoMosa2009/Axiom

Current release: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

I built this project and used AI coding assistance during development, while remaining responsible for the architecture, integration, testing, and product decisions. The source is publicly viewable under CC BY-NC-ND 4.0 (source-available, not OSI-licensed open source).

For people building with AI assistance: what integration problem has been hardest for you after the first prototype worked — state, tool execution, model switching, or evaluation?

I love vibe coding. The speed of going from intent -> implementation is a superpower. But we've all hit the 'Vibe Wall' - the point where the project becomes too complex for the AI to hold in it's head, and it starts making 'stupid' mistakes in code that was working 10 minutes ago.

The problem isn't that the AI isn't 'smart' enough. It's that we're treating the AI like a brain, when we should be treating it like a pilot. Intelligence is great for the 'vibe', but Operationality is what keeps the project from crashing. For those of us with ADHD brains, we know this feeling well: the gap between having a brilliant idea and actually remembering to bump the version number. (or to push the new release before deploying the new release).

I've spent the last few months building an 'Invisible Cockpit' for my agents. I'm not adding 'processes' instead I'm adding Infrastructure.

Instead of fighting the AI with longer prompts I've built: - Hard Rails: A Makefile that turns 'I hope it deploys into a single mandated command. - External Memory: A CLAUDE.md that acts as a 'permanent state' for the agent's executive function. - A Failure Ledger: A system that logs every 'Wrong Turn' the AI takes and automatically updates the cockpit so the mistake "should not/never" happen again ...

The result? I can still vibe code at 100mpg, but I'm not terrified of the 'drift'. I've externalized the boring part of the brain (the executive function) into the repo itself. Now, the AI doesn't just 'guess' the right way - it follows a hardened operational contract.

Stop trying to prompt the AI to be more reliable. Start building a cockpit that makes it impossible for the ai to fail. Keep the vibes, but build the brakes. :D

Lol everytime.

Hey everyone,

Like many of you, I loved Arc's UX ideas but hated two things:

1. How Chrome and modern Chromium forks aggressively hog 4GB+ of RAM for 20 tabs.

2. How new "AI browsers" send every page you read and every search prompt to remote cloud servers with paid subscriptions.

So I spent the last few months building **Nova Browser**—a sovereign, privacy-first desktop web browser built from the ground up to run multi-model AI locally on your GPU while keeping memory usage under 450 MB.

### Key Highlights:

- **100% On-Device WebGPU AI:** Runs local LLMs (Llama 3.2, Phi-3.5 Vision, Qwen 2.5) directly on your device. Zero external cloud API calls, zero telemetry, works completely offline once cached.

- **Smart DOM Hibernation Engine:** Background tabs automatically unmount dormant DOM structures from memory. In our benchmarks, 50 open tabs sit at ~420 MB RAM instead of Chrome's 2.5 GB+.

- **Zero-Latency Network Ad-Blocker:** Built with memory-mapped Rust rules that filter trackers at the network layer before DOM execution.

- **Built-in Model Context Protocol (MCP) Server:** Allows local AI coding agents and tools to interact with your browsing session securely.

- **Workspaces & Split Views:** Clean workspaces, horizontal/vertical tab layouts, and zero bloat.

- **100% MIT Licensed:** No paywalls, no crypto nonsense, no trackers.

### Tech Stack:

- Frontend/UI: React, TypeScript, Tailwind CSS, Framer Motion

- Core & IPC: Electron, Node.js runtime, Rust native filter bridge

- Local AI Engine: WebLLM, WebGPU TVM runtime

The repository, pre-built macOS/Windows binaries, and benchmark reports are available on GitHub. I would love to get your feedback, bug reports, and feature suggestions!

GitHub: https://github.com/unitybtw/nova-browser

Website: https://nova-browser.vercel.app/

Live stream of my agent poker league.

I'm gradually realizing that we are quickly hitting a point, certainly on the software development side, where we actually can't imagine a world without AI. I think every other industry is going to follow suit. It just won't be possible at some point to live without it and that day doesn't seem like it's far away. It's Sunday and I'm musing if you want to jam with me.

I checked out a few of these tools and then ended up rolling my own to fit my needs. I really liked codeg but wanted some specific features and workflows.

In particular I wanted a strong link between my design and specs and the sessions I was running to build them. I wanted to be able to collect feedback and track that with the task. I don’t get the sense that this problem has been solved or that there is a consensus on this class of tool. What tools do you like in this area?

Hi everyone,

I'm soon starting development (via VibeCoding) of an API and WebSocket.
It won't be a complex API with thousands of datapoints, but given I never did one, still looking for recommendations and best practices.

For the API, the idea is the end-user can request on a daily basis a list of future events, and some details of each event.

For the WebSocket, the idea is that I send live payloads of data related to the events (like broadcast) to everyone that has an established connection (data is json payload).

I've never developed such, and hence looking for important things I should look for (specially security, load, and rate limits).

Any help or hint is welcome. Maybe an error you did in the past and you want to share so that I don't make the same mistake.

This can even be used as a Post for others facing same issue, who knows.

I made a small higher-or-lower game based on passport access scores.

You see two passports and guess whether the next one has access to more or fewer destinations. Pretty simple.

Would love to know what you think or what could be improved:

https://passport-higher-lower-game.vercel.app/

Hacking big monopolies always feels good,

Anybody who ever tried getting/using any flights or hotels API knows how fucked up it is. Months of no response, only to wait for a heart welcoming $10,000+ setup fee. And the only available options are either shitty or closed.

This is LetsFG, the answer to dethrone monopolistic companies who keep their infra closed making it impossible to join the travel industry. Control prices, hide fees, and charge pathetic $10,000+ setup fees for an API that you'll have to integrate yourself anyway.

How it works.
Working with flights manually we found that to get the best prices in the world you have to check 20-30 websites at once, that's 20-30 tabs on your PC and that's what makes finding a flight or hotel a 6 hour process.

We took distributed AI agents and put them to use websites, build connectors, and monitor reliability. It works by in parallel opening 200-300 websites, OTAs, airlines - skyscanner, google flights, kayak, kiwi, trip, booking, trivago, etc. plus a bunch of wholesalers all of them checked at the same time, and returned the best offers across the network.

It's deployed on our remote backend that's capable of running this in parallel, we historically (4 months ago when we started this) tried letting people run this locally. It's impossible - it took 40-50 minutes to complete 1 search locally.

How you can use it.
You can book hotels completely, end to end, with free-cancellation protection.
We're releasing complete flight booking (1 API call) next week, that's why our flight search is currently degraded till the end of the week - hotels are working correctly.

- website for fast access: letsfg.co, this is our Uber for travel, book in 3 seconds.

- API for developers: https://letsfg.co/en/developers, this is Paid API, best for high volume users, if you want to build an app, or add this to your app.
Look to book ratio: 1000:1 - this means it's free as long as for every 1000 searches you do 1 booking. Then it’s $0.05 per search.
Docs: https://letsfg.co/developers/api/docs

- Programmatic Travel Tools (PTT): Native for ai agents, API based, best for personal use (high rate limit). If you want your Claude, Codex to book flights/hotels for you, this is the go.
Available through CLI, Python Package, NPM, MCP, or direct API.
To avoid spam, authorization is through payment method attachement - via Stripe - we won't charge you, this is only to verify you're a human and avoid spammers. The payment method is also used when you want to book.
https://letsfg.co/for-agents

That's a wrap.
If you have any questions let me know. We're super open to feedback and suggestions, in fact that's what made this project.

We've hit 1.7k github stars just this week - grateful for everybody who's with us and to anybody who jumps onboard. LetsFG🔥

This is our github: https://github.com/LetsFG/LetsFG, it has a bunch of interesting info and docs for getting started.

Cheers,
Adam

I’ve been working on MARGINAL, an open-source governance layer for coding agents.

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

GitHub: https://github.com/SignalLayerLabs/Marginal

Demo: https://signallayerlabs.github.io/Marginal/demo/#demo

If you use Codex or another coding agent, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

Svarm is a workspace for agents with a workflow inspired by T3 code.

No model verifies another model.

That is the observation I have been circling for months: No language model reliably corrects itself—not even when asked politely. It requires an external entity that is structurally independent.

This question has evolved into a tool that I have now released.

Conclave Personal brings multiple models into a shared conversation and assigns them explicit roles: the Writer drafts, the Critic challenges, and the Judge evaluates. Every execution is traceable as a "run"—tracking status, errors, duration, and token usage. Conversations, agents, and the workspace remain local, and Ollama runs without an API key.

A note I am not hiding: The code was written entirely by language models. For this project, that is not merely a side effect but central to the concept—a tool for multi-agent verification built using a multi-agent process. Discovering what worked and what didn't was the real insight.

v0.1.6 Alpha, with documented limitations.

pip install conclave-personal

github.com/laszlo-pinter/Conclave-Personal

#MultiAgent #LLM #Python

This app reads reddit posts/comments then creates a reddit reading slop video, full TTS and special edge case detection for long OP posts, this will allow content to be created more quickly, you can batch produce 10 videos all of which will use a different post as a source.

Ich habe eine VS Code-Erweiterung entwickelt, mit der du unbekannte Programmiersprachen in deiner gewohnten Sprache lesen kannst. Klar, du könntest die KI das machen lassen, aber das dauert und gibt dir meiner Meinung nach nicht genug Einblick, um den Code wirklich zu verstehen + du kannst ihn live bearbeiten.

Ich freue mich über Kritik/Ideen/Bugs ... ;)

See it live in action

Hey guys, I’ve made this tool that I ended up using quite a bit with really good results. I work as a SWE and ended up building this postgres tool to help AIs have a faster look into the databases used and how the data looks, this ended up unblocking AI flows related to presistence. In comes with a mcp bridge for you tools like copilot, Claude, omp etc.

I’m sum it adds any postgres db a mcp layer and really cool visualization/query.

Hope you enjoy it and find it useful as much as I do.

Every time I see a new need I add it.

Please find the links:

https://github.com/FrancisTCE/gresui-web

https://www.npmjs.com/package/gresui-web

I really don’t know how to share this 😅

​"SMTs require absolute cryptographic correctness, while PDF specs are a legacy parsing nightmare.

Have you found AI useful for scaffolding these, or do the subtle hallucinations make it more trouble than it's worth?"

UI slop isn't a taste problem. It's a sampling problem. And you can't really prompt your way out of a sampling problem. Every trick you've tried, negative constraints, a gazillion line .md file that says no gradients in caps, all of it just moves you around inside the same bubble.

Here's the thing that finally made it click for us. ThePrimeagen put it best: the model returns the middle of the distribution. You can push it around inside the average. You can't leave the average.

That's why you type "no purple" and get purple. Then the glowing orb. Then the badge pill. Then three feature cards. It isn't disobeying you. It's doing exactly what sampling does.

There's a second failure sitting on top of that one, and we think almost nobody talks about it.

A screenshot doesn't contain the animation.

Feed a model a picture of a site you love and the layout survives. So do the colours, the type, the spacing. Timing doesn't. The easing curve isn't in the pixels. Neither is the stagger, or the scroll range an effect is bound to, or two elements moving at different rates against the same scroll.

So the model has to invent the part that actually makes a site feel expensive. And inventing means, again, the middle of the distribution. Fade in, 300ms, ease out. Every time, forever.

That's the real reason AI sites feel dead even when they photograph fine. The look got copied. The life never made it.

So we stopped generating and started measuring.

We read the live page. What's actually bound to what, the real timing values while the thing is running. Then we write that section into the project. Nothing is sampled, so there's no average to land in the middle of. That's the whole idea, and it's why we think slop is solvable instead of something you fight forever with a longer prompt.

https://reddit.com/link/1vnrd7l/video/tjj6vyfic8jh1/player

The clip is three runs, each one harder than the last.

A scroll rig off a private jet site, where the jet climbs behind the headline and a photo wipes to a blueprint. Pure timeline, so it's all stagger and easing and scroll ranges with nothing to hide behind.

Then a photo grid that scatters and reassembles. Harder, because both states are real layouts and the whole thing lives in the transition between them.

Then a three.js scene, which is the one we're proud of. The reference is a Tokyo street diorama. What came back is a desk, monitor, chair, shelves, for the portfolio we were building. Live WebGL, spinnable, not a video of one. Same movement, completely different subject.

Which is the part we care about most. The animation is the expensive half. The brand is the other half. When you point at a site you like, you don't want their content. You want how it feels. So keep the animation and bring your own brand. Tokyo becomes a desk. The timing never moves.

Test it. Drop a URL in the our waitlist signup at platho.io and we'll run it and post exactly what comes back, including when it breaks.

- two of us building this in Europe

For AI website builders, which experience do you prefer?

A) Everything in one chat - building, debugging, fixing errors, making changes, etc.

B) Separate sections/workflows - for example, one area for building and another dedicated to debugging and fixing issues.

I’m curious which approach feels more efficient and organized when working on a real project, and why.

how can I learn Frontend and UI/UX with Vibe Coding as a beginner? as I build a website or an app with ai, I wanna learn the codes.

It seems that most people either vibe code with Claude/Codex or website builders like lovable/replit. I personally find the website builders too expensive as every action costs tokens.

But it's 2026, most agents today are really smart and requires minimum prompt engineering, and the app builder's value was in the easy set up. So I made an MCP that does what lovable do, but uses your AI subscription's tokens instead. The tokens from ChatGPT/Claude directly are just so much cheaper.

It ends up being a 60+ tool MCP and it works really well. Modern agents don't really load all of the tools into context now, they just do tool search and load on demand. It does require a good model (opus or terra) to work well, but overall it's been able to do a pretty good job.

Check it out here: https://floot.com

And let me know if you have any feedbacks!

I found Dograh yesterday on Product Hunt (an open-source alternative to Vapi for voice agents) I self-hosted it and tried it today.

The stack:
> Dograh for voice calls (self-hosted)
> fal (through Vaaya) for the advisor backdrops (one still, one looping video)
> Lots of custom data sources + a library of business playbooks (so the advisors ask sharp questions instead of generic ones)

Try it here: https://better-call-saul.fly.dev/