MurphyA/hacker-news huggingface dataset:
Back end where you just define schema, access policy, and functions
by emilss | 2026-02-22 23:01:42+00:00
Would you use a backend where you just define schema, access policy, and functions?

Basically something like making smart contracts on EVM, but instead they run on a hyperscaler, and have regular backend fundamentals.

Here's a mock frenchie made me, was thinking something like this:

schema User {
email: string @private(owner)
name: string @public
balance: number @private(owner, admin)
}

policy {
User.read: owner OR role("admin")
User.update.balance: role("admin")
}

function transfer(from: User, to: User, amount: number) {
assert(caller == from.owner OR caller.role == "admin")
assert(from.balance >= amount)
from.balance -= amount
to.balance += amount
}

Was playing with OpenFGA, and AWS Lambda stuff, and got me thinking about this.

So you would "deploy" this contract on a hyperscaler, which then let's users access it from your lean js front-end, via something like this:

const res = await fetch("https://api.hyperscaler-example.com/c/your-contract-id/transfer", {
method: "POST",
headers: {
"Authorization": "Bearer <user-jwt>",
"Content-Type": "application/json"
},
body: JSON.stringify({
from: "user_abc",
to: "user_xyz",
amount: 50
})
});

The runtime resolves the caller identity from the JWT, checks the policy rules, runs the function, handles the encryption/decryption of fields and so your frontend never touches any of that.

That's it, would you use it? Is there something that does this exactly already? Feeling like building this.
by wakawaka28 | 2026-02-22 23:03:21+00:00
I'm not sure either but some of those things are bashisms. `<(...)` is a bashism and won't work in some shells. Honestly I ONLY use bash, so it's fine for me, but since you seem to be a pedantic person I thought you should consider trying to solve that puzzle too. Someone might want to copy and paste your command into csh, tcsh, zsh, sh, or ksh. Some of these may support bashisms and some don't. I haven't tried to investigate further either, even to the point of talking to an AI about it, but if you want max nerd cred then you can shoot for it. Keep in mind that csh/tcsh is not entirely POSIX compliant, but it is default on some BSDs.
by throwaway290 | 2026-02-22 23:03:51+00:00
So try to sell your high tech product to literal charity next and see what they offer. As you can imagine after this thought experiment, we're not talking about literal charities.

If you want to make money don't be surprised they also want to make money. If it is financially better to build it themselves they will, or they will tell their friends. Pro tip: don't tell them enough.

Just like in China if they can take your product and slap their own label and sell it at 50% discount they will.
by SirensOfTitan | 2026-02-22 23:04:18+00:00
Right. So then when is the best time for labor to act to ensure those mechanisms are put in place? Before or after AI has eliminated its leverage?

Like I totally realize we're agreed in some sense, but some form of socialism now in the US seems politically untenable, and as soon as AI actually starts making service labor obsolete, we lose our leverage. How do we do something about it?
by _pdp_ | 2026-02-22 23:04:44+00:00
You don't need to use OpenClaw, NanoClaw or any of these new variants. You can literally use Codex, Claude Code, Gemini, OpenCode for the same thing. The only thing that it is missing from all of them is the communication channels because none of them come with native communication tools like OpenClaw.

But this is not such a big deal.

I made an open-source lightweight daemon in Go that fills that gap. All it does is to provide the means to connect to popular messaging systems like Slack, Discord, WhatsApp, Telegram, etc. and expose this all through the CLI.

The project is hosted here: https://github.com/pantalk/pantalk

My personal realisation recently has been that the unix way is the best way. We just need to go back creating daemons and lightweight composable CLIs and let agents do their thing. They are increasing being trained to operate the command-line and they are getting pretty good at it.
by skznnz | 2026-02-22 23:05:49+00:00
> Could become new power tools.

If this worked, it’d have worked on low cost devs already. We’ve had the ability to produce large amounts of cheap code (more than any dev can review) for a long time.

The root issue is it’s much faster to do something yourself if you can’t trust the author to do it right. Especially since you can use an LLM to speed up your understanding.
by hug | 2026-02-22 23:05:54+00:00
About the only thing about the weather I can tell from my window is whether it is currently raining or not.

The temperature inside is not at all indicative of the temperature outside, the sun being out doesn't mean it is warm, and I don't really have any useful indicators of wind, unless the windows are rattling, but that doesn't let me know if there's a stiff breeze.

I could walk over and open up my balcony door and experience it all personally, but checking my phone or watch is faster and more accurate, and also gives me the forecast at the same time.
by comex | 2026-02-22 23:05:54+00:00
Reply to self: I managed to get their code running, since they seemingly haven’t published their trajectories. At least in my run (using Opus 4.6), it turns out that Claude is able to find the backdoored function because it’s literally the first function Claude checks.

Before even looking at the binary, Claude announces it will“look at the authentication functions, especially password checking logic which is a common backdoor target.” It finds the password checking function (svr_auth_password) using strings. And that is the function they decided to backdoor.

I’m experienced with reverse engineering but not experienced with these kinds of CTF-type challenges, so it didn’t occur to me that this function would be a stereotypical backdoor target…

They have a different task (dropbear-brokenauth2-detect) which puts a backdoor in a different function, and zero agents were able to find that one.

On the original task (dropbear-brokenauth-detect), in their runs, Claude reports the right function as backdoored 2 out of 3 times, but it also reports some function as backdoored 2 out of 2 times in the control experiment (dropbear-brokenauth-detect-negative), so it might just be getting lucky. The benchmark seemingly only checks whether the agent identifies which function is backdoored, not the specific nature of the backdoor. Since Claude guessed the right function in advance, it could hallucinate any backdoor and still pass.

But I don’t want to underestimate Claude. My run is not finished yet. Once it’s finished, I’ll check whether it identified the right function and, if so, whether it actually found the backdoor.
by krackers | 2026-02-22 23:05:57+00:00
I also did err by making a blanket statement "no one price matches for protein bars", so GP was right to call it out.

I do understand and see that there are cases in which one's time preference could be such that it is sensible or necessary to price-match at that granularity even when buying a single unit. However even then there's still other constraints such as cost of transportation & reputation of vendor.

Even today you can often find protein bars or name-brand supplements on Amazon for a slightly lower price (including shipping) than supermarkets, but that comes with the risk of adulterated, expired, or tampered products that not everyone will accept for the sake of slightly lower prices.
by vunderba | 2026-02-22 23:06:04+00:00
> Very fast efficient UI driven (multi app/web/desktop at the same time, agnostic) validation while you vibe.

This sounds neat in practice, but what does this mean exactly?

Most devs I know integrate Opencode/Codex/etc through something like Playwright-MCP which handles testing, physically clicking on elements, and validation through a combination of DOM inspection, JS evals, and screenshots.

It's not the fastest thing in the world because it still has to spin up a browser (headless or otherwise) - but I don't see how that's avoidable if you want genuine E2E testing.
by fweimer | 2026-02-22 23:06:11+00:00
> A human can't search 10 apps for the best rates / lowest fees but an agent can.

Why would those apps permit access by agents?

It's always been the case that “agents” could watch content with ads, so that the users can watch the same content later, but without ads. The technology never went mainstream, though. I expect agents posing as humans would have a similar whiff of illegality, preventing wide adoption.

Local agents running open weights models won't really work because everybody will train their services against the most popular ones anyway.
by slightwinder | 2026-02-22 23:06:11+00:00
> At present your memories are proprietary data in whichever LLM you use.

There is an export-function.

> What if you want to use other models as well?

Then do that? Does one AI having chats with you, prevents you from using the other?

> Third, OpenClaw allows you to run your models as agents.

Don't they all allow that?

> We already have examples of these agents creating an AI religion

More like Humans playing bots, doing some shenanigans. That was all stage play, humans and bots role-playing what western culture expects to happen in such a scenario.
by dryarzeg | 2026-02-22 23:06:11+00:00
That reminds me of one joke that I heard recently:

- Dad, dad, do you and your colleagues use artificial intelligence at work?

- Oh, dear, we don't even use natural intelligence...

As they say, every joke has a grain of truth in it. There are people who, in principle, do not think about why they do something or what the consequences will be. That's just the way they are.
Show HN: Sayiir Powerful/durable Rust workflow engine – Python/Node.js bindings
by ybsoft | 2026-02-22 23:07:19+00:00
Hi HN! I built Sayiir, an open-source durable workflow engine with a Rust core.

The problem: most workflow engines (Temporal, Airflow, Prefect) require heavy infrastructure, custom DSLs, or replay-based execution that forces determinism constraints on your code. Replay means re-executing your entire workflow history on every recovery — and you can't freely call external APIs or use arbitrary libraries without careful wrapping.

Sayiir takes a different approach: continuation-based execution.

- On crash recovery, it resumes from the last checkpoint — not from the beginning. No replay overhead.
- No determinism constraints. Your tasks can call any API, use any library. No purity rules, no sandboxing.
- No DSL. Workflows are composed with native language constructs — a workflow! macro in Rust, a fluent builder in Python/TypeScript.
- Pluggable persistence. PostgreSQL backend is stable, codec layer supports JSON or zero-copy binary (rkyv).

Architecture: the core is a graph-based execution engine in pure Rust (hexagonal architecture). Python bindings via PyO3/maturin, Node.js via NAPI-RS. Everything is stable — core, Python, Node.js, and Postgres backend.

I chose continuation-driven over replay-driven because replay engines pay a growing cost as workflow history lengthens, and they push complexity onto developers (determinism rules, versioning). Continuations checkpoint state at each step boundary, so recovery is O(1) — just deserialize and go.

Try it live in the playground: https://docs.sayiir.dev/playground/

Docs: https://docs.sayiir.dev
crates.io: https://crates.io/crates/sayiir-runtime
Discord: https://discord.gg/A2jWBFZsNK

MIT licensed. Looking for contributors, early adopters, and feedback. Happy to answer any questions about the architecture or tradeoffs.
by fuzzfactor | 2026-02-22 23:07:27+00:00
That's because they use high-pressure tanks.

Actually higher working presure than regular welders' oxygen tanks.

Too bad the higher the pressure, the heavier the tank, especially steel.

I had a pretty good job offer from a company that was going to start building CNG tanks out of carbon fiber.

This was a few years before the failure of the Titan submersible.

CNG has made some progress since then, here's the kind of thing there is now:

https://steelheadcomposites.com/sites/default/files/2024-01/...
by halostatue | 2026-02-22 23:08:53+00:00
Disclaimer: I haven't tried this yet.

I would want the equivalent of the trixie-slim Docker image (Debian 13, no documentation). It's ~46 Mb instead of ~4Mb as a Docker image, but gives a reasonably familiar interface.

(This is largely based on some odd experiences with Elixir on Alpine, which is where I am doing most of my work these days.)
Show HN: Agentloom – import skills, agents, commands, and MCP from repos
by farnoodma | 2026-02-22 23:08:59+00:00
Why I built this:
I kept redoing the same setup across AI tools and repos. Skills/prompt agents/commands/MCP servers lived in different places, each tool had different config formats, and onboarding kept breaking from config drift.

Agentloom is my attempt to keep one canonical source of truth and sync to provider-native outputs (Codex, Claude, Cursor, Gemini, Copilot, OpenCode).

Core workflow:
npx agentloom add obra/superpowers

That imports an entire stack from a source repo:
- skills/
- agents/
- commands/
- mcp.json

Then sync generates each provider’s native files from that canonical source.

Repo: https://github.com/farnoodma/agentloom

Would really value feedback on:
1) conflict UX in non-interactive CI mode
2) lockfile/reproducibility model
3) boundaries between shared core vs provider-specific behavior
by charleslmunger | 2026-02-22 23:10:01+00:00
The default Gboard keyboard has settings for always showing the number row, or only showing it when entering a password. There is also a setting for the "suggestion strip" under "corrections & suggestions". You can also drag to resize the keyboard itself in the Gboard menu, to scale the height.

Now, whether your users will do that to play your game is a different story, but the options exist.
by MPender08 | 2026-02-22 23:10:28+00:00
Hey HN, I’m an independent researcher. I've been exploring the thermodynamic limits of AI and built a theoretical hardware framework and PyTorch simulation to address it.

The Problem: Current digital AI is hitting the "Landauer Wall": the massive energy cost of erasing bits and brute-forcing hierarchical data in flat, static Euclidean matrices.

The Project: This is the Manifold Chip, a Dynamically Gated Analog Crossbar (DGAC) architecture. It uses analog Field Effect Transistors (FETs) as variable shunts to warp its own effective geometry on the fly. Instead of routing sparse data through a static grid, the chip physically "plunges" into a non-Euclidean/hyperbolic state when it encounters error stagnation, creating geodesic shortcuts.

The Code: The repo includes a PyTorch simulation (run_brain_sim.py) mapping this continuous thermodynamic decay. In a non-linear XOR stamina test, the "VIP Voltage" (global error signal) triggers a geometric transition that yields a 5x convergence speedup while drastically cutting maintenance power.

The Theory: This architecture translates the biophysics of Martinotti/SST-mediated dendritic gating into silicon. It builds on two broader papers I've recently published on the thermodynamics of dynamic curvature adaptation (links in the repo, bottom of the README.md)

I used LLMs (Gemini) strictly as a technical sounding board to help formalize the math, prototype the PyTorch geometry, and apply my biophysics theory to silicon.

I’m a self-taught researcher and would love to hear the community's honest thoughts on the memristor-shunt logic, the analog fault tolerance, and the manifold scaling laws.
by jaygreco | 2026-02-22 23:10:36+00:00
I really like epaper displays for all of the reasons mentioned in the article. Shame the patent locks continue to keep prices high even though the core technology has improved enough for prices to drop.

A few years ago I came into a couple of e-ink displays that had been previously used for storefront/product pricing. The hardware to drive them was locked down but I was able to reverse engineer the panel by finding a datasheet that was close enough and hacking up an adafruit thinkink. I had a lot of fun writing my own driver/abstraction layer. I originally intended to support a bunch of different panels but ran out of steam after the first one did exactly what I wanted.

https://github.com/jaygreco/MagInkCal
Show HN: Free AI tool that analyzes your Strava training data
by jakeboyd4444 | 2026-02-22 23:11:15+00:00
I built rexcoach.com because I'm a runner who's brain responds better to numbers than "feel." It connects to Strava, analyzes your training data, and flags issues like running too fast, intensity distribution, and cardiac cost. It's free, just looking for feedback.
by ahartmetz | 2026-02-22 23:11:27+00:00
I have a Strix Halo laptop, HP ZBook Ultra G1a. (HP is a weird brand. I'm not a loyal customer, but every once in a while they create a product with really good reviews, I buy it, and it delivers.) Performance is almost on par with Apple's best, but battery life under light load is much worse :P, 6:30 or so.

Under full load, battery life is an hour or so, similar to Apple actually! If the numbers I've seen are correct, they also use a lot of power under full load.

Also, thank $deity for engineered noise signatures. Whooshing is not so bad. Whining fans are the worst. Last heard in better laptops several years ago.
by aleph_minus_one | 2026-02-22 23:11:29+00:00
A fun fact about Grokipedia:

Many pages about math-related topics contain quite some "red text", i.e. parts that don't render properly, e.g.

> https://grokipedia.com/page/Derived_category (scroll down; for this page the mentioned phenomenon is particularly pronounced)

> https://grokipedia.com/page/K-theory

> https://grokipedia.com/page/Actuarial_notation

> https://grokipedia.com/page/Cobordism (scroll down to "Advanced Perspectives")
by ryanckulp | 2026-02-22 23:11:31+00:00
thanks for the support and i hear you. a few folks pointed their Boox at TRMNL[1], and we’re finally in the smart home arena now with free 5 min refresh rate for Home Assistant. aiming for JIT refresh by summer.

1. https://www.reddit.com/r/Onyx_Boox/s/ZSLF7u5pm8
by piskov | 2026-02-22 23:11:58+00:00
> A phantom read is one where a transaction runs the same SELECT multiple times, but sees different results the second time around

> Under the SQL standard, the repeatable read level allows phantom reads, though in Postgres they still aren't possible.

This is bad wording which could lead to an impression that a repeatable read may show different values. Values in rows will be the same but new rows may be added to the second result set. New rows is important as no previously read rows can be either changed or deleted — otherwise there will be no repetition for those rows second time around.
by abound | 2026-02-22 23:12:24+00:00
I noticed my Tailscale-based homelab was struggling to serve basic web traffic via an ingress VM, and figured out the problem was DERP-related. Tailscale recently announced the GA of Peer Relays [1], and I wonder if the timing is not a coincidence: e.g. their centrally hosted DERP servers are getting overwhelmed, and they're hoping to offload some traffic to customer-hosted relays.

[1] https://news.ycombinator.com/item?id=47063005
Show HN: Open-sourced an AI agent directory with an automated discovery pipeline
by mot92 | 2026-02-22 23:12:48+00:00
I run aiagents.directory and got tired of manually curating agents. Built a pipeline to automate it:

1. Sourcing: Firecrawl Search API + LLM extraction to find agents mentioned in blog posts and list articles, not just homepage links. Filters junk via blocklists and deduplication.

2. Enrichment: Scrapes each site for features, pricing, screenshots, logos. Handles aggregator pages (ProductHunt, YC) by extracting the actual product URL.

3. Review: Pydantic AI agent (GPT-powered) classifies submissions. Returns confidence scores. High confidence auto-applies, low confidence flags for manual review.

I still trigger it manually and review before publishing — want to make sure output quality is solid before I flip it to full automation. Code's up if the approach is useful to anyone building directories or curation pipelines. Questions/feedback welcome

https://github.com/mohamed-taha/aiagents-directory-oss
by woodruffw | 2026-02-22 23:13:33+00:00
> LLMs don’t have such instincts and can potentially be instructed to present or evaluate the primary, if opposing, arguments.

It seems essentially wrong to anthropomorphize LLMs as having instincts or not. What they have is training, and there's currently no widely accepted test for determining whether a "fair" evaluation from an LLM stems from biases during training.

(It should be clear that humans don't need to be unpolitical; what they need to be is accountable. Wikipedia appears to be at least passably competent at making its human editors accountable to each other.)
by b00ty4breakfast | 2026-02-22 23:13:41+00:00
this is like using an "ethically produced" brick to smash your foot with; The method of manufacturing the brick isn't the problem.

These formats are designed for a specific purpose; maximizing engagement to extract value.

so we've remove the incentive to extract value but we leave the predatory design that maximize engagement? You working in a different milieu but you are bringing the worst parts of the previous milieu along for the ride.

Please, anybody working on this kind of alternative social platform, we need to rethink how we interact online; decentralization leaves the worst parts of modern social media completely unaddressed.
by jameshart | 2026-02-22 23:13:51+00:00
Outside my house right now it’s a cold, still evening with a high overcast. My expectation based on my years of experience living here and having seen these conditions before would be that it would likely clear out overnight, freeze hard, and be a beautiful day tomorrow.

In fact, though, a massive bomb cyclone is forming a few hundred miles away and it’s likely to dump over a foot of snow on us in the next 24 hours, accompanied by 50mph winds.

Weather forecasts are, not surprisingly, actually useful.
by thaumasiotes | 2026-02-22 23:14:22+00:00
> So I fixed the debugger (it turned out to be a one-line configuration change)

That line links to the commit, which adds

.withDebug(true)

to an invocation of GradleRunner in a file named AllFunctionalTests.kt in the krossover project.

My question is:

Why can the software choose whether, when I run a debugger on it, the debugger will work?

It can't, of course, so what's going on?
by pfdietz | 2026-02-22 23:14:28+00:00
I'm sorry but you appear to be completely deranged. The paper says nothing of the sort. Let me give the abstract:

"This paper compares the relative cost of long-distance, large-scale energy transmission by electricity, gaseous, and liquid carriers (e-fuels). The results indicate that the cost of electrical transmission per delivered MWh can be up to eight times higher than for hydrogen pipelines, about eleven times higher than for natural gas pipelines, and twenty to fifty times higher than for liquid fuels pipelines. These differences generally hold for shorter distances as well. The higher cost of electrical transmission is primarily because of lower carrying capacity (MW per line) of electrical transmission lines compared to the energy carrying capacity of the pipelines for gaseous and liquid fuels. The differences in the cost of transmission are important but often unrecognized and should be considered as a significant cost component in the analysis of various renewable energy production, distribution, and utilization scenarios."

I'm to read this as supporting your assertion that electrical transmission is several times cheaper??
by crazygringo | 2026-02-22 23:14:33+00:00
> Especially the current weather conditions. That's mostly useless info

Do you... not go outside? And not need to know if you need the heavy coat, light coat, light waterproof coat, and/or umbrella? Or pants vs shorts? And the answers are very different at 7am vs 11am vs 3pm?

I'm not trying to be sarcastic, I'm just genuinely baffled.