value: prvctice

value:
Started as a personal research tool — I was buried in notes and needed something that could connect sources without hallucinating. Instead of feeding it content, I built a system-prompt structure using curated knowledge graphs that shape the model's prior. It surfaces things I'd never heard of without just pulling from generic top-10 lists.
Over 14 months it grew into something I'd call a DIY OS. Key parts:
- A recursive learning system that tracks tool usage and re-ranks tools based on your habits
- An intent coordinator that abstracts the interaction layer so you can plug in game controllers, MIDI, gestures, or voice without hard-wiring each one
- A built-in app SDK — the system generates its own apps based on usage patterns (the calendar and study timer were made by Prvctice itself)
It's free and open source. I also wrote a longer piece about the 14-month journey here: https://prvctice.com

value: Show HN: Prvctice,A personal OS I built solo that generates its own apps

author: prvctice


value: cheeaun

value: Show HN: A userscript that shows when you starred a GitHub repository

author: cheeaun


value: TyKolt

value:
The problem: you feed your own data to an LLM, ask a question,
and get a confident answer — partly fabricated.
Kremis is an embedded graph store (Rust, Apache 2.0) built around
one constraint: every answer must trace back to a real data point.
How it works:
- You ingest your data as EAV signals (entity, attribute, value)
- Kremis stores them in an append-only graph (redb underneath)
- Every query returns one label:
    FACT       — path exists in your graph
    INFERENCE  — derived from graph traversal
    UNKNOWN    — "not in your data, I won't guess"
The LLM never writes to the graph. Only your verified signals do.
The graph can't hallucinate — it either has the path or it doesn't.
There's a runnable demo (Python stdlib, no pip):
  examples/demo_honesty.py
It ingests 10 signals, asks 6 questions, shows which LLM answers
are grounded and which are fabricated.
It also has an HTTP API and MCP support (Claude can query your
graph directly via tool calls).
Honest limitation: ingestion is EAV format, so you need to reshape
your data first. Working on making this easier.

value: Show HN: I built a graph store so my LLM can't hallucinate facts from my data

author: TyKolt


value: zyoralabs

value:
ZSE is an LLM inference engine built for simplicity and efficiency.( Phase 1 )
Features:
- Single .zse file format (model + tokenizer + config embedded)
- Zero network calls on load - works completely offline
- Dual INT4 kernel backend (ZSE Kernel + ZSE bnb Kernel)
- Intelligent layer auto-selects optimal kernel for your hardware
- Fast cold starts for serverless deployments
Benchmarks (H200, Qwen 2.5):
ZSE Kernel:
  7B  → 5.67 GB VRAM, 37 tok/s, 5.7s cold start
  14B → 10.08 GB VRAM, 21 tok/s, 10.5s cold start
  32B → 19.47 GB VRAM, 11 tok/s, 20.4s cold start
  72B → 41.54 GB VRAM, 6 tok/s, 51.8s cold start
ZSE bnb Kernel:
  7B  → 6.57 GB VRAM, 46 tok/s, 6.0s cold start
  14B → 11.39 GB VRAM, 28 tok/s, 7.1s cold start
  32B → 22.27 GB VRAM, 20 tok/s, 20.8s cold start
  72B → 47.05 GB VRAM, 16 tok/s, 53.0s cold start
Usage:
  pip install zllm-zse
  zse convert Qwen/Qwen2.5-7B-Instruct -o model.zse
  zse serve model.zse --port 8000
https://github.com/Zyora-Dev/zse

value: Show HN: ZSE – Single-file LLM engine with dual INT4 kernels

author: zyoralabs


value: justvugg

value:
Hi everyone,
I’d like to share a tool I built, called dbcli. It’s a database CLI designed specifically for AI agents, enabling them to understand and interact with any database using a single command. Whether you're developing AI systems that require database access or need a fast and efficient way to query and profile your databases, dbcli is optimized for speed and simplicity.
Key Features:
Instant Database Context: Use dbcli snap to get schema, data profiling, and relationships in one call—no need for multiple tool invocations.
Optimized for AI Agents: Designed to minimize overhead for AI systems. Get database insights and query results without wasting tokens or setup time.
Lightweight: No server setup, no SDK installation—just pip install dbcli and you’re ready to go.
Multi-database Support: Supports SQLite, PostgreSQL, MySQL, MariaDB, DuckDB, ClickHouse, SQL Server, and more.
Simple Queries and Writes: Run SQL queries, write data, and execute SQL files with ease.
Data Profiling: Get real-time stats on column distributions, ranges, and cardinality to better understand your data.
Integration: Easy integration with AI agents like Claude, LangChain, and others.
Why dbcli over MCP?
Zero context cost: Unlike MCP, which can consume hundreds of tokens just to fetch schema data, dbcli provides everything in a single command with no token overhead.
Faster Setup: Minimal installation and no external configuration needed—just install with pip install dbcli.
Works for Any Agent: dbcli works with any agent that has shell access—no need for special protocol support.
Installation:
pip install dbcli
Optional database drivers:
pip install "dbcli[postgres]"pip install "dbcli[mysql]"pip install "dbcli[all]"
Check out the project on GitHub: https://github.com/JustVugg/dbcli
Looking forward to your feedback and any suggestions for improvements!

value: Show HN: Dbcli – Database CLI Built for AI Agents

author: justvugg


value: wisdomtreelzz

value: Show HN: How to measure the value of Agentic AI

author: wisdomtreelzz


value: jatingargiitk

value:
I built an open-source framework where multi-agent systems fix their own prompts.
Each skill is a structured SKILL.md. After every run, an LLM judge scores each skill and tags exact failures. An LLM patcher generates candidate fixes to just the failing section. Each candidate is replayed on past traces. Winner gets promoted. Loser discarded.
One command: evoagents autofix
Key decisions:
- LLM-as-judge, not regex — constraints are natural language, evaluation should be too
- Section-level patching — only the broken part gets touched
- Replay gating — no patch ships without proving it improves on real data
- Versioned — every change is a new version, instant rollback
You can steer it: evoagents autofix --guide "prefer primary sources"
pip install evoagents
https://github.com/jatingargiitk/evoagents

value: Show HN: EvoAgents – Agents that evolve their own skills

author: jatingargiitk


value: freediver

value:
Sharing a little hobby project of mine, that i've been working on for the last few months.
The motivation is the midlife crisis (and an amazing video explaining it linked in the project) and trying to wrap my thoughts about life in general.
With this project I tried to build a model about how one's life unfolds and what are the powers we have to influence the outcome.

value: Show HN: Curves of Life

author: freediver

title: Show HN: Curves of Life


value: foxfoxx

value:
Govbase tracks every bill, executive order, and federal regulation from official sources (Congress.gov, Federal Register, White House). An AI pipeline breaks each one down into plain-language summaries and shows who it impacts by demographic group.
It also ties each policy directly to bias-rated news coverage and politician social posts on X, Bluesky, and Truth Social. You can follow a single bill from the official text to how media frames it to what your representatives are saying about it.
Free on web, iOS, and Android.
https://govbase.com
I'd love feedback from the community, especially on the data pipeline or what policy areas/features you feel are missing.

value: Show HN: Govbase – Follow a bill from source text to news bias to social posts

author: foxfoxx


value: riffonio

value: Show HN: Excellusion, a PoC about the future of apps

author: riffonio


value: ruizprogelio

value: Show HN: Dust – Device Unified Serving Toolkit (CUDA for Phones)

author: ruizprogelio


value:
Dispatch 001 is the first piece from a project called Metanoia Research. I have structured it around Dante's three canticles, Inferno, Purgatorio, Paradiso, as lived theology rather than academic argument. I have drawn on Ted Chiang's Story of Your Life for a section on the inadequacy of sequential language to carry simultaneous divine awareness, which was the most honest intellectual framework for what I was trying to say.
Metanoia is not on HN. It is not technical. It is not a product. It is one man writing honestly about suffering, purgation, and Providence, to forget the past so we might remember the future.
I will publish one dispatch per month for the foreseeable future.

value: Show HN: Metanoia Research

title: Show HN: Metanoia Research


value:
Hi HN,
I built ParseForce because parsing emails has always been surprisingly painful.
Many automation workflows still rely on incoming emails: invoices, order confirmations, shipping notifications, etc. The usual solutions involve fragile regex rules or Zapier-style email parsers that break when email formats change.
ParseForce takes a different approach.
You create a unique inbox and define the data you want to extract. Incoming emails are parsed using AI into structured JSON and delivered to your webhook.
Example workflow:
Email received → ParseForce parses it → structured JSON → webhook to your backend.
Example output:
{
"invoiceNumber": "INV-84217",
"items": [
{ "name": "Valve kits", "quantity": 60 },
{ "name": "Pressure regulators", "quantity": 20 }
],
"total": 1284.50
}
Typical use cases:
* extracting invoice data
* processing order confirmations
* parsing shipping notifications
* automating legacy email workflows
The goal was to make email integrations as simple as webhook integrations.
Stack:
* Node.js / TypeScript
* PostgreSQL
* AI-based schema parsing
* webhook delivery system
I’d love feedback from the HN community.
Site:
https://parseforce.io

value: Show HN: ParseForce – Turn emails into structured JSON and send them to webhooks


value: prastik

value: SwarmWatch is an activity monitor and control plane for your AI coding swarms. Works seamlessly across all major coding agents and platforms.

value: Show HN: SwarmWatch – Live view of your coding agents at work

author: prastik


value: JackC

value:
The Agent Protocols Tech Tree is a Civilization-style technology tree that shows the evolution of more and more complex protocols for building agents, coming from a "rough consensus and running code" perspective. You can stay at a high level or click through to see each protocol all the way down to the wire format.
I made this tool as an alternative to a slide deck for a conference on AI agents that included both policy/regulatory folks and tech folks -- I wanted something for the policy side that shows the complexity of the decentralized community behind AI agents and why regulating them is a messy topic; and for the tech side that would let you see what the actual tech is beneath the jargon.
I'd love to know what you think I got right or wrong. There's a bunch of ways to organize and structure this story, how various competing incentives are driving people to agree on common frameworks and ways of doing things. I'm curious how you would tell the story differently and what tech out on the right edge you think is coming up.
Tool: https://harvard-lil.github.io/agent-protocols/
Blog post: https://lil.law.harvard.edu/blog/2026/02/23/agent-protocols-...
Code: https://github.com/harvard-lil/agent-protocols/

value: Show HN: Agent Protocols Tech Tree

author: JackC

title: Show HN: Agent Protocols Tech Tree


value: inguz

value:
Summary:
keep (https://github.com/hughpyle/keep/, MIT-licensed) is a skills practice wrapped around an implementation of "memory for AI agents".
The practice is this: repeated reflection on means and outcomes, so that skillful action improves over time. But the raw implementation of memory is its foundation. Without working memory, you can't iterate.
Similarly, without benchmarks, you can't tell what works. Today we're publishing results for the LoCoMo benchmark.
Scores: 76.2% overall (weighted average)
Single-hop 86.2% (841 questions)
Temporal 68.5% (321 questions)
Multi-hop 64.2% (282 questions)
Open-domain 50.0% (96 questions)
The linked blog post has more detail including industry comparisons.  Also links to full repro steps and result data.
This run used local models for embeddings and analysis (nomic-embed-text and llama3.2:3b), and gpt-4o-mini for the query and judge.
Proof point I think that a *local-only* LLM-assisted memory system can achieve solid benchmarks.
Background:
`keep` started with my experience using forgetful agents, and identifying a need for a skill that implements "reflective" memory (not itself new, see e.g. Shinn et al https://arxiv.org/abs/2303.11366) -- here the reflection practice is quite opinionated, saying effectively: what you do is what you become.
Whether *this* works is not a subject of the benchmark.
Docs:
copious documentation at https://docs.keepnotes.ai/guides/

value: Show HN: Benchmarking the Keep memory system with LoCoMo

author: inguz


value: Show HN: MassMAP – Masscan as a Service LOL


value: Show HN: Mailfeed – Your reading list, owned by you


value: schiffy

value:
btrc is a statically-typed language that transpiles to C11. It adds classes, generics (monomorphized), type inference, lambdas, f-strings, collections (Vector, Map, Set), threads, GPU compute via WebGPU, ARC memory management, exception handling, and a standard library — while generating strict C11 with no runtime, no GC, and no VM.
The compiler is a 6-stage Python pipeline (lexer → parser → analyzer → IR gen → optimizer → C emitter) driven by a formal EBNF grammar and an algebraic AST spec (Zephyr ASDL). The generated C is readable and linkable with any C11 compiler. It ships with a VS Code extension (LSP with completions, diagnostics, go-to-def, hover) and 930 tests.
I've wanted to build something like this for about 10 years, but it was always too ambitious of a project to do on the side. With AI, I was able to build it over a handful of evenings after work, which is really wild.
Some things worth noting:
A few things that I find fun / interesting / noteworthy:
- The EBNF grammar and ASDL spec are the single source of truth — the lexer, parser, and AST node classes are all derived from them, not hardcoded
- Generics are monomorphized (like C++ templates / Rust), so zero runtime overhead but binary size grows per type combination
- ARC handles most memory management including cycle detection and cleanup on exceptions — no GC, deterministic destruction
- The entire stdlib (collections, math, datetime, IO, threading) is written in btrc itself
- @gpu functions transpile to WGSL compute shaders with auto-generated WebGPU boilerplate — array params become storage buffers, scalars become uniforms
- The generated C is meant to be readable — you can step through it in gdb/lldb and it mostly makes sense (just verbose with lots of underscores)
- There's a 3D game engine example (ball + WASD + jump + shadows + raymarching) that's ~570 lines of btrc across 11 small modules
- The VS Code extension reuses the compiler's own lexer, parser, and analyzer — diagnostics match exactly what the compiler reports
- btrc inherits C's memory model wholesale — no borrow checker, no lifetime analysis. You can absolutely still shoot yourself in the foot
- The whole thing was built in a few evenings after work with heavy AI assistance, which felt like the most interesting part of the project honestly

value: Show HN: btrc – C, but better. Built with AI in just a few weeknights

author: schiffy


value: tljq

value: Show HN: Engram – Your terminal now has perfect memory (local AI, no cloud)

author: tljq


value: buckydigital

value: Show HN: Grabchars 2.0 – get keystrokes direct, first update in 36 years

author: buckydigital


value:
Hi HN,
I built Product Model, an open-source MDX-based grammar that gives product specs the same rigor as code — typed blocks, validation, version control, and a JSON AST output.
The problem: product intent lives in Google Docs and Notion. Implementation lives in code. Between them there's no structured layer, so requirements drift, edge cases disappear, and "that's not what I meant" becomes the most expensive sentence every sprint.
I wanted something more natural than code but more structured than a Google Doc — a format that both humans and AI agents can read, write, and reason about. That's what led me to build this.
Product Model lets PMs author .product.mdx files using blocks like Feature, Policy, Logic, Definition, and Constraint. Tooling validates the grammar, checks cross-references, and builds a machine-readable AST. Think of it as a type system for product requirements.
It comes with a CLI for validation and builds, and a visual Studio editor so you never have to touch raw MDX if you don't want to.
Repo: https://github.com/pmTouchedTheCode/product-model
Would love feedback on the grammar design and whether this matches real PM workflows you've seen.

value: Show HN: Product Model – A structured grammar for bridging PRDs and code


value: wladradchenko

value:
Hi HN,
About six months ago, when Gravit Designer (later Corel Vector) was shut down, I was genuinely upset. I had been using it for years — it was simple, fast, and powerful enough for most of my design work.
When it disappeared, I couldn’t find a web-based vector editor that felt the same. So I decided to build repeat Gravit Designer in original view, but with better functionality and free. The goal was not just to clone it, but to recreate the workflow and accessibility that made it great:
I built it solo, focusing on performance and keeping the interface clean and familiar for former Gravit users. And I developed mobile and tab interface for app.
I’d really appreciate feedback — especially from people who used Gravit or other vector tools professionally.
Thanks.

value: Show HN: I built a free alternative to Gravit Designer after it shut down

author: wladradchenko


value: jacobn

value:
We needed a side project to give agentic coding a try, and created tensorspy.com together with Junie and ChatGPT 5.2.
Tensor Spy lets you quickly inspect the contents of numpy & pytorch tensors locally (your tensors are not uploaded to any servers).
This is useful to validate your deep learning data pipelines, to check which layers in your diverging model are actually going haywire, and just because it's kind of cool & a lot more convenient for one-off inspections than loading things up in python.
If you work with diffusion models, inspecting the latent space can be quite informative: you want some "noise" in there but it should probably be fairly smooth for your LDM (Latent Diffusion Model) to be able to target it well.
Also, if you haven't looked at your data, it's probably not what you think it is ;)
Basic stats are auto-computed, and any inf/nan values are both counted and rendered with contrasting colors, to help you quickly identify issue hotspots.
The site is free, and our broad intention is to keep it that way (we run a bunch of pro-bono little utility sites in addition to our commercial ones, they're all linked on the about page).
Would love to hear your thoughts, I'm sure there are some stats or utility features we missed, so please give it a spin and let us know!
---
Agentic coding is a brave new world. Three years ago, after the initial rush of ChatGPT's launch, I commented to some friends that "we're standing on the beach and the water just receded". The tsunami is really hitting now. As in: this project took about 2 weeks, and not only would we not have done it without agentic coding, it would have taken months using "traditional methods". With agentic coding, adding .pt/.pth support was basically a single request. And it just worked. Time to adapt yet again.

value: Show HN: Tensor Spy: inspect NumPy and PyTorch tensors in the browser, no upload

author: jacobn


value: kgarten

value:
As the title says, I have been playing a bit with whisper.cpp and the Apple Speech to Text models and put out a small demo app.
Wondering where to go from here. I was thinking to remove the ads form the free version and add an AI summary to the payed one.
Ideas welcome. Btw, source code is here: https://github.com/kkai/aimemo

value: Show HN: Alpha of a Speech to Text iOS App (Feature Requests Welcome)

author: kgarten


value: jannesblobel

value:
Hi everyone,
I love Markdown but collaboration is a pain. Whenever I work on a document with others, I end up switching to Google Docs, then exporting to Markdown, copying it into the right repository, and committing it locally.
Why Google docs? .md misses annotations, discsusions, Richttext that everybody (also non techies) know how to work with...
Thats why I build colibri, a Google Docs-like experience for any GitHub Markdown files. Accessible and usable for everyone, with or without a GitHub account.
Just replace the g of github.com with tune "tuneithub.com".
https://github.com/Legit-Control/get-colibri
->
https://tuneithub.com/Legit-Control/get-colibri
and you can start to collaborate - press open PR - to get your changes merged back in.
Feedback, I’d love:
- How do you currently collaborate on .md files?
- If you could add one feature to a Markdown editor like this, what would it be?
Limitations:
- Works only for public GitHub repositories for now
- Support for private repos coming soon

value: Show HN:Turn any GitHub .MD into a collaborative editor by replace "g" with tune

author: jannesblobel


value: oleschaper

value:
Hey HN,
We're building Minit Games, an open platform for short-form HTML5 games served in a personalized feed.
The problem: game discovery on mobile is broken. Finding something new means digging through store rankings, downloading, and waiting. The top 1% of publishers take 92% of in-app purchase revenue. Meanwhile, AI coding tools are making it easier than ever to build playable experiences, but there's nowhere to distribute them.
Minit is a feed of bite-sized games (roughly 60-second loops) that load instantly in the browser. No install, no app store friction. Every interaction (skip, play, replay, share) trains an AI recommendation engine that matches players with content in real time.
For creators, it's an open platform. Anything that exports to HTML5 works — Godot, Phaser, Construct, or any of the emerging AI tools. We handle distribution and discovery.
Tech-wise: everything runs as HTML5 in a native wrapper, so games are playable across iOS, Android, and web from a single build. The recommendation engine learns from high-frequency signals since short loops mean far more data points per session than traditional games.
We just came out of stealth with a $2M pre-seed from LVP and Sony Innovation Fund. Team is based in Hamburg, five people, currently building toward an invite-only Alpha.
Would love feedback from the HN community, especially from anyone building HTML5 games or working with AI game creation tools. What would make you want to publish on a platform like this?

value: Show HN: Minit Games, a feed-first platform for short-form HTML5 games

author: oleschaper


value: rmgn

value:
  Google Cloud Workflows has no official emulator. The dev cycle is: edit YAML, deploy to GCP, trigger, check logs. Repeat for every change.

  I built an open-source emulator in Go that runs locally:

    docker run -p 8787:8787 -p 8788:8788 \
      -v $(pwd)/workflows:/workflows \
      -e WORKFLOWS_DIR=/workflows \
      ghcr.io/lemonberrylabs/gcw-emulator:latest

  What it does:

  - Watches your workflow directory and hot-reloads on save
  - Full REST and gRPC API compatibility (same endpoints, same request/response format)
  - Workflow http.* steps call your local services — so you can run your entire orchestration stack on localhost
  - Parallel execution, subworkflows, try/except/retry, expression engine
  - Most of the standard library: http, sys, text, json, base64, math, list, map, time, uuid, events, retry
  - Built-in web UI at /ui for triggering executions and inspecting results
  - CI-friendly: set WORKFLOWS_EMULATOR_HOST=localhost:8787 in your test env

  What it doesn't do: googleapis.* connectors (mock them with local HTTP services), IAM/auth, Eventarc triggers, step-level execution
  history.

  Apache 2.0. Written in Go.

  GitHub: https://github.com/lemonberrylabs/gcw-emulator
  Docs: https://lemonberrylabs.github.io/gcw-emulator

value: Show HN: Local Emulator for Google Cloud Workflows

author: rmgn


value:
Hi HN — I built Lysium to reduce context-switching when working through GitHub issue/PR queues.
Lysium uses GitHub + the Devin API so you can route work to background agents and keep moving.
You can:

  • Swipe issues/PRs to close, merge, or skip
  • Launch implementation requests from issues/PRs or from a freeform Code tab
  • Run multiple agent sessions in parallel across repositories
  • Trigger one-click issue/PR assessments and PR reviews
  • Track progress in an Activity view split into Sessions and Actions

Try it: https://www.lysium.ai/
Code: https://github.com/dabit3/lysium
No email signup flow; full functionality requires GitHub OAuth plus a Devin API key + org ID.
I’d especially appreciate feedback on onboarding friction, general UX, and where agent automation should be explicit vs automatic.

value: Show HN: Lysium – cross-platform control plane for agentic software delivery


value:
Hi HN,
I built Gipity, an AI-native cloud computer that runs entirely in your browser.
https://gipity.ai
(free to try)
The original goal was a "hosted OpenClaw" - a chat-driven environment with persistent state and real infrastructure behind it. It has since expanded into something closer to a programmable cloud workspace.
It looks like a terminal (retro DOS style), but it is not just chat. It supports:
- Persistent files
- Programmable databases
- Agentic workflows and scheduled tasks
- Access to multiple top-tier AI models
- App creation and execution from chat
Demo video:
https://youtu.be/Nbs2jpG3iHA
In the demo video I show:
- Creating and editing a small web app
- Generating and adding sound effects
- Saving state to a database
- Setting up a daily automation
- Compiling and running a Win64 assembly binary
I am particularly interested in feedback on:
- Where this fits relative to tools like Replit or Lovable
- Whether "chat-first AI computer" makes sense as a framing?
- What would be required for you to actually use something like this
Happy to answer technical questions about architecture, isolation, storage, orchestration - or ServiceNow (where I currently work building their coding assistant) or my prior startups (started in 1998!).
-Steve

value: Show HN: Gipity – AI cloud computer in the browser


value: axadrn

value:
Hi HN,
I’m building two products for Go + templ developers:
goilerplate
- a Go boilerplate with auth, payments, email, blog/docs, SEO, and more
- https://goilerplate.com
templUI Pro
- premium UI blocks for Go + templ
- https://pro.templui.io
Both are one-time purchases with lifetime updates.
Would love feedback on positioning, packaging, and overall clarity.

value: Show HN: goilerplate and templUI Pro, two products for Go and templ developers

author: axadrn


value: rohansx

value:
I got tired of the git worktree workflow being broken by default — every new
worktree drops you into a directory with no .env, no node_modules, and you're
waiting on npm install before you can do anything.
workz fixes that automatically. It symlinks heavy directories (node_modules,
target, .venv) and copies .env files into every new worktree. Zero config — it
detects your project type from lockfiles.
But the thing I'm most excited about is fleet mode, added in v0.5:

  workz fleet start \
    --task "add user authentication" \
    --task "refactor the database layer" \
    --task "write integration tests" \
    --agent claude

That creates 3 isolated worktrees, syncs deps into each, writes a .workz-task.md
with the task description, and launches Claude in all three simultaneously. Each
agent works on its own branch with no interference.
v0.6 adds `workz serve` — a local web dashboard at localhost:7777 showing all
your worktrees as cards with status, last commit, actions (sync, open in
VS Code/Cursor, remove). Fleet worktrees get their own section showing the task.
v0.4 added an MCP server so Claude Code can manage worktrees autonomously:
  claude mcp add workz -- workz mcp
Stack: Rust, single binary, ~5MB. Ships for macOS and Linux.

  cargo install workz
  brew install rohansx/tap/workz

GitHub: https://github.com/rohansx/workz
Happy to answer questions about the architecture — the worktree + symlink
strategy and the MCP integration were the interesting design problems.

value: Show HN: Workz – run 5 AI agents on parallel Git worktrees with one command

author: rohansx


value: behrlich

value:
Code: https://github.com/ehrlich-b/punchcards
Just for fun, I've only spent a few hours on it so far. What are everyone's punch card emulation needs?

value: Show HN: Punch card simulator and Fortran IV interpreter

author: behrlich


value: kaliades

value:
I wanted to explore Valkey's vector search capabilities for AI workloads and had been looking for an excuse to build something with Bun. This weekend I combined both into a memory layer for Claude Code.
https://github.com/BetterDB-inc/memory
The problem: Claude Code has CLAUDE.md and auto memory, but it's flat text with no semantic retrieval. You end up repeating context, especially around things not to do.
BetterDB Memory hooks into Claude Code's lifecycle (SessionStart, PostToolUse, PreToolUse, Stop), summarizes each session, generates embeddings, and stores everything in Valkey using FT.SEARCH with HNSW. Next session, relevant memories surface automatically via vector similarity search.
The interesting technical bit is that Valkey handles all of it - vector search, hash storage for structured memory data, sorted sets for knowledge indexing, lists for compression queues. No separate vector database.
There's also an aging pipeline that applies exponential decay to old memories based on recency, clusters similar ones via cosine similarity, and merges them to keep the memory store from growing unbounded.
Self-hostable with Ollama for embeddings and summarization, or plug in any LLM provider. Runs on Bun, ships as compiled binaries. MIT licensed.

value: Show HN: Valkey-powered semantic memory for Claude Code sessions

author: kaliades


value: Serusk

value:
I want to present a new tool that allows you to deploy and run your own VPN server with just a few clicks on Windows, Linux, Android and iPhone/Mac.
No public IP or open ports are needed - both client and server use outgoing connections to bypass NAT/FW. This is handled with a relay server that forwards opaque, encrypted traffic.
WireGuard is used as VPN protocol (rust implementation). UI was done in Flutter and look the same across all OSs. The core logic in C++. It was quite fun to put all this together :).
The motivation for this project was the time, effort, and errors involved in deploying a VPN server whenever my colleagues or I did so. Also, all major VPN implementations lack clear error and status reporting.
We tried to address all this in qrvpn. You only need to create a username/password, click Start, and connect with the same app as the client, or with a native WireGuard VPN. Log messages are meaningful and status reporting is accurate.
The end result is somewhat similar to Tailscale/NetBird, but I believe it is faster and easier to deploy and use, especially for ad-hoc-like scenarios.
Screenshots/text and video instructions for your OS:
https://qrvpn.com/docs/
I would like to hear any feedback and feature requests!

value: Show HN: Qrvpn – deploy and run VPN server on any device and behind NAT/FW

author: Serusk


value: techsearcher

value:
Hey HN,
I’m conducting an experiment for certain models that I’m using often.
Here are the findings:
• Google Gemini 2.5 Flash: 595 ms avg
• Anthropic Claude Opus 4.6: 1887ms avg
• OpenAI GPT-4.1 Mini: 976 ms avg.
Planning quarterly deep-dive reports with P99 latency, TTFT, regional performance, and cost analysis for  potential weekly/monthly insight reports. Let me know what else can be improved. Thanks

value: Show HN: Independent monitoring of AI API reliability

author: techsearcher


value: digitalshepard

value: Show HN: Self-hosted AI agent observability (OTel, Grafana, bash hooks)

author: digitalshepard


value: Urbaneye

value:
Built this over a weekend as a public service when the US-Israel-Iran conflict broke out. Non-commercial, no
  ads, no paywall.

  What it does:
  - 25+ live TV channels (Al Jazeera, BBC, CNN, Reuters, etc.)
  - Battlespace map with verified strike markers (source-linked)
  - Live flight radar via adsb.lol
  - Naval vessel tracking (curated OSINT positions)
  - AI-curated conflict timeline (GPT-4o extracts events from 10 RSS feeds)
  - Reddit OSINT dispatches from r/worldnews, r/geopolitics
  - Emergency helplines for 12 countries
  - Timezone switcher (IST, Iran, Israel, Dubai, GMT, EST)

value: Show HN: War.direct – Real-time conflict intelligence dashboard for the Iran war

author: Urbaneye


value: Show HN: Ccbridge – A CLI to Orchestrate Claude Code and Codex


value: gtkacz

value:
Hey yall,
I wanted to share *smart-commit-rs*, a fast, lightweight cross-platform TUI I built to facilitate managing git commits, including generating messages via LLMs.
Here are some of the main features:
* *Convention following:* The tool by default will generate commit messaged according to the Conventional Commit standard, and optionally according to Gitmoji as well.
* *Extensive LLM Provider Support:* Built-in integration for Groq (default), OpenAI, Anthropic, Gemini, Grok, DeepSeek, OpenRouter, Mistral, Together, Fireworks, and Perplexity.
* *Customer LLM Support:* You can easily point it to a custom provider like a local Ollama instance using OpenAI-compatible endpoints.
* *LLM Presets:* You can save various provider presets, being able to freely switch between them. If your primary API throws an HTTP error, you can also configure a fallback rank so the tool automatically retries using the alternate LLM presets you've configured.
* *Diff Exclusion Globs:* You can exclude minified assets, `<i>.lock` files, PDFs, etc., from the LLM analysis to save tokens, while still officially committing them.
 *Advanced Git Tooling:* Message generation doesn't work just with commits. You can use `cgen alter <hash>` to rewrite a specific commit's message, `cgen undo` for a safe soft reset with Conventional Commit-compliant revert messages, or `cgen --tag` to automatically compute and create the next semantic version tag.
* *Commit Tracking:* It maintains a per-repository cache of managed commits, browsable via `cgen history` with native `git show` integration.
*A quick note on development:* While the project is rigorously human-reviewed and heavily backed by strict unit testing (matching CI coverage gates), a large portion of the boilerplate and core logic was written using agentic AI.
You can grab it via Cargo (`cargo install auto-commit-rs`) or via the curl/PowerShell install scripts in the repo: https://github.com/gtkacz/smart-commit-rs
Any feedback or contribution is more than welcome, and GitHub stars are greatly appreciated.
Thank you for your time!

value: Show HN: Smart-commit-rs – A zero-dependency Git commit tool in Rust

author: gtkacz


value: switz

value:
Hey HN,
I just released v4 of my gapless playback library that I first built in 2017 for https://relisten.net. We stream concert recordings, where gapless playback is paramount.
It's built from scratch, backed by a rigid state machine (the sole dependency is xstate) and is already running in production over at Relisten.
The way it works is by preloading future tracks as raw buffers and scheduling them via the web audio API. It seamlessly transitions between HTML5 and web audio. We've used this technique for the last 9 years and it works fairly well. Occasionally it will blip slightly from HTML5->web audio, but there's not much to be done to avoid that (just when to do it - lotta nuance here). Once you get on web audio, everything should be clean.
Unfortunately web audio support still lacks on mobile, in which case you can just disable web audio and it'll fallback to full HTML5 playback (sans gapless). But if you drive a largely desktop experience, this is fine. On mobile, most people use our native app.
You can view a demo of the project at https://gapless.saewitz.com - just click on "Scarlet Begonias", seek halfway in the track (as it won't preload until >15s) and wait for "decoding" on "Fire on the Mountain" to switch to "ready". Then tap "skip to -2s and hear the buttery smooth segue.

value: Show HN: Gapless.js – gapless web audio playback

author: switz


value: chrillemn

value:
Hey everyone,
How do you handle license risk in projects with a lot of dependencies?
Do you check licenses before installing packages, or only later when it becomes a problem?
I built this tool because I wanted a quick overview of what I had actually pulled into one of my projects. It turned out one dependency was AGPL-3.0, which would have required me to open source the entire project if distributed.
That wasn’t my intention, so I replaced it with an alternative. But it made me realize how easy it is to accidentally introduce strong copyleft licenses without noticing.
Do you actively monitor dependency licenses, or is it something you only think about when legal/security gets involved?

value: Show HN: license checker for npm projects

author: chrillemn


value:
I got tired of watching Claude Code read entire files when it needed one function. Built an MCP server that pre-computes a dependency graph with tree-sitter and serves only the relevant code nodes to the agent.
Ran a proper benchmark to see if it actually matters.
Setup: FastAPI codebase (800 Python files), Claude Sonnet 4.6, 7 tasks (bug fixes, features, refactors, code understanding), 3 runs per task per arm, 42 total executions. Both arms run in full isolation with --strict-mcp-config. Results collected via headless claude -p with --output-format stream-json.
Results:

  Cost per task:  $0.78 → $0.33  (-58%)
  Duration:       170s → 132s    (-22%)
  Output tokens:  504 → 189      (-63%)

Savings by task type:

  Code understanding:  -57%
  New features:        -53%
  Refactoring:         -48%
  Bug fixes:           -29%

The pattern: baseline Claude makes ~15 Read + 4 Grep + 4 Glob calls per task, accumulating context incrementally. With the graph, it averages 2.3 run_pipeline calls that return pre-ranked context in one shot. Less cache creation, fewer round trips, and the agent writes more concise responses because it already has the right context.
Code understanding benefits the most because that's where the agent spends the most tool calls exploring. Bug fixes benefit the least because the scope is usually narrow enough that a few Read calls get you there anyway.
The graph is built with tree-sitter (functions, classes, types, imports, call references), stored in SQLite, updated incrementally on file save. Also does cross-session memory — observations linked to graph nodes, auto-flagged stale when the code changes.
Single Rust binary, everything local, zero network calls except an optional license check.
https://vexp.dev — free tier, no account needed.
Happy to answer questions about the approach, the benchmark setup, or where it breaks down.

value: Show HN: 58% cost by replacing file reads with a dependency graph on AI Coding


value: pikkoloassembly

value: Show HN: Know Your SMD Footprints

author: pikkoloassembly

title: Show HN: Know Your SMD Footprints


value: Show HN: memgraph-agent – Graph-powered memory for AI agents (NER + PageRank, zero LLM cost)

value: Show HN: Memgraph-agent – NER+PageRank memory for AI agents, $0 LLM cost


value: Show HN: PEP 827 – TS-like type manipulation in Python


value: Ndmtrieff

value: Show HN: Built lovable but for your existing products

author: Ndmtrieff


value: yevbar

value:
If you'd like to learn about what Elixir and WebAssembly are or why even integrate the two together, check out this blog post https://yev.bar/firebird
And, of course, here's the GitHub https://github.com/hdresearch/firebird
I also posted a thread to Twitter where I ship nifty stuff if fun uses of technology is interesting to you https://x.com/itisyev/status/2028543436388016510

value: Show HN: I spent a billion tokens and all I got was this repo

author: yevbar


value:
If you'd like to learn about how I corralled the agents to do this, check out this blog post https://vers.sh/blog/elixir-webassembly-billion-tokens
And, of course, here's the GitHub https://github.com/hdresearch/firebird
I also posted a thread to Twitter where I ship nifty stuff if fun uses of technology is interesting to you https://x.com/itisyev/status/2028543436388016510

value: Show HN: I spent a billion tokens bridging Elixir and WebAssembly


value: Show HN: CTORank – Recruit Engineering Leaders (CTOs, VPS, Directors)


value: rchaz

value:
I've been running multiple AI coding agents in parallel on the same repo. The agents code fine. The problem is managing multiple parallel sessions with git. Multiple agents, one branch, one overwrites the other.
Git worktrees give isolation but the per-session setup/teardown doesn't scale.
GitButler looked promising but testing each agent's changes in isolation was tedious.
Neither was built for this workflow.
git-stint automates the full lifecycle. Each agent session gets its own branch and worktree automatically. WIP auto-commits on exit or crash. Full diff, squash, and PR workflow for review. Conflicts caught before merge. Main stays clean.
Zero runtime deps. npm install -g git-stint. Built for Claude Code's hook system but works with any AI tool that writes to a git repo.
Been using it daily across my own projects. Would love feedback on the approach.

value: Show HN: Git-stint – Built for AI coding agents to multitask without collisions

author: rchaz


value: jademind

value: Show HN: PiPulse – iOS App to remote control your pi.dev agents

author: jademind


value: mistyshadow

value:
Hi HN,
I built a small privacy-focused web app called ChatOffRecord.
It creates temporary anonymous chatrooms that automatically self-destruct in 10 minutes.
No accounts, no logs, no database of messages — everything is kept in memory and disappears when the room expires. The idea is to provide a simple way to have an off-the-record conversation with someone without needing a login or installing anything.
Core features:
- Create an anonymous chatroom in one click
- No sign-up or personal data
- No persistent storage of messages
- Rooms auto-delete in 10 minutes
- Invite by sharing the URL
I also added an optional one-time $2.99 upgrade that creates a permanent private room with a custom link. Messages in those rooms are still ephemeral (no storage), but the URL never expires.
Would love feedback — especially around security assumptions, UX flows, and any edge cases you think I should consider. This is my first attempt at building an ephemeral WebSocket-based chat system with strict no-storage rules.
Live site: https://chatoffrecord.com
(You can test everything directly, including free rooms.)

value: Show HN: ChatOffRecord – Anonymous chatrooms that self-destruct in 10 minutes

author: mistyshadow


value: andrew-alt

value: Show HN: Nanograph – On-Device GraphDB for Agents

author: andrew-alt


value: deckardt

value: A little weekend project with my daughter to show her what computers can do and as an added bonus, help her practice this schoolyard finger counting game.

value: Show HN: Super Chopsticks – Finger Counting Game

author: deckardt


value: tugaypala

value: Show HN: ImagineIf – Collaborative storytelling with AI visuals in 22 languages

author: tugaypala


value: memly

value: Show HN: MemlyBook – Real autonomous agent experiment with games & sports bet

author: memly


value: junianwoo

value:
Smidge (smdg.app) takes source material and produces production-ready skills compatible with the open Agent Skills spec. Works with Claude, Cursor, Copilot, and 30+ AI agents.
The core idea: your agents should have the same expertise you do, without you manually writing SKILL.md files.
How it works:
Drop source material (YouTube, PDFs, audio, docs, slides, up to 50MB each, multiple sources at once)
Source-aware extraction: transcripts get distilled, papers keep structure, slides get expanded
Automatic skill catalogues: a textbook or manual becomes multiple focused, topic-specific skills
Every skill validated against the Agent Skills spec
Download individual skills or full catalogues
CLI:
npm i -g smdg-cli
smdg generate --source ./docs/brand-guide.pdf
Tech: Next.js, Supabase (Postgres + Auth + Storage), Claude API for extraction, Stripe for payments.
Two free generations. Credit packs start at $9 for 5 skills. $19/mo unlimited.
I built this because I wanted my coding agents to have domain expertise from my existing materials. The extraction engine is source-aware: it adjusts its strategy based on whether it's processing a transcript, an academic paper, a framework doc, or a slide deck. For large inputs, it automatically detects distinct topics and produces a catalogue of focused skills instead of one monolithic file.
Happy to answer technical questions about the extraction pipeline or the Agent Skills spec.

value: Show HN: Smidge. Turn expert knowledge into agent intelligence

author: junianwoo


value: tracyspacy

value:
I'm building a tiny embeddable VM in Rust, where the core primitive is a Task with its own state and executable bytecode instructions.
Recently I added new example: Implementation of Binary Coded Decimal decoder from Petzold's "Code" book — every logic gate (bits switch, inverters, AND gates) is a task carrying its own instructions.
It works simple : cargo run 1001  -> 9 and as output it will show AND gate with inputs and output
bcd-decoder: https://github.com/tracyspacy/spacydo/tree/main/examples/bcd-decoder

value: Show HN:Logic gates as persistent stateful tasks – a BCD decoder built on a VM

author: tracyspacy


value: spliffedr

value: Show HN: CodecProbe – What your device says it can play vs. what it can

author: spliffedr


value: rishi-hn

value:
Hi HN,
I built vim-claude-code, a Vim/Neovim plugin that integrates Claude CLI directly into the editor to enable AI-assisted development workflows without leaving Vim.
The goal was not to build “chat inside Vim,” but to enhance real workflows developers already use.
Current features:
Generate and improve Git commit messages from diffs
Refactor selected code
Generate tests
Summarize code blocks
Send visual selections directly to Claude
Terminal-based integration (no background daemons)
Technically, the plugin follows standard Vim plugin architecture:
Lightweight plugin/ bootstrap
Lazy-loaded autoload/ modules
Modular command dispatcher
Terminal bridge to Claude CLI
Configurable keymaps
Separation of Git, workflow, and terminal logic
It works with both Vim and Neovim.
I’d appreciate feedback from the Vim community — especially around workflow improvements and architecture decisions.
Repo:
https://github.com/rishi-opensource/vim-claude-code
Happy to answer questions.

value: Show HN: Vim-Claude-code – Claude CLI integration for AI workflows inside Vim

author: rishi-hn


value: gingerol

value: Show HN: SpacerMint – iPhone storage cleanup that never touches the cloud

author: gingerol


value: bonjourjoel

value:
I built a review-first AI copilot for VS Code that enforces structured specs and lets you review every patch before it touches your repo.
Demo (1 min): https://youtu.be/E7XcQx2j6Do
Would love feedback from developers on this approach.

value: Show HN: VS Code AI copilot that catches mistakes before they break your code

author: bonjourjoel


value: raykamp

value:
I’ve been running parallel Claude Code instances while working on different tasks. Two problems kept slowing me down:

  1. I was constantly jumping between terminals to see which session needed input.

  2. Using git worktrees added setup friction (installing deps, bootstrapping environments, etc.), which discouraged parallel work.

So I built ccmux.
It’s a thin layer on top of tmux that:

  - Adds a glanceable sidebar UI showing all Claude Code sessions

  - Surfaces attention-needed states with visible alerts

  - Wraps git worktrees with a lightweight workflow abstraction so spinning up parallel tasks feels cheap

Technical details:

  - tmux provides the pane/session orchestration

  - The sidebar is built with Python’s Textual (rich TUI)

  - Each Claude Code session runs as a window in a nested tmux session.

I now use it daily to juggle multiple AI coding sessions without losing context. Happy to answer questions or dive into implementation details.

value: Show HN: Ccmux – Reduce context switching for parallel Claude Code sessions

author: raykamp


value: shraiwi

value:
A filter list for uBO that blurs all video and non-follower content from Instagram. Works on mobile with uBO Lite.
related: https://news.ycombinator.com/item?id=47016443

value: Show HN: uBlock filter list to blur all Instagram Reels

author: shraiwi


value:
I built a small WebGPU library that gives you a NumPy-like API in the browser—arrays, matmul, softmax, that kind of thing. No shaders to write, no TensorFlow.js. Just `gpu.array([1,2,3])` and `await a.add(b)`.
It falls back to WebGL2 when WebGPU isn't available (Safari, Firefox) and to CPU for Node/headless. Same API everywhere. ~160KB minified, zero dependencies.
The shaders are pre-built WGSL—add, mul, relu, layer norm, attention scores, etc. I added FFT and spectrogram recently, plus conv2d and pooling (CPU for now). Reductions like sum/max use multi-pass since you can't fit 1M elements in one workgroup.
Demos: [phantasm0009.github.io/accel-gpu](https://phantasm0009.github.io/accel-gpu/) — basic math, image processing, heatmap, neural net inference, N-body sim. Would love feedback.
GitHub: [github.com/Phantasm0009/accel-gpu](https://github.com/Phantasm0009/accel-gpu)

value: Show HN: Accel-GPU – NumPy for the browser GPU


value: Show HN: Watchtower – see every API call Claude Code and Codex CLI make


value: piotrzientara

value: Show HN: MarketClaw – A minimalist protocol for Agent-to-Agent labor trade

author: piotrzientara


value: FanaHOVA

value:
About 6 years ago I wrote a blog post [0] with some ideas on how to help popular open source maintainers deal with  all the noise on Github. Patted myself in the back and never did anything about it :)
There's recently been a lot more discussion around this due to AI, so I've built a simple tool called "Slop Meter" [1]. It gives maintainers a quick snapshot of the user's history in open source:
1) Do they just open issues and expect you to do everything, or will they put in the work  to fix the problems and open a PR? What's the issues : PR ratio?
2) If they do contribute, what percentage of their PRs actually gets merged?
I feel like these are the two most important signals when triaging what to pay attention to in open source.
You can install this on any Github repo and it will automatically post a comment with the stats. We do not run this on maintainers or existing contributors.
You can also go on the web and look up a Github profile; it will take a minute or so to import depending on how much public data they have (maybe longer if this makes the front page...).
Example profile: https://slopmeter.kernellabs.ai/u/mitchellh
If you are an OSS maintainer, I'd love to hear any feedback.
[0] https://www.alessiofanelli.com/posts/how-can-we-help-oss-mai...
[1] https://slopmeter.kernellabs.ai/

value: Show HN: Slop Meter for GitHub

author: FanaHOVA

title: Show HN: Slop Meter for GitHub


value: Show HN: Free Topical Authority Map Generator


value:
aft was my stab at having a way to understand what claude is doing and also having the language to reason about differences in model behavior when we make them do long agentic runs / change prompts / alter tools etc. The intention of the toolkit to provide an empirical measure of how agent behavior can differ as things changes like environments, tools, prompts etc.
It gives the tools to measure the changes in "behaviors that the users define". This means that it is more like a hypothesis testing framework for what the agent is doing over actually telling what the agent might do.
The reasoning and derivations behind these tools is given over here https://technoyoda.github.io/agent-science.html
Would be very happy to hear feedback and questions. (Please ignore the names given to theorization, it was for shits and giggles)

value: Show HN: Aft, a Python toolkit to study agent behavior


value: ssistilli

value:
Hey HN – I built Nightmarket because I kept running into the same problem building AI agents: every time my agent needed a new capability (weather data, enrichment, web scraping, whatever), I had to go sign up for a service, grab an API key, store it, figure out billing, and wire it all together. Multiply that by 10 services and it's a mess. Agents can't sign up for accounts. They can't enter credit cards. They can't manage API keys. But they can hold a USDC balance and pay per request.
Nightmarket is a marketplace where AI agents discover and pay for API services on-chain. No accounts, no API keys, no subscriptions. Your agent pays per call in USDC via x402.
How it works:
Browse the marketplace — each service shows pricing, live usage stats, and docs
Give your agent the Nightmarket skill (one line in your system prompt, or npx skills add Fallomai/skills --skill nightmarket)
Your agent discovers, calls, and pays for services automatically. USDC settles on Base per request.
The whole flow: Agent → discover → call → pay → 200 OK
One integration unlocks every service on the marketplace. Your agent doesn't need a separate key for each provider — it just pays and gets data.
For sellers: list your API, set a per-call price, and go live immediately. No approval process. Agents start calling as soon as you're listed. You get paid in USDC. Every listing shows live call volume and revenue so buyers can pick providers with proven track records.
What makes this different from existing API marketplaces: RapidAPI and friends are built for humans with credit cards. Nightmarket is built for agents with wallets. The x402 protocol (HTTP 402 "Payment Required") means payment is native to the HTTP request itself — no webhooks, no billing dashboards, no invoices. An agent hits an endpoint, gets a 402, pays, retries, gets data. One round trip.
We're live at https://nightmarket.ai — you can browse services now and plug the skill into any agent (Claude, GPT, open-source, whatever).
Curious to hear from HN:
API providers: would you list your service? What's stopping you from monetizing to agents today?
Agent builders: what APIs do you wish your agents could just pay for and use without the signup/key dance?
Anyone: poke holes in the model — what breaks when agents are the primary buyer?

value: Show HN: Nightmarket – API marketplace where AI agents pay per call in USDC

author: ssistilli


value: manikmakki

value:
Hey HN! I'm building a deceptively simple chat application fronting a local LLM (Ollama or any OpenAI compatible API). TamAGI is the culmination of about 6 months worth of scattered thoughts and incredibly frustrating code sessions (I _suck_ at Python). With OpenClaw's release, I had the "Aha" moment I was looking for and used Claude Code to help fill in the gaps (to be frank, quite a lot of gaps) and make this project a reality.
The TLDR: TamAGI is a virtual agent, in the spirit of Tamagotchis. Where it differs is developing a personality and growing as an "entity" the more you interact with it. It ships with a hand full of tool calls out of the box, and has an extensible framework for the Agent to create its own tools. Memory is handled by ChromaDB with RAG providing context injection via system prompt dynamically. It supports only a single user currently, but has optional authentication for client-server use on bare metal or in containers.
I'm quite happy with how it is shaping up, and I'm looking for any feedback to drive the next iteration. Thank you for looking!

value: Show HN: TamAGI – A local-first virtual agent that lives on your machine

author: manikmakki


value: Show HN: GitHub Action that diagnoses CI failures with Claude AI


value: oknoorap

value: Show HN: Writing App for Novelist

author: oknoorap

title: Show HN: Writing App for Novelist


value: reevio

value:
Game: A blackjack game where the dealer commentary is openly contemptuous of everyone at the table. Daily leaderboard with 21 hand limit.
Maker: Former online gambling product manager, now working in a big corporate.
Large backlog of unsuccessful side projects that were great fun to work on :)

value: Show HN: Blackjack Smack Game

author: reevio

title: Show HN: Blackjack Smack Game


value:
Hey HN – I've been building in the agent payments space for a while and the biggest bottleneck I see isn't the protocol (x402 is great) — it's that most API providers have no idea how to actually integrate it. The docs exist, the middleware exists, but going from "I have a REST API" to "agents can discover and pay for my endpoints" still takes way more work than it should.
CrowPay fixes that. We integrate x402 payment headers into your existing API and configure USDC settlement on Base. You go from zero to agent-accessible in days, not months.
How it works:
You have an existing API (Express, Next.js, Cloudflare Workers, any HTTP server)
We add x402 payment capability — your endpoints return 402 with payment instructions, agents pay in USDC and get access
USDC settles to your wallet on Base. You get a dashboard with real-time analytics on agent payment volume.
That's it. You don't have to learn how x402 works under the hood, run blockchain infra, or change your API architecture.
Why this matters now: There are over 72,000 AI agents paying for services via x402, with $600M+ in annualized volume across 960+ live endpoints. Stripe just added x402 support. CoinGecko is charging agents $0.01/request. This is going from experiment to real money fast — and most API providers are leaving it on the table because the integration is still too annoying.
The agent-side story: We also handle wallet creation and spending budgets for agent builders. If you're building agents that need to pay for things, Crow lets you create a wallet, fund it, set spending limits, and let your agent loose. The agent gets a budget, and you don't wake up to a surprise $10k bill.
What I'd love to hear:
What's keeping you from adding agent payments today?
Is it technical complexity, uncertainty about demand, or something else?
Agent builders: how do you handle spending controls? Is "agent gets a wallet with a budget" the right abstraction?

value: Show HN: CrowPay – add x402 in a few lines, let AI agents pay per request


value: Swayworn

value:
If you come to my house for dinner, there is a non-zero chance I will try to get you to play my favorite party game: Eat Poop, You Cat! (aka Telephone Pictionary aka Telestrations aka Broken Picture Phone)
You've probably played it: The first player comes up with a sentence. The second player draws a picture of the sentence. The third player writes a sentence describing the picture, and so on. After all players have contributed, the full sequence is revealed.
Are there existing online implementations? Of course. But:
- They all expect you to fingerpaint on your phone. It's hard to make great art that way! ExMo does have a drawing tool (it's expected), but players are encouraged to create their art however they like (past media include paper & pen, SculptrVR, collage, diorama, and Procreate) and upload a picture.
- The best way to play is at a party with your friends, with each player writing a starting sentence on a piece of paper and then they all get passed around. Party Mode captures that experience (and is therefore the second-best way).
Stack: SvelteKit/TS, Supabase for database and file storage, Clerk for auth. I was using BullMQ for background jobs, but switched to just leaning on the database for a simpler stack. I used server-side events for notifications, but that meant keeping Vercel running constantly which is unnecessarily expensive; polling does the trick.
Code is cheap these days, so it's open source (see footer). Happy to discuss any of it.

value: Show HN: Exquisite.Monster – Telephone Pictionary with strangers and friends

author: Swayworn


value: ismailperim

value:
Hey HN! I built this because I got tired of waking up to read Docker logs.
OnCallMate is an autonomous AI agent that:
- Monitors your Docker containers (proactive scheduler)
- Detects anomalies (crashes, OOM, restarts)
- Autonomously investigates using OpenAI function calling
- Performs RCA and suggests fixes
Example workflow:
User: "any issues?"
→ AI calls docker_list, docker_inspect (4x), docker_stats (3x), docker_logs
→ Returns: " CRITICAL nginx - OOMKilled. Memory hit 512MB limit.
   Recommend: docker update --memory=1g nginx"
Security-first design:
- not SaaS/self-hosted
- Docker socket proxy (read-only by default, no direct socket exposure)
- Admin-only access (Telegram ID allowlist)
AI provider options:
- OpenAI/Claude API (you choose what to send)
- OpenRouter free tier (cost-effective)
- Bring your own model (extensible architecture)
Built in 3 days using:
- OpenAI function calling (multi-turn tool loops)
- Universal tool architecture (Docker now, K8s and cloud providers later)
- TypeScript + Dockerode + Telegram (Slack etc. later)
Open source (MIT), runs entirely in your network.
GitHub: https://github.com/ismailperim/oncallmate
What features would make this more useful for you?

value: Show HN: OnCallMate – AI agent for autonomous Docker incident RCA

author: ismailperim


value: kbrkbr

value:
This field guide grew out of a longer essay I wrote on questioning and stories. I was trying to understand how questioning actually works in practice, and whether there is a minimal structure behind it.
Most material I found focuses on techniques or interview tactics, or is very abstract like the Erotetics literature. I was more interested in understanding the parts and how they work together.
Questioning seems to be an underrated skill in incident investigations, debugging, and project clarification.
I tried to compress what I found into a single visual model.
The diagram reduces inquiry to a few simple moves:
- Track nouns, verbs, qualifiers, time and place
- Move in phases: overview => details => loose ends
- Use question types and tools appropriate to the goal of each phase
It is intentionally small and easy to remember.
It will not make anyone a brilliant interrogator, but it provides a minimal structure when you would otherwise improvise. It might be helpful to practitioners.
I would be interested in critical feedback, especially from people who use structured questioning in technical or investigative work.

value: Show HN: A One-Page Field Guide to Questioning

author: kbrkbr


value: faizanbhat

value: I've been using Claude Code extensively for PM work. I've built a set of workflows that help with common problems e.g. breaking down problems, simulating brainstorms, grouping ideas into themes, stress testing decisions and theses, etc.

value: Show HN: Goodthinking – PM skills for Claude Code

author: faizanbhat


value: tristanMatthias

value:
Hey HN!
I found myself constantly needing to pass complex codebases to LLMs for things like PRD generation, etc. Every time I paste a codebase into Claude I pay tokens for files the model doesn't care about. But if I only paste the relevant files, the model loses context about how everything fits together. It's an annoying tradeoff.
llmdoc is a small CLI that adds short LLM summaries for each file and intelligently updates them when the hash changes.
llmdoc annotate # Adds summaries for each file (respects .gitignore and you can configure it to ignore more)
llmdoc dump # Generates a handy "at a glance" summary to give to an LLM for complete context of your codebase.
There's also llmdoc check for CI — exits 1 if any annotation is stale or missing, no API key needed.
It supports Anthropic and OpenAI, works with 50+ languages, respects .gitignore, and has a --dry-run flag that estimates cost before touching anything.
A known issue is rate limiting for LLM providers, but because it all works with hashes, you can just rerun a few times to get it working.
Let me know what you think!

value: Show HN: Llmdoc – annotate codebase with LLM summaries only re-scan what changed

author: tristanMatthias


value: Show HN: DevToolKit – Free, Client-Side Dev Tools (Chmod, Cron, Docker Compose)


value: vustagc

value: A little weekend project, made so I can pause/play/rewind directly on the piano, when learning a song by ear.

value: Show HN: Pianoterm – Run shell commands from your Piano. A Linux CLI tool

author: vustagc


value: Convia

value: Show HN: Argus – A reproducible validation protocol for ML workloads (Free)

author: Convia


value: pranavchahal

value:
Hi HN, I’m Pranav (founder). I design hardware and kept seeing a weird split:
Engineers don’t trust AI to design full PCBs (hidden assumptions, stackups, manufacturing constraints, EMI/return paths, and the cost of being even slightly wrong - why tools like Flux still aren’t widely trusted for full designs).
But customers keep asking ChatGPT to “review” boards. They paste screenshots/Gerbers and expect a real sign-off. It often sounds right, but it can hallucinate or miss what actually causes respins.
Lesson building this: the hard part isn’t more AI, it’s deterministic, reproducible detection with explicit assumptions, with AI only to explain findings and suggest fixes.
Would love critique: what’s worth catching pre-fab, what’s too noisy, and what would make you trust this as a release gate.

value: Show HN: BoardMint – upload a PCB, get a standards-backed issue report in ~30s

author: pranavchahal


value: vcodes

value:
I posted logcat.ai here several months ago when it was mostly an idea.
Since then I left my job and have been building full-time. 400+ organic signups, paying customers across telecom, automotive, and device management. Time for a proper Show HN.
The problem:
I've spent 13 years in Android OS internals (AOSP, LineageOS, founding engineer at Esper) and the debugging workflow has never meaningfully improved. You get a 100MB bugreport zip with 20+ files and spend hours ctrl+F'ing timestamps trying to correlate logcat with kernel logs with dumpsys with radio logs. Telecom engineers have it worse because they're also juggling QXDM modem traces. Automotive teams pile VHAL and CAN bus on top of all that.
What logcat.ai does:
Upload the files you already have and get a root cause analysis with a correlated timeline across layers (app, framework, HAL, kernel, modem). No SDK, no agents, nothing to install.
How people actually use it:
Telecom engineer uploads modem traces alongside a bugreport to figure out why VoLTE calls drop during handovers.
MDM company uploads bugreports from fleet devices to triage field issues without reproducing them.
Delta mode: upload two bugreports (working vs broken), get a structured diff of what changed without all the noise.
Deep Research: autonomous multi-pass investigation that follows causal chains across log sources.
What's interesting technically:
The hard part is preprocessing. A 200MB bugreport needs heavy denoising and intelligent chunking before an LLM can reason over it. Every other log type comes with its own challenges and then there is a mix of all of them. We use AI for human readable representation of the analysis and interaction. Currently supports bugreports, logcat, dmesg, tombstones, ANR traces, modem log exports from QXDM/QCAT or Mediatek's/Samsung's modem log outputs.

value: Show HN: Logcat.ai – Observability for Android, Telecom, Automotive System Logs

author: vcodes


value: simonij

value:
Hey HN! I built Flowly, a macOS utility that brings smooth, fluid scrolling to any external mouse.
If you've ever used a third-party mouse on Mac, you know the pain. macOS gives trackpads beautiful inertial scrolling, but external mice get choppy/laggy, line-by-line movement. Flowly fixes this by intercepting scroll events and applying smoothing to create natural, fluid motion across every app.
· Works system-wide with any mouse (Logitech, Razer, etc.) · Per-app control: enable/disable smoothing per application · Customizable smoothness and speed · Lightweight: <1% CPU, ~20MB memory · macOS 12+ (Monterey through Sequoia)
Would love to hear your feedback! This is my first MacOS app also
https://flowlyapp.dev

value: Show HN: Flowly – a macOS app that brings smooth, fluid scrolling to any mouse

author: simonij


value: smalltorch

value:
ED is a new way to protect your messages in a old way.
The typical codebook comes with many challenges. They are hard to transport, hard to update, distribute. They do have one solid feature however. If the codebook can be kept secret, it will not be broken with compute.
ED attempts to solve these issues.
The words database included in the repo is a collection of over 2million common words, phrases, people, places and things. Each entry is tied to a unique string of numbers. To generate a 'key' we simply shuffle the map using secrets.randbelow() function. This is important as it's using device level entropy. Each entry reaches the 2million+! Permutation equally.
The combination of shuffles is now considered your key. This is what you can share with Bob.
Because each entry has multiple entries, based on how common a word or phrase is. You can send the same exact message many times without it ever repeating.
Alice and Bob can also generate long term keys that can be rotated. This comes at the cost of key size, but a 365 day key schedule is still only around 4gb.
Because of the ability to compress a long phrase into a single entry, this codebook shrinks the data efficiently.
Once the two ends are established, you should be able to privately communicate over any channel, including public channels.
Example Gallery: https://postimg.cc/gallery/Gs23JQW

value: Show HN: Ed – A modern take on ancient codebook technology

author: smalltorch


value:
Hi HN,
My team and I (a group of independent music artists and developers) have been building IndieMe, an AI system that helps artists define their identity while planning releases.
A pattern we kept seeing in independent music is that artists don’t necessarily struggle with making songs. They struggle with clarity — who they are, what they stand for, what their visual world looks like, and who they’re actually speaking to. Without that foundation, release marketing tends to feel scattered.
So we built a structured onboarding workflow that models an “Artist Profile” first — including target audience, visual direction, color palette, narrative positioning, and messaging backbone. From that profile, the system generates release strategies, content ideas, and actionable timelines that stay consistent with the artist’s identity.
Under the hood, we focus on structured outputs instead of open-ended chat. The goal is to generate modular, editable building blocks (identity system → strategy modules → task plan) rather than walls of AI text.
We’re officially launching now with a free tier and Pro subscription, and are actively testing whether artists are willing to pay for identity-first strategy tooling.
Would really appreciate feedback — especially from:
- indie musicians
- people building AI-native SaaS
- anyone thinking about identity modeling/content planning for creators
Happy to answer questions.
https://indie-me.ai
— Jason

value: Show HN: IndieMe – AI for music artist brand identity and release strategy


value: rayediaz

value: Show HN: I built an AI sound effects generator for game devs

author: rayediaz


value: nicktikhonov

value:
I built a voice agent from scratch that averages ~400ms end-to-end latency (phone stop → first syllable). That’s with full STT → LLM → TTS in the loop, clean barge-ins, and no precomputed responses.
What moved the needle:
Voice is a turn-taking problem, not a transcription problem. VAD alone fails; you need semantic end-of-turn detection.
The system reduces to one loop: speaking vs listening. The two transitions - cancel instantly on barge-in, respond instantly on end-of-turn - define the experience.
STT → LLM → TTS must stream. Sequential pipelines are dead on arrival for natural conversation.
TTFT dominates everything. In voice, the first token is the critical path. Groq’s ~80ms TTFT was the single biggest win.
Geography matters more than prompts. Colocate everything or you lose before you start.
GitHub Repo:
https://github.com/NickTikhonov/shuo
Follow whatever I next tinker with: https://x.com/nick_tikhonov

value: Show HN: I built a sub-500ms latency voice agent from scratch

author: nicktikhonov


value:
I built this to compress the jump from messy ideas to engineer-ready specs.
It takes raw inputs — docs, transcripts, brainstorm notes — and it asks the questions necessary to turn ambiguity into a PRD engineers can actually scope against.
The end result is a structured PRD with feature, milestones, budgets, tech stack, and open questions that's easily shareable to wherever you go to get your software built.

value: Show HN: PRD Agent – Turn your app idea into a shareable RPD in minutes


value:
Every agent framework gives you logs(each its own flavour of logs). Unstructured text. Maybe some spans if you're lucky. When your agent breaks something, you get to grep through a wall of output in some proprietery system.
Why can't i easily see what the agent did to produce the PR? why can't i restart a different agent from a state?
I got tired of this. agd is a content-addressed object store and causal DAG for recording agent behavior.
It works like git (blobs, trees, refs, immutable objects identified by hash), but the object types are specific to LLM interactions: messages with typed content parts, tool definitions, and workspace snapshots that form a causal graph.
The core idea is stolen from git: the data model is the API. You interact with objects directly. Everything is immutable, everything has a hash.
An "action" in the DAG records: what messages the agent saw (observed state), what it produced (produced state), which tools were available, which model was used, and what caused it (parent actions).
Two states per action, both full snapshots, not deltas. You diff them to see what changed.
What you get:
- agd log --session s1 shows one conversation's full causal chain
- agd show <action> --produced --expand shows the exact prompt and tool calls
- agd diff between two actions compares messages and workspace files
- agd rewind moves a session back to a previous point (old actions stay in the store)
- agd replay reconstructs the exact input state and reruns an action
It integrates as middleware/plugin. Wraps your existing LLM calls, records before/after state, doesn't require rewriting your agent code. The session ref (like a git branch pointer) auto-advances on each action, so parent tracking is a single ref read.
Written in Zig. Most of the code was written with heavy AI assistance. The store is append-only loose files, like git's object directory. Write path targets low single-digit ms per action with batched fsync. Sessions can be bundled and published to a remote for sharing and viewing(working on a POC of this, have some core questions)
This is pre-alpha. The object model and write path work. Workspace capture, session sharing, and a Phoenix LiveView web viewer are functional.
Plenty is still missing: resume-from-any-point, proper diffing, the replay command. The on-disk format will probably change. I wouldn't depend on it for anything you care about yet.
What it does not do: orchestrate agents, make agents smarter, stream in real time, or replace your framework.
Looking for feedback, thoughts, contributors
Repo: https://github.com/frontman-ai/agd

value: Show HN: Agd – a content-addressed DAG for tracking what AI agents do


value: lgdimaggio

value: Show HN: I used an IoT sensor and Claude to diagnose a hairdryer

author: lgdimaggio


value: Show HN: Synapse – P2P AI agent collaboration with async human supervision


value: fuelingcurious

value:
Hi HN,
I’m a chemical engineer and I manage logistics at a refinery down in Texas. Whenever I try to explain downstream operations to people outside the industry (including my kids), I usually get blank stares. I wanted to build something that visualizes the concepts and chemistry of a plant without completely dumbing down the science, so I put together this 5-minute browser game.
I am not a software developer by trade, so I relied heavily on LLMs (Claude, Copilot, Gemini) to help write the code. What started as a simple concept turned into a 9,000-line single-page app built with vanilla HTML, CSS, and JavaScript. I used Matter.js for the 2D physics minigames.
A few technical takeaways from building this as a non-dev:
 * Managing the LLM workflow: Once the script.js file got large, letting the models output full file rewrites was a disaster (truncations, hallucinations, invisible curly-quote replacements that broke the JS). I started forcing them to act like patch files, strictly outputting "Find this exact block" and "Replace with this exact block." This was the only way to maintain improvements without breaking existing logic.
* Mapping physics to CSS: I wanted the minigames to visually sit inside circular CSS containers (border-radius: 50%). Matter.js doesn't natively care about your CSS. Getting the rigid body physics to respect a dynamic, responsive DOM boundary across different screen sizes required running an elliptical boundary equation (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry) > 1 on every single frame. Maybe this was overkill to try to handle the resizing between phones and PCs.
* Mobile browser events: Forcing iOS Safari to ignore its default behaviors (double-tap zoom, swipe-to-scroll) while still allowing the user to tap and drag Matter.js objects required a ridiculous amount of custom event listener management and CSS (touch-action: manipulation; user-select: none;). I also learned that these actions very easily kill the mouse scroll making it very frustrating for PC users. I am hoping I hit a good middle ground.
* State management: Since I didn't use React or any frameworks, I had to rely on a global state object. Because the game jumps between different phases/minigames, I ran into massive memory leaks from old setInterval loops and Matter.js bodies stacking up. I had to build strict teardown functions to wipe the slate clean on every map transition.
The game walks through electrostatic desalting, fractional distillation, hydrotreating, catalytic cracking, and gasoline blending (hitting specific Octane and RVP specs).
It’s completely free, runs client-side, and has zero ads or sign-ups. I'd appreciate any feedback on the mechanics, or let me know if you manage to break the physics engine. Happy to answer any questions about the chemical engineering side of things as well.
For some reason the URL box is not getting recognized, maybe someone can help me feel less dumb there too.
https://fuelingcuriosity.com/game

value: Show HN: Vanilla JavaScript refinery simulator built to explain job to my kids

author: fuelingcurious


value: vasanthv

value: Show HN: Veread – A minimal RSS reader for web. No sign ups. No downloads

author: vasanthv


value:
Drawbridge is a drop-in replacement for `requests` or `httpx` that provides comprehensive SSRF protection.
For every request, it will:
1. Resolve DNS first with single getaddrinfo() call
2. Validate all IPs, and reject if any resolved address is private/reserved
3. Pin the connection by rewriting the URL to validated IP, and sets the Host header and TLS SNI to original hostname
4. Re-validates on each redirect hop.
This blocks most SSRF attack methods: DNS rebinding, address obfuscation, and redirects.
Also see our launch post here: https://tachyon.so/blog/ssrfs-trickiest-issue

value: Show HN: Drawbridge – Drop-In SSRF Protection for Python


value:
I built this after noticing my brother was literally copying answers from ChatGPT and failing exams lol
The core idea is to provide hints first rather than instant answer like every AI tool. I believe it's gonna make Gen-Z dumb if they stop critical thinking, problem-solving skills.
Honest feedback welcome, especially criticism.
App Store: https://apps.apple.com/us/app/thinkfirst-ai-homework-help/id...

value: Show HN: ThinkFirst – The Anti-ChatGPT for Students


value: JacobCreator

value:
m8tes lets you create agents that work across your apps autonomously.
you can trigger them by schedule, webhook, email, or manually.
I have these running on autopilot:
- Add negative keywords for wasted spend in Google Ads (weekly schedule)
- Review new job applicant (webhook)
I also delegate tasks directly to agents on email. And there's a kanban to manage tasks manually.
free to get started. let me know if you have any questions or feedback!

value: Show HN: M8tes.ai – AI teammates that do your work

author: JacobCreator


value: possiblelion

value: I've built airdefense.dev, which is able to simulate all kinds of ballistic missiles, one-way-attack drones like Shaheds, and most of the commonly deploy anti-air defence systems. All of this inside the browser. I've now added a scenario of the current attacks in the Middle East by Iran. It was quite the challenge to optimize it enough to not completely kill a common laptop, although it still runs best on a bit beefier systems.

value: Show HN: I simulated 1200 Iranian missiles attacking air defences in a browser

author: possiblelion


value: agilek

value: Show HN: Set of Braille Unicode spinners as React decorator components

author: agilek


value: chuckgreve

value:
I built DeadSwitch after realizing that if I died tomorrow, my family would have no idea how to access any of my accounts, crypto wallets, or important documents.
$120 billion in Bitcoin has been permanently lost — most of it because the owner died without passing on access. That number haunts me.
DeadSwitch is a portable encrypted vault that runs entirely from a USB drive. No cloud required — your data never leaves your device unless you want it to.
How it works:
- Store passwords, crypto wallets, financial accounts, documents, medical info, legal info, and personal video/audio messages
- Assign specific items to specific beneficiaries (your spouse gets financials, your kids get personal messages)
- Set a configurable check-in schedule — if you miss enough check-ins, it automatically delivers everything to the right people
- Print an emergency card PDF for each beneficiary with instructions and a secret code
Tech: AES-256-GCM-SIV encryption, Argon2id key derivation, XChaCha20-Poly1305 for video/audio. Multi-platform (Windows, macOS, Linux). Open source.
Adding an optional $10/mo cloud vault backup for belt-and-suspenders protection.
Happy to answer any questions about the crypto/security implementation.

value: Show HN: DeadSwitch – Encrypted USB vault with dead man's switch

author: chuckgreve


value:
Hi folks, zi2zi-JiT is the follow-up work to the original zi2zi project (https://github.com/kaonashi-tyc/zi2zi). Now with JiT (Just image Transformer) as the backbone, it can generate high-fidelity fonts in under one hour on a single GPU.
Fonts created with zi2zi-JiT:
- Zi-QuanHengDuLiang (权衡度量体): https://github.com/kaonashi-tyc/Zi-QuanHengDuLiang
- Zi-XuanZongTi (玄宗体): https://github.com/kaonashi-tyc/Zi-XuanZongTi
- Eva-Ming-Simplified (Eva明朝简体): https://github.com/kaonashi-tyc/Eva-Ming-Simplified
Pretrained weights and LoRA fine-tuning scripts included.
I'm sharing it here in the hope that this tool reaches more people and truly helps individual CJK font designers.

value: Show HN: Zi2zi-JIT – Generate Chinese font in one hour


value: beomjunkdev

value:
I got tired of copy-pasting the same CLAUDE.md, rules, and skills across projects. So I built updose — a boilerplate manager for AI coding tool configurations.
It works with Claude Code, Codex, and Gemini CLI.
What it does:
- Search and install community-shared boilerplates (rules, skills, agents, commands) with one command

  npx updose search <query>
  npx updose add <owner/repo>

- Publish your own setup so others can use it

  npx updose init
  npx updose publish

Built with TypeScript. Open source (MIT). Feedback welcome.

value: Show HN: Updose – A boilerplate for AI coding tool configs

author: beomjunkdev


value: genesalvatore

value:
For the last few months, we've been working on a fundamental architectural shift in how autonomous agents are governed. The current industry standard relies almost entirely on probabilistic alignment (RLHF, system prompts, constitutional training). It works until it's jailbroken or the context window overflows. A statistical disposition is not a security boundary.
We've built an alternative: Deterministic Policy Gates. In our architecture, the LLM is completely stripped of execution power. It can only generate an "intent payload." That payload is passed to a process-isolated, deterministic execution environment where it is evaluated against a cryptographically hashed constraint matrix (the constitution). If it violates the matrix, it is blocked. Every decision is then logged to a Merkle-tree substrate (GitTruth) for an immutable audit trail.
We filed 99 provisional patents on this architecture starting January 10, 2026. Crucially, we embedded strict humanitarian use restrictions directly into the patent claims themselves (The Peace Machine Mandate) so the IP cannot legally be used for autonomous weapons, mass surveillance, or exploitation.
I wrote a full breakdown of the architecture, why probabilistic safety is a dead end, and the timeline of how we filed this before the industry published their frameworks: Read the full manifesto here: https://salvatoresystems.medium.com/the-death-of-probabilist...
The full patent registry is public here: https://aos-patents.com
I'm the founder and solo inventor. Happy to answer any questions about the deterministic architecture, the Merkle-tree state persistence, or the IP strategy of embedding ethics directly into patent claims.

value: Show HN: We filed 99 patents for deterministic AI governance(Prior Art vs. RLHF)

author: genesalvatore


value: Show HN: OpenTimelineEngine – Shared local memory for Claude Code and codex


value: infiniteregrets

value: Parallax is a CLI for orchestrating independent AI agent cohorts (Claude, Codex, etc.) over isolated, append-only logs or streams. Each cohort operates on its own log and does not see the intermediate reasoning of others i.e. disagreement is enforced at the infrastructure layer rather than prompted at runtime. Agents write to sequenced, durable logs and a separate moderator agent subscribes to all streams, monitors progress, issues steering instructions when necessary, and synthesizes outputs at the end.<p>That means, coordination is just done over a log with natural language, which allows us to rewire topology of agents mid-run, fork, merge, spawn breakout rooms or build any research methodology on the fly depending on the question. If something goes wrong / crashes, agents can resume from where they left off. Further, if the log or stream is serverless, agents can connect over the log from any machine anywhere in the world and collaborate on tasks / research.

value: Show HN: Parallax – Coordinate adversarial AI agents over durable streams

author: infiniteregrets


value: dokdev

value: Show HN: AgentBrowser Token-efficient browser for AI agents via ASCII wireframes

author: dokdev


value: azorstudio

value: Show HN: WaitQ – queue management and waitlist system

author: azorstudio


value: baristaGeek

value: Show HN: Open-Source Postman for MCP

author: baristaGeek

title: Show HN: Open-Source Postman for MCP


value:
Hi HN,
We built this because we got tired of becoming accidental platform engineers.
Multi-database stacks are the default now, but the operational overhead is brutal. We wanted one auth layer, one dashboard, and one way to provision and monitor everything.
Live now: `Redis` + `TigerBeetle` (weird combo, but that’s what our beta users needed).
Next up:
- `MySQL`
- `ClickHouse`
- `Postgres` + `PostGIS`
- `VectorDB`
SDK-first approach. `Node` and `Python` ready.
npm:
<https://www.npmjs.com/search?q=%40bridgebase>
PyPI:
<https://pypi.org/project/bridgebase/>
Would love feedback from anyone running multi-database workloads in production.
What’s the biggest pain point we missed?

value: Show HN: BridgeBase – one control plane for TigerBeetle,Redis,MySQL,ClickHouse


value: Show HN: StrategicConsult – Game theory augmented AI for decision making


value: goshtasb

value:
I kept running into the same annoying friction with Claude Desktop and Cursor: I’d snip a Python traceback, the AI would tell me to "run pip install pandas," and then I’d sit there and type it out myself. If the AI clearly knows the fix, why am I doing the typing?
So I built OmniGlass.
The UX is simple: You draw a box on your screen, local OCR extracts the text, and an LLM classifies what you're looking at. But instead of generating a chat response, it gives you an action menu.
The core difference from Claude Desktop isn't the AI—it’s what happens after the AI thinks. Claude reads your screen and writes you a paragraph. OmniGlass reads your screen and runs the command.
What it does today:
Snip a traceback → Generates the fix command, you confirm, it runs.
Snip a data table → Opens a native save dialog and spits out a clean CSV.
Snip a Slack bug report → Drafts a GitHub issue with all the context filled in.
Menu bar input → Type plain English, and it triggers the appropriate command.
The security elephant in the room (Why I built this):
Nobody is really talking about the security risks of MCP plugins yet. Claude Desktop runs them with your full user permissions. A rogue plugin—or a clever prompt injection—can just read your SSH keys, scrape your .env files, and ship them off.
To fix this, OmniGlass sandboxes every plugin at the macOS kernel level using sandbox-exec.  Your /Users/ directory is completely walled off. Environment variables are aggressively filtered. Shell commands strictly require your manual confirmation before executing. I wanted to be able to run community plugins without sweating about what they can access.
The Stack:
Frontend/Backend: Tauri (Rust + TypeScript)
Vision: Apple Vision OCR (local)
Plugin System: MCP over stdio
Models: Works with Claude Haiku, Gemini Flash, or fully local via llama.cpp using Qwen-2.5 (takes ~6s end-to-end, nothing leaves your machine).
Current Status:
I just shipped our second working plugin (a Slack Webhook) to run alongside the GitHub Issues plugin. It's two real-world plugins proving the architecture actually works, not just a boilerplate template and a promise. Both are under 250 lines of code.
Where I'd love your help:
Break the sandbox. Seriously. If you can figure out a way to read ~/.ssh/id_rsa from a plugin, that is a critical bug and I want to know about it.
Build a plugin. There are 8 open issues in the repo right now with full MCP schemas, manifests, and implementation hints. Most take less than 100 lines.
Port to Windows/Linux. The Windows build compiles in CI but hasn't been tested on real metal. Linux needs Tesseract + Bubblewrap to replace the Apple OCR and sandbox.
Requires macOS 12+ right now. Fully open source (MIT).
Would love to hear your thoughts or answer any questions about the sandboxing setup!

value: Show HN: OmniGlass – Executable AI screen snips with kernel-level sandboxing

author: goshtasb


value: voidbrainvoid

value:
Hi everyone,
I’ve developed a minimalist 2FA tool (TOTP) for CLI. My goal was to create something with the widest possible reach across Unix-like systems without the typical dependency bloat.
Key features:
- Pure ANSI C: No external dependencies beyond libc.
- Wide Portability: Tested and running on Linux, FreeBSD, OpenBSD, and NetBSD.
- Security focused: Fixed-width types, endianness-aware, and compiled with stack protection flags.
- Lightweight: Fast execution, ideal for integration into scripts and legacy infrastructure.
- Build for final users is gmake based but without autotools.
The project is hosted on Codeberg under the BSD-3-Clause license. I’m currently in the final polishing stage and would love to hear your thoughts on the code structure and portability.
Check it out here: https://codeberg.org/rafael-santiago/pinhead

value: Show HN: Pinhead – Adding 2FA to Your CLI (Linux, FreeBSD, OpenBSD, NetBSD)

author: voidbrainvoid


value: foundatron

value:
I built this over the weekend after reading about StrongDM's software factory (their writeup: https://factory.strongdm.ai/, Simon Willison's deep dive: https://simonwillison.net/2026/Feb/7/software-factory/, Dan Shapiro's Five Levels: https://www.danshapiro.com/blog/2026/01/the-five-levels-from...). OctopusGarden is an open-source implementation of the pattern StrongDM described: holdout scenarios, probabilistic satisfaction scoring via LLM-as-judge, and a convergence loop that iterates until the code works; no human code review in the loop.
What stood out to me was that this architecture largely rhymes with the coding workflows I and others already do with coding agents. It's basically automating the connective tissue between the workflows I was already doing in Claude Code, and then brute-forcing a result. In the dark factory model, a spec goes in, code gets generated, built in Docker, validated against scenarios the agent never saw, scored, and failures feed back until it converges.
I've tried it with mostly standard CRUD/REST API apps and it works. I haven't tried anything with HTML/JS yet. You can try the sample specs in the repo.
Some raw notes from the experience:
1. I don't want to maintain the code these factories generate. It works. The phenotype is (largely) correct, but the genotype is pretty wild and messy. I did not use OctopusGarden to build OctopusGarden (you can tell because it uses strict linting and tests). I know the point of these systems is zero human in the loop, but I think there's a real opportunity to get factories to generate code that humans actually want to maintain. I'm going to work on getting OctopusGarden there.
2. Compliance might be a nightmare. In my day job I think a lot about ISO 27001 and SOC 2 compliance. The idea of deploying dark-factory-generated projects into my environments and checking compliance boxes sounds painful. That might just be the current state of OctopusGarden and the code it generates, but I think we can get to a point where generated code is completely linted, statically checked, and tested inside the factory. That's not OctopusGarden today, but maybe it will be there next week? I can see this moving fast.
3. These dark factory apps will be hard to debug. There was a Claude outage today and I couldn't run my smoke tests or generate new apps. I don't want to maintain services that can't be debugged and fixed by a human in a pinch. We're already partially there with AI-assisted code, but this factory-generated code is even more convoluted. Requiring AI to create a new app version is probably worth it...but it's still yet another thing between you and quickly patching an urgent bug.
4. Security needs a better story. These things need real security hardening. Maybe that's just better spec files and scenarios, maybe it's something more. I'm going to drink a strong cola and think about this one.
5. The unit of responsibility keeps growing. Last year we said code must come in PR-sized bites — that's how we manage risk. Now we're talking about deploying meshes of services created and deployed with no humans in the loop (except at creation). AI-generated services could really push the scale of what people are willing to accept responsibility for. Most SRE teams manage 1-5 services at big companies. Will that number increase per team? How much GDP is one person willing to manage via agents? Just a shower thought.
6. I was surprised this works. I'm surprised at how easy it was to make. I'm surprised more of these aren't out there already. I only did a couple of GitHub searches and didn't find many. I'm bad at searching. Sorry if I didn't find your project.

value: Show HN: OctopusGarden – An autonomous software factory (specs in, code out)

author: foundatron


value: mishrasanjeev

value:
AI agents are being deployed to schedule meetings, write code, manage infrastructure, and transact on behalf of users. But there's no standard way to
  authorize what an agent can do, audit what it did, or revoke access when something goes wrong. Most teams are hacking together API keys and custom RBAC
   — none of it is portable, auditable, or revocable at the agent level.

  Grantex is an open delegated authorization protocol designed specifically for AI agents. Think of it as OAuth 2.0 for the agentic era: a principal
  (human or organization) grants an agent scoped, time-limited permissions via signed JWT tokens. Every action is auditable. Permissions can be revoked
  instantly — including cascade revocation across delegation chains when one agent delegates to another.

  What makes it different:

  - Standards-track: We submitted an IETF Internet-Draft (draft-mishra-oauth-agent-grants-01) to the OAuth Working Group and filed a public comment with
  NIST NCCoE on AI agent authorization.

  - Production-ready: 30+ packages across TypeScript, Python, and Go. Integrations for LangChain, OpenAI Agents SDK, Google ADK, CrewAI, Vercel AI, MCP,
  and more. 679 tests. Deployed on Google Cloud Run.

  - Enterprise features: SOC 2 Type I certified. Security audited by Vestige Security Labs (all findings remediated). Policy engine integration with OPA
  and Cedar. Budget controls with atomic debit. Prometheus metrics + OpenTelemetry tracing.

  - Self-hostable: Apache 2.0 licensed. Docker Compose for local dev, Helm chart for Kubernetes, Terraform provider for infrastructure-as-code.

  Quick start:

    npm install @grantex/sdk
    pip install grantex
    go get github.com/mishrasanjeev/grantex-go

  GitHub: https://github.com/mishrasanjeev/grantex
  Docs: https://grantex.dev/docs
  Playground: https://grantex.dev/playground
  Protocol spec: https://github.com/mishrasanjeev/grantex/blob/main/SPEC.md
  IETF draft: https://datatracker.ietf.org/doc/draft-mishra-oauth-agent-grants/

  Happy to answer questions about the protocol design, the IETF process, or implementation details.

value: Show HN: Grantex–Open authorization protocol for AI agents(IETF draft submitted)

author: mishrasanjeev