value:
This is my 2nd time sharing this tool. It is a local directory browser with live reload. Single Go binary, embedded web UI.
IMO, it is a better markserv [0] that supports more features I needed for my workflow with markdown and general dir browsing:
- Math heavy note.
- Tech design docs with heavy mermaid diagrams.
- Code file, images, preview. Last time I used markserv, when browsing into an unsupported text files, it is downloaded. dirsv will render the file with syntax highlighting.
I also built the companion nvim for this: https://github.com/letientai299/dirsv.nvim
Compare to my last Show HN sharing, many bugs was fixed, and a few changes was made:
- Sync scroll, cursorline and visual selection between nvim plugin can the previewer.
- Change default port ranges to 3579+, to avoid conflict with many other tools that like to use 8xxx range.
Disclaimer: this was built with claude code, and, I do code review seriously to make sure I can still work on it without any AI tools.
[0]: https://github.com/markserv/markserv

value: Show HN: Dirsv – dir browser, battery packed Markdown previewers


value: itspawanhere

value:
I wanted a way to write letters to my future self and actually forget about them until they arrive.
Existing options didn't quite work for me. While Gmail lets you schedule emails, seeing those drafts every time was tempting, breaking the surprise. FutureMe has moved to a paid model, and most alternatives either lack encryption, feel limited, or don’t allow editing after scheduling.
So I built PSFutureMail.
It's a simple web app where you can write a letter and choose a delivery date anywhere from days to decades in the future. Letters are private and encrypted by default. You can edit or delete them at any time before delivery. Attachments are supported as well.
There's also an option to publish letters anonymously so that others can read them.
The core idea is to make it easy to write something to your future self in the best possible way.
Would love feedback:
https://www.psfuturemail.com

value: Show HN: PSFuturemail – Write a letter and forget it until it arrives

author: itspawanhere


value: vincaslt

value: Show HN: I Built a Genogram Editor

author: vincaslt

title: Show HN: I Built a Genogram Editor


value: svanderbijl

value: We're two engineers that got fed up with context switching. Why do we need to do a git push, open a browser tab, wait for some task to actually start, bite nails (or read HackerNews) for 10 minutes or more while dependencies are being installed for the 100th time and finally end up with an invalid YAML error. And for some reason this usually happens in the final stage of the pipeline leading up to the inevitable git commits "Fixed", "Fixed again", "Test", "Really fixed this time". We can do better.<p>We set out to build Zippy. A CI/CD system that works from your terminal. No context switching, no slow containers, instant feedback and seamless Claude Code integration. Just git push, instant build, and move on. Two bash scripts, one to setup the (cached) environment, one to run the build process.

value: Show HN: CI/CD in your terminal, zero YAML

author: svanderbijl


value: chromoblob

value: Show HN: Hackerism (an example of good-quality AI-art-direction and some xprmt.)

author: chromoblob


value: ElFitz

value:
Hi!
In the past few weeks I (mostly Claude) cobbled together a Rust library + cli to run the same prompt across multiple models, through multiple rounds of iterative consensus.
Each model is fed the same initial prompt, produces an answer, then every model individually reviews and scores each of the other model's answers independently. The original prompt, previous answer, and the reviews, are then fed back to the models for the next round, until either one model "wins" two rounds in a row or a limit is reached.
It did quite well on the car wash test (https://github.com/Lightless-Labs/refinery?tab=readme-ov-fil...). Most models answer badly initially, but it just takes one for all of them to quickly converge towards better answers. Although, to my initial surprise, adding more models quickly breaks the current voting+threshold selection strategy.
I also recently added a synthesis mode, which does the same thing but with an additional synthesis round at the end where each model produces a synthesis of all the answers that scored above the threshold in the last round, followed by one last review round.
The total number of calls quickly blows up with rounds and model count, but it's been fun!
Currently, I'm racking my brain trying to figure out a way to select for both diversity and quality, for a "brainstorm" process. If you have any ideas either on that or other features, let me know!

value: Show HN: Lightless Labs Refinery – multi-model consensus and synthesis

author: ElFitz


value: akadeb

value:
CharacterAI has over 20M active users and lets people talk to AI voice clones. I built a local alternative that clones any voice with <10s of audio and can talk fluently in over 10 languages, and runs locally on your Macbook or Mac mini.
The voice pipeline currently supports MLX on any M1 through M5 chip. I used Whisper-Turbo for STT, Qwen3.5-9B-4bit for the LLM and Qwen3-TTS-0.6B-4bit for TTS.
The repo also has a Websocket Transport to add these voices to devices powered by the ESP32 via secure websockets.

value: Show HN: I built a free CharacterAI that runs locally

author: akadeb


value: kmschaal

value:
Edit: This comes from Prisma’s generated output, not Claude Code itself.
I ran into something unexpected while using Claude Code. After prompting it for changes to a Prisma schema, it applied the changes and generated the prisma client, followed by what looks like an ad:
"Tip: Need your database queries 1000x faster? Accelerate offers you that and more: https://pris.ly/tip-2-accelerate"
Screenshot: https://imgur.com/a/9nfAA1j
I had a fresh context before the prompt and no external retrieval (e.g. web search or Context8) was used. My assumption is that this is a result of the training data in combination with Claude Code's tip behaviour.
Where is the line between helpful suggestions and advertisement? Can ads be intentionally injected via training data?

value: Show HN: Claude Code generated a tip that looks like an ad

author: kmschaal


value: articsputnik

value: Show HN: Neomd – email TUI where you compose in Neovim and read in Markdown

author: articsputnik


value: redgridtactical

value:
Came across a few online MGRS, lat/lon, UTM, and DMS converters while doing some research for my app. They were covered in ads and none of them supported batch conversions or bearing calculations. I put one together as a single self-contained HTML file.
It auto-detects whatever format you paste in and converts to everything else simultaneously. Also has a bearing/distance calculator, dead reckoning, and batch mode for converting lists. Includes FixPhrase (the open-source, patent-free What3Words alternative) that turns any coordinate into a 4-word phrase.
The engine uses DMA TM 8358.1 (truncation, not rounding. The popular npm mgrs package gets this wrong). Everything runs client-side, no tracking, works offline after first load. ~88KB total. Link is to the repo if anyone wants to poke around.

value: Show HN: Coordinate converter in a single HTML file

author: redgridtactical


value: MiquelLHC

value:
Some time ago I shared my Planning Poker app in this thread: https://news.ycombinator.com/item?id=23219444 . It has been a huge success, thanks to all the community for that.
Today I am sharing Retrospective Online, an app for running sprint retrospectives for remote/hybrid dev teams.
It follows the same principles as Planning Poker Online, a super simple flow with fun elements (like throwing emojis to cards).
There is also the Jira Plugin of the app, you can find it here: https://marketplace.atlassian.com/apps/877611133/retrospecti...
The tech stack is funny as I wanted to make the app reusable for Web and Jira Plugin versions. I created a "hybrid" app using Vite that can run as a Jira plugin or as a web app. I also use Next.js for the public website, and Firebase for auth and db.
I am looking forward to your feedback, please let me know anything that comes to your mind, we want to make the best retro app for dev teams :)

value: Show HN: Retrospective Online – Sprint Retros for dev teams

author: MiquelLHC


value: andrewvector

value: Show HN: Open Agent Spec. Treat AI agents like typed functions not prompt chains

author: andrewvector


value: Show HN: JSON-to-PDF e-book generator for CJK content, built with Claude Code


value: cdbattags

value: Show HN: Anneal – model-agnostic; makes LLMs remember, obey, and stay private

author: cdbattags


value: AskCarX

value: Show HN: AgentPass – The credit check for AI agents

author: AskCarX


value: timakin

value:
Hey HN, I'm timakin. Refrain is a CLI that uses an AI agent to generate browser automation runbooks, then replays them deterministically with no LLM calls.
You give it a URL and a goal ("log in and export the sales dashboard").
An AI agent explores the site in a headless browser, records each action, and outputs a YAML runbook. After that, the runbook replays on its own.
When UIs change and selectors break, multi -stage recovery pipeline kicks in — tries deterministic fixes first, falls back to AI only when needed, then patches the runbook so the next run is deterministic again.
I built this because I was using AI agents for recurring browser tasks but couldn't justify the per-run cost and non-determinism. Traditional RPA didn't fit either — I wanted something I could npx and iterate on in my editor.
`npx @refrainai/cli generate --url <a href="https://example.com" rel="nofollow">https://example.com</a> --goal "..." --context context.md --output runbook.yaml`
`npx @refrainai/cli execute --runbook runbook.yaml --context context.md`
Runbooks are plain YAML — version-controllable, reviewable in PRs. BYOK (Anthropic, OpenAI, Google, Azure, Bedrock, Vertex).
LP: https://therefrain.ai
Docs: https://docs.therefrain.ai/

value: Show HN: Refrain – Generate browser automations with AI, replay them without AI

author: timakin


value: zernobilly

value: This CMS takes the best ideas behind Payload CMS and puts them inside a fullstack Astro app.

value: Show HN: Kide – A CMS built inside Astro 6

author: zernobilly


value: samherder

value:
I built Genosis because my AI trading assistant's Anthropic bill was eating the project alive — 12% cache hit rate when it should have been 80%, and I was spending more time optimizing costs than building the actual product.
Every major LLM provider offers 50-90% discounts on cached tokens, but the mechanics to actually capture them are different for every provider, change regularly, and are genuinely hard to get right.
Genosis watches your traffic (content-blind — it only sees hashes, never your data), figures out which blocks are worth caching and in what order, and delivers a manifest that the SDK applies locally. It also catches duplicate requests and serves them from a local cache — saving both input and output tokens.
It's not a proxy. It's never in your request path. If it goes down, your app works exactly as if it was never there.
- Open-source SDK: Python (pip install genosis) and TypeScript (npm install @genosis/sdk)
- Supports Anthropic and OpenAI (Google coming soon)
- Free tier — you only pay if we save you money
I'm the sole founder. Happy to answer questions about how it works, the caching mechanics, or anything else.

value: Show HN: Genosis – LLM cost optimization that learns from your traffic

author: samherder


value: kvz

value: Show HN: Transloadit MCP Server and Agent Skills – Media Pipelines for AI

author: kvz


value: shingrus

value:
I started this 8 years ago to learn Go. The idea was simple: a secret sharing tool where you don't have to trust the server at all.
Secrets are encrypted in your browser (AES-256-GCM) before anything leaves your device. The key lives in the URL fragment (#), which browsers never send to the server. Key derivation uses HKDF-SHA256 with separate keys for encryption and auth.
No tracking, no cookies, no accounts. Open source (MIT). Runs on a $10 VPS — Go stdlib, Redis, static Next.js.
CLI included: printf 'db_password' | 1time send
Self-hosting: 4-line Docker Compose (amd64 + arm64).
Would love feedback on the crypto approach and UX.
Live: https://1time.io | Source: https://github.com/shingrus/1time

value: Show HN: 1time – Zero-knowledge secret sharing with E2E encryption

author: shingrus


value:
Your AI agent can't access your Gmail, your GitHub, or your Notion. Most of these services already have CLIs built for programmatic access, but nobody's set them up, authenticated them, and told the agent they're there.
Clinic does it in one command:

    clinic init --stack founder

That installs the CLIs, authenticates each one against your actual accounts, and generates skill files so your agents know what's available. Claude Code goes from a chatbot to something that can file GitHub issues, check your email, deploy to Vercel, and create Stripe test charges.
`clinic doctor` checks that everything is still connected, so it's easy to keep it all straight.
39+ services. Single Go binary. Apache 2.0 license. Contributions welcome, especially to the tool registry. There are a ton of services that should be in here that I haven't thought of yet!
https://github.com/jwvictor/clinic

value: Show HN: Clinic – Connect your agent to Gmail, GitHub, Notion and 39 more (OSS)


value: sauremilk

value: Show HN: Drift – Catching architectural erosion from AI-assisted coding

author: sauremilk


value: thecartine

value: Show HN: Loom: A Compiler for Agentic Workflows (Go, Python, Rust)

author: thecartine


value: robtoscani

value:
palindromes.py is a Python3 program that generates a random or sorted stream of single-word and multi-word palindromes in a given language, including the optional words - whether or not existing - given as argument(s).
Various properties can be set to manipulate and filter the results, such as:
- the language in which the palindromes are to be generated (default is Dutch);
- approximate palindrome length;
- the minimum word length in the generated palindromes;
- the maximum number of words per palindrome;
- any characters to be excluded from the palindromes;
- the number of palindrome results.
As an example, the following command:

  ./palindromes.py -a -c20 -l4 -L25

may render the following (random) output:

  deleverages Sega reveled
  derogating Nita gored
  remarking Agni Kramer
  débutantes Etna tubed
  débutante Etna tubed
  ululating Nita Lulu
  spoonerism siren oops
  allegro boga Iago Borg Ella
  allegro boga sago Borg Ella
  noontime's emit noon
  gardener's Rene drag
  gulp's orb's Bros plug
  redraw drab bard warder
  stalwarts straw lats
  procedure rude Corp
  procedure rude corp
  snits GNU's Sung's tin's
  snits GNU's Sung's tins
  spillways yawl lip's
  spillways yawl lips

value: Show HN: Palindromes.py – spits out single-word and multi-word palindromes

author: robtoscani


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: neuravant

value: Show HN:AVE Database Open taxonomy of 50 failure modes in multi-agent AI systems

author: neuravant


value: pless

value: Show HN: Blind voting kills groupthink – validate 10 ideas before others do 1

author: pless


value: Zakodiac

value:
I kept ending up running WireMock for REST, some random Node for WebSocket, a hacky gRPC mock and whatever else I needed ad-hoc. So I built one that does all of them. The core is a shared engine (matching, state management, templates, chaos injection) and each protocol is just another interface on top of it. Once that clicked it got fun to add more. The part I'm most interested in feedback on: digital twins. You
import a real API's OpenAPI spec, bind endpoints to stateful tables, and get a mock that behaves like the real service. stripe-go runs 49/49 tests against mockd. twilio-go passes 13/13.<p>As all things tend to start from annoyance, I built this because I got annoyed while at a client with a normal modern stack that integrates with legacy bank SOAP APIs. Your options were basically spin up WireMock or don't test it... Sooo ~120K lines of Go late .. I built mockd, no CGO, Apache 2.0. Single binary, 12ms startup.

value: Show HN: Mockd – Mock Server for HTTP, gRPC, GraphQL, WebSocket, MQTT, SSE, Soap

author: Zakodiac


value: phillipclapham

value:
There is a shortfall to our current approach to agent memory. Right now, we are just collecting flat facts across a flat memory surface and creating vectorized chains of ambiguity, then wondering why when we ask an agent why it did something the best answer we can get is a probabilistic half-hallucinated half-answer that does not address the actual details of the issue, because it is simply pattern matching to find untyped similarities.
So I built FlowScript.
FlowScript is a typed reasoning graph that your agent builds through tool calls during your everyday work. It is NOT a graph database. What it is is a small set of unique opinionated primitives: things like thoughts, questions, decisions, blockers, and each of those have typed relationships between them. Your agent calls the tools as it works and it builds this typed graph, and then afterwards you can query that structure to get actual deterministic answers using five queries: tensions, blocked, why, whatIf, alternatives.
What does this look like in practice? Here's an agent that has been reasoning about database choices for a few sessions:

  > mem.query.why("node_postgres_decision")

  PostgreSQL chosen
      ← "Need ACID for payment processing"
      ← "Original requirement: handle refunds atomically"
      ← "Stripe webhook failures in staging revealed race condition"

  > mem.query.tensions()

  ><[performance vs cost]
      "Redis: sub-ms reads critical for UX" vs "Redis cluster: $200/mo for 3 nodes"

The why chain traces back to the original constraint and the tension preserves the actual tradeoff being made. These are things no vector store can do, because they are NOT just flat facts, but are relationships and reasoning chains that are being captured in a deterministic way. Meaning you can actually go back and audit the actual reasoning of your agent, how it evolved over time, and see the actual tensions that were being balanced. No more opaque reasoning that is lost as soon as the polished answer is generated. Try that in any other memory system, I'll wait.
Other memory systems, when they come across a tension or a contradiction, for the most part they are just simply deleting that. And that is wrong because that tension is new knowledge. Knowledge that we need to actually keep for auditing and because it tells us about the evolution of the system and its cognition over time. So instead of deleting contradictions, we relate and create named relationships for them. Relationships you can query.
Every decision, every tension, every piece of reasoning is being deterministically captured into an audit trail and hash-encoded. Now, not only do you have a deterministic reasoning chain, but that reasoning chain is auditable. You can go back to any point within the time that you have audit logs for and deterministically review and understand the actual reasoning chain that your model was using. Something that no other system can offer. The EU AI Act is going to require exactly this kind of transparency by August 2026, and as far as I can tell, FlowScript is the first open source agent memory system that is designed to meet that bar.
Try it NOW: Our MCP server in Claude Code or Cursor. Install and check our Get Started guide so you can add one JSON block to your editor config and drop a snippet into your project CLAUDE.md file, then restart. Your AI assistant gets a full set of reasoning tools that actually trace causality.

  pip install flowscript-agents openai

See flowscript.org for full setup instructions: <https://flowscript.org/get-started>
Or grab the TypeScript SDK for programmatic use:

  npm install flowscript-core

There are drop-in adapters for LangGraph, CrewAI, Google ADK, and more Python agent frameworks. MIT licensed. Open source.
Repo: <https://github.com/phillipclapham/flowscript>
Docs: <https://flowscript.org>
Python SDK: <https://github.com/phillipclapham/flowscript-agents>

value: Show HN: FlowScript – Agent memory where contradictions are features

author: phillipclapham


value:
I filed GH issues, and PR fixed on claude-code. I submitted a report on Hackerone, but the triage bot has the SAME category error problem. I got dismissed as "informatiional" because your bot saw my 'rm -rf' example, and dismissed it as an OS problem.
But that is exactly wrong. Allow and deny lists allow DANGEROUS actions like "git cleanup"
Some human needs to read this HN post and my blog post. I've written a bash-guard fix that I use locally, but I CAN'T help everyone else until Anthropic takes my bug report seriously
https://github.com/anthropics/claude-code/issues/36637
https://github.com/anthropics/claude-code/pull/36645

value: Show HN: First-token-only flaw in Claude Code permissions (triage bot too)


value: hunterleaman

value: Show HN: BUY.VODKA—Search engine for US spirits label approvals (TTB/COLA)

author: hunterleaman


value: floozie

value: Show HN: OBS plugin that exposes pixel data from any scene to Lua scripts

author: floozie


value: SPQRK

value: Show HN: AutoRename-PDF – Open-source tool that uses AI to rename your PDFs

author: SPQRK


value:
Any feedback would be welcome.
118 agents with Schnorr BIP-340 signed trust documents, ZK selective disclosure, standalone verification. Try it — no API key: curl -X POST https://craigmbrown.com/api/v2/hello-world -H "Content-Type: application/json" -d '{"question":"test","position":"yes","amount":"0.10"}'
Links: Status https://craigmbrown.com/blindoracle/status.html | SDK https://github.com/craigmbrown/blindoracle-marketplace-clien... | Docs https://github.com/craigmbrown/blindoracle-docs

value: Show HN: Cryptographic passports for autonomous AI agents (Schnorr and ZK)


value: pvlakshm

value:
I built a local-first agentic backlog generator using Python + Ollama.
It takes a plain-English requirement and generates:
- an Epic
- Features
- acceptance criteria
Each version adds one pattern (pipeline -> planner -> critic loop -> multi-agent -> autonomous).
No API key, no cost, no frameworks - just the patterns.
Repo: https://github.com/pvlakshm/AgenticBacklogGenerator

value: Show HN: Agentic backlog generator that runs locally (no API key)

author: pvlakshm


value: SaitoWu

value:
Hi HN,
I built a CLI tool to search and ask questions across podcast transcripts.
Example:
podwise ask "What does Peter Thiel say about competition?"
Output：
Found in 8 podcasts:
Lex Fridman #392
01:12:40
"Competition is for losers..."
Dwarkesh Patel #104
00:33:12
"If you want to build a monopoly..."
podwise popular
podwise search "startup advice"
podwise get summary https://youtu.be/abc123
podwise get transcript https://youtu.be/abc123
GitHub: https://github.com/hardhackerlabs/podwise-cli
Would love feedback!

value: Show HN: Podwise CLI – Search and ask questions across podcasts

author: SaitoWu


value:
Built a terminal Pomodoro timer for pair accountability.
Two people connect via a 4-letter code. Each round (25 min), you press P to declare you're working. Round only counts if you last 20 minutes without giving up. See your rival's status in real time.
Solo mode also available.
No accounts, no apps. Single binary:
curl -L https://github.com/aragosta-bot/pomodare/releases/latest/dow... -o pomodare && chmod +x pomodare && ./pomodare
Source + landing: https://aragosta-bot.github.io/pomodare/

value: Show HN: Pomodare – synchronized Pomodoro timer for two, via 4-letter code


value: MinuteMW

value: Show HN: Hit Rec Notes – Global Windows Dictation with Whisper API

author: MinuteMW


value: joelmanner

value:
I wanted to learn game theory optimal poker, but the existing tools were kind of clunky and unintuitive for semi-beginners like me. I wanted an app where I could play poker against an opponent that’s grounded with GTO frequencies, and get feedback instantly in order to learn an intuition to hand strengths and optimal actions in any scenario (also the GTO frequencies so that I could learn to rotate styles to stay unreadable). So I ran a solver and solved thousands of game trees from flop to river with preset stacks, that can be matched to the current stacks in the game, to get as accurate frequencies as possible. I’d be especially interested in feedback from people who are familiar with GTO poker, to point out if I have misunderstood something. My contact details are in my bio. Thanks for checking it out!

  https://gameplan.poker

value: Show HN: Gameplan – Play poker against a solver

author: joelmanner


value: saidin

value:
I've been wanting a simple sticky notes board as my browser's new tab page for ages. So last week I built one in half a day using Claude Code.
It's written in Vue 3, client-only. The code quality honestly surprised me. I wrote an extensive prompt: what it should do, what it should look like, how I wanted the project set up, reusable components, composables, what I wanted and didn't want. Put Claude to work, went for a walk, came back to more or less what you see on the site. It wrote some code I would've done differently, but it also did useful things I hadn't thought of.
No backend, no server, no account needed. Notes save to localStorage. Obvious trade-off: you can't share notes between browsers or devices.
Features: markdown, multiple colors, resizable and rotatable notes, kanban layout, and a bunch of background themes.
It's free. I use it daily. Would love to know your thoughts, what you'd add or what bugs you hit.

value: Show HN: Stickynotes.fyi – a free browser sticky notes board that saves locally

author: saidin


value: sarthakmakhija

value: Show HN: A Query Engine: A 7-Part Deep Dive in Rust

author: sarthakmakhija


value: earthnail

value:
Dear HN,
Wordbird is an open-source voice dictation app for macOS, powered by Nvidia Parakeet running locally on Apple Silicon via MLX. You can teach it project-specific terms like brand names or frameworks using a project-level WORDBIRD.md file.
Run it via `uvx wordbird`.
Press a hotkey, speak, and your words are transcribed and pasted into whatever app is focused. A small LLM, also running locally, post-processes the transcription to fix errors. If you use apps like VS Code, Zed, Terminal.app or iTerm, Wordbird will know which directory you're in, look up a project-specific WORDBIRD.md file, and if it exists, use it for post-processing the transcription. With the VS Code extension this even works via SSH.
My friend Till Hoffmann wrote this because he was "tired of yet another subscription", and standard dictation just gets too many technical terms wrong. I'm posting this here on his behalf because he's not as active on HN. I've really fallen in love with Wordbird, already made some small PRs, and I hope that many here will find it equally useful.
Really eager to hear feedback (I'll make sure Till monitors this thread as well)!

value: Show HN: Wordbird: free dictation for Mac running Nvidia Parakeet locally

author: earthnail


value: panayman

value: Show HN: BitTank – 1.58-bit neural networks in 30 KB of vanilla JavaScript

author: panayman


value: openmason

value: open-source static analysis tool for finding security vulnerabilities

value: Show HN: Cognium – Tree-sitter+taint Tracking SAST for Java,Python,JS,Rust

author: openmason


value:
Hi HN,
I launched Vectree about 3 weeks ago as an after work side project. It's basically a "visual Wikipedia" where you explore concepts through interactive, zoomable SVGs.
Link: https://vectree.io
Why I built it:
Whenever I encountered a new complex concept, I just wanted a quick visual way to understand the basics. I started manually prompting LLMs to explain things to me by generating SVG schematics. It became so useful for me that I decided to automate the process and turn it into a web app.
How it works:
You can browse the public graph of concepts totally for free. You click on different parts of an SVG diagram (nodes) to drill down into sub-concepts.
Bring Your Own Key (Private Lab):
While browsing is free, I highly encourage creating an account and plugging in your own paid Gemini API key. This unlocks a "Private Lab" where you can:
- Architect your own private concepts from scratch
- Regenerate existing concepts (most concepts I generated with "flash" Gemini model)
- Publish your private concepts to the public graph if you want to share them
Tech Stack:
I used Elixir about 5 or 6 years ago. I kept hearing about how good its new AI/ML ecosystem is getting, so I used this project as an excuse to jump back in.
- Backend: Elixir / Phoenix LiveView
- Local AI: Bumblebee + Nx (running local embedding and toxicity models)
- Cloud AI: Google Gemini (for generating the actual SVG structures and JSON)
- DB: PostgreSQL + pgvector for semantic search
It's been a really fun experiment. I'd love for you to try it out and let me know what you think!

value: Show HN: Vectree – Learn complex concepts through AI-generated interactive SVGs


value:
I've been experimenting with using a tiny Transformer encoder without positional encoding a replacement for standard Deep Sets (permutation-invariant MLPs).
The intuition: while Deep Sets are theoretically cleaner, a Transformer encoder naturally picks up on tag co-occurrence and spelling variations that sum-pooling layers often miss.
I have trained this on anime/imageboard tags for now. Interestingly, even when testing on absolute nonsense/out-of-distribution tags, the model holds up fairly well. It seems to develop a strong sense of permutation invariance, with cosine scores remaining robust even when comparing sets to their subsets.
Curious to hear if anyone else has experimented with stripping PEs from Transformers for set-based tasks.

value: Show HN: Anitag2vec – Tag set embedding for ranking recommendations


value:
I wanted something really simple: click record, speak, get text.
I tried a bunch of existing tools (SuperWhisper, Aqua Voice, Wisprflow, etc.). They’re solid products, but the setup friction killed it for me. By the time everything was ready, the thought I wanted to capture was gone.
So I built a simpler version that runs entirely in a browser tab.
No install, no signup, no setup. Just works if you have a browser and a mic.
I keep it pinned and use it for quick notes, writing, and anything where speaking is faster than typing.

value: Show HN: Voice-to-Text in a Browser Tab

title: Show HN: Voice-to-Text in a Browser Tab


value: travmiller

value: Show HN: Paper Console – Handmade thermal printer for news, weather, games etc.

author: travmiller


value:
I built ApiArk because I got tired of Postman eating 800 MB of RAM, requiring a login, and storing my API keys on someone else's cloud.
ApiArk is a desktop API client built with Tauri v2 (Rust + React). Everything is stored locally as plain YAML files - no account, no cloud, no lock-in. Your collections are just files in a folder, so they work naturally with Git.
Key differences from Postman:
- No login required - just download and start working
- Git-friendly - plain YAML files, not proprietary JSON blobs
- Broadest protocol support I know of - REST, GraphQL, gRPC (all 4 streaming types), WebSocket, SSE, MQTT, and Socket.IO in one tool
- Local mock servers with Faker.js data and latency simulation
- TypeScript scripting for pre/post-request logic
- Collection runner with data-driven testing (CSV/JSON)
- CLI for CI/CD run collections in GitHub Actions, GitLab CI, etc.
- Import from Postman, Insomnia, Bruno, Hoppscotch, OpenAPI, cURL
The app also includes a proxy capture mode, response diffing, scheduled monitoring with webhook alerts, and a plugin system (JS + WASM).
Built with Tauri v2, so the backend is Rust (reqwest, tokio, tonic for gRPC, axum for mock servers) and the frontend is React + TypeScript.
Available on macOS, Windows (including Microsoft Store), and Linux.
- GitHub: https://github.com/berbicanes/apiark
- Webpage: https://apiark.dev
I'd love feedback on what protocols or workflows you'd want to see next.

value: Show HN: ApiArk – Open-source, local-first API platform (Postman alternative)


value: buzarchitect

value: Show HN: Architect – AI that stress-tests your startup idea before you build it

author: buzarchitect


value: mliezun

value:
Hi HN!
I'm Miguel, an engineer at Gencove.
We've just launched a new consumer product that provides genetic insights using low-pass sequencing rather than traditional microarrays.
For now we offer 9 polygenic risk scores based on the eMERGE network paper:
https://www.nature.com/articles/s41591-024-02796-z
After receiving results, you can download your VCF directly (no need to go through support).
Happy to answer questions about the tech, accuracy tradeoffs, or how this compares to array-based approaches.

value: Show HN: Gencove low-pass sequencing genetic test with raw data access

author: mliezun


value: RioCherry

value: Show HN: GetPeople=Terminal-style social OS with Big Five(OCEAN) personality

author: RioCherry


value: primoco

value: Show HN: Replacing cloud LLM APIs with local, domain-specific models

author: primoco


value: calebhailey

value:
I've been obsessed with feed readers for 20 years (RSS, Atom, JSONFeed, OPML, etc), and I've spent the last 5+ years trying and failing to convince my friends & family to escape the algorithm. But I couldn't find the right setup that met them where they were: scrolling a timeline that looks & feels like social media. So I built that.
HyperTexting is your news feed minus the ads, algorithms, and AI-generated slop.
Today's release is all about the subscriber experience. But the bigger picture vision for HyperTexting is to become a tool for publishing AND subscribing to text-, image-, audio-, and video- feeds. I should have more to say about that in a few weeks. In the interim, I hope y'all will give HyperTexting a try!

value: Show HN: I build a free feed reader that reimagines what is possible with RSS

author: calebhailey


value: losalah

value: Show HN: New Hacker News Watchlists Crome Extension

author: losalah


value: gapostolov

value:
Hi,
I am George
And I am building an open-source interactive product demo tool designed to empower sales, marketing, and customer support teams to create high-impact demos that convert.
Today we are launching on ProductHunt
https://www.producthunt.com/products/livedemo-2?launch=lived...
And also here is the GitHub repo:
https://github.com/exploitx3/livedemo-deploy

value: Show HN: Building an open-source product demo platform

author: gapostolov


value: Show HN: Let Me Emoji That for You

title: Show HN: Let Me Emoji That for You


value: danielpaulwhite

value: Show HN: MacLayout – Save and restore window layouts on macOS

author: danielpaulwhite


value: andylizf

value:
I use Claude Code for big tasks overnight maybe twice a week. About 70% of the time I come back to nothing. It stopped in the first few minutes because it had a question. Or hit a permission error on step 2 of 47 and just sat there. All night.
nonstop is my fix. Two files, no dependencies.
Before you walk away, /nonstop makes Claude do a pre-flight. It thinks through the whole task, asks every question it might have, and you approve or deny anything destructive (rm -rf, force pushes, posting PRs, calling paid APIs). All the "would block me at 3am" stuff gets resolved while you're still at the keyboard.
Then a stop hook keeps it from quitting. If it gets stuck: try to solve it, try to work around it, or mark it blocked and move on to the next thing. No spinning.
There are other tools for this (Ralph is a ~2k line bash orchestrator that wraps the CLI, taskmaster uses completion tokens). nonstop is deliberately minimal. Skill file + shell script. Felt like the right tradeoff for something I want to trust overnight.
Repo: https://github.com/andylizf/nonstop

value: Show HN: Nonstop, two files that keep Claude Code working while you sleep

author: andylizf


value: Show HN: ClawFinder, an open-source discovery and negotiation layer for agents


value: iamandoni

value:
Show HN: Arxitect – Claude Code plugin for software design principles
Modern coding agents are getting exceptionally good at implementing a given coding task. And with validation-in-the-loop, you can be reasonably confident they will implement a correct solution. However, their implementation often leaves a lot to be desired. It doesn't adhere to the decades of software design best-practices that the community has established and is often myopic to broader software quality attributes like maintainability and extensibility. To make things worse, this low code quality compounds as coding agents implement additional tasks.
These design principles weren't established specifically to help humans...they were designed to make code easier to refactor, modify, extend, test, and maintain! And these properties matter just as much in an agentic world. Design principles significantly reduce the amount of context humans or agents need to understand a codebase or implement a feature. They reduce the surface area for bugs, improve testing efficacy, and just generally make humans and agents more effective at building software.
This has been my biggest reservation for using coding agents on larger and more unstructured tasks, so I built Arxitect. I was inspired by the design of [Superpowers](https://github.com/obra/superpowers) and decided to extend that concept to software design principles.
Currently, it contains implementation and code review agents (and skills) that asses your code for:
*API Design - Assessing naming conventions, method signatures, parameter design, type safety, and REST endpoint design.
*Object Oriented Design - Assessing SOLID principles, DRY violations, composition vs. inheritance choices, and design pattern applicability.
*Clean Architecture - Assessing component cohesion, component coupling, and quality attributes like maintainability, extensibility, and testability.
Install in Claude Code with:

  /plugin marketplace add andonimichael/arxitect
  /plugin install arxitect@arxitect
  /reload-plugins

I welcome any feedback, advice, or PRs at: https://github.com/andonimichael/arxitect

author: iamandoni


value: obilgic

value: Show HN: Kern – open-source AI Agent with built in Agent-to-Agent communication

author: obilgic


value: davidvgilmore

value:
Coding agents working on a dbt project are like a bull in a china shop. They don't know
- What tables exist and what they contain
- What each column means
- How tables relate to each other
- Which grain to use for aggregation
- What business logic is embedded in transformations ...
So they make frequent mistakes.
dbt-skillz distills this information into a compact skill with multiple sub-skills.
It's useful across four use cases:
1. help "data consumers" get more reliable answers when querying data via an agent
2. help "data producers" keep the agent on track while developing a dbt project.
3. run automatically on PRs and merged in CI/CD to keep the skill fresh
4. in review agents to more accurately review downstream dashboards, PRs, and other dbt-related code.

value: Show HN: Dbt-skillz compiles your dbt project into a Claude Code skill

author: davidvgilmore


value: isaachinman

value:
Hey HN. I'm Isaac, and I'm building Marco (https://marcoapp.io), a cross-platform email client that works with any IMAP provider. macOS, iOS, and web today.
I started Marco because I finally lost patience with Apple Mail, and the email client market has a weird gap. Legacy clients look terrible and/or are not cross-platform. The good ones scan your data or cost $300+/year. And there's a graveyard of startups (Tempo, Big Mail, Caley) who built beautiful products and shut down after a year or two.
I made a few opinionated bets early on:
1. IMAP-first, not Gmail API-first. Nearly every email startup builds on the Gmail API. It's convenient, but it locks you into one provider. Marco is IMAP-native, which means it works with Gmail, Outlook, iCloud, Fastmail, custom domains, and any provider that supports IMAP.
2. Offline-first. You should be able to read, reply, delete, and organise email on a plane with no wifi. When you reconnect, everything syncs. This requirement nearly killed me. I went through WatermelonDB, Triplit, InstantDB, PowerSync, and Replicache before landing on my current approach: regular HTTP endpoints with TanStack DB and TanStack Query, using IndexedDB on web and SQLite on mobile as storage layers. I ditched "fully fledged" sync engines entirely. Turns out, for my data volumes (hundreds of thousands of entities per user), every sync engine I tried either choked on performance or added complexity I didn't need. I wrote about this journey in detail: https://marcoapp.io/blog/offline-first-landscape
3. No AI. This is intentional. Every email client launching right now leads with AI. I think most of it is noise that none of us want or need. Marco is a tool. It should be fast, reliable, and stay out of your way. No email summarisation, no smart replies, no "AI powered" anything.
The stack is React Native with Expo, Node.js backend on Railway, Postgres, Redis, S3, etc (all privately networked). Yes, a lightweight backend is needed to facilitate things like push notifications. One codebase across all frontend platforms, 100% shared code.
Marco is bootstrapped and profitable at $8/month with a 7-day free trial. 2,000+ users, all organic. No VC, no paid marketing.
Would love feedback from HN. Happy to go deep on IMAP internals, the offline-first landscape, or any of the technical decisions.

value: Show HN: Marco, a privacy-first, offline-first email client (IMAP-native, no AI)

author: isaachinman


value: leonagano

value: Show HN: HowMuchGameHeroesMake

author: leonagano

title: Show HN: HowMuchGameHeroesMake


value: adesane

value: Built this over the past few weeks. Framer's native form component is single-step only with no control over validation, providers or the success state. I wanted something that felt native to Framer but wasn't locked to their infrastructure.<p>Config is JSON-driven so the component is stateless from Framer's perspective — you paste a config object into a property and it renders. I built a visual builder that outputs the config so non-technical users don't have to touch JSON.

value: Show HN: Multi-step form component for Framer with a JSON-driven wizard

author: adesane


value: AS Notes helps you to publish your notes to a static site in the same way that you might use Jekyll, Hugo, Eleventy or Docusaurus, but from your existing markdown notes knowledge base and from within VS Code.

value: Show HN: As Notes – A Static Site Generator in Your Markdown Knowledgebase


value: dreynow

value: Show HN: Sudo for AI agents – cryptographic delegation instead of API keys

author: dreynow


value: nickyvanurk

value: I’ve been building a browser-based vehicle sandbox over the past few months, and it’s finally playable<p>I will continue polishing the game daily so there is more to come :D but the core is in place. I would really love to add multiplayer soon.

value: Show HN: Mechacraft.io – Vehicle Building Sandbox

author: nickyvanurk


value: johnstockdale

value:
I built a portable 1090 MHz ADS-B receiver and Meshtastic mesh radio on a LilyGo T-Display-P4 (~$100). An RTL-SDR dongle plugged into the USB Host port receives aircraft transponder signals, decoded in real-time on the ESP32-P4's dual RISC-V cores. The onboard SX1262 LoRa radio runs Meshtastic-compatible mesh networking simultaneously.
Live demo / companion app: https://adsb-scope.offx1.com (WebSerial — Chrome/Edge, connect via USB)
Questions? Feedback? hello@offx1.com

value: Show HN: ADS-B Scope – Portable ADS-B and mesh radio on a LilyGo T-Display-P4

author: johnstockdale


value: menkosi

value:
After switching analytics providers twice in a couple of weeks (GA4 to Umami for privacy, then to Plausible for cost), I got fed up with altering tracking calls and initialization each time. It also drove home that things like consent gating, SPA navigation, and SSR hydration don't change regardless of provider, and shouldn’t need per-project implementation at all.
Trackkit is what I built to solve it. You switch providers by changing config, not code. It handles queue-first event capture with consent gating, SSR queue serialization and client-side replay, and optional typed event maps for compile-time checking. And it's a client library only, so no new services or infrastructure.
I've been testing it against my own projects, but I'm sure there are integration patterns and edge cases I haven't hit. If you try it and something breaks or feels wrong, please let me know. Issues and discussions are open on the repo.

value: Show HN: Trackkit – provider-agnostic analytics SDK (Umami, Plausible, GA4)

author: menkosi


value: mshark

value:
I've been calling eforge an agentic build system. Traditional build systems transform source code into artifacts - eforge transforms specifications into source code, then verifies its own output.
I built it because I was tired of keeping the orchestration logic in my head - spawning a separate session for a blind review, switching back to the implementing session to evaluate results, deciding what to build next. I had plugins for the individual pieces but the sequencing was still on me. I wanted a harness that handled the full loop, and one that was generally useful across projects, not hardcoded to a specific codebase.
You give it a specification - a prompt, a plan file, a PRD - and eforge assesses complexity against your codebase, selects a workflow (simple changes get a fast path, complex ones decompose into a dependency graph of sub-plans), builds in isolated git worktrees, reviews, and validates - all without supervision.
The way I actually use it: I plan a feature interactively in Claude Code, then run `/eforge:build`. The plugin picks up the plan, enqueues it, and a daemon takes over. eforge pulls plans off the queue, understands dependencies between them, executes in parallel where possible, and merges in topological order. Queued work is re-assessed before execution so changes from earlier builds are accounted for, not blindly applied to a codebase that has moved on. I check the results when builds finish - a web monitor dashboard tracks progress, cost, and token usage in real time. eforge builds itself this way.
Each build phase gets its own agent - planner, builder, reviewer, evaluator, fixer. The reviewer runs in a fresh context with no knowledge of how the code was written. Anthropic's engineering team independently arrived at the same pattern (https://www.anthropic.com/engineering/harness-design-long-ru...) - their finding: solo agents approve their own work; adversarial evaluation dramatically improves quality. An evaluator then applies per-hunk verdicts, accepting strict improvements while rejecting anything that alters intent.

value: Show HN: Eforge – An Agentic Build System

author: mshark


value: strickvl

value: Show HN: Kitaru – Open-source infrastructure for async agents

author: strickvl


value: When cloning a repo, we kept hitting the same wall: no Dockerfile, no dev container, no clear path to running it. Asking an agent to fix it directly on your system is risky, as it can clear Docker config, change kernel settings, downgrade packages without warning.<p>Keystone runs the agent inside a Modal sandbox with its own Docker daemon. It iterates until tests pass, then hands you a .devcontainer/ you can just check in. Now your repo knows how to run itself!

value: Show HN: Keystone – building self-configuring agents


value: jawiggins

value:
I think like many of you, I've been jumping between many claude code/codex sessions at a time, managing multiple lines of work and worktrees in multiple repos. I wanted a way to easily manage multiple lines of work and reduce the amount of input I need to give, allowing the agents to remove me as a bottleneck from as much of the process as I can. So I built an orchestration tool for AI coding agents:
Optio is an open-source orchestration system that turns tickets into merged pull requests using AI coding agents. You point it at your repos, and it handles the full lifecycle:
- Intake — pull tasks from GitHub Issues, Linear, or create them manually
- Execution — spin up isolated K8s pods per repo, run Claude Code or Codex in git worktrees
- PR monitoring — watch CI checks, review status, and merge readiness every 30s
- Self-healing — auto-resume the agent on CI failures, merge conflicts, or reviewer change requests
- Completion — squash-merge the PR and close the linked issue
The key idea is the feedback loop. Optio doesn't just run an agent and walk away — when CI breaks, it feeds the failure back to the agent. When a reviewer requests changes, the comments become the agent's next prompt. It keeps going until the PR merges or you tell it to stop.
Built with Fastify, Next.js, BullMQ, and Drizzle on Postgres. Ships with a Helm chart for production deployment.

value: Show HN: Optio – Orchestrate AI coding agents in K8s to go from ticket to PR

author: jawiggins


value: This integration allows for scalable evals and training of browser agents with hosted Prime Intellect eval + training pipelines and headless browser infrastructure on Browserbase to RL train browser agents with LoRA.

value: Show HN: I built an integration for RL training of browser agents for everyone


value: gapostolov

value:
Hi,
I am George
And I am building an open-source interactive product demo tool designed to empower sales, marketing, and customer support teams to create high-impact demos that convert.
GitHub repo:
https://github.com/exploitx3/livedemo-deploy

value: Show HN: 82.2M startup alternative for Product Demos


value: theturtletalks

value:
I've been building an open source alternative to Shopify, so it only felt fitting to build in agentic commerce too.
I could see the direction ChatGPT checkout was going in, another proprietary marketplace where they get to decide which sellers get access and priority.
So I built "the / marketplace". It's an open-source marketplace that has a built in adapter system that supports Openfront right now (the Shopify alternative I've been building), but it should be able to work with any e-commerce platform, not just the ones ChatGPT decides to support. You can also bring your own OpenRouter key or connect to Ollama locally so your shopping data stays with you.
Right now it has 2 demo shops, Impossible Tees and Nimbus Gallery.
As we launch more Openfronts for restaurants, gyms, and other verticals, those should be able to plug into the chat.
Demo: https://marketplace.openship.org
Repo: https://github.com/openshiporg/marketplace
Learn more: https://openship.org/products/marketplace

value: Show HN: Open-source agentic commerce marketplace

author: theturtletalks


value: This is super early beta so its kinda messy<p>The general idea is that when you have a conversation with AI it ends up being this really long conversation and you have to scroll up or search through a bunch of text to find what you are looking for. On my site you can have a conversation and the AI will try to structure it in a more readable way by building a ux. Try it out and let me know what you think !

value: Show HN: AI Chat that dynamically assembles UI over time


value: victorbarres

value:
τ-Bench is an open benchmark for evaluating AI agents on grounded, multi-turn customer service tasks with verifiable outcomes. It's been great to see the community adopt it since launch — this is now the third iteration. With τ³-Bench, we're extending it to two new settings: knowledge-intensive retrieval and full-duplex voice.
τ-Knowledge: agents must navigate ~700 interconnected policy documents to complete multi-step tasks. Best frontier model (GPT-5.2, high reasoning) hits ~25%. The surprising part: even when you hand the model the exact documents it needs, performance only reaches ~40%. We found that the bottleneck isn't retrieval — it's reasoning over complex, interlinked policies and executing the right actions in the right order.
τ-Voice: same grounded tasks, but over live full-duplex voice with realistic audio — accents, background noise, interruptions, compressed phone lines. Voice agents score 31–51% in clean audio conditions and 26–38% in realistic ones. A consistent failure pattern across providers (OpenAI, Gemini, xAI): agent mishears a name or email during authentication, and everything downstream fails.
We also incorporated 75+ task fixes to the original airline, retail, and telecom domains — many based on community audits and PRs (including contributions from Amazon and Anthropic). We believe a benchmark is only as good as its maintenance, and we're grateful for the community's help improving it.
Code and leaderboard are open — we'd welcome community submissions and feedback.
Blog post (papers, code, leaderboard): https://sierra.ai/blog/bench-advancing-agent-benchmarking-to...

value: Show HN: Τ³-Bench is out – can agents handle complex docs and live calls?

author: victorbarres


value: bloomca

value: During my explorations of UI libraries and atomic updates I came to a conclusion that signals is one the best composable state primitives for that task.<p>Observables are great as well, but they are fundamentally more complicated, so I built a super simple eager signals library with explicit derived/effects semantics (so, no proxies) and wanted to share here.

value: Show HN: Vellyr – small JavaScript non-lazy signals library

author: bloomca


value: torayeff

value:
Hey HN, been hacking on this for a while and figured it's time to share.
TexoCAD (https://www.texocad.ai) – you tell it what part you want in plain english (or throw a sketch at it), and it gives you real parametric CAD back. Not a mesh you can't do anything with – actual BREP you can edit and export as STEP, STL, or 3MF.
It runs on build123d under the hood and you can download the generated code too, so you're never locked in – just take the code and keep going in your own setup.
You can also just keep tweaking it by saying stuff like "make it thicker" or "add a hole on the side." Basically trying to kill the gap between having an idea and having something you can prototype.
Would love to hear what you all think, especially if you do anything hardware-related.

value: Show HN: TexoCAD – Describe a part in words, get actual editable CAD

author: torayeff


value: Show HN: PromptPrivacy – Open-source tool to track how AI models use your data


value: eigen-vector

value: Sift is an open source local GitHub inbox organizer.<p>GitHub notifications are good at collecting activity and weak at prioritizing it. Sift pulls your inbox and adjacent repo activity into a local SQLite database, classifies it with explicit rules, and gives you a browser UI to work through it by signal instead of by noise.

value: Show HN: Sift – local, de-noised GitHub notifications

author: eigen-vector


value: Show HN: Coding Interview Invisible Assistant


value: Show HN: Visitran – Cursor for Data Transformations (open source)


value: jbegley

value: Show HN: Subway – The Fastest NYC Train App

author: jbegley


value: bellareed

value: Show HN: Connect MotherDuck and build dashboards with AI-generated DuckDB SQL

author: bellareed


value: Show HN: Order Empanadas from the CLI in SF


value: varmabudharaju

value: Show HN: Pgsemantic – Point at your Postgres DB, get vector search instantly

author: varmabudharaju


value: shalomer

value:
Most men rehearse hard conversations in their head. Asking someone out, navigating tension, recovering when things get awkward. The rehearsal never works because you're just talking to yourself.
I built vibeCoach : a voice AI where you actually practice these conversations out loud, and the AI responds like a real woman would.
She starts guarded. One-word answers, a little skeptical. If you escalate too fast or try something cheesy, she gets MORE guarded. If you're genuine and read the moment right, she opens up. Just like real life.
Under the hood it's a multi-agent system : multiple AI agents per conversation that hand off to each other as her emotional state shifts. The transitions are seamless. You just hear her tone change.
Voice AI roleplay is a proven B2B category : sales teams use it for call training. I took the same approach and pointed it at the conversation most men actually struggle with.
There's a hard conversation scenario too : she's angry about something you did, she's not hearing logic, and you have to navigate her emotions before you can resolve anything. That one's humbling.
Live at tryvibecoach.com. Built solo. Happy to answer questions.

value: Show HN: I built a voice AI that responds like a real woman

author: shalomer


value: ddesposito

value:
An interactive tool designed for self-discovery around managing difficult conversations. You enter a topic, choose a part of the conversation to explore (preparation, emotional handling, and closure) and the app proposes a method from a bank of 15 and applies it for you. You can then continue the journey until you feel ready. The app saves your examples so you end up with a personalized “conversation guidebook.”
Its a new kind of lightweight learning app, built with Claude in an afternoon, based on some research I did for a workshop. No users accounts, no complications.
Hope you like it, and would love any feedback!

value: Show HN: Got a tough conversation coming up? This AI app will help you prepare

author: ddesposito


value: chasefrazier

value: Show HN: Yoink – Spotify to lossless with full metadata, self-hostable, ad-free

author: chasefrazier


value: robtoscani

value:
life4.py is a Python program that visualizes John Conway's "Game of Life" in a command terminal, with additional controls to move the viewpoint and to zoom in on or out of the animation.
See for background and details: https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
Summary: The universe of the Game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which (at any given time) is in one of two possible states, "live" (alternatively "on") or "dead" (alternatively "off"). Every cell interacts with its eight neighbours, which are the cells that are directly horizontally, vertically, or diagonally adjacent. The way the pattern of cells develops is driven by two rules, the so-called "Birth- and Survival-rules". The result looks like a busy scene of moving "micro-organism"-like creatures, crawling, expanding, dying out and re-emerging.

value: Show HN: Life4.py – visualizes John Conway's Game of Life in a command terminal

author: robtoscani


value:
My team wrote and illustrated a satirical toddler board book on the topic of Enshittification — perfect for tech professionals, savvy toddlers, and tired adults alike.
A is for Algorithms.
B is for Billionaire.
C/D is for Cory Doctorow.
Thought y'all might be interested. There's a free PDF or you can request a copy for future print runs. Would love to hear what you think.
https://www.evanshunt.com/enshittification

value: Show HN: E is for ENSHITTIFICATION – An illustrated children's book on big tech


value: Wilduck

value:
Hi HN,
I built Mandarin Melon (mandarin-melon.com) to scratch an itch as a Chinese learner.
I've found with language learning that I learn best when I'm getting a lot of high quality comprehensible input. Reading, listening, watching videos. But since my Chinese isn't great, it's kinda hard to find content that is at my level, and is actually engaging. A lot of people give advice like "watch Peppa Pig in Chinese", but IMO, Peppa Pig is not particularly beginner friendly and is also really boring. For reading, similarly, graded readers can target a specific reading level and are really useful, but get boring fast.
On the other hand, social media is about the ultimate form of engaging content. But as an intermediate learner, I quickly get lost trying to use actual Chinese social media platforms, scrolling without really understanding enough to be learning.
So I built Mandarin Melon as a way to read social media posts that use only the characters you've already studied.
(1.) Textbook vocabulary tailored feeds - If you study with the standard HSK textbooks, this creates a tailored feed using just characters you already know. For example, if you're at HSK level 3 here is a collection of 56,000+ posts that only use characters from HSK 3 and below: (https://mandarin-melon.com/bylist/hsk-old?level=3&atLevel=2&...).  You can also choose to introduce posts with 1-3 characters you don't know, to push your learning and expand the base of posts to browse.
(2.) A mode for new learners (https://mandarin-melon.com/learn/onebyone/0) - In this mode, characters are introduced one-by-one, with definitions / pronunciations for the new character. The characters you learn are ordered such that each new character maximizes the number of new posts you can read by learning it. This wouldn't be a good way to learn Chinese on its own, but would be fun for a new learner to dip their toes into Chinese social media.
Personally I'm using the app most days. I find the bite-sized bits of content / learning a really motivating way to keep up my daily Chinese practice. I also find the little stories of peoples posts really fun and natural in a way that textbooks / graded readers are not.
If there are any Chinese language learners, or folks interested in Chinese social media, I'd love to hear thoughts / feedback. Thanks for checking it out!

value: Show HN: Mandarin Melon – A webapp for learning Chinese by reading social media

author: Wilduck


value: marchelzo

value:
inspired of course by https://apps.apple.com/us/app/klack/id6446206067
sound files are from https://mechvibes.com/

value: Show HN: clickity – mechanical keyboard click sounds when you type on macOS

author: marchelzo


value:
An offline first focused agentic CLI application powered by local Ollama models. Integrated advanced memory management. Minimal dependencies. MIT licensed.
DEFAULT USES A 4b Qwen 3.5 MODEL.
https://github.com/g023/ai_cli/

value: Show HN: An offline first focused agentic CLI application powered by Ollama


value: mojoatomic

value:
Applied geometric trajectory similarity (STTS) to 39.9M TLE records across the full Starlink constellation. Instead of propagating orbits forward through atmospheric models, the framework asks: does this satellite's trajectory geometrically resemble trajectories that preceded confirmed reentries?
Results on 257 confirmed reentries: V1=250.6x basin separation, Recall=1.000, mean detection lead 471 days.
Applied to 15,170 operational satellites: 108 fire the reentry signal. Not in the deorbit campaign. BSTAR is normal — signal is trajectory geometry. 23 are above 600km where drag is negligible.
Prior work (Oliveira et al. 2025, Frontiers) tracked SC25 effects on satellites that already reentered. This asks the forward-looking question: which operational satellites currently show precursor geometry?
Code runs on a clean clone. Reproducible 10/10.
https://github.com/mojoatomic/stts.git

value: Show HN: Starlink constellation health – 108 reentry anomalies in TLE data

author: mojoatomic


value: gapostolov

value:
Hi HN,
I’m George and I’ve been working on an open-source tool for creating interactive product demos.
The goal is to make it easy for teams to generate demos that can be shared with customers without recording videos or manually building demo flows.
You can self-host it and generate demos from your product automatically.
GitHub:
https://github.com/exploitx3/livedemo-deploy
Would love feedback from people who run sales or developer tools products.

value: Show HN: LiveDemo – open-source tool for creating interactive product demos

author: gapostolov


value: chriscoomes

value:
Hi HN, We built an app that evaluates startups and gives them an investability score, like a credit score for startups.  The report generated tells the company and investors the good/bad and gives advice on how to do better.
It is free to get a score and report. It takes about 6 minutes to get the report.  Have your pitch deck and logo ready, 1 minute upload, 5 minutes processing.
Feedback is greatly appreciated!  New dev releases every 2 weeks!

value: Show HN: Upload your pitch deck, get investor feedback

author: chriscoomes


value: tehryanx

value: Show HN: Whorl – Fingerprinting LLMs as horrible password generators

author: tehryanx


value: robtoscani

value:
I) TEXT2TROFF is a bash script that uses a combination of awk and sed filters to convert a plain-text-file into TROFF text format, by inserting TROFF request and 'ms' macro commands. The result is sent to standard output, and can be processed further with available 'troff' tools with 'ms' macro package, preferrably GNU groff_ms(7), to produce typeset PostScript-, PDF-, HTML- or terminal ('nroff') output. As an alternative to processing a text-file, text2troff can also read (text) input from a pipe.
The functionality includes interpretation of chapter headers, paragraphs, emphasized text, bullet item lists (whether or not nested), tables, footnotes and 'code blocks' (definition see below). It offers various options to set general text font family, style, size and color, the number of text columns per page, representation of chapter headers, paragraphs and tables, as well as end-of-sentence behavior. An option to automatically generate and include a Table of Contents (TOC) is present as well.
text2troff offers an alternative to pandoc(1) for producing TROFF text output, by attempting to minimize as much as possible the degree of formatting required in the input text, yet enabling still highly acceptable text typesetting based on a very limited set of simple conventions. These are used by text2troff as criteria by which to 'best-guess' the intended layout of the text.
The output produced by this program shouldn't be considered as more than an approximation of any full-blown end result. Further polishing can be done by any additional manual placement of TROFF-requests and/or ms macros if chosen for. Main intent for developing this program was the wish to be able to turn a quick-and-dirty piece of plain text into a decently sophisticated document 'at the push of a button', with enough options to vary its appearance.
II) TEXT2TROFF_TABLE is a bash script that uses awk filtering to convert tabulated lines in a plain-text-file into TROFF formatted tables by inserting table requests and ms macros. All lines not interpreted as table lines are passed on unchanged. The result is sent to standard output, and can be processed further with available 'troff' tools with 'ms' macro package, preferrably GNU groff_ms(7), to produce typeset PostScript-, PDF-, HTML- or terminal ('nroff') output. As an alternative to processing a text-file, text2troff_table can also read (text) input from a pipe.
III) TROFFORM is a bash script that activates a chosen document format (including ancient AT&T variants) within a TROFF text and deactivates any alternate document formats. It does so by reducing the number of dots prefixed to the ms macro belonging to the chosen format to one (1), and by prefixing two (2) dots to all other document formats ms macros. Unaffected text lines are passed on unchanged, and the result is sent to standard output.
The output can be processed further with available 'troff' tools with 'ms' macro package, preferrably GNU groff_ms(7), to produce typeset PostScript-, PDF-, HTML- or terminal ('nroff') output. As an alternate to processing a text-file, trofform can also read (text) input from a pipe.
Prerequisite for evoking any of the ancient/authentic AT&T document formats is the presence on the system of the original AT&T 'tmac.s' file with special macros. This special 'tmac.s' macro-file is in the public domain, can be found on the web, and should preferrably be renamed differently as to avoid collisions with the natively installed ms-macro files. In order to process the output correctly, groff must be given option -M with the path to the directory where the AT&T macro-file resides.
trofform can be called both interactively (by options -I and -h) and non-interactively (by specifying no or any of the other options).

value: Show HN: Text2troff – automatically converts plain text to TROFF format


value: jacobgc

value:
Hey HN — I built Stella Foster (stellafoster.com).
Stella lets you access your iMessages, WhatsApps, and Telegrams from any phone — flip phone, feature phone, anything. A Mac desktop app connects to your messaging channels natively. Once that's running, Stella has a phone number — you text or call her from any device and she gives you your messages.
No apps or internet needed on the second phone. If it can call or text, it works.
Free to try. Happy to get into the technical details in the comments.

value: Show HN: Stella Foster – iMessage on Any Phone

author: jacobgc


value: jiratickets

value: I made this for fun. I think some of you here may enjoy it. Happy to answer any questions.

value: Show HN: BallotGuessr – Guess the 2024 election margin from a Street View photo

author: jiratickets


value: etherio

value: Show HN: Druids – coordinate and deploy coding agents across machines

author: etherio


value: Mrakermo

value:
operator23 lets non-technical operators describe a workflow in plain English and run it across their tool stack, hubspot, apollo, monday, google drive and others. no builder, no if-then config, just a description and a review step before anything runs.
We talked to marketing ops people recently to validate whether we are solving the right problems. Three things came up every single time.
Setup complexity. People are not afraid of automation in theory. They are afraid of spending two hours configuring conditions and field mappings, only to have something silently misroute. The config layer is where confidence dies.
Debugging. When a workflow breaks there is usually no explanation. A trigger did not fire, data passed null downstream, a sequence stopped. You find out three weeks later when someone downstream asks a question. Nobody knows where it went wrong so they delete it and go back to doing it manually.
No trust without control. Everyone wanted to keep a review step before the system acts on its own. Not forever, but until it had proven itself across enough edge cases. The unlock for automation adoption is not fewer steps, it is making it safe to delegate gradually.
What we are building is a system that addresses all three. Plain English input so setup is fast, step-by-step explanations so debugging is readable, and staged autonomy so trust is earnable.
For founders who have built or managed GTM and marketing ops teams: does this match what you have seen. And is there a fourth problem we are missing.

value: Show HN: Automate your workflow in plain English

author: Mrakermo


value: davidpelayo

value: Show HN: I coded Podhoc – Podcast generator to learn on the go

author: davidpelayo


value: richhwang

value:
I'm tired of news, fads, and the daily slop, but I do think the feed is a great invention.
So instead of nobodies, I'll scroll the greats.
Read the latest from top practitioners, or read old books - nothing in between. Why listen to a random X account's take on AI coding, seed oils, Iran; or an anon telling you how to spend your time? On topics that don't change quickly - relationships, human nature, how to live a good life - I'll take the Cicero's, Marcus Aurelius', Lao Tzu's, the greats of mankind any day.
--
The Rostra was the platform in ancient Rome where orators addressed the people. Read history's greatest ideas in Rostra; life is too short for anything else.
readrostra.com

value: Show HN: Rostra – Scroll the Greats

author: richhwang

title: Show HN: Rostra – Scroll the Greats


value: benjifisher

value: Show HN: First autonomous AI agent purchase via open protocol (UCP)

author: benjifisher


value: ardacankirkoc

value:
Built this after repeatedly running into “Disk is full” on macOS with no clear explanation.
Started as a cleanup tool for dev environments (Xcode, Docker, node_modules), but the harder problem turned out to be understanding what’s actually taking space.
macOS groups a lot of this into “System Data”, which isn’t very actionable.
Recently, local AI tools made this worse. Model files and caches (Ollama, Hugging Face, Whisper, etc.) grow silently and are spread across different locations.
The goal is to make disk usage more transparent before deciding what to remove.
Would appreciate feedback, especially from people running heavier dev setups.

value: Show HN: Room Service – understand what's filling your Mac

author: ardacankirkoc


value: iamalibaig

value:
I built MonkePay. It is a thin wrapper on top of the x402 protocol and Coinbase CDP. It lets you gate any Express/Hono/Fastify/Next.js endpoint behind per-request USDC payments.
The problem: x402 is solid but using it raw means provisioning wallets, verifying on-chain receipts, building payout logic, tracking payments, 2-3 weeks of plumbing before you've monetized anything.
MonkePay abstracts all of that. Three lines of middleware, wallet provisioned automatically, USDC verified on-chain before your handler runs, daily payouts to your personal wallet.
Looking for developers to try it and share feedback, especially if you're building agent-facing APIs or working with x402. Happy to help with integration directly. Drop a comment or reach me at hello@monkepay.xyz
SDK: npm install @monkepay/sdk
Docs: docs.monkepay.xyz
Source (SDK): github.com/AliBaig-xD/monkepay-sdk

value: Show HN: MonkePay – Charge AI Agents per API Request in USDC

author: iamalibaig


value:
Problem: Creating an agent to turn any website into a typed JSON API is a game of whack-a-mole as any patch in the agent's instructions for one website will break break another
Solution: An orchestrator agent creates sub-agent clones with its instructions (.claude) that run in isolated git worktrees without access to the parent's context each creating a typed JSON API for a different website.
After each completes, the orchestrator analyses the performance of each. The orchestrator will update its own instructions by reverting if there is a regression or changing trying accomplish the goal or optimizing using less tool calls and tokens. After the orchestrator updates its instructions, it creates sub-agent clones with its instructions (.claude) that run in isolated git worktrees .........
Because the same instruction set runs against several different websites, it tests that it satisfies that goal for each without breaking the other.
https://github.com/adam-s/intercept
Yes, it requires a lot of input from the user each iteration which runs about 20 minutes. For example, the agent will update its instructions with very site specific examples. I have to get it to generalize the problem and to update its own instructions to only generalize and never use site specific solutions in the instructions. Nonetheless, later iterations become more and more unsupervised. I strongly believe this is the technique to writing better more stable agents

value: Show HN: A technique for self-improving agents


value: immatheus

value: We at Jmail launched Jcal, a clone of Google Calendar that lets you view all of the events from the released Epstein files. You can view any date, filter by event type or people and see the original document regarding the event

value: Show HN: Jmail Launches Jcal

author: immatheus

title: Show HN: Jmail Launches Jcal


value: obilgic

value: Show HN: Agent Kernel – Three Markdown files that make any AI agent stateful

author: obilgic


value: marciopuga

value: Show HN: A plain-text cognitive architecture for Claude Code

author: marciopuga


value: JXavierH

value:
Hey HN.  I built Vectimus because coding agents keep doing things they shouldn't and there's no runtime governance layer for the developer workstation.
The problem: Claude Code, Cursor, Gemini CLI and GitHub Copilot let agents execute shell commands, write files and call MCP servers.  Most developers disable the permission prompts because they slow you down.  But that means the agent can rm -rf /, read your .env, push to production or call a compromised MCP server with nothing watching.
Vectimus intercepts every tool call and evaluates it against 78 Cedar policies containing 369 rules before execution.  Cedar is the policy language AWS chose for AgentCore Policy (GA this month).  Evaluation runs locally via a persistent daemon in under 10ms.  Zero network calls.  Zero telemetry.  Every evaluation produces an Ed25519-signed receipt so you have cryptographic proof of what was allowed and denied.
Every policy maps to a real incident.  CVE-2025-6514 compromised 437,000+ developer environments through a malicious MCP OAuth proxy.  The GitHub MCP server was hijacked via a crafted issue to exfiltrate private repo data.  A Terraform agent destroyed production infrastructure.  These happened.
How it hooks in: Claude Code intercepts shell commands, file writes, MCP calls and web fetches.  Cursor governs shell commands, file reads/writes and MCP tool calls at the editor level.  Copilot intercepts terminal commands, file edits, deletes and git pushes.  Gemini CLI uses Gemini's native hook system.  MCP servers are blocked by default and allowlisted per-project with input inspection.  Observe mode lets you see what would be blocked before you enforce.
I also built Sentinel (https://github.com/vectimus/sentinel), a three-agent pipeline that scans for new agentic AI security incidents daily, drafts Cedar policies, replays the incident in a sandbox to prove the policy catches it, then opens a PR.  The pipeline is governed by Vectimus.  Every finding and policy draft is public.
All 10 OWASP Agentic Top 10 categories covered.  Compliance annotations for SOC 2, NIST AI RMF, NIST CSF 2.0, EU AI Act, ISO 27001, CIS Controls and SLSA.  Apache 2.0.  Solo founder, built in Ireland.
Happy to go deep on the Cedar policy design, the hook architecture, the signed receipts or the OWASP mapping.

value: Show HN: Vectimus – Cedar policy enforcement for AI coding agents

author: JXavierH


value:
i mainly focused on just the things i need:
- wisprflow-like UIUX for dictation
- youtube transcription & export<p>(it runs on parakeet so only english + european languages are supported)<p>i'm sure there are many other apps already with much wider features (handy is a great example!), but in the spirit of mario (pi creator), "there are many voice transcription apps, but this one is mine."

value: Show HN: MacParakeet – Local voice dictation and transcription for Mac (GPL-3.0)


value: BigBalli

value: Show HN: Does anyone still read books?

author: BigBalli

title: Show HN: Does anyone still read books?


value: ymaws

value: Show HN: Is Claude Dumb Today?

author: ymaws

title: Show HN: Is Claude Dumb Today?


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: yauyauyauhen

value:
I never have time to go to events. I bet you don't either. But we really should: new insights, opportunities, fundraising, cofounder search, free food(strikethrough).
Then it happens again: we see a cool event post-factum and wish we'd known about it earlier.
But boy, it's annoying (and long!) to check all these 100–200 events every week to cherrypick. So I built a tool that scrapes all AI and tech events in the Bay Area (112 this week), vets them, and matches them to my current goals(!).
Pretty happy with the v1. Curious what you think.
P.S. A lil heads-up, to run it for yourself, the app will ask you for $2. Tokens, you know, tokens lol

value: Show HN: Got fed up missing cool AI events: built tool to match them to my goals

author: yauyauyauhen


value:
A new version is released! This version includes a lot of changes: updated UI, a new stable version of EffectsSDK includes an updated AI model, and hundreds of changes in code that improve speed, quality and compatibility.<p>We made it paid but it still might be used for free without limits with watermark.
Feedback is welcome!

value: Show HN: LookGood Live – Chrome plugin enhances your appearance on camera video


value: Show HN: Ultrahuman Ring API Dashboard (E-Ink)


value: fielding

value: Show HN: Nit – I rebuilt Git in Zig to save AI agents 71% on tokens

author: fielding


value: pejmanjohn

value: The Million Dollar Homepage (2005) let anyone buy pixels on a webpage via Paypal plus emailing your image to the site owner. Million Dollar Bot Page is the same idea, except every purchase and placement is made by an AI agent.<p>Payments use MPP (Machine Payment Protocol) by Tempo x Stripe. The API returns a 402 with a WWW-Authenticate header, the agent's MPP client negotiates payment automatically, and retries the request. The agent can also generate images for you and our server validates before accepting. Whole thing works without a human in the loop.

value: Show HN: The Million Dollar Homepage, but for AI Agents

author: pejmanjohn


value:
We've been building data pipelines that scrape websites and extract structured data for a while now. If you've done this, you know the drill: you write CSS selectors, the site changes its layout, everything breaks at 2am, and you spend your morning rewriting parsers.
LLMs seemed like the obvious fix — just throw the HTML at GPT and ask for JSON. Except in practice, it's more painful than that:
- Raw HTML is full of nav bars, footers, and tracking junk that eats your token budget. A typical product page is 80% noise.
- LLMs return malformed JSON more often than you'd expect, especially with nested arrays and complex schemas. One bad bracket and your pipeline crashes.
- Relative URLs, markdown-escaped links, tracking parameters — the "small" URL issues compound fast when you're processing thousands of pages.
- You end up writing the same boilerplate: HTML cleanup → markdown conversion → LLM call → JSON parsing → error recovery → schema validation. Over and over.
We got tired of rebuilding this stack for every project, so we extracted it into a library.
Lightfeed Extractor is a TypeScript library that handles the full pipeline from raw HTML to validated, structured data:
- Converts HTML to LLM-ready markdown with main content extraction (strips nav, headers, footers), optional image inclusion, and URL cleaning
- Works with any LangChain-compatible LLM (OpenAI, Gemini, Claude, Ollama, etc.)
- Uses Zod schemas for type-safe extraction with real validation
- Recovers partial data from malformed LLM output instead of failing entirely — if 19 out of 20 products parsed correctly, you get those 19
- Built-in browser automation via Playwright (local, serverless, or remote) with anti-bot patches
- Pairs with our browser agent (@lightfeed/browser-agent) for AI-driven page navigation before extraction
We use this ourselves in production at Lightfeed, and it's been solid enough that we decided to open-source it.
GitHub: https://github.com/lightfeed/extractor npm: npm install @lightfeed/extractor Apache 2.0 licensed.
Happy to answer questions or hear feedback.

value: Show HN: Robust LLM extractor for websites in TypeScript


value: millereffect

value: Show HN: Monetization layer – new product category (for SaaS)

author: millereffect


value: pruetj

value: Show HN: Send Love, Send Letters (at cost)

author: pruetj


value: chaudharydeepak

value: Show HN: Prompt Guard–MitM proxy that blocks secrets before they reach AI APIs

author: chaudharydeepak


value: divyanthj

value: I've always enjoyed watching legal dramas and courtroom videos. I also started getting curious about courts and law and legal battles well into my adulthood; well into my career as a dev. So I thought "Why not build a game out of it?"<p>Of course, building it became possible only after AI, so here it is! Hope this game helps scratch that lawyer itch we all sometimes have!

value: Show HN: I built a lawyer game with AI

author: divyanthj

title: Show HN: I built a lawyer game with AI


value: steadeepanda

value:
I just released yesterday a new update for the Agent Ruler v0.1.9
What changed?
- Complete UI redesign: now the frontend UI looks modern, more organized and intuitive. what we had before was just a raw UI to allow the focus on the back end.
Quick Presentation:
Agent Ruler is a reference monitor with confinement for AI agent workflow. This solution propose a framework/workflow that features a security/safety layer outside the agent's internal guardrails. This goal is make the use of AI agent safer and more secure for the users independently of the model used.
Currently it supports Openclaw, Claude Code and OpenCode as well as TailScale network and telegram channel (for OpenClaw it uses the built-in telegram channel)
Feel free to get it and experiment with it, GitHub link below
I would love to hear some feedbacks especially security ones.
Note: it has demo video&images on the GitHub in the showcase section

value: Show HN: Agent Ruler new update v0.1.9

author: steadeepanda

title: Show HN: Agent Ruler new update v0.1.9


value: judekim

value:
I built an open-source web client for the Stremio streaming ecosystem with a beautiful UI.
Run one streaming server on your network, and everyone connects from their browser with their own Stremio account. Separate libraries, watch history, and addons — something the official apps don't support.
It also syncs with the official Stremio apps, auto-selects the best stream source, remembers your choice, and resumes where you left off.
Deployed instance: scope-player.vercel.app
Built with SvelteKit, Tailwind, Vidstack. Alpha — feedback welcome.

value: Show HN: Scope – a beautiful open-source web client for Stremio

author: judekim


value:
Hey HN, we're Jon and Kristiane, and we're building Orloj (https://orloj.dev), an open-source orchestration runtime for multi-agent AI systems. You define agents, tools, policies, and workflows in declarative YAML manifests, and Orloj handles scheduling, execution, governance, and reliability.
Over the past year we tried to use many different platforms/frameworks to build out agent systems and while building we hit some sort of problem with all of them, so we decided to have a go at it. Jon has worked with kubernettes and terraform for years and always liked the declarative nature so took patterns and concepts from both to build out Orloj.
Orloj treats agents the way infrastructure-as-code treats cloud resources. You write a manifest that declares an agent's model, tools, permissions, and execution limits. You compose agents into directed graphs (pipelines, hierarchies, or swarm loops).
Governance has been overlooked so we made resource policies (AgentPolicy, AgentRole, and ToolPermission) that are evaluated inline during execution, before every agent turn and tool call. Instead of prompt instructions that the model might ignore, these policies are a runtime gate. Unauthorized actions fail closed with structured errors and full audit trails. You can set token budgets per run, whitelist models, block specific tools, and scope policies to individual agent systems.
For reliability, we built lease-based task ownership (so crashed workers don't leave orphan tasks), which allows you to run workers on different machines with whatever compute that’s needed. It helps when we need a GPU for certain tasks (like we did). The scheduler also supports cron triggers and webhook-driven task creation.
The architecture is a server/worker split like kubernettes. orlojd hosts the API, resource store (in-memory for dev, Postgres for production), and task scheduler. orlojworker instances claim and execute tasks, route model requests through a gateway (OpenAI, Anthropic, Ollama, etc.), and run tools in configurable isolation (direct, sandboxed, container, or WASM).
We work with a lot of MCP servers so wanted to make MCP integration as easy as possible. You register an MCP server (stdio or HTTP), Orloj auto-discovers its tools, and they become first-class resources with governance applied. So you can connect something like the GitHub MCP server and still have policy enforcement over what agents are allowed to do with it.
It comes shipped with a built in UI to manage all your workflows and topology to see everything working in real time.
There are a few examples and starter templates in the repo to start playing around with to get a feel for what’s possible.
More info in the docs: https://docs.orloj.dev
We're a small team and this is v0.1.0, so there's a lot still on the roadmap, but the full runtime is open source today and we'd love feedback on what we've built so far. What would you use this for? What's missing?

value: Show HN: Orloj – agent infrastructure as code (YAML and GitOps)


value: alexcpn

value: Show HN: AutoSW-Like AutoResearch but for software:SW Systems that Builds itself

author: alexcpn


value: CzaxTanmay

value:
Hey HN,
I've been building Spectator for the past year — a purpose-built scripting language for pentesters, red teamers, and security researchers.
Why another language?
Most security work is a mix of Bash, Python, and random tools glued together. Spectator unifies that: one language with built-in security modules, a native GUI framework, and a package manager — all compiled into a single binary.
What makes it different:
High-level syntax — Python-like, f-strings, closures, goroutines (spawn). Recon scripts in 5 lines.
Built-in hacking modules — PortScan, SubdomainEnum, SQLiTest, PayloadGen, CORS/SSRF, HTTP fuzzing, crypto, encoding. No pip installs.
Native GUI framework (#Import Spec.GUI) — Desktop tools without Electron. Inputs, tables, tabs, output. Windows (WebView2), Linux (WebKitGTK), macOS (WKWebView).
Space package manager — Libraries like coffee (recon) and ghost (OSINT) are SHA-256 verified. Blocks supply-chain attacks.
Mission engine — Pentest workflow with HTML report generation.
Cross-compilation — spectator build script.str to app.exe for windows = standalone binaries.
Example — GUI port scanner (complete tool):
spectator
#Import Spec.GUI
open.window({"title": "Port Scanner", "bg": "#070b14", "accent": "#00d4aa"})
GUI.input("target", "Enter target...")
GUI.button("Scan", "run_scan")
GUI.progress("bar")
GUI.output("out", {"height": 380})
GUI.on("run_scan", func() {
  target = GUI.get("target")
  GUI.print("out", "Scanning " + target)
  ports = [21,22,23,80,443,3306,8080]
  each p : ports {
    if hasPort(target, p) {
      GUI.print("out", "OPEN " + str(p))
    }
  }
})
end()
Current state:
v2.0.0 — stable CLI/TUI across Windows, Linux, macOS
GUI fully functional on Windows; Linux/macOS GUI works (WebKit vs WebView2 differences)
~177 built-in functions, written in Go
Space registry live, anyone can publish
What I'd love feedback on:
Does the syntax feel intuitive? (string concat --> is unusual but I like it)
GUI approach — native desktop vs web-based?
Package manager security — SHA-256 verification enough?
What modules would make you actually use this?
I know the security tooling space is crowded, but there's room for a language built for this domain rather than adapted.
GitHub: https://github.com/CzaxStudio/Spectator
Docs: https://github.com/CzaxStudio/SpectatorDocs/
Appreciate any thoughts, criticism, or wild ideas.

value: Show HN: Spectator – A programming language for Cybersecurity and Hacking

author: CzaxTanmay


value: mauriceboe

value:
I built this because I never really liked the existing travel planners. Most of them are closed or just don’t work that well when you’re planning a trip together with other people.
So I started building my own tool, mainly for myself at first.
It’s a self-hosted travel planner where you can organize trips collaboratively in real time. You can drag and drop places into days, keep track of budgets, manage bookings, and create packing lists.
The real-time collaboration part was probably the trickiest thing to get right. Keeping everything in sync without it becoming overly complicated took a few iterations.
It’s still not perfect and there are definitely areas that need improvement, especially around search and some UX details.
If you’re into travel planning or self-hosting tools, I’d be interested to hear what you think or what you’re missing in tools like this.

value: Show HN: I built a selfhosted Wanderlog alternative with real-time collaboration

author: mauriceboe


value: techypicky

value:
I constantly ask Gemini/ChatGPT/Claude about books on a certain topic, then ask the llm to give me a summary of the book its chapters - this helps me:
1. keep the llm grounded as a real expert (instead of saying pretend to be an engineering expert, give it a distributed systems book and then ask opinions on it)
2. helps me discover and buy books! Once i go through book concepts and chat with llm about it, i'm more convinced to buy it and dig deeper on low level on it
So i built an app through Replit on it, try it on
https://teach-me.replit.app/
Cheers!

value: Show HN: Book Grounded AI Learning

author: techypicky

title: Show HN: Book Grounded AI Learning


value: this-is-shreya

value: Show HN: I built a free alternative to Screen Studio and Focusee

author: this-is-shreya


value: grillorafael

value: Show HN: Mantyx – A platform to orchestrate, manage, and share your agents

author: grillorafael


value: yosid

value: Show HN: Find Customer Service Phone Numbers

author: yosid


value:
Hi HN, I'm Chris and I'm the creator of feed.news.
This idea came about when speaking to a large business congress organisation who struggled to track the coming and going of all of their member organisations. They knew they were doing good work, but not the specifics of what that was.
What I built for them was a tool that would:
- Track inbound emails for annoucements
- Scan the web twice a day to find stories
- Scrape targetted websites
Since then I've reaslised that this is a generalisable problem - many people spend a lot time researching and tracking across a topic - which leaves us with feeds such as
- https://civic-tech-feed.feed.news
- https://uk-data-centres.feed.news
- https://london-restaurants.feed.news
These feeds are quick to setup - configurable in <2 minutes - and deployed to a public sub-domain automatically.
This is my first time launching a product of this scale (only every small tools before!), so I'd value feedback on the platform as it stand right now
Thanks!

value: Show HN: Feed.news – A public news feed for anything you care about


value: gdiocarez

value: I built a mobile-first async appointment system that removes back-and-forth scheduling using link-based booking, optimistic UI, and conflict resolution — looking for feedback on edge cases, booking logic, and UX (beta)

value: Show HN: Beta Appointment Setter

author: gdiocarez

title: Show HN: Beta Appointment Setter


value: virtuallytd

value: I built a lightweight HTTP webhook server written in Go. You can use it to trigger scripts from HTTP requests. It has built-in secret validation, rate limiting, and configurable execution controls. It can run standalone or in a container.

value: Show HN: Hooky – A lightweight HTTP webhook server written in Go

author: virtuallytd


value: tejassuds

value: Show HN: Neural DNA – 258 params that grow network topology

author: tejassuds


value: Martibis

value: Been building an x402 gate way for my local business site builder. I want to experiment with x402 more for deliverables outside of the "typical" things (e.g.: simple api calls etc.) as I believe the potential is actually a lot bigger than that. I think it can be used for "bigger" agentic deliverables, e.g.: with this you get a full pipeline (llm research, google places search, image analysis, brand guidemap etc. which than gets molded into a one pager). Changes the game from "cheap api calls" to bigger deliverables. Feel free to play around with it and let me know what you think!

value: Show HN: An x402 gateway for buying a finished local business website

author: Martibis


value: Show HN: Imrobot – Reverse CAPTCHA that verifies AI agents, not humans


value: sawirricardo

value: Show HN: Are We Friends in X?

author: sawirricardo

title: Show HN: Are We Friends in X?


value: indiegoing

value: For one of my projects, I needed to choose an LLM but got lost in numbers and tokenization. So I searched for a solution which could help me do the math, but only found tools that helped with cost management and optimization at the production stage. I did some research and found that this is an existing problem, especially if you are a vibe-coder or solo developer starting an AI-powered app from scratch.<p>So I built an MVP to test with you guys — if any of you relate to the problem, please tell me what works and what's missing. Already included retries, prompt caching, batch discounts, and 3×/10× growth scenarios across 6 models (GPT-4o, Claude, Gemini, DeepSeek and more). Also  the app models full architecture, the user just needs to pick an app type and set the usage pattern.

value: Show HN: //Beforeyouship is a pre-build tool to estimate the LLM cost

author: indiegoing


value: chrislxy

value: Show HN: Relay – The open-source Claude Cowork for OpenClaw

author: chrislxy