durch

The framing assumes the agent can reliably represent its principal, and I'm not convinced that holds even if you get everything else right.

The problem is that the agent itself is the attack surface. An adversary who controls the communication channel can manipulate what the agent believes about who it's talking to, which means anything it holds, its list of authorized actions, a shared secret you gave it, whatever, can be exfiltrated in ways the agent can't detect because the manipulation happens below the layer where it can reason about trust.

Open harnesses and open standards help but they don't close this gap, because the thing you need to trust, the agent's own judgment about its principal, is exactly what gets compromised. The trust chain has to go below software entirely: hardware attestation, signed commands with keys the agent can verify but never access. That's really an OS problem dressed up as an agent architecture problem.

Design indeed becomes the bottleneck, I think that this points to a step that is implied but still worth naming explicitly -> design isn't just planning upfront. It is a loop where you see output, see if it is directionally right, and refine.

While the agents can generate, they can't exercise that judgement, they can't see nuances and they can't really walk their actions back in a "that's not quite what I meant" sense.

Exercising judgement is where design actually happens, it is iterative, in response to something concrete. The bottleneck isn't just thinking ahead, it's the judgment call when you see the result, its the walking back, as well as thinking forward.

Thank you! I really hope we can make some headway here :)

If you have a few minutes I invite you to check what we're doing over at Open Horizon Labs, its exactly the type of thinking we have around the current state of the world. Apologies I feel like I'm stalking you in the comments, but what you're saying absolutely resonates with what I've been thinking, and what I've been trying to build, and its refreshing to finally feel that I'm not insane.

https://github.com/open-horizon-labs/superego is probably the most useful tool we have, but I'm hoping that we can package it and bring it to the people, as it does make all these LLMs orders of magnitude more useful

I am 100% in agreement, AI is a tool and it does not rob us of our core facilities , if anything it enhances them 100x if used "correctly", ie intentionally and with judgement.

I will borrow your argument for JTP since it deals with exactly the kind of superficial objections I'm used to seeing everywhere these days, and that don't move the discussion in any meaningful way.

This is exciting, I hope you manage to get traction for the idea!

I currently have rely on a sort of supervisor LLM to check and detect if we're drifting, or overcomplicating or similar (https://github.com/open-horizon-labs/superego).

While I still to figure out who watches the watchers, they're are pretty reliable given the constrained mandate they have, and the base model actually (usually) pays attention to the feedback.

Yegge is an absolute legend, no doubt about that :D

Something in there you'd like to discuss further, I've been thinking a lot about these ideas ever since LLMs came around, and I think these are many more of these discussion ahead of us...

Generator vs. explorer is a useful distinction, but it's incomplete. Agents without a recognition loop are just generators with extra steps.

What makes exploration valuable is the cycle: act, observe, recognize whether you're closer to what you wanted, then refine. Without that recognition ("closer" or "drifting"), you're exploring blind.

Context is what lets the loop close. You need enough of it to judge the outcome. I think that real shift isn't generators → agents. It's one-shot output → iterative refinement with judgment in the loop.

Ironic indeed: pattern-matching the prose style instead of engaging the idea is exactly the shallow reading the post is about.

Format conversions (text → code, description → SVG) are the transformations most reach for first. To me the interesting ones are cognitive: your vague sense → something concrete you can react to → refined understanding. The LLM gives you an artifact to recognize against. That recognition ("yes, more of that" or "no, not quite") is where understanding actually shifts. Each cycle sharpens what you're looking for, a bit like a flywheel, each feeds into the next one.

LLMs find the center of the distribution: the typical pattern, the median opinion. Tailwind was an edge bet. It required metis, the tacit competence to know the consensus (semantic classes, separation of concerns, the cascade) was a local maximum worth escaping. That judgment, knowing what the center is wrong about, doesn't emerge from interpolation. It emerges from the recognition loop where you try something, feel "that's not quite it," and refine.

The bottleneck was never typing. It was judgment. Tailwind is crystallized judgment. AI can consume it endlessly. Producing the next version requires the loop that creates metis, and that loop isn't in the training data.

I've replied with this in another comment, but this seems more pertinent ;)

Thats exactly the approach I took with https://github.com/cloud-atlas-ai/miranda, Telegram bot, PR is the human review point, tests + CodeRabbit catch most issues.

Bot intercepts Claude's AskUserQuestion calls via a hook, sends me an inline keyboard, injects my answer back into the session. Claude keeps working, PR still happens—but I can unblock it from my phone in 5 seconds instead of rejecting a PR based on a wrong guess.

Steve Yegge is building awesome things in this space, but I've found them too heavy, started using bd when it was small, but now its trying to do too much IMO, so made a clone, tailored to my use case -> https://github.com/cloud-atlas-ai/ba

Same approach here. PR is the human review point, tests + CodeRabbit catch most issues -> https://github.com/cloud-atlas-ai/miranda.

The gap I wanted to fill: when Claude is genuinely uncertain ("JWT or sessions?" "Breaking change or not?"), it either guesses wrong or punts to the PR description where you can't easily respond.

Built a Telegram bot that intercepts Claude's AskUserQuestion calls via a hook, sends me an inline keyboard, injects my answer back into the session. Claude keeps working, PR still happens—but I can unblock it from my phone in 5 seconds instead of rejecting a PR based on a wrong guess.

Works in tandem with a bunch of other LLM enhancers I've built, they're linked in the README or that repo

Cassie.fm the newest and jankiest entry into the crowded uptime monitoring space now offers status pages and a public status API in its already generous free tier.

Check out my previous Show HN (https://news.ycombinator.com/item?id=42284411) post for more details on the service.

Hi HN,

I built Cassie.fm (https://cassie.fm) website and API monitoring service.

Why?

I run a tiny software shop, and bulk of our work consists of integrating our products (field service management app) on top of various ERPs (local and ancient for the most part). These ERPs often have APIs tacked on as a afterthought. These go down very often . If the API we integrate with goes down, it looks bad for us since our product does not work, so in order to drive accountability and transparency I hacked together an API monitoring solution. I wanted something that:

- Scales as we add more monitors: Pay only for what you use. No subscriptions. (We're actually paying for our own credits, its a bit weird with accounting but it forced me to do a proper Stripe integration)

- Real-time alerts, sms, email and webhooks, so that we can keep everyone in the loop including our user facing apps.

- Simple, transparent pricing, maybe we decide to invest more heavily in marketing this to our existing clients, and most pricing these days is garbage

What’s Next?

I'm building this to solve a specific business problem for my shop. I like to be driven by actual users, so as adoption grows so will the feature set. Some things I'm considering are analytics, and customisable alerts, response structure checks and schema validation.

Get Started

Register - https://cassie.fm/account/register. You get free 1600 daily credits, no strings attached. Accounts that have no monitors are automatically purged after 30 days, and I promise I won't send you any emails unless you send some first :).

This sounds a lot like my dream setup, We've been slowly building something along those lines. I've linked a video at the bottom that shows how we did something similar with an Obsidian plugin. Hit me up if you're interested in more details, we'd be happy to get an alpha user who gets it.

We've mostly had trouble explaining to ppl what exactly it is that we're building, which is fine, since we're mostly building for us, but still it seems like something like this would be the killer app for LLMs

Obsidian Canvas UI demo -> https://www.youtube.com/watch?v=1tDIXoXRziA

Also linking out Obsidian plugin repo in case someone wants to dive deeper into what we're about -> https://github.com/cloud-atlas-ai/obsidian-client

Very zeitgeisty :), I've created something similar a while ago (https://tmp.page), the idea was to have expiring web pages, with a nice API. Our FEs are quite similar, yours is nicer tough :).

Something I've built to serve a specific need, then scope creep happened.

Few notable features are:

+ expiration of one minute to one day

+ optional password protection

+ everything stored encrypted

+ deleted as soon as expired.

+ no registration and no limits (until something breaks :))

+ REST API for creation and retrieval

While reading random posts here I realised that there is a slew of people selling stuff on Amazon, relying on customer product reviews as their main source of feedback.

As Amazon does very little to make searching through these reviews friendly I decided to build something to facilitate getting useful info out of product review data.

There is a short video on the [landing page](http://research.oneiros.cc) you can watch in case below is TL:DR.

The basic idea is that you subscribe to products , the app scrapes reviews from Amazon (.com and .co.uk ATM). The user than has the ability to search through the reviews as well as get some basic breakdowns of words and phrases people use as part of positive or negative reviews (courtesy of a basic lexical analysis).

As this is a sort of `alpha` signup is of course free and fast (no email verification ;)), and due to my puny infra each user is limited to five products.

Anyway all feedback is welcome and extremely appreciated.

I've been keeping busy with re:search, an Amazon product review search, mining and insights, http://research.oneiros.cc

An interface on top of a learning algorithm that would alert users when certain conditions are met (certain word mentioned for example) as part of an Amazon customer review.

POC version would allow users to subscriber to products sold on Amazon and search through its reviews, as well as get some basic statistics about lexic patterns in reviews (positive or negative, most common words...). Based on the initial adoption the learning algorithm would come into play and provide suggestions and insights based on customer reviews.