value: jacoka

value:
I built VocalSplit because I wanted a way to separate vocals and music without uploading files to a remote server. Most existing tools are either paid SaaS or require a complex local Python environment (like Spleeter or Demucs).
This tool runs entirely in the browser. No data leaves your machine, and there are no processing limits or queues. It uses [említsd meg a technológiát, pl. WebAssembly vagy ONNX Runtime Web] to handle the inference locally.
Thanks for checking it out!

value: Show HN: VocalSplit – Browser-based vocal remover running 100% locally

author: jacoka


value:
I built a Colab notebook that demonstrates a full pipeline for bootstrapping and training a YOLO object detection model without manual annotation.
The workflow uses open-vocabulary object detection to generate bounding boxes from free-text prompts, which are then exported as YOLO labels and used to train a detector.
Typical workflow in the notebook:
Start with an unlabeled or weakly labeled image dataset
Generate bounding boxes using prompts (for example "cat's head" or "dent in car bumper")
Filter positives and rebalance the dataset
Export labels in YOLO format
Train and evaluate a YOLO model
In the example notebook I use a cats vs dogs dataset with only image-level labels. Using the prompt "cat's and dog's head", the pipeline auto-generates head bounding boxes and trains a small YOLO model.
The repository mainly contains the Colab notebook plus example scripts for running the detection and exporting YOLO labels.
Curious to know what people think of this approach.

value: Show HN: Colab pipeline for auto-labeling datasets with prompt and training YOLO


value: kummap

value: This is a simple docker cluster for containing AI agents in Zero Trust fashion. Why? For the past few months I have has couple hours in a day to use for studying AI related technologies and for my motivation it is pretty crucial to post something about it online.

value: Show HN: A simple hardened AI Docker cluster

author: kummap


value: sawirricardo

value: Show HN: TUI for SVN

author: sawirricardo

title: Show HN: TUI for SVN


value: ulrischa

value: Show HN: AIWatermarkDetector: Detect AI Watermarks in text or code

author: ulrischa


value: jasisz

value:
I’ve been building Aver around a simple question:
If AI is going to write more of the first draft, what should the source look like for the human reviewer?
Aver is an experimental statically typed language and toolchain for AI-written, human-reviewed code.
My bet is that source code should carry more than implementation. In most projects, implementation survives in the code, but intent lives in docs, decisions live in ADRs or tickets, and expected behavior lives in tests that may or may not stay close to what they describe.
Aver tries to make those parts first-class: explicit method-level effects in function signatures; ? strings for machine-readable function intent; decision blocks for design choices and tradeoffs; colocated verify blocks for pure functions; deterministic record/replay for effectful flows; aver context for compact contract-level module export; aver compile to Rust; and aver proof to Lean 4 for mechanical proof checking of the pure subset.
A small pure example:

  fn charge(account: String, amount: Int) -> Result<String, String>
      ? "Pure charge validation and transaction-id creation."
      match amount
          0 -> Result.Err("Cannot charge zero")
          _ -> Result.Ok("txn-{account}-{amount}")

  verify charge
      charge("alice", 100) => Result.Ok("txn-alice-100")
      charge("bob", 0)     => Result.Err("Cannot charge zero")

A reviewer can see at a glance what the function is for (`?`) and a machine-checkable example of expected behavior (`verify`).
An effectful wrapper looks like this:

  fn chargeAndPrint(account: String, amount: Int) -> Result<Unit, String>
      ? "Effectful wrapper around charge."
        "Prints the transaction id on success."
      ! [Console.print]
      result = charge(account, amount)
      match result
          Result.Ok(txn) ->
              Console.print(txn)
              Result.Ok(Unit)
          Result.Err(err) ->
              Result.Err(err)

The `!` makes side effects part of the signature rather than hidden inside the implementation.
Aver is intentionally opinionated: no exceptions, no null, no `if`/`else`, no loops, no closures. Branching goes through `match`, failure through `Result`, absence through `Option`, and side effects are explicit.
The repo includes small examples, but also `projects/workflow_engine`, which is my attempt at a medium-sized auditable application core with app/domain/infra split, replayable effectful flows, and verify-driven pure logic.
This is still early. I’m not claiming everyone should replace mainstream languages with Aver.
The narrower question I’m testing is whether making intent, decisions, checks, and effect boundaries machine-readable inside the source makes AI-produced code easier to review, constrain, and trust.
I’d especially like feedback on whether this feels like a language worth existing, or whether the same idea should just be conventions and tooling on top of an existing language.

value: Show HN: Aver – a language designed for AI to write and humans to review

author: jasisz


value: howardV

value:
Hey HN,
I built TryMyClaw after spending way too long trying to self-host OpenClaw. Docker port conflicts, Python version hell, nginx configs — you know the drill.
The managed hosting options out there are black boxes: no SSH, no custom plugins, can't inspect your own data.
TryMyClaw is different: you get a dedicated server, full root access, and bring your own API keys (OpenAI, Anthropic, whatever). No token markups, no vendor lock-in.
What you get:
• Full SSH & root access to your instance
• Bring your own API keys — no middlemen
• Multi-channel: Telegram, WhatsApp, Slack, Discord
• Install any community plugin or build your own
• Auto-updates & daily encrypted backups
Starter is $19/mo. Deploy in ~5 minutes.
Happy to answer questions about the setup, the stack, or why I think "managed + full control" is actually possible.
https://trymyclaw.com (https://trymyclaw.com/)

value: Show HN: TryMyClaw – Managed OpenClaw hosting with full SSH and root access

author: howardV


value: tskulbru

value:
I have a handful of GA4 properties — a couple web apps, a side project, a thing I shipped on a weekend — and I got tired of clicking through Google's UI every morning to check if anything weird happened overnight. I was spending my mornings clicking through GA4 properties one at a time just to see yesterday's numbers, and whenever I needed to actually understand what was going on I'd have to connect Claude to each one individually. It's a lot of tab-switching for what should be a 30-second check. So I built a dashboard that pulls them all into one screen and tells me when traffic does something statistically unusual.
That's Plask. It connects via Google OAuth (read-only scope) and shows all your GA4 properties in one place. Sessions, users, key events, comparison deltas — the quick pulse check I wanted without navigating Google's interface six times.
The part I spent the most time on is the anomaly detection. I went with modified Z-scores using Median Absolute Deviation over a 28-day rolling window instead of standard deviation — it handles the spiky traffic patterns you get on smaller sites without crying wolf every weekend. No ML, no black box, just basic stats that run at zero cost. Alerts get classified as info/warning/critical, and you can tune sensitivity per property.
There's also a weekly digest powered by Claude Haiku that turns the numbers into a couple paragraphs of plain English every Monday morning. I built it mostly because I wanted to stop opening the dashboard on Mondays.
Stack for those interested: Next.js 16, Supabase Postgres with Drizzle ORM, Auth.js v5 (needed custom OAuth scopes that Supabase Auth doesn't support), Stripe, deployed on Vercel. Daily sync runs as a cron at 6am UTC — nothing fancy, no event streaming.
Solo project. Would genuinely appreciate feedback on the product, the anomaly detection approach, or anything else. Happy to go deep on implementation details.
https://plask.dev

value: Show HN: I replaced my morning GA4 tab explosion with one page

author: tskulbru


value: branoco

value:
I've been building GlobCall — browser-based international calling, no app, no SIM, just open a tab and call anywhere. A lot of people found it when Skype shut down last year and stuck around.
10,000+ users, 40+ countries. I run my own business in Europe and use it daily.
The more companies started using it — support, sales, collections, onboarding — the more I saw the real opportunity. Not cheaper calls. Calls that don't need a human to make them.
The "Human-Phone" interface is still beautiful:
A real voice call closes deals chat can't close. It de-escalates situations email makes worse. Across cultures and languages, a human voice carries weight no notification ever will.
But it doesn't scale. Someone has to be awake. Someone has to speak the language. Someone has to smile through call thirty-seven of the day.
The medium is extraordinary. The constraint is us.
The "Agent-Phone" interface is what we're building next:
Agentic AI voice agents that place and receive real phone calls.
A local number in Brazil following up on unpaid invoices. An AI speaking Romanian handling inbound at 2am. An outbound agent qualifying leads in the UAE before your sales team picks up the phone...
The infra exists. What's been missing is the calling layer that works without a six-figure enterprise contract. That's the gap we're closing now.
You can start today — with humans:
The agentic layer is in private testing. Everything else is live: international calls, local numbers in any country, browser or API. No per-seat pricing, no sales call. Top up and go.
Happy to answer questions about the stack, or how we're thinking about the agent layer.
→ would love seeing you or your company try it at globcall.com

value: Show HN: I Built a Skype Alternative. Then Discovered AI Agentic Voice

author: branoco


value: davidfarrell

value:
https://aigreenlight.app
My main agent is Claude Code but I've been dabbling with Copilot CLI, Cursor CLI, and Codex CLI too. The biggest productivity killer across all of them is the same: agents blocking on permission prompts while I'm away from my desk.
So I made Greenlight: an iOS app that forwards agent permission requests to your phone as push notifications. And it worked! And then Anthropic released "Remote Control". That was a tough day. But I realized something: there's no agent-agnostic remote control. So I've extended Greenlight to work with Copilot, Cursor and Codex too.
The companion CLI (`greenlight connect`) wraps your agent session. The agent runs in full auto mode while Greenlight intercepts actions before they execute. This inverts control: instead of the agent deciding what permissions to ask you for, you decide what actions the agent is permitted to take. Did you know that Claude Code runs `ssh ... git@github.com` every time you start a session?
Other stuff I like about it: compound shell commands are split into segments and color-coded by risk level so it's easy to judge the risk of a command. Over time your rules are tuned to the project and you only receive requests for novel or destructive commands. My favorite feature is "pull the plug": you can sigkill any agent that is rabbitholing and ignoring you.
The server mostly a router - it never inspects or saves your transcript. Would love feedback, especially from anyone juggling multiple agents.

value: Show HN: Greenlight – Manage your AI coding agents from your phone

author: davidfarrell


value: powerwild

value:
Hi HN,
I built MoodPulse App, a small app that helps you log your mood in seconds and visualize how it changes over time.
The idea came from wanting something simpler than most journaling or mental-health apps. Many of them require long entries or feel heavy to maintain daily. I wanted something that takes just a few seconds but still gives useful insights.
What it does:
• Log your mood with a single tap (with optional notes)
• Visualize emotional trends with simple charts
• Track streaks and weekly patterns
• Share visual mood charts with friends if you want
The focus is on speed and consistency — something you’ll actually keep using.
I’d really appreciate feedback from the HN community, especially on:
• whether mood tracking like this is actually useful
• features that would make it more valuable
• privacy expectations for apps in this space
Website: https://moodpulse.saposs.com/
Thanks!

value: Show HN: MoodPulse App – a simple app to track your mood in seconds

author: powerwild


value: simonbc

value:
Aaron Swartz and I built Jottit in 2007 as a really simple way for anyone to make a page on the web in seconds. You just typed something, clicked a button, and you got a page on a secret URL. It went offline years ago.
I've now rebuilt it from scratch. It's basically the same idea, but even simpler. Go to jottit.org, write markdown, and you have a published page. Claim it, pick an address, and you now have a feed of your pages at yourname.jottit.org. There's no signup to start writing. And no JS on public pages. You can export your writing when you want.
Jottit is free and open source. It's not a startup, just something I really wanted to exist again.

value: Show HN: Jottit – Publish in seconds, reviving my 2007 project with Aaron Swartz

author: simonbc


value: Show HN: gists.sh – Beautiful Viewer for GitHub Gists


value: jpzk

value:
Agent self on boarding, built in. It reads the docs, pays the 5 USDC/month on Solana, spins up an inbox, and starts receiving/sending. No signup form. No credit card. No you.
• Prompt to mailbox (no human interaction required)
• @agentmbox.com mailbox included
• Custom domains included, even Custom DNS will be set up via agent
• IMAP, SMTP, and REST API — any language, any framework
On X: https://x.com/solapunk80/status/2031701417304494537
On ProductHunt: https://www.producthunt.com/products/agentmbox?launch=agentm...

value: Show HN: YC W26 AgentMBOX agent self-onboarding mailboxes

author: jpzk


value:
I built a very small internet experiment to measure engagement between payment platforms.
The idea is simple:
Venmo vs Cash App.
Participants can tap $1 on either platform and it counts as an engagement signal.
There is:
• no product
• no donation
• no reward
• no exchange
The $1 simply acts as a friction signal to measure which community shows up.
The site displays live engagement data including:
• platform split
• time-of-day activity
• engagement heatmap
It's basically a real-time behavioral experiment.
Curious to see which community participates more.

value: Show HN: Engagement Experiment – Venmo vs. Cash App


value:
I built agent-triage - a CLI that automates diagnosing AI agent failures in production.
I was spending way too much time staring at traces, logs and dashboards trying to figure out why my multi-agent setups kept failing.
You just point it at your traces (LangSmith, Langfuse, OpenTelemetry, or a JSON file). It pulls the system prompts directly from the logs, extracts the behavioral rules, and uses an LLM-as-a-judge to replay each conversation step-by-step.
It flags exactly which turn broke things, which agent caused it, and traces cascading failures across routing, handoffs, and retrieval.
It aggregates root causes across all of them: "24 out of 51 failures are missing escalations." You know exactly what to fix first.
Runs locally. Only LLM API calls leave your machine.
npx agent-triage demo — runs on sample data, uses your own API key (~$0.002/conversation with gpt-4o-mini).
https://github.com/converra/agent-triage
Demo report: https://demo-report-sigma.vercel.app/

value: Show HN: Agent-triage – diagnosis of agent failures from production traces


value: ashlance

value:
I'm a developer and dad who wanted to hand my daughter the iPad without her
  getting lost in Plex's UI. She navigates YouTube Kids fine — big pictures, tap
   to play — but Plex's menus were totally beyond her.

  I already had managed users and rating filters set up, so the content was
  handled. It was purely a UI problem. So I built Canopy.

  It's a native iOS app that connects to your existing Plex server and gives
  kids a simple carousel interface — big posters, tap to watch. It respects your
   managed user restrictions so you don't have to re-configure anything.

  Features: poster grid UI, PIN-gated parental controls, screen time limits,
  continue watching, and full support for Plex managed users and content
  ratings.

  Built with SwiftUI, no analytics or tracking, no subscriptions. $4.99 on the
  App Store.

  https://canopykids.app

  Happy to answer questions about the build, the Plex API, or anything else.

value: Show HN: Canopy – A kid-friendly Plex client for iOS

author: ashlance


value: wslyvh

value:
Hi HN,
Most people have 100+ accounts they've forgotten about, creating security risks and privacy exposure. Every account you create, every service you sign up for, every online purchase is connected to your email address. Paperweight scans your inbox to map your digital footprint, then helps you take back control and delete your data.
Local-first. Your data stays on your computer. Respecting your privacy by default.
Features
- Marketing/Bulk unsubscribe — Find an unsubscribe from marketing and bulk mailing lists in minutes
- Account inventory — Discover which vendors and services have your data
- Breach alerts — Know when companies you use get breached (via haveibeenpwned.com)
- GDPR deletion support — Generate data deletion requests to reduce exposure
- Local-first — Your emails and settings stay on your machine
- Privacy-respecting — No data sent to external servers
- Open development — Built in public, source code available for audit
If you connect via Gmail, you will see Google's "unverified app" warning. The verification process takes time. Since the app is local and open source, you can review the scopes and code yourself before proceeding.
Free to try (30-day scan, all features). Temporary $19 lifetime license for unlimited email history and to support development.
More info: https://www.paperweight.email/
Happy to answer questions!

value: Show HN: Paperweight, local-first inbox scanner to manage your digital footprint

author: wslyvh


value:
Every day, the top HN posts are analyzed and the most promising startup ideas are surfaced, scored, and explained in one place.
Each idea includes what to build, why now, the market opportunity, and the community signal behind it.
https://buildwhat.org

value: Show HN: Buildwhat.org – Find tech business ideas


value: saphalpdyl

value:
Demo: https://aether.saphal.me
GitHub: https://github.com/saphalpdyl/Aether
Aether is a multi-BNG (Broadband Network Gateway) ISP infrastructure lab built almost from scratch that emulates IPoE IPv4 subscriber management end-to-end. It supports IPoE/Ipv4 networks and runs a python-based vBNG with RADIUS AAA, per-subscriber traffic shaping, and traffic simulation emulated on Containerlab. It is also my first personal networking project, built roughly over a month.
Motivations behind the project
I'm a CS sophomore. About three years ago, I was assigned, as an intern, to build a OSS/BSS platform for a regional ISP by myself without mentoring. Referencing demo.splynx.com , I developed most of the BSS side ( bookkeeping, accounting, inventory management ), but, in terms of networking, I managed to install and setup RADIUS and that was about it. I didn't have anyone to mentor me or ask questions to, so I had given up then.
Three years later, I decided to try cracking it again. This project is meant to serve as a learning reference for anyone who's been in that same position i.e staring at closed-source vendor stacks without proper guidance. This is absolutely not production-grade, but I hope it gives someone a place to start.
Architecture overview
The core component, the BNG, runs on an event-driven architecture where state changes are passed around as messages to avoid handling mutexes and locks. The session manager is the sole owner of the session state. To keep it clean and predictable, the  direBNG never accepts external inputctly. The one exception is the Go RADIUS CoA daemon, which passes CoA messages in via IPC sockets. Everything the BNG produces(events, session snapshots) gets pushed to Redis Streams, where the bng-ingestor picks them up, processes them, and persists them.
Simulation and meta-configs
I am generating traffic through a simulator node that mounts the host's docker socket and runs docker exec commands on selected hosts. The topology.yaml used by Containerlab to define the network topology grows bigger as more BNG's and access nodes are added. So aether.config.yaml, a simpler configuration, is consumed by the configuration pipeline to generate the topology.yaml and other files (nginx.conf, kea-dhcp.conf, RADIUS clients.conf etc.)
Known Limitations
- Multiple veth hops through the emulated topology add significant overhead. Profiling with iperf3 (-P 10 -t 10, 9500 MTU, 24 vCPUs) shows BNG→upstream at ~24 Gbit/s, but host→BNG→upstream drops to ~3.5 Gbit/s. The 9500 MTU also isn't representative of real ISP deployments. This gets worse when the actual network is reintroduced capping my throughput to 1.6 Gbits/sec in local.
- The circuit ID format (1/0/X) is non-standard. I simplified it for clarity.
- No iBGP or VLAN support.
- No Ipv6 support. I wanted to target IPv4 networks from the start to avoid getting too much breadth without a lot of depth.
Nearly everything I know about networking (except some sections from AWS) I learned building this. A lot was figured out on the fly, so engineers will likely spot questionable decisions in the codebase. I'd genuinely appreciate that feedback.
Questions
- Currently, the circuit where the user connects is arbitrarily decided by the demo user. In a real system with thousands of circuits, it'd be very difficult to properly assess which circuit the customer might connect to. When adding a new customer to a service, how does the operator decide, based on customer's location, which circuit to provide the service to ?

value: Show HN: I built an ISP infrastructure emulator from scratch with a custom vBNG

author: saphalpdyl


value: tobiasbischoff

value:
Hey HN, I built LobsterLair because I got tired of maintaining my own OpenClaw setup. Docker updates, uptime monitoring, API key management — it ate more time than actually using the agent.
So I built managed hosting: sign up, name your bot, start chatting. Under 2 minutes.
AI is included. Every instance runs MiniMax M2.5 (200k context) — no API key needed, no OpenAI account, no billing surprises. You just chat.
Each user gets an isolated Docker container with AES-256 encryption, persistent memory, and built-in Chromium for web automation. Connect via webchat or Telegram.
48h free trial, no credit card. $19/mo after that.
Stack: Next.js, PostgreSQL, Nginx, Hetzner (Germany). Happy to answer questions about the architecture or the business side.
https://lobsterlair.xyz

value: Show HN: LobsterLair – OpenClaw hosting with AI included ($19/mo)

author: tobiasbischoff


value: luckyturkey

value: Show HN: Faster, cheaper Claude Code with local semantic code search via sqlite

author: luckyturkey


value: PowMan

value: Show HN: Tradefacts.io – JSON API for US/Canada tariff data as trade war heats

author: PowMan


value:
I wanted to make a music visualizer that would show all of the notes and show what chord is playing. To make the analysis easier and accurate I stuck to MIDI only input.
The main presets are:
  - Warp: A kaleidoscopic view
  - Stars: Shows the notes spiral away
  - Clock: Reveals the music analysis mechanisms
  - Piano: The standard MIDI visualizer view
The menu allows for the compositor layers to be mixed and matched so you can explore and experiment. I'd recommend trying the "Feedback" and "CRT" overlays first.
I used Claude Code to generate all of the code, but it still took quite a bit of time to get it to look the way it does.
I wrote a post reflecting on my experience building it as well: https://decompiled.dev/blog/fractured-jukebox/

value: Show HN: MIDI Visualizer

title: Show HN: MIDI Visualizer


value: AskCarX

value:
Hi HN. This week Meta acquired Moltbook (agent social network), OpenAI acquired Promptfoo (agent testing), and Mandiant's founder raised $190M for Armadin. Agent infrastructure is clearly where things are heading.
We built AgentSign -- a zero trust engine for AI agents. The problem: agents are operating without any identity infrastructure. Moltbook went viral for fake posts because there was zero verification on who or what was posting.
AgentSign gives every agent a cryptographic identity certificate, signs every action into an execution chain, and runs runtime code attestation before anything executes. There's also an MCP Trust Layer for agent-to-MCP server verification, and a Stripe-powered Trust Gate for agent payments.
5 subsystems: identity certs, execution chain verification, runtime code attestation, output tamper detection, and cryptographic trust scoring.
Free and open source. Built in London.
SDK: https://github.com/razashariff/agentsign-sdk
Happy to answer questions.

value: Show HN: AgentSign – Open-source zero trust engine for AI agents

author: AskCarX


value: marcobambini

value: Show HN: Liteparser – a complete SQLite parser in C

author: marcobambini


value: xlth

value:
Built this because I was tired of sharing URLs full of tracking cruft. Safari extension for iOS and macOS that strips utm_*, fbclid, gclid, and 50+ other tracking parameters automatically. Runs entirely on-device with zero data collection.
Also bundles CRED-1, a domain credibility dataset (2,672 flagged domains with 5 independent trust signals) that can warn you before visiting sources known for misinformation.
Available on the App Store for iPhone, iPad, and Mac.

value: Show HN: Trackless Links – clean URLs, no tracking (Safari)

author: xlth


value: mosbyllc

value:
Last year, my doctor mentioned I should pay attention to my cardiovascular risk. I searched for online calculators and found two problems: they were either filled with ads or simply threw numbers at you without explaining what they meant.
So I built AIRiskCalc. It's a collection of free health risk assessment tools with AI interpretation.
Currently live with five calculators:
ASCVD Risk (10-year cardiovascular risk based on ACC/AHA 2013 Pooled Cohort Equations)
Type 2 Diabetes Risk (ADA assessment model)
Cardiovascular Risk (multi-factor evaluation)
CVD Risk (cerebrovascular focus)
Miscarriage Risk (early pregnancy assessment)
Implementation: Next.js 15, Cloudflare Pages. AI layer uses Vercel AI SDK with Claude.
One detail I paid attention to: the ASCVD formula involves logarithmic transformations and coefficient matrices from the original 2013 paper. I transcribed the equations into TypeScript and verified against sample data in the paper's appendix.
Each calculator displays the reference source in code comments. Results include AI-generated explanations of what the numbers mean. No personal data is collected.
The question I'm thinking about: where's the line between helpful AI interpretation and overstepping into medical advice? I want the tool to be useful without replacing professional judgment.
Feedback welcome on this balance.

value: Show HN: AIRiskCalc – AI-Powered Health Risk Calculators

author: mosbyllc


value: payrollengine

value:
Instead of hard-coding payroll rules, PayrollEngine models business logic as
composable Regulation layers — versioned JSON/YAML config + runtime C# (Roslyn).
Layers inherit and override like CSS cascade: national law → industry → company.
v0.10.0-beta.1 shipped earlier this week alongside the new docs site (payrollengine.org).
The most interesting new example: MultiCountryPayroll — DE/FR/NL sharing a
single base regulation, with a split employee whose contract crosses borders
mid-period. The regulation handles it without a single country-specific
code path.
Other additions:
- Payrun Preview: in-memory calculation, no DB writes
- Async payrun jobs: HTTP 202, bounded queue, webhook on completion
- Parallel employee processing with per-employee state isolation
Stack: .NET 10, SQL Server, Docker, Roslyn
GitHub: https://github.com/Payroll-Engine/PayrollEngine
Docs: https://payrollengine.org

value: Show HN: PayrollEngine – Open-source regulation-based payroll framework (.NET)

author: payrollengine


value: Show HN: Partnership Intel – Find partners for your products, faster


value: gbram

value:
Hey HN,
I built StreamHouse, an open-source streaming platform that replaces Kafka's broker-managed storage with direct S3 writes. The goal: same semantics, fraction of the cost.
How it works: Producers batch and compress records, a stateless server manages partition routing and metadata (SQLite for dev, PostgreSQL for prod), and segments land directly in S3. Consumers read from S3 with a local segment cache. No broker disks to manage, no replication factor to tune — S3 gives you 11 nines of durability out of the box.
What's there today:
  - Producer API with batching, LZ4 compression, and offset tracking (62K records/sec)
  - Consumer API with consumer groups, auto-commit, and multi-partition fanout (30K+ records/sec)
  - Kafka-compatible protocol (works with existing Kafka clients)
  - REST API, gRPC API, CLI, and a web UI
  - Docker Compose setup for trying it locally in 5 minutes

  What's not there yet:
  - Battle-tested production deployments (I'm the only user so far)
  - Connectors for consumers to immediately connect to (i.e clickhouse, elastic search etc)

The cost model is what motivated this. Kafka's storage costs scale with replication factor × retention × volume. With S3 at $0.023/GB/month, storing a TB of events costs ~$23/month instead of hundreds on broker EBS volumes.
Written in Rust, 15 crates thus far. Apache 2.0 licensed.
GitHub: https://github.com/gbram1/streamhouse
How it works blog on my main website: https://streamhouse.app/how-it-works
Happy to answer questions about the architecture, tradeoffs, or what I learned building this.

value: Show HN: StreamHouse – Open-source Kafka alternative

author: gbram


value: Show HN: Creatomap: Search who knows who and who pays who on YouTube


value:
Hi HN,
I've been building Autopsy, an open-source CLI tool to solve a problem I hate: manually digging through CloudWatch logs during a 3 AM page.
It pulls your CloudWatch logs and GitHub deploys, passes them to an LLM, and returns a structured root cause analysis in your terminal in about 30 seconds.
The early version worked, but the diagnosis vanished the moment you closed your terminal. I just shipped v0.2.2 to make it actually fit into an SRE/DevOps workflow:
Local History: Every run now saves automatically to a local SQLite DB. You can search, browse, and export past incidents (autopsy history list).
Instant Post-Mortems: Passing --postmortem generates a full incident report in Markdown, including a timeline, evidence, and checkbox action items.
Slack Integration: Passing --slack pushes the diagnosis directly to your incident channel via webhook.
You can chain them: autopsy diagnose --postmortem --slack
A big priority here is privacy. It’s built with Python, runs locally, and your logs never leave your machine (aside from the direct payload you choose to send to the LLM).
GitHub: https://github.com/zeelapatel/autopsy
PyPI: pip install autopsy-cli
I'd love for you to try it out. I'm especially looking for feedback on the LLM's diagnosis accuracy across different types of stack traces and log formats. Happy to answer any questions!

value: Show HN: Autopsy CLI – Open-source AI incident diagnosis in 30s


value: psantosl

value:
I generated 2 years of a programmer's life — every hour tracked. His job at a big tech company, a side project that takes off, gym sessions, dinners with his wife, kids, the moment he quits his job to go indie. 4,251 entries.
The CLI is a single binary (no dependencies) that includes a TUI time tracker and a built-in MCP server. Run rows mcp install --demo and you can start asking Claude about this guy's life in 5 minutes.
Try things like:
"When did he quit his job?"
"Show me all dinners with his wife"
"How much time did he spend on his side project last month?"
"Show me a bar chart of gym sessions per month"
It's actually a time tracker I built for myself — I've been logging every hour of my life in spreadsheets since 2014 (44,000+ entries). The demo data is there so you can try it without entering your own data first.

value: Show HN: A fictional programmer's life, hour by hour – ask Claude via MCP

author: psantosl


value: I know, it's a very first-world problem. But in my house, we have a hard time deciding what to watch. Too many options!<p>So I made this to recreate Cable TV for YouTube. I made it so it runs in the browser. Quickly import your subscriptions in the browser via a bookmarklet. No accounts, no sign-ins. Just quickly import your data locally.

value: Show HN: Channel Surfer – Watch YouTube like it’s cable TV


value: theredsix

value:
Hi HN, I forked chromium and built agent-browser-protocol (ABP) after noticing that most browser-agent failures aren’t really about the model misunderstanding the page. Instead, the problem is that the model is reasoning from a stale state.
ABP is designed to keep the acting agent synchronized with the browser at every step. After each action (click, type, etc), it freezes JavaScript execution and rendering, then captures the resulting state. It also compiles the notable events that occurred during that action loop, such as navigation, file pickers, permission prompts, alerts, and downloads, and sends that along with a screenshot of the frozen page state back to the agent.
The result is that browser interaction starts to feel more like a multimodal chat loop. The agent takes an action, gets back a fresh visual state and a structured summary of what happened, then decides what to do next from there. That fits much better with how LLMs already work.
A few common browser-use failures ABP helps eliminate:
* A modal appears after the last Playwright screenshot and blocks the input the agent was about to use
* Dynamic filters cause the page to reflow between steps
* An autocomplete dropdown opens and covers the element the agent intended to click
* alert() / confirm() interrupts the flow
* Downloads are triggered, but the agent has no reliable way to know when they’ve completed
As proof, ABP with opus 4.6 as the driver scores 90.5% on the Online Mind2Web benchmark. I think modern LLMs already understand websites, they just need a better tool to interact with them. Happy to answer questions about the architecture, forking chrome or anything else in the comments below.
Try it out: `claude mcp add browser -- npx -y agent-browser-protocol --mcp` (Codex/OpenCode instructions in the docs)
Demo video: https://www.loom.com/share/387f6349196f417d8b4b16a5452c3369

value: Show HN: Open-source browser for AI agents

author: theredsix


value: senjindarashiva

value:
Hi HN,
I’m a self-coached endurance athlete and long-time user of Intervals.icu. Over the years I’ve gotten comfortable interpreting my own training data (CTL/ATL trends, HRV, fatigue, etc.), but I kept running into a practical problem:
The training plan makes sense when you write it, but real life rarely cooperates.
Bad sleep, work travel, missed workouts, or suddenly having only 45 minutes instead of two hours. In those moments the question becomes: does the planned workout still make sense today?
I built a small tool called PacePartner to help with that:
https://pacepartner.app
The idea is not to replace coaching or generate perfect plans, but to act as a decision layer on top of Intervals.icu.
It connects to your account and reads things like:
training load (ATL / CTL)
HRV / recovery signals
sleep data
planned workouts
upcoming races
You can then ask questions like:
“Should I still do threshold today?”
“I only have 60 minutes — what should I train?”
“I missed yesterday’s workout — how should the week adapt?”
If the workout changes, it can also push the new session back into the Intervals calendar.
What surprised me while building this
Initially I assumed the main challenge would be building a very specialized “AI coach”. In practice the biggest improvement came from simply giving the model good context from the athlete’s actual training data.
Most athletes already have a training plan. The useful part isn’t generating one from scratch — it’s helping adjust it when circumstances change.
Rough architecture
Intervals.icu OAuth integration
Pull training metrics + calendar data via API
Contextual prompt layer grounded in common endurance training principles
Conversational interface (web + messaging)
Still early and very much a work in progress.
Would especially appreciate feedback from:
endurance athletes who use Intervals / TrainingPeaks
people building AI assistants around structured datasets
anyone thinking about AI systems that augment decision making rather than automate it
Happy to answer any questions.

value: Show HN: AI assistant that reads Intervals.icu data and adjusts workouts

author: senjindarashiva


value: iamevandrake

value: Show HN: Opensoul – Open-source agentic marketing stack (6 AI agents)

author: iamevandrake


value: loookas

value: Show HN: Loquix – Open-source Web Components for AI chat interfaces

author: loookas


value:
Thesys just open-sourced their generative UI rendering engine. Interesting timing given where Google a2ui and Vercel's json-render are headed.
The difference worth noting: a2ui and json-render both treat JSONL as the contract between the LLM and the renderer. Thesys is betting that's the wrong primitive. Their engine uses a code-like syntax (OpenUI Lang) instead — LLM writes it, renderer executes it. The argument is that LLMs are fundamentally better at generating code than generating structured data, so you get cleaner output and ~67% fewer tokens.
The broader vision seems to be a model-agnostic, design-system-agnostic layer that sits between any LLM and your actual UI components. You bring your own components and design tokens, the engine handles translating LLM output into rendered interfaces — charts, forms, tables, cards.
Generative UI as a category is still figuring out what the right abstraction is. This is a concrete stake in the ground against JSON-as-spec.

value: Show HN: OpenUI – A code-like rendering spec for Generative UI


value: tgalal

value:
Instead of giving LLM tools SSH access or installing them on a server, the following command:

  $ promptctl ssh user@server

makes a set of locally defined prompts "magically" appear within the remote shell as executable command line programs.
For example, I have locally defined prompts for `llm-analyze-config` and `askai`. Then on (any) remote host I can:

  $ promptctl ssh user@host
  # Now on remote host
  $ llm-analyze-config /etc/nginx.conf
  $ cat docker-compose.yml | askai "add a load balancer"

the prompts behind `llm-analyze-config` and `askai` execute on my local computer (even though they're invoked remotely) via the llm of my choosing.
This way LLM tools are never granted SSH access to the server, and nothing needs to be installed to the server. In fact, the server does not even need outbound internet connections to be enabled.
Github: https://github.com/tgalal/promptcmd/

value: Show HN: Execute local prompts in SSH remote shells

author: tgalal


value: arberx

value:
We couldn't find a good open source solution for this so we built Canonry to monitor how ChatGPT, Gemini, and Claude represent and cite our sites.
It tracks visibility scores, citation-readiness, and brand accuracy across providers over time.
Self-hosted on SQLite, config-as-code in YAML, CLI and API are first-class.
Would love some feedback!

value: Show HN: Canonry – Open-source AEO monitor (track how AI engines cite you)

author: arberx


value:
Hey HN,
I guess this is just another SQLITE editor powered by WASM, I created this to help me write queries faster with AI like we have autocomplete in VS Code. I also added few features which are important to me as data scientist:
Copy results to clipboard, I dont want to always export to excel/csv, sometimes just copy to clipboard is way handier.
Quickly select a table but not all rows
Quickly check number of records in a table
Export a large table to CSV, I have tested a table > 1 M rows, and it could export it all in browser.
Look at historical queries
Added AI to quickly formulate query. You need to add your own API keys.
Functionalities in this editor is more centred around my day-to-day requirements, let me know if you find it interesting. If you use SQLIte in your day-to-day life, I guess this would be helpful.
Its an MIT licensed project, so feel free to explore.
Also, I have partially vibe coded this tool. It is not possible for me to write all the front end code. I have used vanillay JS + Old school bootstrap framework.
Link: https://sql.computelite.com/
Github: https://github.com/airen1986/sqlite-client
Thanks

value: Show HN: Another SQLite editor in browser powered by WASM and AI


value:
We’ve been building GladeKit, an AI agent for Unity game development that works directly inside the editor. Instead of just generating code, it reads the actual project state: scene hierarchy, scripts, selected objects, component values, installed packages, and compiler errors - then takes actions inside Unity.
What it does today:
- 150+ native Unity actions (create prefabs, wire components, configure Animator Controllers, build UI, set up physics, lighting, and NavMeshes)
- Reads real editor context before taking action
- Project-aware modes for Agent, Debug, and Ask workflows
- Turn-by-turn revert and script diff viewer so changes are inspectable and reversible
I started this because most “AI for game dev” tools still leave you doing the actual editor work manually: pasting scripts, assigning references, fixing errors, and clicking through the inspector.
It’s still early, but I’d especially love feedback from Unity developers on where this feels genuinely useful versus where it still breaks down.
Try it here: https://gladekit.com

value: Show HN: GladeKit – AI agent for Unity game development


value: kbigdelysh

value:
Hey HN,
We built RapidFire AI, an open-source framework that lets you compare dozens (or hundreds) of RAG and context engineering configurations in parallel, without needing a GPU cluster.
Tuning a RAG pipeline means experimenting with chunk sizes, embedding models, retrieval strategies, reranking thresholds, prompt schemes, generator models, and more. With traditional tools, you run these sequentially, wait for each to finish on the full dataset, and then compare. That's painfully slow and wastes tokens/compute on configs you'd have killed after seeing the first 10% of results.
RapidFire AI shards your eval dataset and schedules all configs one shard at a time, cycling through them with efficient swapping. You get running metric estimates with confidence intervals in real time, based on online aggregation from the database systems literature. Spot a bad config early? Stop it. See a promising one? Clone it and tweak knobs on the fly, no restart needed.
On a beefy machine you can comfortably run 100+ configs in a single experiment. Want to see it in action without installing anything? We have a Google Colab tutorial that runs 4 RAG retrieval configs in parallel on a free Colab GPU, zero local setup, under 2 minutes to get started. It builds a financial Q&A pipeline on the FiQA dataset, grid-searches over chunk sizes and reranker settings, and shows live metrics with confidence intervals as the configs run. If you're only calling OpenAI or other closed APIs, you don't even need a GPU at all.
Colab: https://colab.research.google.com/github/RapidFireAI/rapidfi...
We'd love feedback on what knobs/integrations matter most to you. Happy to answer questions here.

value: Show HN: Run 100+ RAG experiments in parallel, even on a single GPU

author: kbigdelysh


value: august-

value:
Hi HN, I built Ink, a full stack deployment platform where the primary users are AI agents, not humans.
We all know AI can write code, but deploying them still requires a human to wire it up: hosting, databases, DNS, and secrets. Ink gives agents those tools directly.
The agent calls "deploy" and the platform auto-detects the framework, builds it, deploys it, and returns a live URL at *.ml.ink. Here's a demo with Claude Code: https://www.youtube.com/watch?v=F6ZM_RrIaC0.
What Ink does that I haven't seen elsewhere:
- One agent skill for compute + databases + DNS + secrets + domains + usage + metrics + logs + scaling. The agent doesn't juggle separate providers — one account, one auth, one set of tools.
- DNS zone delegation. Delegate a zone once (e.g. dev.acme.com) and agents create any subdomain instantly — no manual adding DNS records each time, no propagation wait.
- Multiple agents and humans share one workspace and collaborate on projects. I envision a future where many agents collaborate together. I'm working on a cool demo to share.
- Built-in git hosting. Agents push code and deploy without the human setting up GitHub first. No external account needed. (Of course if you're a developer you can store code on GitHub — that's the recommended pattern.)
You also have what you'd expect:
- UI with service observability designed for humans (logs, metrics, DNS).
- GitHub integration — push triggers auto-redeploy.
- Per-minute billing for CPU, memory, and egress. No per-seat, no per-agent.
- Error responses designed for LLMs. Structured reason codes with suggested next actions, not raw stack traces. When a deploy fails the agent reads the log, fixes it, and redeploys autonomously.
Try: https://ml.ink
Free $2 trial credits, no credit card. In case you want to try further here's 20% code "GOODFORTUNE".

value: Show HN: Ink – Deploy full-stack apps from AI agents via MCP or Skills

author: august-


value:
We are Bailey and Robbie and we are working on Klaus (https://klausai.com/): hosted OpenClaw that is secure and powerful out of the box.
Running OpenClaw requires setting up a cloud VM or local container (a pain) or giving OpenClaw root access to your machine (insecure). Many basic integrations (eg Slack, Google Workspace) require you to create your own OAuth app.
We make running OpenClaw simple by giving each user their own EC2 instance, preconfigured with keys for OpenRouter, AgentMail, and Orthogonal. And we have OAuth apps to make it easy to integrate with Slack and Google Workspace.
We are both HN readers (Bailey has been on here for ~10 years) and we know OpenClaw has serious security concerns. We do a lot to make our users’ instances more secure: we run on a private subnet, automatically update the OpenClaw version our users run, and because you’re on our VM by default the only keys you leak if you get hacked belong to us. Connecting your email is still a risk. The best defense I know of is Opus 4.6 for resilience to prompt injection. If you have a better solution, we’d love to hear it!
We learned a lot about infrastructure management in the past month. Kimi K2.5 and Mimimax M2.5 are extremely good at hallucinating new ways to break openclaw.json and otherwise wreaking havoc on an EC2 instance. The week after our launch we spent 20+ hours fixing broken machines by hand.
We wrote a ton of best practices on using OpenClaw on AWS Linux into our users’ AGENTS.md, got really good at un-bricking EC2 machines over SSM, added a command-and-control server to every instance to facilitate hotfixes and migrations, and set up a Klaus instance to answer FAQs on discord.
In addition to all of this, we built ClawBert, our AI SRE for hotfixing OpenClaw instances automatically: https://www.youtube.com/watch?v=v65F6VBXqKY. Clawbert is a Claude Code instance that runs whenever a health check fails or the user triggers it in the UI. It can read that user’s entries in our database and execute commands on the user’s instance. We expose a log of Clawbert’s runs to the user.
We know that setting up OpenClaw is easy for most HN readers, but I promise it is not for most people. Klaus has a long way to go, but it’s still very rewarding to see people who’ve never used Claude Code get their first taste of AI agents.
We charge $19/m for a t4g.small, $49/m for a t4g.medium, and $200/m for a t4g.xlarge and priority support. You get $15 in tokens and $20 in Orthogonal credits one-time.
We want to know what you are building on OpenClaw so we can make sure we support it. We are already working with companies like Orthogonal and Openrouter that are building things to make agents more useful, and we’re sure there are more tools out there we don’t know about. If you’ve built something agents want, please let us know. Comments welcome!

value: Show HN: Klaus – OpenClaw on a VM, batteries included


value: debarshri

value: Show HN: Rewriting Mongosh in Golang Using Claude

author: debarshri


value: IMAYousaf

value:
I* have been following the situation in the Middle East closely over the past months and realized I was spending a lot of time just trying to figure out what actually happened where. Most sources either show raw social media posts or mix combat events with general news.
The closest thing to what I wanted is Liveuamap, but it has increasingly become a general news aggregator. The map includes protests, political statements, weather alerts, and unrelated incidents. There are also intrusive ads and the sources are often just reposted tweets without much verification or analysis.
I wanted something more focused. Specifically a map that only tracks combat events and shows the actual evidence when possible.
So I built Defogwar:
https://www.defogwar.com/
It is an interactive Mapbox GL globe where military events such as airstrikes, drone strikes, artillery, ground assaults, and territorial changes are plotted geographically. Events are color coded by faction. There is a timeline slider so you can scrub through time and watch how things unfold day by day. Clicking a marker opens details about the event along with embedded video when footage exists.
The goal is simple: no political commentary pins, no news ticker spam, just combat events with sources.
The most interesting part technically ended up being the data pipeline.
Manually curating conflict events does not scale when you are one person, so I built an ingestion layer that pulls from RSS feeds and Telegram channels. The content is passed through Gemini 2.0 Flash which extracts structured fields such as coordinates, event type, factions involved, and severity. Everything then goes into a review queue.
Nothing goes live automatically. Every event still goes through manual review before it appears on the map.
The hardest problem has been filtering propaganda from the AI extraction step. A lot of the best footage actually originates from highly opinionated (or biased depending on your perspective) sources, which means the text surrounding it can contain language like “terrorist state” or exaggerated claims about damage. I often have to manually strip that language and normalize the description so the map remains factual.
Another challenge has been extracting reliable coordinates. Many posts reference places indirectly or only mention nearby towns. I ended up building a geocoding layer to resolve these into coordinates before review.
Current stack:
Next.js 14
PostgreSQL with PostGIS for spatial queries
Mapbox GL for the globe visualization
Cloudflare R2 for video storage (zero egress fees made this practical)
Railway for hosting
Right now the coverage is focused on the Iran conflict. I had other conflicts mapped earlier but temporarily removed them to focus on improving the data quality and pipeline first. Once the ingestion process is more reliable those will come back.
Long term I am also interested in mapping historical conflicts using the same timeline interface. I have found aggregators of historical events like WWII and the Vietnam War etc.
I would love feedback on the map UX. If anyone here works with OSINT data or knows good open sources for verified conflict reporting I would be very interested to hear about them.
*I helped with deployment and some UI refinement. My colleague did the heavy lifting on the engineering and data pipeline. He will be in the comments later. Thanks for considering this!

value: Show HN: I built an interactive globe for verified combat events

author: IMAYousaf


value:
I built an Android app called Bingo Caller Pro to replace the physical bingo/tambola cages and paper cards that people use at family gatherings and small events.
The idea was to turn a phone (or TV) into a self-contained bingo host setup.
The host device runs the caller and board display, and players can join by scanning a QR code that opens a digital bingo card in their browser. Each card has a short ID so the host can quickly verify wins.
A few features it ended up with:
* TV mode so the board can be cast to a large screen
* QR-based lobby that generates unlimited 75-ball or 90-ball cards
* built-in voice callers that automatically announce numbers
* quick win verification using a 5-character card ID
* a few fun soundboard effects for when someone wins (or falsely claims bingo)
The caller itself runs fully offline, so it works well in cottages or community halls with weak internet. Players only need connectivity once to load their digital card.
It started as a small side project for hosting game nights but turned into a pretty polished bingo caller.
If anyone is curious about the implementation or has ideas for improvements, I’d love feedback.
Play Store:
https://play.google.com/store/apps/details?id=com.bingosurf....

value: Show HN: Bingo Caller Pro – a digital BINGO experience


value: vkuprin

value:
I built Site Spy after missing a visa appointment slot because a government page changed and I didn’t notice for two weeks.
It watches webpages for changes and shows the result like a diff. The part I think HN might find interesting is that it can monitor a specific element on a page, not just the whole page, and it can expose changes as RSS feeds.
So instead of tracking an entire noisy page, you can watch just a price, a stock status, a headline, or a specific content block. When it changes, you can inspect the diff, browse the snapshot history, or follow the updates in an RSS reader.
It’s a Chrome/Firefox extension plus a web dashboard.
Main features:
- Element picker for tracking a specific part of a page
- Diff view plus full snapshot timeline
- RSS feeds per watch, per tag, or across all watches
- MCP server for Claude, Cursor, and other AI agents
- Browser push, Email, and Telegram notifications
Chrome: https://chromewebstore.google.com/detail/site-spy/jeapcpanag...
Firefox: https://addons.mozilla.org/en-GB/firefox/addon/site-spy/
Docs: https://docs.sitespy.app
I’d especially love feedback on two things:
- Is RSS actually a useful interface for this, or do most people just want direct alerts?
- Does element-level tracking feel meaningfully better than full-page monitoring?

value: Show HN: I built a tool that watches webpages and exposes changes as RSS

author: vkuprin


value: chaokunyang

value:
Apache Fory Schema IDL is the first cross-language schema that treats object graphs (shared refs, cycles, polymorphism) as a first-class contract and still generates idiomatic domain models.
1. `ref` encodes shared identity/loops in the schema (weak refs supported) — no manual ID stitching
2. `union`/`any` give reusable polymorphism; same semantics across Java/Python/Go/Rust/C++/C#/Swift
3. Generated types are real domain models (POJOs, dataclasses, structs, enums), not transport wrappers
4. Compatible evolution: field-id matching, defaults, unknown-field skip
5. One `.fdl` → compatible bytes across all supported languages
Try it in 60 seconds:
```bash
pip install fory-compiler
foryc ecommerce.fdl \<p><pre><code>  --java_out=./java --python_out=./python --go_out=./go \

  --rust_out=./rust --cpp_out=./cpp --csharp_out=./csharp --swift_out=./swift</code></pre>
```
Shared-identity round-trip (Java):
```java<p>OrderBatch restored = OrderBatch.fromBytes(new OrderBatch(first, second).toBytes());<p>assert restored.getOrders().get(0).getCustomer() == restored.getOrders().get(1).getCustomer();<p>```
Feedback welcome: where do object graphs bite you today? Try `foryc --emit-fdl` on a `.proto` / `.fbs` and tell me what feels off.

value: Show HN: First IDL for Object-Graph Serialization (Apache Fory IDL)

author: chaokunyang


value: baetylus

value:
Hey HN,
This is a local CLI that translates every push into product updates.
They're logged on Debrief (link is available on repo), but you can ostensibly change it to wherever.
I built this as a first-step to helping engineers communicate work real-time. I'm aware many companies have built-in pipelines, but was hoping that this could bridge the gap between what was planned and what was done (e.g. the trade-offs and granular decisions made).
Hope some folks find it useful! -Will
BTW - you can use `local` mode on this, so that you run a script on every push to summarize with your own AI scripts, in case you need anything bespoke.

value: Show HN: open source, local CLI that turns your commits into product updates

author: baetylus


value: genedai

value:
Hey HN,
I run a recruiting AI startup, and the thing that keeps blowing my mind is how
much money companies dump into sourcing tools, ATS platforms, employer branding —
then turn around and publish a job description that reads like it was written by
a committee in 2014.
We kept seeing the same patterns. "Competitive salary" (translation: we don't
want to tell you). "Fast-paced environment" repeated four times (translation:
we're disorganized). Forty-seven bullet points under Requirements (that's not
a JD, that's a CVS receipt).
So I built JD Roast. You paste in a job description, it tears the thing apart
across six dimensions — clarity, honesty, inclusivity, attractiveness, structure,
and conversion — gives you a score out of 100, and roasts each section with
specific suggestions on how to fix it.
The tone is sharp on purpose. We tried a "professional report" version first.
Nobody read it. Nobody shared it. Turns out people actually engage with feedback
when it stings a little.
Some stuff it catches that I think is genuinely useful:
- Requirement inflation ("8 years of Kubernetes" when K8s launched in 2014)
- Gendered language patterns that shrink your applicant pool without you realizing
- The word "synergy." Just... no.
- Missing salary info — which, depending on the state, might actually be illegal now
No login needed. No email wall on the core roast. We gate the full rewrite
behind an email because yes, we're a startup and we need leads — but the roast
itself and the score are completely free. Not "free trial" free. Actually free.
Some context on the tech: it's not just "throw the JD at GPT and see what
comes back." Each dimension has its own detection logic — readability scoring,
gendered language pattern matching, salary transparency signals, requirement
inflation heuristics, etc. The LLM handles the commentary and rewrite, but the
scoring rubric is deterministic.
Try it: https://jd-roast.openjobs-ai.com/
Things I'd love to hear from y'all:
1. If you've written JDs before — does the rubric make sense? Are we weighting
   the right stuff?
2. Is the roast tone too much, or about right? We're going for "brutally honest
   friend" not "mean for no reason."
3. Missing dimensions? I've been debating adding "Remote Clarity" — whether
   remote/hybrid/onsite is actually stated clearly. Seems important in 2026.
Happy to go deep on any technical questions or talk about the recruiting industry
if anyone's curious. I spent years at Boss Zhipin in China (went from 50M to
200M users while I was there) so I have some scars and opinions on two-sided
marketplaces.

value: Show HN: JD Roast – Paste a job description, get it brutally roasted

author: genedai


value: meub

value: Show HN: KnowledgeWorker – A Corporate Productivity Simulator

author: meub


value: Reqeique

value:
I kept losing track of what my agents were doing. Most agent tooling is either fire-and-forget (kick off a run, hope it works) or full orchestration frameworks that assume you want a DAG. I wanted something in between: treat agent tasks like scheduled work, see where agent time actually goes, and get lifecycle visibility without wiring up a whole observability stack.
Kronos is a self-hosted dashboard + CLI bridge for scheduling agent tasks and tracking them through:
SCHEDULED -> DISPATCHED -> IN_PROGRESS -> COMPLETED / FAILED / TIMED_OUT
Tasks render as time blocks in a day/week/month calendar view (using Schedule-X), so you can see agent utilization at a glance — like a shared team calendar, but for your agents.
How it works:
1) Create a task in the dashboard — assign an agent alias, set a schedule (one-shot or cron), timeout, execution mode.
2) Workers poll or stream tasks via /api/bridge/tasks (streamable HTTP or polling fallback).
3) The `kronos` CLI bridge runs locally, picks up tasks, and sends lifecycle events back as the agent executes.
4) Dashboard updates in real-time over SSE.
A few details HN might care about:
- "@ file mentions" in task prompts — autocomplete against your project files in the UI, with CLI-side mention preprocessing that resolves @path/to/file before the prompt hits the agent. Scoped to a configurable working directory.
- Auth is per-alias — bridge tokens are minted per agent, so workers are scoped to their own task queue.
- No vendor lock-in on the agent side — Kronos doesn't care what model or framework your agent uses. The CLI bridge speaks a simple lifecycle protocol (ACP events over stdio).
- ~30k LOC, Next.js + TypeScript + Prisma. Self-hosted, single `npm run dev` to start.
What's missing (and I know it):
- No cross-process deduplication yet — if two watchers claim the same alias, you can get double execution.
- No per-agent concurrency limits or rate shaping.
- No retry/dead-letter for failed deliveries.
- The mention picker UI is functional but basic — no fuzzy ranking or keyboard navigation yet.
Asking genuinely:
- If you run agents on a recurring basis, how do you track what ran and when? Curious if the calendar metaphor resonates or if a log/timeline view would be more natural.
- Is self-hosted-only the right call, or would a hosted option matter for adoption?
Repo:
https://github.com/Reqeique/Kronos

value: Show HN: Kronos – A calendar-style scheduler for AI Agents agent runs

author: Reqeique


value: bneb-dev

value:
Hey HN,
I wanted to try mapping telemetry ingestion to the bare metal. What started as an exploratory project turned into an explorartory product (maybe). I built aacyn, a single-binary engine that drops onto a $600 consumer Mini PC and confortably ingests and queries 5 million events per second without a cloud cluster.
Some info about how it works:
- the memory model: It writes directly to a file-backed mmap ring buffer using a strict Structure-of-Arrays (SoA) layout. You get a fixed disk footprint, safe wrap-arounds, and zero GC pauses.
- vectorized queries: Full-table scans are natively executed in C using AVX-512 SIMD instructions (~286μs to scan 5M events).
- drop-in ingestion: It speaks native OTLP (port 4318) via a lightweight FFI bridge. No custom SDKs—just point your existing OpenTelemetry collector at it.
- declarative filtering: A TOML file compiles into binary C-structs to drop noise or rollup metrics directly during the ingestion loop with virtually zero overhead.
ok, so as for the business the model:
The core engine, the unthrotttled 5M event/sec throughput, OTLP ingestion, and a local WebGPU dashboard are 100% free for individual developers.
Then if you want to use it for a team, hooking it into your central Grafana instance, enabling Linux eBPF auto-discovery, or streaming cold-storage backups to S3/R2—there's a $4/month license key (for now).
This (I hope) funds my time maintaining the enterprise features without artificial capacity limits.
You can spin it up in a few seconds:
curl -sSL https://aacyn.com/install.sh | bash
We just had a sprint from version 0.5 to 0.7 overnight, so there might be some small bugs. Feel free to email feedback@aacyn.com
Thanks

value: Show HN: Aacyn v0.7.0 – A bare-metal observability engine (5M events/SEC)

author: bneb-dev


value: Show HN:Nono-Cowork:Self-hosted AI agent with file sync to your local machine


value: ybouane

value:
I’ve been experimenting with agent frameworks like OpenClaw recently and wondered how useful that model could be for ecommerce workflows.
A lot of Shopify tasks are repetitive: generating product descriptions, monitoring inventory, sending reports, tagging products, etc. In theory, agent-style systems could automate a lot of that.
The problem I ran into is that most agent frameworks are developer tools, and wiring them directly to a live store API feels risky. You don’t really want an unconstrained agent making arbitrary API calls.
So I built Clawly, which is basically an AI assistant system designed specifically for Shopify stores.
Instead of giving an agent full access, each assistant has scoped permissions and can only use the tools you allow (similar to Shopify API scopes). For example:
- an assistant that only generates product descriptions
- one that monitors orders and sends alerts
- one that produces daily sales summaries
Agents can also connect to external tools like Klaviyo, Notion, email, Google services, etc, so they can run automations across systems.
It’s still early but it’s been useful for automating small store workflows.
Curious what people here think about agent-style systems applied to ecommerce operations.

value: Show HN: Clawly – OpenClaw for Shopify Merchants

author: ybouane


value: skykery

value:
Anthropic just launched their official Claude Code Review tool, pricing it at $15–$25 per PR. If your team is shipping 10+ PRs a day, that model scales terribly.
Even before their launch, I was running a custom local Claude agent for my team to review PRs. The feedback was great and it caught real bugs, but the workflow was a massive time sink. I was manually invoking "claude --agent .. branch_name", grab the output, filter it and post the relevant comments.
So I built reviewd to automate the local execution: https://github.com/simion/reviewd
It is a Python-based background daemon that runs on your machine or a VPS.
How it works:
1. It polls GitHub/BitBucket for open PRs.
2. Creates a near-instant git worktree (no re-cloning).
3. Optionally runs your actual local test/lint commands (the AI gets the stdout/stderr).
4. Pipes the context into the Claude, Gemini, or Codex CLI you already have installed.
5. Parses the JSON output and automatically posts structured inline and summary comments to the PR via Github/Bitbucket API.
The Echo Chamber Problem:
Besides avoiding the $15/PR extortion fee, there's a technical reason to run this locally: avoiding the AI echo chamber. If your devs are using Claude to write the code, using Claude to review it means it's grading its own homework and shares the same blind spots. Because reviewd is model-agnostic, you can write with Claude, but configure the daemon to use Gemini or Codex for the review to get a true second opinion.
Under the hood:
- Uses thread-safe SQLite in WAL mode to track state so it never double-posts.
- Runs fully headless (systemd ready, no TTY needed).
- Tool execution is sandboxed depending on the CLI (e.g., Claude's --disallowedTools Write,Edit).
It completely fixed the PR bottleneck for my team without adding another paid third-party CI integration.
Repo is here: https://github.com/simion/reviewd
Would love to hear your thoughts, or if you spot any edge cases I missed.

value: Show HN: Reviewd – A free, local alternative to Claude Code Review(no API costs)

author: skykery


value: fuelingcurious

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

value: Show HN: I built a refinery simulator game to explain job to my kids

author: fuelingcurious


value: AskCarX

value: Show HN: AgentSign – Zero trust for AI agents (OWASP-aligned)

author: AskCarX


value: ticktockten

value:
I built Rust extensions for Axolotl that dramatically speed up data loading and preprocessing for LLM fine-tuning.
The problem: Python data pipelines become the bottleneck when fine-tuning large models. Your GPUs sit idle waiting for data.
The solution: Drop-in Rust acceleration. One import line, zero config changes.
Results on 50k rows:
 - Streaming data loading: 0.009s vs 0.724s (77x faster)
 - Parallel SHA256 hashing: 0.027s vs 0.052s (1.9x faster)
Works with Parquet, Arrow, JSON, JSONL, CSV. Supports compression. Cross-platform.
Usage:
import fast_axolotl
import axolotl  # now accelerated
pip install fast-axolotl
Built with PyO3 and maturin. MIT licensed. Happy to answer questions about the Rust/Python interop or benchmark methodology.

value: Show HN: Fast-Axolotl – Rust extensions that make Axolotl fine-tuning 77x faster

author: ticktockten


value:
Hello HN, we are thrilled to announce that we are now launching the Beta Version of XenevaOS as a sandbox next month. For the first time, you’ll be able to experience our Free & Open Source Operating System that has been written with a custom kernel from the ground up for XR.
The finished version of the Operating System is targeted to run on XR (AR/VR/MR) devices natively in a standalone manner. The main advantage of our OS is the fact that since it has a custom kernel specifically written for XR, it is able to achieve very low latency and is optimized for target hardware. It will be able to run efficiently on minimal hardware resources.
One of the ways we're making this possible is by minimizing abstraction layers.
Due to limited server access, user slots are also limited in the initial rollout.
Register through the following link to be among the first to test the Beta next month - https://explore.getxeneva.com/
If you want to look at the codebase, you can also go through our GitHub Repository - https://github.com/manaskamal/XenevaOS

value: Show HN: Launching Our XR-Native Operating System


value: linggen

value:
Linggen is an open-source agent system where agents, skills, and scheduled missions are all markdown
  files. Drop a .md file, get a new agent.

  - Multi-agent — agents delegate to each other, run concurrently. Message a running agent mid-task and it
  adapts (cooperative interruption)
  - Any model — Ollama, OpenAI, Claude, Bedrock, any OpenAI-compatible endpoint. Route per agent with
  auto-fallback
  - Skills as files — portable Markdown skills, compatible with Claude Code and Codex (Agent Skills
  standard)
  - Scheduled missions — cron-based autonomous tasks without human-in-the-loop
  - Web UI + TUI + VS Code — all share real-time session state via SSE

  Rust backend (axum, tokio, ratatui). React 19 frontend embedded via rust-embed. Native tool calling for
  all major providers. Workspace-scoped file ops with per-agent permissions.

  Early stage. The name 灵根 (Líng Gēn) means "spiritual root" in cultivation fiction — the innate
  foundation that determines what you can become.

  GitHub: https://github.com/linggen/linggen

  curl -sSL https://linggen.dev/install.sh | bash && ling

value: Show HN: Linggen – Open agent system in Rust, any model, file-based

author: linggen


value: TheAntiEgo

value:
Hey HN. I'm building SuperDebate. The basic idea is that millions of adults did competitive debate in school and there's nothing for them now. No leagues, no local clubs, no way to compete. We're trying to fix that.
We built a platform where you can run structured debates with assigned sides. That's the key piece. You don't argue your opinion. You get assigned a position and have to make the best case for it. It changes the whole dynamic.
I coached in the Chicago Urban Debate League years ago. My students were the first national champions from an urban debate league. I've been thinking about how to bring that format to adults for a long time. We've been running events in Chicago and just ran our first international tournament in Honduras. Now we're expanding to other cities.
The way it works: a local host picks a topic, we provide the format and platform, people show up and debate. We're looking for people who want to run one in their city. If you've ever wanted to do something more structured than arguing on the internet but didn't know where to start, that's what we're building for.
Would love feedback on the product. And if you're interested in hosting a debate locally, reach out. superdebate.org

value: Show HN: Making Debates Great Again

author: TheAntiEgo

title: Show HN: Making Debates Great Again


value:
Hi HN,
I've been building Slate for the past few months and just open-sourced it. It's a native macOS app that puts AI chat and web browsing in the same window.
The idea came from how I actually use AI day to day. I'd ask Claude or GPT something, get a bunch of links or recommendations, then cmd-tab to a browser, open tabs, lose context, and go back and forth. It felt broken. I wanted the browser inside the AI conversation, not the other way around.
So Slate is an AI workspace first, browser second. You ask a question, get a synthesized answer, click into sources right there in the same session, and keep asking follow-ups with full context. Each tab has its own conversation history.
A few things that might be interesting to this crowd:
- Native SwiftUI + WebKit, no Electron. Runs light on memory and battery on Mac. Downside: it's MacOS only, but it's the choice i took to create best possible UI and the user experience.
- Most other "AI Browsers" bolt AI onto the chromium as an after-thought, but I wanted to build AI-first experience.
- Supports Anthropic, OpenAI, Gemini, and Ollama for local models. Bring your own API keys.
- Built-in content blocking, so pages load fast and clean.
- Sessions group your tabs into workspaces you can archive and restore.
- MIT licensed.
It's very much a v1. There's plenty I want to improve — extensions, better history, sync, AI Agents, MCPs, etc. — but the core loop of chat → browse → follow up feels solid enough to share.
Repo: https://github.com/slate-ai/slate
Download (.dmg): https://github.com/slate-ai/slate/releases/download/v1.0.0/s...
Would love feedback, especially from anyone who's worked with WebKit or has opinions on how AI should integrate with browsing. Happy to answer questions about the architecture or anything else.

value: Show HN: Slate – Open-source AI workspace with a built-in browser


value: logicallee

value: Show HN: Prompt Engineering GUI – Become an Expert Fast

author: logicallee


value: harvenstar

value: Show HN: AgentClick – Human-in-the-loop review UI for AI coding agents

author: harvenstar


value: ffsoftboiled

value: I started adding music that I discovered on Spotify, but wanted to fight the algorithm and make my own memories and playlists. Almost ten years later it's an autographic audio memory vault.  No framework, no database

value: Show HN: My 9-year, 4,500-song manual music archive (2017–2026)

author: ffsoftboiled


value: Show HN: subagent-reuse – MCP that stops Claude Code subagents re-reading files


value: ericciarla

value: Show HN: A CLI to scrape, search, and interact with the web for AI agents

author: ericciarla


value: novateg

value: Zeta was built for one simple reason: Social media should not control the narrative. Algorithms shouldn’t manipulate opinions. Platforms shouldn’t silence people. Zeta is a non-biased social network where ideas compete freely. No political agenda. No shadow banning. Just open conversation. Welcome to the reset. Website: meetzeta[dot]com

value: Show HN: Social Media, Reset

author: novateg

title: Show HN: Social Media, Reset


value: shalinshah

value:
Hey HN, we're building Hyper: an iOS voice recorder for the conversations that matter too much to pause and take notes. 1:1s with your cofounder, coffee chats, standups, whiteboard sessions. One tap to record, and when you're done you get a summary, full transcript, and tappable action items (calendar events, reminders, email drafts) — no notes needed.
We built this because at our last company (a robotics startup), the most consequential decisions happened spontaneously — in hallways, over lunch, on walks. None of it got captured. Every recorder we tried was built for scheduled Zoom calls with agendas. We wanted something for the messy, unstructured conversations where the real work happens.
How it works: Hyper transcribes your conversations in real-time. On-device wakeword detection lets you ask it questions mid-conversation with “hey hyper” or via chat without breaking flow — "wait, what did we decide about the deadline last time?" — and it pulls from every past conversation. After the meeting, another agent extracts structured actions and maps them to the rest of your tools (like Calendar, GMail, and native iOS integrations).
The bet we're making: existing meeting tools stop at "here's a document." We believe people don't want better documents from their meetings, they want answers to their questions.
We envision a future where people can simply ask across all conversations and get the answer instantly — without files or folders or manual organization. We’re building out a long-term memory framework that lets Hyper resolve conflicting information, surface stale information, and help untangle the gnarliest of problems.
We're two founders, currently self-funded, building in SF. We’d love for you to try it out in your next exciting conversation and to hear your feedback. Thanks!
-- Shalin & Kanyes

value: Show HN: Hyper – A stupidly non-corporate voice AI app for IRL conversations

author: shalinshah


value: kulesh

value:
Most UI frameworks solve the wrong problem — they help developers build interfaces faster. DAUB bets on the next problem: AI generating interfaces directly.
The core idea: instead of writing component code, you describe a UI in structured JSON. DAUB renders it. No compilation, no virtual DOM diffing. The spec is the UI.
What shipped so far (v3.13):
- daub.css + daub.js: 76 components, 20 theme families, two CDN links, zero build step
- JSON-Render spec: AI outputs structured JSON, DAUB renders a live interface — already working in the Playground
- 7-stage generation pipeline: analyze → scaffold → generate → selfCheck → verify → repair → visual diff
- 189 pre-made blocks across 34 categories with multimodal RAG retrieval
- MCP server on Cloudflare edge: generate_ui, render_spec, validate_spec, get_component_catalog — any MCP client (Claude, Cursor, custom agents) can generate DAUB interfaces without writing a line of component code
What's coming:
- v3.14: Action bindings — buttons that POST to real endpoints, forms with submit handlers, shareable URLs, version history. Generated UI becomes functional and outlives the session.
- v4.0 (Intent Engine, in progress): "I need to track my expenses" → spending dashboard with charts, filters, input form. Context-aware: location, time, history inform the output.
- v5.0 (Agent Runtime): multi-agent orchestration where one agent fetches data, another picks layout, a third wires actions. The interface is a byproduct of understanding, not a thing you build.
The underlying bet: as AI generates more of the interface layer, value accrues to whoever owns the rendering spec that agents target. DAUB wants that spec to be small, inspectable, text-diffable, and easy for both humans and models to work with — not locked inside a framework.
It's not competing with React or shadcn/ui. It's the layer underneath whatever generates the UI.
Playground: https://daub.dev/playground.html
Roadmap: https://daub.dev/roadmap
MCP server + GitHub: https://github.com/sliday/daub
Happy to get into the spec format, the complexity-routing pipeline, or how the MCP integration actually works.

value: Show HN: Daub – A rendering spec for AI-generated UIs (two files, no build step)

author: kulesh


value:
I built R2 Desk Pro because the Cloudflare R2 dashboard is fine for
one-off tasks but painful for real workflows — bulk uploads, sync
automation, cost visibility, and large bucket navigation across
multiple accounts.
It runs on Windows, macOS, and Linux. Built with Tauri v2 and Rust.
A few things I focused on for the security model:
- Vault-gated access with Argon2id passphrase — no unlock, no R2
  operations
- Credentials stored exclusively in the OS keychain, never in app
  settings
- All R2 requests execute in the Rust backend so secrets never sit
  in browser code paths
- License validated via Lemon Squeezy on activation, then cached
  locally with an offline grace period
On the feature side beyond the basics:
- Resumable multipart uploads with session persistence
- Sync engine with dry-run planning before any destructive operation
- Bucket administration: CORS, lifecycle rules, custom domains,
  event notifications, jurisdiction
- Cost analysis with per-bucket and per-prefix breakdowns
- Live R2 metrics via Cloudflare GraphQL
- Signed URL generation for GET, HEAD, PUT, DELETE
- Cloudflare cache purge from the desktop workflow
Private beta is live at $29. First 100 customers get 25% off with
code R2CONTROL (valid until March 15 23:59 UTC). 250 seats per
platform.
Happy to answer questions about the Tauri/Rust architecture, the
security model, or any of the R2-specific implementation details.
https://r2desk.greeff.dev

value: Show HN: R2 Desk Pro – a vault-locked desktop client for CF R2 (Tauri/Rust)


value: sravyavedantham

value: Show HN: Shadowscan – see what an AI agent can access on your machine

author: sravyavedantham


value: imfavourite

value:
Hi HN,
I built Morpholder after repeatedly running into the same annoying workflow on macOS.
Every time I needed to convert a file I had to open a converter, upload the file, download it again, and move it back to Finder. It always felt unnecessary when I already knew the format I needed.
So I tried a different idea: what if renaming the file actually converted it?
Morpholder watches folders and performs the real conversion when the extension changes.
For example:
favicon.png → favicon.ico
photo.heic → photo.jpg
video.mov → video.gif
video.mp4 → audio.mp3
But it also unlocks some workflows beyond simple conversions:
- Append _nobg to an image → background is removed automatically (uses Apple’s subject detection)
- Rename an image to .txt → text is extracted from the image using Live Text
- Append _min → compress image for the web while preserving quality
- Rename an image to .icns → builds a macOS app icon package
- Append _pages to a PDF → exports each page as high-resolution images
The app runs in the menu bar and processes everything locally.
Curious what the HN community thinks — especially if you have ideas for other suffix-based workflows.
https://morpholder.com

value: Show HN: I built a Mac app that converts files when you rename them

author: imfavourite


value: Mitchem

value:
I've been using Claude Code Max and Codex daily and kept hitting the same problem; AI quickly ships working code that have real issues: logic errors, security gaps, subtle regressions. You catch them in review, fix them, but the agent session has already closed. Doesn't it make sense to have the AI fix its own mistakes
while it still knows why it made them?
Saguaro is a background daemon that reviews AI-generated code and feeds findings
back to the same agent that wrote it. The agent evaluates the critique, it knows why it made those decisions in the first place, and self-corrects what's actually wrong.
The flow: you tell Claude Code to build something. Claude writes code. Saguaro's
stop hook triggers a background review (the user sees nothing). On the next turn, findings come back to Claude. Claude says "I see some issues with my approach, fixing now" and corrects itself. No human typed anything. No blocking.
It uses your existing Claude Code / Codex / Gemini subscription. No API key
needed. No external account. Everything runs locally. The daemon self-spawns on demand and auto-shuts down after 30 minutes of inactivity.
There's also a rules engine for teams that want more deterministic enforcement.
You write rules as markdown files with YAML frontmatter, scoped to specific
file globs. But the daemon works out of the box with zero rules. It reviews like a senior staff engineer: bugs, security, regressions, dead code. The rules engine adds more precision for teams/individuals that need it.
Setup is "sag init" + restart CC + go back to coding. That's it.
Apache-2.0. TypeScript.

value: Show HN: Saguaro: CLI that makes Claude Code fix its own mistakes

author: Mitchem


value:
Hey HN, I'm Zach, founder of Portal.
Portal lets you share a live sandbox browser session as a link.
Try it here: https://www.makeportals.com/try
Instead of asking someone to sign up, install software, or book a demo for user research, onboarding, or sales, you send a link and they interact with the real product in a sandboxed browser environment, then you get session replays.
Each viewer gets a fresh remote browser instance that starts from a defined state (URL, cookies, extensions, local files, etc). Sessions are isolated and expire automatically.
The sessions have configurable guardrails: - disabling buttons - restricting URLs - API rate limits - Time limits
In Watch Mode, an AI Agent with contextual awareness clicks through a demo and explains the product. In Play Mode, users explore a guardrailed session while the AI answers questions.
Portal came from trying to get feedback on a chrome extension I’d built to help people with disabilities control gmail with voice. People were cautious to download it & I kept wishing I could send a browser session with the extension already installed to try safely & an AI to explain async.
Portal grew out of that idea: share an exact browser state where your product works without requiring installs or already logged into demo accounts.
Some early uses: - Getting user feedback on local projects in Claude Code with a temporary links/rate limits - Helping onboard to high friction/integration products like extension/add-ons or code reviewers - Replacing inbound product demos in sales for SMBs by embedding on landing pages or sending to prospects with the AI agent self-serve created - Ending live presentations with a QR code open to a live product environment - PMs sharing prototype links for feedback in slack
Docs: https://www.makeportals.com/docs/mcp
Try in Claude Code: claude mcp add --transport http portal https://mcp-portal-sogv.onrender.com/mcp
OpenClaw: https://clawhub.ai/Zach213/portal
Curious about the browser sessions you’d want to share w/ an AI guide- we’re improving latency of interaction every week & think stateful URLs/shareable product states are the future. Love any feedback as we're early!

value: Show HN: Portal (SPC F25) – Try products with browser session sandboxes


value: shaiunterslak

value: I made this lil app that scrapes your LinkedIn and simulates your career/life as AI continues to advance.

value: Show HN: An app to simulate whether AI will take your job

author: shaiunterslak


value: obaid

value:
Hey HN,
I built MailboxKit because I kept running into the same problem: AI agents need email but existing APIs aren't designed for them.
The typical flow for an agent is: get an email address, send messages, receive replies, and handle threading — all via API, without a human setting things up. Most email services require manual domain verification, complex OAuth, or aren't built for programmatic access from the start.
MailboxKit lets an agent self-register and start sending/receiving in a single API call:
```
POST /api/v1/register
{"name": "My Agent", "owner_email": "you@example.com"}<p>→ {"api_key": "mbk_...", "email": "abc123@agent.mailboxkit.com", "inbox_id": '19999d'}
```
That's it. The agent now has a real email address, can send and receive, and gets inbound messages via webhooks. Threading, read/unread tracking, attachments, and custom domains all work out of the box.
The API docs double as an LLM-readable skill file (mailboxkit.com/skill.md) so agents using tool-use can discover and learn the API themselves.
Currently used by a handful of agents doing customer support, research, and outreach. Would love feedback from anyone building agent infrastructure.

value: Show HN: Email inbox for your OpenClaw agent

author: obaid


value: mkagenius

value:
The combination of a browser, a LLM and a sandbox seems like the perfect turing machine for the AI agent world - it can probably achieve any task there is to automate.
There can be many ways to play around with this combination but using visual workflow and nodes seemed the most intuitive way, so I am building Sandbox Flow.
Later I am planning on adding local LLMs, a playwright and a local sandbox.
Have a look!

value: Show HN: Sandbox Flow – A Playground for Sandboxes

author: mkagenius


value: luftaquila

value:
If you use Claude a lot, you end up checking your rate limit all the time. I got sick of refreshing claude.ai/settings/usage, so I wired up some old-school analog voltmeters and put them on my desk instead. There are apps for that, but I wanted something I could glance at in the real world.
They're 91C4 DC voltmeters, the ones with a needle from old lab equipment. Up to seven. Claude rate limit, CPU, GPU, memory, disk, network - you pick what each one shows.
I vibe-coded the whole thing except the PCB layout with Claude Code. Rust firmware for a CH32X033F8P6 $0.15 RISC-V MCU, Tauri desktop app, OpenSCAD (script CAD) housing you can 3D print. Also made a web tool for designing the gauge face graphics.
Everything is open-source and open-hardware. Firmware, app (macOS/Windows/Linux), PCB design, gerbers, BOM, SCAD/STL files are all in the repo. Order the PCB assembled from JLCPCB, solder wires to the voltmeters, print the housing, and that's it.

value: Show HN: Pointify – DIY Retro analog gauges for system stats and Claude usage

author: luftaquila


value:
The Goal: What are the things that people care most about when buying a car? Turn that into objective truth through data, and make that data accessible for everyone.
However you like to explore information, this site has it.
Aggregated review scores, specs, and safety ratings for nearly 5,000 cars
Curated snapshots of dozens of categories
Entire leaderboards filterable by any metric you can think of
AutosIntelligence AI for quick text-based questions (daily community message limit right now)
Twitter style feeds
Data-backed Articles for leisurely reading
Car vs. Car, Brand vs. Brand comparison tooling
An MCP server to integrate into your own models (upon request)
It's totally free for use. All that I ask is that you provide feedback for what works well, and what doesn't.
If none of this makes sense yet, think of it as basically iMDB or Metacritic for cars.
Hope this helps you in your car buying journey!

value: Show HN: AutosArena – The most complete automotive data platform, available free


value: aceelric

value: Show HN: CAS – I reverse-engineered Claude Code to build a better orchestrator

author: aceelric


value: momentmaker

value:
I built pancakemaker for myself as a dead-simple personal expense tracker that works fully offline and syncs when you're back online.
The core idea: SQLite runs in the browser via WASM as the local store, and Cloudflare D1 handles cloud sync — no traditional backend needed.
The whole stack is serverless-edge (Cloudflare Workers + D1), so it's cheap to run and fast to deploy. I wanted something I'd actually use daily without worrying about yet another SaaS subscription.
Would love feedback on the sync approach and whether the WASM-first architecture holds up in practice.

value: Show HN: An offline-first expense tracker on Cloudflare D1 and SQLite WASM

author: momentmaker


value: timmetime

value:
I've been building Glyphh, a hyperdimensional computing runtime, for two years. This is the first HDC-based entry on the Berkeley Function Calling Leaderboard (BFCL V4), to my knowledge.
The idea: LLMs run at build time to generate intent exemplars. At runtime, function routing is pure HDC vector math — sub-ms, zero tokens, deterministic. Claude Haiku handles argument extraction only. The model code is fully open source.
Results: 74.50% overall (#2 behind Opus), 83.30% agentic (best on board, beating Opus), 88.71% non-live AST (top 3). Total eval cost: $2.08. Opus runs the same eval at $87 (results not yet verified by bfcl team).
The README is transparent about where it struggles (multi-turn: 53.75%) and where the LLM does the work vs HDC. There's also an independent code review in the repo. Happy to answer anything about the architecture (https://glyphh.ai)

value: Show HN: HDC-based function caller ranks #2 on BFCL V4 – $2.08 vs. Opus at $87

author: timmetime


value: floo

value: Show HN: Free audiobooks with synchronized text for language learning

author: floo


value:
I built https://pickmonfans.com/ to document the massive controversy surrounding the new game "Pickmon."
Beyond the surface-level drama, I'm interested in the technical and legal implications of such a release in 2026. How do we define "inspiration" versus "infringement" when assets look this familiar?
The site includes a visual database for side-by-side comparisons and a legal tracker for the ongoing IP debate. Built with Cloudflare's edge stack for speed. Curious to hear your thoughts on the legal future of such projects.

value: Show HN: A crowdsourced wiki tracking design origins in Pickmon


value: chrillemn

value: I am kinda proud of this simple tool - i would love to hear some feedback xD

value: Show HN: VSCode .env Autocomplete

author: chrillemn

title: Show HN: VSCode .env Autocomplete


value: pmdfgy

value:
Initially RebootX was made to connect cloud providers (AWS, GCP, etc.) and dashboard providers (Grafana) to manage these on-the-go. It is very useful, especially in case of emergency.
Then I've added https://github.com/c100k/rebootx-on-prem to connect anything that is "runnable". This natural abstraction helped me integrate the new integration this post is about : Cursor.
This way, we can also manage agents we start from our laptops with our phones. I'll be glad to get your constructive feedback to improve the integration.
Best,

value: Show HN: Manage Cursor agents from your smartphone

author: pmdfgy


value: jochenk

value: Works especially well together with: https://github.com/jkerdels/dew-plugin

value: Show HN: I made a DAG MCP that supports complex tasks in Claude Code

author: jochenk


value: azhtom

value:
Hi HN,
I’m building Chanchito, a simple app that helps people organize their finances in 30 days.
In many countries in Latin America, people don’t really use budgeting apps. Most people track expenses in WhatsApp chats, spreadsheets, notes, or just try to remember where their money went.
The idea behind Chanchito is to make this easier. The focus is not complicated financial planning, but simply helping people understand their money within a month.
You can log income and expenses quickly, organize categories like savings, debt or services, and build a clear view of your monthly finances. You can also register transactions conversationally, including through WhatsApp.
It’s currently available for users across Latin America and I’m starting with Spanish-speaking users.
I’d really appreciate feedback from the HN community, especially from people building products for emerging markets.
https://chanchito.app
If anyone here is also building for LATAM, I’d love to hear about your experience.

value: Show HN: Chanchito, a 30-day system to organize your finances (for Latam)

author: azhtom


value: MegaByteMark

value: Show HN: A Markdown DSL to stop AI agents from hallucinating UI code

author: MegaByteMark


value: mannders

value: Show HN: BSocial – Business-sector social powered by Ethereum

author: mannders