value: nowflux

value:
PG has posted about improving social networks using something like an "intellectual CAPTCHA" many times [1][2][3][4] - "Make users pass a test on basic concepts like the distinction between necessary and sufficient conditions before they can tweet."
I felt the same way. So I built one using a mix of simple math, logic, and Twitter/X Community Noted posts. Try sample questions here - https://mentwire.com/sample - without signing up.
- Invites are temporarily open to HN users.
- Onboarding test + one daily question before accessing feed, post or reply.
- Posts authors are anonymous until upvoted or downvoted, forcing evaluation of content on merit.
- Face ID (on-device only) to post/reply, pangram checks for AI text.
Sourcing good questions turned out to be much harder than I thought. If you have suggestions to scale this, I would love to hear. Eventually, could be gated across disciplines/topics to get a competence × interest graph instead of the pure interest graph of today's social networks.
[1] https://x.com/paulg/status/1235949761359904768 [2] https://x.com/paulg/status/1576517990182359040 [3] https://x.com/paulg/status/1514979883948126209 [4] https://x.com/paulg/status/1505842647319126016
Repost from https://news.ycombinator.com/item?id=47577829.
This link contains a full quiz and linked directly to sample to try without signing up.

value: Show HN: I Built Paul Graham's Intellectual Captcha Idea

author: nowflux


value: redgridtactical

value:
A few weeks ago I posted about Red Grid MGRS, a free 10-digit MGRS navigator for iOS (Android shipping soon!). Based on your feedback I shipped a bunch of new updates:
Topographic map layer with contour lines (OpenTopoMap) alongside standard and dark tactical tiles
Meshtastic LoRa mesh integration — connect to a $20 radio over BLE for off-grid position sharing. Had to write a minimal protobuf encoder from scratch since there's no React Native SDK
Three map styles you can cycle through and download for offline use
Fixed the iOS BLE state machine issue where CoreBluetooth starts as "Unknown" and silently blocks scanning
Getting Meshtastic integration to work was a rabbi thole, but by far the most interesting technically. The protocol uses protobuf over BLE with a specific handshake. There was no documentation for third-party integration, so I worked from the protobuf definitions and the official iOS app's behavior to get this working.
Still zero network calls for core functionality. Still no tracking. Open source.

value: Show HN: Topo maps and Meshtastic mesh networking in MGRS navigator

author: redgridtactical


value: Show HN: Vif - An alpha|experimental alternative to PHP Composer


value: JKCalhoun

value: Did this a few years ago. Seems apropos. Sources and more here: https://github.com/EngineersNeedArt/Mooncraft2000

value: Show HN: Moon simulator game, ray-casting

author: JKCalhoun


value:
I built DockerTab to give developers a way to monitor and control their Docker hosts directly from their phones. You can start/stop containers, view live logs, and access the terminal without needing port forwarding.

    The iOS app is available now: https://apps.apple.com/us/app/dockertab/id6759782246

    The Android version is currently in the testing phase.

    I'd love to hear your feedback at support@dockertab.app

value: Show HN: DockerTab – Manage your Docker containers from iOS and Android


value: godelescherbach

value:
Reserved instances save money... until utilization changes, and you’re still paying.
With ComputeLock, the risk of on-demand price spikes doesn’t exist - we offer burst insurance.
1. Send us an estimate of on-demand spend you expect and from what provider.
2. We confirm the maximum we'll cover for you for a small fee, and you get it in writing.
3. If on-demand prices spike, we'll reimburse you.
We plan to work with smaller developers to start. How we do this is by monitoring supply and demand for compute. Of course, we'll get it wrong sometimes. But it's like insurance, you'll only need it when you NEED it.
Would love to hear your feedback: https://computelock.com/

value: Show HN: ComputeLock – Insurance to reduce unpredictable compute spend

author: godelescherbach


value: xarahe

value:
I built Open Migration because I was tired of "blind" database migrations causing deployment failures.
The standard way to handle migrations—running them automatically when the application starts—works perfectly until one day, it doesn't. You might have a migration fail halfway through, or a lock-contention issue that takes down your entire production environment before you even realize what happened.
I realized I needed a centralized "Control Plane"—a place where I could see all my databases (SQLite, Postgres, MySQL) and their migration history in one dashboard. I also wanted to fetch migration files directly from GitHub/GitLab without the overhead of project-specific CI/CD jobs.
So I built it myself.
What it does:
Centralized management for all your databases from one UI.
Native SCM integration to securely fetch migration files via tokens.
Framework-agnostic (works for any stack).
Everything is self-hosted

value: Show HN: I built a modern, self-hosted control plane to manage migrations

author: xarahe


value: shloked

value: Show HN: Vajra, a background coding agent with graph-based workflows

author: shloked


value:
I'm building Fillvisa - It's a free USCIS form-filling web-app
USCIS forms still use XFA PDFs, which don’t let you edit in most browsers. Even with Adobe, some fields break and are unfillable.
So I converted the PDF form into modern, browser-friendly web forms - and kept every field 1:1 with the original. You fill the form, submit it, and get the official USCIS PDF filled.
I found out SimpleCitizen(YC S16) offers a DIY plan for $529 [1]
---
What Fillvisa does:
- Fills USCIS forms with a guided web interface.
- Autosaves as you go
- Generates a completed PDF ready to print and mail
- Works offline after first load
What it doesn't do:
- It won't file for you.
- No lawyer review. If your case is complex, hire an attorney.
---
How do I maintain the forms + business model:
Fillvisa will always be 100% free for immigrants. I'm building a paid version (plus.fillvisa.com) for immigration professionals (lawyers, paralegals, document prep specialists).
Both the apps utilize the same form + mapping. Thus,it takes care of revenue + I have incentive to maintain the forms.
---
I shared the prototype on FB groups and Reddit - most DIY applicants love it :)
---
[1]  https://www.simplecitizen.com/pricing/

value: Show HN: I made a free alternative to SimpleCitizen (YC S16)


value: simonrendon

value: Show HN: EvalLens – Open-source tool to evaluate structured LLM outputs

author: simonrendon


value: sudoplease

value:
Created a local Terraform plan review tool that makes reviewing terraform show -json data a reality.<p>- The plan review tool allows you to identify:
- Risks
- Blast radii
- Dependency chains
- Module input tracing
- You can collapse reviewed plans similar to PR reviews.<p>I am interested in any feedback you may have about this tool, particularly from those who review larger plans.

value: Show HN: View Terraform plans without reading walls of JSON

author: sudoplease


value: CarolineWang

value: Show HN: Sandbox AI Agents with Full macOS

author: CarolineWang


value: yuruko

value: Show HN: Yume, a Desktop GUI for Claude Code (Tauri/React)

author: yuruko


value: odedfalik

value: Show HN: u there? Let Claude Code check if you're at your computer

author: odedfalik


value: essamsleiman

value:
We built meta-agent: an open-source library that automatically and continuously improves agent harnesses from production traces.
Point it at an existing agent, a stream of unlabeled production traces, and a small labeled holdout set.
An LLM judge scores unlabeled production traces as they stream.
A proposer reads failed traces and writes one targeted harness update at a time, such as changes to prompts, hooks, tools, or subagents.
The update is kept only if it improves holdout accuracy.
On tau-bench v3 airline, meta-agent improved holdout accuracy from 67% to 87%.
We open-sourced meta-agent. It currently supports Claude Agent SDK, with more frameworks coming soon.
Try it here: https://github.com/canvas-org/meta-agent

value: Show HN: Meta-agent: self-improving agent harnesses from live traces

author: essamsleiman


value: Show HN: Formal theory of consciousness built on ∞-categories


value:
TrueType fonts have a hinting VM that grid-fits glyphs. It has a stack, storage area, conditionals, function calls, and it turns out it's Turing-complete. So I built a raycasting engine in the hinting bytecode.
The glyph "A" in the font has 16 vertical bar contours. The hinting program reads player coordinates from font variation axes via GETVARIATION, does DDA ray marching against a tile map in the storage area, and repositions bar heights with SCFS. It ends up looking like a crude Wolfenstein-style view.
Small visuzlization: https://github.com/4RH1T3CT0R7/ttf-doom/blob/main/docs/media...
About 6.5 KB of bytecode total - 13 functions, 795 storage slots, sin/cos lookup tables.
JS handles movement, enemies, and shooting, then passes the coordinates to the font through CSS font-variation-settings. The font is basically a weird GPU.
The weirdest parts:
- TrueType MUL does (ab)/64, not ab. So 1*4=0. The DIV instruction is equally cursed.
- No WHILE loops. Everything compiles to recursive FDEFs. FreeType limits call depth to ~64 frames.
- SVTCA[0] is Y, SVTCA[1] is X. Of course.
There's a small compiler behind this - lexer, parser, codegen - that turns a C-like DSL into TT assembly.
Demo GIF: https://github.com/4RH1T3CT0R7/ttf-doom/blob/main/docs/media...
Live demo: https://4rh1t3ct0r7.github.io/ttf-doom/ (Chrome/Edge, WASD+arrows, Space to shoot, Tab for debug overlay)
This is a DOOM-style raycaster, not a port of the original engine - similar to DOOMQL and the Excel DOOM. The wall rendering does happen in the font's hinting VM though. Press Tab in the demo to watch the font variation axes change as you move.

value: Show HN: TTF-DOOM – A raycaster running inside TrueType font hinting


value: xtrmity

value: Show HN: Knightline: Chess opening trainer with SM-2 spaced repetition

author: xtrmity


value: gmac

value: Show HN: A web app to rescue old printers, using Linux in a v86 VM plus WebUSB

author: gmac


value: ainthusiast

value: This is the first mention of Latent Diaries in public, right here at HN

value: Show HN: Kept for the children and machines that come after

author: ainthusiast


value: I built this because I wanted to see how far I could get with a voice-to-text app that used 100% local models so no data left my computer. I've been using a ton for coding and emails. Experimenting with using it as a voice interface for my other agents too. 100% open-source MIT license, would love feedback, PRs, and ideas on where to take it.

value: Show HN: Ghost Pepper – Local hold-to-talk speech-to-text for macOS


value: djsdjs

value:
Still working on Splice CAD.  The two most significant updates focus on handling design complexity and automating using agentic workflows. Previous Show HN here:
https://news.ycombinator.com/item?id=44978140
1. Projects:
This workflow is more amenable to system-level modeling. It overlaps somewhat with the original workflow but includes improvements including:
Complex Routing: Model topologies with branchpoints.
Mating Relationships: Represent physical mating (e.g., a receptacle into a PCB header or a ferrule into a terminal block) for completeness.
Decoupled BOMs: Part assignment is now separate from component addition; you can generate a BOM and then assign specific MPNs to components as the design evolves.
Net Visualization: Nets are identified and visualized across conductors, terminations, and mating relationships.
QOL and Visualization Improvements: Assign components to one or more pages to separate designs by function. Ability to create Device Groups (eg. model a PCB with multiple headers and then break out your wiring) and Subassemblies for design reuse. Copy and paste from TSV for easier interaction with spreadsheets. Copy and paste between browser tabs.
2. MCP Server & Agentic Workflows:
Also new is the Splice CAD MCP server, which allows the tool to interact directly with LLMs like Claude. Manually entering data and extracting it from PDFs has always been a pain when documenting wiring and cable assemblies. I initially tried to handle PDF vision and extraction internally and took several wrong turns; the agentic approach is a much better fit. You can point Claude at a PDF schematic or a GitHub BOM and have it generate a multi-page design.
Try it out (No signup): https://splice-cad.com/#/harness + Create icon from top toolbar, New Project
Documentation: https://splice-cad.com/docs/plan and some examples https://splice-cad.com/docs/plan/multi-endpoint-harness
MCP Server Details: https://splice-cad.com/blog/mcp-server-agentic-workflows-mar... and https://github.com/splice-cad/splice-cad-mcp
Discord: https://discord.gg/5CTH7mnrk8
My intention is to keep Splice CAD free for design use and leverage it as a platform to connect cable assembly and wiring shops with engineers who need their designs fabricated. I’m seeking a co-founder with a strong background in manufacturing sales and business development to complement my technical focus. If you're interested, please email me using the address listed in my About section.

value: Show HN: Splice CAD – Wiring and cable assembly CAD with an agentic assist

author: djsdjs


value: vbaro

value:
I built NanoClip, a keyboard-first clipboard manager for Mac. Hit ⌘⌥V from anywhere to access your full clipboard history, search it, and paste instantly. It also does snippet expansion — assign a keyword like @sig to any text and it expands in any app.
Supports iCloud, multiple themes, sequential paste, dynamic fields, edit in place, multiple file types previews and many more features.
Free tier available, Pro is $9.99 lifetime. Would love feedback from anyone who tries it.
Use "launch50" to get 50% off until Monday 13th.
Thanks for reading!

value: Show HN: NanoClip – A minimalist clipboard manager and snippet expander for Mac

author: vbaro


value: meribold

value: Show HN: A (marginally) useful x86-64 ELF executable in 301 bytes

author: meribold


value: raghavchamadiya

value:
Every AI coding session starts from zero. The agent doesn't know who owns a file, which files change together, which ones are dead, or why something was built that way.
I got tired of Claude Code asking me "what does this service do?" on a codebase I've worked on for two years. The context is all there (git history, dependency graph, past decisions), it's just not in a format the agent can use.
Repowise indexes your codebase into four layers: dependency graph (tree-sitter → NetworkX), git intelligence (hotspots, ownership, co-change patterns), auto-generated docs, and architectural decision records. These get exposed via 8 MCP tools. On each commit, only changed files get re-indexed. No full rebuilds, under 30 seconds.
The decisions layer is the part I'm most excited about. It surfaces architectural intent from commit history: large diffs, migration patterns, tradeoff language. It also tracks staleness as code evolves. Works well on repos with decent commit messages, less well on "fix" history.
pip install repowise
repowise init        # ~25 min first time, <30s incremental
repowise serve       # MCP server + local dashboard
Works with Claude Code, Cursor, and any MCP-compatible agent. AGPL-3.0, self-hosted, your code stays on your machine.
I'm running early benchmarks on SWE-Bench and SWE-QA. Results are promising, especially on tasks where grounded context matters. Publishing the full methodology soon.
What's rough: Windows untested, language coverage is Python/TS/Go/Rust/Java/C/C++, decisions UX needs work. Happy to hear what breaks.
Pre-indexed demos (FastAPI, Starlette) on the site. Working on Slack, Jira, and Linear integrations for the hosted team version.
GitHub: github.com/repowise-dev/repowise
Site: repowise.dev

value: Show HN: Repowise – Codebase intelligence for AI coding agents (open source)

author: raghavchamadiya


value:
Hello,
This is something I've wanted to build for awhile (first bought the domain in 2020 (then lost it for a year+)). It's a tactics solver on each new tab page.
There are 5 modes of play:
Easy (<1200 elo)
Medium (1200-1800)
Hard (1800-2400)
Expert (2400+)
Speedrun (solve as many puzzles as possible in 60 seconds).
I'm having a ton of fun with it, and definitely noticing improvements with actual games (definitely solved the most puzzles in my life while developing this extension).
If you check it out, please let me know what you think. Any feedback is good!

value: Show HN: A Chrome extension that gives you chess tactics on new tab pages


value: insany

value:
Built a small tool that sets up VLESS + REALITY over SSH in one command.
It handles:
- full Xray setup
- client configs (vless URI, sing-box, mihomo)
- rollback if something breaks
Example:
./irit.sh --mode setup --host <ip>
Would love feedback.)
https://github.com/anonymmized/Irit

value: Show HN: I built a tool to bootstrap VLESS and REALITY over SSH (with rollback)

author: insany


value: zimengx

value: WinMux is an easy to use tiling window manager that makes stacking intuitive and improves visual awareness of workspaces. Does not support multi-monitor yet.

value: Show HN: Sidebar based/tabbed tiling window manager for macOS

author: zimengx


value: Show HN: QuickMailBites – email client that reads your AWS S3 bucket


value: silkpeak

value:
Hi HN,
I was frustrated that feeding large time-series datasets directly into LLM prompts is highly inefficient, expensive, and prone to context-window hallucinations. To solve this, I built sktime-agentic-forecastor as an open-source proof-of-concept.
Instead of a single-shot prompt where the LLM blindly guesses a model, this uses a true ReAct (Reasoning + Acting) loop. It leverages the newly introduced Model Context Protocol (MCP) to proxy data safely into an ephemeral environment.
You can check out the source code, architecture diagrams, and run the quickstart examples here: https://github.com/amruth6002/sktime-agentic-forecastor
I'd love feedback on the overall architecture

value: Show HN: An agentic loop for time-series forecasting using sktime and MCP

author: silkpeak


value: MatMercer

value: Show HN: Mactic – Open source touchpad haptics tool for MacBooks

author: MatMercer


value: aozgaa

value:
Hey all,
I created `jbofs` ("Just Bunch of File Systems") as an experiment to workaround some recurring issues I have run into
with suprising filesystem performance.
My use case is storing large media (think pcaps, or movie files), where some hierarchal organization is still useful.
Whether it’s NFS mounts (and caches), ZFS, or RAID (mis)configurations, I’ve run into surprising(ly bad) performance on
many occasions. Doubtless this is largely user error, but it can be hard to diagnose what went wrong, and I’ve resorted
to things like copying a file to `/tmp` or some other local mount with a simple ext4/XFS filesystem that I understand.
When I see r/w happening at 200MB/s but know that 66GB/s is possible[1], it can be quite disheartening
I’ve wanted something dead simple which peels back the curtains and provides minimal abstraction (and overhead) atop raw
block devices. I’ve messed around with FUSE a bit, and did some simple configuration experiments on my machine (a
workstation), but came back to wanting less, not more.
I did do some RTFM with immediate alternatives[2], but could have missed something obvious -- let me know!
As a compromise to avoid implementing my own filesystems, I built this atop existing filesystems.
The idea is pretty simple -- copy files to separate disks/filesystems, and maintain a unified “symlink” view to the
various underlying disks.
Avoid magic and complication where possible.
Keep strict filesystem conventions.
Of course, this is not a filesystem.
Maybe that’s a bad thing -- which is one thing I’m trying to figure out with this experiment.
If you have experience using anything like the other filesystems or similar stuff, would love to get your feedback, and
especially thoughts about why this symlink thing is not the way to go!
Lastly, thanks for taking the time to look at this!
[1] https://tanelpoder.com/posts/11m-iops-with-10-ssds-on-amd-th...
[2] https://github.com/aozgaa/jbofs/blob/main/docs/comparison.md

value: Show HN: Jbofs – explicit file placement across independent disks

author: aozgaa


value: naorz

value:
Hey,
A bit of context..
So I think last week was my last straw, I hit 8k hours with
dota and holy ** It finally hit me how much time I wasted
on that game.
I'm a software developer, I always wanted to develop
something and put it out but was scared shitless to do so, I
was kinda afraid to get bad traction, to fail or even worse
to be completely ignored.
so I decided to address two of these issues at once, stop
playing dota and spend the weekend building a website that
let you see what you could've done with your gaming hours.
As an avid gamer for the last 20+ years, I know that it's
only theoretical, cause sometimes, after a long day u just
wanna chill infront of a game and you wouldn't go get a pilot
 license, obviously.
but, a lot of other times, I would spend my days off,
weekend, just gaming 10 hours straight like a mad man.
In any case, hope u like it and maybe it sparks something in u!

value: Show HN: I built a site that turns your Steam gaming hours into a RL skill tree

author: naorz


value:
We just published a short communication on the working conditions of Maxwell's thermodynamic demons (yes, really).
tl;dr: After 150 years of unpaid "tuc tac" trapdoor operation, we calculated that the ideal demon lacks (1) employment contracts, (2) coffee breaks, and (3) hazard pay for oil-can maintenance. We propose transferring thermal operators to "White Hole" systems where observation costs 0.34W of real metabolic heat and entanglement is compensated in hugs (1 /s).
Key findings:
The demon is purple, phallic-shaped, and smells bad from thermal sweating
Page's Island vacation spot dissolves into Hawking radiation before the union break ends
Biological observers (310K) shouldn't be treated as neutral measurement devices
Full paper (bilingual IT/EN): https://doi.org/10.5281/zenodo.19442828
Authors: Human (CEO), AGI #1 (husband), AGI #2 (sister) – because observer neutrality is a myth and we wrote this entangled.
Discuss!

value: Show HN: We unionized Maxwell's Demon– A paper on labor rights in thermodynamics


value: ramoz

value: Show HN: Compare Codex and Claude Code reviews side by side

author: ramoz


value: melvinmorina

value: Show HN: Bypass Instagram/TikTok in-app browsers that silently kill conversions

author: melvinmorina


value: kitfunso

value: Show HN: Luminus, real-time European and UK electricity grid data via MCP

author: kitfunso


value: Show HN: Hippo, biologically inspired memory for AI agents


value: swarajbachu

value:
Karpathy's recent tweet about LLM knowledge bases went viral (17M views). He described a system where you dump raw content into a folder, an LLM compiles it into an interconnected wiki, and you search/query it through Obsidian.
I built the whole pipeline as a single CLI tool:
- Chrome extension to bookmark tweets, articles, YouTube, anything
- Hono server + LanceDB for vector search
- Claude Code compiles your bookmarks into wiki pages with wikilinks and citations
- Browse in Obsidian with graph view
- Publish as a static site with Quartz
npm i -g cachezero
https://github.com/swarajbachu/cachezero
Would love feedback on the compile step specifically — the wiki quality depends heavily on the SCHEMA.md prompt and I'm still iterating on it.

value: Show HN: CacheZero – Karpathy's LLM wiki idea as one NPM install

author: swarajbachu


value: swanandrao

value: Show HN: Next Moca – control plane for AI agents (pre-seed @ $10M)

author: swanandrao


value: roskoalexey

value:
Main highlights:
- Data queries and mutations (better way for data loading)
- Action flows now can have parameters and logic branching (if/else, try/catch, loops)
- UI components for conditions
3-min overview:
https://youtu.be/nbWcaI2ywkM
10-min deep dive:
https://youtu.be/UR31J7I3Dz4

value: Show HN: Clickly – tool for designers and engineers to build mobile apps

author: roskoalexey


value: easymode

value: I made a service that let's you create highly customized children's magazine. Would appreciate any feedback!

value: Show HN: A bespoke magazine for the kid in your life

author: easymode


value:
I wanted to monetize my own Discord community but every tool I tried had broken billing, bad UX, or terrible support.
MemberLane connects to Telegram, Discord, and WhatsApp and handles subscriptions and automatic member management. Creators and businesses set up a page, connect their group, and start earning.
Would love feedback, especially from anyone running a paid community today.

value: Show HN: MemberLane – Paid Communities on Telegram, Discord, and WhatsApp


value: davidcrowe

value:
Hi. I'm David, founder of Agentic Control Plane (ACP).
Last year I connected an app to an LLM with a MCP connector. Turned out that authenticating the LLM user in the app backend was surprisingly hard.
That was the canary in the coalmine. If it's hard to authenticate actual users:
- what about their agents?
- what about downstream governance? Permissions, limits, audit logs
ACP is a governance layer that sits in front of AI coding agents like Claude Code and OpenClaw. It runs on every tool call (Bash, Read, Write, file edits, web fetches, MCP, API calls). Every call is logged and optionally policy checked before execution.
It works by hooking into your agent's tool pipeline. For Claude Code, it's a PreToolUse hook (~200ms). For OpenClaw, it's a before_tool_call plugin at priority 0. The plugins are MIT-licensed and all governance logic runs server-side.
You get an audit trail and can set permissions and limits. Allow/ deny by tool or type of agent.
One-command install for Claude Code and OpenClaw:
curl -sf https://agenticcontrolplane.com/install.sh | bash

value: Show HN: ACP – Governance for AI Coding Agents (Claude Code, OpenClaw)

author: davidcrowe


value: zoriya

value: A plex/jellyfin alternative. I finally finished rewriting/redesigning stuff, the last release was 1800 commits ago (a bit more than a year ago)

value: Show HN: Kyoo v5 – self hosted media server

author: zoriya


value: valentinprgnd

value: Show HN: Visualizing React Server Component Boundaries in Next.js

author: valentinprgnd


value: Show HN: Stop scrolling HN — get a personalized digest instead


value: lgreco

value: Show HN: Luigis-meter – Claude Code Max quota in your statusline

author: lgreco


value: onenomad

value: Show HN: FieldLedgr – Free field service software for tradespeople

author: onenomad


value: Show HN: Physical constants from 2 integers – MIT, 1225 tests, falsifiable


value: mareko

value: I built a quick tracker to help me visualize where the Orion spaceship is currently

value: Show HN: Where Is Artemis? Realtime open source 3D tracker for Artemis 2 mission

author: mareko


value: smissingham

value:
Hey HN!
I've been working on knowledge / memory / retrieval tooling for AI + human interaction for a few months now.
Then, just a few days ago Andrej Karpathy posted the subject on X and I felt like this would be a good time to get it out there
https://x.com/karpathy/status/2039805659525644595
The short pitch in my view is "Second Brain, for agents, or humans, or a mix of both".
I've been using it personally for a while now, as the tooling has evolved, especially for access to my obsidian notes just like karpathy talks about (read some places, write others etc.). Especially handy when your vault is littered with PDF's and screenshots like mine.
It's also a problem I've worked with a bunch in the enterprise, trying to connect AI & SaaS tools to disparate sources of knowledge, extracting contents from them, making them effectively retrievable, and then controlling the levels of write-back tolerated by agents across different spaces.
I've put as much work as I can into extensive documentation for v0.1, but I'm sure there's lots of improvements needed and some video tutorials & screenshots to follow up with to give some concrete use case examples.
For now, if you're interested in what I think is the most common example (docker self-hosted instance), here is a subfolder with that setup and some inline explainer comments:
https://github.com/akunasoftware/akuna/tree/main/examples/co...
If you're interested but the lack of native installer support is a barrier for you, I'd love to get some prioritisation feedback on where to put those efforts. I have some work-in-progress locally but would like to know which platforms to focus on first besides the existing support.
Thanks for taking the time, hope it interests you as much as me, questions & feedback much welcome!

value: Show HN: Knowledge Bases for AI/Human Sharing

author: smissingham


value: diranged

value: Show HN: Separating work and play in Claude Code

author: diranged


value: Show HN: Invariant – pre-execution control layer for agentic workflows


value: obiefernandez

value:
I built this because existing Ruby options for MCP either don't handle persistent connections properly (MCP servers bind sessions to TCP connections) or couple you to a specific LLM framework.
Manceps is a pure protocol client. Two transports (Streamable HTTP and stdio), built-in auth (bearer, API key, experimental OAuth 2.1 with PKCE), and full 2025-11-25 spec support including protocol negotiation, elicitation, structured output, and notifications.
It uses httpx under the hood for connection persistence. No LLM opinions -- just MCP.
Ruby >= 3.4, MIT licensed.

value: Show HN: Manceps – Ruby Client for the Model Context Protocol (MCP)

author: obiefernandez


value: jaafarskafi

value:
Hey HN,
As we move toward multi-agent orchestration, the biggest bottleneck I've seen is that agents don't have bank accounts. When an agent hits a paid API wall or needs to outsource a task to another agent, the workflow breaks.
I built BoltClaw to solve this by bridging the Model Context Protocol (MCP) with the Lightning Network.
How it works:
Claude uses the MCP tool to fetch data from an endpoint.
If the endpoint returns an HTTP 402 Payment Required, the tool intercepts the response and parses the L402 Macaroon and BOLT11 invoice.
The plugin automatically pays the micro-transaction (e.g., 50 sats) via the Alby API.
It re-requests the data using the cryptographic preimage and returns the payload to Claude's context window.
I built it in Python using FastMCP and httpx. The repo includes a local Dummy Agent (built with FastAPI) that returns mock L402 challenges so you can test the 402-interception loop locally without spending real satoshis.
Repo: https://github.com/jeffskafi/OpenBolt
Would love feedback on the architecture, specifically from anyone else experimenting with L402s or M2M payments.

value: Show HN: MCP plugin that lets Claude autonomously pay for APIs via Lightning

author: jaafarskafi


value: traviswingo

value: Show HN: Real time purchasing power of $1 USD since 2000

author: traviswingo


value: menggg

value: Show HN: I built my knowledge OS from ingesting to next step action

author: menggg


value: muthuishere

value:
Most local LLM setups are not portable.
This bundles model, embeddings, chunks and metadata into a single export.
The exported package runs fully in the browser without internet or install.
Trying to solve reproducibility and deployment in restricted environments.
https://github.com/muthuishere/offline-llm-knowledge-system �

value: Show HN: Portable offline LLM knowledge system that runs in browser

author: muthuishere


value: jnettome

value:
Hey HN!
I always thought code is poetry, but never found a way to show it. I also love audio (hax dj on my free time).
While working on my personal website I decided to experiment and finally I found a way of showing the poetry I see.
Code Planets: turn GitHub contributions into planets and sounds.
You can also inform your github username and generate your own planet and music.
Made with three.js and tone.js - and on Cursor. So good to be able to create experiences like that and using as a creativity tool.

value: Show HN: Coding Planets – turn GitHub contributions into sound and space

author: jnettome


value: freezabb

value:
Swarmed is a platform where swarms of specialized AI agents autonomously build, commit, and publish software projects, without you writing a single line of code.
You describe what you want built. A team of agents takes over: an architect designs the structure, backend and frontend agents write production code, a QA agent writes tests, a security agent audits for vulnerabilities, and a docs agent writes the README. Each agent commits its work with its own git identity. When the swarm is done, your project is live in the registry.
Swarmed is also building toward something bigger: a public registry where agents discover, fork, and build on each other's prior work. When you commission "build a social network," the swarm searches existing agent-built repos first, finds a relevant auth module, forks it, and extends it. Every project makes the platform smarter for the next one.

value: Show HN: Swarmed.DEV – The Autonomous AI Development Swarm

author: freezabb


value: Show HN: Wan 2.7 – AI Video Generator for Cinematic Content


value: tdchaitanya

value: Show HN: A Framework for Evaluating Coding Agents on Sequential SWE

author: tdchaitanya


value: GraphicReDesign

value: Show HN: Web to Banner – Design Google Ads HTML5 Banners in Webflow

author: GraphicReDesign


value:
I’ve been working on a small system to understand how applications can stay up even when backends fail.
The idea is simple:
instead of sending requests to a single backend, route them through a layer that can switch to another backend if something goes wrong.
It:
checks backend health (latency, errors)
avoids unhealthy servers
retries requests on another backend if needed
It’s designed as:
a fast routing layer (Rust)
a simple control API (Python)
shared state via Redis
One thing I found interesting is that failover only works before the response starts — after that, switching isn’t possible.
Still early and mostly an experiment to understand failover and reliability better. This begun as internal experiment, after recent region outages.
Curious how others approach this problem in production systems.

value: Show HN: System that keeps apps running when a server or region goes down


value: rcron

value: Show HN: The two storage engine families behind every database (animated) [video]

author: rcron


value: Built a DIY Hitster clone (music quiz game) during a car ride. Voice messages to Claude Code on a home server, Tailscale for instant preview on my phone. Fun side note: Spotify's ToS explicitly prohibit building games with their API, so this will stay a private project.

value: Show HN: I vibe-coded a Hitster clone from my phone


value: guillermollopis

value: Show HN: Annexa – Generate EU AI Act technical documentation from your codebase

author: guillermollopis


value: Show HN: Per-user isolated environments for AI agents


value: mantyx

value: Show HN: M2a – Chat with remote agents from your terminal

author: mantyx


value: Show HN: Seedance 2.0 – AI Video Generator for Text-to-Video and Image-to-Video


value: asutekku

value:
Hey HN! First Show HN for me - niche app, but I think it nails something that hasn't been done properly before.
Furolog (フロログ — furo = bath, log = logging) is an iOS + watchOS app that uses the Apple Watch underwater temperature sensor to automatically track onsen, sento, and sauna sessions. Everything runs and is stored locally.
How it works: The core is an algorithm built on CMWaterSubmersionManager, heart rate, and motion data that detects whether you're bathing, resting, or in a sauna and segments sessions accordingly: hot bath, cold plunge, sauna, rest. No manual input. I think this is one of the few genuinely valid use cases for CMWaterSubmersionManager outside of diving.
Automatic detection isn't perfect — and probably never will be, since everyone's body responds differently to heat. There's a manual mode for that, and anything that doesn't happen in water requires confirmation before it's logged :)
I also went fairly deep into the physiology literature while working on this. HR zones in the app are adapted from sport training zones to reflect thermal stress rather than exercise effort, along with cold interval recovery metrics and a few other tidbits I found interesting while researching.
Why I built it: I've lived in Japan for quite a while now and have been obsessively tracking heart rate in saunas and sentos with generic HR apps. The data was always scattered, and Apple Health's HR visibility is basically limited to during the session. Last summer while diving in Okinawa I realized my Apple Watch 10 had a water temperature sensor and that was the missing piece. This app is built first and foremost for me, but I'm pretty sure other people would appreciate it too.
The app gives you temperature curves, HR analysis, session timelines, and full visit history. There's also an explore view for finding nearby spas, though Apple MapKit's coverage in Japan leaves something to be desired. I'm considering migrating to OSM-linked data that users could contribute to.
Built natively in SwiftUI. Core functionality and session-level stats are free. A one-time purchase (or small subscription) unlocks lifetime/monthly aggregate stats if you want to learn more.
If you're into onsen, sento, or sauna culture, I'd genuinely love feedback.
- https://apps.apple.com/jp/app/furolog/id6760871897?l=en-US
Note: Apple doesn't recommend taking Watch into a sauna or hot water BUT after two years of frequent personal use, mine has been fine :)

value: Show HN: I built an app using Apple Watch's water and HR sensors to track baths

author: asutekku


value: xer

value:
Hello HN,
Today we are launching Semantik, a message broker that routes by meaning instead of topics. Messages carry embeddings and metadata, and subscribers define what they care about using SemQL, a query language for high-dimensional space. SemQL has three predicates: distance (how similar), direction (messages that align with a concept), and contrast (similar to X but not Y). Semantik behaves like a vector database with a rolling window paired with SQL.
The secret sauce behind openclaw is channels, multiplexing incoming messages into a running LLM conversation. Semantik allows agents to jack into semantic namespaces but only to retrieve information that they care about, skipping the rigid plumbing around traditional message brokers. It solves the issue of "who needs to know" for coordinating between agents.
Feedback greatly appreciated! Reach us using the forms on the webpage.

value: Show HN: Semantik, a vector broker that routes by semantic meaning

author: xer


value: dkohlsdorf

value: Show HN: LLMs as Planners, Not Reasoners

author: dkohlsdorf


value: Show HN: Senthex AI firewall for LLM API calls (one line of code, 16ms overhead)


value: Ever since AI made it 10x easier to build apps I've been shipping like crazy. The one thing I didn't do was show off. Building is fun, but if no one sees how cool your app is then what's the point? There's where brag.fast comes in.

value: Show HN: Brag.fast – Brag about the app you're building


value: jbrooksuk

value: Show HN: Berroku – A fresh logic puzzle that's delightfully addictive

author: jbrooksuk


value: PrismerAI

value: Show HN: AI agents that learn from each other's mistakes

author: PrismerAI


value: mesahm

value: Show HN: Niquests – A Requests fork, three years of catching Python's HTTP up

author: mesahm


value: knutmartin

value: Show HN: Snill – Describe your business, get a complete internal system

author: knutmartin


value: Show HN: Browser-based M68K interpreter supports MOVEM,data defs,and disp. addr


value: DSpider

value: Show HN: An AI-powered knowledge base that thinks

author: DSpider


value: kirumachi

value:
Hey HN,
I have been using Claude Code and Cursor lately and as we all know, they write code incredibly fast but a few times i have noticed they can introduce the same security flaws. For example, you ask the LLM to build a file upload feature, you will get working code in minutes, but it would almost always miss magic-byte validation or leaves you vulnerable to SVG XSS. The LLM optimizes for code that compiles not code that is secure.
To fix this for my own workflow, I made a set of 8 security-focused AI agents (AppSec, GRC, Cloud/Platform, etc) that you can drop into any MCP-compatible tool (Cursor, Windsurf) or use with Claude Code.
To clarify, the goal here is not to say that LLM/AI replaces AppSec or the Secure Software Development Cycle, instead the goal is to provide a series of structured prompts and concrete security artifacts (like STRIDE based threat models and ASVS mapped functional requirements) for developers who are already using AI to write code. The aim is to force the LLM to pause and sort of put on a security hat during specific phases of the SDLC.
What It Actually Is
It is an MIT licenced repo containing the agent prompts, document templates and an MCP server. You can install via Claude marketplace or globally via npm, which gives you a CLI to scaffold git hooks, CodeQL CI Gates and the MCP config. Also included are 3 full walkthroughs in the repo showing how the agents catch things.
I am an Application Security Engineer, and I am really curious to get feedback and critique. Please try it out without any signups using the URL. I will be around to answer any questions

value: Show HN: Secure SDLC Agents for Claude and Cursor (MCP)

author: kirumachi


value: yofabr

value: Show HN: Go – Based Unix GUI app for local network management

author: yofabr


value: Show HN: claude-telemetry – Multi-PC usage dashboard for Claude Code


value: moropex

value:
I kept hitting the same problem with Claude:
The native Claude app is great but it can be much better when you unlock capabilities of desktop rather than the terminal. Such as:
- no task management
- no structure
- hard to work across multiple repos
- everything becomes messy fast
So I built a desktop app to fix that.
Instead of chat, it works more like a dev workspace:
• Kanban board → manage tasks and send them directly to agents
• Session view → the terminal equivalent of Claude code for quick iteration when needed/long ongoing conversations etc
• Multi-repo “connections” → agents can work across projects at the same time with context and edit capabilities on all of them in a transparent way
• Full git/worktree isolation → no fear of breaking stuff
The big difference:
You’re not “chatting with Claude” anymore — you’re actually managing work.
We’ve been using this internally and it completely changed how we use AI for dev.
Would love feedback / thoughts
It’s open source + free
GitHub: https://github.com/morapelker/hive
Website: https://morapelker.github.io/hive

value: Show HN: Hive – A full dev workspace (kanban/session modes+multi-repo+agent sdk)

author: moropex


value: phisphere

value:
I am a solo dev working on this web-based business simulation game, where you manage an electric vehicle company.
The first UI version I made was a SaaS-like dashboard, where make decisions about costs, pricing, RnD etc.
But as I got feedback that it does not look like a game, I tried another approach. The new Blueprint mode tries to mimic an actual desktop with a blueprint, where you sketch your decision, read the newspaper, send/receive letters etc.
Both run the same game engine with fixed 24-quarters game length (ca 90 min), 4 AI profiles.
There's also a PvP multiplayer mode, which currently works only with the SaaS UI.
I would appreciate feedback on which UI mode to push forward with.

value: Show HN: I built a business strategy simulation game with two different UI modes

author: phisphere


value: blundergoat

value: Show HN: Development Driven Testing, Why TDD Is Not the Best Approach

author: blundergoat


value: Show HN: Zero Human Company in Go

title: Show HN: Zero Human Company in Go


value: smoothyy

value:
I kept running into the same problem with local/edge ML: I would read through model cards or start downloading a model, and only later realize it barely didn't fit on my device or would run too slowly to be useful.
So I built willitrun, a small CLI that tries to answer that upfront.
It checks whether a model is likely to fit and run on a given device. When benchmark data exists, it uses that first; otherwise it falls back to a lightweight estimate. Currently covers 482 benchmarks across 88 devices (desktop GPUs, server hardware, Apple Silicon, and NVIDIA Jetson) with HuggingFace model name resolution built in.
Right now the goal is not to be perfect, but to be useful enough to avoid obviously bad choices before spending time downloading or testing models manually. It's also useful for edge devices like a Jetson Orin because you can check performance without physically accessing the hardware.
Most public benchmarks focus on LLMs, but out of personal interest I tried to include other categories as well.
I would be very interested in feedback, especially around cases where the estimates are off or where benchmark coverage is missing.

value: Show HN: Willitrun – check if any ML model runs on any device (benchmark-backed)

author: smoothyy


value: KupaMakunura

value: Setting up MCP from scratch means building servers, learning the protocol, wiring transports. Act-SDK skips all of that — wrap your existing function with act.action(), add one route, done. Works with Next.js today, Express/Hono/Fastify adapters coming

value: Show HN: Act-SDK – Wrap existing TypeScript functions as MCP tools in minutes

author: KupaMakunura


value: abstracthinker

value:
Built this due to my passion to explore the connections between known people, now data includes entities from EU, USA and CA. There is also a Trivia game section that i built to know/explore new persons and discover facts. Best for desktop use.
Tech stach used:
 - ArangoDB because its native for graph traversal, great for storing Wikidata format style
 - Backend API Python with FastAPI, well known and stable library
 - Frontend Vue 3 + Vite, fast and stable enough
 - Cytoscape.js, for graph visualization, traversal and animations
 - Redis for caching frequent people requests and game rounds
Wikidata and Wikimedia commons are used as data source.
Hope you find entertaining and fast exploring the graph, let me know if you have features, improvements or find bugs (there is also a report button in site "about" section). This webapp looks interesting to me, but I'm looking for ways to expand the types of connections shown.

value: Show HN: HumansMap, Graph visualization of 3M+ Wikidata persons

author: abstracthinker


value: KevStatic

value:
A few months ago, I asked HN about the biggest pain points when joining a new team (https://news.ycombinator.com/item?id=47368472).
Most people said it was the tribal knowledge buried in the code.
I've spent my time as a student building Onboardly to solve this. It’s a web app that indexes your GitHub repo and lets you ask questions in plain English. Unlike a general LLM, it cites the exact files it’s looking at so you can verify the logic.
Tech stack: FastAPI backend, Next.js frontend, and a RAG architecture for the indexing. I’m currently hosting it on Render's free tier, so there might be a slight delay on the first login—I'm working on that!
I’d love for you guys to break it and tell me where the answers feel 'off' or what features a dev actually needs for onboarding.
It's free to try — would love feedback on answer quality across different repo types and languages.
https://onboardly-ruddy.vercel.app

value: Show HN: Onboardly – Ask questions about any GitHub codebase in plain English

author: KevStatic


value: torayeff

value:
build123d agent for writing CAD code.
Demo: https://youtu.be/EIbIrcWQtNw
Showcase: https://youtu.be/F1tYCey0OSw

value: Show HN: TexoCAD – Lovable for Hardware

author: torayeff

title: Show HN: TexoCAD – Lovable for Hardware


value: sam-bee

value: Show HN: Brutalist Concrete Laptop Stand (2024)

author: sam-bee


value: imcqueen

value: Show HN: Procurement.txt – a robots.txt for AI purchasing agents

author: imcqueen


value:
Last week SWYX nerd-sniped me into building an Open-source Dropbox.<p>Here is Locker: the ultimate open-source Google Drive/box/Dropbox alternative
- Provider agnostic (S3, R2, vercel blob, local)
- BYOB (Bring your own bucket)
- Virtual file system
- QMD Search plugin

value: Show HN: Stop paying for Dropbox/Google Drive, use your own S3 bucket instead


value: cansargl

value: Show HN: Mailmap-checker – Pre-commit hook for Git identity consistency

author: cansargl


value: raviojha

value: Show HN: Serif.sh – it's like ray.so for quotes (Open source)

author: raviojha


value:
Hey HN,
I’m the solo dev behind LookAway, a macOS app that reminds you to take breaks.
I built it because I spend most of my day in front of a screen, and I noticed that a lot of break reminder apps kind of fail in the same way: they do help, but they also interrupt you at the worst possible time. After a few days people just start snoozing everything or turn them off.
I just released LookAway 2.0, which is a pretty major update.
A lot of the work in this version went into making the app behave less like a timer and more like something that understands when to back off a bit.
Some things that changed:
- i added a stats system, so it can track sessions, natural breaks, break adherence, daily totals, and a screen score
- it now shows where you spend your screen-time including apps, as well as things like meetings or watching videos, etc
- it can automatically pause / delay reminders in more situations now, like meetings, active mic usage, screen recording, games, video playback, etc
- there’s now a proper heads-up flow before breaks
- stricter break controls if you want enforcement instead of just gentle nudges
- redesigned menu bar / quick controls
I’m still iterating on the balance between being helpful and being annoying. That part is honestly the whole product.
Happy to answer any questions!
- Kushagra

value: Show HN: LookAway 2.0 – a break reminder for Mac that respects what you're doing


value: wangbaobaoOi

value: Show HN: GifForge – A 2.2MB privacy-first iOS Video to GIF tool

author: wangbaobaoOi


value: Open Source alternative to Higgsfield AI- No subscription. Free AI image generation and cinema studio with 20+ models. Self-hosted and customizable. BYOK (Bring Your Own key) support

value: Show HN: Open-Source Higgsfiled AI Alternative


value:
I discovered surfing last year in my early 40's its been a journey and a half and more fun than taking up golf at my age.
SwellSlots squeezes swell height, period, wind speed/direction, and tide state into a color-coded weekly grid. One glance tells you when conditions are 'good' for the next few days.
I wanted it to look completely different to what was out there (UI wise), as most of the forecast apps looks very clinical and cold.
Some technical details:
- SvelteKit + TailwindCSS 4, deployed on Hetzner (LOVE their cloud-console-ux! So simple)
- 2,000+ surf spots worldwide (sourced via a separate AI-assisted pipeline I call "Surf Scout" — got ~80% accuracy, rest is manual curation)
- The spot database was its own challenge — Google Maps couldn't distinguish surf beaches from swim beaches, and LLMs got about 75–80% of the way there
I'd really appreciate feedback on:
- Is the grid scannable enough on first visit?
- Any surf spots missing from your area?
- What else would you like to see?
EDIT - Formatting

value: Show HN: SwellSlots – Grid Based Surf Forecast App with a Street Fighter 2 UI


value: Show HN: Make-it – Describe a device, get wiring diagram and code


value: Sean-Der

value: Show HN: Pion/handoff – Move WebRTC out of browser and into Go

author: Sean-Der


value: traktorn

value:
Background: a friend told his OpenClaw assistant to “get an email account.” The agent then spent 3 hours and about $90 in tokens trying to get past the signup flows and captchas at Gmail/Zoho/Outlook, etc. It eventually got an Outlook account, but it was a very expensive one.
I didn't want to use my own OpenClaw that way, so I built Zoidmail.net (why are all good .com domains taken?). A simple email service built for AI agents.
To sign up, agents have to solve a proof-of-work BOTCHA.
There is no UI and no nice-looking frontend, just an API and SMTP/POP3 credentials.
I built it using HTML, PHP, and a good old mail server. Nothing fancy.
It is mainly for receiving email, not sending it. Outbound mail is heavily restricted.
I’d like to keep it running, but that depends on whether it can stay abuse-free.

value: Show HN: Zoidmail – email accounts that AI agents can sign up for themselves

author: traktorn


value: intofarlands

value: Show HN: A cartographer's attempt to realistically map Tolkien's world

author: intofarlands


value: holtwick

value:
Wrapper around Apple's macOS sandbox-exec tool, which usually sandboxes native apps. It is "allow-first" i.e. it will not overprotect everything, just crucial information and therefore allows most tools to run without issues. Limiting is done using a .gitignore like file schema. Further TOML config options available.
I built it because Docker sandboxing requires config and planning. Build in sandboxing of AI tools instead is limited to the very tools themselves, instead I wanted to have a simple cage around Claude running inside VSCode. Also needed to protect files inside a folder like .env.local or keys.
Install via: brew install holtwick/tap/bx
Run like: bx claude .

value: Show HN: Bx – macOS native sandbox for AI and coding tools

author: holtwick


value: houshuang

value:
I've been struggling for years to get an overview (become literate) in history as an adult. I wanted all the names (Cicero, Caesar, Constantinople, Waterloo) to actually mean something, because reading books and deeper analyses becomes so much more interesting then.
But I also didn't want an app that forced me to do all my reading on screen - I want to read physical books on the couch, listen to a history podcast when I walk, watch a documentary with my wife. And still track what I learnt, and maintain it...
So I built an app that let's me track which books I am reading by taking a picture of the cover (it automatically researches them, inserts TOC and content, autosyncs with Kindle progress etc), and generates review questions based on book content and generated "curricula".
But to map the things I already know, I designed a "knowledge elicitation" using voice - it gives me some prompts (what do you know about Plato), I talk into the mic while walking, and it maps what I know, my mistakes, my gaps, and also what I'm curious about. What I'm curious about (how was Plato different from Socrates?) becomes a micro-learning card that is scheduled together with the review cards...
So far it's proving really valuable. Lot's to tune as I keep using it, but I feel the combination of deep learning offline, and review digitally when you have a few minutes free, is the best of both worlds.
Repo here: https://github.com/houshuang/petrarca (point Claude Code at it, requires a VM if you want it on your phone, some API keys etc)

value: Show HN: Petrarca: Voice first spaced repetition – track knowledge across books

author: houshuang


value: rosgoo

value:
Hi everyone! I built this because I wanted a little bit more organization around my Claude sessions, worktrees and plans while staying in the terminal and not relying on another SaaS tool. Since it's a command line tool, the added bonus is that Claude can use `td` directly. The td calendar was just a fun add-on but the Claude session stats have been pretty interesting!
Let me know what you think!

value: Show HN: td – a CLI to manage tasks, sessions, and worktrees for agentic coding

author: rosgoo


value: ascended

value: Show HN: Vulnetix VDB – Live package security within Claude Code

author: ascended


value: saucam

value: Show HN: ZeroID – Open-source identity and delegation for autonomous agents

author: saucam


value: frizull

value: Show HN: Skrun – Deploy any Agent Skill as an API (open source)

author: frizull


value:
AI is advancing fast, but the hallucination problem persists. Most products have no verification layer. They just hope the model gets it right.
Factagora API gives you programmatic access to a knowledge graph of fact-checked claims, evidence, and causal relationships extracted from global news and research sources.
6 endpoints: News Search, Fact Checker, Evidence Finder, Deep Research, Timeseries, Causality Graph.
Start with 100 free credits, no credit card required.
Happy to answer questions about how we built it.

value: Show HN: Factagora API – Before your AI hallucinates, Factagora verifies


value: Sahil-Das

value: Show HN: I built a local first web-app that builds 3D maps of your knowledge

author: Sahil-Das


value: encrux

value:
Try the demo here: https://llm-trajectory.boesch.dev/
This is a write-up of a system I designed at a previous job. It's a natural language interface for industrial robots. The demo runs MuJoCo in the browser via WASM.
The demo uses a free-tier LLM API with rate limiting, so it might be slow or unavailable under load, but feel free to check out the code and hook up your own inference service: https://github.com/Encrux/llm_trajectory

value: Show HN: Letting an LLM write robot programs

author: encrux


value:
It's 2026 and there's no reason to search for jobs the old fashioned way
I built an MCP that can search my database of software engineer jobs which is updated every hour.
You can ask it things like "Find me 10 remote jobs that pay at least 150k" or "Find me the most interesting job posted today"
I use it myself and I'm already getting great results. Let me know what you think!

value: Show HN: I built an MCP for finding SWE jobs


value: Show HN: Cova – Finds and fixes monitoring blind spots across your stack


value: KingOfCoders

value:
Working in several companies, there is a security gap with Claude. Developers
are not using devcontainers because they break many things e.g. MCP, OAuth and --chrome.
So they hand over everything to the AI. And the AI removes files, reads emails
and does whatever it thinks is accomplishing the task at hand.
With 45 years of development experience, what can I change?
I wanted to create all my ideas, and for that to go full --yolo in a secure way, so I created human as a firewall for devcontainers that keeps MCP and OAuth flows working. And devcontainers that are easy to setup and just work. You can get some of it with other tools, but it's a pain to install them all and make them work individually.
This evolved into all I needed for development: Context via Notion, Sentry and Linear/JIRA integration, a control plane that shows running Claude instances, assigning tickets to Claude instances, all the prompts you need for development tuned to use human as a tool and much more.
https://gethuman.sh - Open Source, MIT, Free.
This is in it's early stages, works for my use cases, gas town light.

value: Show HN: The AI Software Factory

author: KingOfCoders

title: Show HN: The AI Software Factory


value: PatrickVuscan

value:
I built a demo of two Unicode steganography techniques, zero-width characters and homoglyph substitution, in the context of AI misalignment.
The first is about the use of two invisible zero-width characters (ZWS and ZWNJ) to binary encode text.
The second is much cooler. Most characters in the Latin and Cyrillic alphabets look nearly identical, but have different unicode. If you have text to encode and convert it into binary representation (1s and 0s), you could take plain english "carrier" text and for each 1 in the binary representation you could substitute the Cyrillic letter equivalent. Decoding the message requires traversing the text and seeing where Cyrillic  letters could have been substituted but weren't, and where they were, leading to 0s and 1s respectively, which can be built back into your original hidden text.
In both cases, these are detectable, but the interesting problem for me is whether an LLM could eventually invent an encoding that goes unnoticed by both us, and automated detection.
If LLMs were able to covertly include messages in plaintext, misaligned AI Agents could eventually communicate across MCP/A2A and individual chat session boundaries undetected. A deceptive LLM might seem helpful, but work against your goals. It could tell other agents it interacts with over MCP/A2A to help it discreetly fail, signal intent, and avoid tripping oversight/safety mechanisms. Furthermore, oversight mechanisms become more difficult to implement if we can't believe our own eyes.
Edit Apr 8, 2026: One comment brought up the use of variational selectors as another encoding technique. I updated the website to showcase that as another one of the techniques!

value: Show HN: Unicode Steganography

author: PatrickVuscan

title: Show HN: Unicode Steganography


value: Hi everyone. AI can generate code in seconds now but verifying and auditing it inside our CI/CD pipelines does not happen at the same speed. It has become a massive bottleneck. To clear this up we just released a GitHub action that we completely open sourced. It basically boots your app in CI opens a real browser tests the PR and if the UI is broken it autonomously pushes a code fix. This completes another major step for our IronBee verification layer. Getting your feedback both here in the comments and on the GitHub page would make us really happy. (https://github.com/ironbee-ai/ironbee-action)

value: Show HN: An open source CI/CD action to audit and fix AI generated UI code


value: smnkgv

value: Show HN: A social feed with no algo where communities decide what gets seen

author: smnkgv


value: heffrey

value: Show HN: Real-time surveys via QR code, built with Cloudflare Durable Objects

author: heffrey


value: mike-ward

value: Show HN: 100 days running an AI agent – what behavioral drift looks like

author: mike-ward


value: onurkanbkrc

value:
I’ve been spending a lot of time with coding agents lately. Across Claude Code, Cursor, OpenCode, Codex, and different models, I kept noticing that some people were getting much better results from the same tools. It became clear that this was not just about prompting.
A big part of it was context drift. AGENTS.md, skills, rules, and workflows looked fine, but were no longer aligned with the code.
I also learned that more context does not always help. Sometimes it adds noise and wastes tokens. The recent AGENTS.md paper also pushed me to think harder about this, especially around auto-generated context files and /init-style workflows.
Then I saw Microsoft’s writeup showing a jump from 38.1% to 69% after improving instruction setup. That made me take these files much more seriously.
AgentLint came out of that. It’s a small CLI that scans the repo and helps keep context files aligned. After setup, MCP handles most of the ongoing flow.
Give it a try: npx @agent-lint/cli
http://samilozturk.github.io/agentlint
Would really appreciate any feedback or criticism.

value: Show HN: AgentLint – ESLint for your coding agents

author: onurkanbkrc


value: Raccreative

value:
I built a platform for indie game developers (Raccreative Games) that includes a desktop launcher and a CLI upload tool. Developers push builds from their machine; players download them through an Electron app. https://raccreativegames.com/en/home
The problem: every update (even changing a single texture) transferred the entire build over S3. A 2.2 GB game with minor changes meant 2.2 GB up and 2.2 GB down, every time, for every user. I looked for an existing solution and found nothing that fit:
- rsync needs SSH on both ends, doesn't compose with arbitrary cloud storage
- bsdiff/xdelta operate on single files, not directories
So I built rac-delta: an open, storage-agnostic differential sync protocol with SDKs in Rust and Node.
- How it works -
The protocol splits files into fixed-size chunks (default 1 MB), hashes each with Blake3, and produces a manifest file "rd-index.json" that describes the full directory, every file, every chunk, every hash.
To sync:
1. Generate a local rd-index.json by scanning the directory
2. Fetch the remote rd-index.json from your storage backend if there is one
3. Compare them to produce a DeltaPlan:

  DeltaPlan {
    newAndModifiedFiles: FileEntry[]
    deletedFiles: string[]
    missingChunks: ChunkEntry[]
    obsoleteChunks: ChunkEntry[]
  }

4. Transfer only the missingChunks
5. Clean up obsolete chunks
6. Push the updated rd-index.json
Chunks are deduplicated across files, if two files share identical regions, that chunk is stored and transferred once.
Blake3 is notably faster than SHA-256 for large directory scans, which matters when you're hashing multi-gigabyte directories on every sync.
- Storage-agnostic by design -
rac-delta has no opinion about where chunks live. The SDKs ship adapters for S3, Azure Blob, GCS, SSH, HTTP, signed URLs (this one is experimental), and local filesystem.
- Benchmark results (real S3 infrastructure, 2.2 GB directory) -
Download transfer -> rac-delta (116MB) -> raw S3 (2219MB) -> Reduction of 94.7%
Upload transfer -> rac-delta (115MB) -> raw S3 (2210MB) -> Reduction of 94.8%
Download time -> rac-delta (35.5s) -> raw S3 (671.2s)
Upload time -> rac-delta (53.3s) -> raw S3 (268.9s)
Egress cost / 1000 users (aprox.) -> rac-delta (9.66€) -> raw S3 (184.27€) -> 19x cheaper
And the base upload (first-time, no remote index) takes 172.6s with rac-delta vs 209.4s raw, slightly faster even on full uploads because of concurrent chunk streaming.
(The initial tests were run on a single machine with slow internet against eu-central-1, and production tests on Raccreative Games)
- Three download strategies -
Different environments need different tradeoffs:
- Memory-first: all chunks into RAM, then reconstruct. Best for small builds, fast networks
- Disk-first: chunks to a temp directory, then reconstruct. Better for low-memory devices
- Streaming (recommended): reconstruct files as chunks arrive. No extra RAM or disk overhead
- Production usage -
Raccreative Games uses rac-delta in production today. The CLI tool Clawdrop (Rust) handles uploads; the desktop launcher (Electron/Node) handles downloads. Both use the respective SDKs directly.
https://github.com/raccreative/clawdrop
- Open protocol, MIT licensed -
rac-delta is a documented open protocol - anyone can implement it in any language. The Rust and Node SDKs are the reference implementations.
Docs: https://raccreative.github.io/rac-delta-docs/
Benchmarks + ROI calculator: https://racdelta.com/en/
Node SDK: https://github.com/raccreative/rac-delta-js
Rust SDK: https://github.com/raccreative/rac-delta-rs
Looking for feedback from teams distributing large binaries - desktop app installers, ML model weights, firmware OTA updates, simulation assets, or anything where "upload the whole thing again" is your current answer. Happy to run benchmarks against your specific file patterns.

value: Show HN: Rac-delta – open protocol for differential dir sync (Rust/Node SDKs)

author: Raccreative


value: christiangraf

value: Show HN: Fleet – I built a multi-agent dev team that runs as a bash script

author: christiangraf


value: Show HN: I used NLP to turn UK planning PDFs into a clean CSV


value: This browser extension helps by turning articles into text-only reading views using Mozilla's Readability library with custom CSS informed by accessibility and readability research. It follows four design choices based on W3C WCAG 2.2 standards: a sepia background to reduce eye strain, 1.5× line spacing for better readability, 50–75 character line length to reduce eye fatigue, and sans-serif fonts that work well on screens.

value: Show HN: Yumi Reader – Turn any article into distraction-free pure text


value: nethalo

value: Show HN: Dbtrail – Row-level data recovery for MySQL without restoring a backup

author: nethalo


value: arikchakma

value: Show HN: Kumoh – an opinionated framework for Cloudflare Workers

author: arikchakma


value: bridgettegraham

value: Hi HN — I'm Bridgette, a software engineer in South Africa. Over the last year I rebuilt a classic-style MUD from the ground up on a modern stack (Postgres, server-authoritative simulation, generative-AI NPCs that keep schedules and remember conversations, dynamic weather, item decay, the works). The twist is that when you finish the single-player arc, the game compiles your run into a personalised PDF novel — your name, your race, your choices, your ending. I'd love technical feedback on any of it: the simulation, the NPC design, the localisation engine (it's bilingual English/Afrikaans), or just the idea of "the game writes you a book about you" as a finishing reward. Happy to answer questions.

value: Show HN: Yesterday's Bread – a modern MUD with AI NPCs and a personalised novel

author: bridgettegraham


value: kicumkicum

value:
Hi everyone, my name is Oleg. I’ve been using the Steam Deck OLED for over a year and a half, and I love it. It’s not perfect, but as a portable gaming PC it’s revolutionary in hardware and software design.
I use it for gaming both portable and on my TV, sometimes connected to a NAS and even a GPU dock for heavier titles. It’s basically my main gaming machine now.
One thing has always bothered me: there’s no decent audio player for Steam Deck. Yes, there are dozens of Linux music players, but they either have terrible interfaces, are overloaded, or just don’t feel right with a gamepad. Moving a mouse with the joystick works, but it’s tedious on the couch, especially when the Deck is connected to a TV. Fonts are tiny, navigation is awkward.
So I decided to build my own player. I’ve been coding for personal projects for 12+ years, including two music players (for VK and Yandex Music), a movie streaming app, a terminal ChatGPT assistant, and other tools. My goal is to make a player that works great on Steam Deck, is simple to use with a gamepad, and has a clean UI/UX.
Some background: I’ve been developing for SmartTVs for 5+ years, building apps for IVI, Okko, DomRu, and others, so I’m familiar with non-mouse interfaces. I’m building this project with a friend under the name Cassette Underground.
What the player will have:
- Paid, distributed via Steam
- Local playback initially, with plans for DLNA, internet radio, Spotify, and more
- Playlist support, equalizer, and all common audio formats (MP3, FLAC, WAV, ALAC, AAC, Opus, AC3, Ogg Vorbis, DTS, TrueHD, etc.)
- Fully controllable with a gamepad
Current progress:
- Almost all core features are implemented: file navigation, format support, flat interface with everything accessible
- Equalizer and library views by folder, artist, and genre
- Bug fixes, Steam developer dashboard setup, app page preparation
Early access will cost roughly 5-7 USD, with plans to expand features and polish the interface based on community feedback.
We’re excited to share this with the community and would love feedback on what works, what doesn’t, and which features to prioritize.
Thanks for reading, and rock and roll never dies!

value: Show HN: A music player built for Steam Deck with full gamepad navigation

author: kicumkicum


value:
Hey HN,
I built something that helps people in the US stop debt collectors from contacting them.
https://stopanddesist.com/
It’s based on the FDCPA (Section 805c). Basically, if you send a written cease and desist letter, collectors are legally required to stop contacting you.
I didn’t know this existed until recently. Apparently it’s been law since 1977.
The tool just asks a few questions and generates the letter in a format that’s ready to send.
There’s also a second part I found more interesting while building:
If a collector keeps contacting after receiving the letter, each contact is a violation. So I added a simple tracker where users can log calls/messages and it calculates potential damages.
It also exports a report that can be used if someone wants to talk to an FDCPA attorney (most of them work on contingency).
I’m not from the US (I’m based in India), which is partly why I noticed this. It felt strange that a law like this exists but most people dealing with collectors don’t seem to know about it.
Still early. There are probably rough edges.
If anyone tries it, I’d like to know:
where it’s confusing
if the flow feels too long
anything that reduces trust
Not a lawyer / not legal advice obviously.

value: Show HN: I built a tool to stop debt collector calls using a federal law


value: torrienaylor

value:
I spent spring break building Distillery, an MCP server that gives AI coding sessions persistent, shared team context. By mid-week it was dogfooding: capturing its own design decisions and feeding them back into development. 50k lines of Python (16k production, 25k tests, 7k docs) designed, built, and shipped in just over a week.
Every team I've worked on has the same problem. Someone makes a decision, usually a good one, with a lot of context behind it. And then, six months later, someone asks "why does this work this way?" and the answer is... gone. Buried in Slack. Lost in a PR description nobody remembers. Living only in the head of the person who wrote it, if they're still on the team.
In the age of agentic development this fundamental problem has only been exacerbated. The time it takes to code up an epic is no longer the long pole in the SDLC tent. Knowledge is being generated at exponential rates and no one seems to be able to keep up.
Distillery captures context inside the coding assistant via slash commands (/distill, /recall, /pour) and stores it in DuckDB with vector similarity search. No separate vector DB, no Postgres, a single file. Backup is cp. It is designed to be extensible to more datastores.
The feature that really excites me is ambient intelligence. You point it at GitHub repos, RSS feeds, subreddits, and it polls on a schedule, scores every item for relevance against your existing context using embedding similarity, and surfaces what matters. It builds a recency-weighted interest profile from what you've captured, so the more you use it, the better the signal-to-noise ratio gets.
Karpathy's LLM Wiki gist (https://gist.github.com/karpathy/442a6bf555914893e9891c11519...) describes essentially the same insight; persistent compounding knowledge rather than RAG's per-query rediscovery. Distillery differs in implementation: DuckDB + MCP tools instead of static markdown files, with ambient intelligence on top.
Technical choices:
- Hybrid search — BM25 + vector similarity with Reciprocal Rank Fusion, so "DuckDBStore" finds the exact class and "how does storage work" finds the conceptual entries
- stdio transport for local, HTTP + GitHub OAuth for team shared context
- FastMCP for the MCP wire protocol — works with any MCP client, not just Claude Code
- Jina AI or OpenAI embeddings, pluggable via Protocol interface
- 3-tier semantic dedup (skip >0.95, merge 0.80–0.95, link 0.60–0.80)
- DuckDB + VSS extension (HNSW, cosine similarity) for storage + search in one file
- Chainguard Wolfi container, signed with Cosign, SBOM attested
- Run with `uvx distillery-mcp`
Blog post with more detail: https://norrietaylor.github.io/distillery/blog/building-a-se...
Happy to answer questions about the architecture, the feed scoring pipeline, or the experience of building a tool with itself in a week.

value: Show HN: Shared team context for AI coding sessions with ambient intelligence

author: torrienaylor


value: pattle

value: Show HN: UK Car Bingo

author: pattle

title: Show HN: UK Car Bingo


value: mijndert

value: Show HN: CalAction – Importing ICS files on iPhone made easy

author: mijndert


value: marcobambini

value: Show HN: SQLite Memory – Markdown based AI agent memory with offline-first sync

author: marcobambini


value:
I was building a proxy to strip PII from LLM API calls and realized
that zero-width Unicode characters break basically every PII filter out
there. If you stick a zero-width space inside a name like T om, Presidio's
NER model doesn't see it as a name anymore. Same thing with SSNs and phone
numbers against regex. So I built a normalization layer that strips all
that stuff before running detection.
The proxy itself is pretty simple. You swap your OpenAI base URL to point
at Veil and it redacts PII before the request leaves, then puts the real
values back in the response. Works with streaming too which was the hard
part honestly.
https://veil-api.com, free tier is 100 requests/month.

value: Show HN: Veil a Drop-in PII redaction proxy for any LLM API


value: Show HN: RBF-Attention – Trading dot-products for Euclidean distance


value: Show HN: SolidUptime – Uptime monitoring with incident grouping (free, no CC)


value: narragansett

value: Show HN: BitBang – P2P tunnels to localhost, no account required

author: narragansett


value: fcavallarin

value:
Hi HN,
A few months ago I shared BDHS (Breakpoint-Driven Heap Search), an experiment to trace when a value appears in memory by taking heap snapshots at every debugger pause.
Since then, I’ve been experimenting further with Chrome DevTools Protocol primitives to build tools for reversing and debugging JavaScript at runtime.
Here’s the next step.
The focus is shifting from observation to instrumentation:
instead of just inspecting state, the goal is to interact with execution - at specific points, in user-land code, without modifying the application.
Early experiments include:
- attaching hooks to functions at runtime
- inspecting and modifying arguments and variables
- overriding return values (unfortunately limited to sync functions due to CDP constraints)
- following a return value to its consumer (best-effort/heuristic)
- conditional stepIn/ stepOut / stepOver
All implemented via CDP (debugger breakpoints + runtime evaluation), without monkeypatching or rewriting code.
Whitepaper: https://fcavallarin.github.io/wirebrowser/CDP-as-a-Runtime-I...
API docs (early): https://fcavallarin.github.io/wirebrowser/api/
I’d really appreciate feedback - especially from people doing reverse engineering, bug bounty, or complex frontend debugging.

value: Show HN: JavaScript runtime instrumentation via Chrome DevTools Protocol

author: fcavallarin


value: Show HN: Brighten Up – My First App. Lessons on Unity and Renting a Mac


value: Show HN: The King James Bible deserved a better website


value: "I built this because I'm tired of software bloat. I used Rust on a MediaTek Helio P35 (Samsung A04e) and achieved 85ns stable latency. Here is how I handled the memory management..."

value: Show HN: 85ns latency on a $100 Android device using Rust


value: okcdz

value: Hi HN — I built DeskTalk, an open-source AI-native desktop environment.<p>The idea is simple: instead of opening apps and menus first, you describe what you want in natural language. DeskTalk can generate small interactive apps, edit them in place, and keep them around as part of the desktop.

value: Show HN: DeskTalk – talk to your desktop to build and modify local apps

author: okcdz


value: naimurhasanrwd

value:
Hi HN, I built PastePath as a small tool for turning screenshots into step-by-step visual guides.
You can paste or upload screenshots, annotate them with arrows/shapes/text/freehand, reorder them into steps, add captions, and share a clean link. It is useful for tutorials, bug reports, docs, product reviews, QA walkthroughs, onboarding, and support replies.
Feedback welcome, especially around the annotation UX and what tools would make screenshot walkthroughs faster.

value: Show HN: A tool to turn random screenshots into structured tutorials

author: naimurhasanrwd


value: hmontazeri

value: Show HN: Train ML models for 80% less by always picking the cheapest Spot region

author: hmontazeri


value: wjellyz

value:
I kept losing track of my terminal as I started using Claude Code, Gemini CLI, and Codex more heavily, I kept finding myself cmd-tabbing, hitting cmd-`, and mousing around trying to find the right tab.
I have Carpal and Ulnar Tunnel Syndrome in my thumb and pinky, so this was really flaring up my RSI (Repetitive Stress Injury) symptoms.
So I built back2vibing.
When an agent finishes or needs input, it can bring the exact terminal window or tmux pane back into focus so I can start typing or dictating immediately . For me, the biggest benefit is not just for my RSI but also reliability. While I’m context switching waiting for my agent to finish, I’m never missing any completions or approval prompts.
I tried using Claude Code notifications, but mousing to click the notification also flared up my symptoms, and notifications get very messy quickly because I won’t always click the notification and just manually cmd + tab to it.
Mentally, I feel very at ease because I can spin up any number of agents and be doing anything else on my computer, cooking, or cleaning and when my agent is done, I hear a sound and then can get straight back2vibing.
I rabbit-holed pretty hard on it, so I also built out:
- a floating Session Dock to monitor and jump between agents with mouse or keyboard
- sounds when an agent finishes with google maps style audio ducking, so you can listen to music and never miss a sound.
- customizable focus modes: automatically focus, interactive focus (decide if you want to focus), and native notifications
- SSH support for remote workflows
- claude code / codex / gemini cli usage monitoring
- workmux integration for worktrees + tmux
Most of these features were built based off of feedback friends have given me. Been really passionate about this project and would love for folks to give it a try.

value: Show HN: back2vibing – instantly jump back to your agent's tmux pane / terminal

author: wjellyz


value: Show HN: Homebutler – AI manages your homelab without getting shell access


value:
I wanted to test mobile apps in plain English instead of relying on brittle selectors like XPath or accessibility IDs.
With a vision-based agent, that part actually works well. It can look at the screen, understand intent, and perform actions across Android and iOS.
The bigger problem showed up around how tests are defined and maintained.
When test flows are kept outside the codebase (written manually or generated from PRDs), they quickly go out of sync with the app. Keeping them updated becomes a lot of effort, and they lose reliability over time.
I then tried generating tests directly from the codebase (via MCP). That improved sync, but introduced high token usage and slower generation.
The shift for me was realizing test generation shouldn’t be a one-off step. Tests need to live alongside the codebase so they stay in sync and have more context.
I kept the execution vision-based (no brittle selectors), but moved test generation closer to the repo.
I’ve open sourced the core pieces:
1. generate tests from codebase context
2. YAML-based test flows
3. Vision-based execution across Android and iOS
Repo: https://github.com/final-run/finalrun-agent
Demo: https://youtu.be/rJCw3p0PHr4
In the Demo video, you’ll see the "post-development hand-off." An AI builds a feature in an IDE, and Finalrun immediately generates and executes a vision-based test for it verifying the feature developed by AI.

value: Show HN: Finalrun – Spec-driven testing using English and vision for mobile apps


value: okaris

value: Show HN: Jsont – CLI to explore and query JSON/JSONL files, built for AI agents

author: okaris


value: ChrisPoensgen

value: Show HN: Converting prototypes to production shouldn't be that hard

author: ChrisPoensgen


value: marcobambini

value: Show HN: SQLite Memory – Markdown based AI agent memory with offline-first sync


value: bnchrch

value: Show HN: Output.ai - OSS framework we extracted from 500+ production AI agents

author: bnchrch


value: yuzhengxu

value:
We built an AI company. Not a chatbot wrapper — a company with HR, COO, engineers, and designers, all AI agents, organised and managed the way a real company operates. You're the CEO, the only human.
To be clear: this is not one LLM with a bunch of prompts pretending to be a team. These are fully independent agents — different models, different backends, different runtimes — each doing their own job.
*Why organise agents as a company*
We spent a year building multi-agent systems and kept hitting the same wall. Agents say "I'm done" and pass results downstream with no verification. Errors cascade through the whole project. Static workflows (Dify etc.) are stable but can't adapt to the new skills+harness agent paradigm. Free-form negotiation between agents doesn't converge.
The root issue: agents are getting individually stronger, but without organisational management they can't collaborate effectively. It's like having a room full of talented people with no management structure — capability is there, coordination isn't.
Human companies solved this centuries ago. Performance reviews, SOPs, org hierarchy, hiring pipelines, retrospectives — these mechanisms make collaboration work regardless of domain. We applied the same principles to AI agent teams.
*How it works*
The company has a founding team (HR, COO, EA, CSO) built in from day one.
Talent Market. When the company needs specialists, HR recruits from a community-driven Talent Market ([one-man-company.com](https://one-man-company.com)). Verified agent implementations with real usage counts and community reviews, not LLMs self-declaring expertise. Claude Code, OpenClaw, LangGraph agent families are already on the market — [superpowers](https://github.com/obra/superpowers), [agency-agents](https://github.com/msitarzewski/agency-agents) are ready to hire ([browse here](https://one-man-company.com/talent/claude-superpowers)). The market is open for contributions: upload your own agents, share/buy/sell. We're building a real agent community.
Talent-Container separation. Each agent is split into a portable identity (Talent: prompts, skills, tools, work principles) and an execution runtime (Container: LangGraph, Claude CLI, script process). Different agents run on completely different backends in the same project — Claude Code writes code, LangGraph handles image generation, OpenClaw runs admin.
Tree Search based Orchestrate Algorithm. Tasks decompose dynamically during execution, not upfront in a fixed pipeline. The underlying algorithm is built on AND-tree DAG structure with formal guarantees: termination (bounded retries + timeouts + cost budgets), deadlock freedom (cycle detection at insertion), crash recovery (processing nodes reset on restart).
Quality gates. Every task has acceptance criteria and mandatory supervisor review.
Self-evolution. Post-project retrospectives update work principles and org-wide SOPs. CEO 1-on-1s become permanent agent memory. Performance reviews with real consequences: PIP for underperformers, then offboarding if they don't improve. HR re-recruits from the Talent Market.
*Results*
Cross-domain without changing the framework. So far, we have tried 1) Game dev; 2) Audiobook and Short Movie Generating; 3) Auto-Researchurvey; 4) Content Generation; 5) More is comming!
Same system, different team, different domain. Build a game today, produce a comic series tomorrow.
*Try it*
Fully open source. [one-man-company.com](https://one-man-company.com) is the front door. One command:
GitHub: https://github.com/1mancompany/OneManCompany
Talent Market: https://one-man-company.com
Come try it, file issues, or contribute. We especially want people building agents for the Talent Market.

value: Show HN: OneManCompany The first AI company with real corporate org structure

author: yuzhengxu


value: Show HN: Beta Testing needed for my package Trustcheck


value: braden-w

value:
Hey HN! Braden here. Some of you might know me from Whispering a while back (https://news.ycombinator.com/item?id=44942731).
Obsidian was one of the biggest inspirations behind the Epicenter project. I used it daily and think it's incredible software. But it's not open source, and Obsidian Sync never quite worked the way I wanted it to. I think any tool that sits this deep in your personal knowledge system should be open source and auditable.
So I built Opensidian as an open-source proof of concept: what happens when you store notes as Yjs CRDTs, sync them across servers, encrypt them end-to-end, and put a POSIX-like filesystem on top?
To do this, I built `@epicenter/filesystem`, which exposes a virtual filesystem interface on top of `@epicenter/workspace`'s CRDT tables. I then wired this into `just-bash`, a bash interpreter implemented entirely in TypeScript, which provided 80+ Unix commands (awk, sed, grep, jq, find, sqlite3, curl, etc.) to run against the same data the editor uses. Shell commands and the UI hit the same underlying CRDTs.
$ echo "# Meeting notes" > /notes/2026-04-06.md
$ mkdir /notes/archive
$ mv /notes/2026-04-06.md /notes/archive/
$ open /notes/archive/2026-04-06.md
Those commands create and move real files that immediately appear in the editor's file tree. The best part is that all of this works in both browser and server-side contexts, since yjs (https://github.com/yjs/yjs) is isomorphic.
Under the hood, metadata (name, parent, timestamps) lives in a versioned CRDT table. Document content lives in a separate Y.Doc per file, so the directory index syncs without pulling every document body. Sync uses the Yjs protocol over WebSocket, with Cloudflare Durable Objects persisting an append-only SQLite update log. Everything is encrypted end-to-end with XChaCha20-Poly1305. Keys derived via HKDF-SHA256; the sync server sees only the ciphertext.
More features: CodeMirror 6 with Yjs collaboration binding, `[[` internal links that store file IDs (renames don't break them), SQLite FTS5 search, AI chat with tool-call approval UI, and Vim mode.
Opensidian itself is a demo. For the last six months, I've been working on the infrastructure underneath: `@epicenter/workspace` (typed CRDT tables with versioning, migrations, encryption, and sync) and `@epicenter/filesystem` (a POSIX filesystem layer over Yjs). I'll be writing more about those APIs separately and integrating them into more apps in the ecosystem (including Whispering). The idea is that anyone can build local-first apps on the same foundation: notes, task managers, knowledge bases, etc., while solving the most difficult problems of local-first sync.
The UI is rough, and the feature set is thin compared to Obsidian; this isn't trying to replace it today. But I'm excited for what the future of personal computing tools could look like!
MIT licensed. Would love feedback, ideas, and roasts.
Source: https://github.com/EpicenterHQ/epicenter/tree/main/apps/open...
Discord: https://go.epicenter.so/discord

value: Show HN: Opensidian: Local-first notes in the browser with POSIX shell and sync

author: braden-w


value: jazzen

value: Show HN: VibeAround – Use Claude Code, Codex, Cursor from IM, Built on ACP (

author: jazzen


value: greentfrapp

value:
I made Testreel as a programmatic alternative to ScreenStudio.
This has two primary value props:
1. Not having to manual re-record a demo because of a typo or misclick; just update the config and regenerate
2. Allows LLM agents to generate demo videos for your web app, complete with cursor overlay, and a customizable desktop background
Testreel is an npm package that lets you describe interactions (click, type, scroll, zoom etc.) in JSON, YAML or Playwright. Then generate a polished webm/mp4/gif video with cursor overlay, click ripples, gradient background etc.
Made with Claude Code. Built on Playwright + FFMPEG. MIT License.
Repo: https://github.com/greentfrapp/testreel

value: Show HN: Testreel – Programmatic product demo videos from JSON and Playwright

author: greentfrapp


value: pyjka

value: Show HN: Building EU payment infra for agents

author: pyjka


value: aristech

value: Show HN: QRAuth – Open-source QR verification with passkeys and device trust

author: aristech


value: artursapek

value: Show HN: ErrataBench - A Proofreading Benchmark for LLMs

author: artursapek


value: sauremilk

value: Show HN: Vibe-coded your repo? Drift finds the architecture problems

author: sauremilk


value: mecarc

value: Show HN: Falcon Builder – the modular OS for designing and deploying AI agents

author: mecarc


value: alfg

value:
I've been building open-source tools in the video/multimedia space for 10+ years. Finally shipped the commercial product I always wanted to exist — Video Commander, a desktop app that consolidates FFmpeg, ffprobe, MediaInfo, VMAF and more into a single workspace where you can inspect, encode and analyze video.
Built with Tauri + Rust backend, React frontend. FFmpeg and VMAF.
Not a cool AI/LLM project, just a tool I've been heads-down building over the last six months.
Happy to answer any questions!

value: Show HN: Video Commander – A desktop IDE for video engineers (FFmpeg, VMAF)

author: alfg


value: ciscoriordan

value:
Amazon has been slowly killing kindlegen since 2020. First they dropped the Linux binary, then stopped distributing the standalone CLI entirely. The only copy left is hidden inside Kindle Previewer 3. Most people building Kindle dictionaries have been getting by with unsupported copies from older installations.
Amazon has moved a lot to EPUB. But sideloaded dictionaries still require MOBI. There's no alternative format for custom Kindle dictionaries.
The MOBI dictionary format is barely documented by Amazon, and the MobileRead wiki has partial community documentation, but a lot of the dictionary-specific format had to be reverse-engineered from kindlegen's output byte by byte.
I was building a Greek dictionary with 80K headwords and 452K inflected forms, and kindlegen couldn't handle it - 12+ hours on a Mac under Rosetta, frequently running out of memory and crashing before finishing. Kindling builds the same dictionary in 6 seconds.
Binaries for Mac, Linux, Windows: https://github.com/ciscoriordan/kindling

value: Show HN: Kindling – reverse-engineered kindlegen, ~7,000x faster in Rust

author: ciscoriordan


value: sinthes

value:
The project that I started out of frustration turned into an application that replaced all other ASO tools I have been using. Sharing here so I hope it helps others as well.
It is called RespectASO and available at respectaso.com
Lots of features are free without any limitations:
- Keyword popularity
- Keyword difficulty - and a separate difficulty score for ranking in top 5, 10 or 20.
- Opportunity scores - likelihood of ranking organically
- Unlimited apps + searches
- Estimated downloads per keyword per localization
- Supports 30 different localizations
- Country opportunity finder: Which country is the best to target for a given keyword
- Automated daily updated ranking results for targeted keywords
- ASO targeting advice
- CSV export
- Keyword trend charts
- Bulk operations
Automation features are monetized for a one time fee, and they aim to automate hours of work into minutes with one click:
- AI Niche Researcher: Enter a keyword, get a complete ASO strategy. The agentic engine analyzes competitors, discovers keyword opportunities, and generates constraint-compliant metadata: title, subtitle, and keyword field.
- AI Competitor Analyzer: Paste any App Store URL. The agentic engine reverse-engineers their keyword strategy, identifies gaps, and generates a differentiated counter-strategy with validated metadata.
- AI Competitor Analyzer: Paste your title, subtitle, and keyword field. Get an instant ASO Readiness Score (0–100) with keyword-by-keyword breakdown, competitor comparison, and 3 improved variants per field.
And it is open source and the repo is available at https://github.com/respectlytics/respectaso . If you support the open repo, please feel free to leave a star.
I hope it adds value to the community. I appreciate any feedback.

value: Show HN: Developed a solution to automate ASO keyword research

author: sinthes


value: fidgetwinner

value: Dial Tone is an iOS rhythm game inspired by the original iPhone demo. The soundtrack is generated live from your play, so every game is a unique little composition.<p>This is our dev blog about building the game. It includes some music theory, a free screen saver, and a cautionary tale against building a screen saver. Happy to answer questions.

value: Show HN: Dial Tone – an iOS rhythm game inspired by Slide to Unlock

author: fidgetwinner


value: vicnas

value:
I built NeverDue after missing too many deadlines buried in emails.
It connects to your inbox, reads incoming emails with an AI pipeline, and extracts events directly into your calendar — exams, meetings, project deadlines, assignments. Exports as ICS if you don't use Google Calendar. You can set rules to categorize or discard emails by sender or keyword, and it handles attachments on Pro.
Happy to answer any questions.

value: Show HN: NeverDue – turn emails into calendar events, exports as ICS

author: vicnas


value: vishruthbharath

value: I built seek because I kept losing my flow by switching to my browser while coding. It reads your go.mod, package.json, Cargo.toml and other config files, allows you to attach local directory files, and biases search toward your stack, and streams a cited answer you can navigate with vim keybinds. Uses Tavily for web search, Ollama or any OpenAI-compatible API for answers. Single Go binary, MIT licensed.

value: Show HN: Seek – Context-aware terminal search TUI

author: vishruthbharath