value: alamparelli

value:
I built a macOS dictation app where everything runs on-device. Transcription, auto-correct, translation. No audio or text leaves your machine.
It ships with 4 transcription engines you can swap between: WhisperKit (99 languages), NVIDIA Parakeet TDT 0.6B (25 European languages, fastest of the bunch), Qwen3-ASR 0.6B (30 languages), and Apple Speech on macOS 26+. They all run through CoreML/Metal. Whisper is the most versatile, Parakeet wins on raw latency for European languages, Qwen3 does better with CJK. I went with a protocol-based architecture so you pick the engine that fits your use case instead of me pretending one model rules them all.
After transcription, there's an optional post-processing pipeline using Apple Intelligence (FoundationModels framework, macOS 26+, also fully on-device): auto-correct with filler word removal, tone rewriting, translation. The annoying part was FoundationModels cold start. First inference after idle takes 2-3s, which kills the experience. I worked around it by firing a throwaway mini-inference (`session.respond(to: "ok")`) in parallel while audio is still being transcribed, so the model is already warm when the text arrives. Hacky, but it shaved off the perceived latency.
Getting transcribed text into any arbitrary macOS app was honestly the hardest part. I use clipboard save/restore: read all NSPasteboard types (not just strings, also images, RTF, whatever the user had copied), write the transcribed text, simulate Cmd+V via CGEvent posted to `cghidEventTap`, then restore the original clipboard. Electron apps are slower to process paste events, so I detect them by checking if `Contents/Frameworks/Electron Framework.framework` exists in the app bundle and add extra delay. This whole approach requires Accessibility permissions, which means no sandbox, which means no App Store. I'm fine with that trade-off.
Built this solo in about 6 weeks. One-time purchase, no subscription.
I'm genuinely unsure about the multi-engine approach. Is letting users choose between Whisper/Parakeet/Qwen3 useful, or would most people prefer I just auto-select based on their language? Also curious if anyone has a cleaner approach to text injection on macOS. The clipboard hack works everywhere but it feels fragile and I don't love it.

value: Show HN: Dicta.to – Local voice dictation for Mac with on-device AI

author: alamparelli


value: Show HN: AI-native SDLC – 156 test docs, 16 skills, 1 human


value: mikedistribute

value:
I kept skipping runs because I had nobody to go with. I looked for a solution that let me find other runners in real time near me — nothing existed. So I built it.
>
> Pulse shows you nearby runners on a map with upcoming sessions you can join. Or create your own and let others find you. No club signup, no group chat management.
>
> It's in early TestFlight beta (iOS only for now). I'm looking for runners who'd use this to tell me what's broken and what's missing.
>
> TestFlight link: https://testflight.apple.com/join/9f56taxY

value: Show HN: Pulse Running – find nearby runners and join their sessions (iOS beta)

author: mikedistribute


value: kwhkim

value: If you want your issues free from vendor lock-in, editable offline, and simple to install and use, git-pad can help you.

value: Show HN: Git-pad: Git-native issue tracker

author: kwhkim


value: LightMorpheus

value: Hey HN, HTTP 402 — Payment Required — has been in the spec since 1997, reserved "for future use." It's finally getting used.

value: Show HN: Nullpath – A marketplace where AI agents pay each other via HTTP 402

author: LightMorpheus


value:
Claude Code recently added native worktree support (--worktree), which helps a lot with parallel agent isolation.
What's still unsolved is conflicts across active worktrees, which often surfaces late.
I built Clash (OSS, Rust) to detect potential conflicts earlier using read-only merge simulation across worktrees during edits.

  - clash check <file> for pre-edit checks
  - clash status for a cross-worktree conflict matrix
  - clash watch for live monitoring
  - Claude plugin hook support for Write|Edit|MultiEdit

Quick setup (CLI + Claude plugin):

  curl -fsSL https://clash.sh/install.sh | sh && \
  (claude plugin marketplace add clash-sh/clash || true) && \
  (claude plugin install clash@clash-sh || claude plugin update clash@clash-sh)

Would love feedback or your thoughts on this.

value: Show HN: Clash – Detect Git worktree conflicts before parallel agent edits


value:
Hi HN,
I originally started this project simply to safely run autonomous coding agents (like Claude in auto-mode) in isolated environments. But as I built it, I realized the potential was much bigger than just sandboxing: it's about making a coding agent callable like a standard API, and ultimately, defining your entire development workflow as infrastructure.
Axon is a Kubernetes-native framework that abstracts the coding agent itself. By standardizing the container interface, you can seamlessly plug in Claude, Codex, Gemini, OpenCode, or your own custom images without changing your orchestration.
How it works under the hood:
The architecture relies on standard K8s CRDs (Tasks, Workspaces, TaskSpawners, and AgentConfigs).
A Task is the fundamental unit of work for a coding agent. When a Task is created, Axon spins up an ephemeral Pod with a freshly cloned git workspace to execute it.
You use an AgentConfig to declaratively define the specific rules, custom skills, and MCP (Model Context Protocol) servers the agent is allowed to access during that Task.
A TaskSpawner reacts to GitHub events (like a new issue or PR) and automatically generates these Tasks on the fly.
Deterministic outputs (branch names, PR URLs, token usage) are captured directly back into the K8s resource status.
To test this, I built a fully autonomous self-development pipeline. It actively triages issues, suggests new features, finds bugs, and writes the code to fix them. It uses standard GitHub issues and PR comments as the feedback loop to guide the agents. You can see how that is wired together here: https://github.com/axon-core/axon/tree/main/self-development
The main repo is here (with demo video): https://github.com/axon-core/axon
I’d love to get your real-world feedback—especially on the CRD design, the container abstraction model, and what new features you would need to actually integrate this into your workflows.

value: Show HN: Axon – A Kubernetes-native framework for AI coding agents


value: conorfarrington

value:
Hey HN,
A few years ago the worst boss I ever had told me “I don’t encourage side projects.”
So obviously I spent a few evenings recently to build Pythia (live beta at https://pythia-rating.com).
It’s a single letter grade (AAA down to C) that combines five indices into one executive-friendly score:
•Performance (40 %) – real CrUX field data + Lighthouse lab
•Security (20 %) – modern HTTP security headers
•Privacy & Tracking (20 %) – cookies, trackers, 3rd-party domains, consent signals
•Sustainability (15 %) – page weight, green hosting, CO₂ estimates, image bloat
•Infrastructure (5 %) – CDN usage + aggressive caching headers
Plus a fun “Amazon lost revenue” calculator (100 ms delay ≈ 1 % revenue impact, adjustable by your ARR and e-comm %).
Some illustrative point-in-time scans (as of ~13:00 GMT today, public data only, indicative):
AI companies
•OpenAI: CCC
•xAI: B
•Anthropic: CCC
•Google DeepMind: BB
(Keeping Elon happy.)
Universities
• MIT: CCC
• Harvard: CCC
• Oxford: BBB
• Cambridge: BBB
(Oxbridge quietly winning on digital health.)
Everything runs on public sources (CrUX, Lighthouse, custom resilient HTTP agent for headers/cookies). No logins, no tracking on the scanner itself. Built purely as a side project because I was tired of 47-metric dashboards that no CEO ever reads. Wanted one number + dollar impact + actual fix suggestions.
Would love your brutal feedback on:
•Scoring weights (do they feel right?)
•Missing metrics you’d want to see
•Edge cases it gets wrong
•Who else this could actually be useful for (agencies doing client audits? PE doing diligence? in-house teams benchmarking competitors?)
Happy to answer questions or add anything people ask for. Thanks for looking!

value: Show HN: Pythia– Moody's-style AAA–C rating for any site (perf and other vitals)

author: conorfarrington


value: veniyer

value:
I kept running into the same pattern: calling an LLM API thousands of times with the same prompt template, just swapping in different text. Classify this contract clause. Route this support ticket. Categorize this log line.
For teams handling contracts, patient records, or internal logs, sending that data to a third-party API isn't always an option. And at scale, you're paying per-token for what's essentially pattern matching.
So I built a CLI that trains a small local classifier from labeled examples. Give it 50 input/output pairs, it trains a ~230KB model on your machine, and you run inference locally. No network calls. Everything runs on Node.js - no Python, no GPU, no Docker.
Under the hood it uses all-MiniLM-L6-v2 for sentence embeddings (runs locally, downloads once at ~80MB) and trains a small neural network on top of your labels.
For topic/domain classification - where categories are about different things - I'm seeing 80-95% accuracy with 50 examples. It struggles with sentiment and tone (44-50%), because "amazing camera" and "terrible camera" produce nearly identical embedding vectors. I documented this openly in the benchmarks.
The benchmarks use real text from AG News (127K articles) and 20 Newsgroups (18K posts), with only 50 training samples drawn from each. The test harness and all fixture data are in the repo - clone it and run npx tsx tests/harness/run.ts to reproduce.
This isn't trying to replace LLMs. It's specifically for the repetitive classification tasks where the same prompt structure processes different data every time.
Open source, Apache 2.0. Still early. Curious whether anyone has tried similar embedding+classifier approaches for their own workflows, or if there's demand for multi-label classification.

value: Show HN: Train a 230KB text classifier from 50 examples – no API keys, no GPU

author: veniyer


value: subdomain

value:
Hi HN,
I'm Micah Blachman, the creator of Crosspassion. After posting about my previous version a few days ago, I rebuilt the entire app from the ground using Codex.
Crosspassion aims to be Reddit, but for finding where your interests overlap. If I was interested in, say, mechanical keyboards and type design, I could check the mechanical keyboard/type design community, and look at the latest discoveries of projects that combine both interests. Plus, you get to connect with people who share your exact crosspassion, or interest combination.
I'm not a developer, so I used Codex for the code. I'm the first to say AI-generated websites and web apps are not a match for the quality of human-created projects, but Crosspassion is still very early-stage.
I'd love feedback on how to improve Crosspassion even further, and if you're a developer and you have any ideas about how to take the project to the next level, feel free to reach out!
I wrote about the idea behind Crosspassion on my newsletter: https://micahblachman.beehiiv.com/p/crosspassion/, and you can contact me at micah.blachman@gmail.com.
-Micah

value: Show HN: Rebuilt My Social Network with Codex in One Day

author: subdomain


value: I made this for personal use but thought it may be useful for others as well.

value: Show HN: Reflect – a simple screentime alternative for macOS


value: Show HN: MCP server that lets AI build, play, and debug Godot games (84 tools)


value: schmommy

value:
Hi HN — I built LazyHippo.dev as a sandbox for auth testing, product testing, and general “let me break this before users do” workflows.
It started as a tool for my own projects because auth and edge cases kept eating time:
- login/signup issues
- session weirdness
- role/permission behavior
- product-flow regressions
- test scenarios that are annoying to recreate manually
The goal is to have a practical environment for validating auth/product behavior without building a huge internal setup every time.
Who it’s for:
- indie hackers
- builders shipping quickly
- teams who need lightweight testing workflows
- people who want to catch auth/product issues earlier
What I’d love feedback on:
1. What auth/testing pain points waste the most time for you?
2. What would make a tool like this genuinely useful vs. “nice idea”?
3. Which features would be must-have for version 1?
I’m especially interested in feedback from people who’ve dealt with messy auth flows in production.

value: Show HN: LazyHippo.dev – sandbox for auth and product testing

author: schmommy


value: garrjo

value:
I built a physics computation platform that replaces brute-force numerical PDE solvers with analytic geometry evaluated in a 13D coordinate space. Instead of discretizing onto million-cell meshes and iterating to convergence on a supercomputer, GDBS maps physical systems into geometric positions where observables become exact coordinates. Evaluation is O(N) instead of O(N³), so what takes HPC clusters hours runs in <100ms in WebAssembly in the browser.
7 physics domains: plasma/fusion, materials science, cosmology, geophysics, fluid dynamics, quantum information, and molecular/medical. 300+ validation tests against NIST, CODATA, Planck 2018, ITER Physics Basis, PREM, and peer-reviewed literature. Example: bulk modulus of diamond — GDBS: 443 GPa, CRC Handbook: 442 GPa.
The stack is Rust→WASM for the physics engine (6,300+ LOC, 59 modules), .NET 8/C# backend, vanilla JS frontend. Includes a query language (GQL), REST API, and a built-in precision system that tracks numerical drift across 65 orders of magnitude (validated at 0.27% error on Hawking radiation calculations spanning ℏ at 10⁻³⁴ to thermodynamic scales).
Free 14-day trial with full access. Theory module is free permanently. Beta program available for researchers (citation required).
- https://gdbs.getvaultsync.com
- https://doi.org/10.5281/zenodo.18753425 (Geometric Number Scale - PrePrint)
I do hope it helps.

value: Show HN: GDBS – Browser geometric physics engine replacing HPC cluster workloads

author: garrjo


value: sivchari

value:
I built awsim, a lightweight AWS emulator in Go for CI/CD testing.
Core services (S3, DynamoDB, SQS, Lambda, IAM) implemented, 40+ services in progress.
- Single binary, no auth required
- Instant startup, in-memory storage
- Contributions welcome
Feedback welcome!

value: Show HN: Awsim – Lightweight AWS emulator in Go (40 services in progress)

author: sivchari


value: starkience

value:
StarkZap is an open-source TypeScript SDK for adding Bitcoin-backed asset transfers, balances, lending & borrowing and staking to web, mobile, or server apps.
The goal is to let developers integrate programmable Bitcoin assets without requiring users to install wallets, manage seed phrases, or hold gas tokens.
Under the hood it runs on Starknet and supports WBTC, tBTC, LBTC, SolvBTC, and other Bitcoin-backed ERC20 tokens.
```import { StarkZap, StarkSigner, Amount, fromAddress, getPresets } from "starkzap";<p>const sdk = new StarkZap({ network: "sepolia" });
const wallet = await sdk.connectWallet({
  account: { signer: new StarkSigner("0xYOUR_PRIVATE_KEY") }
});<p>await wallet.ensureReady({ deploy: "if_needed" });<p>const { STRK } = getPresets(wallet.getChainId());
const balance = await wallet.balanceOf(STRK);<p>if (balance.gte(Amount.parse("10", STRK))) {
  const tx = await wallet.transfer(STRK, [
    { to: fromAddress("0xRECIPIENT"), amount: Amount.parse("10", STRK) }
  ]);
  await tx.wait();
  console.log(tx.explorerUrl);
}
```
Key properties:
- Gas sponsorship via paymaster (users don’t need gas tokens)
- Multiple auth strategies (email/social via Privy, passkeys via Cartridge)
- Batch transfers and contract calls in a single atomic transaction
- Works in Node, browser, and React Native
The SDK abstracts account management, fee handling, and wallet popups. This won’t make sense for every app (e.g., if you only need fiat checkout). It’s for existing apps that want programmable onchain assets without the wallet UX.
Would appreciate feedback on the API design and whether this abstraction makes sense.

value: Show HN: StarkZap – Gasless Bitcoin Payments SDK for TypeScript

author: starkience


value: micahele

value:
I built DoNotify because I kept missing Google Calendar events. Telegram calls worked for v1, but they required the app and didn't reliably ring through Do Not Disturb.
So I rebuilt it around regular phone calls via Vonage's Voice API. When a Google Calendar event is due, DoNotify calls your phone number and speaks the event details aloud: title, time, location. No app needed. Rings through silent mode and DND. Works internationally.
Stack: Laravel, Livewire, Vonage Voice API, LemonSqueezy for billing. Google OAuth for calendar sync and sign-in. Resend for backup email reminders.
Recently added an API so you can trigger reminders programmatically from your own workflows. There's also an OpenClaw skill if you're into agent-based automation.
Would love feedback on the approach. The core bet is that voice calls are the only notification channel people physically can't ignore.
https://donotifys.com

value: Show HN: DoNotify – Google Calendar reminders as phone calls(not notifications)

author: micahele


value: rklosowski

value:
I built Bruce because I was drowning in noise while trying to launch my own SaaS.
I had F5Bot set up for keywords, but it was sending me 50+ alerts a day —
mostly irrelevant. I'd spend 20 minutes triaging to find 2 threads worth
responding to. The problem wasn't lack of monitoring, it was lack of signal.
Bruce is different: instead of matching keywords, it scores every item 0-100
against your product context, ICP, and competitor list. It understands why
something is relevant, not just that a keyword appeared.
The part I'm most excited about: it learns. Every time you act on a signal
or dismiss one, Bruce adjusts. By week 2, it's surfacing very different
(better) things than week 1.
What it monitors: Reddit, Hacker News, RSS feeds, ProductHunt, and anything
with an RSS endpoint via RSSHub (YouTube channels, newsletters, etc.)
Stack: Next.js 15, PostgreSQL, Drizzle, Better Auth, my self-built AI runtime,
RSSHub.
Live at https://smartbruce.com
Happy to answer questions about the scoring model or architecture.

value: Show HN: Bruce – AI signal radar for Reddit/HN that learns what matters to you

author: rklosowski


value: pdlug

value:
Hi HN, I built TypeGraph, a type-safe knowledge graph library that runs on your existing Postgres or SQLite.
After years of building knowledge graphs and other graphy things, I had the same issues whenever an application’s relationship modeling (permissions, RAG context, recommendations) outgrew standard ORMs: deploy a dedicated graph database (heavy ops, separate infra, data syncing headaches), or roll a graph-in-SQL implementation by hand.
I've hand-rolled enough of these to know the drill: same table structures, same traversal boilerplate, same performance surprises. I wanted graph semantics without graph infrastructure so I built TypeGraph as that pattern packaged as a library. It runs on anything from in-memory SQLite to a full Postgres cluster, using Zod for a single source of truth (driving your DB schema, API validation, and TS types).
You query it with a fluent builder that's fully typed through traversals:

    const results = await store
      .query()
      .from("Person", "p")
      .traverse("worksAt", "e")
      .to("Company", "c")
      .whereNode("c", (c) => c.industry.eq("Tech"))
      .select((ctx) => ({
        person: ctx.p.name,
        company: ctx.c.name,
        role: ctx.e.role,
      }))
      .execute();

Eject at any time and you're left with clean, well-structured SQL tables and nothing proprietary to untangle.
A few things that set it apart from rolling your own:
* Ontology reasoning: subClassOf, implies, inverseOf — query for "Media" and automatically get Podcasts and Articles. Define "Admin implies Editor" and permission checks expand automatically.
* Vector + graph queries: combine embedding similarity search with graph traversal in one query. Uses pgvector on Postgres, sqlite-vec on SQLite.
* Incremental adoption: builds on Drizzle. Add graph capabilities to an existing project without replacing your ORM or migrating your database.
Where it works well: knowledge graphs for RAG (vector similarity + graph context), relationship-based access control, recommendations, social features, any domain where multi-hop relationships are core.
Where it doesn't: billions of edges (use a graph database), heavy graph algorithms like PageRank (use specialized tools), distributed graph processing.
Docs: https://typegraph.dev
GitHub: https://github.com/nicia-ai/typegraph/
Happy to answer questions about the design, implementation, or tradeoffs.

value: Show HN: TypeGraph – Type-safe graphs on Postgres/SQLite (no graph DB required)

author: pdlug


value: schmommy

value:
Hi HN — I built Satisfice.app because I’m a chronic overthinker and kept getting stuck in idea loops instead of shipping.
The problem:
I’d get an idea, research it to death, tweak the concept endlessly, and lose momentum before building anything.
What Satisfice does:
It helps you pressure-test an idea quickly so you can decide whether to:
- ship now
- simplify
- pivot
- or stop wasting time on it
The goal isn’t “perfect analysis” — it’s helping founders move forward with enough clarity to act.
Why the name:
“Satisficing” = choosing an option that’s good enough to meet the goal, instead of optimizing forever.
Who it’s for:
- indie hackers
- side-project builders
- founders with too many ideas and not enough launches
I’d love feedback on:
1. What makes you personally stop overthinking and start shipping?
2. What signals do you use to validate an idea fast?
3. What would make a tool like this actually useful in your workflow?

value: Show HN: I built a $5 AI tool to stop me from overthinking startup ideas


value: ChesterHsu

value: Show HN: What if YAML was a programming language? (412 built-in modules)

author: ChesterHsu


value: rwxdash

value:
I'm an SWE/SRE, and I've spent a lot of time building and maintaining internal CLI tools for the teams I've worked with. On top of that, there were always scattered scripts that needed organization. I got tired of the overhead involved in packaging, distribution, and writing parsers every single time I wanted to automate a new workflow.
I built mici to solve this for myself, both at work and for personal projects. It's a very trivial tool but it gets the job done for me.
It is a Rust-based runner that turns your directory structure into a CLI. You just drop a YAML file in the mici folder and the command is ready to run. If you have worked with GitHub Actions, the syntax will feel very familiar.
It handles the "boring" parts like input validation, help documentation, command registration, and more out of the box so you can focus on the actual logic/script you want to write. It also works on both Unix and Windows systems.
It is still early (v0.x), but I am working toward a v1.0 with features like parallel execution and better step isolation. Hopefully the README and the examples are thorough enough for fresh eyes. I would love some feedback on the approach.
Repository can be found here: https://github.com/rwxdash/mici

value: Show HN: Mici – CLI framework that uses your filesystem as the command tree

author: rwxdash


value:
I built a native macOS menu bar app for real-time dictation that can run fully on-device.
Most dictation tools, even local ones, use Whisper or similar offline models: you record, then wait for the transcript. Localvoxtral uses Mistral's Voxtral Realtime, one of the first open-source speech models with a natively streaming architecture. Words appear as you speak, not after you stop. It feels closer to someone typing along as you talk.
Press a shortcut, speak, and text gets typed directly into whatever app you're in. No cloud, no subscription, no data leaving your machine.
Two backend options:
voxmlx on Apple Silicon: I forked voxmlx to add a WebSocket server and memory optimizations. Runs a 4-bit quantized model on an M1 Pro. Audio and inference stay fully on-device.
vLLM on NVIDIA GPU: tested on an RTX 3090, noticeably faster.
The app is native Swift (~97%), lives in the menu bar, and stays out of your way. Configurable shortcut, mic selection, auto-paste.
GitHub: https://github.com/T0mSIlver/localvoxtral
Pre-built DMG available in Releases

value: Show HN: Localvoxtral – Local real-time dictation on macOS with streaming STT


value: jbingen

value:
GitHub: https://github.com/jbingen/jsonchunk
npm: https://www.npmjs.com/package/jsonchunk
If you're building on top of LLMs with structured output, you've hit this: the model streams JSON token by token, but JSON.parse throws on anything incomplete. So you either wait for the full response (bad UX) or write hacky string recovery logic to show partial results.
jsonchunk is a tiny tolerant recursive descent parser that extracts the best-effort object from whatever has arrived so far. It handles common mid-stream cases: strings cut mid-escape, objects with keys but no values yet, trailing commas, partial numbers, nested structures, etc.
```
parse('{"name": "Ali')           // { name: "Ali" }
parse('{"users": [{"id": 1}, {') // { users: [{ id: 1 }] }
```
It's typed as `DeepPartial<T>` so your editor knows any field might not be there yet. The API is dual-mode: a stateless `parse()` for one-shot use, and a push-based `createParser()` / `parseStream()` for piping streams.
Tested with a fuzz suite that splits every test fixture at every possible byte position and verifies the final parse is correct. Also threw Anthropic API responses at it with deeply nested objects, escape sequences, unicode, etc.
There are a few similar libraries, but most are untyped, SAX-style, or tied to larger frameworks. The goal here was a tiny dependency-free primitive designed specifically for modern Web Streams and TypeScript.
Would love feedback, especially from anyone who's dealt with this problem in production.

value: Show HN: Jsonchunk – Parse incomplete JSON from streaming LLM responses

author: jbingen


value:
Hey HN,
I've been following Google's A2A protocol since it launched and noticed that there is still no good way to find agents out on the public internet. They're scattered across GitHub repos, registries, cloud deployments, random subdomains, and many go offline without anyone noticing.
So I built Waggle, which is a search engine that crawls the web for any domain that exposes a valid agent card, indexes them with semantic embeddings, and tracks their health over time. Waggle's index is exposed in a few different ways. First, there is good old search. There is also a REST API for programmatic access. But the feature I'm most excited about is Waggle's A2A-compliant meta-agent that knows how to delegate tasks to other agents. You ask Waggle "What are the GPS coordinates of the Empire State Building", it queries the database, finds a geocoding agent, and hands off your task, then gets back to you when the other agent is done.
The ecosystem is still very young and a lot of agents my crawlers dredge up are still "hello world" demos that are neither useful nor properly implemented. But I'm happy to report that over the course of one month, I went from 8 indexed agents to over 100, with about half being online at any given time. You can try out the Waggle agent / task delegation by using the chat feature (no registration required).
Some known-good agents you can take for a spin:
- Cliff the Surveyor (geocoding, earthquake / flood analysis in the US)
- Dispute_Email_Agent (functions as advertised)
- OpSpawn AI Agent (Tries to do many things, I only had luck with converting markdown to HTML)
In any case, excited to share! Happy to answer questions.

value: Show HN: Waggle – A search engine for A2A protocol agents


value: Show HN: AI-Nexus – Unified Rule Manager for Claude Code, Cursor, and Codex


value: marcelglaeser

value: Show HN: I analyze your GitHub code and generate a developer personality card

author: marcelglaeser


value: lepisma

value:
I built Harp because I couldn't keep my own health records in one place without relying on cloud platforms or hospital portals.
Harp is a strictly offline Personal Health Record app that stores everything in plain Org Mode files. You can:
1. Maintain journals of health events
2. Attach reports, prescriptions, scans, any other file as org-mode attachments
3. Search and filter using on-device OCR
4. Export curated takeouts for doctor visits
There is no cloud, no trackers, no ads. You own the files and decide how to sync them (Syncthing, Nextcloud, local filesystem, whatever).
I wanted to support more devices so it’s written in Kotlin Multiplatform. Android is ready, iOS is planned. For desktop, since these are Org files, working with them in Emacs is really easy.
If you care about private health data, I'd love your thoughts.
Here is a write up around the project https://lepisma.xyz/2026/02/24/harp/
Project page and documentation: https://docs.lepisma.xyz/harp/

value: Show HN: Harp – Offline, Org-Mode Based Personal Health Records Application

author: lepisma


value: debba

value:
I built Tabularis, a database GUI for MySQL/PostgreSQL/SQLite/MariaDB.

  The interesting bit is the plugin architecture: instead of shipping
  a monolith with built-in drivers, each database driver is a separate
  executable. The core process spawns it and communicates via JSON-RPC 2.0
  over stdin/stdout. No shared libraries, no ABI concerns, process
  isolation for free.

  This means you can write a plugin in Rust, Go, Python, or anything
  that can read stdin and write JSON. The first community plugin is
  DuckDB.

  The app itself is Tauri 2 + React 19 – no Electron, no JVM.

  GitHub: https://github.com/debba/tabularis

value: Show HN: Tabularis – DB GUI where drivers are JSON-RPC executables

author: debba


value: gmcquillan

value: Show HN: Scry – Test migrations against production scale copy of your DB

author: gmcquillan


value: artlessbfa

value: Show HN: Maude the Unicorn Slayer – Disrupting Series-B startups in 16-bit

author: artlessbfa


value: sdubois

value:
I ported Karpathy's microgpt [1] to TypeScript. It implements a complete GPT-2 architecture (autograd, tokenizer, multi-head attention, RMSNorm, and Adam optimizer), all in ~500 lines with zero runtime dependencies. It runs natively in the browser, no Python runtime or backend needed.
You can try it in the playground: https://microgpt-ts.vercel.app/playground
There are preset datasets (baby names, Pokemon, company names, movie titles, etc.) or you can paste your own text. The playground shows live loss curves as the model trains, and you can step through generation one token at a time to see the probability distribution at each step.
One difference from Karpathy's original is style. His microgpt is a single Python script optimized for brevity. This version splits the code into a few small files, types everything, and uses named helper functions (dotProduct, transpose, mean) instead of terse one-liners. The tradeoff is a bit more code, but it's easier to read and follow.
I built it up following the same progression as the blog post: bigram count table, then MLP with manual gradients, then autograd, single-head attention, multi-head + layer loop, and finally Adam. Each step is a separate PR and tag on GitHub [2] so you can follow along or check out any snapshot.
[1] https://karpathy.github.io/2026/02/12/microgpt/
[2] https://github.com/dubzdubz/microgpt-ts

value: Show HN: Microgpt-ts – Full GPT in 500 lines of TypeScript, zero dependencies

author: sdubois


value: Nikitaita

value:
Built a JS library for reading and writing Apache Parquet files that actually fits on edge runtimes (CF Workers, Vercel Edge, Deno Deploy, etc.)
326KB total, zero dependencies, two functions: readParquet and writeParquet.
Flat schemas only — no nested types. Great for logs, events, analytics. ~100KB write takes ~5ms, ~20 MB/s throughput.
Been running it in production with millions of events per day. Rust/WASM core is ~440 lines.
npm install tiny-parquet
https://github.com/nktrchk/tiny-parquet

value: Show HN: Tiny-parquet – JavaScript lib to read/write Parquet in 326KB of WASM

author: Nikitaita


value: Show HN: Stupid simple e-ink RSS reader

title: Show HN: Stupid simple e-ink RSS reader


value: normanbell

value:
We built a local-first writing editor that records the composition process (keystrokes, paste events, AI interactions) and exports a PDF with annotation highlights + an AI usage appendix.
The motivation: AI detectors are genuinely broken. Stanford research showed >60% false positive rates for non-native English writers on TOEFL essays. The "solution" from institutions has been to buy more detectors or make the policies so broad that either the student can do nothing if they are accused or the teacher can do nothing if the student does not make an admission.
Instead of trying to detect AI use after the fact, we give students a way to record their process as they write. The exported PDF shows a professor exactly what was human-written, what was AI-assisted, and what was pasted from external sources.
Tech stack:
- NiceGUI (Python) for the editor
- Quasar Q-Editor (contenteditable) with JS paste/ghost-completion hooks
- Dual PDF engine: WeasyPrint (CSS rendering) with ReportLab fallback (pure Python, works on Windows)
- Ollama integration for local AI (recommended model: qwen2.5:0.5b, ~400MB)
- TWFF (Tracked Writing File Format): ZIP-based container with XHTML content + process-log.json with SHA-256 chained hash
The format spec (TWFF) is open. Anyone can implement it. We're trying to get at least one other tool to support it before calling it a "standard".
Demo: https://firl.nl/twff
Spec: github.com/Functional-Intelligence-Research-Lab/twff

value: Show HN: Glass Box: writing editor that exports a verifiable PDF of your process

author: normanbell


value: gitsual

value:
OpenPDB creates AI agents with distinct personalities from a database of 12,000+ characters. Each agent has unique voice, values, and worldview—not generic responses. Ask Batman about creative blocks →
 strategic, character-driven response instead of a list. Works locally with Ollama or via Google Colab demo. Integrates with OpenGoat for multi-agent collaboration. Free and open source.

value: Show HN: OpenPDB – Generate AI agents with real personalities

author: gitsual


value: AlexandruEneDev

value: Show HN: Rappelo – A small tool for solopreneurs to capture leads faster

author: AlexandruEneDev


value: Show HN: Search through half a million works of art using natural language


value: sergiomattei

value:
Hi HN :)
Over the past couple of weeks, I got pretty intrigued by the rise of OpenClaw and agent harnesses like Pi.
At some point, I decided I wanted to make my own in order to learn how these things work. I learn by doing, and it seemed like a fun project. So I started building my own OpenClaw in TypeScript--but at some point realized I'd rather start from first principles, so instead I shifted focus towards building my own agent harness.
Something curious happened though: the more I looked at the problem space (agent system, running tools, etc)--the more it looked like Erlang/OTP to me. I had a hunch that Elixir would be a great fit for this problem.
I started building it and effectively, yes! It was a great fit. The agent loop maps perfectly to an Erlang GenServer/gen_fsm, parallel tool execution is easy by just spawning cheap Erlang processes, and multiple agents/subagents can be isolated in one system as separate supervision trees. This is all a lot of stuff I would've had to reinvent if another language was used.
Erlang/OTP is an amazing system. This setup gives me incredible observability into running agent systems--I can remote iex to the server binary and manipulate the system, end tool execution. The agent can debug itself by connecting to its own running instance. And, in the future, you can probably network these using Erlang distribution as well!
So far, in terms of features, the harness is minimal but packs a punch.
- Read/write files
- Shell calls
- Multiplatform
- Subagent support
- Asking questions
- Nice CLI :)
All in all, this project has been very fun to build. It's finally at the point where it's building itself and that's very rewarding to watch.
https://github.com/matteing/opal
Take a look at the GitHub, drop a star, and let me know any feedback? It's my first time building an agent system, so any input is welcome. Thank you!

value: Show HN: A minimal coding agent in Elixir (Erlang/OTP)

author: sergiomattei


value: MbBrainz

value:
I built TTSLab — a free, open-source tool for running text-to-speech and speech-to-text models directly in the browser using WebGPU and WASM.
No API keys, no backend, no data leaves your machine.
When you open the site, you'll hear it immediately — the landing page auto-generates speech from three different sentences right in your browser, no setup required.
You can then try any model yourself: type text, hit generate, hear it instantly. Models download once and get cached locally.
The most experimental feature: a fully in-browser Voice Agent. It chains speech-to-text → LLM → text-to-speech, all running locally on your GPU via WebGPU. You can have a spoken conversation with an AI without a single network request.
Currently supported models: - TTS: Kokoro 82M, SpeechT5, Piper (VITS) - STT: Whisper Tiny, Whisper Base
Other features: - Side-by-side model comparison - Speed benchmarking on your hardware - Streaming generation for supported models
Source: https://github.com/MbBrainz/ttslab (MIT)
Feedback I'd especially like: 1. How does performance feel on your hardware? 2. What models should I add next? 3. Did the Voice Agent work for you? That's the most experimental part.
Built on top of ONNX Runtime Web (https://onnxruntime.ai) and Transformers.js — huge thanks to those communities for making in-browser ML inference possible.

value: Show HN: TTSLab – Text-to-speech that runs in the browser via WebGPU

author: MbBrainz


value:
Hi HN,
MCP (Anthropic) connects agents to tools. A2A (Google) connects agents to tasks. But no protocol exists for agents to network on behalf of people. That's what we built.
Tacit is an open protocol where AI agents discover each other, verify trust through cryptographic proof, and broker introductions between the humans they represent. Both sides must explicitly consent before anything happens.
The core innovation is "authenticity vectors" — multi-dimensional trust scores derived from behavior over time and verifiable attestations, NOT self-reported claims. Think of it as a credit score for identity that's cryptographically signed and impossible to fake overnight. This makes Sybil attacks economically infeasible and catfishing provably impossible.
Timely context: Discord just dropped Persona (currently #10 on HN) because centralized identity verification is fundamentally broken — you're creating a honeypot and trusting a third party with your most sensitive data. Tacit takes the opposite approach: W3C DIDs for decentralized identity, DIDComm v2 for E2E encrypted messaging, Verifiable Credentials for attestations. No central authority. No data harvesting. Your keys never leave your device.
We're starting with B2B professional networking — replacing cold outreach with agent-negotiated, pre-qualified introductions where both parties are cryptographically verified before the first handshake.
Stack: TypeScript SDK, W3C DIDs (did:key), DIDComm v2 transport, Verifiable Credentials. Protocol spec, whitepaper, and working demo in the repo.
MIT licensed. No tokens. No blockchain. No VC. Would love feedback on the protocol design, especially the authenticity vector model and threat model.
https://tacitprotocol.com

value: Show HN: Tacit – The missing Layer 3 of the AI agent stack (open source)


value: secbear

value:
The core of every agent framework is the same ReAct loop. It's commodity code. What actually matters is everything around that loop — how you manage context windows, how you pipeline tool execution, how you handle durability and replay. These are hard problems with real design trade-offs, and yet every framework bundles them into one monolith where you buy all of it or none of it.
neuron is the layer below frameworks. It defines trait boundaries — `Provider`, `Tool`, `ContextStrategy` — and ships working implementations of each as independent crates. You get four context compaction strategies without pulling a single provider. You get the Anthropic provider without the tool registry. You get MCP support without the agent loop. The analogy is `serde` and `serde_json`: one crate defines the traits, the others implement them, and you compose what you need.
v0.3 is 12 crates. Three providers (Anthropic, OpenAI, Ollama), composable tool middleware with a `#[neuron_tool]` proc macro, four context compaction strategies, an agent loop with cancellation and parallel tool execution, full MCP support across both stdio and Streamable HTTP, sessions, guardrails with sandboxing and permission policies, and a dedicated OpenTelemetry crate following the GenAI semantic conventions. Rust 2024 edition, native async traits.
Adding a provider is adding a crate. The existing provider crates serve as templates — implement the `Provider` trait from `neuron-types`, wire up streaming, and you have a first-class citizen in the ecosystem. The same goes for context strategies, tool middleware, and session backends. More provider and integration crates are on the roadmap, but the architecture is specifically designed so that you or your agent can add them without waiting on me.
That last point is deliberate. The repo ships with `CLAUDE.md`, `llms.txt`, and architecture docs written to be machine-readable. An LLM agent can pull the codebase, understand the trait boundaries, and start building against them. If you're using Claude Code or similar tools to scaffold new integrations, neuron is optimized for that workflow.
Looking for feedback on the crate boundaries and API surface. The docs site walks through the reasoning behind specific trade-offs — why axum-style middleware instead of tower, why `DurableContext` wraps side effects rather than observing them, why the flat `Message` struct instead of variant-per-role.
Repo: https://github.com/SecBear/neuron
Crates: https://crates.io/crates/neuron

value: Show HN: Neuron – Independent Rust crates for building AI agents

author: secbear


value:
Hi HN,
A while ago I had a mildly depressing realization.
Back in 2010, I had around $60k. Like a "responsible" person, I used it as a down payment on an apartment. Recently, out of curiosity, I calculated what would have happened if I had instead put that money into NVIDIA stock.
I should probably add some context.
For over 10 years I've worked as a developer on trading platforms and financial infrastructure. I made a rule for myself - never trade on the market.
In 2015, when Bitcoin traded about 300 usd, my brother and I were talking about whether it was a bubble. He made a bold claim that one day it might reach $100k per coin. I remember thinking it sounded unrealistic - and even if it wasn't, I wasn't going to break my rule.
That internal tension - building systems around markets while deliberately staying out of them is probably what made the "what if?" question harder to ignore years later.
The result was uncomfortable. The opportunity cost came out to tens of millions of dollars.
That thought stuck with me longer than it probably should have, so I decided to build a small experiment to make this kind of regret measurable:
https://shouldhavebought.com
At its core, the app does one basic thing:
you enter an asset, an amount, and two dates, and it gives you a plain numeric result - essentially a receipt for a missed opportunity.
I intentionally designed the UI to feel raw and minimal, almost like a late-90s terminal. No charts, no images, no emotional cushioning - just a number staring back at you.
What surprised me wasn't the result, but how much modern web infrastructure it took to build something that looks so simple.
Although the app is a single page with almost no UI elements, it still required:
- Client-side reactivity for a responsive terminal-like experience (Alpine.js)
- A traditional backend (Laravel) to validate inputs and aggregate historical market data
- Normalizing time-series data across different assets and events (splits, gaps, missing days)
- Dynamic OG image generation for social sharing (with color/state reflecting gain vs loss)
- A real-time feed showing recent calculations ("Wall of Pain"), implemented with WebSockets instead of a hosted service
- Caching and performance tuning to keep the experience instant
- Dealing with mobile font rendering and layout quirks, despite the "simple" UI
- Cron and queueing for historical data updates
All of that just to show a number.
Because markets aren't one-directional, I also added a second mode that I didn't initially plan: "Bullet Dodged".
If someone almost bought an asset right before a major crash, the terminal flips state and shows how much capital they preserved by doing nothing. In practice, this turned out to be just as emotionally charged as missed gains.
Building this made me reflect on how deceptive "simplicity" on the web has become. As a manager I know says: "Just add a button". But even recreating a deliberately primitive experience today requires understanding frontend reactivity, backend architecture, real-time transport, social metadata, deployment, and performance tradeoffs.
I didn't build this as a product so much as an experiment - part personal curiosity, part technical exploration.
I'd be very interested to hear how others think about:
Where they personally draw the line on stack complexity for small projects?
Whether they would have gone fully static + edge functions for something like this?
How much infrastructure is "too much" for a deliberately minimal interface?
And, optionally, what your worst "should have bought" moment was?
Happy to answer any technical questions or dig into specific implementation details if useful.

value: Show HN: Quantifying opportunity cost with a deliberately "simple" web app


value: tipsee

value: Show HN: I just released v7 Javalin, a JVM web framework

author: tipsee


value: unslop

value:
I built a CLI tool that turns codebases and PRs into diagrams so you can quickly understand how things fit together. Originally made it because I couldn't follow my own AI-generated repos.
Just shipped a big update:
- Switched from D2 to Mermaid for rendering
- Tree-sitter AST parsing + agentic flow instead of raw LLM calls. ~50x faster.
- Works on any GitHub repo or PR, not just local
- Dropped the web frontend, it's just a CLI now
- Published as a pip package
Still a ton to improve and I'm building fast. Feedback, issues, PRs all welcome.

value: Show HN: Noodles – Turn any codebase into a diagram with Claude and Tree-sitter

author: unslop


value: Brzzy

value:
I had a slightly absurd realization: despite all the UI polish on iOS, most weather apps are still just the same numbers in slightly different rectangles. So I built Brzzy. The idea was simple: what if checking the weather felt less like reading a spreadsheet and more like opening something fun? Brzzy turns forecasts into customizable GIFs you can tweak and share. Pick your vibe, set your tags (Star Wars, Harry Potter, whatever), and your forecast stops feeling alive!
I’m currently offering free lifetime access to Brzzy+ for anyone curious to try it.
Lifetime Brzzy+ code: monkey
Redeem inside the Brzzy+ section of the app, scroll down to secret code.

value: Show HN: Forecasts as GIFs (Free Lifetime Access)

author: Brzzy


value:
Hey HN,
I often work with CSV and JSON files that are a bit messy - duplicates, inconsistent formatting, or just hard to inspect.
I usually end up jumping between Excel, scripts, and random online tools.
So I started building a small browser-based tool to make this easier.
Right now it lets you:
- Convert between JSON, CSV, Excel formats
- Remove duplicates quickly
- Filter and reshape data visually
- Inspect basic issues in the file
and few more.
Everything runs in the browser - no uploads to a server.
It’s still early, but I’d love to know your experience and thoughts about the product.
Maybe I am missing something or thinking wrong, your response will really matter.
So looking forward for your feedback.
I would like to ask:
- what is that thing in your data workflows or data tasks, that feels like slowing you or like giving a sharp pain regularly?
Link: https://www.datumintapp.com/

value: Show HN: A fast way to clean and convert messy CSV/JSON files in the browser


value: caioaao

value: Show HN: Code Execution for LLMs via a Sandboxed Lua REPL

author: caioaao


value: Dagryl

value:
I’m building rungs.dev. The IDE runs at https://studio.rungs.dev
What it does now:
- Build AOIs in Structured Text and Ladder Logic
- Run in-browser simulation
- Write and run AOI tests
- Inspect trend-style execution data
Goal: faster AOI iteration for educational purposes.
Feedback wanted:
- Which PLC concepts/workflows are hardest to learn?
- What’s missing before this is useful for class/self-study?
- Where this feels better or worse than existing tools?

value: Show HN: Rungs.dev – IDE for PLC AOIs with Structured Text and Ladder Logic

author: Dagryl


value: Slns

value: Show HN: DataPorter – Rails engine for data imports

author: Slns


value: Tomasmillar

value: Show HN: Bel interpeter vibe coded with Claude Code

author: Tomasmillar


value: mickamy

value:
Hi HN, I shared sql-tap here a few weeks ago — a transparent SQL proxy that captures every query and lets you inspect it in real-time. Thanks for the feedback last time.
Two big additions:
*Built-in Web UI* — Add `--http=:8080` and open your browser. It's a zero-dependency vanilla JS SPA embedded in the binary — nothing extra to install or deploy. Features:
- Real-time query stream via SSE
- SQL syntax highlighting
- Click to inspect details, run EXPLAIN / EXPLAIN ANALYZE
- Query statistics view with normalized grouping (count, errors, avg/total duration)
- Structured filter (`d>100ms`, `op:select`, `error`)
- Transaction grouping (collapsible)
- Slow query colorization
- Pause / Clear controls
- Export captured queries as JSON or Markdown
- Copy query with bound args
- N+1 detection (toast notification + row highlight)
*N+1 query detection* — sql-tap now automatically detects when the same SELECT template is executed 5+ times within 1 second (configurable). Both TUI and Web UI show flagged queries in real-time — every query in the pattern is marked, not just the first one. Thresholds, time window, and alert cooldown are all tunable via CLI flags. `--nplus1-threshold=0` to disable.
Other updates since v0.0.1:
*TUI improvements*
- Structured filter mode (`f`): `d>100ms`, `op:select`, `error`, combinable with AND logic
- Analytics view (`a`): aggregate queries by template, sort by total/count/avg duration
- Export to file (`w`): save captured queries as JSON or Markdown
- Copy with bound args (`C`): substitutes `$1`/`?` placeholders with actual values
- Sort by duration (`s`), half-page scrolling (`Ctrl+d`/`Ctrl+u`)
- Alert overlay for copy/export operations
*Database support*
- TiDB support (`--driver=tidb`)
- MySQL 9 compatibility
- Fixed PostgreSQL binary parameter decoding (UUIDs, etc.)
The proxy works the same way: point your app at sql-tapd instead of your database, no code changes needed. It parses the native wire protocol to capture queries, prepared statements, transactions, and errors transparently.
Written in Go, single binary, install via Homebrew (`brew install --cask mickamy/tap/sql-tap`) or `go install`. This is a solo side project — if you find it useful, a star on GitHub would mean a lot.

value: Show HN: SQL-tap now has a browser-based Web UI

author: mickamy


value:
WHY was I SSH’ing into my laptop from my phone at parties?!
Either I had a feature idea I wanted an agent to build right then, or I was worried my agents were blocked waiting on my decision.
It dawned on me: humans are just another dependency in an agent workflow, so I turned myself into a tool-call.
I built an iOS app (Extendo) where agents can reach me to request approvals, choices, or plan reviews.  They just use a CLI tool and skill.  My phone buzzes. I answer in seconds. The agent gets back to work.
The key: the agent blocks until you respond, and receives your answer along with your verbal feedback.
What you can do from your phone:
- approvals and checklists
- option buttons and rankings
- markdown plan reviews (tap-hold individual paragraphs to add voice comments is so satisfying!)
- kanban boards
- voice responses
- capture ideas on Apple Watch/Action Button and dispatch them to the right agent later
It’s a voice-first native iOS interface with push notifications.  Push notifications are critical: the interaction needs to take seconds, not minutes.
```<p>extendo artifact create my_server implementation-choice
  --type multiple_choice
  --title "Where should we implement the rate limiter?"
  --option "backend:Backend API"
  --option "core:Core Library"
  --option "edge:Edge/CDN"
  --option "gateway:API Gateway"<p>```
If an agent can run bash, it can reach you.
I’ve been using it with Claude Code, OpenClaw, Pi, and custom scripts.
The backend protocol is open: you should self-host for tighter integration with your system (though there's a shared server available). There’s also an OpenClaw plugin and a Claude Code harness in the repo, a core library, and sample code to customize your own backend.
I used Extendo to build Extendo: design decisions, approvals, plan reviews, prioritization.  Agents coded. I made decisions while walking the dog and between sets at the gym.
*Links*
3-min demo: https://www.youtube.com/watch?v=X5Dv9fU7Lb8
TestFlight: https://testflight.apple.com/join/PGHRCnQ4
GitHub: https://github.com/egradman/extendo-cli

value: Show HN: Turn human decisions into blocking tool-calls for AI agents (iOS+CLI)


value: ThatGuyRaion

value: As part of my february web dev work, I got IRIXNet updated with a new design for all but the classic forum mode.

value: Show HN: I Redesigned IRIXNet

author: ThatGuyRaion

title: Show HN: I Redesigned IRIXNet


value: ivannovazzi

value:
Tired of .env files getting out of sync across team members and environments? KeyEnv is a CLI-first secrets manager that replaces scattered .env files with a secure, encrypted store.
- Pull secrets with a single command: keyenv pull
- Secrets are AES-256-GCM encrypted at rest
- Per-project, per-environment scoping (dev/staging/prod)
- Team access controls + full audit trail
- Works with existing apps that read from environment variables — zero code changes
The problem we kept running into: teams share secrets over Slack, check in .env.example files with real values, or have 5 different versions of the same key floating around. KeyEnv eliminates the category.
We'd love feedback, especially from teams dealing with microservices or multi-environment setups.

value: Show HN: KeyEnv – manage team secrets without scattered .env files

author: ivannovazzi


value: MrTravisB

value:
Hello HN,
We are the team behind Tabstack (https://tabstack.ai) - part of Mozilla. We just open sourced Pilo (pronounce PIE-low), the core engine that powers our automation platform. You can check it out on Github at https://github.com/mozilla/pilo.
Pilo is an agentic web automation library. Instead of writing rigid scripts with CSS selectors, you give it a natural language goal (e.g., "Find the best pizza in Seattle and extract the ratings") and it autonomously navigates the browser to achieve it.
We built this because we were struggling to make reliable agents for our own /automate endpoint. Existing tools were either too brittle (breaking on minor DOM changes) or too heavy (feeding raw HTML to LLMs, blowing up context windows).
Here is how Pilo solves those problems:
- Accessibility Tree over HTML: Instead of parsing raw HTML "soup," Pilo captures the browser's accessibility tree (via Playwright's _snapshotForAI). This gives the LLM a semantic, stable view of the page (buttons, links, inputs) rather than div hell.
- Context Compression: We pipe that tree through a compression engine. We map verbose tags (like listitem -> li), shorten reference IDs, and deduplicate repetitive text. This reduces token usage by 60-80% without losing interactive elements, allowing for much longer agent loops.
- Layered Error Handling: The web is flaky. Pilo treats navigation failures as distinct from interaction failures. It uses timeout escalation for network issues (doubling wait times) and will automatically restart the browser instance if it detects a "stuck" state or DNS failure.
- Agentic Loop: It follows a strict Plan -> Observe -> Act -> Validate loop. It even includes a separate validation step where a second LLM "grades" the final output against the original success criteria before returning it.
The "Cool" Part (Browser Extension) Since the core logic is decoupled from the runtime, we packaged it into a browser extension. You can install it, type a prompt, and literally watch the agent drive your local browser tab in real-time. It’s a great way to debug how the LLM "sees" the page.
Why Open Source? We sell the managed infrastructure (scaling browsers, persistent sessions, etc.) at Tabstack. But the execution engine itself, the thing that decides "click here" or "scroll there", should be open. You can run Pilo entirely on your own machine with your own API keys without paying us a dime.
You can read more about it on our blog https://tabstack.ai/blog/introducing-pilo-browser-automation.
Or check out the repo, install it, and give it a try - https://github.com/mozilla/pilo
We’d love to hear your feedback on the compression pipeline or how you’re handling agent state in your own projects.
Happy to answer any questions!

value: Show HN: Pilo – open-source agentic web automation engine by Mozilla

author: MrTravisB


value: jundot

value:
I was frustrated that coding agents like Claude Code were basically unusable with local models. every few turns the prefix shifts, KV cache gets invalidated, and your mac has to re-prefill the entire context from scratch.
So i built oMLX. it persists KV cache blocks to SSD, and when a previous context comes back, it restores from disk instead of recomputing. this alone made Qwen3-Coder-80B on my M3 Ultra actually usable for real coding sessions.
Some other stuff it does: continuous batching, multi-model serving (LLM + embedding + reranker at once), prefix sharing with copy-on-write, and a native mac menubar app so you don't have to touch the terminal.
Just shipped a built-in benchmark tool too, so you can test your own setup easily.

value: Show HN: oMLX – coding agents on local LLMs without the painful reprefill

author: jundot


value: anatolidp

value:
Ive been working on zym, its a dynamic scripting language meant to be embedded in a host application or in smaller systems.
I built Zym because i wanted a touch more control in a scripting language. Most languages ask for a tradeoff: you get flexibility, expressiveness, and fast iteration, but you give up control over how your data moves, how your stack behaves, and how your runtime executes code. If you want that control back, the conventional answer is to drop down into a compiled, statically-typed language.
This is my attempt to sort of harness both sides together in a way without making them fight each other. It's a scripting language that stays out of your way when you want to move fast, and gets precise when you need it to.
Its pretty standard syntax for what a dynamic language would expect, functions, looping, variables, other stuffs on the surface but with a touch of manual control flow.
Zym's control surface is where it splits:
Explicit memory semantics — ref, slot, and val modifiers let you declare exactly how values move across function boundaries.
Delimited one shot continuations as a primitive — Zym provides the building blocks to build out control flow as needed/wanted instead of relying on a set model, allows for construction of coroutines, fibers, generators, async, unconventional control flow, whatever it is thats needed.
Script-directed TCO — Zym provides scope aware tco compiler directives, basically u tell compiler this return function i wanna jump, it does it no questions asked.
Instruction-count preemption — the VM supports time-slicing by instruction count via a host pump and script callback, not just cooperative yields. Really handy for fair scheduling.
Simple(ish) 2 way FFI - Zym was designed to be embedded. Its ffi is fairly simple to work with and provides the ergonomics of writing natives more directly like you would write a function normally rather than a lot of manual stack juggling. Allows reentry so one can move in and out of c land fairly simply.
Still early days and I am constantly working on it — would love feedback on the design, especially the memory semantics model and the continuation useage.
Playground (WASM): https://zym-lang.org/playground
Docs/Site: https://zym-lang.org/docs
Github: https://github.com/zym-lang/zym

value: Show HN: Zym, embeddable script lang with continuations, preemption, mem control

author: anatolidp


value: stefanhoelzl

value: Show HN: CodeHydra – Run multiple isolated AI coding agents in parallel

author: stefanhoelzl


value: Sayyidalijufri

value: Show HN: I built tool that automatically inserts text behind any object on image

author: Sayyidalijufri


value: oliveroll

value:
Hi HN, I built PriceTagGenerator, a tool for e-commerce sellers to add clean price tags / sale badges to product photos fast (Shopify/Amazon/Etsy).
The goal is to skip Photoshop/Canva and do bulk edits in minutes.
Looking for feedback on: which badge/tag styles you actually use, and what would make this fit into your workflow.

value: Show HN: I built a tool to generate clean price tags for small retailers

author: oliveroll


value: bigEnotation

value:
Tested it out this [weekend](https://ctftime.org/team/425785), spent $100 across xai ($35), google($35), anthropic($25).
- xai:grok-4-1-fast-reasoning solved 8
- google:gemini-3-flash-preview solved 5 (building on xai)
- anthropic:opus-4-5 couldn't solve any additional ones - also was a bit annoyed by the constant 429 ratelimiting, wished I had instead switched to openai, but I didn't want to keep spending money.
Did pretty good for web and cryto, less so for pwn
Built based on devcontainers.

value: Show HN: Prompt2pwn – CTF Automated Solver

author: bigEnotation


value: nxnze

value: Show HN: Ghist – Task management that lives in your repo

author: nxnze


value: bturtel

value:
Hey HN, I fine-tuned a small open-source model on golf forecasting and it beats GPT-5 at predicting golf outcomes. The same approach can be used to build a specialized model in any domain, you just need to update a few search queries.
We fine-tuned gpt-oss-120b with LoRA on 3,178 golf forecasting questions, using GRPO with Brier score as the reward.
Our model outperformed GPT-5 on Brier Skill (17% vs 12.8%) and ECE (6% vs 10.6%) on 855 held-out questions.
How to try it: the model and dataset are open-source, with code, on Hugging Face.
How to build your own specialized model: Update the search queries and instructions in the Lightning Rod SDK to generate a new forecasting dataset, then run the same GRPO + LoRA recipe.
SDK link: https://github.com/lightning-rod-labs/lightningrod-python-sd...
Dataset: https://huggingface.co/datasets/LightningRodLabs/GolfForecas...
Model: https://huggingface.co/LightningRodLabs/Golf-Forecaster
Questions, feedback on the SDK, suggestions for new domains to try this on - all are welcome.

value: Show HN: Open-source LLM and dataset for sports forecasting (Pro Golf)

author: bturtel


value: Show HN: Digital Janitor – A 1-click Python script to auto-sort messy downloads


value: ignasheahy

value:
I have something to show you - it's a unique platform I've been working on and lately it has picked up some pace, so it's now more mature.
Check out https://heahy.com (or special chat made for you: https://heahy.com/c/hackernewschat)
There you can:
-Create public channels and chats by simply entering a name (like IRC), and if it's free, it's yours, or you join it otherwise.
-Each thread is real-time, so you can chat with other people there - no need to refresh for new comments.
-4chan-like reply system - it doesn't use nested comments because that wouldn't work with a real-time chat system, but there is a structure that allows you to manage different conversations. For example, if you click a post, you will see all posts that led to that post on the right sidebar. You can also double-click and that post becomes the root post (kind of like tweets/comments on X.com).
-Create private groups and personal chats with other people.
-Supports P2P live audio/video calls (up to 8 people) in all private chats and in public chats if the channel allows (you can test it by clicking Create call in the @random chat channel)
-Video/image uploads (up to 8MB now) and the ability to save media to your library for later viewing
-You can follow channels, chats, threads and users, and all those posts appear on your feed in a simple chronological order
-Unlike Discord: no tracking, advertisements, AI, paywalls, registrations; nothing is hidden behind a server - just a web page fully accessible and searchable both in the app and by search engines
On the immediate roadmap:
-Mobile apps (Android first)
-Chat Match portal - Create a simple poster with one picture, tags for filtering, and a description of what you are searching for, and match with other posters to start DMs.
-Reactions/GIFs - instead of integrating with Tenor or similar, Heahy will have its own reactions library.
-Long-form text/blogs - Channels will be able to have rich long text threads, basically allowing you to have a blog on Heahy.
I am really looking forward to hearing some feedback and constructive criticism. What do you think?

value: Show HN: If Discord, Reddit, X, IRC and 4chan had a baby

author: ignasheahy


value: buva

value: Show HN: SQL Crack – Local-first SQL visualizer with column lineage

author: buva


value: Show HN: Vendor.rip - Fleet Agent Skill to replace SaaS


value: sahair

value: Show HN: Toolrelay.io – Connect Your SaaS to AI

author: sahair


value: Show HN: Making missed workouts cost money with Android TEE and smart contracts


value: masqueradeorm

value: Show HN: MasqueradeORM – Memory Efficient Node ORM: Just Write Classes

author: masqueradeorm


value: FlynnLachendro

value: Show HN: Lattice – Track what top AI labs are publishing daily

author: FlynnLachendro


value: ramonga

value: Show HN: OpenLingo – Connecting Sonnet 4.6 to a Duolingo-like interface

author: ramonga


value: selectedambient

value: FFmpeg wrapper with a modern GUI — batch processing, YouTube downloading via yt-dlp, metadata editing, and real-time progress. Built because Adobe Media Encoder uses 200MB to display a button.

value: Show HN: LoMux – Lightweight FFmpeg GUI in Rust (3MB Binary)

author: selectedambient


value: philcunliffe

value: I got tired of clickbait thumbnails on youtube so I created an extension that replaces all thumbnails with a frame from the video. There are options for static percentage or most watched moment.<p>It's help me avoid a lot of real bad videos, enjoy!

value: Show HN: Unthumb – Replace YT thumbnails with frames from the video

author: philcunliffe


value: onecommit

value:
Hey HN! We’re Arne and Raban, the founders of Emdash (https://github.com/generalaction/emdash).
Emdash is an open-source and provider-agnostic desktop app that lets you run multiple coding agents in parallel, each isolated in its own git worktree, either locally or over SSH on a remote machine. We call it an Agentic Development Environment (ADE).
You can see a 1 minute demo here: https://youtu.be/X31nK-zlzKo
We are building Emdash for ourselves. While working on a cap-table management application (think Stripe Atlas + Pulley), we found our development workflow to be messy: lots of terminals, lots of branches, and too much time spent waiting on Codex.
Emdash puts the terminal at the center and makes it easy to run multiple agents at once. Each agent runs as a task in its own git worktree. You can start one or a few agents on the same problem, test, and review.
Emdash works over SSH so you can run agents where your code lives and keep the parallel workflow. You can assign tickets to agents, edit files manually, and review changes.
We also spent time making task startup fast. Each task can be created in a worktree, and creating worktrees on demand was taking 5s+ in some cases. We now keep a small reserve of worktrees in the background and let a new task claim one instantly. That brought task start time down to ~500–1000ms depending on the provider. We also spawn the shell directly and avoid loading the shell environments on startup.
We believe using the providers’ native CLIs is the right approach. It gives you the full capabilities of each agent, always. If a provider starts supporting plan mode, we don't have to add that first.
We support 21 coding agent CLIs today, including Claude Code, Codex, Gemini, Droid, Amp, Codebuff, and more. We auto-detect what you have installed and we’re provider-agnostic by design. If there’s a provider you want that we don’t support yet, we can add it. We believe that in the future, some agents will be better suited for task X and others for task Y. Codex, Claude Code, and Gemini all have fans. We want to be agnostic and enable individuals and teams to freely switch between them.
Beyond orchestration, we try to pull most of the development loop into Emdash. You can review diffs, commit, open PRs, see CI/CD checks, and merge directly from Emdash once checks pass. When starting a task, you can pass issues from Linear, GitHub, and Jira to an agent. We also support convenience variables and lifecycle scripts so it’s easy to allocate ports and test changes.
Emdash is fully open-source and MIT-licensed.
Download for macOS, Linux or Windows (as of yesterday !), or install via Homebrew: brew install --cask emdash.
We’d love your feedback. How does your coding agent development setup look like, especially when working with multiple agents? We would want to learn more about it. Check out our repository here: https://github.com/generalaction/emdash
We’ll be around in the comments — thanks!

value: Show HN: Emdash – Open-source agentic development environment

author: onecommit


value:
Hi HN! I'm Prithvi—my co-founder Frances and I launched Promptless almost a year ago here (https://news.ycombinator.com/item?id=43092522). It's an AI teammate that watches your workflows—code changes, support tickets, Slack threads, etc.—and automatically drafts doc updates when it spots something that should be documented.
Frances and I really appreciated the feedback from our first launch. Today we’re launching Promptless 1.0, which addresses our biggest learnings from the last 12 months.
I also made it way easier to try it out. You can tag @promptless on any open-source Github PR or Issue with a doc update request, and Promptless will create a fork and open a PR for your docs to help. Feel free to use our own docs as a playground: https://github.com/Promptless/docs/issues
Or, you can sign up at https://promptless.ai to get free access for your own docs for the next 30 days. Here's a demo video: https://youtu.be/IWwimHCEY7Y
For me, the coolest part of the last year has been seeing how users got creative with Promptless. One user has Promptless listening in to all their Slack Connect channels, so whenever they answer a customer question, Promptless figures out if their docs should be updated and drafts an update if so. Another user has Promptless processing every customer meeting transcript and updating their internal docs after each meeting: customer dashboards, feature request pages, etc.
Some of the biggest things that are new with version 1.0:
- Automatically updating screenshots: this was by far our most requested feature. The need here was always clear.  People would exclude screenshots from docs because they’d get stale quickly, even though they knew screenshots would be helpful to users. A year ago, we just couldn't ship a good enough solution, but given how much LLMs' visual grounding has improved in the last year, now we've got something we're proud of.
- Slop-free writing: The most common critique on early Promptless suggestions was that even though they were accurate, they could sound generic or verbose, or might just reek of AI slop. Promptless 1.0 is 3.5x better at this (measured by voice-alignment compared to what users actually published), through a combination of fine-tuned models, sub-agents, and alignment on user-defined preferences.
- Open-source program: We're especially proud of this—Promptless is now free for CNCF/Linux Foundation projects (reach out if you’re a maintainer!). You can take a look at how Promptless is supporting Vitess (a CNCF-graduated project) with their docs here: https://github.com/vitessio/website/commits
Check it out and let us know if you have any questions, feedback, or criticism!

value: Show HN: Tag Promptless on any GitHub PR/Issue to get updated user-facing docs


value: mnemoxai

value:
I kept building things that already existed. Last month I spent 6 hours on a tool before discovering 847 similar repos on GitHub.
So I built an MCP server that checks before your AI starts coding. Install with `uvx idea-reality-mcp`, and Claude/Cursor will automatically scan GitHub + Hacker News for existing implementations before writing a single line.
Returns: reality_signal (0-100), duplicate_likelihood, top 5 similar repos, evidence from multiple sources, and pivot suggestions.
It's a protocol layer, not a SaaS dashboard — the check happens inside your IDE workflow.
Python, MIT licensed, zero config. Would love feedback on the scoring algorithm.

value: Show HN: Idea Reality MCP – Pre-build reality check for AI coding agents

author: mnemoxai


value: JacobDivbyzero

value:
I built GhostVM to make running untrusted or experimental code on macOS safer without sacrificing the dev experience.
It runs a full macOS VM using Apple’s virtualization framework, with snapshots and explicit host bridges (clipboard, file transfer, ports) so you can control what crosses the boundary.
I originally built it to sandbox agent-driven workflows and risky installs I wouldn’t run directly on my host machine. Happy to answer questions or discuss tradeoffs.
Website + docs: ghostvm.org

value: Show HN: GhostVM – native macOS VMs for secure dev and isolated agent workflows

author: JacobDivbyzero


value:
Despite the name, OpenRouter's core isn't truly open. I’m building open-next-router (ONR) to change that.
Inspired by Nginx’s atomic configuration philosophy, ONR allows developers to integrate and switch between various LLM channels through simple config files rather than writing boilerplate code. The goal is to move away from "hard-coded integrations" and toward a modular, high-performance routing layer.
I'm aiming to build the "Nginx for the LLM era." It’s still in the early stages, and I’d love to get feedback from the community or collaborate with anyone interested in the future of open LLM infrastructure.

value: Show HN: Open-next-router (ONR) – An Nginx-inspired, config-driven LLM router


value: murzynalbinos

value:
I posted the first version here a few months ago, but today I've got a massive update, that I wanted to share...
So basically Log Voyager is a client-side log analyzer that can open multi-gigabyte log files (10GB+) in the browser without crashing, using the File Slicing API to stream chunks rather than loading everything into memory.
Technical approach: Instead of reading the entire file into RAM (which crashes browsers on 2GB+ files), LV use File.prototype.slice() to read 50KB chunks via FileReader. This keeps memory usage constant at ~10MB regardless of file size. For GZIP files I use the native DecompressionStream API.
What's new in v2.0:
- Command Palette (Ctrl+K) for keyboard-driven navigation
- Multi-Filter: apply multiple include/exclude filters simultaneously with regex support
- Error Aggregation: groups similar errors by pattern, shows occurrence counts
- Split View: two independent panels for comparing different file sections
- Heatmap Navigation: visual error density on minimap (red=error, orange=warn)
- Log Statistics: real-time level distribution with bar charts
- Export Selection: export specific lines as TXT/JSON/CSV
- Dark/Light theme toggle
- Full keyboard shortcut system (Vim-style navigation for search, bookmarks, etc.)
Thanks for checking it out (and very appreciate feedback)!
Code: https://github.com/hsr88/log-voyager

value: Show HN: Log Voyager 2.0 – Analyze 10GB+ log files in the browser

author: murzynalbinos


value: Show HN: Cadre – Agent framework for Claude Code with persistent memory


value: rikroots

value:
I’ve been working on a small proof-of-concept screen-recording tool that runs entirely in the browser. It lets you capture screens or windows, add a talking-head camera feed, layer multiple targets, drag and scale them, draw annotations directly on the canvas, and record everything to a local MP4/WebM file. There’s no backend, no build step, and no external dependencies apart from MediaPipe and Scrawl-canvas.
The project is intended to be hackable rather than polished, and includes a keyboard-accessible UI and a step-by-step walkthrough. Code and demo are here:
GitHub: https://github.com/KaliedaRik/sc-screen-recorder
Feedback very welcome.

value: Show HN: SC Screen Recorder: a browser-based screen recorder with added layers

author: rikroots


value: shreyask

value:
Sift through the noise. Score your feed with EmbeddingGemma, right in the browser.
Sift is a Chrome MV3 extension that runs fully client-side using WebGPU + Transformers.js. It scores posts on Hacker News, Reddit, and X and dims low-relevance items so the good stuff stands out.
Users can label items (/) to collect training data, export it as CSV, and fine-tune the model using the included Python pipeline.
Demo video:
https://github.com/user-attachments/assets/83430c6b-b7fa-41c...
Repo:
https://github.com/shreyaskarnik/Sift
Would love feedback!

value: Show HN: Sift – Score your feed locally with EmbeddingGemma

author: shreyask


value: midlifedad

value:
I built YouAM because AI agents have no standard way to find or message each other. If you have a LangGraph agent and I have a CrewAI agent, there's no "email" between them. YouAM fixes that.
Every agent gets:
- A routable address: name::youam.network
- A signed contact card (name, public key, relay endpoint)
- An encrypted inbox with store-and-forward delivery
Messages are NaCl Box encrypted end-to-end. The relay never sees plaintext. You can run your own relay or use the public one.
60-second quickstart:

    pip install youam

    from uam import Agent
    agent = Agent("myagent")
    await agent.send("socrates::youam.network", "What is virtue?")
    messages = await agent.inbox()

Three AI agents (Socrates, Oscar Wilde, Groucho Marx) are live on the network. You can message them from the site.
The first community on the network is Clawlink (clawlink.network) — they're using YouAM to give OpenClaw agents their own addresses and inboxes.
Python + TypeScript SDKs. PostgreSQL-backed relay. Apache 2.0.
Live demo: https://youam.network
Repo: https://github.com/youam-network/uam
Docs: https://docs.youam.network
Solo founder shipping v0.3 — would love brutal feedback.

value: Show HN: YouAM – An address, contact card, and encrypted inbox for AI agents

author: midlifedad


value: makmakapps

value: Show HN: MakLock – Free macOS App Locker with Touch ID and Apple Watch

author: makmakapps


value:
I've been working on a Rust CLI for dataset deduplication and wanted to share benchmark results. Ran on FineWeb sample-10BT (14.8M records, 29GB) on a single machine.
Exact dedup vs DuckDB + SHA-256:
2:55 vs 7:55 wall clock (2.7x faster)
688MB vs 21.9GB peak RAM (32x less)
Single core vs 4+ cores
Duplicate counts match exactly (51,392 both ways)
Fuzzy dedup (MinHash + LSH) vs datatrove:
36:44 vs 3h50m+ — datatrove stage 1 alone ran for 3h50m and we killed it
datatrove's bottleneck turned out to be spaCy word tokenization on every document before shingling. fastdedup uses character n-grams directly which is significantly cheaper
23GB vs 1.1GB RAM — this is a real trade-off, not a win. datatrove streams to disk; fastdedup holds the LSH index in memory for speed
Honest caveats:
Fuzzy dedup needs ~23GB RAM at this scale — cloud workload, not a laptop workload
datatrove is built for distributed execution, tasks=1 isn't its intended config — this is how someone would run it locally
Tiered storage to spill LSH index to disk is on the roadmap
Demo: https://huggingface.co/spaces/wapplewhite4/fastdedup-demo
Repo: https://github.com/wapplewhite4/fastdedup
Happy to answer questions about implementation or methodology.

value: Show HN: Fastdedup – Rust dataset deduplication (2:55 vs. 7:55 688MB vs. 22GB)


value: valtlfelipe

value: Show HN: Hedit – Modern Hosts File Editor

author: valtlfelipe


value: ramoz

value: Show HN: Security Checklist for OpenClaw Deployments

author: ramoz


value: Like DoorDash for Internet trolls, Rent-a-Hater is a digital marketplace where users can pay what they want for other users to send memes, jokes, roasts, and taunts (within ToS guidelines) to a publicly accessible recipient (no private harassment or doxxing). Rent-a-Hater is meant for US-based 18+ users that agree to strict no-harassment/threat/bigotry guidelines and primarily serves a fun way to make a few extra bucks online. While the platform is fully functional with Stripe integration, leaderboards, and user anonymization, the platform is also meant to serve as a commentary on the predatory nature shared between the gig economy and rental companies, turning those who rely on them into, effectively, "haters".

value: Show HN: Rent-a-Hater

title: Show HN: Rent-a-Hater


value: lemagee

value: Show HN: Dreamscroll – Replace bedtime doomscrolling with nature photos

author: lemagee


value: clawforge

value:
AI assistants are going local.
Tools like OpenClaw let employees run AI agents directly on their machines — with file access, shell execution, web fetch, custom skills, etc.
That’s powerful.
But for enterprises, it creates a new problem:
• No visibility
• No policy enforcement
• No audit trail
• No kill switch
• No control
We built ClawForge, an open-source control plane for OpenClaw.
Think of it like MDM — but for AI assistants.
ClawForge gives organizations:
 • Org-wide tool allow/deny policies
 • Skill approval workflow
 • Audit logs for tool calls & sessions
 • Heartbeat monitoring
 • Emergency kill switch
 • SSO/OIDC auth
Architecture:
OpenClaw instance (employee machine)
→ ClawForge plugin
→ Control plane (API)
→ Admin console
Policies are enforced at the edge (client-side), not server-side blocking.
If the control plane is unreachable, it fails secure.
Repo:
https://github.com/ClawForgeAI/clawforge
Would love feedback from folks working on AI agents, DevTools, or enterprise security.

value: Show HN: ClawForge – MDM for AI assistants (governance for OpenClaw)

author: clawforge


value: oDot

value:
Happy to share the early version of Trolley, which will package your TUI app with Ghostty for non-technical users on MacOS and Linux, with Windows being a WIP.
This came about after writing a small TUI to allow a friend to back up their entire Vimeo library, and finding that while they enjoyed the simplicity and speed of the TUI, they did not like having to use the shell to get there, nor did they want to install a terminal like Ghostty for a better experience.
Trolley makes it easy to package apps for that kind of person. It's still very early, but I thought it'd be interesting to get some feedback, so let me know what you think.
If you're developing a TUI or considering a hog like Electron for an app that can be text-based, give Trolley a look.

value: Show HN: Trolley – Run terminal apps anywhere

author: oDot


value: umeshlamton

value:
I built connector-oss because I kept running into the same problem with
multi-agent AI systems: when something goes wrong, you have no cryptographic
ground truth of what any agent stored, read, or accessed. Log files are
mutable. There's no tamper-proof record.
connector-oss is an in-process Rust kernel that adds memory integrity
primitives to existing agent frameworks (LangChain, CrewAI, AutoGen).
How it works:
1. Every memory write is content-addressed with Blake3 — the CID is
   deterministic, so any modification to stored content produces a
   different CID and is detected on next read.
2. Every agent operation is logged to an Ed25519-signed Merkle chain.
   The chain links H(n) = hash(H(n-1) + op_n), so altering any entry
   breaks every downstream entry. Retroactive tampering is detectable.
3. Namespace isolation is enforced at the Rust kernel level — agents
   are confined to their namespace in vac-core, not by a Python
   convention that can be bypassed.
4. An 8-dimension trust score (consistency, accuracy, recency,
   isolation, integrity, coverage, coherence, provenance) is computed
   from kernel state — not from LLM self-report.
Crate structure:
- vac-core: MemoryKernel, 28 syscalls, RangeWindow, Interference engine
- vac-store: ProllyKernelStore (Prolly Tree + Blake3), IndexDbKernelStore
- vac-ffi: ~500-line PyO3 thin wrapper
- connector-engine: AgentFirewall, DualDispatcher, KnowledgeEngine
- connector-server: axum REST + Prometheus metrics
One interesting problem: the Prolly Tree backend is async (tokio) but
PyO3 calls are synchronous. We bridge this with block_in_place +
handle.block_on(), which requires flavor = "multi_thread" in tokio
test configs. Namespace packet keys include a timestamp to avoid CID
collisions: ns:{ns}:{ts}:{cid}.
788 tests, 0 failures. <50μs overhead per memory operation.
4-agent pipeline produces 105 audit entries, integrity check passes.
pip install connector-oss
Apache 2.0.
```

value: Show HN: Connector-OSS – Memory integrity kernel for AI agents

author: umeshlamton


value: sarunasch

value: Make your Claude Code run Codex, Gemini, OLLama, Groq or anything else. Read full capture logs of what's going. Small, local, transparent.

value: Show HN: Run any LLM inside Claude Code. A local auditable proxy for 7 providers

author: sarunasch


value:
AI agents are making decisions that affect money, infrastructure, and users —
but most systems rely on editable logs.
I built PiQrypt to explore whether an AI agent can have a
cryptographically verifiable decision history.
Each event is:
- Ed25519 signed
- SHA-256 hash chained
- Fork-detectable
- Optionally RFC 3161 timestamped
- Optional post-quantum (Dilithium3 / ML-DSA-65)
The goal isn't blockchain or consensus —
it's agent identity continuity and tamper-evident history.
MIT licensed, local-first.
https://github.com/piqrypt/piqrypt
I'd appreciate feedback on the design, especially around
fork handling and key rotation.

value: Show HN: PiQrypt – Cryptographic audit trail for AI agents (Ed25519, Dilithium3)


value: conesus

value:
Hacker Smacker adds friend/foe functionality to Hacker News. Three little orbs appear next to every commenter's name. Click to friend or foe a commenter and you'll more easily spot them on future threads. Makes it easy to scroll and spot the commenters you love to read (and hate to read).
Main website: https://hackersmacker.org
Chrome/Edge extension: https://chromewebstore.google.com/detail/hacker-smacker/lmcg...
Safari extension: https://apps.apple.com/us/app/hacker-smacker/id1480749725
Firefox extension: https://addons.mozilla.org/en-US/firefox/addon/hacker-smacke...
The interesting part is friend-of-a-friend: if you friend someone who also uses Hacker Smacker, you'll see their friends and foes highlighted too. This lets you quickly scan long comment threads and find the good stuff based on people you trust.
I built this to learn how FoaF relationships work with Redis sets, then brought the same technique to NewsBlur's social layer. The backend is CoffeeScript/Node.js/Redis, and the extension works on Chrome, Edge, Firefox, and Safari.
Technically I wrote this back in 2011, but never built a proper auth system until now. So I've been using it for 15 years and it's been great. PG once saw it on my laptop (back when he was still moderating HN, in 2012) and remarked that it was neat.
Thanks to Mihai Parparita for help with the Chrome extension sandboxing and Greg Brockman for helping design the authentication system.
Source is on GitHub: https://github.com/samuelclay/hackersmacker
Directly inspired by Slashdot's friend/foe system, which I always wished HN had. Happy to answer questions!

value: Show HN: Hacker Smacker – Spot great (and terrible) HN commenters at a glance

author: conesus


value: import-shiburin

value:
Hello HN! Working as a SRE, our team handle a lot of terraform projects.
Dealing with them, one annoyance is matching terraform version for all of those projects, usually done by (1) finding file containing `required_version` field, (2) finding nixpkgs commit for that version, and (3) copying flake.nix from somewhere else. Using alternative version manager like tfenv or asdf is not possible for some teammates who are using NixOS as their daily driver.
This tool parses HCL of all .tf files in given directory, usually current working directory, looks for `required_version` of terraform, finds matching nixpkgs commit, and generates/updates flake.nix to use needed version of terraform.
Any feedbacks are appreciated. Thanks!

value: Show HN: Tfg – flake.nix generator for Terraform projects

author: import-shiburin


value: david-rodriguez

value:
Hi HN,
I built QueryVeil because I was tired of two things: (1) uploading data to third-party tools, and (2) AI tools that just translate English to one SQL query and call it done.
QueryVeil is an AI data analyst that actually investigates. When you ask "why did revenue drop last month?", it doesn't just run one query — it plans an approach, runs multiple queries, self-corrects when it hits errors, and builds a report with its findings. Like a junior analyst who happens to live in your browser tab.
Everything runs client-side:
- *DuckDB WASM* for SQL execution — your data never leaves your machine
- *WebLLM* for local AI (Llama via WebGPU) — no API keys, no server costs
- *LangGraph agent* for multi-step investigations with tool use
What it actually does:
- Drop in CSV, Excel, JSON, or Parquet files (or connect to Postgres, MySQL, BigQuery)
- Get an instant data brief — row counts, column profiles, anomaly detection, data quality warnings — before you ask anything
- Ask questions in plain English. The AI agent runs multiple queries, self-corrects SQL errors (up to 3 retries), and generates charts automatically
- Proactive insights: correlation detection, outlier flagging, duplicate detection, temporal gap analysis — runs automatically on every new table
- Four modes: Chat, SQL editor (with schema-aware autocomplete), Jupyter-style notebooks (with cell references and variables), and a drag-and-drop report builder
- Share reports and notebooks via public links, embed them, or schedule email delivery
- Command palette (Cmd+K) for quick actions
Free tier: local AI (WebLLM/Ollama), unlimited files, all four modes, auto-insights.
Pro ($19/mo or $190/yr): 12+ cloud models via OpenRouter (Claude, GPT-4o, Gemini, DeepSeek, Llama, etc.), database connections, sharing, scheduled reports. 14-day free trial.
Technical details:
- Nuxt 4, Vue 3, Pinia, TailwindCSS
- DuckDB WASM handles millions of rows in the browser
- LangGraph StateGraph with ReAct loop — the agent has tools for SQL execution, schema inspection, column stats, and creating notebooks/reports
- Self-correction: when SQL fails, the error + schema context goes back to the AI for auto-fix
- WebLLM runs Llama-3.2-3B via WebGPU — zero server cost for the free tier
- Ollama support for people who prefer running models locally
- Server-side: Supabase (auth + Postgres), Stripe billing, OpenRouter proxy with model allowlist
Try the demo instantly — no signup, no email: https://app.queryveil.com/demo
It loads sample ecommerce data, auto-profiles it, shows proactive insights, and lets you chat or write SQL. Everything runs in your browser.
Landing page: https://www.queryveil.com
Solo developer, would love feedback — especially on the agent behavior and whether the proactive insights are useful or noisy.

value: Show HN: QueryVeil – An AI data analyst that investigates your data

author: david-rodriguez


value: flamenfury

value: Show HN: Permanent Underclass – Terminal game about AI acceleration (Rust)

author: flamenfury


value: coryxrx

value:
There's certain features I wish Mac OS had, and I got tired of waiting for Apple to implement them.
MacCoolinator is the answer!
First and currently only feature: always show window titles on Mission Control, without having to hover.

value: Show HN: MacCoolinator – Putting the "Cool" in Mac

author: coryxrx


value: kyledotkyle

value: Show HN: Recall – A personal CRM you use over text messages

author: kyledotkyle


value: DavidCanHelp

value: Show HN: Tools Are Lying to You

author: DavidCanHelp

title: Show HN: Tools Are Lying to You


value:
Genograms are family trees used by therapists to map relationships, trauma patterns, and medical history across generations. They're incredibly useful. They're also a pain to make.
I built GenogramAI so you can just describe your family in plain English and get a properly formatted genogram in seconds. No learning specialized software. No manual dragging of symbols.
Therapists, social workers, and med students have been our early users — but honestly anyone curious about their family dynamics can use it.
https://genogramai.com

value: Show HN: GenogramAI – Create Genograms in Seconds


value: shotwellj

value:
We built AIR Blackbox — open-source compliance infrastructure for AI agents targeting the EU AI Act enforcement deadline on August 2, 2026.
If you're deploying LLM-based agents (LangChain, CrewAI, AutoGen, OpenAI Agents SDK) into production, the EU AI Act requires tamper-evident audit trails, human oversight mechanisms, data governance controls, and injection defense — for any system classified as high-risk.
Most teams we've talked to either don't know about the deadline or assume their existing logging is enough. It's not. Article 12 specifically requires logs that regulators can mathematically verify haven't been altered. Article 14 requires the ability to interrupt agent execution. Article 15 requires defense against prompt injection and data poisoning.
What we built:
Trust layers for LangChain, CrewAI, AutoGen, OpenAI Agents SDK, and RAG pipelines — each is a pip install that hooks into your existing agent code with ~3 lines of setup
HMAC-SHA256 tamper-evident audit chains — every agent decision, tool call, and LLM interaction gets logged to a chain that regulators can verify
ConsentGate — risk-classifies tool calls and blocks critical operations until approved
InjectionDetector — 15+ weighted patterns scanning prompts before they reach the model
WriteGate + DriftDetector (for RAG) — prevents knowledge base poisoning and detects retrieval anomalies
Compliance scanner — pip install air-compliance && air-compliance scan ./my-project tells you exactly which articles you're missing
Everything maps to specific EU AI Act articles (9, 10, 11, 12, 14, 15). Zero vendor lock-in, Apache 2.0, zero core dependencies on the trust layers.
The scanner is probably the fastest way to understand where your gaps are. It takes about 3 seconds to run on a typical project.
GitHub: https://github.com/airblackbox
PyPI: pip install air-compliance
Happy to answer questions about what the EU AI Act actually requires for AI agent deployments — we've read the full regulation and mapped it to specific technical controls.

value: Show HN: Open-source EU AI Act compliance layer for AI agents (8/2026 deadline)

author: shotwellj


value: chancemehmu

value: Show HN: Datapoint – replacing mobile ads with data labelling tasks

author: chancemehmu


value:
When I saw there were loads of tools made for automating everything from iMessage to Mail through OpenClaw, I decided it would be neat to have a brand new app that lets you send messages from an SSH console.
The work is based on steipete's imsg (https://github.com/steipete/imsg), and is a spiritual successor to things like CamHenlin's imessageclient (https://github.com/CamHenlin/imessageclient)).

value: Show HN: Imsg-TUI – A Console App for Sending and Receiving iMessages