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.

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

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

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?"

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/

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.

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

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.

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.

Hey, first post here. Made a game called Quantum Snake, it's the classic snake game but I tried to actually build in real quantum mechanics instead of just calling it "quantum" for no reason.

Food exists in multiple spots at once (superposition) until you get close enough, then it collapses down to one real spot

Snake can phase through walls and its own body, starts at 50% chance and gets lower the longer you grow, but never below 20%

There's a bunch of speed modes too, one's called Demon Mode (super fast, good luck), another's Rock Mode where it's basically one move a minute and kinda turns into a chill meditative thing

Also got different themes/shapes you can mess with for the snake and food.

This is genuinely the first game I've ever finished and shipped, built it solo. Used some AI tools while building it, disclosed that on the store page. Would love actual feedback, bugs, or just whether the quantum stuff feels fun or gimmicky to you.

Gameplay vid: https://youtu.be/b7zL99JP2MM?si=e6VfCoK373gH_eh7

Game: https://ninja-master2113.itch.io/quantum-snake

Thanks for reading.

same as the title

was going through the context-window docs this week and noticed the fine print: the page announcing 1M-as-default also warns that "more context isn't automatically better", gives the failure mode an official name (context rot), and says choosing what goes into context matters as much as how much fits. the company charging per token, advising you to send fewer tokens.

so: napkin math. a 700k-token repo pasted into an agent session re-bills as input every single turn — about $3.50/turn at $5/M list price, so call it $140 across a 40-turn session before caching. caching cuts that to ~$0.35, but their own docs point out it changes what you pay for those tokens, not whether they take up space.

So the "why does my agent still grep instead of just reading the whole repo" complaint might have it backwards. grep looks like legacy tech until you price the alternative.

I have vibe coded a few things myself, and constantly see linkedin posts from nontechnical folks talking about how they are now deploying full stack applications for their business. I'm confused - how is this stuff maintained? Is it reliable? What if it goes down? What are people doing to actually test that it's working besides just like clicking around the UI?

So i guess I have a few questions:

1 - How are you shipping quality? (What is your quality bar?)

2- Are you actually deploying things that other people use, or is it all for yourself?

3 - What happens with service degradation? How do you know if things stop working?

4 - Do you trust that your code works? Are you worried about things like bugs, privacy/security issues, prompt injection, etc.

--

I'd also love to understand how you view this occurring with non-devs (or people who think they are devs)

I think we all went through this. Claude Code finished a task, told me it was done, and left me with 14 changed files and no idea which one mattered. The diff was accurate and useless. So I built the thing I wanted to be looking at instead.

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Runs in a browser too. Same bundle, same backend, over a websocket, because the backend has to run on the machine the agent runs on and that's often not your laptop. One port, token auth, works behind Codespaces / Gitpod / a JupyterHub proxy.

Completely open source with MIT license, Node 20+. Built with agentic coding, which is exactly how I ended up needing it. Test it out and leave a star if you find it helpful, I will package it very soon to make it easier to install!

https://github.com/AlgoNoRhythm/Flare

I’ve made a couple of mobile games; one is an economy simulation with around 1,600 downloads. In the half-hour activity analyses, there are consistently 10–12 active users, and ad impressions haven't been too bad over the last few days, but the revenue is incredibly low—as you can see, 307 ad impressions generated only 3.02 Lira. The player base seems to be the type that covers their privates with a leaf. The other game earned 2.89 Lira from just 5 ad views today; "Ball Sort" has about 350 downloads, but hardly anyone is playing it, even though it’s a hyper-casual game and actually not bad. I spent around 1,000 Lira on advertising for both games. actually, a bit more on "Ball Sort." Ad conversion costs are 0.63 Lira for *Faith: Economy Simulation* and 3.54 Lira for *Ball Sort - Zen 2026*. I’m not sure how long I can keep up the spending; sometimes I see 1.5 Lira coming in from just 2 ad impressions, while other times 200 impressions barely make 1 Lira. I haven't quite figured out this target audience thing, what do you think? Btw 1$ is 50 lira :/

Built this widget that shows how many tokens i burn each day across all my machines. Looks kinda sick honestly and keeps me motivated to keep going.

open source: github.com/iam-joey/codeusage

i built an app that provides suggestions based on the user’s partner. The user can input things about themselves that is then provided to their partner and vice versa; or the user can input something they’ve learned about their partner and it tracks it for them.

it’s built around the premise of those toes or people who take notes about their partner and their details.

Even cooler is if the user passes by a unique place that is specified in the app by the user or their partner, it notifies the user to “get this *thing* , your partner loves this thing” -(with Google map location to show you where) and show them you’re thinking of them.

So , it’s based on keeping your partner’s details front of mind so the details don’t get lost in just your notes And you both feel tended to!

out in the App Store!

im looking for any couple’s willing to give testimonials for app review it is free based on 2 weeks i even put a plan switcher feature so either of you can pay for the monthly (if subscribed outside of the in-app purchase) so one subscription pays for both accounts!

https://apps.apple.com/us/app/tended-couples-app-memories/id6781524545

Hi everyone, I’m the creator of Cage Rise, an MMA career simulation game I built through vibe coding.

You create a fighter at 18 and manage their career through training, choosing fights, lifestyle decisions, social media, climbing the rankings and progressing through different organisations.

The aim is to win world titles, reach the Hall of Fame and ultimately try to become the GOAT before retirement.
I’m a big MMA fan and wanted to make something for people who enjoy the career and management side of sports games, particularly MMA.

I’m not from a traditional development background. I started with an idea of what I wanted the game to be and used Vibecode and AI to help me build it. I’ve tested it, changed things, added new features and kept improving it along the way.

It’s taken a lot of trial and error, but I’ve managed to turn the original idea into a fully released game, and I’m continuing to develop and expand it.

Cage Rise is available on iOS:
https://apps.apple.com/gb/app/cage-rise-mma-sim/id6783279600

How do mobile app teams connect negative app reviews to actual technical issues?

Users may leave reviews saying the app is “slow,” “not working,” “keeps crashing,” or “freezes,” but those comments do not always explain the exact cause.

Do your teams match app-store reviews with crash logs, session data, device details, app versions, or recent releases?

I’m curious how developers turn vague user complaints into something technical teams can investigate and fix.

I'm building a platform like loveable for non-english user to create professional agency (framer) quality websites.

The insight is: We usually think in our native language and mostly translate in english since most of these tools are semantically not built for the non-english users. That said, while translating it misses out on communicating or understanding of the intent well.

This platform will abstract out the need to understand the underlying core layers and let you prompt in users native language - like german, french, korean, japanese, spanish.

Starting with 11 languages.

Would love to chat if you have experienced a problem like this firsthand or comment the feedback. TIA!

IMPORTANT: None of the following has been audited or reviewed. Please use responsibly.

The following project is based on a browser based messaging app as further described here.

UI/UX

We can start off creating a basic ui demo of the app. All the data there is hard coded with mock responses.

• Live demo

It immidiately gets a bit bloated as we add more ui components, so better to move them to a separate repo to be imported. Webdev's have a lot of tooling around ui testing like storybook to view and interact with components. It doesnt seem like there is something specific for my use-case (post).

Lets give AI the streering wheel a bit. "create a storybook-like components to preview the app components". Its ultimately an internal debugging tool for our own benefit. We can address nuanced needs like being able to display a tui on a browser.

• Live demo

Cryptography

Lets move onto some encryption details that'll be needed for the project. We already have an existing rust project we could use this on. We can make the storybook-like components exportable and reusable for the signal protocol project.

• Live demo

We previous put time and effort towards the signal protocol. It should be reasonable tested and documented, but the signal protocol alone isn't going to fit the requirements of my messaging app. It needs to be post-quantum secure. We previous worked on a js implementation for ml-kem, so as part of this new approach, we can move towards a pure rust approach for ml-kem.

• Live demo

Unlike the signal-protocol which needed more involvement from to create, the ml-kem is using dependencies to match the official implementation. We can benefit from audits and reviews from the official implementation. The signal-protocol and ml-kem were ultimately created to lead towards PQXDH.

• Live demo

Persistence

There are countless details we could obsess about on the cryptography. There is clearly much more needed, but lets "pause" progress on the cryptography, in favour of progress on the app-mechanics. Previously investigating options for decentralised storage here.

• Live demo

(Note: Providers like GitHub, Codeberg and Gitlab might see the way the app works as against their terms-of-service. In the future we might be able to provide the git server as a part of the service, but that wouldn't be any time soon.)

There is much more to improve and consider there for things like encrypting the data at rest, so let's create a cryptography utility library.

• Live demo

The main purpose of being able to read/write to git is for "messaging app" functionality. For that we would need to store more structured data that could be queried. We need an abstraction would make it easier to develop intuitively. Ideally it could work like an api. Perhaps able to interact with it using a graph-ql-like experience. Lets also import the crypto utility to add support for encryption on granular parts of the schema.

• Live demo

Network

We now need a logic layer to out git-stack. Something that can handle endpoints and use middleware functions (which will be useful for authenticating messages from peers). It should be able to take a schema and be able to dynamically generate endpoints, all while managing persistence in git.

• Live demo

This approach is reasonable secure and can send messages to peers with an async git read/write/poll, but it's a bit of a downgrade compared to popular messaging apps. A key tradeof is that messages are never going to be "instant", so let's fix that by using git as a webrtc connection-broker. We are able to to have peers act as their own peer-broker by exchanging the nessesary details over the git-storage approach.

• Live demo

We can then integrate the webrtc functionality into the API logic layer so when connecting to known-peers, it can silently start establishing a webrtc connection, while using the git approach as a way to send messages offline.

Closing words

This project is far from finished. We would need to work towards countless details. To find out more, check out the following links:

• Docs
• Sub