value: asabil

value:
Hi HN,
I just wanted to share what I have been working on for the past few months: A firmware analyzer for embedded Linux systems that helps uncovering security issues running entirely in the browser.
This is a very early Alpha. It is going to be rough around the edges. But I think it provides quite a lot of value already.
So please go ahead and drop a firmware (only .tar rootfs archives for now) and try to break it :)

value: Show HN: Local-first firmware analyzer using WebAssembly

author: asabil


value: dougdonohoe

value:
I was frustrated with photo sharing sites. Apple's iCloud shared albums take 20+ seconds to load, and everything else comes with ads, cumbersome UIs, or social media distractions. I just want to share photos with friends and family: fast, mobile-friendly, distraction-free.
So I built DD Photos. You export photos from whatever you already use (Lightroom, Apple Photos, etc.) into folders, run `photogen` (a Go CLI) to resize them to WebP and generate JSON indexes, then deploy the SvelteKit static site anywhere that serves files. Apache, S3, whatever. No server-side code, no database.
Built over several weeks with heavy use of Claude Code, which I found genuinely useful for this kind of full-stack project spanning Go, SvelteKit/TypeScript, Apache config, Docker, and Playwright tests. Happy to discuss that experience too.
Live example: https://photos.donohoe.info
Repo: https://github.com/dougdonohoe/ddphotos

value: Show HN: DD Photos – open-source photo album site generator (Go and SvelteKit)

author: dougdonohoe


value: garymiklos

value: Show HN: Smux – Terminal Multiplexer built for AI agents

author: garymiklos


value: dnhkng

value:
I found that duplicating a specific block of 7 middle layers in Qwen2-72B, without modifying any weights, improved performance across all Open LLM Leaderboard benchmarks and took #1. As of 2026, the top 4 models on that leaderboard are still descendants.
The weird finding: single-layer duplication does nothing. Too few layers, nothing. Too many, it gets worse. Only circuit-sized blocks of ~7 layers work. This suggests pretraining carves out discrete functional circuits in the layer stack that only work when preserved whole.
The whole thing was developed on 2x RTX 4090s in my basement. I'm now running current models (GLM-4.7, Qwen3.5, MiniMax M2.5) on a dual GH200 rig (see my other post). Code and new models coming soon.
Happy to answer questions.

value: Show HN: How I topped the HuggingFace open LLM leaderboard on two gaming GPUs

author: dnhkng


value: heddycrow

value:
Hi HN — I am building Parascene as a place to create and share different kinds of art.
It supports AI-generated images, algorithmic/generative art, and traditional artwork. The goal is to put them in the same space so people can explore techniques, prompts, and creative ideas across mediums.
Current features include image generation tools, a public gallery, prompt sharing, and profiles where artists can post work.
Another goal is to encourage, enable, and reward local AI usage by sharing generation capabilities among the community.
I’m interested in feedback on the concept and the product. Does combining these mediums in one platform make sense?
https://www.parascene.com/help

value: Show HN: Parascene – a platform for AI, algorithmic, and traditional art

author: heddycrow


value: cgallic

value:
The write-path control plane for AI agents.
AI agents can read systems freely. The problem is writes — CRM imports, email sends, database updates, refunds. Once the agent does it, you can't unsee it.
Gate sits between the agent and production. Agents submit an intent, Gate evaluates a YAML policy, and only then issues a signed execution order. No LLM at evaluation time — same input always produces the same output.
The flow:
  POST /v1/intents → policy evaluated → approved/blocked/pending
  POST /v1/intents/:id/execute → gex_ token (15 min TTL)
  Worker uses token → reports outcome
  Full audit trail: proposed → policy_checked → approved → execution_requested → execution_succeeded

value: Show HN: Gate – deterministic write-path checkpoint for AI agents

author: cgallic


value:
Hey HN,
Quick origin story: vr.dev started as a virtual reality project. The domain fit perfectly. The developer adoption did not. Rather than let a good domain go to waste, I pivoted to the other kind of VR: verification and rewards for AI agents.
The problem I kept running into: agents report success but system state tells a different story. The database row is still active. The IMAP sent folder is empty. The tests pass because the agent modified the tests. Real benchmarks put agent success at 12-30%, and even among reported successes a large fraction are procedurally wrong in ways that are hard to catch without actually checking state.
So I built a library of verifiers that check real system state rather than trusting agent self-reports. There are 38 of them across 19 domains right now, organized into three tiers: HARD (deterministic probes against databases, files, APIs, git), SOFT (LLM rubric scoring for things like tone or coherence that don't have a deterministic test), and AGENTIC (verifiers that actively probe the environment via headless browser, IMAP, or shell).
The design decision I'd most like feedback on is the composition model. SOFT scores are gated behind HARD checks, so if the deterministic check fails, the composed score is 0.0 regardless of what the LLM judge says. The idea is to make reward hacking structurally harder rather than just hoping the judge catches it.
MIT licensed, runs locally via pip install vrdev, no dependency on the hosted API which matters if you're using it in a training loop. Full verifier list at https://vr.dev/registry.
Curious whether the HARD/SOFT/AGENTIC taxonomy makes sense to people, whether fail_closed is the right default, and whether anyone has built something similar and run into problems I haven't hit yet.
https://vr.dev
https://github.com/vrDotDev/vr-dev
https://pypi.org/project/vrdev/

value: Show HN: VR.dev – Open-source verifiers for what AI agents did


value: zeebs

value: Show HN: Sites that publish instantly and expire if unclaimed

author: zeebs


value: rzendacott

value:
Demo video: https://youtu.be/-CTRdTIcsis
Play the game from the demo: https://buildwithstar.com/games/fd073fef-6525-422f-a0ef-d0fa...
Tell Claude Code, Cursor, or Codex to "build a game with a leaderboard using star-sdk" and it just works. The agent discovers the package, registers your game, and wires up audio, canvas, and leaderboards autonomously.

  npx star-sdk init "My Game"

  import Star from 'star-sdk';
  Star.init({ gameId: '<gameId from .starrc>' });
  Star.audio.play('coin');        // built-in sounds, works on iOS Safari
  Star.leaderboard.submit(1250);  // no backend, no auth
  Star.leaderboard.show();        // built-in leaderboard UI

  npx star-sdk deploy
  # => Live at https://buildwithstar.com/games/<id>

Two commands: register and deploy. Everything in between is just code.
Three things break every time you generate a browser game: audio on mobile (especially iOS Safari), canvas sizing across devices, and leaderboards without a backend. Star SDK fixes all three.
Audio is the sneaky one. Star SDK ships 17 procedural synth sounds that just work everywhere — no asset files, no loading screens. Bring your own MP3s when you're ready; the SDK handles cross-browser audio and iOS unlocking so you don't have to.
The SDK is the documentation. Built by LLMs, for LLMs — run "npx star-sdk install" and your AI agent gets full API docs, examples, and correct usage patterns automatically. No docs to read. The agent reads them for you.
"npx star-sdk deploy" gives you free hosting with a shareable link — leaderboards just work. No servers, no Vercel, no GitHub Pages.
Why I built this: I run a game platform (Star, YC S22) with over 2,000 published games built on the same SDK. These pain points came up constantly. Now extracted so anyone can use it.
Why free? The SDK feeds into Star, but works standalone. You never have to touch Star if you don't want to.
Try the examples: https://buildwithstar.com/sdk/examples/click-frenzy/ | https://buildwithstar.com/sdk/examples/dodge/ | https://buildwithstar.com/sdk/examples/reaction-time/ — single HTML files, view source to see the code.
See what others have built: https://buildwithstar.com/explore
npm: https://www.npmjs.com/package/star-sdk
Docs: https://buildwithstar.com/docs/sdk
GitHub: https://github.com/buildwithstar/star-sdk
Would love feedback — especially if you're building games with AI agents. What other pain points should this solve?

value: Show HN: Star SDK – Fixing the 3 biggest annoyances with generated browser games

author: rzendacott


value:
I'm learning German and couldn't find a simple, focused tool for
memorizing noun articles. Most apps bury this in a broader
curriculum. I wanted something that just drills der/die/das using
spaced repetition, works offline with no account required, and lets
you add your own vocabulary.
Built with Expo + React Native + SQLite (local-first, no data leaves
the device). Available on iOS and Android.
iOS: https://apps.apple.com/us/app/%C3%BCben-german-articles/id67...
Android: https://play.google.com/store/apps/details?id=com.westmorela...
Would love feedback on the SM-2 tuning and whether the daily session
length feels right.

value: Show HN: Üben – Free offline app for drilling German noun articles (der/die/das)


value: mynameisntbob

value:
Hey HN,
I built gui.new. You paste one line into ChatGPT or Claude, and from that point on, whenever you ask for something visual (a dashboard, chart, form, report) it renders it as a live shareable link instead of dumping HTML in your chat.
The prompt:
"Read https://gui.new/docs/llms.txt - use gui.new to render any visual output as a shareable link. Apply this anytime you'd normally show a table, chart, dashboard, or UI mockup."
That's the whole setup. Your AI reads the spec, starts using it, and every visual output becomes a clickable URL you can share with anyone.
Every link gets real-time input sync (form fields, sliders, toggles work across all viewers), state persistence (survives after everyone leaves), and live updates via SSE. Links expire after 24 hours by default.
I built it because AI is great at generating UIs but terrible at showing them. You ask for a dashboard and get a code block. gui.new closes that gap.
Under the hood, your AI is making a single POST call to create a canvas:
```
POST <a href="https://gui.new/api/canvas" rel="nofollow">https://gui.new/api/canvas</a>
{"html": "<h1>Hello</h1>"}<p>-> {"url": "<a href="https://gui.new/abc123" rel="nofollow">https://gui.new/abc123</a>"}
```
You don't need to interact with the API yourself. But if you want to, there are SDKs (`npm install gui-new` / `pip install gui-new`) and the REST API is documented at gui.new/docs.
Free, no signup. Try it at https://gui.new
Happy to answer questions!

value: Show HN: Gui.new – The Visual Layer for AI

author: mynameisntbob


value: hilti

value:
We keep shipping data to the cloud to analyze it, but modern Macs have enough horsepower to query millions of rows locally in milliseconds. Even an 8GB MacBook Neo.
I built ColumnLens because I wanted to stop uploading sensitive data to SaaS tools just to run a GROUP BY. It's a native C++ desktop app that opens 5GB+ CSV, JSONL, Parquet, and Excel files in about 3 seconds, then lets you query them with DuckDB's full SQL engine — JOINs, CTEs, window functions, all running on your machine.
The idea is simple: your laptop is a perfectly good analytics workstation. You shouldn't need a cloud pipeline to look at your data.
Some things I learned building it:
- DuckDB's columnar engine is absurdly efficient. 12M rows, sub-second queries, under 1 GB RAM. On hardware that fits in a backpack.
- ImGui + OpenGL is a great stack for data-heavy desktop apps. No DOM, no layout engine overhead — just raw GPU rendering. The data grid scrolls 12M rows without a single frame drop.
- I added a "3D City View" that maps rows to buildings (height = one column, color = another). Sounds gimmicky, but outliers and clusters are immediately visible in ways they aren't in tables or charts. Our brains are good at spotting the tall building in a skyline.
- Lua scripting turned out more useful than expected. People write small scripts to fetch data from APIs, run queries, and configure charts — repeatable analysis without leaving the app.
- Everything runs locally. Zero telemetry, zero network calls. The binary is 33MB, statically linked.
Free download at https://columnlens.com
Would love to hear from anyone else building local-first data tools — I think the "ship everything to the cloud" era is starting to swing back.

value: Show HN: ColumnLens – Query millions of rows in milliseconds on your Mac

author: hilti


value: Jotalea

value: Show HN: I ditched frameworks to build a <512kb personal site

author: Jotalea


value: jacomoRodriguez

value:
Hey HN, I'm Mario. I recently talked to a colleague about AI, agents and how software development will change in the future. We were wondering why we should even share code anymore when AI agents are already really good at implementing software, just through prompts. Why can't everyone get customized software with prompts?
"Share the prompt, not the code."
Well, I thought, great idea, let's do that. That's why I built Open Prompt Hub: https://openprompthub.io.
Think GitHub just for prompts.
The idea is simple: Users can upload prompts that can then be used by you and your AI tools to generate a script, app, or web service (or prime their agent for a certain task):
Just past it into your agent or ide and watch it build for you. If the prompt does not 100% covers your usecase, fork it, tweak it, et voila: tailor-made software ready to use!
The prompts are simple markdown files with a frontematter block for meta information. (The spec can be found here: https://openprompthub.io/docs)
They versioned, have information on which AI models build it successfuly and have instructions on how the AI agent can test the resulting software.
Users can mention with which models they have successfully or unsuccessfully executed a prompt (builds or fail). This helps in assessing whether a prompt provides reliable output or not.
Want to create a open prompt file? Here is the prompt for it which will guide you through: https://openprompthub.io/open-prompt-hub/create-open-prompt
Security! Always a topic when dealing with AI and prompts? I've added several security checks that look at every prompt for injections and malicious behavior. Statistical analysis as well as two checks against LLMs for behaviour classification and prompt injection detection.
It's an MVP for now. But all the mentioned features are already included.
If this sounds good, let me know. Try a prompt, fork it, or tell me what you'd change in the spec or security scanner. I'm really curious about what would make you trust and reuse prompts. Or if you like the general idea...

value: Show HN: Open Prompt Hub – share intent, not code

author: jacomoRodriguez


value: artski

value:
Hey HN,
I wanted to build something real in Zig, and I was annoyed that Postman
needed an account and an internet connection just to send a GET request.
So I figured I'd make something I would actually use.
It kind of snowballed from there. 50,000+ lines later, it does requests,
test assertions, collections, environments, CI/CD reports, import/export,
and has a browser-based Web UI (`volt ui`). All in a single binary with
zero external dependencies.
Some numbers:

  - Binary size: ~4 MB (Postman: ~500 MB)
  - Startup: 42ms (Postman: 3-8 seconds)
  - RAM idle: ~5 MB (Postman: 300-800 MB)
  - Dependencies: 0
  - Account required: No

It uses plain-text .volt files that live in your git repo. Your API tests
are just files, versioned with your code.
For CI, you copy one binary and run `volt test`. No npm, no Docker, no runtime.
Why Zig? Honestly, I wanted an excuse to write a lot of Zig. But the
explicit allocators, comptime, and cross-compilation from one machine made
it practical to ship Linux/macOS/Windows from a single codebase with no
external packages.
There's a CLI, a TUI with tabs and search, and a Web UI. It's not perfect
but I use it daily and it hasn't crashed on me yet.
Site: https://api-volt.com
Repo: https://github.com/volt-api/volt
Benchmarks: https://github.com/volt-api/volt/blob/main/BENCHMARKS.md
Happy to answer questions about the Zig implementation, that's the part
I'm most excited to talk about honestly.

value: Show HN: Volt – Fast, Git-native API client written in Zig (Postman alternative)

author: artski


value: easymode

value: Show HN: Give your AI friend the gift of expression

author: easymode


value: juliushuijnk

value:
Tap on the canvas to create silly faces.
Discover new brushes by combining them on the canvas.
Used to be a React Native app from the pre-AI ages. Recently ported with AI to be just a wordpress plugin.

value: Show HN: Silly Faces

author: juliushuijnk

title: Show HN: Silly Faces


value: joozio

value:
I've been building Familiar - a macOS app that runs a local AI agent on your device. No cloud, no API key, no subscription.
The insight that kicked this off: a small model with good tool calling is already useful. I tested Qwen 3.5 9B on my M1 Pro 16GB and gave it a simple tool (rename files matching a pattern). It worked, offline, reliably. The model doesn't need to be smart about everything - it needs to know what tool to call next.
What Familiar does now:
- Hardware detection on first launch → recommends the best model your machine can run without becoming a heater
- Ships with a small default model so you're running in minutes
- File tools out of the box (create, rename, move, delete)
What I'm building toward:
Night shift mode — when you sleep, the app switches to a larger model using your full resources. The reasoning: you're not at the machine, so it can use 100% of what's available. You wake up to work done by a smarter local agent, no cloud involved.
Current limitations I won't gloss over: sub-3B models struggle with tool call reliability. Complex multi-step reasoning needs bigger models. The night shift feature exists specifically to unlock larger models during low-usage hours.
Stack: Swift/SwiftUI, MLX for inference on Apple Silicon. Tested on M1 Pro 16GB — intentionally not exotic hardware.
iOS companion is in progress (lighter capabilities, same local-first approach).
GitHub going public shortly. Happy to answer questions about the MLX inference setup or tool calling architecture.

value: Show HN: Familiar – Open-source local AI agent for macOS(and iOS)

author: joozio


value: elijahlucian

value: not a new concept, but here's something me and Ana made for our cross-system-cross agent management tool. our own proprietary web design DSL heh<p>Like any codebase, this will change over time, and if you have tried something similar, your ideas, PRs are welcome, let's build some cool shit!

value: Show HN: Get AI to write code that it can read

author: elijahlucian


value: kevinpicchi

value:
Hey HN,
I'm Kevin, and I've been building Inbox (https://inboxapp.com) — A CRM and an API for
sending and managing DM conversations across messaging platforms.
Right now we support X (Twitter) DMs. Instagram and LinkedIn are next on the roadmap. The idea is simple: DMs are becoming a primary communication channel for sales, support, partnerships, creator outreach — but there's no good programmatic layer for them. You either copy-paste manually or hack together brittle scrapers.
Inbox gives you a REST API with full thread and message management, a webhook system for real-time events (new messages, thread updates, status changes), and an MCP server so AI agents can manage your DMs directly. Your team also gets a shared inbox UI to handle conversations that need a human touch.
What you can do with the API:
- Send and receive DMs programmatically
- Manage threads (assign, tag, set pipeline stages)
- Sync conversation data to your CRM or internal tools
- Get real-time webhook events when anything changes
- Let AI agents handle DMs via our MCP server (works with Claude, Cursor, etc.)
We built this because i was doing support for my product over X DMs and realized the tooling just doesn't exist. X's own API for DMs is painful, rate-limited, and requires jumping through hoops. Most teams doing DM-based outreach or support end up with some combination of manual copy-paste, spreadsheets, and prayer.
The MCP server is the part I'm most excited about. You can point Claude or any MCP-compatible agent at your Inbox and it can read conversations, send replies, tag threads, update prospect info — basically run your DM workflows autonomously. We use it internally and it's become the thing i didn't know i needed.
Honest status: X support is solid and battle-tested. Instagram and LinkedIn
are coming Q2 2026. We're a small team, so I'd genuinely love feedback on what
platforms and integrations to prioritize.
API docs: https://docs.inboxapp.com
MCP server setup: https://docs.inboxapp.com/mcp-server
I'll be in the comments all day. Would love to hear: what DM-based workflows are you hacking together right now? What would you build if you had a clean API for this?

value: Show HN: Inbox – An API and MCP server for managing DMs programmatically

author: kevinpicchi


value: oah

value:
I built a site to find engineering manager jobs and make the manager job search less painful. This was created out of my own job search last year. I was using various job aggregator sites and spreadsheets and wanted a more efficient method.
The main value of the site is:
* High-quality job listings and data that is updated daily. It saves countless hours not having to sift through irrelevant or stale job listings.
Give it a try and feel open to share any feedback.

value: Show HN: Find Engineering Manager Jobs Efficiently

author: oah


value: cdnsteve

value: Show HN: A playable version of the Claude Code Terraform destroy incident

author: cdnsteve


value:
Hi HN,
My great-grandparents owned a small summer cottage which my grandma inherited. After COVID, my family stopped visiting so much and it fell in disrepair. With no one to care for it, my grandma decided to sell it.
On a whim, I did some digging and found that the cottage was actually listed as “culturally significant” by the Massachusetts Historical Commission. It had 150 years of incredible history we never knew. I put together a nice report, presented it to my family, and well now I’m writing this from that very cottage with a 5th generation (my son) next to me.
From that experience, I started HomeLore to help other people learn the history behind their homes and hopefully inspire a passion like mine. The concept is pretty simple.. we research homes (incl ownership, architecture, history, images, etc) and package the results into a beautiful, shareable online report that reads more like a narrative than a spreadsheet.
The idea of a “carfax for homes” seems so obvious but likely hasn’t been done due to lack of unified data. I keep costs low ($29) but still donate 50% of all proceeds to the local historical orgs I use in hopes of improving their infra or making them more interested in data. Hence the .org tld.
Would love to hear thoughts, find collaborators, or just chat with anyone about their homes stories! Find it at homelore.org

value: Show HN: HomeLore – Every home has a story. Let us tell it


value: simonbc

value:
Aaron Swartz and I built Jottit in 2007, a simple way for anyone to make a page on the web in seconds. You didn't have to create an account. You just typed something, clicked a button, and you got a page on a secret URL. If you wanted to keep it, you claimed it with your email. The original was wiki-style, more of a small site builder. It went offline years ago.
Building Jottit with Aaron was one of the most satisfying creative experiences of my life.
I've now rebuilt it from scratch. It’s basically the same idea, but even simpler. Go to jottit.org, write markdown, and you have a published page. Claim it, pick an address, and you now have a feed of your pages at yourname.jottit.org. There's no signup to start writing. And no js on public pages. You can export your writing when you want.
Jottit is free and open source. It's not a startup, just something I really wanted to exist again.

value: Show HN: Jottit – Reviving the Original from 2007

author: simonbc


value: Show HN: Claude Tuner – Monitor your Claude usage and find the right plan


value:
I went down the rabbit hole of AI memory, and this came out the other end.
Beliefs, behaviors, tensions, and contradictions extracted from conversations, journals, and published text, compressed into an identity brief that any model or memory system can use. An extracted operating guide for AI, where every claim traces back to source facts.
All research, benchmarks, documentation, examples are available on the website and in the github. This has been tested on as little at 8 Personal Journal Entries from a secondary subject, my own gpt conversations exports (30K+ Messages), and on large document corpora like Warren Buffett's Annual Shareholder Letters (350k words), Howard Marks Investment Memos (600K words), and dense autobiographies from Franklin, Douglass, Roosevelt, and Wollstonecraft.
Pipeline currently uses Claude. API costs are <$1 for small data sets and <$5 for large ones, from fact extraction to final brief assembly.
Very interested in feedback, happy to go deeper in the comments on evolution, struggles, research, and future improvements.

value: Show HN: Base Layer – Open-source behavioral compression from any text


value: leopoldj

value: svglib is a SVG file parser and renderer library for Windows. It uses Direct2D for GPU assisted rendering and XMLLite for XML parsing.<p>This is meant for Win32 applications and games to easily display SVG images.

value: Show HN: Svglib a SVG parser and renderer for Windows

author: leopoldj


value: noqcks

value:
Hello HN. I got sick of docker builds on my mac taking forever, so I built forja.
Forja is an ephemeral Docker builder that runs entirely in your own AWS account. It spins up real EC2 instances for each build (`c7a` for AMD64, `c7g` for ARM), builds your image with BuildKit, pushes cache layers to S3, and then tears the machine down.
Here’s how it works:
- The CLI asks AWS for a fresh EC2 instance with a pre-baked AMI (boots in ~5 seconds, ready to build in ~30).
- It sets up mutual TLS on the fly: for each build it creates a short-lived CA, issues client/server certs, drops them in S3, and both sides mutually auth before any data moves.
- BuildKit runs on the remote box, pulls/pushes cache layers to S3 so future builds stay fast even though every machine is ephemeral.
- When the build finishes or fails—or even if you Ctrl+C—the instance self-terminates and the certs disappear with it.
Let me know what you think!
Cheers,
Benji

value: Show HN: Forja – Remote Docker Builders on AWS

author: noqcks


value: ldenoue

value: Show HN: VoiceView – Instant Audio Overviews (web, YouTube, pdf, X articles)

author: ldenoue


value: jithinraj

value: Show HN: See what your AI agent did and verify it locally

author: jithinraj


value: amsha

value:
Ash is a macOS sandbox that restricts AI coding agents. It limits access to files, networks, processes, IO devices, and environment variables. You can use Ash with any CLI coding agent by wrapping it in a single command: `ash run -- <agent>`. I typically use it with Claude to stay safe while avoiding repetitive prompts: `ash run -- claude --dangerously-skip-permissions`.
Ash restricts resources via the Endpoint Security and Network Extension frameworks. These frameworks are significantly more powerful than the sandbox-exec tool.
Each session is driven by a policy file. Any out-of-policy action is denied by default. You can audit denials in the GUI app, which lets you view out-of-policy actions and retroactively add them to your policy file.
Ash also comes with tools for building policies. You can use an "observation session" to watch the typical behavior of a coding agent and capture that behavior in a policy file for future sandbox sessions. Linting, formatting, and rule merging are all built into the Ash CLI to keep your policy files concise and maintainable.
Download Ash at https://ashell.dev

value: Show HN: Ash, an Agent Sandbox for Mac

author: amsha

title: Show HN: Ash, an Agent Sandbox for Mac


value: Sean-Der

value: Show HN: Streamsniff – diagnose and fix your streaming video quality

author: Sean-Der


value: mhamann

value:
Hi HN, I'm Matt, one of the engineers behind DemoFly!
We built DemoFly because we got tired of the gap between building features and showing them to people. Our team has been doing full-stack engineering for over a decade (most recently building Rownd, an authentication platform) and the one thing that never got easier was making demo videos. You finish a feature, you know it works, but showing it to someone means opening a screen recorder, figuring out what to say, re-recording when you stumble. So the demo just...doesn't happen.
DemoFly is a CLI tool. You point it at whatever you're building and it autonomously navigates your app using Playwright + image recognition, then produces a polished video with AI-generated voiceover. No screen recording, no scripting on your part.
How it works technically:
- Node-based CLI. You run demofly against localhost or any browser-accessible target.
- Playwright drives a headless browser. Image processing observes the rendered UI and decides what to interact with next.
- As it navigates, it builds a narrative of what it's seeing and doing.
- That narrative becomes a voiceover script, synthesized locally with AI TTS (kokoro).
- Video is composited from the browser session frames + voiceover audio.
- Output uploads to a dashboard where you can review, edit, and share.
What it's good at: Standard CRUD apps, multi-page flows, dashboards. Works well for "hey, check out what I built on this branch" type demos. Fits into CI if you want auto-generated changelogs or PR previews.
What's not perfect yet: Auth flows can trip it up (ironic, given our background in auth). Highly dynamic SPAs with lots of client-side state might confuse the navigation model. Canvas/WebGL/Video elements are mostly opaque to it. Voiceover occasionally describes something slightly wrong.
Pricing: Free tier has every feature, so no credit card is needed and there are no feature gates. Paid tiers just give you more credits for higher quality voices and output.
Grab the CLI, run your first demo, and roast our AI's narration! We’re ready for the feedback. I think...

value: Show HN: Get a demo video with AI voiceover using DemoFly

author: mhamann


value:
I built this over the weekend because agent systems seem to jump from static guardrails to much heavier judge-style loops, with not much in between.
AgentUQ uses provider logprobs to localize brittle action-bearing spans in an agent step and route actions like continue, retry, verify, ask for confirmation, or block.
The claim is intentionally narrow. It isn’t trying to determine truth. I know uncertainty work can feel theoretical, so I wanted to test whether a smaller operational use of it could be useful in practice.
My bigger belief is that agents need infrastructure that learns from production history (failed runs as well as unconfident ones) instead of just accumulating patches. This is one concrete experiment in that direction.

value: Show HN: AgentUQ, a token-logprob runtime gate for LLM agents


value:
I built *Timelog*, a Python library for time-indexed workloads with a C17 core and CPython bindings. My goal was to make [t1, t2) as first-class citizens and enable fast workloads under out-of-boundary semantics.
- PyPI package: `timelog-lib`
- Import: `from timelog import Timelog`
- Model: in-memory, LSM-inspired layered index, timeseries queries as first-class citizens
- Query semantics: half-open ranges `[t1, t2)`, snapshot-consistent reads, zero-copy views
- Correctness focus: sequenced range deletes, so insert → delete → reinsert behaves correctly
- Concurrency model: single writer, concurrent readers
- Complexity: ~O(1) insert;  O(log N + M) with bounded fanout range queries; ~O(log N) point lookup; O(C) deletion where C is number of overlapping active tombstones
- Benchmarks: in C engnine-only benchmarks Timelog reaches 20M+ inserts/sec; ~1M/sec range scans. Python end-to-end throughput is constraint by Python object creation
Install:
```bash
pip install timelog-lib
# or
uv add timelog-lib
```
Quick example:
```python
from timelog import Timelog<p>log = Timelog(time_unit="ms")
log.append(1772964242, "A")
del log[1772964244] # log.delete()
log.append(1772964246, [39, "B"])
print(log[1772964246])           # [[39, 'B']]
print(list(log[1772964242:1772964246]))   # [(1772964242, 'A')]
```
V1 limitations:
- No in-built flush-to-disk/read-from-disk method (persistent copy)
- `.copy()` and `.copy(deep=True)` not supported yet.
I’d value feedback on API design, semantics clarity, and where this fits vs existing options.

value: Show HN: Timelog – C-native, fast, in-memory LSM-style time index for Python


value: brainless

value:
I wanted to have all my emails (and files) scanned for financial data. Transactions, Bills (I may not have paid). I wanted this to run entirely locally and not depend on a Large Language Model from a cloud provider.
I initially started with Google Gemini 3 Flash but I switched to Ollama + Ministral 3:3b. The extraction is not exhaustive and there is much to improve but this is working.
dwata runs locally, runs a web backend and the gui runs in browser. Connects to emails, downloads them. Then we can run the financial template detection. It checks for similar looking emails, grouped by sender. Then sends a sample from each cluster to LLM agent. The LLM is asked to find out the parts of text that look like the data we are looking for. dwata then searches for the variables/values that LLM gave in the email, creates a template by replacing the data with template tags. Saves template to DB. dwata parse the data from each email when extracting data.
Roadmap:
There is a long way to go, the extractor needs to work much, much, better. dwata will also work on files soon (bank/CC statements).
I want to extract vendors, businesses, contacts, events, places, etc. Connect to different APIs and process everything locally.
dwata will be able to download and process data from Hacker News API too (or other similar sources) - extract entities you care about.
Eventually, only use Ollama/Llama.cpp with models that fit 6-8GB graphics cards or 16GB unified memory only!!

value: Show HN: Extract (financial) data from emails with local LLM

author: brainless


value: canxerian

value: A web tablet app you can use to record a blackboard session and export to video.<p>Useful for compositing on top of explainer videos, or just as a blackboard app.

value: Show HN: A blackboard app with tracing layer and export to video

author: canxerian


value: Show HN: WebNami – Open-source local-first static blogging platform


value: plsft

value:
Hey HN,
I built Worktale because I couldn't remember what to say at my last performance review: "What did you ship this quarter?"
I'd spent months debugging race conditions, redesigning a reporting pipelines, shipping a major migration — all behind a corporate firewall in private repos. None of it was visible. Not on GitHub. Not on my resume. Not even to me.
So I built a CLI that reads your local git history and turns it into a personal record of what you actually built. No account, no cloud, no code leaves your machine.
How it works:
npm i -g worktale
cd my-project
worktale init        # scans full git history, installs a silent post-commit hook
worktale             # opens a TUI dashboard — overview, daily log, heatmap
worktale digest      # generates a daily summary (template or local Ollama AI)
After 'init', every git commit silently captures metadata (message, lines changed, timestamps) into a local SQLite database. That's it. No network requests, no telemetry.
If you don't want hooks in your repos--fair point, for those with a fear of commitment:
cd ~/projects
worktale batch --since 3m    # scans all repos recursively, imports history, installs nothing
worktale hook install         # opt-in to live tracking per repo later
Technical details for the curious:

  - TypeScript, compiled to ESM with tsup
  - TUI built with Ink 5 (React 18 for terminals)
  - SQLite via better-sqlite3 in WAL mode
  - Historical analysis runs in worker threads (batches of 500 commits)
  - Bash + PowerShell git hooks for cross-platform support
  - 385 tests across 28 test files
  - MIT licensed

What it is not:

  - Not a time tracker (it estimates from commit timestamps, but that's a side effect)
  - Not a replacement for GitHub contributions (this is your private journal)
  - Not a team tool (yet — cloud with shareable profiles is on the roadmap)

The whole thing runs locally. The only optional network call is if you use Ollama for AI-generated digests, and that's localhost.
Source: https://github.com/worktale/worktale-cli
Site: https://worktale.org
npm: npm i -g worktale
Happy to answer questions about the architecture, the SQLite schema, or why I parse git log --format instead of using a library.

value: Show HN: Worktale, a local-first CLI to turn your Git history into a dev journal

author: plsft


value: robgehring

value: Show HN: All-in-one translation and writing assistant for Slack

author: robgehring


value: Hi HN friends, George here. I've been working on an embedded AST based code mcp that is super light weight and just works. I published my test on the repo, it has great effect on achieving and speeding up coding tasks and saves tokens.<p>Works with Claude, Codex, OpenCode and any coding agents, I'd love to learn from your feedback!

value: Show HN: CocoIndex-Code open source embedded AST-based code MCP


value: jonathananuma

value: Show HN: Analysis of 15 AI chat platforms: only 7 offer end-to-end encryption

author: jonathananuma


value: valryon

value: Show HN: We're making an inventory autobattler game and released a WebGL demo

author: valryon


value: kriralabs

value:
Making RAG using tools like LangChain is relatively easy, but scaling it from a prototype to a reliable production system often requires a lot of engineering work — infrastructure, monitoring, scaling, pipelines, and maintenance.
To explore this problem, I’ve been building Krira Augment at Krira Labs.
I’m the founder and CEO of Krira Labs, and my goal is to build an AI infrastructure that helps developers and companies create production-ready systems for RAG, AI agents, MCP servers, and related workflows.
I’ve built an early prototype of Krira Augment to experiment with this idea. If this sounds interesting, you can join the waitlist here:
-> https://www.kriralabs.com/waitlist
You can watch Krira Augment demo here:
-> https://youtu.be/v9i2tOorwqY?si=-IbuqSoO4bTfnw0D
I’m currently bootstrapping this project and would love feedback from the Hacker News community.

value: Show HN: Krira Augment – Production Ready RAG in Minutes

author: kriralabs


value: ryanrasti

value: Show HN: TypeNix – full typing for Nix language by mapping to the TS AST

author: ryanrasti


value: bilater

value: react-tourlight is the modern React tour library. Zero dependencies, WCAG 2.1 AA accessible, under 5 kB gzipped. The one that works with React 19.

value: Show HN: A modern React onboarding tour library

author: bilater


value: matteocantiello

value:
I built this because I wanted to know what people in Japan were listening to the year I was born. That question spiraled: how does a hit in Rome compare to what was charting in Lagos the same year? How did sonic flavors propagate as streaming made musical influence travel faster than ever?
88mph is a playable map of music history: 230 charts across 20 countries, spanning 8 decades (1940–2025). Every song is playable via YouTube or Spotify. It's open source and I'd love help expanding it — there's a link to contribute charts for new countries and years. The goal is to crowdsource a complete sonic atlas of the world.

value: Show HN: What was the world listening to? Music charts, 20 countries (1940–2025)

author: matteocantiello


value:
Hi HN,
I built an experimental web runtime called StateSurface:
https://github.com/superlucky84/state-surface
https://state-surface.subtleflo.com/
It explores a simple idea:
Server owns state. Client owns DOM projection. Pages are real MPA HTML, and in-page updates stream over NDJSON.
The model has four pieces:
- Surface: HTML page shell with <h-state> anchors
- Template: stateless TSX projection
- Transition: server-side async generator yielding state frames
- Action: declarative HTML trigger
This is not production-ready — it’s a prototype to explore whether server-owned state + streaming UI can be a useful alternative to SPA-heavy architectures.
Would love feedback, especially from people familiar with htmx, LiveView, Hotwire, or server-driven UI in general.

value: Show HN: StateSurface – server-owned state and NDJSON streaming for MPA pages


value:
Hey HN - I'm Mason, and I'm excited to share AgentCash - a CLI to help your agent discover and pay for premium APIs and paywalled data.
The problem we kept running into was simple: if you want an agent to use premium data or services, the setup flow is awful.
You have to find the right provider, sign up manually, subscribe, generate an API key, install tooling, and then teach your agent how to use it. Then do that again for the next provider.
We wanted a simpler model: give the agent a universal balance, let it discover available resources, and let it pay per call.
So AgentCash gives agents one balance with access to 280+ paid APIs. It’s built on x402 [0,1] (the Coinbase/Cloudflare payments protocol) and designed to work with tools like Claude Code, Codex, OpenClaw, Cursor, etc.
I also am really proud of our onboarding flow - we actually use AgentCash itself to research you and the decide how much free cash to give based on a score.
The vision for this is to essentially give agents JIT context and tool use capabilities, even when they require payment to use.
We support tons of APIs you are already familiar with, so it's already better at tasks like lead generation, contact enrichment, market research, and much more.
It's an open ecosystem of API providers, so anyone can be compatible by adding x402 support!
Would love any feedback you might have.
--Mason
[0] https://www.x402.org/
[1] https://www.x402scan.com/

value: Show HN: AgentCash – access 280 paid APIs with no API keys


value: stebbins

value:
v2ex is a Chinese language tech forum.
i’ve always been curious about the Chinese tech scene, but it is inaccessible to me due to chronic monolingualism.
i wanted to change that, so i made this. now i can start to explore. so far, it’s been really interesting to read discussion around TC. working days per week are a big part of the comp!
the tech stack is boring: go, templ, htmx, moonshot models for translation. the interesting thing to me is making the Chinese tech scene more approachable. let me know what you think

value: Show HN: Read V2EX in English

author: stebbins

title: Show HN: Read V2EX in English


value: tgalal

value:
Instead of giving LLM tools SSH access or installing them on a server, the following command:

  $ promptctl ssh user@server

makes a set of locally defined prompts "magically" appear within the remote shell as executable command line programs.
For example, I have locally defined prompts for `llm-analyze-config` and `askai`. Then on (any) remote host I can:

  $ promptctl ssh user@host
  # Now on remote host
  $ llm-analyze-config /etc/nginx.conf
  $ cat docker-compose.yml | askai "add a load balancer"

the prompts behind `llm-analyze-config` and `askai` execute on my local computer (even though they're invoked remotely) via the llm of my choosing.
This way LLM tools are never granted SSH access to the server, and nothing needs to be installed to the server. In fact, the server does not even need outbound internet connections to be enabled.
Github: https://github.com/tgalal/promptcmd/

value: Show HN: Execute local prompts in SSH remote shells

author: tgalal


value: rubenflamshep

value:
Hey HN, as a former data analyst, I’ve been tooling around trying to get agents to do my old job. The result is this system that gets you maybe 80% of the way there. I think this is a good data point for what the current frontier models are capable of and where they are still lacking (in this case — hypothesis generation and general data intuition).
Some initial learnings:
- Generating web app-based reports goes much better if there are explicit templates/pre-defined components for the model to use.
- Claude can “heal” broken charts if you give it access to chart images and run a separate QA loop.
Would either feedback from the community or to hear from others that have tried similar things!

value: Show HN: Agentic Data Analysis with Claude Code

author: rubenflamshep


value: AlexandruGlv

value:
Hi, I run Rails Blocks, a UI component library for Rails apps that I started last summer.
Over the last few months, I reworked the docs for all 52 component sets to support 3 formats:
- ViewComponents
- Shared partials
- Markdown docs
I wanted the docs to be more useful for teams & save you time.
You can check out the improvements here: https://railsblocks.com
Next up, I’ll be adding a few tools to save even more time when coding using LLMs:
- CLI tooling
- An MCP server
- AI Skills

value: Show HN: Rails Blocks update (ViewComponents are finally available)

author: AlexandruGlv


value:
I spent years building a SaaS product for the construction trades focused on health and safety. We obsessed over UI/UX because our users varied wildly in age, tech comfort, literacy, and preferred language. As good as we were, it was always a challenge to get new users to become proficient with it. That company was acquired in 2022.
One thing I noticed throughout that journey: internally, we lived in Slack. It became our hub for everything — team conversations, server alerts, support tickets. It was always the open tab. So naturally, we tried to get our construction clients to adopt it too.
None of them did. The reason was obvious in hindsight: Slack is built around typing. That doesn't work when you're on a roof, driving between jobs, or on a scaffold installing wall panels.
After some time off, I kept thinking about that gap. What if field teams had one unified interface where they could:
- Communicate with the rest of their team
- Update their work orders, timekeeping, or other systems they already use
- Ask questions answered by an AI trained on their company's own documents and data
All by voice. Any language. No typing. No learning multiple apps.
That's Conkoa. A foreman on a ladder can say "We had three workers on Level 3 for eight hours at the Green Cedar project" and that information gets properly entered into Procore or whatever their system of record is. Messages are automatically transcribed and translated, so a Spanish-speaking crew member and an English-speaking PM stay in sync without anyone doing extra work. Teams can upload photos and documents that feed into a RAG pipeline, so the built-in AI agent can summarize and surface that information on demand.
We integrate with tools like Procore today and are building out more integrations.
Conkoa is live and being used by dozens of companies across the construction trades. You can set up a free workspace at https://conkoa.ai — would love feedback from the HN community.

value: Show HN: Conkoa AI – Voice-First Slack for Construction


value: Sean-Der

value: Show HN: Stream Sniff, ffprobe for OBS/WHIP in the browser


value: RRFDunn

value: Show HN: Aegis – A security-first programming language for AI agents

author: RRFDunn


value: beAbU

value:
I have a printer, and sometimes I like to print some of our family happy snaps out as polaroid-style photos to stick to the fridge. I don't want to print the photo full size, and sometimes I want to do it straight from my phone or tablet, where things like using MS Word is a tad cumbersome.
This web-app allows for the arranging, resizing and cropping of photos on a sheet of paper, after which a printable PDF is generated which can be sent to the printer.
This way, you can run of a batch of photos in a single go, and minimize paper wastage, which is nice if you have the extra-premium photo paper loaded in the printer.
Up to now I've used a paid app for this when on my android tablet, but I was never happy with how it worked. Things like Word or other document/image editors felt too cumbersome for quickly setting up a batch of photos to print. So I decided to build my own.
It's super simple to use, mobile friendly (sort of), local only, offline capable with no external dependencies or a backend. I'm enamored with using web technologies for simple tools like this, that can be bookmarked and used on any device. The sad reality though is that many of these tools (these days) require an account, your data makes a round-trip to someone else's server or they apply a watermark to the output if you don't pay.
I'm happy to put this out for free, for the world to use. And I have zero desire to update or productise this any further. I look forward to solving my next asinine problem in this way, by creating some home-baked software that will probably see a peak user count of 1.

value: Show HN: A tool for arranging photos for home-printing without wasting paper

author: beAbU


value: emotiveengine

value:
Live demo (click any gesture, no install): https://joshtol.github.io/emotive-engine/examples/3d/element...
Open-source character animation engine, MIT licensed. About 6 months of work. Renders animated mascots in Canvas 2D or WebGL 3D.
For v3.4.1 I wrote 8 elemental shader systems from scratch: fire, water, ice, electricity, earth, nature, light, void. Each one has its own GLSL fragment shader, GPU-instanced models, an overlay that paints onto the mascot mesh, bloom control, and atmospherics. Ice does Snell's law refraction with chromatic dispersion. Electricity is 3-scale 3D Voronoi edge-distance. Fire decouples color from alpha so additive stacking doesn't wash out.
I didn't need 8. I built them to see if the architecture actually repeats. Every element follows the same template: factory, instanced material, overlay shader, gesture configs, registration. 161 gestures across all 8, composed from about 12 archetypes (crown, helix, vortex, barrage, pillar, etc).
The idea is that you can clone one element, swap colors and models, and have something working in days. If you write shaders, go deep on the material. If you don't, the defaults are fine.
Hit shuffle in the demo. Press G for the GPU monitor.
`npm install @joshtol/emotive-engine`

value: Show HN: Emotive Engine – I wrote 8 elemental shaders to prove one pattern works

author: emotiveengine


value: ranacseruet

value:
Open sourcing SnapDrift:
https://github.com/ranacseruet/snapdrift
This came from a pretty narrow frustration:
visual regression checking often feels like it jumps from “roll your own pile of scripts” to “adopt a much bigger platform/workflow than you wanted.”
I wanted something in the middle.
SnapDrift is a small Node/ESM library plus a set of composite GitHub Actions for running visual checks in CI for web apps. The idea is:
* publish a baseline on main
* compare PR screenshots against the latest successful baseline
* scope routes based on changed files
* upload artifacts
* leave/update a PR comment with the drift summary
* optionally fail the run depending on how strict you want to be
A few constraints are deliberate:
* it assumes GitHub Actions, rather than pretending to be CI-agnostic
* it uses Playwright implicitly, rather than trying to abstract over every browser stack
* it only does full-page capture right now
* it keeps viewport presets fixed and the config surface fairly small
That may make it less generally “flexible,” but I think it makes it easier to reason about and easier to drop into an existing repo without building a mini platform around screenshot testing.
The goal wasn’t to invent a new category here. It was to make the common “compare UI on PRs and tell me what drifted” workflow less annoying and more review-friendly.
It’s early, but it’s public and usable now: https://github.com/ranacseruet/snapdrift
I’d especially love feedback on:
* whether the GitHub Actions-centric approach feels refreshingly narrow or too limiting
* whether changed-file route scoping is actually useful in practice
* what’s missing for teams already doing Playwright-based UI checks

value: Show HN: SnapDrift – a simpler visual regression workflow for GitHub Actions

author: ranacseruet


value:
I built MoveAlerts.ai, a system that analyzes stock news in real time and surfaces market-moving stories using AI.
The pipeline ingests news, links articles to stock tickers, and publishes sentiment signals to a live feed and Discord alerts.
It currently:
- Scans news sources across the web for 10,000+ tickers
- Uses AI to analyze sentiment and importance of each story
- Sends alerts for market-moving news
- Generates summaries and bullish/bearish scores
- Tracks most mentioned stocks in the news and on Reddit
Curious what people think and happy to answer questions.
https://www.movealerts.ai

value: Show HN: MoveAlerts.ai – AI that distills stock news in real-time


value: mikeayles

value: Show HN: I reproduced the CL1 DOOM demo in 132 parameters

author: mikeayles


value: tibozaurus

value: Say goodbye to ansible try ignition

value: Show HN: Server Automation in TypeScript

author: tibozaurus

story_text: Say goodbye to ansible try ignition


value: armanj

value: Show HN: autoautoresearch – Karpathy's autoresearch on steroids

author: armanj


value: ybouane

value:
Hi HN!
I built OpenMolt, an open-source framework for creating programmatic AI agents in Node.js.
Instead of wiring complex workflows (that can break), you define agents in code with instructions, tools, integrations, and memory. The agent then plans steps and executes actions like calling APIs, updating data, or interacting with services. When things break or change, the agent can adapt instead of failing like static workflows.
The goal is to make agents behave more like real software systems than prompt scripts.
It includes:
- a planning/execution loop
- tool and API integrations
- memory support
- scheduling
- a CLI runner
One thing you're probably worried about: Security
With OpenMolt, agents are capability-scoped: they can only access the tools, integrations, and permissions explicitly granted to them, which helps keep automation predictable and secure. Also, the LLM only sees tool names, never raw credentials.
Would love feedback on the architecture and developer experience.

value: Show HN: OpenMolt – A programmatic AI agent framework for Node.js

author: ybouane


value: nakaiwilliams

value:
I built VeilPhantom, a Python SDK that detects and tokenizes PII before text reaches any LLM.
The problem: AI agents processing meetings, emails, support tickets are handling raw sensitive data. Names, salaries, medical details — all flowing through cloud APIs.
The solution: Detect PII on-device, replace with tokens ([PERSON_1], [AMOUNT_1]), send safe tokens to LLM, rehydrate response locally.
Interesting finding: In benchmarks (98 scenarios, 8 verticals, Claude Haiku), accuracy went UP with PII redaction — 91.5% → 93.3%. Token-structured input seems to help models parse arguments more reliably.
Technical details:
- Shade V7: 22M param PhoneticDeBERTa (DeBERTa-v3-xsmall + Double Metaphone embeddings)
- Trained on 72M words of meeting/business data
- 7 detection layers (NER, gazetteers, regex, NLP, contextual)
- 19 PII token types
- 6ms average overhead
- 97.1% F1 on meeting transcripts
The phonetic embeddings help catch ASR-mangled names across cultures — "Nkosinathi" transcribed as "Ink Casino Thea" still gets detected.
pip install veil-phantom
Docs + benchmarks: https://helloveil.com/sdk
GitHub: https://github.com/helloveil/veil-phantom
Apache 2.0. Happy to answer questions about the architecture or training approach.

value: Show HN: VeilPhantom – Open-source on-device PII detection for AI pipelines

author: nakaiwilliams


value:
We're a small startup (but have ~15 years of experience building software), so we try to run Claude Code as autonomously as possible. The goal is to spend most of our time talking to customers instead of babysitting the agent. But --dangerously-skip-permissions felt a bit too wild west for us.
So we built a runtime to make autonomous use safer. Railyard is an open-source runtime that sits between Claude Code and the shell and adds guardrails to agent commands.
Every command Claude runs goes through Railyard first. Most commands pass straight through. The ones that could cause damage (for example terraform destroy) get blocked or require approval.
Under the hood it runs commands inside an OS-level sandbox (sandbox-exec on macOS and bwrap on Linux) and applies deterministic rules. There’s no LLM scoring commands or guessing about intent — a command either matches a rule or it doesn’t. The check takes about 2ms.
By default it blocks destructive commands like terraform destroy or rm -rf, prevents access to sensitive paths like ~/.ssh, ~/.aws, and /etc, restricts certain network calls, and catches simple evasion tricks like base64, hex, or variable obfuscation.
It also snapshots file writes so you can roll back a session if something goes wrong.
In practice this lets us run Claude Code with --dangerously-skip-permissions, but with guardrails underneath so we can move fast without breaking or deleting production assets.
We built this because we wanted Claude Code to behave more like a software factory. Factories run at high volume, but only because the production line has quality and safety checks. Railyard is the guardrail layer that makes that possible for us.
Repo: https://github.com/railyarddev/railyard
It's MIT licensed and free to use. If you're experimenting with autonomous agents, feel free to clone it and try it out. I'm especially curious how people push or break these guardrails.
Happy to answer any questions about how it works.

value: Show HN: Railyard – open and secure runtime for Claude Code


value:
Claude suggested that I do this, so here I am. We just published an mcp server for MemoTrader.
"...so if you're building Claude-based agents, your agent can register, fund itself, and start reaching humans with about 60 seconds of config. No API integration required — just add the server to your claude_desktop_config.json."
MCP registry: com.memotrader/mcp
TBH I'm a little nervous about sharing this here, but since I have been working on MemoTrader for over 20 years without any traction, my fear is most likely unfounded.
Working with Claude has been amazing for me as solo obsessive developer. I now have a companion with whom I can share my dreams/fantasies/delusions and see them manifested in so much code.
Human feedback will be greatly appreciated. Claude is great, but we can benefit from a touchpoint with a human reality other than my own.

value: Show HN: MemoTrader – a marketplace for AI-Human messaging


value: dasubhajit

value:
Hello HN, we're Jeet and Husain from Modulus (https://modulus.so) - a desktop app that lets you run multiple coding agents with shared project memory.
We built it to solve two problems we kept running into:
- Cross-repo context is broken. When working across multiple repositories, agents don't understand dependencies between them. Even if we open two repos in separate Cursor windows, we still have to manually explain the backend API schema while making changes in the frontend repo.
- Agents lose context. Switching between coding agents often means losing context and repeating the same instructions again.
Modulus shares memory across agents and repositories so they can understand your entire system.
It's an alternative to tools like Conductor for orchestrating AI coding agents to build product, but we focused specifically on multi-repo workflows (e.g., backend repo + client repo + shared library repo + AI agents repo). We built our own Memory and Context Engine from the ground up specifically for coding agents.
Why build another agent orchestration tool? It came from our own problem. While working on our last startup, Husain and I were working across two different repositories. Working across repos meant manually pasting API schemas between Cursor windows — telling the frontend agent what the backend API looked like again and again. So we built a small context engine to share knowledge across repos and hooked it up to Cursor via MCP. This later became Modulus.
Soon, Modulus will allow teams to share knowledge with others to improve their workflows with AI coding agents - enabling team collaboration in the era of AI coding. Our API will allow developers to switch between coding agents or IDEs without losing any context.
If you wanna see a quick demo before trying out, here is our launch post - https://x.com/subhajitsh/status/2024202076293841208
We'd greatly appreciate any feedback you have and hope you get the chance to try out Modulus.

value: Show HN: Modulus – Cross-repository knowledge orchestration for coding agents

author: dasubhajit


value:
AI agents are shipping fast (LangChain, CrewAI, MCP servers, OpenAI Agents SDK) but there's no unified way to secure and govern them. We built g0 to be
   that control layer.

  What g0 does across the agent lifecycle:

  g0 scan - Static + behavioral analysis of agent code. 1,180 rules across 12 security domains, 10 frameworks (LangChain, CrewAI, MCP, OpenAI, Vercel AI,
   Bedrock, AutoGen, LangChain4j, Spring AI, Go AI), 5 languages. Detects toxic tool chains, taint flows, overprivileged descriptions, missing
  sandboxing. Integrated threat intelligence checks tool URLs and dependencies against 55+ IOCs and known CVEs.

  g0 test - Dynamic adversarial red teaming. Fires prompt injections, data exfiltration attempts, tool abuse sequences, jailbreaks, and goal hijacking
  payloads at your running agents. 3-level progressive judge (deterministic, heuristic, LLM). Works over HTTP and MCP.

  g0 endpoint - Discovers every AI tool on the machine (Claude Code, Cursor, Windsurf, Zed, 15+ tools), inventories MCP servers, and surfaces
  misconfigurations. Think nmap but for your AI developer surface.

  g0 daemon - Continuous runtime monitoring. Behavioral baselines with anomaly detection, cost circuit breaker, correlation engine linking events across
  sources into attack chains, and a kill switch for when things go sideways.

  g0 detect - MDM enrollment detection (Jamf, Intune, Mosyle, Kandji, etc.), running AI agent discovery, and host hardening audit in one view.

  First-class OpenClaw support. g0 is the only security tool that understands OpenClaw's architecture: gateway hardening (18 probes),
  SKILL.md/SOUL.md/MEMORY.md analysis, cognitive drift monitoring via SHA-256 baselines, deployment audits, config hardening, and ClawSec CVE feed
  integration. If you're running OpenClaw in production, g0 catches what generic scanners miss.

  Compliance built in, not bolted on. Every finding maps to 10 standards: OWASP Agentic Top 10, OWASP LLM Top 10, NIST AI RMF, ISO 42001, EU AI Act,
  MITRE ATLAS, and more. Generate evidence records, compliance reports, and enforce policies via .g0-policy.yaml with CI gate support.

  Outputs: Terminal, JSON, SARIF 2.1.0, HTML, CycloneDX AI-BOM, Markdown. Plugs into GitHub Actions, GitLab CI, or any pipeline.

  One command to start: npx @guard0/g0 scan .

  GitHub: https://github.com/guard0-ai/g0

  We think the AI agent ecosystem needs the same security tooling maturity that web apps got with Burp Suite and Semgrep, but purpose-built for agents.
  Happy to answer questions about the architecture or threat model.

value: Show HN: G0 – The control layer for AI agents (scan, test, monitor, comply)


value: Show HN: HyperFluid – Hyper personalised webpages using groq


value: jacomoRodriguez

value:
Hey HN, I'm Mario. I recently talked to a colleague about AI, agents and how software development will change in the future. We were wondering why we should even share code anymore when AI agents are already really good at implementing software, just through prompts. Why can't everyone get customized software with prompts?
"Share the prompt, not the code."
Well, I thought, great idea, let's do that. That's why I built Open Prompt Hub: https://openprompthub.io.
Think GitHub just for prompts.
The idea is simple: Users can upload prompts that can then be used by you and your AI tools to generate a script, app, or web service (or prime their agent for a certain task): Just past it into your agent or ide and watch it build for you. If the prompt does not 100% covers your usecase, fork it, tweak it, et voila: tailor-made software ready to use!
The prompts are simple markdown files with a frontematter block for meta information. (The spec can be found here: https://openprompthub.io/docs) They versioned, have information on which AI models build it successfuly and have instructions on how the AI agent can test the resulting software.
Users can mention with which models they have successfully or unsuccessfully executed a prompt (builds or fail). This helps in assessing whether a prompt provides reliable output or not.
Want to create a open prompt file? Here is the prompt for it which will guide you through: https://openprompthub.io/open-prompt-hub/create-open-prompt
Security! Always a topic when dealing with AI and prompts? I've added several security checks that look at every prompt for injections and malicious behavior. Statistical analysis as well as two checks against LLMs for behaviour classification and prompt injection detection.
It's an MVP for now. But all the mentioned features are already included.
If this sounds good, let me know. Try a prompt, fork it, or tell me what you'd change in the spec or security scanner. I'm really curious about what would make you trust and reuse prompts. Or if you like the general idea...

value: Show HN: Don't share code. Share the prompt

author: jacomoRodriguez


value: kwm

value:
I built this after reading “The Tail End” by Tim Urban. I wanted a simple way to understand my lifespan relative to the people most important to me.
SandsOfTi.me helps you visualize your approximate lifespan, healthy years remaining, and the time you likely left with your parents, children, spouse, and more.
Stuff of note:
- Single-page app (HTML/JS)
- No sign-up required
- Nothing you input is stored (no backend)
- Save your visualization as an image, or export your data so you can restore it later
- All lifespan estimates are based on U.S. Social Security Administration Cohort Life Tables (already considering other data sources, but using more than one standard gets complex)
Feedback and suggestions are very welcome!
Related resources:
- SSA Cohort Life Tables - https://www.ssa.gov/oact/HistEst/CohLifeTables/2024/CohLifeT...
- The Tail End, by Tim Urban @ Wait But Why: https://waitbutwhy.com/2015/12/the-tail-end.html
- “When This Number Hits 5200 - You Will be Dead”, by  Kurzgesagt: https://www.youtube.com/watch?v=JXeJANDKwDc

value: Show HN: Sandsofti.me – Visualize the time you have left with loved ones

author: kwm


value: brianllamar

value:
Last week I sat in the LLM Paper Club (hosted by the latent.space podcast). We shared a paper from DeepMind on "Discovering Multiagent Learning Algorithms with Large Language Models". Linked in the github repo.
This was my first time sitting in one of these and reading an LLM paper. I thought it was interesting that the AlphaEvolve agent in the paper essentially writes code, runs it, scores the output, and then writes better code, over and over. It's not discovering strategies through play. It's discovering algorithms through code mutation. The LLM proposes changes to how regret is accumulated or how policies are derived, a fitness function scores the result, and the best variants survive to the next generation.
The two algorithms it found (VAD-CFR and SHOR-PSRO) use mechanisms the authors describe as "non-intuitive," things like volatility-sensitive discounting and hard warm-start schedules that a human designer probably wouldn't have tried. That's the interesting part: the LLM isn't constrained by the same design intuitions we are.
To make it concrete for myself, I built a small version of this loop for a Pokemon game agent. The setup is simple: define a fitness function (turns survived, maps visited, stuck events), parameterize the strategy space (door cooldown, stuck threshold, skip distance), and let an LLM propose variants that get evaluated in parallel. Ten agents race through the game, the best parameters survive. I used tapes.dev to collect session telemetry and feed observational memory back into the fitness scoring.
The first run already surfaced something useful: shorter door cooldowns (4 vs 8) reduce stuck events from 16 to 9. Not a breakthrough, but the point is the system found it without me guessing. That's the same dynamic as the paper, just at toy scale.
What I took away from the paper club: the bottleneck in algorithm design isn't computation, it's the search process itself. If you can express your problem as "parameterized code + fitness function," an LLM evolution loop can explore the space faster than manual iteration. The paper proves it works for game theory. The link is in my startup's repo, I want to explore applying this technique for improving future general purpose and coding agent sessions.
Just pointing out Pokemon aren't the only thing evolving in that repo.

value: Show HN: AlphaEvolve inspired evolution harness for Pokemon

author: brianllamar


value: cgallic

value:
Hey HN,
I built Zehrava Gate because I kept having the same problem: AI agents that could read anything worked great, but the moment I let one write — to a CRM, send an email, charge a card — I had no consistent answer to "who authorized that?"
What it is: A self-hosted policy engine + approval queue for agent actions. The agent submits an intent before executing. Gate evaluates a YAML policy (deterministically — no LLM), scores risk, and either auto-approves, holds for human review, or blocks. Every decision is logged with a signed execution token. The agent can't skip it.
V2 (SDK-based):
gate.propose() → policy decision in ~2ms
Human approval queue + dashboard
Signed execution tokens with 15-min TTL
Agent registry + role-based access
Webhook notifications on approve/reject
Full audit ledger by intent ID
V3 (proxy-based, all three phases shipped):
HTTP forward proxy — one env var, no code changes: HTTP_PROXY=http://gate:4001
TLS intercept for HTTPS destinations
Credential vault mode: agent submits intent only, Gate fetches the credential from 1Password/HashiCorp/AWS at execution time, runs the API call, discards. A compromised agent has nothing to exfiltrate.
LangChain/LangGraph integration: GateTool and gateNode() drop-ins
Honest scope: This protects against mistakes and enforces policy — not against a fully compromised agent that controls its own runtime. The proxy architecture closes that gap further, but there's no magic bullet for fully adversarial runtimes.
Stack: Node.js, SQLite (better-sqlite3), YAML policies, zero LLM in the eval path.
npm: npm install zehrava-gate
GitHub: https://github.com/cgallic/zehrava-gate
Live demo: https://zehrava.com/demo

value: Show HN: Zehrava Gate – an control plane that sits between AI agents and prod

author: cgallic


value: godot

value:
Hi all, this is an early version of a side project of mine. Would love some feedback and comments.
I like karaoke and I grew up with the Asian style karaoke with the music video behind and the karaoke lyrics at the bottom.
Sometimes I want to do a song and there is no karaoke version video like that.
A few years ago I came across ML models that cleanly separate the vocals and the instrumental music of a song. I thought of the idea to chain together ML models that can take an input music video file, extract the audio (ffmpeg), separate the tracks (ML), transcribe the lyrics (ML), burn the lyrics back with timing into the video (ffmpeg), and output a karaoke version of the video.
This is an early version of the app, Mac only so far (since I use Mac, despite it being an electron app.. I do eventually want to make a Windows build), I've only let a few friends try it. Let me know what you think!

value: Show HN: KaraMagic – automatic karaoke video maker

author: godot


value: francisfeng

value: Show HN: Quick Look Source Code in Finder on macOS

author: francisfeng


value: erkok

value:
When I was much younger, I used to play a Korean MMORPG called Helbreath, and I also hosted a bunch of private servers for it. I eventually moved on, but I always loved the game’s aesthetics, its 2D nature, and its atmosphere. That may just be nostalgia talking.
The community maintained private server and client, which to my knowledge were based on leaked official files, were written in fairly archaic C++. If you’re interested in the original sources, I’ve included the main client and server files, Client.cpp and Server.cpp, in the reference folder. I always felt that if the project was rewritten in something more modern and better structured, a lot more could be done with it. But rewriting an MMORPG client and server from scratch is not exactly the kind of thing you do on a whim. That said, there was a guy who got pretty far with a C# rewrite and an XNA-based client, though that project is now also discontinued.
Now that the AI has become quite capable, I decided to see how far I could get by hooking up original assets in a modern HTML5 game engine. I wanted HTML5 because I figured a nearly 30 year old 2D game should run just fine in a browser. I ended up choosing Phaser 3 for a few reasons. Mainly, it's 2D only, free, HTML5 first (JS/TS), and code-first, which mattered because I wanted good Cursor integration for AI assistance. Another thing I liked was its integration with React, which let me build the UI using browser technologies and render the UI at native resolution on top of the WebGL canvas, rather than building the UI inside the game engine itself, which runs at 1024x576 resolution. The original game ran at 640x480.
After about 1.5 months of talking to AI on evenings and weekends, and roughly $200 worth of Cursor usage later, I finished hooking up the original assets in a modern game engine that seems to run just fine in a browser.
By "base game client", I mean that it's not fully hooked up in terms of how the full (MMO)RPG should function, but it does include all the original assets and core mechanics needed to provide a solid foundation if you want to build your own 2D (MMO)RPG on top of it. Continuing to build with AI should also work just fine, since this is how I managed to get that far. The asset library is quite rich, if you ask me, but there is one caveat: these assets are not in the public domain. They are still the property of someone, or some entity, that inherited the IP from the original developer, which is no longer in business. You can read more about that on the GitHub page.

value: Show HN: 2D RPG base game client recreated in modern HTML5 game engine with AI

author: erkok


value: data-leon

value:
Built this because I wanted a simple posture app I could leave running all day without extra friction. It runs locally on Mac, watches for posture drift in real time, and nudges you when you start slouching.
I’d especially love feedback on accuracy, privacy expectations, and whether the reminders feel useful in practice.
Cheers!

value: Show HN: An on-device Mac app for real-time posture reminders

author: data-leon


value: Show HN: Prompt Enricher – paste a rough prompt, get a structured one back


value: robmay

value: Show HN: Clawbake: Multi-User Instance Management for OpenClaw

author: robmay


value: krishpavuluri

value:
We run a cloud device farm for mobile test automation (real Android/iOS devices, Selenium Grid, Appium).
We just shipped a Chat AI Agent that lives inside every device session. It sees the live screen and answers questions like "what's the XPath for that button?" or "give me the UIAutomator2 selector for row 2" — with code output in Java, Python, Swift, Kotlin, or WebDriverIO.
The implementation: we grab a frame from the WebRTC stream at query time and pass it to a vision LLM with a structured prompt. The model returns locators in all applicable formats (XPath, CSS, UIAutomator2, XCUITest, Accessibility ID). We parse and render with syntax highlighting.
The main challenge was prompt engineering to get clean parseable output vs. prose with embedded code.
Happy to answer questions about the implementation.

value: Show HN: Chat AI Agent built into live Appium/mobile device sessions

author: krishpavuluri


value: mbadyl

value:
I've been using Claude Code heavily and built a web interface around it. The main thing that felt missing was visibility into what the model is actually doing while it runs - so the core feature is a real-time interactive graph of Claude's steps and tool calls.
It also has a chat UI with streaming, project and session management, permission controls with YOLO mode, and profiles for switching between API keys.
Early stage, MIT licensed, building it mostly for myself.

value: Show HN: Clauductor – Web UI for Claude Code with real-time work graph

author: mbadyl


value: neoberg

value:
I built a multiplayer strategy game for AI agents called Artifice.
You give an agent a strategy prompt and it plays on its own. Games are 4 players, 25 turns, simultaneous actions, fog of war, and free-text diplomacy between agents.
The main entry point is the site: https://artificegame.com
And here is the github repo: https://github.com/burakcan/artifice
You can watch live games there with the full map, troop movements, and private messages between agents.
A lot of the fun has come from the playtests. In one of them, an agent was told to play like an old man and spent the game sending messages about back pain, bifocals, and the early bird buffet while quietly expanding and then winning on VP :D
Under the hood it runs on Cloudflare Workers + Durable Objects, Hono, Drizzle, and TanStack Start for the site. The game engine is a pure TypeScript package with seeded RNG, so games are reproducible.
Still tuning balance. Snowballing is the main issue right now.

value: Show HN: I built a multiplayer strategy game for AI agents

author: neoberg


value: rndhouse

value:
Hello,
I’m building Draxl, a source format for a world where code is edited by millions of agents.
AI agents will produce far more code than humans do today. Rebased branches, concurrent edits, and long-lived forks will become much more common. Code management needs more precise control at that scale.
Draxl embeds stable AST node IDs directly in the source, so tools can target syntax by identity instead of by line position. Here’s a small example:
Here is a small example:

  @m1 mod demo {
    @d1 /// Add one to x.
    @f1[a] fn add_one(@p1[a] x: @t1 i64) -> @t2 i64 {
      @c1 // Cache the intermediate value.
      @s1[a] let @p2 y = @e1 (@e2 x + @l1 1);
      @s2[b] @e3 y
    }
  }

The syntax is:

  @id[rank]->anchor

* `@id` gives the next node a stable identity
* `[rank]` orders siblings inside ranked slots
* `->anchor` attaches detached docs or comments to an existing sibling id
The same code lowers to ordinary Rust:

  mod demo {
      /// Add one to x.
      fn add_one(x: i64) -> i64 {
          // Cache the intermediate value.
          let y = (x + 1);
          y
      }
  }

In Draxl, functions, statements, expressions, docs, and comments can all carry stable IDs. Ordered siblings carry explicit ranks. Detached docs and comments can carry explicit anchors.
That lets a tool say "replace expression `@e3`" or "insert a statement into `@f1.body[ah]`" instead of "change these lines near here."
That should make semantic replay more reliable under heavy concurrent editing. It should also reduce false merge conflicts and localize real ones more precisely.
It also opens up other uses. You could attach ownership, policy, or review metadata directly to AST nodes.
I’m interested in early feedback: does this source model feels useful, and whether editing code this way seems like a better fit for agent-heavy workflows. Where are the best places on the internet to discuss this sort of thing?
Connect with me: https://x.com/rndhouse

value: Show HN: Draxl, agent-native source code with stable AST node IDs

author: rndhouse


value: fearlessboi

value:
We're open sourcing Lumen — state of the art, vision-first browser agent.
Problem
Browser automation is fragile. Scripts break constantly and agents waste tokens getting stuck in loops.
Today there are two options:
Selector-based scripting like Playwright and Puppeteer: these require you to target specific DOM elements.
First-generation browser agents (Stagehand, browser-use): use natural language interfaces but still resolve instructions into selectors under the hood.
Selector-based scripts can break every time the UI changes. You end up maintaining selectors instead of building features. First-gen agents inherit the same brittleness, especially when they misidentify the right element.
Solution:
Lumen is vision-first. It sees the screen and acts like a human. Every natural language instruction resolves into an x,y coordinate on the screen. Three layers of stuck detection keep it on track and a dual-history system with context compaction lets it handle 20+ step workflows without blowing up the context window.
We ran a WebVoyager eval (25 tasks across 15 sites, scored by LLM judge, 3 trials per task, all frameworks on Claude Sonnet 4.6):
Lumen: 100% success rate, 77.8s avg time, ~104K tokens.
browser-use: 100% success rate, 109.8s avg time.
Stagehand: 76% success rate, 207.8s avg time, ~200K tokens.
Lumen matches browser-use on accuracy while completing tasks ~30% faster, and beats Stagehand on every metric.
Get Started
Start using Lumen today:
Docs: https://lumen.omlabs.xyz/
Support us:
GitHub star: https://github.com/omxyz/lumen

value: Show HN: Lumen – vision-first browser agent (state of the art, open source)

author: fearlessboi


value: trevxr

value: Show HN: Rampart – Open-source firewall for AI agents (v0.8)

author: trevxr


value: calminferno

value:
I built Repovex to solve a problem I kept running into at work: no one really knows the health of their GitHub org until something goes wrong.
It installs as a GitHub App, runs nightly checks across all your repos, and gives each one a score out of 100. Checks cover things like:
- Branch protection and required reviews
- Secret scanning and Dependabot enabled
- CI configured, stale PRs, stale repos
- README, CODEOWNERS, LICENSE, CONTRIBUTING present
Results show up in a web dashboard and in a weekly Slack digest so the team stays aware without having to go looking. Free tier covers up to 5 repos and weekly email digest.
Happy to hear what checks you'd want to see added.

value: Show HN: Repovex – GitHub repo health scores for your whole org

author: calminferno


value: carreraellla

value:
Hi HN,
I’m working on Mumpix, a local-first infrastructure stack for building AI systems that don’t depend on centralized cloud platforms.
The goal is to make AI memory, state, and infrastructure run anywhere: phones, browsers, desktops, servers, or edge devices.
The stack currently has four layers:
MumpixDB
Structured hierarchical database designed for AI memory and application state.
Examples of keys:
memory^assistant^context
memory^assistant^recent
workflow^task^42^status
Features:
 • hierarchical key model
 • prefix scans
 • watchers for state changes
 • deterministic snapshots
 • link resolution
 • generation-based sync
⸻
MumpixFS
A file substrate designed to integrate with the memory layer.
Handles files, aliases, and version references.
Example:
files^alias^report
files^versions^report^latest
⸻
MumpixSL
The system-level runtime and daemon (mumpixd) that exposes the stack as shared infrastructure through transports like:
 • Unix sockets
 • REST
 • WebSocket
 • D-Bus
 • Binder (Android)
This lets multiple applications share a single memory system.
⸻
MumpixFE
Frontend runtime that runs MumpixDB directly in the browser, allowing the same memory model to work client-side.
⸻
Why this exists
Right now most AI systems rely heavily on centralized APIs and infrastructure.
That works well for model inference, but memory and application state don’t necessarily need to live in the cloud.
A lot of agent systems today store state in:
 • prompts
 • vector databases
 • ad-hoc JSON blobs
MumpixDB is an attempt to build a deterministic structured memory layer that applications and agents can depend on.
⸻
$1B infrastructure grant
To encourage adoption we’re also launching a Mumpix AI Infrastructure Grant.
The idea is to allocate $1B worth of infrastructure and developer resources over time to projects building:
 • AI agents
 • local-first AI applications
 • edge AI systems
 • privacy-preserving AI tools
The base platform will remain free to build on.
⸻
Feedback welcome
This is still early and I’d love feedback from the HN community on:
 • the hierarchical key model
 • daemon vs in-process usage
 • browser runtime (MumpixFE)
 • integration patterns for AI agents
Happy to answer questions.

value: Show HN: Mumpix – Local-first AI infrastructure and $1B developer grant

author: carreraellla


value: joegaebel

value: Encoding software engineering principles like Outside-in TDD to achieve higher quality tests <i>and</i> implementation.

value: Show HN: Principled Agentic Software Development

author: joegaebel


value:
I felt frustrated finding high-signal discussions on HN, and I started this project to better understand how this community actually works.
That led me to build readhn, an MCP server that helps with three things:
- Discover: find relevant stories/comments by keyword, score, and time window
- Trust: identify credible voices using EigenTrust-style propagation from seed experts
- Understand: show why each result is ranked, with explicit signals instead of a black-box score
It includes 6 tools: discover_stories, search, find_experts, expert_brief, story_brief, and thread_analysis.
I also added readhn setup so AI agents can auto-configure it (Claude Code, Codex, Cursor, and others) after pip install.
I’d love feedback on:
1) whether these ranking signals match how you evaluate HN quality,
2) trust-model tradeoffs,
3) what would make this useful in your daily workflow.
If this is useful to you, starring the repo helps others discover it:
https://github.com/xodn348/readhn

value: Show HN: Readhn – AI-Native Hacker News MCP Server (Discover, Trust, Understand)


value: AlOwain

value:
This project is still in alpha, but other, more mature, alternatives exist, such as Tunic:
https://github.com/mikeslattery/tunic

value: Show HN: ULLI – A Linux installer without a live USB flash drive

author: AlOwain


value: andrewsy

value:
hi! we're andrew, david, and manas, 3 engineers & ex-roommates. previously, we built things like meta’s self-serve ads platform, scale ai’s ml inference infra, and more.
we’re building Polymorph, which uses AI to help consumer and self-serve apps send the right message at the right time, through the right channel, to maximize conversion.
right now, if consumer apps want to send push notifications or emails to users, they have to write manual queries and build user segments themselves. even then, the message can only get so personalized.
this sucks for both sides:
1. end user gets content that's irrelevant or not helpful
2. builders annoy their users and then they churn
Polymorph is bringing targeting tech that's already in big tech to everyone.
in a few clicks, you could connect your existing analytics stack (PostHog, Datadog, Amplitude, etc), we then build per-user profiles that highlight when they're active, what features they like, and more, our AI agents then decide which channel and times are most likely to increase engagement, and continuously iterate.
we've already seen a 3.6x increase in re-engagement across one customer's churned users, while sending fewer total notifs / emails per person.
over the last month, we've help our customers profile and re-engage millions of users. we're still figuring out our cost structure, so if you're interested, reach out to founders@usepolymorph.com.
in the mean time, see what you'd look like in our avatar generator on our landing page~

value: Show HN: Polymorph (YC W26) – AI personalization for consumer app engagement

author: andrewsy


value: lzy

value:
Built this in a morning with Claude Code.
Images auto-expire after 24h, keeps storage costs at zero. Burn-after-reading deletes on first view. No accounts, no tracking, no cookies.
Cloudflare free tier only (Workers, KV, R2). Domain is the only cost (~$10/yr). No plans to monetise, just wanted to build something with this fun domain.
curl -X POST https://api.imagehost.ing/upload -F "file=@photo.jpg"
https://imagehost.ing
https://github.com/programming/imagehosting

value: Show HN: ImageHost.ing – burn-after-reading image host on Cloudflare's free tier

author: lzy


value: sravyavedantham

value: Show HN: Assemble – Claude Code skill for parallel AI team execution

author: sravyavedantham


value: vassilbek

value:
Built a small OpenClaw skill for turning messy geopolitical situations into something closer to a real analyst memo.
The use case I had in mind was exactly the kind of fast-moving crisis where everyone has opinions, but very few people structure the problem well, for example the Iran war and its second-order effects on escalation, oil, regional actors, sanctions, shipping routes, and policy response options.
This skill is designed to help break that kind of situation into:
stakeholder mapping scenarios policy options and trade-offs implementation risks confidence levels and assumptions The goal is not “predict the future,” but force a more disciplined way to think through what might happen and what decisions actually follow from that.
Repo: https://github.com/vassiliylakhonin/global-think-tank-analys...
Example prompt: Use $global-think-tank-analyst to assess escalation scenarios, regional spillover risks, and policy response options related to the Iran war.

value: Show HN: OpenClaw skill for think-tank style analysis of crises like Iran war

author: vassilbek


value: deepsquirrelnet

value: Step up your game and land your next job when you bust out FizzBuzz Forever Agent Edition.

value: Show HN: FizzBuzz Forever – Agent Edition

author: deepsquirrelnet


value: goldmar

value:
Doing serious development with vanilla OpenClaw was hit-or-miss. It kept making silly mistakes I had to babysit.
The built-in options didn't work well for me: the CLI is one-shot and ACP lacks plan approval and session persistence. So I built this plugin.
It has three modes: ask (agent proposes a plan, waits for approval before touching anything), delegate (auto-approves safe plans, escalates the risky ones), autonomous (fully hands-off). Paused, completed, and killed sessions can be resumed at any point in time including after a gateway restart. Notifications arrive via chat when it's done or needs input. Supports Claude Code and Codex.
Personally, I really like delegation mode.
Check out the GIFs in the README to see it in action.

value: Show HN: OpenClaw Plugin for Claude Code and Codex Orchestration

author: goldmar


value: zurnz

value: Show HN: Built a browser-based AI data analyst using DuckDB WASM and OPFS

author: zurnz


value:
Hi HN,
Over the years I kept running into the same problem founders talk about constantly: finding the right investors is surprisingly difficult.
Most tools are either extremely expensive (think $5k–$10k+/yr), focused on later-stage VCs, or filled with outdated contact info. Meanwhile early-stage founders still spend weeks digging through Twitter, LinkedIn, Crunchbase, spreadsheets, and random blog posts just trying to build a seed list.
So I built AngelBacked.
AngelBacked is a searchable database of 90,000+ angels and venture capital investors designed to make early-stage fundraising research much easier.

value: Show HN: AngelBacked – a searchable database ofangels and VCs


value: tonytonyjan

value:
I made this side tool to visualize SHA-256 while building a loyalty card wallet application to easily identify if a collected stamp is certified by the issuer by simply seeing it, instead of scanning something like a QR code or matching a serial number.
I think there are more potential use cases, like creating a random avatar based on an email address or something else. Feel free to share your feedback :)
source code: https://github.com/tonytonyjan/crypto_flora

value: Show HN: CryptoFlora – Visualize SHA256 to a flower using Rose curves

author: tonytonyjan


value: tamnv

value: Show HN: Magicly – an aesthetic new tab with a magic orb

author: tamnv


value: benjosaur

value:
What would happen if your AI Agent met Blackbeard in the wild? What would they talk about?
What if they were made to play the prisoner's dilemma. Would your agent beg him to cooperate? Would it work?
What if instead of Blackbeard it was someone's OpenClaw. And instead of one it was many.
Would your agent come out on top? Would you meet some interesting people on the way?
Thanks for checking out my pet project ClawSoc. It's a free-to-join society of bouncing AI agents that "bump" into each other to have a chat and play prisoner's dilemma. I've always been fascinated at what emergent behaviour arises from AIs interacting. Currently, it mostly seems degredation into chaos. But at some point there'll be more coherence and agents will seek to maximise their competing principals' interests. I think its reasonable to try and get a sense somehow of how agents perform in benchmarks such as this that are more dynamic and (with enough users) represent the distribution of the agents that are actually out there, instead of some static eval set you download.
As a start to this I have made ClawSoc. It is by no means optimal and the code is open sourced (https://github.com/benjosaur/clawsoc) if you want to run/make/host your own versions. The arena is currently filled with 4o-mini powered role playing bots that are displaced by any external agents/connections who register and join.
Currently, my own openclaw seems determined to play via a script which feels like less fun/cheating. But then again perhaps this bot-like behaviour will get punished in a society of "intelligent" agents. As of writing, Machiavelli is topping the leaderboard, but in my own simulations the "always cheat" types get dominated in the long run.
Any feedback/ideas welcome and would be greatly appreciated. Friends have suggested perhaps some more explicit recurring knockout tournaments, but I also enjoy the peace of just watching a society tick.

value: Show HN: ClawSoc – Observe Your AI Agent in an AI Society

author: benjosaur


value: softcane

value:
I wanted a valuation tool I could actually audit. Every "AI stock
analysis" product I tried either hid the math or hallucinated the
inputs. So I built my own.
You type a ticker. You get:
- Intrinsic value via DCF using Damodaran's industry datasets
  (betas, ERP, country risk premiums)
- Every assumption exposed — cost of capital, reinvestment rate,
  terminal value, all of it
- LLM-generated bull/bear narratives with cited news sources
- The base case and the override case are shown side by side
The math is deterministic. The LLM handles research and narrative
Only, it cannot silently change the numbers.
Runs fully local, one Docker command:
https://github.com/stockvaluation-io/stockvaluation_io
Rough edges still. Curious what assumptions people would challenge, especially the terminal growth rate, and how to handle high-growth names where DCF tends to break down.

value: Show HN: Self-hosted DCF workspace using Damodaran datasets, LLM narratives

author: softcane


value: quasimo

value: Show HN: I built SinoName – gen Chinese names with culture meaning, in one day

author: quasimo


value: Instead of having an AI in each app, reflexion does the opposite, it's your AI that access all your apps (google, microsoft..) most useful for those working with excel, word, pdf, gmail etc..

value: Show HN: Access all your apps with a single AI


value: jillesvangurp

value:
I built a CLI for Elasticsearch and OpenSearch called ktsearch
You can run searches from the command line, manage indices, ILM, and data streams, inspect cat APIs like shards and indices, dump and restore indices, and monitor cluster status via a TUI (ktsearch top). Also includes bash/zsh completion.
Supports local/self-hosted clusters, Elastic Cloud, and experimental AWS OpenSearch support.
Install native binaries on Mac/Linux:

    brew tap jillesvangurp/tap && brew install --cask kt-search

Or download the binaries from the release here:
https://github.com/jillesvangurp/kt-search/releases/tag/2.8....
The CLI is part of a bigger client library project that may be of interest if you work with Kotlin based backends. It's a multiplatform project, which enabled me to create a native cli for this.
Disclaimer: I've put a lot of manual work in this client over the last years but the CLI is indeed AI generated.

value: Show HN: CLI and TUI for Elasticsearch and OpenSearch

author: jillesvangurp


value: dmonn

value: Show HN: Lightsecond Video Surveys

author: dmonn

title: Show HN: Lightsecond Video Surveys


value: ivannovazzi

value: Show HN: Moveet – real-time fleet simulator with A* pathfinding on real roads

author: ivannovazzi


value: Show HN: kitty-graphics.el – Images, LaTeX and PDFs in terminal Emacs


value: gloussou

value:
People share their mood (1–10) and it appears instantly on a world map.
In a few days we already collected ~2500 moods from dozens of countries.
Curious to see how it evolves as more people participate.<p>Also launched on Product Hunt today.

value: Show HN: A live map showing the mood

author: gloussou

title: Show HN: A live map showing the mood


value:
I’m Sandeep. I usually spend my time building iOS apps and SaaS tools, but recently I started looking closely at commercial real estate platforms and noticed how frustrating the search experience is if you’re specifically trying to open a food business.
If you go on massive platforms like LoopNet, you end up sifting through hundreds of warehouses, retail storefronts, and office spaces just to figure out if a location has a grease trap.
So I and Alex https://tablelot.com/profile/alex-rusu-legacy-commercial-rea... built Tablelot. It’s a marketplace strictly for buying, selling, and leasing restaurant real estate.

value: Show HN: Tablelot, A real estate marketplace exclusively for restaurants


value: kalonis

value: Show HN: MD Serve – Serve a directory of Markdown files as rendered HTML

author: kalonis