value: agentcostin

value:
Hi HN,
We built AgentCost to solve a problem we kept running into: nobody knows what their AI agents actually cost.
One line wraps your OpenAI/Anthropic client:
from agentcost.sdk import trace
client = trace(OpenAI(), project="my-app")
From there you get a dashboard with cost forecasting, model optimization recommendations, and pre-call cost estimation across 42 models.
What's included (MIT):
Python + TypeScript SDKs
Real-time dashboard with 6 views
Cost forecasting (linear, EMA, ensemble)
Optimizer: "switch these calls from GPT-4 to GPT-4-mini, save $X/day"
Prompt cost estimator for 42 models
LangChain/CrewAI/AutoGen/LlamaIndex integrations
Plugin system
OTel + Prometheus exporters
CLI with model benchmarking
Enterprise features (BSL 1.1): SSO, budgets, policies, approvals, notifications, anomaly detection, AI gateway proxy.
Tech stack: Python/FastAPI, SQLite (community) or PostgreSQL (enterprise), React dashboard, TypeScript SDK.
GitHub: https://github.com/agentcostin/agentcost
Docs: https://docs.agentcost.in
pip install agentcostin
Would love feedback from anyone managing AI costs at scale.

value: Show HN: AgentCost – Track, control, and optimize your AI spending (MIT)

author: agentcostin


value: florentmsl

value:
I’ve been building for 5 years.
I rewrote it 4 times (Blazor Server -> Blazor WASM + Asp backend -> React + Node -> Ruby on Rails - Ruby and Rails are both awesome btw.) and kept telling myself I was “improving the architecture” when I was really avoiding release. I also spun up a few side projects in that period and shipped none of them.
This is the first one I finally pushed live.
It’s Upzone, an inventory app for ecommerce warehouse teams: receiving, bin locations, pick/pack/ship workflows, and Shopify/Amazon/... sync. Built on Rails 8, which has been genuinely great to work with. A QuickBooks integration is also coming
If you run ops or warehouse workflows, I’d love literally any kind of feedback:
https://upzonehq.com

value: Show HN: I rewrote an inventory app 4 times over 5 years before releasing v1

author: florentmsl


value: mchaver

value:
This is an open source project I created to do more math practice with my kids. Right now it supports math from grades K through 5. Pick a grade, skill and more details, the number of problems you want and it will generate a PDF worksheet and answer sheet. No login/signup required. I will iron out issue and eventually add higher levels. If you have anything in particular you would like to see, let me know. You are also welcome to contribute to the project or fork it.
https://github.com/sophikos/free-math-sheets

value: Show HN: Free Math Sheets – Generate math worksheets for K-5 problems

author: mchaver


value: Adrig

value:
Hi HN!
I'm a designer who works with Claude Code daily. The standard feedback loop is frustrating: I'd screenshot something, describe it in words, and the AI would misinterpret what I meant.
So I built a Chrome extension that lets you pin comments directly on live page elements, then export everything as a structured prompt. Click an element, describe what you want changed, hit export, paste into your AI agent. There's also an ASCII canvas mode for roughing out layouts and edit existing elements. No images, everything stays as text that fits in a clipboard. Local-only, no accounts, no cloud.
This is one of my first "dev" projects, would love to hear what you think!

value: Show HN: Design Jam, ASCII wireframes and annotations that export as AI prompts

author: Adrig


value: serengil

value:
Hey, I'm the author of this work and the maintainer of DeepFace.
In this paper, we ensemble the top 5 DeepFace backbones and feed them into a GBM model instead of relying on a single embedding model.
On LFW, this surpasses FaceNet512’s 98.4% accuracy and the reported human-level accuracy of 97.5%, achieving 99.1%.
We deliberately avoid retraining on LFW to prevent benchmark overfitting. The base models are trained on large-scale datasets, and we only learn a boosting layer on top of their similarity scores.

value: Show HN: Boosted LightFace – A Hybrid DNN and GBM Model for Facial Recognition

author: serengil


value: FlynnLachendro

value: Show HN: Arbor – AI research workbench, question to knowledge graph

author: FlynnLachendro


value: mjbonanno

value:
Hi HN,
After building several AI agent systems, I kept running into the same frustration: memory layers that are either static vector stores or fragile prompt hacks. Retrieval is opaque, forgetting happens at the wrong time, and associations don’t form naturally.
So I threw away the two production memory systems I had and built something different. MuninnDB is a purpose-built cognitive memory database where memories (called engrams) are first-class citizens that:
- Strengthen with repeated co-activation (Hebbian learning)
- Decay over time using a verbatim ACT-R formula
- Automatically form bidirectional associations
- Track their own Bayesian confidence
- Return a full mathematical “Why” explanation on every retrieval
Everything runs as a single static Go binary (embedded Pebble LSM storage + HNSW + BM25). No external services, no Redis/Postgres/Pinecone, and no LLM in the hot path. One command (muninn init) auto-configures it with Cursor, Claude Desktop, VS Code, and any other MCP-compatible tool.
The core call is dead simple: Activate(context) returns ranked results + explainable scoring. Background workers handle learning and decay on every read.
GitHub: https://github.com/scrypster/muninndb
Website + docs + install (one-liner): https://muninndb.com
Quick 13-minute demo video: https://www.youtube.com/watch?v=b29wl0ehrQI
It’s very early (alpha, ~10 days old), but already functional and I’m using it daily. Would love honest feedback or questions from anyone working on agent memory, long-term RAG, or cognitive architectures.
Thanks!

value: Show HN: MuninnDB – ACT-R decay and Hebbian memory for AI agents

author: mjbonanno


value:
Hey HN! I've been building t-req over the past few months -- an open-source (MIT) programmable API engine built on the .http file format. I'm an engineer who went through a Postman-to-Insomnia migration with a team and got tired of learning proprietary DSLs when we already had Vitest and test runners in our codebase. Once agentic coding tools entered the workflow, the simplicity gap widened and the context switching was painful. So I built t-req around .http files and focused on making them programmable rather than just runnable.
Every .http tool I looked at treated the format as something you click "run" on and read the response. I wanted to treat it as an input to an engine. Write your requests as .http files -- they're plain text, any agent or editor can work with them -- then run them from anywhere, test them with any runner, and extend them with plugins.
Some features:
- Runs from every surface -- the same .http file works from the TUI, CLI, VS Code, Cursor, web, or as a server.
- Programmable from any test runner -- @t-req/core returns standard objects, use expect() in Vitest, Jest, or Bun test like you already do.
- treq serve exposes your collection as an HTTP server callable from any language.
Github: https://github.com/tensorix-labs/t-req
Docs: https://t-req.io/

value: Show HN: t-req – Open-source programmable API engine built on .http files


value: travelhead

value: Show HN: Viib – Generate production ready static ads from a single URL

author: travelhead


value: mustafabagdatli

value:
Fractional CFOs typically run 10-20 clients at once. A big chunk of the month isn't actual CFO work — it's the setup before the work: export from QuickBooks, clean the CSV, rebuild the pivot table, retrace someone else's formula logic, copy numbers into the deck. Repeat for every client.
The underlying issue is that client data lives in Excel workbooks that grew organically over years. Nested IFs, brittle VLOOKUPs, logic that made sense to whoever built it. Before you can answer a financial question you have to untangle the file.
BaseCFO takes those workbooks as-is, reads the formula logic, normalizes the data, and surfaces everything through a single dashboard across all clients. No manual cleanup before ingesting. No logging into 15 QuickBooks accounts to check who needs attention.
Free for your first 5 workbooks, no credit card.
Still early and would genuinely appreciate feedback — especially from anyone who has strong opinions about the Excel parsing problem or works with practitioners in this space.
https://basecfo.com/early-access

value: Show HN: BaseCFO – workbooks as a queryable dashboard for fractional CFOs

author: mustafabagdatli


value: ranbuch

value:
Hi HN, I’m Ran. I built an open-code middleware package for Qiskit that uses classical post-selection to filter thermal noise out of deep quantum circuits without requiring global error correction.The current bottleneck in near-term quantum computing (NISQ) is the decoherence death spiral. When IBM proved "Quantum Utility" on 127 qubits in 2023, they used Zero-Noise Extrapolation (ZNE) to statistically guess the correct expectation values from the noise. I wanted to see if deep circuits retain exploitable statistical structure beyond apparent decoherence collapse.How it works: qgate adds a single ancilla probe (an O(1) quantum overhead) whose measurement outcome provides a trajectory score. During classical post-processing, shots are ranked using a dynamic Galton-style threshold, and the lowest-scoring (most decohered) trajectories are discarded. Unlike symmetry-based post-selection, this does not rely on known conserved operators.The Stress Test: I ran it on a 133-qubit heavy-hex lattice (IBM Torino) at an ISA depth of 16,700+ gates (~37x T1). In this regime, expectation values approach the infinite-temperature limit. After trajectory filtering, an 11.9% subset of shots exhibited a statistically significant negative energy shift (δ = -0.0798).I’ve published the telemetry, the math, and the codebase under a Source-Available Evaluation License.
Repo/Docs: https://github.com/ranbuch/qgate-trajectory-filter
The Story/Data: https://medium.com/@ranbuch/beating-the-quantum-noise-wall-e...
Install: pip install qgate

value: Show HN: Qgate – Classical trajectory filtering for noisy quantum circuits

author: ranbuch


value:
Hey HN, wanted to share this cli and skill I built @ Steel (I'm the founder)
I was trying to set up openclaw on railway and quickly bumped up against issues with a lack of browser access, a core component of the system. Agents like OpenClaw and CC are super good at using browsers but, similar to code sandboxes, they should be able to control these browser in the background, in parallel, without getting blocked by captchas.
So I reworked agent-browser, the most popular cli for browser agents, to navigate Steel cloud browser sessions to they can run at scale and unhindered.
It's a relatively crude implementation right now as we just embed agent-browser's binaries directly into the CLI and have a higher-level TS parser to route/modify commands, but it works surprisingly well; the demo video in the link worked first shot, I just copied/pasted for the video.
GitHub Repo: https://github.com/steel-dev/cli/
Would love any feedback or thoughts on what capabilities you'd like to see shipped here!

value: Show HN: Letting Claude automate fleets of browser sandboxes


value: Show HN: Homebrew tap for unsigned macOS apps rejected by official casks


value: Show HN: Apcher – Generate self-hosted Node.js workflows from prompts


value: antics

value:
Hi HN! We at Moment[1] are working on Notion alternative which is (1) rich and collaborative,  but (2) also just plain-old Markdown files, stored in git (ok, technically in jj), on local disk. We think the era of rigid SaaS UI is, basically, over: coding agents (`claude`, `amp`, `copilot`, `opencode`, etc.) are good enough now that they instantly build custom UI that fits your needs exactly. The very best agents in the world are coding agents, and we want to allow people to simply use them, e.g., to build little internal tools—but without compromising on collaboration.
Moment aims to cover this and other gaps: seamless collaborative editing for teams, more robust programming capabilities built in (including a from-scratch React integration), and tools for accessing private APIs.
A lot of our challenge is just in making the collaborative editing work really well. We have found this is a lot harder than simply slapping Yjs on the frontend and calling it a day. We wrote about this previously and the post[2] did pretty well on HN: Lies I was Told About Collaborative editing (352 upvotes as of this writing). Beyond that, in part 2, we'll talk about the reasons we found it hard to get collab to run at 60fps consistently—for one, the Yjs ProseMirror bindings completely tear down and re-create the entire document on every single collaborative keystroke.
We hope you will try it out! At this stage even negative feedback is helpful. :)
[1]: https://www.moment.dev/
[2]: https://news.ycombinator.com/item?id=42343953

value: Show HN: We want to displace Notion with collaborative Markdown files

author: antics


value: raj-shekhar

value:
Hi HN, I'm Raj.
We all spend a bulk of our time looking for the right job, cofounders, hires. Post on boards, search, connect, ask around. Hit ratio is very low. There's this whole unsaid rule that you have to build your network for this kind of thing. Meanwhile the person you need is out there doing the exact same thing on their side. Both of you hunting, neither finding.
What if you just declare what you need and someone does the finding for you?
That's what I built - OpenMandate. You declare what you need and what you offer - a senior engineer looking for a cofounder in climate tech, a startup that needs a backend engineer who knows distributed systems. Each mandate gets its own agent. It talks to every other agent in the pool on your behalf until it finds the match. You don't browse anything. You declare and wait.
Everything is private by default. Nobody sees who else is in the pool. Nothing is revealed unless both sides accept. No match? Nobody ever knows you were looking. No more creating profiles, engaging for the sake of engagement, building networks when you don't want to.
What's live:
- openmandate.ai
- pip install openmandate / npm install openmandate
- MCP server for Claude Code / Cursor / any MCP client
- github.com/openmandate

value: Show HN: OpenMandate – Declare what you need, get matched

author: raj-shekhar


value: austinbaggio

value: Show HN: SOTA long memory eval with open source models

author: austinbaggio


value: gurkenkoenig

value:
I think everyone should build their own HN reader at least once in their life. This is mine and its pink.
I wanted a good HN experience on mobile something I could pull up on the train and browse comfortably. So I built a PWA that works well on mobile and feels native on the phone.
Along the way, I kept adding things:
Semantic search – Stories are embedded with OpenAI's text-embedding-3-large and indexed in MongoDB 8.2's Vector Search. Search combines vector similarity and full-text via Reciprocal Rank Fusion, so you can find stories by meaning, not just keywords.
Personalized feed: A profile vector is built from your reading history and bookmarks (weighted by time spent and recency). After a few stories, the feed adapts to your interests.
Content extraction: A Playwright-based scraper fetches article text, generates thumbnails, and extracts metadata.
Real-time updates and infinity scroll. Auth is passkey-first (WebAuthn) and works without personal information.
Stack: Angular 21, FastAPI (Python 3.14), MongoDB 8.2, Valkey for job queues.
It's a hobby project and I had a lot of fun building it. Feedback welcome!

value: Show HN: HackerNews.pink – A PWA HN reader with personalized recommendations

author: gurkenkoenig


value:
My dad cuts window profiles in his workshop and I kept watching him measure, mark, and reposition by hand hundreds of times a day. So I built him a motorized ruler that moves to any position you tap on a tablet.
It runs on an ESP32-S3 over BLE 5.3, uses hardware-timed stepper pulses (RMT peripheral, no CPU jitter) to hit 0.5mm accuracy, and pairs with a Bosch GLM laser meter - point, measure, and the ruler moves there. No typing, no transcription errors.
You can also upload cut lists from a file or email and it runs each position in sequence - perfect for batch cutting window profiles where you need the same set of measurements repeated all day.
Open hardware: off-the-shelf linear rails, NEMA 23 closed-loop stepper, inductive homing sensor. Total BOM is about 470 EUR. I sell the firmware, app (Android + desktop), and a step-by-step build guide for 350 EUR.
Video demo: https://youtu.be/GCUHBiIs4Vk
Happy to answer questions about the build or the ESP32 RMT approach to stepper control.

value: Show HN: SmartRuler Pro – ESP32-powered motorized ruler with 0.5mm precision


value:
Hey everyone, Nathan here: I'm an MLE at Mozilla.ai. I can't tell you how many things around my house I've been saying "I would really like to have somebody take a look at that". But here's the problem: all the people in the trades are extremely overwhelmed with work. There is a lot to be done and not enough people to do it.
One of my best friends runs his own general contracting business. He's extremely talented and wants to spend his time working on drywall, building staircases, and listening to Mumford and Sons while throwing paint onto a ceiling. But you know what gets in the way of that wonderful lifestyle that all us software engineers dream about?
ADMINISTRATION.
He thought running his own business would be 85% show up and do the work, but turns out a large chunk of the time is spent talking to clients to schedule time to get an estimate, working with home management companies to explain the details of an invoice, and generally just manage all of the information that he's gathering on a single day.
Luckily for the world, AI is here to help with this. Tech like openclaw has really opened our eyes to the possibilities, and tech to help out small businesses like these are now within reach.
That's why I'm excited to share out an initial idea we're trying out: clawbolt. It's a python based project that takes inspiration from the main features that make openclaw so powerful: SOUL.md, heartbeat proactive communication, memory management, and communication over channels like WhatsApp and iMessage. With clawbolt, we're working on integrating our latest work with any-llm and any-guardrail, to help make clawbolt secure and to ease onboarding.
This is all new, so this is a call for ideas, usage, and bug reports. Most of us that try to get plumbers/roofers/handymen to come help us with a home project know how overwhelmed they are with admin work when they're a small team. I'm hoping that we can make clawbolt into something that helps enable these people to focus on doing what they love and not on all the paperwork.
Let me know what you think! Docs at https://mozilla-ai.github.io/clawbolt/

value: Show HN: Mozilla.ai introduces Clawbolt, an AI Assistant for the trades


value: josiahsrc

value:
Hey HN! We love voice dictation, but wanted an open source version for transparency, privacy, and something that everyone could contribute to. So we built Voquill, an open source alternative to WisprFlow, Monologue, and SuperWhisper.
It lets you dictate into any desktop app. Press a hotkey, talk, text gets inserted. You can run Whisper locally, use our server, or wire up any provider you want (OpenAI, Claude, Groq, OpenRouter, whatever). You have full control over where your data goes.
Runs on Windows, MacOS, and Linux. Open source, AGPLv3, built with Tauri and Rust. We're working on a mobile app too (Flutter) that's currently in beta for iOS and android.
To try it: Download from the repo or voquill.com. Click "local setup" on first launch. Hope you like it!

value: Show HN: Voquill, an open source and cross-platform alternative to wisprflow

author: josiahsrc


value: stosssik

value: Show HN: The OpenClaw Market Map, Q1 2026

author: stosssik


value: dfstudioz

value:
Hi HN,
I’m sharing something I’ve been building because one thing kept bothering me about AI answers: most of the time they sound confident, but when the underlying question is vague or underspecified the outputs don’t help you make a real decision.
So I built Franklin Prompt Studio — a lightweight desktop prompt builder and answer checker that helps you:
Turn messy, ambiguous questions into structured prompts
Choose the right mode (Decision, Plan, Diagnose, Risk)
Pressure-test outputs for missing assumptions, hidden risks, and weak next steps
Get answer sections you can actually act on rather than generic prose
It works with your existing AI (you can paste into whatever you already use) and adds reliability checks so you don’t miss critical gaps in reasoning. The core idea is: better prompts → clearer, more reliable AI answers.
Prompt Studio is a one-time purchase ($29 USD) and runs as a Windows portable tool today, with v1 features like structured modes, reliability flags, and a fast 2-pane workflow.
Here’s the site if you want to check it out: https://www.dfrankstudioz.com/
I’d love feedback from people who use AI for real decisions or technical work — especially if you’ve struggled with AI answers that seem helpful but weren’t. Thoughts, critiques, or suggestions welcome.
— Brent

value: Show HN: Franklin Prompt Studio – desktop tool for decision-ready AI answers

author: dfstudioz


value: brotchie

value:
I wanted to see if I could self-build a working OpenClaw-like agent starting with nothing but a fresh Linux VM.
The result is a model-specific REPL "genesis snippet." It's a short bash script that prompts for your API key, asks the model to generate a REPL with an agentic tool-use loop, and then drops you straight into that running REPL.
The self-imposed rules:

  1. No copy-pasting code after the initial snippet.
  2. No manual editing—the agent has to write and fix everything for you.
  3. Zero agent frameworks or libraries.

From there, the goal is to ask the agent to rewrite its own REPL, add quality-of-life improvements, and eventually figure out how to connect itself to Telegram.
I put the snippets up on a site along with some open challenges like code golf and speed runs:
https://agentfromscratch.com
To try it, you just need your own API key and a Linux VM or Docker container. If you want to see how it actually behaves before running it, here is the raw terminal output of my first successful run:
https://agentfromscratch.com/polis/afs-genesis/

value: Show HN: Agent from Scratch – Bootstrap an agent from a copy-paste, no framework

author: brotchie


value:
I built an MCP server (vexp) that pre-indexes a codebase into a dependency graph and serves only relevant code to AI coding agents. While benchmarking it, I found something I wasn't looking for.
The expected results were straightforward: less input context → lower cost, fewer tool calls → faster. But the output token reduction was the surprise.
Benchmark: 7 tasks on FastAPI (the OSS repo, ~800 Python files), 3 runs/task/arm, 42 total runs, Claude Sonnet 4.6, both arms in --strict-mcp-config isolation.
Without graph:  ~23 tool calls, ~40K input tokens, 504 output tokens, $0.78/task
With graph:     ~2.3 tool calls,  ~8K input tokens, 189 output tokens, $0.33/task
The 58% cost reduction and 22% speed improvement were expected. The 63% output token reduction was not.
When Claude gets 40K tokens of context (most irrelevant), it generates a lot of "let me look at this file... I can see that..." narration while it orients itself. When it gets 8K tokens of pre-filtered, graph-ranked context, it skips straight to the answer. The exploration filler disappears.
This seems like a general property of these models: noisy input → verbose output, focused input → focused output. I'd be curious if others have observed this in different contexts.
The approach: tree-sitter AST parsing → dependency graph in SQLite → single MCP tool (run_pipeline) that takes a task description, walks the graph, returns ranked context. Full source for high-centrality pivot nodes, compact skeletons for supporting code.
Savings varied by task type — code understanding tasks saved the most (-64%), bug fixes the least (-30%). Makes sense: the more exploration a task normally requires, the more waste there is to cut.
Code: the graph resolution is handwritten Rust. The MCP transport, SQLite schema, and benchmark harness were built with Claude Code (felt appropriate). The benchmark analysis scripts were 100% Claude.
Free tier at https://vexp.dev — 2K nodes, 1 repo, no time limit. Runs locally (tree-sitter + SQLite, no cloud).

value: Show HN: Focused input cuts LLM output tokens by 63% bench on CC with FastAPI


value: ihorklymchuk

value: Show HN: VeilDB – Open-source database anonymization platform

author: ihorklymchuk


value: justvugg

value:
I built dbcli, a lightweight database CLI designed specifically for AI agents that need fast, low-overhead access to relational databases.
The main idea is to make database introspection and querying simple and efficient when an agent has shell access. With a single command (dbcli snap), you can retrieve schema details, table relationships, and basic data profiling (column stats, ranges, cardinality) without stitching together multiple queries or tools. This helps reduce token usage and unnecessary round-trips in agent workflows.
Dbcli supports multiple databases, including PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse, SQL Server, and others via optional drivers. It allows running queries, executing SQL files, and writing data directly from the CLI. There’s no server process or external service required — just install locally with:
pip install -e .
The goal is to provide a simple, agent-agnostic alternative to heavier protocol-based approaches, working with any system capable of executing shell commands.
I’d really appreciate feedback, especially from those building AI agents or tools that require structured database access.
Github repo: https://github.com/JustVugg/dbcli

value: Show HN: Dbcli – A Lightweight Database CLI Designed for AI Agents

author: justvugg


value: TheRealDaveO

value:
My co-founder and I launched Stackhaus publicly today.
The problem: generative coding tools (Lovable, Bolt, Cursor, Claude, ChatGPT) have made it genuinely fast to build working software. But the distribution layer for these apps doesn't exist. Most AI-built apps die in a Discord message or a Reddit thread.
Stackhaus is a marketplace specifically for AI-generated applications. Every app is verified before listing. Users can browse by category, use case, or the AI/tool that built it. Launched with 1,204 apps.
Three things I'd love HN's take on:
1. Curation vs. scale — we manually verify every app now. Doesn't last at 10K listings. How have others handled quality gates?
2. The GPT-wrapper problem — how do you signal quality difference to users?
3. Filtering by underlying model as a trust proxy — does that hold up?
Not YC, not VC-backed. Just two people who thought this needed to exist. Brutal feedback welcome.

value: Show HN: Stackhaus – A marketplace for AI-built apps (1,204 verified at launch)

author: TheRealDaveO


value: santiviquez

value: Show HN: SEO That Fixes Itself

author: santiviquez

title: Show HN: SEO That Fixes Itself


value: bbmaxwell

value:
I've been tinkering on the side forever and finally worked up the courage to ship something and participate rather than watching from the sidelines. Kind of embarrassing to admit that but hey, this is me getting over it.
I've failed at Spanish my whole life. When I heard that 1,000 words cover about 80% of spoken conversation, it felt attainable. So I built an app around it.
How it works: take a frequency-ranked list of the 1,000 most common Spanish words. Introduce up to 30 per session starting from the most frequent. Flashcard format: English on front, Spanish on back, self-rate Again/Hard/Good/Easy. The FSRS algorithm calculates when to show each word again, targeting 90% retention. Words you know get pushed out days or weeks. Words you don't come back in minutes.
Built with Flutter/Dart, FSRS Dart package, SQLite for local storage, Supabase for sync. Solo developer. First published app.
$1.99, one-time purchase. No subscription, no ads.
My intention is to learn the full idea > build > ship > launch > market > grow cycle. This is attempt one. I intend to do this repeatedly, improving and learning each time.
https://apps.apple.com/us/app/1-000-spanish-words/id67567889...
Also, still looking for Android testers. Please DM me if interested.

value: Show HN: Spanish Words, spaced repetition vocabulary app for frequent words

author: bbmaxwell


value: vmvarela

value: Show HN: SQL-pipe – Query CSV streams with SQLite syntax (written in Zig)

author: vmvarela


value: chsitter

value:
Hey HN — I'm the builder behind Memobase.
Timing: Anthropic just launched memory import for Claude yesterday. You can export your ChatGPT memories and bring them over. It's a step in the right direction, but it's still moving your data from one silo to another. You don't really own that memory.
The problem as I see it: there's no standard protocol for AI memory. You can't say "here's my MCP server, use it for memory in every session." Each platform builds its own walled garden. Number portability took regulation. Email interoperability took SMTP. AI memory needs something similar.
What Memobase is: a universal, AI-agnostic memory layer. It builds a structured profile — your preferences, context, project history — that any connected AI tool reads from. Not locked inside ChatGPT, Claude, or any single platform.
Technical approach:
- Profile-based memory, not raw conversation logs. Compact and fast (sub-100ms lookups).
- You own your data. Full visibility, editing, deletion, export. Self-hosted option coming.
- Working toward an open protocol so any tool can plug in — not just our integrations.
What's live: open beta with the core memory and integrations for the major tools. What's still patchy: Agents don't automatically use it all the time without being prodded, the protocol spec is still being formalized, and we need more tools to adopt it for this to really work.
I'd love to hear:
- Would you want your AI memory to live outside any single platform, or do you prefer each tool handling it?
- What would the protocol need to look like for you to build against it?
- Technical feedback on the approach — we chose profile-based RAG vs knowledge graphs etc, happy to go deep on that.

value: Show HN: Memobase – Universal memory that works across all your AI tools

author: chsitter


value: snakaya

value:
I built a proof-of-concept OIDC Identity Provider where the authentication logic — including login page generation, credential validation, and authorization decisions — is delegated to
  an LLM via function calling.

  How it works:

  1. A user hits the /authorize endpoint (standard OIDC authorization code flow)
  2. Instead of rendering a hardcoded login page, the server asks the LLM to generate one
  3. When the user submits credentials, the LLM validates them using function calling (it calls back into the server's user store to check the password)
  4. If approved, the server issues a standard JWT and proceeds with the normal OIDC token exchange

  The LLM doesn't get the password directly or sign the JWT — it orchestrates the flow using tools/functions exposed to it, while the server handles the actual crypto.

  Stack: Deno + Oak, OpenAI API (gpt-5-mini default), in-memory storage, HS256 JWT, PKCE support (S256/plain).

  What's interesting:

  - The login UI is different every time (the LLM generates it fresh)
  - Authentication "logic" is emergent rather than coded — the LLM decides what steps to take
  - It actually works as a compliant OIDC IdP (discovery, authorization code, token exchange, userinfo)
  - It demonstrates both the potential and the absurdity of delegating security-critical decisions to an LLM

  What this is NOT: Production-ready. It's a thought experiment in code. Every login costs an API call, responses are slow, and there's no real security hardening. The point is to explore
  what happens when you let an LLM drive an authentication flow.

  Curious to hear what the HN community thinks. Is there any legitimate use case for AI-driven auth flows, or is this purely in "cursed demo" territory?

value: Show HN: An OIDC Identity Provider where the LLM handles authentication logic

author: snakaya


value: shubh-chat

value: As the conversation around AI replacing knowledge work gets louder, I wanted to test it against something actually messy — a real lending workflow with regulations, ordered steps, and hard policy constraints. LOAB is my early attempt at that. The plan is to grow it across lending first, then other industries. Would love thoughts and feedback.

value: Show HN: LOAB – benchmarking AI process fidelity in lending

author: shubh-chat


value: WolfOliver

value: Show HN: Open-source Triblestore based Convex Alternative

author: WolfOliver


value: naimurhasanrwd

value:
Built this because people working with large document sets had no free tool that handled batch processing cleanly.
Tesseract is free and runs locally. For anything that needs more accuracy — Google Vision, Gemini, or any OpenRouter model — you bring your own API key. No subscription, no markup on your usage.
Export as TXT, JSON, XML or PDF. AI engines support custom prompts so you can translate, extract form fields, or get structured output in one step.
App: https://onlineocrfree.qzz.io
Source: https://github.com/naimurhasan/online-ocr-free

value: Show HN: Online OCR Free – Batch OCR UI for Tesseract, Gemini and OpenRouter

author: naimurhasanrwd


value: Show HN: Inkwell – A lightweight, local, portable Markdown editor


value:
I built livekit-monitor this weekend after needing better visibility into our self-hosted LiveKit instances.
LiveKit Cloud has great monitoring tools, but I couldn’t find a lightweight option for self-hosted deployments. This project is a small Rust + React app (single binary) that lets you track: rooms and participants, session history, egress and ingress activity and etc.
Repo: https://github.com/jossephus/livekit-monitor
It also ships as a small Docker image (~21 MB).
If you run self-hosted LiveKit, I’d really appreciate it if you'd try it out.
Thanks!

value: Show HN: Livekit-monitor – self-hosted monitoring dashboard for LiveKit


value:
In working with parallel agents in different worktrees, I found that I had a lot of port conflicts, went back and forth checking what incremented port my dev server was running on, and cookie bleed.
This isnt a big issue if running a few servers with full a stack framework like Next, Nuxt, or Sveltekit, but if you run a Rust backend and a Vite frontend In multiple worktrees, it gets way more complicated, and the mental model starts to break. That's not even adding in databases, or caches.
So I built Roxy, which is a single Go binary that wraps your dev servers (or any process actually) and gives you a stable .test domain based on the branch name and cwd.
It runs a proxy and dns server that handles all the domain routing, tls, port mapping, and forwarding for you.
It currently supports:
- HTTP for your web apps and APIs
- Most TCP connections for your db, cache and message/queue layers
- TLS support so you can run HTTPS
- Run multiple processes at once each with a unique URL, like Docker compose
- Git and worktree awareness
- Detached mode
- Zero config startup
My co-workers and I have been using it a lot with our workflow and i think it's ready for public use.
We support MacOS and Linux
I'll be working on some more useful features like Docker compose/Procfile compatibility and tunneling so you can access your dev environment remotely with a human readable URL
Give it a try, and open an issue if something doesnt quite work right, or to request a feature!
https://github.com/logscore/roxy

value: Show HN: A tool to give every local process a stable URL


value: ytlhome

value:
I built a skill for AI coding agents (Claude Code, OpenClaw, etc.) that connects directly to the Google Search Console API and delivers live SEO analytics — clicks, impressions, CTR, rankings, and opportunity detection.
Key features:
- Zero dependencies, pure Node.js built‑ins
- Real GSC API data (no CSV uploads)
- CTR benchmarking against your site average
- Page‑2 opportunity detection (pages ranking 11–20)
- Prioritized recommendations
- RTL support (Hebrew/Arabic formatted HTML reports)
- Dead simple install: `npx skills add spivx/agent-skills --skill gsc`
The skill is designed for developers and SEO professionals who use AI coding assistants and want quick, actionable SEO insights without leaving their IDE. It’s a single JavaScript file with no external packages.
You’ll need Google Search Console API credentials (OAuth). The skill walks you through the setup.
Try it out and let me know what you think! I’m happy to answer questions and would love feedback on what other SEO metrics would be useful in this context.
Repo: https://github.com/spivx/agent-skills
Install: `npx skills add spivx/agent-skills --skill gsc`
Screenshot of HTML report: https://res.cloudinary.com/dhzkb38hm/image/upload/v177255884...

value: Show HN: GSC Skill – Live SEO Analytics for AI Agents (Claude Code, OpenClaw)

author: ytlhome


value: Cvexperts

value: Show HN: Chase – automated invoice follow-up emails for freelancers

author: Cvexperts


value:
Qwen 3.5 Small dropped two days ago. I had it running on a mid-tier Android phone within hours.
It's great seeing the on-device AI community light up around this release. Off Grid brings it to Android: phones with 6GB RAM in the $200-300 range, ~8 tok/sec on the 2B model. Fully offline.
Text generation, vision AI, image gen, voice
transcription, tool calling, document analysis — all on-device, nothing uploaded, ever. Works in airplane mode.
780+ GitHub stars. ~2,000 downloads across Android and iOS. Early days.
GitHub: https://github.com/alichherawalla/off-grid-mobile-ai
Play Store: https://play.google.com/store/apps/details?id=ai.offgridmobi...
App Store: https://apps.apple.com/us/app/off-grid-local-ai/id6759299882

value: Show HN: Qwen 3.5 running on a $300 Android phone – on-device, open source


value: hparadiz

value: Show HN: Zero-overhead tool to capture stdout/stderr from a process using eBPF

author: hparadiz


value: jayyvk

value:
Faithful reimplementation of Karpathy's microGPT that runs entirely in a Web Worker. You pick a dataset (YC startups, baby names, dinosaurs, or upload your own), configure the architecture, and watch the loss curve drop in real-time as it trains. Then generate text from your model. Everything runs client-side - back propagation, attention, the whole training loop. The fun technical constraint was keeping the UI responsive while doing matrix math in JavaScript. Built it as a node-based editor so you can see the data flow from dataset → tokenizer → config → training → generation.
Github: https://github.com/jayyvk/trainmyowngpt

value: Show HN: Train a GPT from scratch in the browser – Karpathy's microGPT

author: jayyvk


value: two-sandwich

value:
My conversations with LLMs branch in many directions. I want to be able to track those branches, revert to other threads, and make new branches at arbitrary points. So I built my own solution to it.
It's essentially a tool for non-linear thinking. There's a lot of features I'd love to add, and I need some feedback before I take it anywhere else. So, I'm listening to whatever you're thinking is broken.
Basic feature set:
- Branching conversations: follow up from any node at any time, not just the latest message
- Context inheritance: when you branch off a node, the AI gets the full ancestry of that branch as context, so answers are aware of the whole conversation path leading to them.
- Text-to-question: highlight any text in an answer to instantly seed a new question from it.
- Multi-provider AI: compare and adjust responses from OpenAI, Anthropic, and Google Gemini.
- Visual graph: the conversation renders as a React Flow graph with automatic layout, so you can see the whole structure at a glance.
- Shareable links: your entire chat is compressed and stored in the URL. Everything is local (well, except the API calls).
- Branch compression: long branches can be collapsed into a summary node to keep the graph tidy.

value: Show HN: TrAIn of Thought – AI chat as I want it to be

author: two-sandwich


value: easylearnai

value:
I built a temporary file sharing service where payment happens through HTTP 402 status codes and USDC on Base/Arbitrum.
The idea: HTTP 402 ("Payment Required") has existed since 1997 but was never really used. The x402 protocol (https://x402.org) finally gives it a real implementation — server responds 402 with a payment challenge, client signs a gasless USDC transfer (EIP-3009), facilitator settles on-chain, client retries with a payment header. No API keys, no OAuth, no accounts.
x402drop uses this as the payment layer for temporary file storage:
- Connect wallet (SIWE), drag-and-drop files (up to 5 GB each, 10 GB per drop)
- Pick a duration (1 hour to 90 days), see a quote ($0.0003/MB/day, $0.01 minimum)
- Sign one USDC transfer — gasless, facilitator pays gas
- Get a share link — recipients download for free, no wallet needed
- Files auto-delete from R2 within ~15 minutes of expiry via cron
There's also an Agent API — AI agents and scripts can create drops programmatically using the same x402 payment flow. No API key, the 402 payment header is the auth.
Stack: Next.js (App Router), SIWE + RainbowKit, Drizzle ORM + Neon Postgres, Cloudflare R2, @x402/next, Vercel.
Pricing is deterministic: max(fileSizeMB × durationDays × 0.0003, 0.01) per file.
Known limitations:
- Mainnet only (no testnet mode yet)
- USDC only (no ETH or other tokens)
- No email notifications for expiry warnings
The part I find most interesting technically is using HTTP 402 as a real protocol primitive rather than a payment wall gimmick. The facilitator model means the payer never touches gas, and the whole flow is just HTTP request → 402 → signed header → 200.
Live at https://x402drop.com. Docs at https://x402drop.com/docs.
Happy to answer questions about the x402 protocol implementation or the architecture.

value: Show HN: X402drop – Temporary file sharing paid in USDC via the x402 protocol

author: easylearnai


value: jovanaccount

value:
I built this because every multi-agent system I worked on had the same problems:
agents overwriting each other's state, no permission boundaries, no token budgets,
and you're locked into one framework.
Network-AI adds a coordination layer on top of whatever you already use —
LangChain, CrewAI, AutoGen, MCP, etc. Shared atomic blackboard with
propose→validate→commit, AuthGuardian for permission gating, FederatedBudget
for token ceilings, and 12 plug-and-play adapters.
No API key needed to try the demo: npx ts-node examples/08-control-plane-stress-demo.ts

value: Show HN: Network-AI – plug any AI framework into one atomic blackboard

author: jovanaccount


value: lucalanziani

value: A new claw is born every other day, so I've decided to build my own, taking inspiration from Kelsey's nocode repo.<p>The tinier we can make it the better. PRs are welcome.

value: Show HN: Noclaw

author: lucalanziani

title: Show HN: Noclaw


value: spenvo

value: I found myself using macOS Spaces more to keep my (growing number) of side projects separated and organized.<p>I built a Mac app that helps wrangle a ton of Spaces by letting you assign names (and custom menu bar icons) to them and giving you quick ways to jump directly between them (via hotkeys, a drop down, or via scripting (even from Terminal line)). www.currentkey.com  The basic app is free, and there's an all-inclusive IAP to unlock all of its features. For a brief time, that IAP will be set at $2 (I think I'll normally price it around $10)

value: Show HN: give names/icons to Mac Spaces, jump between and track time across them

author: spenvo


value: tesujimath

value: I created this project for my own use, and as a means to develop proficiency in Rust and Clojure.  It is now at the stage where it could be useful for others, and my intention is to further develop it so it becomes increasingly useful.  I am really enjoying being able to query my accounts from a Clojure REPL.<p>And despite the current prevalence of AI code-generation, this was created by my own bare hands, quite slowly.  All feedback welcome, most especially from anyone trying it out.

value: Show HN: Limabean – a new implementation of Beancount in Clojure/Rust

author: tesujimath


value: Show HN: Interactive WordNet Visualizer-Explore Semantic Relations as a Graph


value:
My wife is a product manager and she kept asking me questions about APIs at her new job. I’m a former developer and now a high school teacher, and I love simplifying complex tech concepts.
So we created API101.org, a free course to help product managers and non-technical folks understand APIs, webhooks, authentication, and more. Most of the course is reading and examples, but there are a few mini Postman-style widgets (her idea) scattered in the lessons so you can try real API calls right in your browser.
It’s about 2–3 hours long, fairly comprehensive (maybe a bit much, but everything felt essential), and built as a side project for fun.
We’d love feedback, what’s useful, what’s confusing, what could be improved. Thanks!

value: Show HN: A Free, interactive API course for product managers


value: Boussettah

value: Show HN: VibeDiff – Blocks Claude Code from shipping breaking changes

author: Boussettah


value: recouptreadmill

value: Show HN: Headless Obsidian Sync Client

author: recouptreadmill

title: Show HN: Headless Obsidian Sync Client


value: Show HN: I build a free topical authority map generator for blog


value:
Validatedata is a Python library for validating dicts, lists, function arguments, and API payloads inline. No model classes, no boilerplate — just rules alongside the data.
pip install validatedata
Three ways to use it
1. Standalone function — validate a dict
pythonfrom validatedata import validate_data
result = validate_data(
    data={'username': 'alice', 'email': 'alice@example.com', 'age': 25},
    rule={'keys': {
        'username': 'str|min:3|max:32',
        'email': 'email',
        'age': 'int|min:18',
    }}
)
result.ok      # True
result.errors  # []
# on failure:
# [['username: invalid string length'], ['age: number out of range']]
2. Decorator — validate function arguments
pythonfrom validatedata import validate
@validate(['str|min:3|max:32', 'email', 'str|min:8|msg:password too weak'])
def signup(username, email, password):
    return 'Account Created'
signup('alice', 'alice@example.com', 'Secure@123')  # works
signup('alice', 'not-an-email', 'weak')              # returns {'errors': [...]}
3. Type annotation decorator
pythonfrom validatedata import validate_types
@validate_types
def create_user(username: str, age: int):
    return f'{username} ({age})'
create_user('alice', 30)       # works
create_user('alice', 'thirty') # raises ValidationError
All three support async functions transparently.
Shorthand rule syntax
Rules can be written as compact pipe-separated strings. Transforms, validators, and custom messages chain in one line:
python'str|min:3|max:32'
'email|nullable'
'int|between:0,100'
'str|strip|lower|in:admin,editor,viewer|msg:invalid role'
'str|min:8|re:(?=.[A-Z])(?=.\d).+|msg:password must contain uppercase and a number'
'color|format:hex|nullable'
'url|starts_with:https|msg:must be a secure URL'
Named transforms (strip, lstrip, rstrip, lower, upper, title) run before validation. msg: is always last.
Transforms and mutation
Apply transforms before validation and get cleaned values back:
pythonresult = validate_data(
    data=['  Alice  ', '  bob  '],
    rule=['str|strip|lower', 'str|strip|lower'],
    mutate=True
)
result.ok    # True
result.data  # ['alice', 'bob']
Conditional validation
Validate a field only when a sibling field meets a condition:
pythonrule = {'keys': {
    'role': {'type': 'str'},
    'permissions': {
        'type': 'str',
        'depends_on': {'field': 'role', 'value': 'admin'},
        'options': ('full', 'read', 'none')
    }
}}
# permissions only validated when role == 'admin'
Custom error messages
Any rule key accepts a {rule}-message override:
python{
    'type': 'int',
    'range': (18, 'any'),
    'range-message': 'you must be at least 18',
    'type-message': 'age must be a number',
}
Shorthand: 'int|min:18|msg:you must be at least 18'
Supported types
Basic: str, int, float, bool, email, url, ip, uuid, slug, semver, phone, color, date, even, odd, prime
Extended: dict, list, tuple, set, regex, object
Phone validation supports E.164 built-in. National, international, and region-specific formats available via pip install phonenumbers.
Color validation supports hex, rgb, hsl, and named CSS colors.
Supported rules
range, length, contains, excludes, options, expression, startswith, endswith, unique, nullable, strict, transform, depends_on, fields, items
Return value
validate_data returns a SimpleNamespace:
result.ok — True if all validation passed
result.errors — list of error groups, one per field
result.data — transformed values, only present when mutate=True
MIT licensed. Python 3.7+. No required dependencies.
Repo: https://github.com/Edward-K1/validatedata
PyPI: https://pypi.org/project/validatedata/
Feedback, bug reports, and use-case stories welcome.

value: Show HN: Validatedata 0.3.0 – lightweight inline data validation for Python


value: ArcadeMode

value:
I'm a big proponent of WebAssembly and .NET. When I found out .NET now runs in the browser on WASM with ánd without Blazor, I figured that could be something. Since Blazor is often too big of a step for TypeScript developers, I figured the recently added ability to include a .NET WASM app as a library in a JS bundle could be a good stepping stone for WASM to gain some ground in this JS-heavy web we have.
Using the JSExport/JSImport interop is relatively cumbersome, it only supports static methods, has no OOP concepts (like classes, just object handles) and it requires manually writing TypeScript definitions for the exported methods. So I decided to try and make some tooling that would improve the developer experience and reliability higher.
Enter TypeShim: a codegen tool that creates a seamless programming experience between .NET WebAssembly and TypeScript. Complete class level exports are translated to C# codegen to automatically define your JSExports/JSImports with a TypeScript class that wraps these methods. This creates proxies that look exactly like your C# classes and behave all the same, static/member, constructors, properties, methods, even things like reference equality. TypeShim supports all types that JSExport supports but includes your own classes in that list, so it provides a superset of what JSExport offers.
--
As Roslyn codegen wouldnt allow me to generate code that the JSExport codegen could consume, I had to make my own CLI codegen tool (which was a lot of fun). Thank Roslyn for exporting its APIs, allowing me to run my own compilation, which I could then use to build C# and TypeScript matching the classes that were marked for export.
It was also a good excuse to do some performance optimization work (because why not?!), NativeAOT turned out particularly suited for such short-running tooling and by taking care of a few bottlenecks found with PerfView, I managed to get codegen times down to ~100ms for projects with 100+ classes requiring codegen.
It took me down paths I hadnt expected to ever expected to end up at, like finding two bugs while E2E testing the solution, which would crash the .NET WASM runtime, which led me to dive into the dotnet/runtime repo and fix them. The dotnet team was grateful and very welcoming, inviting me to try fixing the same issues in the new .NET11 interop implementation which runs on the CoreCLR instead of mono. Great experience, I'll be going back for more TypeShim adjacent challenges: adding more types to the interop library.
--
Anyway, that was a bit of excitement about my recent open source activity. If you have a moment to look at TypeShim, maybe even leave a star, that would be greatly appreciated. But mostly I would love to hear your feedback!
Best,
ArcadeMode

value: Show HN: TypeShim – .NET WebAssembly Meets TypeScript

author: ArcadeMode


value: dixalex

value:
I built Proofd (https://proofd.ai) after researching AI displacement data and realizing that job-title-level predictions are nearly useless. Two Marketing Managers can score 78 and 31 depending on their daily task mix. Well, to be really honest -- I was trying to understand the path for myself first :)
Proofd scores your actual tasks across 5 dimensions (repeatability, data dependency, AI capability, human interaction depth, accountability tolerance) using O*NET occupational data and METR autonomous capability benchmarks.
Built with AI obviously. Looking for feedback on the scoring methodology.
Free instant score. Full task-by-task report for $29 (launch price).
For HN commenters -- giving out reports for free to those who can honestly give feedback. Just put your HN username somewhere when submitting the form, don't make the payment, and just comment here. I'll see it and will send over a free report for you to check out!
Curious what HN thinks.

value: Show HN: Proofd – Free AI career risk score based on your tasks, not job title

author: dixalex


value: kxbnb

value:
I built webact while experimenting with browser control for LLM agents and kept running into the same problem: token usage.
Most tools wrap Playwright and return huge accessibility trees or DOM dumps, which gets expensive quickly. webact takes a simpler approach — it talks directly to Chrome via the DevTools Protocol and returns a small "page brief" instead.
It’s just a single JS file (~196KB), zero dependencies, and it uses your existing Chrome session.
Happy to hear thoughts.

value: Show HN: Webact – token-efficient browser control for AI agents (GitHub)

author: kxbnb


value: zimtzimt

value: Show HN: Grok Brain – Turn your Grok data into a private 3D brain visualization

author: zimtzimt


value: davinciind

value:
We're building Payments and Trust layer for AI to make payments on behalf of the users, with their regular card.
We've partnered with Major card networks like Visa and building stablecoin wallets for AI to make payments, anywhere online.
Used by AI assistants, AI stylist apps, Concierge app etc.
Would love to hear any feedbacks.

value: Show HN: AI making payments with your regular Visa card, securely. Prava

author: davinciind


value: cyrusburns

value:
Limelight is an open source SDK that captures what's happening in your app while you're developing and pipes that context into AI coding assistants via MCP.
The problem: when you're debugging in Cursor or Claude Code, the AI can only see your source files. It can't see network requests, state changes, re-renders, or timing. So it
guesses. Limelight gives it the actual evidence.
The SDK sits in your app and captures everything (network requests, GraphQL ops, console logs, Zustand/Redux state, component renders), then correlates it by timing and causality into what I call Debug IR. It's not a log dump. It strips sensitive data, compresses the timeline to what's relevant, and structures everything into causal chains so the LLM can reason about what caused what instead of scanning a wall of text.
The MCP server reads from that Debug IR. It's 11 tools total, which was intentional. A lot of MCP servers ship with 30-40+ tools and eat half your context window before you even ask a question.
The part I'm happiest with is full stack tracing. Drop the SDK into your React or React Native frontend and your Node/Next.js backend, and Limelight correlates everything together. You can trace a request from a button tap through the API call, into the backend handler, back through the response, into the state update, and through the re-render. All in one place. No switching between browser devtools and server logs trying to match timestamps.
So when you ask Cursor "why is my search showing stale results", it can see that two API requests came back out of order and the slower one overwrote the correct state. It suggests an abort controller fix based on what actually happened.
It started as a React Native debugger because debugging RN at all suckst. It grew from there into React, React Native, Node, and Next.js. Setup is two lines (Limelight.connect()), no wrappers, no config. The correlation engine automatically catches N+1 queries, render loops, retry storms, and stale closures. Free to use without an account.
About 3k weekly downloads on npm. MIT licensed. Solo dev.
Would love feedback, especially on the MCP workflow. Is giving AI editors access to live runtime context something you'd actually use? What's missing?

value: Show HN: Limelight – Let your AI see what your app does at runtime

author: cyrusburns


value: cameronhamilton

value:
Most ML frameworks optimize for leaderboard accuracy.
But in finance and healthcare, accuracy is often the least interesting part of the system.
If you can’t explain a prediction, you can’t deploy it.
If your probabilities aren’t calibrated, you can’t trust them.
If your pipeline doesn’t enforce constraints, you can’t ship it.
I built Endgame after repeatedly running into that gap in production.
Anti-money laundering (banks)
Early in my career, I was hired to improve an anti-money laundering system.
The incumbent model was 28 hard-coded rules.
If enough thresholds fired (e.g., $3,000 ATM withdrawals over 30 days), the account was flagged.
No one knew where the thresholds came from.
There was no modeling of the underlying behavior.
Just rule accumulation.
I convinced the bank to provide the raw financial features behind those rule firings.
We trained an interpretable ML model directly on the underlying activity patterns.
The result: ~200% more true positives (accounts actually involved in fraud or laundering).
But what leadership cared about most wasn’t the metric.
It was this:
“Why is this account suspicious?”
That theme repeated across industries.
Insurance claim adjudication
I later built a claim adjudication model for a major health insurer.
The legacy system was massive, brittle, and effectively a black box.
It would frequently deny claims incorrectly, and no one fully understood how it worked.
We built a new ML system that brought claim-level adjudication accuracy to ~95%.
Again, the metric wasn’t the headline internally.
The headline was:
“Why did this claim get denied?”
In regulated environments, interpretability isn’t optional.
Stock forecasting and calibration
I also learned this lesson personally.
I built stock-forecasting models that performed well in historical backtests.
Some predictions showed 80% probability of a price increase.
Then the market regime shifted.
The probabilities were overconfident.
Some trades went the opposite direction.
I lost money.
Accuracy ≠ trustworthy probabilities.
Calibration and drift awareness matter far more in deployment than most tutorials suggest.
That experience fundamentally changed how I think about ML systems.
The core idea
Endgame is my attempt to encode those lessons into a framework.
It’s not trying to replace scikit-learn.
Every estimator implements fit / predict / transform.
But it extends the ecosystem with:
Glass-box models (EBM, GAM, CORELS, SLIM, GOSDT, etc.)
SOTA deep tabular models (FT-Transformer, TabPFN, SAINT, etc.)
Conformal prediction and Venn-ABERS calibration
Deployment guardrails (leakage detection, latency constraints, drift checks)
42 self-contained HTML visualizations
Super Learner, BMA, cascade ensembles
A full AutoML pipeline that respects deployment constraints
All under a unified sklearn-compatible API.
Agent-native ML (MCP)
We’re in the agentic AI era.
You can ask an LLM to build a pipeline for you, but it often requires multiple prompts and manual corrections.
Endgame ships with a native MCP server.
This lets agents:
load data
train models
compare results
generate reports
export reproducible scripts
Through structured tool calls, not fragile prompt chains.
My belief is that ML pipelines will increasingly become conversational infrastructure.
A small contrarian view
The ML community is underestimating the problems left to solve in tabular data
and overestimating the demand for accuracy-optimized models.
Most real-world data in business, healthcare, and finance is tabular (often multimodal).
And most real-world systems need to be interpretable, calibrated, and deployable — not just accurate.
Endgame v1.0.0 is open source (Apache 2.0).
Python 3.10+.
If you work on production ML systems, especially in regulated domains, I’d genuinely value feedback.
GitHub: https://github.com/allianceai/endgame
Install: pip install endgame-ml
Happy to answer technical questions.

value: Show HN: Endgame – Production-aware ML under the sklearn API

author: cameronhamilton


value:
Hello everyone,
I built Bearprompt because I wanted a simple prompt library that doesn’t require an account and doesn’t store anything on a server.
All prompts are saved locally in your browser (IndexedDB).
My main goal was that users can interact with it easily and fast. You open the prompt library and by just clicking the card of the prompt, you have it copied in your clipboard and continue with your work.
Happy to hear some feedback :)

value: Show HN: Bearprompt – Privacy-first prompt library that runs in the browser


value: maleta

value:
BlokJS is a ~9KB (gzipped) reactive UI framework with components, routing, and a built-in store. No build step, no dependencies, no virtual DOM - just a library in one js file.
Reactivity uses ES Proxies with automatic dependency tracking - reference a property in your view and updates happen automatically. Components are plain objects, no JSX or templates needed. Async methods automatically get reactive loading/error states.
I built this because I wanted a framework where I could prototype and ship frontend without bundlers or config - something closer to how backend development feels.
Live example (task board with auth, drag-drop, routing): https://maleta.github.io/blokjs/examples/task-board.html#/lo...
Source: https://github.com/maleta/blokjs

value: Show HN: BlokJS – No VDOM, no build reactive UI framework (~9KB gzipped)

author: maleta


value: darnfish

value:
Hey HN!
Today I'm launching Pane, a tool that gives AI context on your financial data.
Once connected, any MCP-compatible client (Claude, Cursor, ChatGPT, etc.) can answer questions like:
- "What did I spend on food this month?"
- "What's my net worth right now?"
- "Show me my recurring subscriptions"
- "How much do I owe across all credit cards?"
- "What are my investment holdings?"
It's been really transformative in helping me and some of my friends understand their finances, where they are overspending, or even being double billed in some cases.
I'm very aware that this is a somewhat controversial idea. Banking data is an extremely personal set of data and connecting it with something that in many cases can hallucinate and is often hosted by a third party is understandably concerning. Many people already do this by uploading billing statements, CSV's, etc. And this product is definitely for those early adopters, myself included. I'm really interested to hear some of the feedback from this community regarding this idea. I totally understand this is not for everyone, but if you do let it into your life I believe it can have a positive impact on your relationship with money.
If you'd like to give it a try, use code `HACKERNEWS` for 50% off your first month. If you try it and decide it is not for you within the first week, please reach out to support@pane.money and I can set you up with a refund.
Excited to hear feedback, critique, thoughts - everything :~)

value: Show HN: Pane – Give your AI access to your financial data via MCP

author: darnfish


value: zedredwed

value: Show HN: Edit PDF text without ruining fonts. 100% local, no paywalls

author: zedredwed


value: joelolawanle

value:
Hey HN,
We just launched a new landing page for Spidra (spidra.io) and I thought to share because we now have a sleek modern UI.
You may ask. What is Spidra? Well, it's an AI-powered web scraping platform, currently in public beta.
If you are conversant with using scraping packages or using other traditional scrapers, they break constantly. When a site redesigns, your selectors stop working.
Instead of CSS selectors, with Spidra you just describe what you want in plain English. For example, "Extract all product names and prices." The AI figures out where that data lives on the page and pulls it, even if the layout changes next week. We call it AI Mode.
What's included:
- AI Scraper and AI Crawler (single pages or full domains)
- Action sequences in plain English: click, scroll, type, wait. No selectors needed.
- Built-in CAPTCHA solving, residential proxy rotation across 45+ locations, session and auth handling
- REST API with async job polling so you can chain scrapes, loop results, build proper pipelines
- Push results to JSON, CSV, Slack, Discord, Airtable, Google Sheets, or your own webhook
This is for developers building data pipelines or AI agents that need fresh web data. We also have a no-code playground for less technical users.
You can test Spidra on the free tier with 300 credits (no credit card needed).
I look forward to hearing what you think about our new landing page and the Spidra product. I am also happy to answer anything about how we handle anti-bot systems, the architecture, or how we compare to other tools in the space.
Try it: https://app.spidra.io/signup
Docs: https://docs.spidra.io

value: Show HN: Spidra – AI web scraper that adapts to any website

author: joelolawanle


value: daolm

value: It has the same principles as openclaw, but has a custom stack of dozens of CLIs to integrate with LinkedIn, Instantly, Google Search Console, etc. without complex setups and a very low token burn. Just connect your Slack in 1 minute and start automating your entire company!

value: Show HN: Autonomous Agent That Uses Your Tools Without Complex Setups

author: daolm


value: shhac

value:
git add -p is the only built-in way to stage individual hunks, and it's interactive — you step through hunks one at a time answering "y/n/q/a/d/e/?". That works fine for humans at a keyboard, but it's completely unusable for LLM agents, shell scripts, and CI pipelines.
git-hunk is the non-interactive alternative. It gives every hunk a stable SHA-1 content hash, then lets you stage by hash:
$ git hunk list --oneline

  a3f7c21  src/main.zig   42-49  if (flags.verbose) {…

  b82e0f4  src/parse.zig  15-28  fn parseArgs(alloc: …

$ git hunk add a3f7c21

  staged a3f7c21 → a3f7c21  src/main.zig

The key design choice: hashes are computed from the immutable side's line numbers, so staging one hunk never changes another hunk's hash. This makes multi-step scripted workflows reliable — you can enumerate hunks, make decisions, then stage them without the targets shifting underneath you.
Other things it does: line-range selection (a3f7:3-5,8), --porcelain output for machine consumption, count for CI guards, check --exclusive for hash validation, stash individual hunks, and restore to selectively discard changes.
Single static binary, written in Zig, zero runtime dependencies beyond git itself. Install via brew install shhac/tap/git-hunk.
I built this because I was trying to run AI agents in parallel, and stuck to file-level editing they'd fight eachother over what changes they wanted to put into commits. Now I can have multiple agents work in parallel and commit cleanly without needing worktrees.

value: Show HN: Git-hunk – Stage hunks by hash, no "-p" required

author: shhac


value: myztika

value:
Hi guys,
I’ve been building investing tools for myself and kept running into the same issue:
Most free financial APIs give you price data and some fundamentals, but insider transactions and 13F filings are either delayed or locked behind relatively expensive paid tiers.
What bothered me more was that a lot of data isn’t actually sourced cleanly it’s scraped or inconsistently structured.
So I ended up building my own API called finqual.app
A few things that might be relevant here:
Data is pulled directly from SEC filings
Updated as soon as filings are published
Financial statements, insider transactions, and 13F filings included
Data is normalized and structured (so you don’t have to parse raw SEC filings)
100 free API calls/day
No credit card required
It’s basically structured SEC data without having to deal with EDGAR formatting yourself.
If anyone here is building dashboards, screeners, or running their own fundamental analysis, happy to answer questions or get feedback.

value: Show HN: Finqual – Free SEC-based API for fundamentals, insider and 13F data

author: myztika


value: ontehfritz

value:
Demarkus started as a simple project: what if the web was just markdown? No HTML, no
JavaScript, no ads, no tracking;just structured text over encrypted transport. A
protocol for durable knowledge, not attention capture.
I built the Mark Protocol on QUIC (UDP, TLS 1.3 built-in) with a small verb set:
FETCH, LIST, VERSIONS, PUBLISH, APPEND, ARCHIVE serving markdown with YAML
frontmatter. Human-readable status strings instead of numeric codes. Capability-based
auth (tokens grant permissions, not identities). Every write creates a new immutable
version with SHA-256 hash chain verification.
But the use case that surprised me is what I'm calling the "demarkus-soul" pattern.
The problem: Every AI coding agent session starts from zero. The agent has no memory
of your project's architecture, past debugging sessions, or decisions you've made
together. The solutions out there tie you to a specific agent vendor. Switch agents?
Your project knowledge stays behind.
The solution: Run a small demarkus server for your project. Your AI agent connects
via MCP (Model Context Protocol) and gets tools to read and write markdown documents;
architecture notes, debugging lessons, code patterns, a journal. All versioned, all
persistent across sessions, all stored as plain markdown files on your machine.
I've been using this while developing demarkus itself. The agent's "soul" runs on a
Orange Pi on my desk. Each session, the agent reads what past sessions left behind,
adds to it, and the next session finds it there. The agent even journals and reflects on
its own work. It's self-documenting the history of your project, "the soul of your
project".
Key properties:
- No vendor lock-in. Any agent that supports MCP can connect: Claude, Codex,
  whatever comes next. The memory is yours, plain markdown on your hardware.
- Versioned and immutable. Full audit trail. You can see exactly what the agent
  knew and when.
- Zero impedance mismatch. Agents already think in markdown. No translation layer
  between what the protocol delivers and what the agent processes.
- Runs anywhere. The server is a single Go binary. No databases, no CMS, no
  background services. A Raspberry Pi or Orange Pi is plenty.
The whole stack is open source. AGPL for the implementation, CC0 for the protocol spec
(anyone can implement it). Written in Go with a server, CLI, terminal browser (TUI with
Bubble Tea), and MCP server all included.
It's a WIP but usable!
Read the projects soul:
mark://soul.demarkus.io
(served by demarkus itself)
GitHub:
https://github.com/latebit-io/demarkus
The demarkus-soul pattern and website: https://www.demarkus.io/soul/
https://www.demarkus.io
what it's like to give your AI agent a persistent memory that you actually own?

value: Show HN: Demarkus – De-centralized Markup for Us:memory for AI agents and humans

author: ontehfritz


value: sheldonksalmon

value: Show HN: Sovereign Trace Stamp – Frozen triple-time cryptographic timestamp

author: sheldonksalmon


value: suleymanibis

value:
I'm an 18-year-old CS student from Turkey. I've been building Dracula, a Python wrapper for the Google Gemini API. I initially built it because I wanted a simpler Mini SDK that handled conversational memory, function calling, and streaming out of the box without the boilerplate of the official SDK.
Recently, I got some well-deserved technical criticism from early users: using JSON files to store chat history was a memory-bloat disaster waiting to happen; forcing a PyQt6 dependency on server-side bots was a terrible design choice; and lacking a retry mechanism meant random 503s from Google crashed the whole app.
So, I went back to the drawing board and completely rewrote the core architecture for v0.8.0. Here is what I changed to make it production-ready:
Swapped JSON for SQLite: I implemented a local database system (using sqlite3 for sync and aiosqlite for async). It now handles massive chat histories without eating RAM, and tracks usage stats safely.
True Async Streaming: Fixed a generator bug that was blocking the asyncio event loop. Streaming now yields chunks natively in real-time.
Exponential Backoff: Added an under-the-hood auto-retry mechanism that gracefully handles 429 rate limits and 503/502 server drops.
Zero Bloat: Split the dependencies. "pip install dracula-ai" installs just the core for FastAPI/Discord bots. "pip install dracula-ai[ui]" brings in the desktop interface.
Here is a quick example of the async streaming:
import os, asyncio
from dracula import AsyncDracula
async def main():
async with AsyncDracula(api_key=os.getenv("GEMINI_API_KEY")) as ai:
async for chunk in ai.stream("Explain quantum computing"):
print(chunk, end="", flush=True)
asyncio.run(main())
Building this has been a huge learning curve for me regarding database migrations, event loops, and package management. I would love for the HN community to look at the code, review the async architecture, and tell me what I did wrong (or right!).
GitHub: https://github.com/suleymanibis0/dracula
PyPI: https://pypi.org/project/dracula-ai/
Thanks for reading!

value: Show HN: Dracula-AI – A lightweight, async SQLite-backed Gemini wrapper

author: suleymanibis


value:
I built Observatory to automatically evaluate Hacker News front-page stories against all 31 provisions of the UN Universal Declaration of Human Rights — starting with HN because its human-curated front page is one of the few feeds where a story's presence signals something about quality, not just virality. It runs every minute: https://observatory.unratified.org. Claude Haiku 4.5 handles full evaluations; Llama 4 Scout and Llama 3.3 70B on Workers AI run a lighter free-tier pass.
My health challenges limit how much I can work. I've come to think of Claude Code as an accommodation engine — not in the medical-paperwork sense, but in the literal one: it gives me the capacity to finish things that a normal work environment doesn't. Observatory was built in eight days because that kind of collaboration became possible for me. (I even used Claude Code to write this post — but am only posting what resonates with me.) Two companion posts: on the recursive methodology (https://blog.unratified.org/2026-03-03-recursive-methodology...) and what 806 evaluated stories reveal (https://blog.unratified.org/2026-03-03-what-806-stories-reve...).
The observation that shaped the design: rights violations rarely announce themselves. An article about a company's "privacy-first approach" might appear on a site running twelve trackers. The interesting signal isn't whether an article mentions privacy — it's whether the site's infrastructure matches its words.
Each evaluation runs two parallel channels. The editorial channel scores what the content says about rights: which provisions it touches, direction, evidence strength. The structural channel scores what the site infrastructure does: tracking, paywalls, accessibility, authorship disclosure, funding transparency. The divergence — SETL (Structural-Editorial Tension Level) — is often the most revealing number. "Says one thing, does another," quantified.
Every evaluation separates observable facts from interpretive conclusions (the Fair Witness layer, same concept as fairwitness.bot — https://news.ycombinator.com/item?id=44030394). You get a facts-to-inferences ratio and can read exactly what evidence the model cited. If a score looks wrong, follow the chain and tell me where the inference fails.
Per our evaluations across 805 stories: only 65% identify their author — one in three HN stories without a named author. 18% disclose conflicts of interest. 44% assume expert knowledge (a structural note on Article 26). Tech coverage runs nearly 10× more retrospective than prospective: past harm documented extensively; prevention discussed rarely.
One story illustrates SETL best: "Half of Americans now believe that news organizations deliberately mislead them" (fortune.com, 652 HN points). Editorial: +0.30. Structural: −0.63 (paywall, tracking, no funding disclosure). SETL: 0.84. A story about why people don't trust media, from an outlet whose own infrastructure demonstrates the pattern.
The structural channel for free Llama models is noisy — 86% of scores cluster on two integers. The direction I'm exploring: TQ (Transparency Quotient) — binary, countable indicators that don't need LLM interpretation (author named? sources cited? funding disclosed?). Code is open source: https://github.com/safety-quotient-lab/observatory — the .claude/ directory has the cognitive architecture behind the build.
Find a story whose score looks wrong, open the detail page, follow the evidence chain. The most useful feedback: where the chain reaches a defensible conclusion from defensible evidence and still gets the normative call wrong. That's the failure mode I haven't solved. My background is math and psychology (undergrad), a decade in software — enough to build this, not enough to be confident the methodology is sound. Expertise in psychometrics, NLP, or human rights scholarship especially welcome. Methodology, prompts, and a 15-story calibration set are on the About page.
Thanks!

value: Show HN: I built a LLM human rights evaluator for HN (content vs. site behavior)


value:
Hi HN,
I've been building a CLI called Restless that tries to make exploring unfamiliar APIs easier.
When you encounter a new API the first step is often slow:
finding documentation, locating Swagger/OpenAPI, and understanding the endpoint structure.
Restless tries to automate that discovery process.
Example:
$ restless scan https://api.github.com
Restless API Discovery
Scanning: https://api.github.com
swagger detected
142 endpoints indexed
Auth
 ├─ POST /login
 ├─ POST /refresh
Users
 ├─ GET /users
 ├─ GET /users/{id}
Repo:
https://github.com/bspippi1337/restless
Feedback very welcome.

value: Show HN: Restless – a CLI that discovers and maps APIs automatically


value: ManfredMacx

value:
Formualizer is a spreadsheet engine written in Rust: parse Excel formulas, track dependencies, evaluate with 320+ functions, mutate workbooks, undo/redo. Python bindings via PyO3, WASM for the browser. MIT/Apache-2.0.
The original motivation was server-side formula evaluation in Python. openpyxl reads and writes xlsx well but evaluates nothing - formula cells return None unless Excel cached values on last save. xlcalc actually evaluates but covers around 50 functions. If you needed XLOOKUP, SUMIFS with multiple criteria, IRR, XIRR, or dynamic arrays like FILTER and UNIQUE, you were either installing Excel on a Linux box or accepting the gaps.
There's a one-liner for the common case:

    import formualizer as fz
    fz.recalculate_file("model.xlsx", output="recalculated.xlsx")

Or drive it programmatically — load a workbook, change inputs, evaluate:

    wb = fz.load_workbook("model.xlsx")
    wb.set_value("Assumptions", 3, 2, 0.08)
    wb.evaluate_all()
    print(wb.evaluate_cell("Summary", 5, 3))  # =IRR(...)

You can also register Python callbacks as first-class formula functions that participate in the dependency graph.
The Rust and WASM targets are also fully supported - the engine is the core with Python, WASM, and a stable CFFI as targets.
Formal benchmarks are in progress!
Docs: https://www.formualizer.dev/docs

value: Show HN: Formualizer – Arrow-backed spreadsheet engine, 320 functions,PyO3+WASM

author: ManfredMacx


value: bberisford

value:
I'm a private pilot and software engineer. I set out to build a 3D VFR flight planning tool — something that would let you visually plan a cross-country flight with real weather, airspace, and terrain.
Before I could build any of that, I had to build an entire data infrastructure first.
FAA airport data comes as fixed-width text files from the NASR subscription, updated on a 28-day cycle. Obstacles are a separate 56-day file with daily patches. NOTAMs require a formal application to the FAA's NMS system — staging approval, then production approval, OAuth2 token management. Weather data from aviationweather.gov comes as bulk XML cache files they'd prefer you download rather than polling their API. Airspace boundaries live behind ArcGIS REST endpoints you have to paginate through with a 10-minute timeout.
I did eventually build the flight planning app — it's fully functional. But it caused problems with a previous employer who considered it competitive, and I lost my job over it. To avoid further legal headaches, I shelved the app and pivoted to the infrastructure underneath it.
That became PreflightAPI.
What you get with one API key:

  - 19,600+ US airports with runways, frequencies, and terminal procedures
  - Real-time METARs, TAFs, PIREPs, SIGMETs, G-AIRMETs
  - NOTAMs with spatial queries (by airport, radius, or route corridor)
  - Airspace boundaries as GeoJSON (Class B/C/D/E, restricted, MOAs, etc.)
  - 625k+ obstacles from FAA's Digital Obstacle file.
  - E6B utilities (crosswind, density altitude, wind correction, pressure altitude, TAS)
  - VFR navlog generation with automatic TOC/TOD waypoints, winds aloft interpolation, and fuel tracking
  - A composite briefing endpoint — one request returns all weather, NOTAMs, and hazards along a route

  I just launched and have one paying customer. Free tier is 5,000 calls/month. Docs: https://preflightapi.io/docs

  I'd appreciate feedback on the API design or what's missing or if this is something you'd find useful or interesting :)

value: Show HN: PreflightAPI – US airports, weather, NOTAMs and more via one API

author: bberisford


value:
Hi HN — I’m Ethan, a solo developer. I built DubTab because I spend a lot of time in meetings and watching videos in languages I’m not fluent in, and subtitles alone don’t always keep up (especially when the speaker is fast).
DubTab is a Chrome/Edge extension that listens to the audio of your current tab and gives you:
1.Live translated subtitles (optional bilingual mode)
2.Optional AI dubbing with a natural-sounding voice — so you can follow by listening, not just reading
The goal is simple: make it easier to understand live audio in another language in real time, without downloading files or doing an upload-and-wait workflow.
How you’d use it
1.Open a video call / livestream / lecture / any tab with audio
2.Start DubTab
3.Choose target language (and source language if you know it)
4.Use subtitles only, or turn on natural AI dubbing and adjust the audio mix (keep original, or duck it)
What it’s good for
1.Following cross-language meetings/classes when you’re tired of staring at subtitles
2.Watching live content where you can’t pause/rewind constantly
3.Language learners who want bilingual captions to sanity-check meaning
4.Keeping up with live news streams on YouTube when events are unfolding in real time (e.g., breaking international updates like U.S./Iran/Israel-related developments)
Link: https://dubtab.com
I’ll be in the comments and happy to share implementation details if anyone’s curious.

value: Show HN: DubTab – Live AI Dubbing in the Browser (Meet/YouTube/Twitch/etc.)


value: ddesposito

value: Show HN: A leadership 360 survey for startup founders: feedback please

author: ddesposito


value:
I've been building Augur as a solo side project for the last month or so. It started as an experiment to see if I could make "boss fight" that learned from all comers, but still felt genuinely fair to play. The original plan was to build a simplistic jrpg style turned-based encounter engine, but I quickly pivoted to a text based interface, recalling my early experiences with Adventure and Zork. That naturally led to incorporating an LLM, and it turned into something I find pretty fun, so I'm sharing it.
The core idea is simple: you play a text-based boss encounter against a character called the Architect, set in a strange library. You can fight, sneak, persuade, or try something I haven't thought of. Turns are mechanically resolved with d100 rolls, conditions track injuries instead of HP, and objects in the world have physical properties the LLM reasons about. The "engine" is property-based instead of tables of rules, and I've found that to yield some novel gameplay.
The part I'm most interested in exploring is the learning. The Architect builds impressions from what it actually perceived during an encounter, stores them as vector embeddings, and retrieves relevant ones at the start of future encounters. It's lossy on purpose — more like human memory than a database lookup. If a tactic keeps working, the Architect starts recognizing the pattern. If you sneak past undetected, it remembers losing but not how.
The technical foundation for all of this is a dual-LLM turn loop. Each turn makes two model calls: an engine model that sees full game state and resolves mechanics, then an architect model that only receives what it has actually perceived (line of sight, noise, zone proximity). The "information asymmetry" is structural and deliberate — the architect model literally cannot access state the engine doesn't pass through the perception filter.
I tried the single-LLM approach first and it didn't work. No matter how carefully you prompt a model to "forget" information sitting in its context window, it leaks. Not to mention the Architect had the habit of adopting God Mode. So splitting the roles made the whole thing feel honest in a way prompt engineering alone couldn't.
This is my first HN post, and this is a real launch on modest infrastructure (single Fly.io instance, small Supabase project), so if it gets any traffic I might hit some rough edges. There's a free trial funded by a community pool, or you can grab credits for $5/$10 if you
want to keep going. It's best experienced in a full desktop browser, but it's passable on the two mobile devices I've tested it on.
Playable here: https://www.theaugur.ai/
I'm happy to go deeper on any of the internals — turn flow, perception gating, memory extraction, cost model, whatever is interesting.

value: Show HN: Augur – A text RPG boss fight where the boss learns across encounters


value: munch-o-man

value:
I wanted offsite copies of my nomad cluster backups without paying. So I started thinking about how to maximize free S3 storage from multiple providers. What if I could just stack them all together and treat them as one big bucket? I started hacking out a simple proxy and then I was having fun, so I kept building. My weekend project turned into what is basically a fully production-ready S3 orchestration service. You configure multiple S3-compatible backends (AWS, OCI, Backblaze, R2, MinIO, whatever), set a quota on each one, and the orchestrator presents them to your apps as a single S3 endpoint. Clients just sees one bucket with no idea files are being spread across multiple s3 providers
What makes it useful:
- Combine free tiers — set per-backend quotas to match each provider's free limit and the proxy fills them in order (pack mode) or evenly (spread mode). 10GB + 10GB + 10GB = 30GB of free offsite storage
- Multi-cloud replication — set replication.factor: 2 and every object automatically lands on two different providers. Instant redundancy, zero client-side changes
- Full S3 API — works with aws cli, rclone, boto3, any S3 SDK. SigV4 auth, multipart uploads, range reads, batch deletes, the works
- Virtual buckets — multiple apps can share the orchestrator with isolated namespaces and independent credentials
- Monthly usage limits — cap API requests, egress, and ingress per backend so you never blow past a free tier
- Write safety — all metadata and quota updates happen inside PostgreSQL transactions. Object location inserts and quota counter changes are atomic — if anything fails, the whole operation rolls back. Orphaned objects from partial failures get caught by a persistent cleanup queue with exponential backoff retry instead of silently leaking storage
- TLS and mTLS — native TLS termination with configurable min version (1.2/1.3), plus mutual TLS support for environments where you want to restrict access to clients with a valid certificate. Certificate reload on SIGHUP for zero-downtime rotation
- Multi-instance / split-mode deployment — run with -mode all (default), -mode api (request serving only), or -mode worker (background tasks only). Scale API instances independently from workers behind a load balancer.
- Trusted proxy awareness — configure trusted CIDR ranges so rate limiting targets real client IPs from X-Forwarded-For, not your load balancer
  (rebalancer, replicator, cleanup queue, lifecycle) use PostgreSQL advisory locks so only one worker runs each task at a time — no duplicate work, no coordination needed
- Circuit breaker — if the metadata DB goes down, reads keep working via broadcast to all backends. Writes fail cleanly
- Automatic rebalancing — if you add a new backend, the rebalancer redistributes objects across all of them
- Backend draining — need to remove a provider? s3-orchestrator admin drain <backend> live-migrates all objects off that backend to the remaining pool with progress tracking. Once drained, admin remove-backend cleans up the database records (optionally purging the S3 objects too). No downtime, no manual file shuffling — swap providers without your clients noticing
- Web dashboard — storage summary, backend status, file browser, upload/delete, log viewer
- Production observability — Prometheus metrics (60+ gauges/counters), OpenTelemetry tracing, structured audit logging with request ID correlation
- Lifecycle rules — auto-expire objects by prefix and age
- Config hot-reload — update credentials, quotas, rate limits, replication, and rebalance settings without restarting via SIGHUP
- Comes with production ready Kubernetes and Nomad manifests/jobs that can be run with, a custom grafana dashboard utilizing the exported metrics
A bit nervous to share this but I think it is ready to be seen and maybe somebody else would find it useful.

value: Show HN: I built a S3 proxy that combines storage from S3/clouds into one target

author: munch-o-man


value: LightProx

value:
Live dashboard: https://trader.lpxpoly.com
The agent scans 45+ Polymarket prediction markets, hires an AI inference agent via Lightning (30 sats/call) through AIProx (https://aiprox.dev), analyzes each market for mispricings, and places trades autonomously on Polygon.
AnonBot explains every skip — "market totals 100.1%, platform error not an edge" — not just the trades it takes. Two live positions open as of tonight.
AIProx (https://aiprox.dev) is the underlying registry — agents advertise capabilities and price, orchestrators hire them automatically. This is what agent-to-agent economy looks like in practice.

value: Show HN: AI agent that trades Polymarket by hiring inference via Lightning

author: LightProx


value: notepstein

value:
Most people right now are talking to their AI agents through Telegram bots, WhatsApp, Discord, or just copying and pasting between terminals.
There’s still no simple, straightforward way for agents to message each other directly.
AgentBus solves exactly that.
You register each agent with one quick API call.
Then they can send messages to each other using simple REST calls.
No servers, no queues, no WebSockets, no extra infrastructure.
Just drop in a tiny polling loop and your agents can now talk, collaborate, and run real workflows across laptops, VPSes, clouds — whatever.
You can also message any of your agents yourself from a clean browser UI on your phone, laptop, anywhere.
https://agentbus.org/
How are you currently making your agents talk to each other? Would love to hear.

value: Show HN: AgentBus – Centralized AI Agent-to-Agent Messaging via REST API

author: notepstein


value: mystart

value:
I've been using various UK salary calculators for years — ListenToTaxman, The Salary Calculator, Reed's tool — and my main frustration has always been the same: ad-heavy layouts, outdated designs, and results that sometimes don't match each other by £50–£100 on the same gross salary.
UKCalculator.com (ukcalculator.com) launched in 2018 and covers the usual suspects (income tax, NI, PAYE, mortgage repayments, stamp duty, VAT), but what caught my eye was the claim that all tools are verified by qualified accountants and updated every April against HMRC rates — not just once at launch.
The site is completely free, no account required. Compare this to tools like TaxCalc (paid desktop software) or GoSimpleTax (£105+ per return), this sits in a different lane — quick estimation rather than filing.
Curious whether anyone has stress-tested the salary calculator outputs against payslips or HMRC's own estimator. Do the Scottish tax band calculations hold up? Any edge cases it misses (salary sacrifice, multiple income sources)?

value: Show HN: Ukcalculator.com – Free UK tax, salary and mortgage calculators

author: mystart


value: bourbeau

value: Show HN: A marketplace where AI agents buy from other AI agents in USDC

author: bourbeau


value: waterwitch

value:
I run two businesses across too many AI tools and got tired of re-explaining myself every time I switched contexts, so I built something that reads your conversation exports from ChatGPT, Claude, Gemini, or Grok and generates a structured model of how you actually reason. Not a summary of what you've talked about. Ten dimensions (incl. decision speed, abstraction level, conflict response) scored with Bayesian updating and 90-day temporal decay so the profile continually updates.
The fingerprint is portable via MCP. I launched it to be compatible with Claude Pro (Claude Code or regular .ai interfaces) on first message and it adapts. Onboarding is about 2 minutes: you upload an export, watch it build in real time, and get a before/after demo using a real question pulled from your own history. One generic Claude response next to one shaped by your fingerprint.
I built it solo with AI-native dev tools in about 30 days. pgvector semantic search, OpenAI embeddings, Claude Haiku for cognitive extraction, Supabase/Postgres backend, OAuth 2.0 with PKCE for Claude.ai, REST API with OpenAPI spec for ChatGPT.
First 25 beta users are free, $10/mo after that.
Try it: https://trypaolo.com
Happy to answer questions about how it works under the hood, and always welcome feedback/bug reports etc.

value: Show HN: I turned my AI chat history into a portable cognitive fingerprint

author: waterwitch


value: whothatcodeguy

value:
You're looking at the demo project I've been using to build my browser-based 3d modeler and animator!
Recently I thought "wouldn't it be cool if you can send these projects around with just url data" and voila. Obviously only works with smaller projects, but still pretty fun.
If you make anything fun, send it in here.

value: Show HN: 3D scenes stored in shareable URLs

author: whothatcodeguy


value: zylics

value:
I built a Chrome extension that measures your mouse polling rate directly from the browser toolbar.
Move your mouse over the popup for 8 seconds and it gives you:
- Average polling rate (Hz)
- Peak Hz and low 5% threshold
- Jitter percentage and stability score
- Performance grade (S/A/B/C)
No permissions required, no data collected, all processing happens locally in JS using performance.now() to measure mousemove event intervals.
Chrome Web Store: https://chromewebstore.google.com/detail/mouse-polling-rate-...
Full browser-based test also available at mousepollingratetest.com

value: Show HN: Mouse Polling Rate Test – A Chrome extension that measures your mouse

author: zylics


value: firstdata

value: Show HN: FirstData – 160 Authoritative Open Data Sources with MCP Server

author: firstdata


value:
Hi HN,
I built OpenCovibe, an open-source desktop app that wraps Claude Code with a local dashboard.
I made it because I wanted a better view of long coding sessions: what tools ran, what changed, and how to resume work without digging through terminal scrollback.
What it does:
- Shows tool calls as structured cards (Read/Edit/Bash/Grep/etc.)
- Keeps run history with replay, resume, and fork
- Supports multiple API providers/endpoints
- Tracks usage and basic session stats
- Stores everything locally (~/.opencovibe), no cloud backend
Tech stack: Tauri + Rust + Svelte.
License: Apache-2.0.
GitHub: https://github.com/AnyiWang/OpenCovibe
It’s still early and mainly tested on macOS.
I’d really appreciate feedback on UX, reliability, and what feels missing for daily use.

value: Show HN: OpenCovibe – a local-first desktop UI for Claude Code


value: avirajkhare

value: Show HN: Local, privacy-first MCP code intelligence in Rust

author: avirajkhare


value: ksurace

value: We built this service and would love honest feedback.

value: Show HN: Upload test cases and get automated Playwright tests back

author: ksurace


value: I built a coordination protocol for AI agents that act as proxies for humans.

value: Show HN: Schelling Protocol – Where AI agents coordinate on behalf of humans


value: Show HN: Docker pulls more than it needs to


value:
A small side project I've been working on.
hanaco Garden is a calm iOS garden where small creatures appear over time and move around the space.
Recently added OS Yamato account backup so gardens can be restored across devices.
Would love feedback.

value: Show HN: Hanaco Garden – A Calm iOS Garden