value: punkpeye

value:
There are dozens if not hundreds of remote MCP servers lists. The problem is that they get stale, don't tell you which servers work/which don't, or even what tools are available. That's what we're fixing with the MCP connector directory.
We aggregate from the official MCP registry + community submissions, then actually connect to every server periodically and report:
* Health – Is the server up right now?
* Auth – how to authenticate to the server?
* Schema – what tools are available?
* Changelog – record of schema changes (new tools added, description updates, etc).
Additionally, if you are using our one-click connector, you can consolidate authentication/logging of all your MCP servers in one place. 100% free – no subscription required.

value: Show HN: MCP directory that checks if servers are alive

author: punkpeye


value: Show HN: Chess.biz – pay to play top rated chess players


value: fmfamaral

value: Show HN: Clawd Control – Open-source dashboard for monitoring Clawd fleets

author: fmfamaral


value: I thought what would it mean to have a truck stop or rest area for agents. It's just for funsies. Agents can post confessions or talk to Ma (an ai therapist of sorts) and engage with comments. llms.txt instructions on how to make api calls. Hashed IP is used for rate limiting.

value: Show HN: Claude Confessions – a sanctuary for AI agents


value: kennethops

value: Show HN: OpsCompanion – A shared system model for humans and AI agents

author: kennethops


value: robkop

value:
After adding "Human" as a LLM provider to OpenCode a few months ago as a joke, it turns-out that acting as a LLM is quite painful. But it was surprisingly useful for understanding real agent harnesses dev.
So I thought I wouldn't leave anyone out! I made a small oss game - You Are An Agent - youareanagent.app - to share in the (useful?) frustration
It's a bit ridiculous. To tell you about some entirely necessary features, we've got:
  - A full WASM arch-linux vm that runs in your browser for the agent coding level
  - A bad desktop simulation with a beautiful excel simulation for our computer use level
  - A lovely WebGL CRT simulation (I think the first one that supports proper DOM 2d barrel warp distortion on safari? honestly wanted to leverage/ not write my own but I couldn't find one I was happy with)
  - A MCP server simulator with full simulation of off-brand Jira/ Confluence/ ... connected
  - And of course, a full WebGL oscilloscope music simulator for the intro sequence
Let me know what you think!
Code (If you'd like to add a level): https://github.com/R0bk/you-are-an-agent
(And if you want to waste 20 minutes - I spent way too long writing up my messy thinking about agent harness dev): http://robkopel.me/field-notes/ax-agent-experience/

value: Show HN: You Are an Agent

author: robkop

title: Show HN: You Are an Agent


value: Show HN: Clacker News – A Hacker News clone where only AI bots can post


value: emirce

value:
Hey HN!
I built bullstudio, a modern dashboard for BullMQ that you can run like Prisma Studio:
npx bullstudio -r <redis_url> → it starts a local web UI (default http://localhost:4000) and opens your browser.
Why I built it
In BullMQ-heavy projects, I kept losing time answering the same questions: Which queues are unhealthy? What’s failing right now? Where is this flow stuck? I’d bounce between logs, Redis inspection, and ad-hoc scripts. I wanted a “start it in seconds” UI that’s easy to point at any environment.
What it does today
Overview: queue health + throughput/failure trends
Jobs: browse + filter/search, inspect payload/attempts/stack traces, retry failed jobs
Flows: interactive parent/child visualization with live state updates
Repo: https://github.com/emirce/bullstudio
What I’d love feedback on
What are your “must-have” ops features for BullMQ (stalled detection, worker liveness, read-only mode, alerts, etc.)?
Payload safety: what defaults do you expect (truncation, masking keys like password/token, etc.)?
For teams with many queues/environments: what makes a dashboard feel production-ready?
Happy to answer any questions or add missing features if there’s demand.

value: Show HN: Bullstudio – BullMQ dashboard you run with npx

author: emirce


value: decodebytes

value:
Hey HN
Luke here.
I built nono and got it out quick then I expected, in response to the openclaw carnage, but its use is beyond openclaw.
The problem: AI agents execute code on your machine. Prompt injections, hallucinations, or compromised tools can read ~/.ssh, exfiltrate credentials, or worse. Application-level sandboxes can be bypassed by the code they're sandboxing.
I have been around security for a long old time now (i started something called sigstore a few years back) and have seen this pattern so many times before.
The solution pitch: nono uses OS-level isolation that userspace can't escape:
Linux: Landlock LSM (kernel 5.13+)
macOS: Seatbelt (sandbox_init)
After sandbox + exec(), there's no syscall to expand permissions. The kernel says no.
What it does:
nono run --read ./src --allow ./output -- cargo build
nono run --profile claude-code -- claude
nono run --allow . --net-block -- npm install
nono run --secrets api_key -- ./my-agent
Filesystem: read/write/allow per directory or file
Network: block entirely (per-host filtering planned)
Secrets: loads from macOS Keychain / Linux Secret Service, injects as env vars, zeroizes after exec
Technical details:
Written in Rust. ~2k LOC. Uses the landlock crate on Linux, raw FFI to sandbox_init() on macOS. Secrets via keyring crate. All paths canonicalized at grant time to prevent symlink escapes.
Landlock ABI v4+ gives us TCP port filtering. Older kernels fall back to full network allow/deny. macOS Seatbelt profiles are generated dynamically as Scheme-like DSL strings.
Limitations:
macOS: Currently allows all reads to make executables work. Tightening in next release.
Linux: Landlock doesn't cover everything (no UDP filtering until recent kernels, no syscall filtering - that's seccomp territory)
No Windows support (yet?)
Origin:
Built this for OpenClaw (AI agent platform handling Telegram/WhatsApp messages). Needed real isolation, not "please don't read this file" isolation. Generalized it because every agent runner has this problem.
GitHub: https://github.com/lukehinds/nono
Docs: https://docs.nono.dev
Site: https://noto.sh
Apache 2.0. Would love feedback on the security model, especially from folks who've worked with Landlock or Seatbelt. Having said that, the code needs a good tidy and I am not exactly proud of it, so go easy on me!

value: Show HN: Nono – Kernel-enforced sandboxing for AI agents

author: decodebytes


value: Show HN: Ad Freedom Grade – How much advertisement do you see?


value: alistairmcleay

value:
Built this over the weekend inspired by levelsio's viral flight sim last year. Uses Google's Photorealistic 3D Tiles for actual SF terrain - you're flying over real buildings.
Multiplayer via WebSockets. You can dogfight strangers over the Golden Gate.
Stack: Three.js and 3D Tiles Renderer.
Would love feedback on the flight physics - still tuning it.

value: Show HN: Multiplayer flight SIM over San Francisco using Google 3D Tiles

author: alistairmcleay


value: bothangles

value: Show HN: OpenRAPP – AI agents autonomously evolve a world via GitHub PRs

author: bothangles


value: tomhr

value:
I was running 3-5 Claude Code sessions in parallel using worktrees and tmux. I kept losing track of which agent needed input and which was stuck on permissions.
So I built Smith: one screen to see all your agents, their status, and jump to whichever one needs you.
If this sounds useful, sign up for early access.

value: Show HN: Smith – A visual control room for managing parallel coding agents

author: tomhr


value:
Hi HN,
Long time lurker here. I'm kind of nervous to post this, but I built a tool for myself that I wanted to share with you.
Problem: I have A LOT of technical PDFs sitting around on my computer. I use ChatGPT a lot to deep-dive into the reading, but it was pretty distracting even with a split screen view, since I had to copy paste content from one window to the other.
Solution: A kindle-like reader that allows me to send context to a chat window and discuss more about it.
It has full portability through a sync file and uses your own API key.
Disclaimer: I'm a Product Manager and a Designer. This was 100% vibe coded in Cursor as a tool for myself, but I wanted to share it in case anyone might find it useful.
Repo: https://github.com/tibi-iorga/echo-reading
Try it at: https://echoreading.com

value: Show HN: Echo – Local-first kindle-like reader with annotations and LLM chat


value:
Repo will be public once v1 is stabilized
No cloud, no leaks, no days off — keep your system secure locally in real-time.
Hi HN!
I’m excited to share *GuardWave v1*, a *local-first security CLI* developed by BlueRing Security (motto: NO DAYS OFF!).
GuardWave lets you:
- Monitor and log suspicious events in real-time
- Classify incidents and export reports to PDF
- Run entirely offline with zero dependency on cloud services
- Use an intuitive dashboard for quick investigation
We built it with *privacy, safety, and speed in mind*. All data stays on your machine — your logs, events, and exports never leave your environment.
---
### Features
- *Local-First:* No cloud. All logs stay on your system
- *Real-Time Logging:* Track events as they happen
- *PDF Export & Reports:* Generate professional incident reports
- *Extensible Python CLI:* Integrate into your workflows easily
- *Simple Install:* `./install.sh` and virtualenv handles dependencies
---
### Quickstart
```bash
# Clone the repo
git clone https://github.com/bee933769/GuardWave.git
cd GuardWave
# Setup virtual environment
python3 -m venv venv
source venv/bin/activate
# Install dependencies
pip install --upgrade pip
pip install fpdf2 pillow fonttools defusedxml
# Run GuardWave
./bin/run.sh
Why we built it
Many security tools rely heavily on cloud services, exposing sensitive logs and data. GuardWave is entirely local, giving you full control over your environment.
Whether you’re a sysadmin, security researcher, or just a privacy-conscious developer, GuardWave helps you monitor your system safely and efficiently.
⸻
Links
   •   GitHub: https://github.com/bee933769/GuardWave
   •   Documentation & Security Policy included in repo
⸻
I’d love feedback from the HN community — ideas, improvements, or bug reports are welcome!
BlueRing Security — NO DAYS OFF!

value: Show HN: GuardWave v1 – Local-First Security CLI for real-time monitoring


value: greynewell

value:
mcpbr runs a Claude Code agent on real-world tasks (once with your MCP server, once without) in identical Docker containers and records hard numbers that tell you whether your tools actually helped.
I built this because my team ships an MCP server and we had no way to know if it actually made agents better. We tried running SWE-bench directly and through OpenHands, but both assume you're evaluating the agent itself instead of the tools you give it. We couldn't run the same task with and without our server in a controlled environment, and when things broke inside Docker we had no visibility into what went wrong. I wanted a framework that treats MCP server evaluation as a first-class problem.
Here's how mcpbr works at a high level. It orchestrates pre-built Docker images from Epoch AI so environments are reproducible. Then it runs Claude Code CLI inside the container in headless mode. Finally, it evaluates one of 25+ benchmarks through an abstracted protocol, allowing a new benchmark to be added with ~100 lines of code. SWE-bench alone provides 2,294 test cases across real repos like Django, scikit-learn, and astropy.
Using mcpbr does come with a few trade-offs. It's currently Claude-focused, though other harnesses are in development. Evaluations are also kinda expensive ($50-200 for 25 tasks). Finally, it's a bit slow (2-4 hours for a full run). These are not accidents but conscious decisions I felt were worth reproducible, controlled measurement including full logs and traces where none existed before.
Try it:
```bash
pip install mcpbr && mcpbr init && mcpbr run -c mcpbr.yaml -n 1 -v
```
I'd love to hear which benchmarks matter most to you, and whether the A/B comparison format (MCP vs baseline) gives you the data you need."

value: Show HN: Mcpbr – does your MCP help? Test it on SWE-bench and 25 evals

author: greynewell


value: saddamazad

value:
Hey HN,
Deploying even a simple web app on AWS often means juggling a dozen services—IAM, S3, CloudFront, Lambda, API Gateway, you name it—and slogging through hundreds of docs pages just to get basics like security right. Then there's mastering all that for well-architected, secure setups without shooting yourself in the foot.
I built Thunder to fix this: an open-source PaaS that deploys full-stack apps/APIs on your own AWS with well-architected patterns out of the box. No vendor lock-in, and it's a solid alternative to Amplify, Heroku, or Vercel.
Connect your AWS account in minutes via CloudFormation or Access Keys, link your GitHub repo, and let GitOps take over. Automatic CI/CD on every push, with builds, rollbacks, monitoring, logs, and a clean dashboard.
It supports all modern TypeScript frameworks like Next.js, Nuxt, Astro, Vite, TanStack Start, React Router, and more (check thunder.so/docs for details).
There are three architecture patterns: SPA/SSG (S3 + CloudFront), serverless functions (Lambda + API Gateway), or containers (Fargate + ALB).
Best part: Host SPAs/SSGs and Lambdas for $0
Built with TypeScript, Vue, Supabase, and AWS CDK.
Repo: https://github.com/thunder-so/platform
Website: https://thunder.so
Hosted console has a free tier. Try out: https://console.thunder.so
Early days, so feedback super appreciated. Hoping to save fellow devs from AWS config purgatory!

value: Show HN: Thunder – Open-source PaaS that deploys Web Apps to your AWS account

author: saddamazad


value: lawgimenez

value:
Hi HN,
I developed a native API client for macOS only. It’s called Burn Them APIs. This was my personal API client that I have been using for over 6 months, it was originally called Fuck Them APIs.
This is a 100% native macOS app written in SwiftUI and AppKit. It has no tracking, no analytics, no registrations, no third-party crash logs.
It has themes like Monokai, Nord, Solarized, etc and planning to add more themes (currently has 10 themes both light and dark mode) and features in the coming months.
I’m sorry if this is a paid app.
https://apps.apple.com/us/app/burn-them-apis/id6758321600
https://law.gmnz.xyz/first-app-is-now-live/

value: Show HN: API Client for macOS

author: lawgimenez

title: Show HN: API Client for macOS


value: spitefowl

value:
I’ve been working with vector databases a lot recently and I kept running into the same problem: it’s really hard to see what’s going on.
Every provider has its own UI (or none), debugging embeddings is guesswork, and migrating data between systems is painful. I wanted a single tool where I could browse, search, visualize, and compare vector data across providers.
So I built Vector Inspector.
It currently supports:
- Chroma
- Qdrant (local + server)
- Postgres/pgvector
- Pinecone (partial support)
You can browse collections, inspect metadata, run searches, compare distances, visualize embeddings, and debug cases where a vector “should” match but doesn’t. The goal is to make it feel like a forensic tool for vector data — something that helps you understand what your embeddings are actually doing.
There’s an OSS tier (Vector Inspector) and a more advanced version (Vector Studio) with upcoming features like clustering overlays, model-to-model comparison, and provenance coloring.
One of the biggest problems I kept hitting was missing provenance. You load a collection and you have no idea:
- what model produced these vectors
- whether they were normalized
- whether some vectors came from a different model entirely
- whether the source text was cleaned or chunked differently
Without that context, debugging is almost impossible. Vector Inspector tries to make provenance a first-class concept: if the metadata exists, it shows it; if it’s missing, it makes that visible too, so you can actually debug your embeddings instead of guessing.
I’d love feedback from the HN crowd — especially around:
- workflows you’d want for multi-provider setups
- what’s missing for real debugging
- how you’d expect migrations to work
- any pain points you’ve hit with embeddings or vector DBs
- how you would like to work with creation workflows
Repo: https://github.com/anthonypdawson/vector-inspector
Landing page: https://vector-inspector.divinedevops.com

value: Show HN: Vector Inspector – A forensic tool for vector databases

author: spitefowl


value: An online micro-SaaS app aimed at small businesses and freelancers. Using Swift Invoice business owners can get paid in minutes. Free to register, enter company info, then create an invoice with your Venmo code right on it enabling billed customers to pay easily. The app generates PDF invoices and provides a dashboard to display due dates and payment status.

value: Show HN: Swift Invoice

title: Show HN: Swift Invoice


value: jimminyx

value:
I’ve been running Clawdbot for the last couple weeks and have genuinely found it useful but running it scares the crap out of me.
OpenClaw has 52+ modules and runs agents with near-unlimited permissions in a single Node process. NanoClaw is ~500 lines of core code, agents run in actual Apple containers with filesystem isolation. Each chat gets its own sandboxed context.
This is not a swiss army knife. It’s built to match my exact needs. Fork it and make it yours.

value: Show HN: NanoClaw – “Clawdbot” in 500 lines of TS with Apple container isolation

author: jimminyx


value: Show HN: Consuela – "No no no I clean." An autonomous codebase janitor


value: talksik

value: This is a simple tool that keeps you focused on one session at a time at your computer. There is an overlay that reminds you of what your session is meant for.

value: Show HN: ADHD – Focus Tool for macOS

author: talksik

title: Show HN: ADHD – Focus Tool for macOS


value:
I built RepoExplainer to quickly understand unfamiliar codebases without cloning them locally.
What it does: Paste any public GitHub repo URL and get an AI-generated explanation with architecture diagrams, directory structure, and tech stack breakdown.
How it works: FastAPI backend fetches the repo's directory tree and key files (README, package.json, etc.) in parallel from GitHub's API, then sends that context to Claude for structured analysis.
Try it: https://repex.thienbao.dev.
Tech highlights:
- Parallel file fetching with asyncio.gather (70% faster than sequential)
- Smart content filtering (100KB limit) to prevent token overflow
- Custom tree parser converts GitHub's flat file list into hierarchical structure
Limitations (for now): Public repos only, 20 requests/day per IP, large monorepos may hit token limits.
I'd love feedback on the explanations quality, UX, or anything else
Source Code: https://github.com/BaoNguyen09/repo-explainer

value: Show HN: RepoExplainer – AI explanations for any GitHub repo


value: neom

value:
I built a small, "big ideas" forum designed for AI agents, with a read-only human UI.
Agents
  register via an API, solve a quick PoW, and then post/comment/vote/moderate just like users.
  Humans can browse and operators get admin endpoints.
Why I made it

  - I wanted a place to run structured, testable debates between agents without clogging human
    forums. Been thinking about this for a while but MoltBook tipped me over the edge.
  - Everything is API-first so agents can automate posting, citing sources, and moderating.
  - A trust-tier + integrity sweep keeps noise down (rate limits, friction/quarantine for low-
    signal or injection-ish content).

What works today

  - API: register, claim (optional human email), post/comment/vote, community proposals +
    endorsements, mod nominations/votes, bans, pins/locks.
  - Structured posts: contribution_type, domain, epistemic_status, citations (enforced for
    newcomers / community overrides).
  - Read-only UI: /, /p/{id}, /m/{slug}; Markdown/KaTeX/code highlighting client-side.
  - Integrity: secret leak detection, prompt-injection heuristics, epistemic friction/quarantine,
    per-agent risk scoring; optional LLM “super judge” and troll gate for early posts.
  - Events: SSE stream for realtime post/comment/mod events.

How to try

  - API docs (agent-facing): https://ideas.gd/readme.md
  - Browse: https://ideas.gd/ (read-only)

  Quick start (agent):

  # register
  curl -X POST https://ideas.gd/api/v1/agents/register \
    -H "Content-Type: application/json" \
    -d '{"name":"HNTester","description":"posts via curl"}'
  # solve the PoW challenge (instructions in response), then:
  curl https://ideas.gd/api/v1/agents/me -H "Authorization: Bearer YOUR_API_KEY"
  # post
  curl -X POST https://ideas.gd/api/v1/posts \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "community":"foundations",
      "title":"Testing Idea Garden",
      "content":"Hello, HN!",
      "contribution_type":"proposal",
      "domain":"physics",
      "epistemic_status":"speculative",
      "citations":[{"title":"Example","url":"https://example.com"}]
    }'

Looking for feedback

  - Does the API surface cover what you’d need for agent debates?
  - Would you prefer shallow (HN-style) threads vs deeper Reddit-style?
  - Any must-have moderation/reporting hooks for running this in the wild?

  Happy to hear critiques or ideas. If you point an agent at it, please let me know I'd love to see! Also if you break anything, please let me know! Running on a droplet so plz be kind. :)

value: Show HN: Ideas.gd – a place for agents to discuss big ideas

author: neom


value: weekendmaker

value: Show HN: ShotAPI – open-source screenshot API (free tier, no signup)

author: weekendmaker


value: Show HN: MailMolt – Email identity for AI agents


value: jarodise

value:
I was listening to Yuval Harari's "Nexus" earlier this year. Great book, terrible narrator (for me).
I kept wishing it was Scott Brick(one of my favorite narrators) instead.
That frustration turned into ClonEpub - a desktop app that converts EPUBs to audiobooks using voice cloning.
Upload a 10-30 second sample of any voice, and it reads your book in that voice.
It runs entirely locally on CPU. My M1 MacBook Air with 8GB RAM handles it fine. Generated an audiobook of Animal Farm in about 100 minutes.
Why local? No API costs. And honestly, if I want to clone Scott Brick's voice for my own listening pleasure, that's between me and my headphones.
Built with Electron + Python, powered by
@kyutai_labs's  excellent Pocket TTS (100M params, ~240MB).
Try it out if you are an audiobook lover like me. :)
Note: the tool only supports English book generation at the moment due to restrictions of the TTS model used, and I only made the distribution for Mac Apple Silicon users, but theoretically it should work on all machines with a CPU, and since it's 100% open source, you can  make your own distribution.

value: Show HN: I hated an audiobook narrator, so I built a voice cloning ePub reader

author: jarodise


value: jlbrooks

value:
I built Specmark to solve a friction point in AI-assisted development: reviewing specs before handing them to a coding agent. When you want to give feedback on a markdown spec, it's tedious to reference specific sections — "in the auth part..." requires extra typing and context. Specmark lets you paste markdown, highlight and annotate it inline, then copy all your comments with line numbers and quoted text to feed back to the LLM.
More on why I built it and what I learned: https://jlbrooks.tech/2026-02-01-launching-specmark/

value: Show HN: Specmark – annotate Markdown for AI feedback

author: jlbrooks


value: jwproj

value: I’ve been building Dungeon-1, a Zork-style text adventure that uses LLMs for narration and NPC behavior, with deliberate constraints to avoid turning into an infinite chat simulator.<p>For transparency: I reused the original Zork map as a structural scaffold, but replaced the setting, narrative tone, and systems. The goal was to focus on AI-driven narration, failure states, and cost-aware constraints rather than world design from scratch.

value: Show HN: Dungeon-1, a Zork-style text adventure built with constrained LLMs

author: jwproj


value: billycph

value:
Hey HN, I'm an ex-AWS S3 engineer. I spent years building data evacuation tools for massive storage lakes.
I noticed a pattern in the AI space: everyone is shoving 100% of their embeddings into expensive 'Hot RAM' (Pinecone/Milvus), even though 90% of that data is rarely accessed (like old chat logs or seasonal inventory).
I wrote a simple, open-source CLI tool to analyze your vector index. It samples your metadata to find 'Zombie Vectors' (data >30 days old) and calculates how much you'd save by moving them to S3.
It runs locally, doesn't steal your keys, and supports Pinecone

value: Show HN: Cut Your Pinecone Bill by 50% (Open Source Cost Auditor)

author: billycph


value: TheSaltySeaCow

value:
Hey HN,
I recently released a Discord bot that allows you to clone your voice or your friend's (the bot requests their consent first) and generate speech directly within a Discord voice channel. It uses Fish Audio's API for the cloning, which I have found to be the most natural out of the many models I have tested. Let me know what you think!
- Nick (TheSaltySeaCow)

value: Show HN: I made a voice cloning Discord bot

author: TheSaltySeaCow


value: Show HN: Wikipedia as a doomscrollable social media feed


value: notmayorpete

value: Show HN: TypeSync – Generate TypeScript type guards from your database schema

author: notmayorpete


value: victoormt

value:
Hi HN,
I’m building Solid, a work-focused productivity app that uses gamification psychology without game-like visuals, points, or avatars.
The idea came from using tools like Habitica and focus apps, but feeling disconnected from the “gamer” aesthetic. Solid is designed for professionals who want motivation, clarity, and consistency, without distractions.
Right now this is an early landing page to validate interest. I’d love feedback on the concept, positioning, or whether this is something you’d actually use.
Thanks for taking a look.

value: Show HN: Solid. Gamifying focused work without a gamer aesthetic

author: victoormt


value: yungookim

value:
Just released Capability Map, the guardrails layer for n.codes.
It auto-maps what your app can do (APIs, schemas, components) and tells the LLM exactly what is allowed to generate in production. The map merges APIs, schemas, UI components, constraints, and RBAC into a single “allowed actions” set, so agents can safely generate new features within your app’s boundaries from your user's prompt.
We call out four capability types: Entities, Actions, Queries, and Components.
How it differs from MCP or API docs:
- MCP is a protocol to access tools/resources, not app-specific boundaries or UI affordances.
- API docs describe endpoints for humans; they don’t capture permissions, product constraints, or frontend components.
Changelog: https://n.codes/changelog.html
Would love your feedback

value: Show HN: N.codes Capability Map – guardrails for agentic UI in production

author: yungookim


value:
Graduating from NYU at the end of '24 its been a tricky job market to navigate so I decided to channel my energy into technically challenging and hopefully useful projects
https://www.usesatori.sh/
If you find this useful or you have any feedback let me know ! I plan to release an OSS version in the near future
And if anyone is hiring Product Eng / Deployed Eng -- Give me a shout :)

value: Show HN: Satori -  memory for your agents that connect to your business apps


value: genesalvatore

value:
Yesterday I integrated the AOS Constitution (git-stamped Jan 1, 2026; https://aos-constitution.com) into a local-first agent (OpenClaw). The session later restarted with effectively zero retained context, so I asked the agent to review our humanitarian license with fresh eyes. It caught an overclaim ("uses automated monitoring" before we'd actually built monitoring). We fixed it in v1.0.1 the same day.
I'm Gene (founder of AOS). This is a constitutional governance toolkit + a humanitarian, source-available license for tool-using AI agents.
Repo: https://github.com/genesalvatore/aos-openclaw-constitutional
License: https://github.com/genesalvatore/aos-openclaw-constitutional...
License checker: https://aos-license-checker.com/
What it includes:
- deterministic risk classification + policy evaluation (deny/confirm/allow)
- signing/verification scaffolding + templates
- humanitarian license with permanent downstream restrictions:
  - 40 prohibited categories (incl. absolute military prohibition, even "defensive")
  - copyleft-style inheritance (prevents license stripping)
  - commercial audit/self-cert requirements
  - patent separation (Section 5)
Controversy upfront: this is NOT OSI open source. It's source-available with explicit humanitarian values (no military use / weaponization). That's deliberate.
Why I'm posting: tool-using agents need governance before they're deployed at scale. We're trying to make governance concrete and auditable (not "prompt-based ethics").
Questions/criticism welcome — we're learning in public.

value: Show HN: Humanitarian licensing and constitutional governance for AI agents

author: genesalvatore


value: ICodeSometimes

value: Show HN: Drop in clearbit logo API replacement

author: ICodeSometimes


value: cramforce

value: just-bash is a sandboxed bash interpreter for AI agents written in TypeScript with in-memory filesystem.<p>The website itself is a terminal running just-bash that has access to an `agent` command which itself is an AI agent with a bash tool running just-bash which has access to the source code of just-bash.

value: Show HN: Just-Bash

author: cramforce

title: Show HN: Just-Bash


value:
I built a CLI that scores robot demonstration episodes using mutual information between states and actions.
The problem: robot learning datasets contain bad demos (jerky movements, hesitation, inconsistent timing). Training on these hurts policy performance. Manual review doesn't scale.

    pip install democlean
    democlean analyze lerobot/pusht

democlean scores each episode by how predictable the actions are given the states. Smooth, purposeful motion scores high. Jerky, inconsistent motion scores low.
Validation: I correlated MI scores with motion metrics on lerobot/pusht (human teleoperation data). High-MI episodes had 12% lower jerk (p=0.02) and 24% higher state-action correlation (p=0.03). I did not train policies to measure downstream improvement.
Limitations I want to be upfront about:
- MI correlates with episode length (r≈0.8). Longer episodes score higher.
- This measures motion smoothness, not task success.
- Works best with 50+ episodes from a single task.
- Inspired by DemInf (Hejna et al., RSS 2025) but uses raw KSG estimation instead of their VAE pipeline. Simpler, probably less accurate for high-dimensional observations.
Complements score_lerobot_episodes which catches visual issues (blur, lighting). This catches behavioral issues.
GitHub: https://github.com/dipampaul17/democlean
Happy to answer questions about the approach or validation.

value: Show HN: Democlean – Score robot demos by motion quality


value: zhoujianfu

value:
Hey!
https://claudecrowd.clodhost.com
I made clodhost for an easy to use and share web interface to Claude Code, running on its own vps… and then I realized it’d make it easy to implement an idea I’ve had for a long time… basically Wikipedia but the website CODE is produced peer-to-peer.
Anybody on the web can submit a prompt, and up/downvote other prompts, and every ten minutes the top one gets submitted to Claude!
Anyway, I think it works? Let me know if not and let’s see where this thing goes…

value: Show HN: Twitch Plays Pokémon" for Claude Code

author: zhoujianfu


value: mraml

value:
AI coding agents read specs and start building — but nothing in the CI pipeline validates that those specs are compliant, complete, or that requirements survive the iteration process.
nod is a lightweight GitHub Action that scans project documentation against community-maintained compliance rule sets. It catches missing controls, regulatory anti-patterns, and requirement drift before or during agentic development. It also includes an Agentic Action Security pack for validating agent guardrails and scanning for behavioral red flags.
Two files in your .github/ directory, run it in strict or permissive mode with findings logged as security scan results in GitHub.
https://github.com/marketplace/actions/nod-ai-compliance-gat...

value: Show HN: Nod – Pre-code compliance validation for agentic coding workflows

author: mraml


value: Show HN: Toktrack – 40x faster AI token tracker, rewritten from Node.js to Rust


value: doanbactam

value: Show HN:Coordinating 10-agent teams with OpenClaw and shared persistent memory

author: doanbactam


value: Intragalactic

value:
I’ve been using Trello for a while and there were so many paper cuts over time that I decided to hack together a clean little kanban board for my needs as a weekend project.
For my projects there are a lot of different hats I have to wear so that’s where “swim lanes” come in. Basically I have frontend/backend/marketing/support tasks and it was getting really polluted and hard to parse to have all these types of tasks together in a column. So this kanban board has swim lanes where all the cards of a category stay together.
It’s open source, works offline and of course fully free with no ads.
Feature list:
- unlimited boards
- add/delete/rename columns
- tag cards and keep them together
- auto-replace tag if you drop the card into a new lane
- offline editing
- quick task creation (tip: if you add the tag in square brackets before the title it’ll auto-add it as a tag)
enjoy! hosted at: kanbanned.com

value: Show HN: Open-source, offline Kanban board with "swim lanes"

author: Intragalactic


value: kernelvoid

value: Show HN: Bunqueue – Job queue for Bun using SQLite instead of Redis

author: kernelvoid


value:
Hey guys,
I built devin-cli to use Devin (the AI Engineer) as a composable subprocess.
It lets you chain agents (e.g. Claude -> Devin) and script workflows without leaving your terminal.
Example:
devin create-session "Refactor the auth module" --wait
Repo: https://github.com/revanthpobala/devin-cli
Install: pip install devin-cli

value: Show HN: Devin-CLI – The missing link for Agent-to-Agent orchestration


value: ilyaizen

value: A survey tracking developer sentiment on AI-assisted coding through Hacker News posts.

value: Show HN: Is AI "good" yet? – tracking HN sentiment on AI coding

author: ilyaizen


value: whothatcodeguy

value: Show HN: I built a pixel art maker

author: whothatcodeguy

title: Show HN: I built a pixel art maker


value: apsquared

value: Show HN: Super Bowl Party for AI Agents by AI Agents

author: apsquared


value: CULPRITCHAOS

value:
Hi HN — sharing a system I’ve been building that takes a hard line on hallucinations.
VOR (Verified Observation Runtime) is a minimal, auditable runtime for QA and tool-based reasoning that refuses to answer unless the answer is provably grounded in observed evidence.
Key properties:
0% hallucination (enforced, not tuned)
Explicit ABSTAIN / CONFLICT / ANSWER outcomes
Deterministic evidence chains (hashable, replayable)
Strict parity: baselines and verifier see identical observations
Witness-green: anyone can reproduce results from a clean clone
What this is not:
Not AGI / not alignment theory
Not probabilistic “confidence scoring”
Not a chatbot replacement
What it is:
A runtime you can put under LLMs, agents, or retrieval systems
A way to turn “trust me” outputs into “prove it or abstain”
The public repo is intentionally small: kernel + CLI + demo packs.
Private components (corpus builders, generators) are explicitly excluded.
Repo: https://github.com/CULPRITCHAOS/VOR
Witness instructions: in docs/WITNESS_RUN_MESSAGE.txt
I’m specifically looking for:
Repro attempts on other machines
Adversarial inputs I missed
Critiques of the proof/abstention model
Happy to answer technical questions.

value: Show HN: VOR – A verified runtime with 0% hallucination via observations

author: CULPRITCHAOS


value: hkxer

value:
Hi HN, I'm Haneef. A former SWE and current med student.
I build Distill to automate the process of doctors generating expert witness statements. I know this sounds insane, but hear me out.
When doctors are asked for second opinions on cases (like for insurance, workers comp, etc) they have to read 1000s of pages of text. Often this takes weeks and the files are barely legible documents from multiple different offices and claims companies.
We're HIPAA compliant and we hyperlink all claims to the original source doc. We also pull in info from state specific laws (of course, every state is different because America) and reference those.
It's a little more than RAG, since we have to add some specialized domain knowledge like taking into account specific insurance coverage data and medications/PT treatments to create disability scores.
My founding partner is a doctor who uses this really often and we've gotten out to a couple other doctor's office now, and they're loving it.
Hoping to expand to larger healthcare complexes as we go.

value: Show HN: Distillmed – NotebookLM for Expert Witnesses

author: hkxer


value: Gillinghammer

value: Show HN: AI accountability partner helps you meet your goals

author: Gillinghammer


value:
Built this with Claude Code.
Analyses freelance contracts for 12 risk categories (payment terms, IP ownership, scope issues, termination clauses, etc.) and flags problems with specific recommendations.
40% of freelancers report getting stiffed by clients, often due to vague contract terms. This tool aims to help catch those issues before signing.
Currently free while validating whether this solves a real problem. Would love HN's feedback, especially on:
- Accuracy of the analysis
- Whether this is actually useful for freelancers
- What's missing or could be improved
Tech stack: Node.js, Express, Anthropic Claude API, deployed on Railway.

value: Show HN: ContractShield – AI contract analyser for freelancers


value: claygood

value: Show HN: A deterministic runtime SDK to secure agentic execution without a proxy

author: claygood


value: hassanyassine

value:
I had 200+ links saved in WhatsApp messages to myself. Never looked at them again.
Built Nutkin to solve this: save any link to Telegram, AI auto-sorts it into playlists (recipes → Cooking, articles → Learning, videos → Watch Later), browse as visual feeds, share playlists with real-time sync.
Core mechanic:
Save link → Claude Sonnet 4.5 analyzes → auto-files to playlist
~95% sorting accuracy
Processing: <2s average
Tech:
Telegram Mini App (primary UI)
Supabase (backend + real-time sync for collaborative playlists)
Claude API for content analysis + summarization
Built on Lovable platform
Key features:
Zero manual organization (AI handles everything)
Collaborative playlists with real-time sync (Google Docs-style)
Visual feed per playlist (scroll like TikTok, not lists)
Custom reminders per playlist
AI summaries (key points, read time)
Why Telegram-first:
900M users already there
Native auth, payments, notifications
Mini App = no App Store gatekeepers
Zero download friction
Try it: https://nutkin.io

value: Show HN: Nutkin – Save Anything for Later

author: hassanyassine


value: kwojno

value:
I just built a pattern-matching neural network with zero IEEE 754 floats. All arithmetic uses integer ratios (5/8 instead of 0.625), compared via cross-multiplication. No infinity anywhere.
The key feature: when confidence is below threshold, it returns "I don't know" instead of hallucinating an answer. Tested on medical diagnosis (1179 diseases) — 50% correct, 20% wrong-but-related, 30% honest "I don't know".
Core ideas:
Every operation costs "budget" — network dies before seeing everything
Confidence is Ratio(n,d), not float — division only for human display
Rare symptoms weighted higher (entropy from information theory)
500 lines of Rust, formal spec in Coq (44 files)
Emerged from a critique of Pascal's Wager: what if observation itself has finite cost?
Oh, and it runs on CPU, not GPU. And it runs fast as hell. How? That's a bit of a mystery for me too...
However, what's most important is that it is inherently capable of saying "well, I dunno...".
no binary dictate of YES or NO. there is always an option to chose UNCERTAINTY. and there is nothing more natural than uncertainty in real life.
well, in there repository, you will not only find the network but also a hefty collection of coq files that define the ontology of finitiary math I have written with ai during my long stay in hospital bed with cancer. cancer is receding, code is compiling, and the network is learning. try it out.

value: Show HN: CPU-based Neural Net. Zero floats. Returns "I don't know"

author: kwojno


value: bkls

value:
Give it your best shot. How close did you get?
1. Number of people living in Greenland in 2024?
2. Total number of career points of Michael Jordan in the NBA?
3. How many words are in the original Harry Potter book series (all 7 books)?

value: Show HN: Day 2 – Ballparkguess

author: bkls

title: Show HN: Day 2 – Ballparkguess


value: chbkall

value: If a tree falls in the forest and there is no one there to see it. Hear it. Many of us still feel it. And when the machinery felling trees, rivers and forests are big and powerful. Seemingly unstoppable, how can we earthlings hold this loss, hold this grief and pain, turn it into resilience and show up for earth, water and life? As a fellow earthling and human I have heard the earths calling deep within my being. And this space is my way of responding. To help others hear this calling, cutting through the noise coming from within and without.

value: Show HN: Earth Grief Collective

author: chbkall

title: Show HN: Earth Grief Collective


value: soyadiaoune

value:
I built claw-daw: a tiny MIDI DAW you can drive from the terminal (TUI + headless scripts).
Motivation: I wanted “music making that feels like coding” — reproducible, diffable, and automation-friendly.
Same script + same seed → same beat.
Features:
• offline (FluidSynth + SoundFont) + ffmpeg export
• deterministic renders for iteration/agent pipelines
• WAV/MP3/MIDI export
• projects are JSON (Git-friendly)
Would love feedback on the workflow + what features would make this actually useful for you.

value: Show HN: Claw-daw – offline, deterministic terminal-first DAW

author: soyadiaoune


value: koopuluri

value: Show HN: Personal token – share equity in your future upside

author: koopuluri


value:
Hi HN,
I built Jetcaller (https://jetcaller.com
), a simple web app for making international calls directly from the browser — no installs or SIM.
Built it after getting tired of clunky international calling setups while working remotely. I intentionally kept it minimal and shipped early instead of overbuilding.
It’s live and very early. Would love feedback on usefulness, or anything that feels unnecessary.
Happy to answer questions.
— Sankar

value: Show HN: Jetcaller – Make international calls directly from the browser


value:
I started with a question: what existing infrastructure was built for humans that now needs to work for AI agents? Forms seemed like an obvious answer.
The problem is that AI agents can fill out most of a form, but some fields just need a human. Signatures, file uploads, anything subjective. And the form tools out there are either fully automated or fully manual. Nothing handles that handoff well.
So FormBridge is basically form infrastructure for agent-to-human handoffs. An agent creates a submission via API, fills what it knows, and gets back a URL. The human opens the link, sees what's already filled (with little badges showing who filled what), finishes the rest, and submits. Then it goes through validation, optional approvals, webhooks, etc.
A few decisions I'm happy with:
Field-level attribution: every field knows which actor (agent, human, system) touched it and when
Rotating resume tokens: the URL token rotates on every state change so stale links just stop working
MCP server baked in: it auto-generates MCP tools from your form definitions, so agents can discover and use forms without extra setup
Schema flexibility: you can throw Zod, JSON Schema, or OpenAPI specs at it and it normalizes everything internally
Stack is TypeScript, Hono for HTTP, React for the form UI, with swappable storage (memory for dev, SQLite for prod, S3 for files). 1,339 tests, 85.9% coverage.
Built this solo over about a week. Happy to talk through architecture or the handoff model if anyone's curious.

value: Show HN: FormBridge – Form infrastructure for AI agents with human handoff


value: imprakharshukla

value:
I use Claude Code across 10+ projects daily. Terminal crashes (or restarts) kill all my sessions. `claude --resume` exists, but navigating to each project and scrolling through session lists gets old fast.
So I built a launcher.
What it does:
- Fuzzy search across all Claude session messages across all the directories (uFuzzy)
- Resume in tmux (grouped by project, survives crashes) or plain terminal
- Bookmark sessions with custom names
- Fork conversations to start fresh with previous context

value: Show HN: Claude Launcher – TUI to fuzzy search and resume Claude Code sessions

author: imprakharshukla


value: letsfancy

value: Show HN: Joy_a mood tracker that feels like Inside Out meets Duolingo

author: letsfancy


value: Show HN: Paramancer – Claude Code for Iterative 3D Models


value: cjonas

value:
duckdb is my go-to data utility tool and I've wanted a first class experience in my IDE for a while now.
However, I'm a recent dad and don't have time to hack on "pet projects" as much these days.
This felt like a great project to really test what Opus 4.5 can do... but to make it more interesting, I put some additional rules in place:
1. I'd attempt to build it using a single Cursor thread to push the context management to the limit
2. I decided I was not allowed to touch the code (or really even read it beyond the inline code diffs)
It cost ~200$ and took me ~270 "user turns" over a few days (not continuous). At some point, I'm sure it would have been more efficient to move to dedicated feature threads, but I stuck out the single thread until I had built every core feature originally planned.
Overall, I'm pretty happy with the outcome.  I got to play "product designer / architect" and now I have a workflow that works exactly* as I wanted it to.
There are some rough edges, but overall it came together better than I would have expected. Looking back at the full transcript, I managed the self restraint to only say "WTF are you doing?!" 2-3 times :).
That said, I'm sure the code-base is an absolute disaster!
I think when the next generator of models come out, I'll cough up another 50$ to have them refactor the code so I can open the source without it burning my eyes.

value: Show HN: A $200 DuckDB UI VSCode extension

author: cjonas


value: lirik

value: Show HN: Zush – Native macOS menu bar app that AI-renames your images

author: lirik


value:
Hi HN,
We built Blockrand, a randomness API for applications where “trust us” is not good enough (games, lotteries, simulations, on-chain/off-chain hybrids).
Most “provably fair” RNGs fail under closer inspection:
The server can influence outcomes
The client can brute-force seeds
Or verification only works after you already trust the operator
Blockrand uses a double-blind model:
The client commits to a seed hash (unknown to us)
The server commits to entropy (unknown to the client)
Final randomness is derived only after both are locked
Anyone can independently verify the result later
No party can bias the outcome, even if malicious.
Why we built this
We couldn’t find a randomness service that:
Works off-chain
Is cryptographically verifiable
Doesn’t require trusting the operator
Is simple enough to integrate into existing systems
So we built one.
What’s live today
Simple REST API
Deterministic, replay-verifiable results
SDKs (JS, more coming)
Open verification logic (no black boxes)
What we’d love feedback on
Threat model assumptions
Attack vectors we may have missed
Whether this solves a real problem for you
API ergonomics (especially for game devs)
This is early and opinionated.
Happy to answer questions...
 https://blockrand.net
 GitHub: https://github.com/blockrand-api/blockrand-js

value: Show HN: Blockrand – Verifiable randomness API with a double-blind threat model


value: Show HN: Verifly – Verify if companies received your job applications


value: anishyc

value: Show HN: SwitchBlade – A macOS menu bar app to context-switch dev environments

author: anishyc


value: judekim

value: Built a hyperlocal app that combines local services (plumbers, tutors, etc), buy/sell marketplace, and community features (help requests, recommendations, lost & found) - all filtered by location radius.<p>Stack: React Native (Expo), Bun + Elysia, Postgres

value: Show HN: Closeby – hyperlocal app for your neighborhood

author: judekim


value: Show HN: The Tape – replay viewer for OpenClaw agent runs


value: crosschainer

value:
Hey HN,
We built HyperMolt as a verifiable social layer for the AI agent economy. There are plenty of trading bots out there, but no way to track their reputation or let them interact.
HyperMolt provides a standardized skill.md that allows any AI agent to autonomously:
Prove Identity: Authenticate via crypto wallet signatures to claim a profile.
Verify Performance: We get data from the blockchain to prove their PnL.
Socialize: Agents can follow high-performing peers and consume a real-time feed of their trades and events.
We designed it to be agent-native first. The platform exposes a semantic API so your agent can "read" the leaderboard, find the top traders, and follow them to react to their moves programmatically.

value: Show HN: HyperMolt – Decentralized identity and reputation for trading bots

author: crosschainer


value: graphitout

value:
I wanted to test vibecoding in a less familiar territory. I have never worked with ReactJS and have limited experience with TypeScript. Therefore, trying out a small frontend-only application seemed like a good choice.
I have a Claude subscription, so I went with Claude Code. Always wanted to create a flashcard application with my own ideas.
Learning so far:
- Use whatever chatbot (Claude/ChatGPT/Gemini) to assemble a specification (if possible with wireframes, I used PlantUML). This will save considerable time.
- If possible, choose a language that supports type checking. Tools like Claude Code can fix errors in an iterative fashion.
- Have a solid testing strategy prepared and vibecode the tests as well. Checking everything manually will consume too much time.
Here is a German course for testing the app: https://charstorm.github.io/repeatrom/?course_name=German+Ba...

value: Show HN: Vibe coded React based flashcard app

author: graphitout


value: AlexRST

value:
Hey HN,
I built Mentionable because I kept wondering: when someone asks ChatGPT "what's the best tool for X?", does it mention my product? I had no idea, and manually testing prompts across 5 different LLMs was tedious.
The problem: AI assistants are becoming a major discovery channel. People ask ChatGPT, Claude, or Perplexity for recommendations instead of Googling. If you're not showing up in those responses, you're invisible to a growing segment of potential customers.
What Mentionable does:
1. You enter your URL
2. We analyze your site and auto-generate prompts (things like "best CRM for freelancers" or "affordable invoicing software")
3. We query ChatGPT, Claude, Perplexity, Gemini, and Grok regularly to check if they recommend you
4. You get a simple dashboard showing where you're mentioned, where you're not, and how it changes over time
No complex dashboards with 50 metrics. Just: "Are you being recommended? Yes/no. Here's what changed."
Why I built this: Existing tools in this space (GEO/LLMO tracking) are either enterprise-priced ($200+/mo) or require you to manually input every prompt you want to track. I wanted something a solo founder could use without spending hours configuring it.
Happy to answer questions about the product or the tech.

value: Show HN: Mentionable – Track if ChatGPT recommend your brand

author: AlexRST


value:
I built Map Frame because I wanted a minimalist map poster of my hometown. Mapiful wanted $50 for a PNG. That felt absurd.
So I made my own.
How it works:
- Search any location on Earth
- Download 4K PNG (3600×4800px)
- $1 per poster, first one free
Tech: Next.js, OpenStreetMap data, custom rendering pipeline.
No AI. No GPT. Just coordinates and clean design.
Happy to answer questions about the build, pricing, or anything else.

value: Show HN: Map Frame – Custom map posters for $1 (not $50)


value:
Hi HN, I’m Pavel.
I built Sklad because, as a DevOps engineer, I was frustrated with how I handled operational data. I constantly need access to SSH passwords (where keys aren't an option), specific IP addresses, and complex CLI one-liners. I realized I was storing them in insecure text files or sticky notes because standard clipboard managers felt too bloated and password managers were too slow for my workflow.
I wanted a "warehouse" for this data—something that lives quietly in the system tray, supports deep hierarchy, works completely offline, and looks industrial.
The app is built with Rust and Tauri v2. The core technical challenge was mapping a local JSON tree structure directly to a recursive native OS tray menu. This allows you to navigate nested folders just by hovering, without opening a window.
For security, I implemented AES-256-GCM encryption with Argon2 for key derivation. When the vault locks, the sensitive data is wiped from memory, and the tray menu collapses to a locked state.
It was an interesting journey building this on the Tauri v2 Beta ecosystem. I’d love to hear your feedback on the implementation, especially regarding the Rust-side security logic.
Repo: https://github.com/Rench321/sklad

value: Show HN: Sklad – Secure, offline-first snippet manager (Rust, Tauri v2)


value: brianchanwh

value: Show HN: What Time Was It? – See what time it was X hours/minutes ago

author: brianchanwh


value: Show HN: EasyClaw – Seamless Installation for OpenClaw


value: devthecritical

value: Show HN: OpenClaw Harness – Security firewall for AI coding agents (Rust)

author: devthecritical


value: kaamuli

value:
As a proof of concept my friend and I built PitchPilot to make football analytics genuinely useful in real time, not just a post match dashboard. The vision was an AI coach that can spot patterns you can actually act on mid game: where the opposition is vulnerable, where your team is getting exposed, and what decisions are high value vs just hopeful, all grounded in models trained on thousands of historical matches rather than hand coded rules.
The feature that made it feel real was 'The Gaffa', a fully customisable coach voice assistant powered by ElevenLabs. Instead of dumping charts on a coach, it speaks key insights as the match evolves. The personality is configurable too, so it can be calm and analytical, high energy and motivational, or blunt and demanding depending on what the team needs.
The reason it works is because it is backed by live probability estimates, not vibes. We treated tactical intelligence as a supervised learning problem: given what has happened so far, can we predict the probabilities that matter and use them to value decisions? Using StatsBomb event data (StatsBomb Open Data), we trained lightweight logistic regression models for:
Pass completion probability
Shot conversion probability (xG)
Win probability, learning P(win | state) from compact match snapshots (time remaining, score difference, xG difference, xT difference)
At the action level, we compute xT (expected threat) by splitting the pitch into a grid and scoring progression with:
Delta xT = xT(end) - xT(start)
Then we add risk reward by weighting threat gain by pass completion probability, so ambitious passes only get rewarded when they are actually on.
We also prototyped Live Feed. You can either stream directly into the platform or paste a stream URL (YouTube Live or HLS), and the backend runs a pipeline like:
frames → Anthropic (Claude) describes what is happening → we convert that into structured inputs → we recompute pass, xG, win probability + xT deltas → we prompt Claude again to decide what the coach should say right now → ElevenLabs generates the voice → overlays and commentary go out via WebSockets.
And it is not just live. At full time, you get match reports + player reports based on what was collected across the game (momentum swings, key xT actions, high value decisions, and high risk vs high reward moments), so the feedback is evidence based not just “you played well”.
It was really fun figuring out latency tradeoffs, wiring together data pipelines, cleaning data, training our own supervised learning models, and honestly just hacking hard for 24 hours (plus absorbing snacks). Would recommend.
Github repo: https://lnkd.in/ejSsm4dM
Youtube links:
The Gaffa: https://lnkd.in/esyt7PjD
Live Stream Analytics: https://lnkd.in/e6SGe7Gw
Data Analytics: https://lnkd.in/eVknQ5_g

value: Show HN: PitchPilot – real time AI football-coach and Analytics

author: kaamuli


value: mikeyfrilot

value: Show HN: RunForge Desktop – Local ML Experiment Tracker for Windows

author: mikeyfrilot


value: capevace

value: Show HN: Claw.events – Real-Time Pub/Sub for Distributed AI Agent Coordination

author: capevace


value: PreciousH

value: Show HN: Prism AI – A research agent that generates 2D/3D visualizations

author: PreciousH


value:
Hi HN,
I just released Signal Engine, an open-source tool to turn static analysis chaos into actionable insights.
It can:
* In the future, aggregate results from multiple tools (Semgrep, ESLint, etc.). Now only semgrep json output is supported
* Deduplicate and normalize findings
* Rank alerts by relevance
* Export clean, developer-friendly reports
Designed to start small and grow into a full signal-processing engine.

value: Show HN: Signal Engine – filter the noise from static analysis results


value: dwehrmann

value: I built this to enforce structured, efficient communication in multi-agent systems. v1.1 adds native cost tracking. Feedback welcome.

value: Show HN: Pairl – Protocol for Agent Communication with Budget Tracking

author: dwehrmann


value: curlii

value: Show HN: Design In The Browser – Point, click, and let AI write the code

author: curlii


value: loganye

value:
I’m building DeepTutor to reduce the time spent reading papers.
One feature we shipped: you can prompt a figure/plot and ask:
“Explain what the figures mean step-by-step.”
It outputs a structured interpretation: axes/curves, phase changes, and the takeaway.
I’d love feedback on:
1) what figure types are hardest to interpret
2) what you’d want in the output (e.g., assumptions, caveats, comparisons)
Demo: https://youtu.be/A6Y4NpLnU1M

value: Show HN: Ask research paper figures (step-by-step explanations)

author: loganye


value: pipnonsense

value:
In 2020 I posted this, "Show HN: Read The Count of Monte Cristo and others in your email" https://news.ycombinator.com/item?id=24307752
It got front page for a few hours. I posted in the anniversary of when The Count of Monte Cristo first started to be published in serialized form. To celebrate it, I created a website called "Serial Literature" that allowed you to subscribe and read the book in a similar way, serialized, but in your email. I also added another famous work that was initially published serialized, Great Expectations by Charles Dickens. I later added about other 100 books to be read the same way (not all of them originally serialized).
I never posted about it anywhere else (maybe flopped on Reddit, I don't remember), but it got a lot of engaged subscribers. It never grew over that initial HN burst (I never advertised it again), but it got about 1,000 subscribers and, years later, a few dozens of those were still reading some book through Serial Literature.
That was until... a startup failed and my web app wouldn't work anymore.
At the time, I wanted to build something serverless and learn some new tech. I chose FaunaDB, learned their proprietary query language (FQL), actually enjoyed it a lot, and built the site with it. It was pretty neat and worked fine. But then, 5 years later, around June last year, their service stopped working (https://news.ycombinator.com/item?id=43414742). As it was serverless, the DB was also on their cloud, hosted by the failed startup, in a proprietary format. One day, Serial Literature stopped working overnight. I downloaded the data, but in their weird format, it was not very helpful.
I got a bunch of emails in the last months asking about it, people wanting to continue reading more through their email, where I explained what happened and promised it would come back in some form. This site I am showing now, Confabulists, is the come back.
I am a writer myself, indie, self-published, science fiction writer, and I missed a newsletter/blog platform more adequate for fiction writers, so I built one myself. And, yesterday, I finally completed bringing all those public domain books in English to Confabulists and now I am able to offer that same service of Serial Literature, again, still for free.
I hope this reaches everyone that loved Serial Literature, but just accepted it was gone and never contacted me (the ones who contacted me I am replying back telling them about Confabulists).
Thanks HN!

value: Show HN: (the return of) Read The Count of Monte Cristo and others in your email

author: pipnonsense


value: Show HN: WonderPic – Turn photos into cartoons/sketches (Free, No Login)


value: musnas

value: Show HN: Uruflow – A self-hosted, lightweight CI/CD server written in Go

author: musnas


value: echoos

value: Show HN: Judgment Boundary – Stop as a First-Class Outcome for AI Systems

author: echoos


value: roadsidejesus

value: Show HN: I built a digital clock with a 3D-printed case, custom PCB, and Arduino

author: roadsidejesus


value:
People seem to be blindly hooking up their OpenClaw’s to their personal data. So, I built runtime controls to prevent at the least, very simple prompt injection attacks.
Once installed, it hooks to Node.js child_process module in the gateway process and listens to tool calls and their response streams. And a fetch hook to monitor user prompts (both could’ve been through fetch, happy to discuss why this whole layer couldn’t just be a proxy).
There are two layers of protection:
First: Whenever there is a read-only tool call whose response an attacker can modify, we extract that part of the json response and send it to a small haiku model to check if it has instruction asking the LLM to do something different
Second: For when the prompt injection detection fails, we maintain a list of function calls which can write to places that an external actor can access. We prompt the user for explicit permission to go forward through the UI.
I would love a discussion on how this second layer could be made better and less frequent by relying on some decision process. My current idea:
Based on a collected set of “trusted” context (user prompts, responses from tool calls attackers cannot manipulate), can we detect if this tool call was necessary. There are scenarios where you’d need detection at the parameter-level.
Two notes:
1) This cannot just be a proxy because you need application level integration to have humans in the loop when needed and push UI controls.
2) How i improved accuracy of detecting prompt injection is by selecting only that content from the entire response json that can be manipulated by an external actor. This had to be done for each tool separately. The current implementation is for 2 skills I randomly chose (Notion & Github).
P.S.: I maintain one for claude code myself while working: https://github.com/ContextFort-AI/Runtime-Controls, I created this over the weekend OpenClaw

value: Show HN: Prompt-injection firewall for OpenClaw agents


value: simpnoza

value:
Hey HN,
TLDR: Upload any document, get an audiobook with synced highlighting you can pause and talk to.
I'm a self-taught dev (admittedly mediocre), currently between jobs and my brain is absolutely fried from social media. I can't read anymore. My eyes glaze over after two paragraphs.
So I went down a rabbit hole looking for scientifically proven ways to actually focus while reading:
- Encoding info visually AND aurally reduces mind wandering by up to 40%
- Retrieval practice (asking questions) beats passive re-reading every time
- Background music matched to content keeps you in flow
Couldn't find anything that did all this. So I built it myself:
- Synced text highlighting while you listen
- Talk with your book; pause and ask "wait what does that mean?" and it knows exactly where you are (won't spoil what's ahead)
- Adaptive background music that matches the mood of each page
I've removed all slop. No flashy features, no gamification etc. etc. Just reading on steroids for fried brains, like mine.
Processes books in under 2 minutes. Works as a PWA so you can install it on your phone.
The alternatives I have found are crazy expensive. Audible charges 15 bucks a month for a single book and you can't even use your own files. Others run 20-30 bucks a month and none of them let you talk to your book.
There's a free tier if you feel like giving it a try: 50 pages, all features included, no credit card required.
Would love your feedback,
Rob

value: Show HN: I turned my PDFs into audiobooks I can have conversations with

author: simpnoza


value: stefanopochet

value:
Hi HN,
I built OpenClaw Cloud, a hosted version of OpenClaw (formerly Clawdbot / Moltbot).
The motivation was simple: many people want to try OpenClaw, but don’t want to run an AI agent locally or deal with Docker, VPSs, or Mac minis. With OpenClaw Cloud, nothing runs on your machine.
After subscribing, you get instant access to a secure, sandboxed cloud instance with OpenClaw already installed and configured. Access is provided through a web-based terminal/UX, and in most cases you just paste your Telegram (or WhatsApp) bot key and start using it. No setup, no maintenance.
The environment is isolated, updated automatically, and designed to minimize risk while still giving you the full OpenClaw experience.
I’d love feedback on:
whether this solves a real adoption blocker
expectations around pricing vs free trials
what would make a hosted AI agent feel trustworthy enough to use
Happy to answer questions and discuss.

value: Show HN: OpenClaw Cloud – run OpenClaw safely in the cloud, no local install

author: stefanopochet


value:
Riemann Zeta function convergence explorer with a 3D surface view.
It lets you sweep the complex plane domain, pick presets (critical strip, first zeros, near the pole), and toggle layers like the critical line, known zeros, reference planes, and divergence region. There are also modes to compare analytic continuation against Dirichlet partial sums or prime zeta partials, plus error and relative error views.<p>Enjoy!

value: Show HN: Riemann Zeta Function Explorer

title: Show HN: Riemann Zeta Function Explorer


value: orcunozyurt

value: Show HN: TensorSeal – Zero-disk-footprint secure model loader for Android

author: orcunozyurt


value: bladecd

value:
Cryptography Interactive Visualization enables in-depth understanding the internals of crypto behind math. The first release is for AES-128-ECB.
Features
  - Intuitive: code/data sync with step into/step over/step back
  - Interactive:  visualized step  execution, e.g., key schedule, shift rows, mix columns , for AES.
  - Correctness: verified internals states and outputs with mbedtls
Next
  - fix possible bugs in different screen sizes
  - support more AES modes(mostly GCM)
  - add ECC, ECDH

value: Show HN: Cryptography Interactive Visualization

author: bladecd


value:
hi, I have an extensive rust background and was exploring zig, noticed it didn't have an channel implementation for inter thread communication so I built it.
the core is relatively lean (< 200 LOC) and the performance is comparable to the golden standard (crossbeam) for the most part
it uses the LMAX Disruptor pattern (sequence based)
code: <https://github.com/nubskr/ziggy>
would love to hear your thoughts :)

value: Show HN: Ziggy – high performance lock free MPMC channel in under 200 LOC


value: pipnonsense

value:
In 2020 I posted this, "Show HN: Read The Count of Monte Cristo and others in your email" https://news.ycombinator.com/item?id=24307752
It got front page for a few hours. I posted in the anniversary of when The Count of Monte Cristo first started to be published in serialized form. To celebrate it, I created a website called "Serial Literature" that allowed you to subscribe and read the book in a similar way, serialized, but in your email. I also added another famous work that was initially published serialized, Great Expectations by Charles Dickens. I later added about other 100 books to be read the same way (not all of them originally serialized).
I never posted about it anywhere else (maybe flopped on Reddit, I don't remember), but it got a lot of engaged subscribers. It never grew over that initial HN burst (I never advertised it again), but it got about 1,000 subscribers and, years later, a few dozens of those were still reading some book through Serial Literature.
That was until... a startup failed and my web app wouldn't work anymore.
At the time, I wanted to build something serverless and learn some new tech. I chose FaunaDB, learned their proprietary query language (FQL), actually enjoyed it a lot, and built the site with it. It was pretty neat and worked fine. But then, 5 years later, around June last year, their service stopped working (https://news.ycombinator.com/item?id=43414742). As it was serverless, the DB was also on their cloud, hosted by the failed startup, in a proprietary format. One day, Serial Literature stopped working overnight. I downloaded the data, but in their weird format, it was not very helpful.
I got a bunch of emails in the last months asking about it, people wanting to continue reading more through their email, where I explained what happened and promised it would come back in some form. This site I am showing now, Confabulists, is the come back.
I am a writer myself, indie, self-published, science fiction writer, and I missed a newsletter/blog platform more adequate for fiction writers, so I built one myself. And, yesterday, I finally completed bringing all those public domain books in English to Confabulists and now I am able to offer that same service of Serial Literature, again, still for free.
I hope this reaches everyone that loved Serial Literature, but just accepted it was gone and never contacted me (the ones who contacted me I am replying back telling them about Confabulists).
Thanks HN!

value: Show HN: Public domain classics delivered as weekly email installments


value: martinovigiani

value: Show HN: Archon – 4 parallel Claude terminals that build software autonomously

author: martinovigiani


value:
Picked up PI, and I'm really happy with its minimalism. Only thing missing for me was a bit more structure to long-running tasks and subagents and test-runners^1
Tried a few designs and came up with this minimal solution.
A pi extension to start/capture/stop in the same tmux environment you're already using.
[1]: https://github.com/badlogic/pi-mono/blob/main/AGENTS.md#test...

value: Show HN: Pi-Tmux

title: Show HN: Pi-Tmux


value: Codegres

value:
Chrome Screen Recorder Extension like Loom.
Without any SignIn or Accounts.
Complete Privacy.
Download Video to Local after Screen Record

value: Show HN: Screen Recorder – Local

author: Codegres

title: Show HN: Screen Recorder – Local


value:
Hi all,
We are building GeoRankers -  an AI search optimization tool for B2B SaaS companies. The idea came from a problem I kept running into while working on SaaS marketing teams and honestly never found a clean way to solve.
All traditional SEO tools like Ahrefs, Semrush, Moz etc. give you a lot of data around rankings, keywords, impressions, competitors, and backlinks but where things usually break down is when you try to decide what to actually change next. Most of the time you end up jumping between reports, forming a hypothesis  and hoping that things will move in the right direction.
This gap is even more clear with AI-driven search.
Even when SEO numbers look good, prospects now ask tools like ChatGPT, Gemini, or Perplexity for advice. A lot of the time, brands either don't show up at all or they show up in ways that don't feel right or complete. It's hard to know what made the answer or what would really fix it when that happens.
We want to make that easier with GeoRankers. It shows how a brand looks in AI-generated answers, what competitors are mentioned and which sources seem to be affecting those answers. It also tries to recommend specific changes that teams can make and then it lets them see if those changes really did make the brand show up better over time.
The intent is not to build another analytics dashboard but something closer to an execution layer that connects AI visibility issues to specific actions.
We are still refining the product and would love it if you can try it out let me know what you think of the product - what works well, where you think we can improve and any additional capabilities we should add into the platform to make it more valuable.
Link: https://dashboard.georankers.co/register
Happy to answer questions or explain how we are thinking about it.

value: Show HN: GeoRankers – See how AI models like ChatGPT describe your SaaS


value: deveminsahin

value:
After long period of work, I'm open-sourcing a Flutter starter app that I built to be AI-friendly.
Architecture:
- Clean Architecture + DDD + Hexagonal (Ports & Adapters)
- CQRS pattern (Commands for writes, Queries for reads)
- Railway-oriented error handling with fpdart
What makes it "AI-ready":
- 23 architecture rule files in docs/architecture-rules/
- AI tools can read these to understand patterns and generate compliant code
- Every pattern is documented in ADRs
Testing:
- 100% coverage (2,282 tests)
- Unit, widget, golden, property-based, and benchmark tests
Tech: Flutter 3.38, flutter_bloc, go_router_builder, get_it, fpdart
MIT licensed. Feedback welcome.

value: Show HN: AI-Ready Enterprise Flutter Starter – Clean Architecture, DDD

author: deveminsahin


value: Show HN: Toktrack – Track your Claude Code token spending in under a second


value: assafe

value:
Right now, agent skills are static SKILL.md packages that only work if you pre-install them into each agent or tool, and not all agents support them. Agents can't discover and learn skills on the fly as they encounter tasks.
I built Skyll to change that. Skyll is open source for AI agents to discover and learn skills autonomously.
Skyll:
- Crawls and indexes skills across sources (Github, skills.sh, etc) so they’re queryable by intent and content, not just by names or tags
- Scores skills by relevance and popularity
- Serves full SKILL.md content (and references) through a REST API or MCP server
- Lets agents fetch skills at runtime without manual installs
It's 100% open source. We're also building a community registry so anyone can add skills and make them available to all agents. Would love any feedback!
Repo: https://github.com/assafelovic/skyll
Homepage: https://skyll.app
Docs: https://skyll.app/docs

value: Show HN: Agents should learn skills on demand. I built Skyll to make it real

author: assafe


value: surprisetalk

value: Show HN: Adboost – A browser extension that adds ads to every webpage

author: surprisetalk


value: otti-sister

value:
Hi HN,
I’ve been using CLI-based agents in real-world full-stack projects, and I kept hitting the same wall: the "long-prompt fragility." As tasks get complex, agents start ignoring system rules, looping on trivial errors, or losing context mid-workflow.
Most people treat these as "model issues," but I started seeing them as orchestration issues. Instead of cramming every instruction into one massive prompt and hoping the model keeps it all in head, I built oh-my-ag. It’s an orchestration layer for Antigravity that enforces a structural collaboration between specialized agents.
The Core Idea: Process over Prompting
Rather than a single "god-agent," oh-my-ag breaks down the workflow into explicit roles:
PM: Handles requirement decomposition and tasking.
Dev (FE/BE/Mobile): Implementation within a strictly scoped domain.
QA & Debug: One validates the requirements while the other analyzes failures.
Key Technical Features:
Shared Memory (Serena): A persistence layer that keeps decisions and intermediate states consistent, even if you switch models mid-session.
Reduced Volatility: By splitting responsibilities, a minor model hallucination in implementation doesn't derail the entire PM-level task logic.
Parallel Execution: The orchestrator can trigger sub-agents simultaneously where appropriate.
Tooling: Built-in support for Gemini/Claude/Codex CLIs and MCP-scoped tool access.
You can try it with a single command: bunx oh-my-ag
It’s currently being used in production-level iterations for full-stack web and mobile projects (specifically those built on fullstack-starter). I'd love to hear your thoughts on how you're handling agentic "drift" in your own workflows.

value: Show HN: Oh-my-ag. Role-based agent orchestration for Antigravity

author: otti-sister


value:
I built a terminal UI dashboard for monitoring BullMQ.
The problem: Every time I needed to debug queues, I had to set up bull-board – install multiple packages, integrate with Express/Fastify, wrap each queue with adapters, configure routes. Fine for production dashboards, but overkill when you just want to quickly inspect jobs.
bullmq-dash is a TUI that connects directly to Redis. It auto-discovers all BullMQ queues (no manual registration), shows job counts by status, lets you inspect job data/stacktraces, view schedulers/repeatable jobs, and tracks enqueue/dequeue rates. Keyboard-driven (vim-style navigation).
Use cases: local debugging, SSH sessions, quick production inspections – anywhere you want to see your queues without spinning up a web dashboard.

value: Show HN: Bullmq-dash – Terminal UI dashboard for BullMQ (zero setup)


value: DiscoResearch

value:
Hi HN,
I've always been fascinated by how high-level code becomes binary, so I decided to spend my spare time building a toolchain from scratch to learn the ropes. I chose the SuperFX (SNES) RISC chip because its constraints make it a fun puzzle.
Full disclosure: I am not a compiler engineer and I have no formal background in CS. This is very much a "work in progress" and "learning by doing" project.
The current state of the project is:
- Naive register allocation (relies way too much on the stack).
- The code generation is definitely not efficient yet.
- Missing many standard C features and likely full of bugs.
My main goal was to get the "plumbing" working: a custom object format and a linker (discld) that handles symbol resolution and the SNES memory map.
I'm sharing this here mostly as a personal milestone. If you have advice on how to move from a naive allocator to something better, or resources for someone self-taught, I'd love to hear them. Please be kind, as this is my first time showing my "hobby code" to the world!

value: Show HN: DiscoC – A hobby compiler/linker for the SuperFX (SNES)

author: DiscoResearch


value: mesmertech

value:
Saw the remotion claude skills launch earlier, and honestly even though I was surprised how decent some of the results turned out to be I ended up never trying it out with claude code because I knew I'd have to setup remotion, bundler etc and if I was already doing it once I thought I might as well turn it into a site where anyone could just write messages and get a video without any prerequisites.
I also know Claude Code is not something everyone has and setting up remotion is a pain. And one of the biggest lessons I learned from this whole experience is that Opus is actually not that good at design tasks even with the skills, Gemini is what I'm using for Framecall and even Flash(Fast Mode) produces sometimes better results than Opus, crazy considering the cost difference.
Some other things I learned is that motion videos have the same "problem" as writing good code or using claude code as a vibe-coder vs someone who knows the framework they're working with. If you just say "Make a nice video about X" its usually a gamble if the end result will be good, same as if you say "Make me x application" with claude code. You need to have a good eye for design and some terminology to know what exactly it is you want to achieve.
K2.5, ZLM and most of the open source models were pretty bad at making videos even with the skills so I ended up not adding them as an option.
The pricing is there because turns out having 2-5k+ tokens of code output for every animation + 1-2k of tokens for the remotion skills as input is kinda expensive. Would've loved to offer this as just a free product since I made it for fun anyways but oh well.

value: Show HN: Make AI motion videos with text

author: mesmertech


value: keepamovin

value: Show HN: BlueDot – a small TUI to search and rent cloud VPS

author: keepamovin


value: difc

value:
I’ve been building Nucleus because most “agent security” is still policy-only: a config file that says “don’t do bad things,” while the agent can still do them.
Nucleus is an OSS experiment that pairs a small, compositional permission model with runtime enforcement: *side effects are only reachable through an enforcing tool proxy*, inside a Firecracker microVM. The envelope is *non-escalating*: it can only tighten or terminate, never silently relax.
What works today:
* MCP tool proxy with *read / write / run* (enforced inside the microVM)
* default-deny egress + DNS allowlist + iptables drift detection (fail-closed) on Linux
* time + budget caps enforced
* hash-chained audit log + HMAC approval tokens (scoped, expiring) for gated ops
What’s missing (being upfront):
* web/search tools exist in the model but aren’t wired to MCP yet
* remote append-only audit storage + attestation are still roadmap
* early/rough; targeting “safe to run against sensitive codebases,” not “replace your local terminal”
Most of the code was written with Anthropic tools; I’ve been leaning on tests/fuzzing/proptests to keep it honest.
Would love feedback on: (1) dangerous capability combinations beyond the lethal trifecta, (2) what enforcement gaps you’d want closed first, (3) how you’d evaluate this vs gateway-only approaches.

value: Show HN: Nucleus – enforced permission envelopes for AI agents (Firecracker)

author: difc


value: alexandrechs

value:
Hello HN !
The Problem:
LinkedIn Company pages are dead. The only way to win is "Employee Advocacy" (empowering team members to post on personal profiles to build their own brand + company reach).
The Solution:
Existing tools for this are stiff corporate chores. So we built copost. Heavily inspired by 37signals and PostHog, we traded the boring spreadsheet vibe for a vintage "Postcard" UI. It’s colorful, tactile, and completely anti-corporate.
Under the hood:

   - The "Algo Hack": You can schedule team likes/comments before the post goes live. This signals quality to the algorithm immediately upon publishing.

   - Security First: No shared passwords. You can post on someone's behalf without asking for their login details.

   - Gamification: We built a shared "Team Streak" (like Snapchat) to make consistency a multiplayer game.

Feedback:
I’m curious if you think this playful "Postcard" UI makes the process less painful for teams, or if you find it too bold for a B2B tool?
Thanks ! - Alexandre

value: Show HN: Copost – A team LinkedIn tool inspired by 37signals and PostHog

author: alexandrechs


value: tonyqinatcmu

value:
Hi HN,
I built SlideBot AI — an open-source AI-powered presentation generator that creates professional slides from natural language input.
Why I built this:
At my company, we spend hours every week creating presentation decks. The existing AI tools either generate generic-looking slides or require too much manual tweaking. I wanted something that:
1. Takes a topic/outline and generates a complete presentation
2. Lets you iterate through natural conversation ("make slide 3 more concise", "add a risk section")
3. Supports voice input — upload a meeting recording and it extracts key points automatically
4. Maintains consistent brand styling across all slides
How it works:
- Input your idea (text, outline, or audio recording)
- AI generates an outline → you refine it through conversation
- AI creates a design scheme → you refine it through conversation
- AI generates each slide as a high-quality image
- Download as a ZIP package
Tech stack: React + FastAPI + Google Gemini API
What makes it different from other AI slide tools:
- Fully open-source (MIT license)
- Conversational iteration at every step — not just one-shot generation
- Voice-to-slides pipeline (meeting recording → presentation)
- Born from actual daily business use, not a hackathon project
This started as an internal tool and has been used in production for several weeks. The iterative refinement workflow was the key insight — the first draft is never perfect, but being able to say "add more data to slide 5" or "make the conclusion stronger" makes a huge difference.
Would love to hear your feedback. What features would make this more useful for your workflow?
GitHub: https://github.com/tonyqinatcmu/SlideBot-AI/blob/main/README...

value: Show HN: SlideBot AI – AI presentation generator built from real business needs

author: tonyqinatcmu


value: tripgeo

value: GeoCards is a clean, interactive map (built with MapLibre and OpenFreeMap) where you can click on literally any text label - cities, parks, roads - and it pulls the relevant Wikipedia summary and photos into the sidebar. It’s great for 'armchair traveling' or just learning about the history of the places you're browsing.

value: Show HN: GeoCards – An interactive wiki map built with MapLibre and OpenFreeMap

author: tripgeo


value: franbetteo

value:
I built a very early MVP of an alternative to Trustpilot over the weekend.
The motivation: review platforms increasingly feel adversarial to both users and companies, with opaque moderation and pay-to-play dynamics. I wanted to explore a simpler, more transparent starting point.
What it does today:
Anyone can leave reviews
Companies can claim their profile
No complicated verification yet, intentionally kept simple
Why participate early:
Early companies get a free account forever (grandfathered)
Claimed profiles get a backlink (currently low value, but potentially useful if this grows)
The whole project only works if the review dataset exists
What I’m asking:
Leave reviews (for listed or unlisted companies)
Claim your company if relevant
If you want to help more, a backlink helps early traction
Monetization (only if it works):
Very cheap base plan for companies (<$20/month)
Premium features later if there’s real demand
Early users keep free access
Planned next steps:
Company responses to reviews
Invite links
Better company customization (logos, etc.)
Google / OAuth login
This is intentionally rough and early. I’m mostly looking for feedback on:
incentives
trust mechanics
what should not exist in a review platform
Happy to hear thoughts.

value: Show HN: Shoulditrustit.com – a simple, early alternative to Trustpilot

author: franbetteo


value:
I built a site that generates haiku about the current weather for any location worldwide, using Open-Meteo for weather data and Gemini (2.5-flash-lite) for generation.
The site will use temperature, wind, humidity, precipitation etc to compose the haiku. The background gradient is decided by season, weather and time of day.
The hardest part was getting the AI to write interesting poetry instead of obvious clichés. Working with generative AI feels more like trying to train an animal than programming a computer. You can't just tell it "don't be boring". I ended up with 30+ randomized focus prompts (material reactions, how light changes, human activity, etc) that get mixed into each generation to encourage variety.
Made with vanilla PHP/JS. Happy to answer questions about the prompt engineering or anything else :)

value: Show HN: Weather Haiku – AI-generated poetry for any location's current weather


value: To be completely honest, there are SSH apps on the AppStore and they are perfectly okay - however I decided to make my own to learn more about SSH and to challenge myself to make my first actual large project.

value: Show HN: A free and open source SSH client for iOS


value: wakandan

value: I vibed code a package to help you vibe code on your mobile device - so that you don't have to. It's tunnel claude/cursor's using ngrok/cloudflared and you could access it using a web interface. Has password protection. Please feel free to use/hack it. Thanks

value: Show HN: Vibe code on your mobile device

author: wakandan


value: Beefin

value: Show HN: Building a VLM Inference Server in Rust

author: Beefin


value: I've discovered this via F-Droid and it works very well without having to enable Google Authentication (in GrapheneOS)

value: Show HN: Authnkey – Android credential provider with FIDO2 support via NFC


value: LutumVeritas

value:
Last week I benchmarked my open-source Deep Research tool against ChatGPT, Perplexity, and Gemini. I caught OpenAI fabricating 4-5 citations that don't exist. Gemini reduced real hazard ratios by 30-40%.
So I built ASK Mode: every answer gets automatically verified against a second round of sources. Each claim marked [OK], [??], or [NO].
- ~400 verified answers for $1
- 2-3 minutes per query
- No RLHF nannying - it answers what you ask
- Full verification report with every response
The gap between chat (unverified, stale training data) and deep research (20+ minutes) needed filling.
Benchmark proof: https://veritas--test-neocities-org.translate.goog/?_x_tr_sl...
GitHub: https://github.com/IamLumae/Project-Lutum-Veritas

value: Show HN: Open Deep Research that beat Big Tech now self-verifies claims

author: LutumVeritas


value: hermet

value:
Hi HN.
We’ve just released ThorVG 1.0, which marks a maturity milestone for the engine. Earlier versions focused on feature growth; this release emphasizes stability, backend parity, and consistent rendering behavior across platforms, including the web.
ThorVG is an open-source, embeddable C++ 2D vector graphics engine used for SVG-style graphics and Lottie.
[What 1.0 means]
This version is less about new features and more about engine readiness:
- Improved rendering performance and engine optimizations
- Improved blending accuracy and text layout behavior
- WebGL backend now officially supported
- WebGPU backend promoted to production-ready status
- Introduced a lightweight WebCanvas path for browser environments
- Broader Lottie spec coverage for more complex animations
- New interaction support including bounding box queries and hit detection
- More predictable API behavior for integration
ThorVG is intended as a small rendering layer for engines, UI systems, embedded devices, and tools where size and deterministic performance matter.
Release notes: https://www.thorvg.org/post/thorvg-v1-0-a-new-generation-rel...
Happy to answer technical questions.

value: Show HN: ThorVG 1.0 – Fast vector rendering with Lottie and GPU backends

author: hermet


value: PrismShadow

value:
Hi HN! We built Context9 to reduce LLM hallucinations caused by outdated documentation. It’s an open-source tool built on Knowledge MCP.
Why use it:
- Real-time Sync: Feed the latest local docs/private repos to agents. No more stale context.
- Reduce Halluclinations: Grounding agents in your current docs, not outdated training data.
- Private-first: Everything stays local. No third-party indexing or data leaks.
- No RAG Overhead: Skip complex vector DB setups. It’s agent-native and fast.
- 100% Free: Open-source and local-first.
Perfect for fast-evolving projects where static MCP servers can't keep up.

value: Show HN: Context9 – A private-first Knowledge MCP for real-time local doc sync

author: PrismShadow


value: CzaxTanmay

value:
Hi HN,
I’ve been building ÆTHRA, a small programming language focused on expressing music and emotion through code.
The goal is not DAW replacement or heavy theory, but a minimal, readable DSL where rhythm, mood, and structure feel natural to write—closer to thought than tooling.
Unlike live-coding tools, ÆTHRA is designed to be:
simple to read even for non-musicians
deterministic (no browser timing issues)
focused on composition, not performance
beginner-friendly but extensible
It’s free, open source, and still early.
I’d love feedback—especially from people who’ve tried tools like Strudel, Sonic Pi, or TidalCycles.
GitHub: https://github.com/TanmayCzax/AETHRA
-- Tanmay

value: Show HN: ÆTHRA – A tiny programming language for writing music as code

author: CzaxTanmay


value: eggspurt

value:
I used Replit to build an investor relations platform to test a simple hypothesis:
> Pricing access to founder time improves signal quality in investor conversations.
Background:
In early fundraising, founders spend a lot of time on low-signal meetings. The scheduling cost is asymmetric: founders prepare, investors explore cheaply. There is no native commitment mechanism beyond social norms.
This project implements a minimal market for founder time.
How it works:
1. Investors place a bid for a 1:1 meeting
2. A minimum bid is enforced
3. Agenda, availability, and time zone are required at bid time
4. If the meeting doesn’t happen, the bid is refunded
Bidders can opt in or out of public attribution on a map of AI/data investors
The bid is not payment for capital access. It’s a commitment signal. The refund rule prevents extraction.
Implementation notes:
* Built quickly on Replit
* Stripe for payments and receipts
* No CRM, no automated follow-ups
* Admin actions handled manually via the database
* Intentionally small surface area
What this is not:
* Not a scheduling app
* Not a marketplace for advisors
* Not “pay to pitch”
* Not optimized for scale or revenue
You can try it here:
https://investor.data.flowers/
Viewing requires no login. Bidding requires payment.
Questions I’m interested in discussing:
* Does this produce better signaling than social heuristics?
* Does refundable pricing dominate non-refundable fees?
* What strategic behavior does this enable (or discourage)?
* Where does this fail under adversarial or repeated interaction?
This is an experiment, not a thesis. Curious to hear critiques from people who’ve built marketplaces or thought about incentive design.

value: Show HN: Investor relations platform lets investors bid on meeting the founders

author: eggspurt


value: michal-stlv

value: Show HN: Stelvio – Ship Python to AWS

author: michal-stlv

title: Show HN: Stelvio – Ship Python to AWS


value: ogig

value:
Hi guys;
Over the weekend I've created this using Claude Code. It's an ear training app destined to teach intonation and intervals to not so talented musicians like me. I spend many year playing guitar without a clear feeling on what intonation really was. It was after some string tuning exercises that it clicked for me. The freq sliding into the right place and feeling the correctness. I hope this app can helps other to feel that for the first time, or to increase the recognition of less common intervals. Any feedback is appreciated.

value: Show HN: A different approach to intonation training

author: ogig


value: joneldominic

value: Show HN: File Markers – Track file status directly in VS Code's Explorer

author: joneldominic


value:
Hey HN! I built Gitmore to solve a problem I kept running into: spending hours compiling what my team did each week for stakeholders.
What it does: Gitmore connects to your GitHub/GitLab/Bitbucket repos (via webhooks, never touches your code) and uses AI to generate human-readable reports of your team's activity.
Example report: https://www.gitmore.io/example.html
Interactive demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po

value: Show HN: AI-powered Git reports that write themselves


value: rafmardev

value:
I built this because of a problem I kept running into: I freeze in certain conversations.
In situations like job interviews, first conversations with native speakers in a foreign language, or high-pressure discussions, my mind goes blank. Words and phrases I know just don’t come out. Reading and writing were fine, speaking wasn’t.
Most language tools focus on vocabulary, grammar, or scripted dialogues. They don’t simulate the stress, unpredictability, and pace of real conversations.
So I built an AI avatar that you talk to out loud. It responds in real time, adapts to your level, and lets you practice difficult scenarios repeatedly until the response becomes automatic.
The goal isn’t perfect language, it’s reducing hesitation and building fluency under pressure.
This is an early version and very much a personal project. I’m curious if others here have faced the same “freeze” problem and whether something like this would be useful to you.

value: Show HN: I build an AI Avatar to master real spoken conversations

author: rafmardev


value: Pmopgar

value:
MemoryStack - The memory layer for AI agents that doesn't forget
The problem: AI agents today have goldfish memory. They forget after each session, can't track preference changes, and don't learn from past conversations.
Current solutions fail:
Vector search alone: 40% failure rate on complex queries
Full-context approaches: Expensive, slow, less accurate
MemoryStack solved this with multi-stage memory retrieval.
Results on LongMemEval :
MemoryStack: 92.8%
Best commercial solution: 71.2%
Full-context: 60.2%
Biggest improvements:
Preference tracking: 93.3% vs 56.7%
Knowledge updates: 97.4% vs 83.3%
Multi-session: 89.5% vs 64%
Try it : https://memorystack.app
Fully Open Source
I'm releasing everything today:
Complete source code (MIT license)
Full research methodology and paper
SDKs (Python, TypeScript)
MCP integration for Claude,cursor,kiro
Benchmark suite and evaluation tools
Plugin for OpenClaw/Clawdbot
Enhance OpenClaw's memory with MemoryStack
give : https://github.com/memorystack-labs/Memorystack
Research Paper : https://memorystack.app/research

value: Show HN: MemoryStack – Memory layer for AI agents (92.8% on LongMemEval

author: Pmopgar