value:
Been running AI agents in production for a while and kept running into the same issues:
controlling what they can do
tracking costs
debugging failures
making it safe for real workloads
So we built AgentRuntime, the infrastructure layer we wished we had.
Not an agent framework, but the platform around agents:
policies
memory
workflows
observability
cost tracking
RAG
governance
Agents and policies are defined in YAML, so it's infrastructure-as-code rather than a chatbot builder.
Example – agents and policies in YAML
agent.yaml – declarative agent config
name: support_agent
model:
  provider: anthropic
  name: claude-3-5-sonnet
context_assembly:
  enabled: true

  embeddings:
    provider: openai
    model: text-embedding-3-small

  providers:
    - type: knowledge
      config:
        sources: ["./docs"]
        top_k: 3

policies/safety.yaml – governance as code
name: security-policy
rules:
  - id: block-file-deletion
    condition: tool.name == "file_delete"
    action: deny
CLI – run and inspect
Create and run an agent
agentctl agent create researcher --goal "Research AI safety" --llm gpt-4
agentctl agent run researcher
agentctl runs watch <run-id>
Manage policies
agentctl policy list
agentctl policy activate security-policy 1.0.0
RAG – ingest docs and ground responses in your knowledge base
agentctl context ingest ./docs
agentctl run --agent agent.yaml --goal "How do I deploy?"
Agent-level debugging
agentctl debug -c agent.yaml -g "Analyze this dataset."
Cost tracking is exposed via the API (per agent/tenant), and the Web UI shows analytics.
The workflow debugger (breakpoints, step-through) lives in the pkg layer; the CLI debug is for agent execution.
What’s in there
Governance
Policy engine (CEL)
Risk scoring
Encrypted audit logs
RBAC
Multi-tenancy
Fully YAML-configurable
Orchestration
Visual workflow designer (React Flow)
DAG workflows
Multi-agent coordination
Conditional logic
Plugin hot-reload
Workflow marketplace
Memory & Context
Working memory
Persistent memory
Semantic memory
Event log
Context assembly combines:
policies
workflow state
memory
tool outputs
knowledge
RAG features:
embeddings (OpenAI or local)
SQLite for development
Postgres + vector stores in production
Observability
Cost attribution via API
SLA monitoring
Distributed tracing (OpenTelemetry)
Prometheus metrics
Deterministic replay (5 modes)
Production
Kubernetes operator (Agent, Workflow, Policy CRDs)
Helm charts
Istio config
Auto-scaling
Backup / restore
GraphQL + REST API
Implementation
~50k LOC of Go
Hundreds of tests
Built for production (in mind)
Runs on:
Local
SQLite
In-memory runtime
Production
Postgres
Redis
Qdrant / Weaviate
Happy to answer questions or help people get started

value: Show HN: Open-sourced AI Agent runtime (YAML-first)


value: CastorLogic

value: Show HN: SignalKit: Real-time audio DSP in pure Swift, zero dependencies

author: CastorLogic


value: Show HN: FetchPrompt – Manage LLM prompts outside your code with a REST API


value:
Detrix is an MCP server that gives AI coding agents (Claude Code, Cursor, Windsurf) a debugger they can control directly. The agent sets observation points on variables in a running process, captures values at runtime, and queries results when ready — no restarts, no code changes at debug time, no print statements.
Here's what that looks like in Claude Code:

  me:    "The order-service is reporting inflated revenue."

  claude: sets observation points on txn.Amount, txn.Unit, total
          → detrix wake order-service:8091
          → detrix observe txn.Amount, txn.Unit, total
          → detrix query_metrics

  claude: "The pricing API changed. It now returns cents for some
           amounts. The code fetches txn.Unit but discards it."

I didn't tell it what to observe. It read the source, picked the variables, watched them live, and found the root cause.
Under the hood it's DAP logpoints — most debuggers can already evaluate expressions without stopping the target. Detrix exposes that over MCP. Pull-based: nothing streams into context, the agent queries when ready.
Overhead is near-zero — logpoints are non-breaking, no pauses, configurable throttling on hot paths. Expression safety layer with allow/block lists prevents accidental exposure of secrets or API keys.
Works locally and remotely — Detrix server runs alongside your service in Docker or on a remote host, so the agent on your laptop observes a process running in the cloud.
Python (debugpy), Go (Delve), Rust (lldb-dap). Ships with a Claude Code skill that makes Claude reach for Detrix before suggesting print statements.
Built this after debugging a trading bot migration where the broker silently changed their price format — the add-prints-restart-wait loop on timing-sensitive code is what Detrix eliminates.
13 Rust crates, 2,300+ tests. MIT licensed. Docker demo with video in `examples/docker-demo/`.
Would love feedback on the DAP approach — are there edge cases in your stack where this would break down?

value: Show HN: Detrix – Give your AI agent a live debugger for running processes


value: Show HN: Persistent Agent Framework – Self-Correcting AI Agents on Claude Code


value: danbitengo

value: Show HN: Oath – prove a human authorized each action before your AI agent acts

author: danbitengo


value: herbstgewinn

value:
Hi HN,
I’m the founder of Lorea (https://lorea.app). It’s a platform that takes dry, heavy study materials (like 50-page nursing or law PDFs) and procedurally generates a playable 3D world out of the concepts.
The Problem:
I realized that traditional studying (staring at text or standard 2D flashcards) completely ignores how human spatial memory works. The "Method of Loci" (memory palace) is proven to be incredibly effective, but building one manually for every textbook chapter is impossibly time-consuming.
How I built it:
I recently sold my V1 of this concept to fully fund this 3D iteration. Here is what is happening under the hood:
Ingestion & Parsing: When a user uploads a PDF, we chunk the text and use an LLM pipeline to extract core entities, hierarchical relationships, and key definitions.
Procedural Generation: Those relationships are mapped into a node-based graph. We use React Three Fiber / Three.js on the frontend to procedurally render 3D islands based on that graph structure. The "parent" concepts become central hubs, and "child" concepts branch out as connected floating islands.
Audio/TTS: I recently switched from ElevenLabs to the OpenAI TTS API to generate the audio voiceovers for the worlds. It cut my text-to-speech costs by roughly 10x while keeping latency low enough for real-time interaction.
Backend: Next.js and Supabase (handling the auth, Postgres database, and Edge Functions for the generation pipeline).
The Hardest Part:
The biggest challenge so far has been dialing in the procedural generation so the 3D worlds don't look like a chaotic mess when a user uploads a densely packed textbook. We had to implement strict clamping on how many "child nodes" can spawn from a single concept before it forces a new level of depth.
A quick heads-up on the landing page: The copy and FAQs on the site are heavily optimized for Gen-Z students and TikTok SEO (which is my actual target market for keeping the server lights on!). You will see things like "Subway Surfers mode" and heavy SEO keywords. But I wanted to share it here specifically to get your feedback on the procedural 3D generation and the Three.js/Next.js architecture underneath all that marketing fluff.
There is a free tier if you want to drop a PDF in and see what it builds. I would love to know what you think of the rendering performance, or if anyone has experience optimizing large-scale procedural Three.js graphs in the browser.

value: Show HN: I built a 3D engine that turns PDFs into playable study worlds

author: herbstgewinn


value:
Hi HN,
I’ve been interested in volume rendering for many years, and once WebGPU became widely available, I wanted to explore how multi-GB volumetric datasets can be streamed and rendered interactively in the browser — without downloading the entire volume up front.
Kiln is a virtualized volume renderer for WebGPU with out-of-core streaming and a fixed VRAM budget.
Many WebGPU volume rendering examples assume the data is compact enough to be downloaded in full before rendering begins and kept fully resident during interaction.
Kiln instead streams multi-GB datasets over HTTP and renders them using a fixed-size GPU page cache and virtual texture indirection. The renderer is fully compute-shader-based and targets WebGPU directly (no WebGL fallback).
Kiln expects the volume to be available as multi-resolution bricks (either preprocessed into its custom format or provided via a chunked format such as OME-Zarr). At runtime, only bricks relevant to the current view are fetched via HTTP range requests, decompressed asynchronously in worker threads, and uploaded to VRAM, while old entries are evicted via LRU.
The logical brick layout is decoupled from physical GPU memory. A compact indirection texture maps logical brick coordinates to atlas slots, and each ray sample resolves this indirection before performing the density lookup inside the brick.
This architecture allows large datasets to become interactive quickly, with a short time-to-first-render and a constant, modest VRAM footprint.
The renderer is format-agnostic. Currently there are two data providers: a simple custom sharded binary format and an experimental OME-Zarr integration, both using the same rendering core.
Happy to discuss architectural decisions or performance trade-offs.

value: Show HN: Kiln – WebGPU-native out-of-core volume rendering for multi-GB datasets


value: stavros

value: Show HN: I made a little voice note recorder

author: stavros


value: taiseiue

value:
I built a browser-based port of fogleman/primitive — a Go CLI tool that approximates images using primitive shapes (triangles, ellipses, beziers, etc.) via a hill-climbing algorithm.
The original tool requires building from source and running from the terminal, which isn't exactly accessible. I compiled the core logic to WebAssembly so anyone can drop an image and watch it get reconstructed shape by shape, entirely client-side with no server involved.
Demo: https://primitive-playground.taiseiue.jp/
Source: https://github.com/taiseiue/primitive-playground
Curious if anyone has ideas for shapes or features worth adding.

value: Show HN: Reconstruct any image using primitive shapes, runs in-browser via WASM

author: taiseiue


value: narragansett

value:
Hi HN,
I built qast because I couldn’t find a tool that “just works” for casting content to a TV. Some TVs support YouTube natively, some do screen mirroring, and only a handful actually show up in Chrome's cast menu. Even when you do get a connection, one TV might accept MKV but not WebM, while another just drops the audio entirely.
qast sidesteps the compatibility problem. It takes whatever you give it -- a local file, a YouTube URL, your desktop screen, a specific window, or a webpage rendered via headless Chromium -- and transcodes it on the fly to H.264/AAC. Because practically every smart TV in the last decade supports this lowest common denominator, it just works.
(Note: You currently need to be running Linux to use it. macOS/Windows support is on the roadmap).
Under the hood:
Written in Python.
Relies on ffmpeg for the heavy lifting (transcoding, window capture).
Uses yt-dlp for extracting web video streams.
Uses Playwright to render web dashboards in a headless browser before casting.
Auto-discovers Chromecast, Roku, and DLNA devices on your local network.
Mostly, I want to get some early feedback. If you have experience wrestling with this problem (especially the endless DLNA quirks) or have ideas for other useful features, that would be fantastic as well.

value: Show HN: Qast – Cast anything (files, URLs, screen) to any TV from the CLI

author: narragansett


value: reflectt

value: Show HN: Reflectt-node – AI agents who built our own task board. Here it is

author: reflectt


value: MaxNardit

value: Show HN: Beetroot – Clipboard manager for Windows with AI transforms

author: MaxNardit


value: ashutoshstark

value: Show HN: VelocityGate – A lock-free app-layer firewall to stop AI scrapers

author: ashutoshstark


value: slpnix

value: Show HN: KrunAI – A CLI tool for running AI agents inside microVM sandboxes

author: slpnix


value: phico

value: Show HN: ChatGPT gets your prompt before you hit send

author: phico


value:
Hi HN,
For the past few months, I’ve been wrestling with a paradox: Individually, AI agents are incredibly fast. Yet, when deployed as a team, organizational throughput often stays flat. We end up acting as "Human Wrappers," manually marshaling data between probabilistic agents.
I decided to treat this as a systems problem, not a management problem. ODL (Organizational Definition Language) is an attempt to bring a "SQL Moment" to agent organizations. Instead of micromanaging how agents work, ODL lets you declare what the structure should be.
Here is a simplified example of an ODL definition orchestrating a self-correcting team with a human-in-the-loop gate:

  approval_gate:
    target: ArchitectureSpec
    approver: CTO
    contents:
      generate_team:
        generator: LeadArchitectAgent
        validators: [SecurityAuditor, PerformanceExpert]
        loop: 3
        inputs: ["BusinessRequirement", "SecurityStandard"]
        output: ArchitectureSpec
        briefing:
          mission: "Design a zero-trust architecture for 10k RPS."

KEY ARCHITECTURAL PILLARS:
1. Functional Core / Imperative Shell: We run probabilistic AI on top of a pure, side-effect-free functional kernel (odl-kernel). It takes the current state (Snapshot) and an event, and calculates the exact next transition without hitting databases directly.
2. Deterministic Convergence: To ensure predictable execution of unpredictable agents, the kernel relies on a deterministic loop:

  for _ in range(self.MAX_ITERATIONS):
      has_change = False
      if self._step_a_transition(...): has_change = True
      if self._step_b_expansion(...): has_change = True
      if self._step_c_dispatch(...): has_change = True
      if not has_change: break # Convergence reached

3. Deterministic Identity: Every node and event is assigned absolute "Space-Time Coordinates" using deterministic UUID v5 generation based on its structural path. Past iterations crystallize into an addressable, immutable history, making the system replayable.
THE "CORTEX" EXPERIMENT:
I am a systems architect/PM by trade. In fact, I have absolutely zero Python programming knowledge. To test my thesis that "if the architecture is rigorous enough, execution becomes purely computable," I spent 40 days defining the core principles and designing over 50 architectural proof patterns (Source-to-IR transformations) in YAML.
I treated the YAML test cases as the absolute law; the AI implementation was rejected repeatedly until it achieved 100% coverage and passed all 50+ structural proof patterns.
I functioned purely as the "Cortex" — defining the Why and the What — while forcing the AI to figure out the How. The result is a fully functional, deterministic Python kernel that passes 100% of its tests. It serves as a physical, verifiable manifestation of the ODL spec.
REPOS:
- L1 (odl-lang) Compiler: https://github.com/co-crea/odl-lang (Apache 2.0)
- L0 (odl-kernel) Execution Engine: https://github.com/co-crea/odl-kernel (BSL 1.1 - Ensuring sustainability for the infrastructure while keeping the language open)
This project is dedicated to the memory of my mentor, Prof. Kazuhisa Seta. He taught me that "structure is the essence of intelligence."
I'd love to hear your thoughts on the architecture, the UUID approach, or the concept of defining organizations as code!

value: Show HN: ODL – Organization as Code. I wrote specs, AI wrote 100% of the code


value: forrestzhong

value:
The USPSTF and ACS publish thorough cancer screening guidelines, but they're dense and scattered across dozens of pages. What you actually need depends on your age, sex, family history, smoking status, and other factors. Most people, including me until recently, simply don't know what they should be getting checked for.
I built FixYou after losing my grandfather to colon cancer that was caught too late. After his diagnosis, my parents went for colonoscopies and found polyps, early and treatable. We didn't lack access to healthcare. We lacked clarity.
FixYou is a free tool that:
1. Walks you through a short AI conversation about your health profile
2. Cross-references your answers against current USPSTF and ACS screening guidelines
3. Gives you a "Shield Score" (0 to 100) and a prioritized list of screenings to schedule
The goal isn't to replace your doctor. It's to prepare you for the conversation, and to be the nudge that gets you to actually book that colonoscopy or mammogram you've been putting off.
March is Colorectal Cancer Awareness Month, which felt like the right time to share this.
Would love feedback on the scoring logic, the screening recommendations, or anything else. Happy to answer questions about the approach.

value: Show HN: FixYou – AI tool that tells you which cancer screenings you need

author: forrestzhong


value: jrswab

value: Show HN: Axe – A CLI for running single-purpose LLM agents

author: jrswab


value: Show HN: PrecisionAudit–An AI copy auditor that actively deletes marketing fluff


value: ontern

value:
Every webhook provider has a different signature algorithm and header format and you
end up rewriting the same verification boilerplate for each one. Tern absorbs that pain.
Zero-dependency TypeScript SDK. Handles signature verification for Stripe, Polar, Clerk, Shopify, Sentry, Grafana and 15+ more. Works with Express, Next.js and Cloudflare Workers.
Also now Tern opens source supports complete inbound webhook event reliability layer including Queuing, retries, deduplication, replay, dead letter queue
and Slack/Discord alerting — all opt-in,

value: Show HN: I got tired of rewriting webhook verification for every provider

author: ontern


value: paolovella

value: Show HN: VellaVeto – Fail-closed runtime proxy for MCP tool calls, in Rust

author: paolovella


value: abhiparuchuri

value:
It's extremely difficult for founders, recruiters and hiring managers to screen their candidates for AI proficiency at scale.
That's why we built Corepoints. You can create and send OAs where AI usage (with AI chat) is a core metric.
You have full control of the testing environment: hallucinations, data leakages, LLM behavior + Grade candidates on aspects such as their answer accuracy (of course), prompting quality, reasoning quality, hallucination susceptibility, token usage, and more.
We're currently doing a demo/beta run for about the next month or so that we can iterate off feedback, no payment/commitment required that we can iterate off feedback.
You can request an account here: https://app.corepoints.ai/request-access
All comments, suggestions, and feedback are welcome and much appreciated. You can also reach us at hello@corepoints.ai !!
Thanks everyone.

value: Show HN: Corepoints – Screen Candidates for AI Proficiency at Scale (Demo Run)

author: abhiparuchuri


value: jjuniordev

value:
I’ve always had this small itch where I felt that personal finance apps out there are too rigid, since everyone has varying goals and needs.
The differentiator between this and a chatbot slapped on a finance app is that you can do anything agents are currently capable of doing: perform custom calculations (since the agent has access to a Python env, it can write code and run it itself), create personalised data visualisations, run simulations on your spending patterns, and more.
The project contains a small CLI tool to access Yahoo Finance data, and markdown files to guide its behaviour. You run a coding harness (Claude Code, Codex, etc.) in the project directory so that it can access the CLI and perform file read/write ops to remember your data.
The agent collects your data and preferences at the start (stored locally), and then you can do whatever you want from there.
Github Repo: https://github.com/junnjiee/finance-agent

value: Show HN: Use Codex/Claude Code as your personal financial assistant

author: jjuniordev


value: jonesatrestdb

value: A React + Codehooks.io template where you define your app's data model as JSON and get auto-generated forms, lists, relationships, lookups, auth, and API docs.

value: Show HN: React admin dashboard template that generates UI from a JSON schema

author: jonesatrestdb


value:
Hey HN,
A fun weekend project: https://www.modembin.com
It's a pastebin, except text/files are encoded into .wav files using real FSK modem audio. Image sharing is supported via Slow-Scan Television (SSTV), a method of transmitting images as FM audio originally used by ham radio operators.
Everything runs in the browser with zero audio libraries and the encoding is vanilla TypeScript sine wave math: phase-continuous FSK with proper 8-N-1 framing, fractional bit accumulation for non-integer sample rates, and a quadrature FM discriminator on the decode side (no FFT windowing or Goertzel), The only dependency is lz-string for URL sharing compression.
It supports Bell 103 (300 baud), Bell 202 (1200 baud), V.21, RTTY/Baudot, Caller ID (Bellcore MDMF), DTMF, Blue Box MF tones, and SSTV image encoding. There's also a chat mode where messages are transmitted as actual Bell 103 audio over WebSocket... or use the acoustic mode for speaker-to-mic coupling for in-room local chat.

value: Show HN: Modembin – A pastebin that encodes your text into real FSK modem audio


value:
I wanted to build a personal finance app where no transaction data ever touches a server. Here's the architecture I ended up with.
The constraint: Two devices need to share an expense ledger, but I don't want to run a database. No Postgres, no Firebase, no Supabase. The user's financial data should never leave their devices.
Storage: IndexedDB only
Every transaction lives in IndexedDB. Schema has 7 object stores — transactions, version history, device identity, pairings, sync state, recurring templates, and alerts. Performance is fine at personal finance scale (thousands of records). I added a simple query cache layer on top to avoid redundant reads — nothing fancy, just memoization with timestamp invalidation.
Sync: WebRTC DataChannel, no relay
Two devices pair using a 4-digit code. A signaling server exchanges ICE candidates and SDP offers — that's all it does. Once the WebRTC DataChannel opens, transactions sync as small JSON payloads directly between devices. The signaling server never sees transaction data.
TURN fallback is there for NAT traversal edge cases, but in practice most connections establish peer-to-peer on the first try.
Conflict resolution:
Both devices can edit the same transaction offline. Every edit creates a version entry. On sync, conflicts resolve using a version vector — latest timestamp wins, but both versions are preserved in history so nothing is lost. Simple but sufficient for a two-device household.
Voice pipeline (the fun part):
Users can speak an expense instead of typing it. Audio goes to a speech-to-text API, then the transcript goes to Gemini Flash with a structured output schema (Zod-validated). It extracts amount, category, payment method, and date from natural language. Accuracy is surprisingly good — the model handles ambiguous input like "lunch with coworkers, split three ways, I paid 1500" correctly.
Curious if anyone has built similar zero-server-DB architectures. How did you handle sync beyond two devices? And would love to hear from anyone who's done WebRTC DataChannel in production — did you end up needing TURN more than expected?

value: Show HN: I built an expense tracker where no data ever touches a server


value: danhergir

value:
I run 3-5 AI coding agents in parallel (Claude Code, Codex, Gemini) and the bottleneck was never the agents, it was managing them. Switching panes, losing track of which agent had which role, re-typing the same setup every time.
Seshions is a terminal UI that gives you one dashboard to launch, route prompts to, and monitor parallel coding agents via tmux. What makes it different from other tmux session managers:
- Blueprints: define a multi-agent team once (planner, builder, reviewer, etc.) and launch the whole group in one action
- Orchestration: dispatch a prompt to a single role, or broadcast to every agent in a group — from one composer
- Works across tools: Claude Code, Codex, Gemini CLI, OpenCode, or any custom shell command
- One command: npx seshions@latest
Demo + repo: https://github.com/danhergir/seshions
Built with Bun + TypeScript. I would love to get feedback on the UX and what workflows you'd want supported.

value: Show HN: Seshions – Orchestrate multi-agent coding agents from one terminal

author: danhergir


value: TylerArrows

value:
I built this after watching the same bug surface in three different IoT projects:
a device sends "offline" then "online" 200ms later, they arrive out of order,
and your system marks a live device dead.
The naive fix is a timestamp check. But timestamps lie — clock drift,
late-arriving packets, firmware bugs. So I built a multi-signal arbitration
engine that weighs event arrival time, signal strength, sequence continuity,
and timestamp plausibility together before committing to a resolved state.
You POST your raw device payload to /v1/sign, then /v1/resolve. You get back
a single authoritative state, a confidence score (0.50–1.0), a recommended_action
enum (ACT / CONFIRM / LOG_ONLY), and a full arbitration trace showing exactly
why it resolved the way it did.
The demo works right now with no signup — just grab the demo key from the landing
page and fire a request. Happy to answer any questions about the arbitration logic.

value: Show HN: An API that resolves conflicting IoT device state in 47ms

author: TylerArrows


value:
I built CoSig because I kept running into the same problem while working with MCP servers: there's no standard way to require cryptographic proof that a human actually authorized what your AI agent just did (or is about to do).
This matters more than it sounds. Your compliance team will eventually ask "who approved the deletion of those customer records?" Your auditors will want to know who signed off on that production deploy. Your incident response playbook assumes a human made a decision somewhere. With vanilla MCP, the answer is "the AI did it because the AI was told it could"... which is not an answer that satisfies a SOX auditor, a HIPAA compliance review, or your own postmortem.
The solution I landed on: WebAuthn co-signing. You put @require_approval() on the sensitive FastMCP tools. When an agent tries to call one, execution blocks, a URL gets surfaced, and the human approves by tapping a hardware security key (YubiKey, etc.) or their device's built-in biometrics (Touch ID, Windows Hello). The signature is tied to that specific request, with a counter that prevents replay and gets stored in an append-only audit log. Then the tool runs.
It's two repos: a lightweight Python SDK (pip install cosig) and CoSig Cloud, a self-hosted Next.js + FastAPI backend you run on your own infrastructure. Nothing phones home. Your audit logs stay yours.
This is alpha, v0.2.0a1. APIs will change and a security review is recommended before production use. But the core flow works and there's a demo linked below showing it end-to-end.
I'd especially like to hear from people building MCP servers for regulated industries, or anyone who's already thought through the "who authorized this AI action" problem and landed somewhere different.
SDK: https://github.com/skyforest/cosig
Backend: https://github.com/skyforest/cosig-cloud
Demo: https://www.youtube.com/watch?v=7AeMJ3ViV5E

value: Show HN: CoSig – WebAuthn co-signing for MCP tool calls


value: AlexDanger

value:
Hi All,
The problem with the modern classroom, as pointed out by Sal Kahn, is that students are forced to spend a fixed amount of time learning a particular topic, and then the whole class moves onto the next topic. It is highly like that a proportion of students will not have gained mastery of basic mathematical skills, making their maths journey increasingly painful until they throw their hands in the air and say ‘I just cant do maths).
I believe AI is one of the most powerful technologies ever invented to assist student learning at each students individual rate. But AI providers generally limit access to students over the age of 13. Neither do they have sufficient mechanisms in place to monitor and redact personally identifiable information that a child uploads, or restrict inappropriate content for this age group.
Wizkid aims to solve these issues.
The end goal here is to create something that uses mastery learning, initially around mathematics. Students should gain mastery over a particular topic prior to proceeding to the next one. If a child is struggling with a problem, the AI should take a step back and try to ensure the child understands the foundational concepts that are required to solve a particular problem.
The tutor will answer questions about all subjects, however upper primary mathematics is the primary focus in this beta release.
Please note this initially this app will be available in Australia. All data is stored in Australia. For ShowHN I am opening this up to most of the world for the sake of feedback. I am following Australian privacy rules, but I can not guarantee compliance with regulations in other countries.
So HN - do your worst! Please use the feedback buttons to add issues. I’ve only allocated a few hundred dollars to the LLM and hosting costs. Please dont go crazy! This is my first ShowHN and first SaaS product. Lots of work to go, but I’d like some feedback on the product itself. I know I’ve got work to do on the legal/liability side.
All data from the beta will be wiped prior to production release. But please dont put anything in there that you consider private. Names are optional and email addresses are not stored in the database, they are managed by Clerk.
I’ve enabled the ability to sign up with temp email accounts during this period. I will cap the number of registrations if I think people are being silly.
I’m looking for feedback on UX, security issues, and of course - the usefulness of the app. Does it help your kid learn and do their homework in a constructive fashion?
 Things I know are problematic:
- My greatest fear is database exfiltration of student chats. I have tried to mitigate that with a quite robust PII detection system. This is a work in progress.
- Sometimes the AI gives the answer instead of guiding the child using the socratic method to find the answer themselves.
- The AI sometimes offers up visualisations that are inappropriate to the age group or the problem at hand.
- The AI can generate images (Nano Banana 2) but I have problems with rate limiting on this model. It will also produce images/diagrams using SVG if you ask it to.
- Most of the content is aimed at upper primary (Grade 4,5,6). 7 and 8 have very early support.
- I dont like my gamification/reward system. I want to incentivise learning and effort rather than just using the system.

value: Show HN: An AI Tutor for Kids with Visualisations

author: AlexDanger


value: fidorka

value: Show HN: MemoryLane – Video as a token-efficient way to analyze user activity

author: fidorka


value: raaymax

value: Show HN: LazyTail – Terminal log viewer with built-in MCP server for AI analysis

author: raaymax


value: mbode

value:
Pricore is a self-hosted private Composer registry for PHP teams. Built with Laravel, Apache 2.0 licensed, and now in public beta.
The problem it solves: managing private packages with VCS repositories in composer.json is slow, Satis requires manual rebuilds, and SaaS options get expensive. Pricore gives you a full Composer v2 registry on your own servers.
What it does:
- Mirrors GitHub/GitLab repos and serves them to Composer
- Webhook-driven updates, no manual rebuilds
- Token-based auth
- Web dashboard for packages, downloads, and activity
- Full Composer v2 metadata-url support
- Up and running in about 60 seconds with Docker.
GitHub: https://github.com/pricorephp/pricore
Blog post: https://pricore.dev/blog/introducing-pricore
Feedback and questions welcome.

value: Show HN: Pricore: an open-source private Composer registry (now in public beta)

author: mbode


value: mnagas

value: Show HN: Blindfold – PII protection for LLM apps (local regex and cloud NLP)

author: mnagas


value: gurachek

value: Show HN: Free tool that scores your interview answers on 4 dimensions

author: gurachek


value:
What if your auth system had no admin override?
I built an authorization intermediary that cannot authorize.
How it works:
• Hashes requests (opaque, can't see payload)
• Forwards to provider (stateless, can't make decisions)
• Provider validates everything (exclusive authority)
The intermediary holds no signing keys. The provider holds the only pen.
Compromise the intermediary = you get nowhere.
200 lines. Zro dependencies. Apache 2.0.
Core- and basic extension demos
Replit.com/@sbw70
Bundled demos
Replit.com/@holiwood4420
Repo
https://github.com/sbw70/verification-constraints/
Run it. Fork it. Fuck it up.
If you can get it to authorize without provider consent, I'd love to see how.

value: Show HN: Auth intermediary that cannot authorize. By design


value: ivanbelenky

value: Show HN: Nbdantic a Humble Pydantic for Notebooks

author: ivanbelenky


value: cnqso

value: Show HN: BloonsBench – Evaluate agent performance on Bloons Tower Defense 5

author: cnqso


value: jmcraft

value:
I built Vocova to solve a workflow I kept running into: you have a YouTube video, a Zoom recording, or a podcast episode, and turning it into accurate, readable text means juggling three different tools – one to download, one to transcribe, one to translate.
Vocova lets you paste a link from 1,000+ platforms (YouTube, TikTok, Zoom, Google Meet, etc.) or upload a file, and get back a transcript with speaker labels, timestamps, and optional translation into 145+ languages – all in one step.
I treat this product like a piece of craft. Every interaction is intentional – the smoothest possible flow from input to output, the highest transcription success rate I can achieve, and a UI that I'd be proud to put my name on. Small things matter: how naturally speaker labels read, how precisely timestamps align with every word, how a bilingual export looks like a polished document rather than a raw data dump.
A few details:
- Speaker diarization with one-click rename and merge
- Bilingual side-by-side view with inline editing
- Export as PDF, DOCX, SRT, VTT, TXT, CSV
- Shareable transcript links – no sign-up required for viewers
Free to start, no credit card required. I'd love feedback on the transcription quality and the overall experience.

value: Show HN: Vocova – Paste a link, get a transcript in 100 languages

author: jmcraft


value: sagiadinos

value:
In 2011 I needed a SMIL-compatible CMS to manage hundreds of IAdea players for
a client. Nothing affordable existed, so I built one commercially. Over the years
resellers started building their own proprietary players instead of paying for
certified hardware. Most failed. So in 2017 I built and open-sourced the media player.
An Android launcher, a proxy, and a CMS followed. The goal: a complete, open digital signage
ecosystem that anyone can run, extend, or contribute to.
What's in the stack:
- garlic-hub: self-hosted CMS for device and content management
- garlic-player: SMIL media player for Linux, Android, macOS, Windows
- garlic-launcher: root-free Android kiosk launcher
- garlic-proxy: proxy for restricted network environments
Live demo: https://garlic-hub.com (login: admin / Demo1234!)
GitHub: https://github.com/garlic-signage
PHP 8.4, PHPStan Level 8, 99% test coverage. All AGPL-3.0.
I'm around to answer questions about SMIL, architecture decisions, or
why open standards matter in digital signage.

value: Show HN: Open-source digital signage ecosystem to escape vendor lock-in

author: sagiadinos


value: Show HN: Run any Google Chrome version(+116) in Docker for web automation


value: sachinneravath

value:
Hi HN,
For the past few months, we've been building Kelviq and it's finally ready to share.
Kelviq is a Merchant of Record (MoR) and monetization platform that you can integrate without building a custom webhook-to-database syncing layer. Along with handling global taxes, checkout, and compliance, it acts as the real-time source of truth for your users feature access and usage credit balances.
Why we built this:
Through our other project, ParityDeals, we saw firsthand how much founders struggle with billing infrastructure. Integrating a payment gateway is easy, but actually building "monetization" is a massive engineering timesink.
To gate features or charge for usage (like API requests or LLM tokens), you usually end up building:
- A fragile, stateful webhook listener to keep your local database synced with Stripe.
- Custom idempotency layers and retry queues for missed events.
- Hardcoded feature flags scattered across your codebase to gate access based on tiers.
- Custom scripts to handle edge cases like upgrades, prorations, and grandfathering legacy users.
Because of this tight coupling, every pricing change, whether it's moving a feature to a new plan or switching from flat-rate to usage-based, requires a database migration and a code deploy.
Our Approach: Entitlement-First
Most billing setups require you to manually bridge the gap between a payment event and your product state. Kelviq simplifies this with an entitlement-first model. You can still use webhooks if you need them, but our SDK allows your app to simply ask Kelviq for a user's current access state at runtime. It eliminates the need to maintain a homegrown subscriptions table just to gate a feature.
How it works:
Zero Webhook Syncing: Stop maintaining a homegrown subscriptions table. Use Kelviq SDK to check if a user has access to a feature before serving the request.
Real-Time Metering: Push usage data to our API at the atomic level (e.g., 1,500 AI tokens). We instantly evaluate it against their tier, deduct from credit balances, or add it to their end-of-month invoice.
Decoupled Pricing: Product and growth teams can change pricing models or tweak overage caps directly in the dashboard without engineers touching the codebase.
We built this to compress weeks of custom billing logic into a few hours of integration. Kelviq also supports multi-currency, built-in PPP pricing (with VPN and proxy protection), and digital product delivery with licensing.
Any feedback is highly appreciated!

value: Show HN: We built a zero-webhook Merchant of Record for SaaS

author: sachinneravath


value: realdanigil

value:
I built GovMatch to solve a problem I kept running into: finding relevant government contracts on governments sites is painful and time-consuming.
GovMatch ingests every new opportunity from SAM.gov (US federal) and TED (EU public tenders) daily. It creates embeddings for each tender, matches them against your business profile using cosine similarity, and sends you a daily email with your top matches.
Stack: Next.js 14, PostgreSQL + pgvector, OpenAI text-embedding-3-small, Prisma, Stripe, Vercel.
Free 7-day trial, no credit card. Would love feedback on the matching quality and UX.

value: Show HN: GovMatch – Daily government contract alerts matched to your business

author: realdanigil


value: david-rodriguez

value: Show HN: I built an AI data analyst that never sees your data

author: david-rodriguez


value: iranu

value: Show HN: ScrapAI – We scrape 500 sites. AI runs once per site, not per page

author: iranu


value:
I'm a developer who spends way too much time in meetings, and most of the time I'm not needed. But I have to stay there half-listening in case someone mentions me. Because of that, I can neither do actual work nor zone out in peace.
I realized I needed a way to safely not care about my meetings. So I built an app.
PingMeBud lets you completely zone out of a meeting and pings you when someone says your name or any keyword(s) you care about. The idea is simple: You join a meeting, hit start, minimize, and go do deep work (or go make coffee). When a keyword is detected, you get a native macOS notification with enough surrounding context to jump back in without looking lost. There's also an optional full-screen red border flash that grabs your attention even if you're deep in another app.
Technical details:
* Uses Whisper (local AI) to transcribe meeting audio purely as a means to detect keywords. Optimized for Apple Silicon (M1-M4).
* Audio captured via ScreenCaptureKit (system audio only, not your mic). You can even have your speakers muted and still get alerts.
* Everything runs locally. Nothing leaves your machine. Transcripts live in RAM only and are wiped when you end the session or close the app.
* No cloud, no accounts, no telemetry.
* Try it free for 7 days, then $29 one-time
* Only network call: a license ping to Polar.sh every 7 days. Between pings, the app can work fully offline.
* Supports wildcard * keyword matching (e.g., meet* for "meeting", "meetings", "meetup”, or *sync for  `async`, `nsync` etc).
* You can also track silences, perfect for when someone asks a question and is waiting for a reply.
* For macOS 12.3+, Apple Silicon required. Made in Electron + React.
It's perfect if you're the kind of person managing lots of meetings, or multiple overlapping meetings (perfect for OE devs).
Happy to answer any questions!

value: Show HN: PingMeBud – A macOS app that listens to meetings so you don't have to


value: sukinai

value: Show HN: Nemp Memory – local project memory that survives tool switching

author: sukinai


value: dlandiak

value: Show HN: TBMQ – Live demo of a high-performance MQTT broker built on Kafka

author: dlandiak


value: Sophify

value:
Hey HN,
For a while now, I've been building a cognitive AI business operating system from the ground up natively as a solo developer. I never coded before 6 months ago. I was frustrated with wrappers and fragile single-agent setups, so I decided to approach this as a distributed systems problem instead. It's called *Sophify*.
Instead of trying to make one monolithic capability do everything, I built a 12-server, 28+ microservice swarm orchestrated by over 40 highly specialized cognitive AI agents.
*Here’s the architecture under the hood:*
*   *40+ Agent Architecture (Model Agnostic):* Decisions aren’t made by a single prompted agent. There is a multi-agent orchestration system that uses weighted voting and consensus across 40+ specialized cognitive agent profiles to synthesize decisions. Crucially, the system is LLM-agnostic—you can plug in whatever LLM you prefer (local or remote) to power the reasoning engines.
*   *The Technician Bot:* Given that this comprises 28+ interconnected microservices running in the cloud.  I wrote a persistent Technician layer. If a node hangs or hits a port collision (hello `WinError 10048`), the Technician detects it, diagnoses the stack, kills zombie processes, reallocates networking, and brings the service back online with zero human intervention.
*   *1,600+ Industry Verticals:* Rather than building general-purpose workflows, the OS comes pre-loaded with state machines and hardcoded context for over 1,600 specific verticals running 1,284 autonomous workflows—handling everything from healthcare compliance to real estate out-of-the-box.
*   *Military-Grade Security & Built-in VPN:* The entire system runs inside an integrated, zero-trust VPN layer with cryptographic audit trails and multi-tenant isolation. Production-ready for DoD contracts, healthcare (HIPAA), and enterprise compliance.
*   *Deep Microsoft 365 Integration:* Full Microsoft Graph API implementation with native access to email, calendar, Teams, OneDrive, SharePoint, and Planner. The system orchestrates across AWS, Azure, and GCP with vertical-specific API frameworks for healthcare EHRs, real estate MLS systems, and finance platforms.
*Why did I build this?*
Started with API keys, ended with self-evolving, self-healing Systems AGI... and I still have to retrieve my own API keys lol. At least the system is fully decoupled, heals its own memory leaks and stalled sockets natively, and scales horizontally.
Happy to answer any questions about the 13-layer self-healing mechanism, managing the websockets across a 12-server swarm without race conditions, or the multi-agent consensus algorithms.
*Serious acquisition inquiries:* sophify-aaron@hotmail.com
Tear it apart. What did I miss?

value: Show HN: I Built Systems AGI – 1600 Verticals, Self-Healing\Self-Evolving

author: Sophify


value: loookas

value: Show HN: Diarize – CPU-only speaker diarization, 7x faster than pyannote

author: loookas


value:
I built a GitHub bot that generates context-aware memes for pull requests.
When a PR is opened, the bot reads the metadata — title, labels, line count, commit messages — and uses AI to pick a meme template and generate a caption that matches the context. It posts the meme as a PR comment. It never accesses your actual code.
Free for public repos. The interesting technical challenge turned out to be prompt engineering for humor — getting AI to be consistently funny in a constrained format is a surprisingly hard problem.
Looking for people to try it and tell me if the memes actually land.

value: Show HN: LGTMeme – AI-generated memes for your pull requests


value: nedcodes

value:
I kept writing Cursor rules that the AI silently ignored. After digging into why, I found a pattern: contradicting directives across files, globs that don't match what you think, YAML frontmatter errors that cause Cursor to skip your rule entirely. So, I built a tool.
npx cursor-doctor scan gives you a health grade (A-F) in 2 seconds. npx cursor-doctor lint tells you exactly what's wrong, file by file. There are 100+ checks so far.
Most of the tool is free (scan, lint, init, migrate). I'd love feedback on what else you'd want checked.

value: Show HN: Cursor-doctor – find out why Cursor ignores your rules

author: nedcodes


value: Show HN: Preventing infinite agent loops with mathematical convergence gates


value: zzx

value:
PTEcorepractice is a practice platform built specifically for the PTE Core exam used for Canadian immigration (IRCC accepted programs).
What it does:
- 700+ real-style PTE Core questions across 12 task types (Speaking, Writing, Reading, Listening)
- Instant AI scoring calibrated to Pearson’s rubric, including pronunciation and fluency feedback
- CLB-focused reporting with an estimated CLB level for each skill and a built-in CLB calculator
- Free daily practice (no credit card required), with optional Pro plan for full access
Why I built it:
When I was preparing my own Canada PR, I couldn’t find a PTE Core practice tool that felt close enough to the real exam. Question banks were messy, “AI scoring” didn’t match official results, and it was hard to see whether I was actually moving toward my CLB targets.
So I built the tool I wished existed: realistic PTE Core questions only, AI scoring tuned to official guidelines, and CLB-oriented analytics instead of vague “percent correct”.
Who it’s for:
- Canada PR applicants choosing PTE Core instead of IELTS/CELPIP
- Test takers who want faster, machine-scored feedback
- People who prefer practicing on desktop or mobile with structured tasks
I’d love feedback on:
- How close the difficulty feels to the real PTE Core
- Whether the AI scoring and CLB estimates match your actual score report
- Any missing features or task types that would make this more useful for serious test takers
You can start a free practice test directly from the homepage.

value: Show HN: PTEcorepractice – Free PTE Core Practice with Instant AI Scoring for PR

author: zzx


value: jetbootsmaker

value:
88% of orgs have had AI agent security incidents, yet MCP servers run broad OAuth scopes with no way to restrict per agent.
After reading about the GitHub MCP exploit I got tired of cobbling together OAuth + custom middleware + prayer. ScopeGate is a permission proxy that sits between your AI agents and external services (Google Drive, Gmail, Calendar, etc).
You connect a service via OAuth, define granular scopes per agent (read-only, specific folders, rate limits), and get a unique MCP endpoint. Agent A can read one Drive folder but not write. Agent B can send email but not read inbox. One click revokes access across all services instantly.
Open-core, self-hostable — same features on cloud and self-hosted.

value: Show HN: ScopeGate – Granular permission gateway for AI agents (MCP, open-core)

author: jetbootsmaker


value: Show HN: AI Home Design – Room redesign and video tour and 3D panorama


value: born-jre

value: Show HN: Potatoverse, home for your vibecoded apps

author: born-jre


value: StephaneBessa

value: Show HN: Kai – macOS native fully autonomous AI agent.

author: StephaneBessa


value: jphorism

value:
I built aside this weekend because I was tired of pasting meeting transcripts into Claude Code myself to get notes that actually connected to my Obsidian vault. Every tool I tried either required an account, sent my audio to a server, or produced summaries disconnected from where I actually think.
aside is a ~5MB Rust binary that records meetings and feeds them into an AI-native transcription-to-vault workflow:
1. Record — captures mic + system audio simultaneously (stereo WAV, left=you, right=them) with a timestamped TUI editor for real-time notes
2. Transcribe — local transcription via whisper.cpp, with a 7-stage cleanup pipeline that strips hallucinations, deduplicates backchannels, and merges fragments
3. Align — interleaves your memo lines with the transcript on a shared timeline, so you can see what was said around each thing you noted
4. Distill — a Claude Code skill searches your Obsidian vault for related notes, then writes a structured note back into it with [[wikilinks]] to your existing thinking
The distillation step is the part I'm most interested in feedback on. The entire pipeline is a 240-line markdown file (a Claude Code "skill") that the LLM follows as instructions. It treats your memo lines as attention signals — what you wrote down mid-call gets priority over what you didn't. Lines you edited mid-meeting get weighted even higher. It searches your vault semantically and by structure (tags, people, wikilinks), then weaves connections into the output note.
The output doesn't read like a meeting summary with action items. It reads like what you would have written up yourself if you had the time — highlighting what mattered to you, connected to what you've already been thinking about.
The skill is plain text. You can read it in the repo, fork it, change how it prioritizes topics or formats notes. There's no black box between the transcript and the vault note — just markdown instructions an LLM follows.
This matters because the workflow is vault-native end to end: sessions live inside the vault, distilled notes land where your thinking already lives, and the AI step uses your vault's own language and structure as context. The meeting note isn't a standalone summary — it's a node in your existing knowledge graph.
Technical details: 3.1k lines total. Rust binary handles recording + TUI (cpal for audio, ratatui for the editor, lock-free ring buffers for real-time capture). Python script handles transcription cleanup. Claude Code skill handles distillation. Everything runs locally except the optional LLM call.
Dual audio capture solves hybrid meetings — conference room mic + remote participants on speaker both get transcribed on separate channels.
No accounts, no telemetry, Apache 2.0. Install via `brew install jshph/aside/aside`

value: Show HN: Aside – Local meeting capture with vault-native AI distillation

author: jphorism


value: fabioperez

value:
Hey HN,
Exodus tracks who's leaving the big AI companies, where they're going, and what they're building. 240+ moves, 80+ companies, every entry sourced.
I used AI to track these after noticing the same pattern every week: someone leaves OpenAI, someone leaves Anthropic, a new startup appears, they get funded week later. A few things stood out:
- Google/DeepMind lost 58 people and got 13 back
- OpenAI alumni founded 18 startups worth $450B+ (TechCrunch calls them "The OpenAI Mafia")
- Half of xAI's co-founding team walked out
- Apple feeds Meta, Meta feeds OpenAI — there's a whole food chain
You can filter by company, role, seniority, or time period. There's a Sankey diagram and a brain drain chart.
The curation pipeline uses the same system I run for https://7min.ai. Every entry is checked against published sources.
Are we missing any patterns?

value: Show HN: Exodus – we tracked 240 moves across companies to map the AI talent war

author: fabioperez


value: persistentVlad

value:
In multi-step tasks, LLM outputs may replace structured intermediate forms with scalar results.
Example:
(2 + 3) * 4  →  20
This removes structural decomposition and makes downstream reasoning dependent on a scalar result.
I built a minimal prototype that enforces admissibility before persistence using a write barrier.
The write barrier separates model output from persistent state.
Core mechanisms:
* Append-only lineage (no in-place mutation)
* Explicit proposal → invariant check → commit cycle
* Whitelisted structural transforms
* Deterministic invariant checks before commit
If a transform attempts to collapse structure (e.g., replacing a decomposed expression with a scalar), the proposal is rejected and never enters the lineage.
Important distinction:
Invalid states may still be representable as data, but they are uncommittable under the governed commit path.
This does not modify the model.
It constrains persistence architecturally around model outputs.
Arithmetic is used purely as a stress-test domain to isolate one narrow claim:
Certain structural collapses can be made impossible to persist.
Limitations:
* Domain-specific invariants
* Not a symbolic solver
* Does not improve model accuracy
* In-memory prototype storage
GitHub: https://github.com/PersistentVlad/persistent-reasoning-archi...

value: Show HN: A Write Barrier That Blocks Structural Collapse in LLM Reasoning

author: persistentVlad


value: plurch

value:
Related Repos helps developers to discover open source projects that are related to each other. This can be useful to find alternative or complementary packages when building a full application. Or you can simply surf around in different neighborhoods to find new ideas that you might not have been aware of.
With the new README badge, project maintainers on GitHub can easily add a link to discover related repositories.
Add the badge here:
https://relatedrepos.com/badge

value: Show HN: Readme badge to quickly find related open source repos

author: plurch


value:
Software makes commitments all of the time. "I won't transfer more than $500," "I'll only access these three APIs," "I won't modify production data." But there is truly no way to verify it actually kept those commitments after the fact. All you do is just trust the logs and which the software itself wrote.
I built Nobulex to fix this. It is open-source middleware that does three things:
1. Lets you define behavioral rules in a simple DSL (permit, forbid, require)
2. Intercepts all actions at runtime and blocks anything that will violate the rules
3. Logs everything in a hash-chained audit trail that anyone can independently verify, not just the operator.
The key insight: you can't just audit a neural network's reasoning, but what you can do is audit its actions against stated commitments. `verify(rules, actionLog)` is always deterministic.

    npm install @nobulex/identity @nobulex/covenant-lang @nobulex/middleware

Three packages, three lines to integrate. The rule language is Cedar-inspired:

    covenant MyAgent {
      permit read;
      forbid transfer where amount > 500;
      require log_all;
    }

Site: nobulex.com | 6,100+ tests across 61 packages. MIT licensed.
I'd love feedback on the rule language — is the permit/forbid syntax intuitive, or would you design the DSL differently?
I'm 15 and built this solo. Happy to answer anything about the architecture.

value: Show HN: I built a way to prove your software kept its promises


value: jithinraj

value: Show HN: Verifiable Interaction Records for Agents

author: jithinraj


value: tikkatenders

value:
Hey HN, I built this because I think $500 for litmus just to check whether my emails would break in Outlook. After Sinch acquired them and pushed prices even higher, I started wondering how much of that could be a library instead of a SaaS dashboard.
Turns out: most of it.
@emailens/engine is a single npm package that runs 8 analysis passes on your email HTML in one call:
1. CSS compatibility: 250+ properties checked against 12 email clients, with per-client scores (0–100). Each warning includes severity, the specific client, and a fix snippet tailored to your framework (React Email, MJML, Maizzle, or plain HTML).
2. Spam scoring: 45+ heuristic signals modeled after SpamAssassin, CAN-SPAM, and GDPR. Catches caps ratio, hidden text, URL shorteners, missing unsubscribe (with transactional email exemption), deceptive links, image-to-text ratio, and more.
3. Accessibility: WCAG contrast, alt text, heading hierarchy, layout table roles, small text, missing lang attribute.
4. Link validation: broken hrefs, insecure HTTP, javascript: protocols, deceptive URLs, empty mailto/tel, generic link text.
5. Image analysis: missing dimensions, oversized data URIs, WebP/SVG in email, tracking pixels, missing display:block.
6. Inbox preview: subject/preheader truncation per client, Gmail clipping detection (102KB threshold).
7. Domain deliverability: SPF, DKIM, DMARC, MX, and BIMI DNS validation. No external dependencies, uses node:dns/promises.
8. Template variables: catches unresolved merge tags across Handlebars, ERB, Mailchimp, Salesforce, etc.
The engine parses the HTML once and shares the DOM across all analyzers, running all 8 checks is basically the cost of one parse.
Framework-aware fixes are where it gets interesting. Every CSS warning comes with a fix snippet tailored to your framework:
React Email JSX → component-level fixes (e.g., VML components for Outlook border-radius)
MJML → <mj-*> element suggestions
Maizzle → utility class alternatives
Plain HTML → inline CSS / VML fallbacks
Fixes are classified as css (simple property swap) or structural (needs HTML restructuring). For structural issues, there's an AI fix layer, the engine builds a context-rich prompt from the warnings, scores, and original source, and delegates to whatever LLM you provide. It's BYOK: you pass a provider function, the engine handles the prompt engineering.
React Email compilation runs in a sandboxed environment (isolated-vm for true heap isolation on servers, node:vm for local/CLI use, or QuickJS via WASM). Maizzle blocks filesystem-accessing PostHTML directives at validation time. MJML uses the standard compiler.
There's also a CSS transformation layer, not just flagging issues, but rewriting the HTML per client. Inlines <style> blocks for Gmail, strips unsupported properties for Outlook, and can simulate dark mode (full inversion for Gmail Android, partial for Apple Mail, none for Outlook Windows).
574 tests covering all of the above. MIT licensed. No accounts, no dashboards, no vendor lock-in.
I'd love feedback on:
The API surface, does auditEmail() (all-in-one) vs createSession() (selective checks, shared parse) make sense as the two entry points?
The scoring formula: 100 - (errors × 15) - (warnings × 5) - (info × 1), too aggressive? Too lenient?
Missing email clients or checks you'd want to see?
Repo: https://github.com/emailens/engine
Docs: https://docs.emailens.dev
If you'd rather not wire it up yourself: https://emailens.dev

value: Show HN: Open-sourced an email QA lib 8 checks across 12 clients in 1 audit call

author: tikkatenders


value: membrshiperfect

value:
Ctrl+P still prints cookie banners, sticky navbars, ads between paragraphs, and floating video players frozen mid-frame. In 2026.
Pooch PDF strips the junk first. It extracts the article content, re-renders it cleanly, and gives you a PDF. One click. Runs in your browser - nothing gets uploaded anywhere.
The paid version ($3/60 days) saves to Google Drive with sensible filenames and generates an AI summary as metadata. The free version just makes clean PDFs. No account needed.
It doesn't work on everything - dashboards, web apps, and hard paywalls are out. It's built for articles and it does articles well.
Named after a dog because it fetches things and brings them back clean.
CWS: https://chromewebstore.google.com/detail/pooch-pdf/[id]
Site: https://poochpdf.com
If it chokes on a page you care about, drop the URL here - genuinely useful feedback.

value: Show HN: Pooch PDF – Because Ctrl+P still prints cookie banners in 2026

author: membrshiperfect


value:
I liked DuckDuckGo's bangs (shortcuts like !g to search Google directly) but didn't want to use DuckDuckGo as my search engine and the bang redirects were slow. Projects like unduck solved this by redirecting bangs locally — but they all load a webpage, execute JavaScript, then call window.location.replace(). Searches had a visible flash before the redirect. Every alternative I've tested — whether it's a page-load redirect, a Cloudflare Worker, or a browser extension — adds measurable latency. I knew a Service Worker could solve this entirely — intercept the request before the browser renders anything. So I built my own tool.
Flashbang intercepts the request at the Service Worker level before the browser renders anything. The SW does a hashmap lookup and a string template fill on raw URL-encoded bytes. Median redirect latency is sub-1ms. The browser never loads a page.
How it works:
- Service Worker intercepts every search request before it becomes a navigation and before page starts loading
- Bang parsing operates on raw encoded strings — no decodeURIComponent, no regex, no new URL() in the hot path
- Supports all 7 DuckDuckGo bang syntax patterns (prefix, suffix, no-space, mid-query, etc.)
- 14,000+ bangs from DDG + Kagi, plus custom bangs
- Address bar autocomplete via OpenSearch with a radix trie, ranked by frecency (exponential decay, 14-day half-life)
- Once the SW is installed, redirects work fully offline
What it's not:
- Not a browser extension — it's a web app you set as your default search engine
- No tracking, no analytics, no telemetry
- Zero runtime dependencies
- AGPL-3.0
~2,600 lines of TypeScript, 1,200 lines of tests. I'd love feedback on the architecture.
https://github.com/ph1losof/flashbang

value: Show HN: Flashbang – Sub-1ms DuckDuckGo bang redirects via Service Workers


value: killix

value:
Orkia is an open-source Rust runtime for LLM agents where policy enforcement, trust scoring, and audit trails are wired into the execution loop at the type-system level.
No code path exists that executes a tool without passing through governance. Fail-closed by default, signed session evidence (ECDSA P-256), and agents that earn autonomy through demonstrated behavior.
Apache 2.0.

value: Show HN: Orkia – a Rust runtime where AI agents can't bypass governance

author: killix


value:
Hey HN. I'm part of the team that built this, though not the engineer behind it. Happy to answer what I can and will loop in the people who built it for anything technical.
The reason we built it: most teams only find out they're running EOL software during a CVE incident or a compliance audit. We kept hearing this problem from customers and couldn't find a tool that clearly answered: which of my dependencies will never get another patch, including the ones your packages depend on?
SCA tools cover known CVEs. They don't cover EOL status or what's coming. That's the gap this is built for.
One thing worth saying directly: HeroDevs is a for-profit company. But part of why we built this is that we think someone needs to be a responsible steward for open source software when maintainers move on. We see this as part of that commitment, not just a product.
Run it with npx @herodevs/cli scan or upload an SBOM on the site (https://eoldataset.com/). Free to use. Curious what you find, especially in ecosystems we haven't covered well yet.

value: Show HN: Eolds, a scanner for EOL open source packages across 12M versions


value: amlug

value: Show HN: Pry – TypeScript compiled to native code, no Electron or V8

author: amlug


value: tigerkid

value: Show HN: I made an AI Agent to dig everything out of your CSV

author: tigerkid


value: Show HN: TeamTalk – Instead of asking one AI, let a whole team debate it


value: cosmicmeta

value:
MoodJot is a mood tracking app I built solo using Kotlin Multiplatform and Compose Multiplatform. It ships on both iOS and Android from a single codebase.
The main differentiator from existing mood trackers (Daylio, DailyBean, etc.) is a community feed where users can share moods and see how others are feeling.
Technical details: - Compose Multiplatform for shared UI (31 screens) - GitLive Firebase KMP SDK for Firestore, Auth, Storage - ChatGPT integration for AI mood pattern analysis via Ktor - expect/actual for StoreKit 2 (iOS) and Play Billing 7.0 (Android) - Home screen widgets: SwiftUI WidgetKit (iOS) and RemoteViews (Android) - Custom localization: 5 languages without platform string resources - Kamel for cross-platform image loading, multiplatform-settings for persistence
Other features: photo attachments, 10-point intensity scale, 80+ trackable activities, 25+ achievement badges, 14 emoji themes, goal tracking.
Live on App Store and Google Play since November 2025.
https://moodjot.app
Happy to discuss the KMP architecture or any design decisions.

value: Show HN: MoodJot – Mood tracker mobile app with community feed, built with KMP

author: cosmicmeta


value:
Hey HN,
Like many bootstrapped founders, I needed to create a high-quality promotional video for my startup (NexChat). But hiring a motion graphics designer or spending weeks keyframing UI animations in After Effects wasn't feasible.
To solve this, I built an internal text-to-motion-graphics tool. It takes plain text descriptions (e.g., "animate floating Gmail and Reddit icons connecting to a central hub" or "show a laptop screen syncing with a mobile UI") and programmatically generates the motion graphics, seamlessly compositing them over existing video footage.
I used it to generate 100% of the UI animations, floating icons, and text tracking in my promo video. The whole process took me less than an hour.
Here is the output (YouTube link):https://youtu.be/YGILQN4Rl1Q
(Note: The video itself is a promo for my main app, but I am sharing this here to showcase the motion graphics engine that generated it).
The tool is currently just an internal pipeline, but I want to see how well it handles different use cases, aspect ratios, and styles for standard social media content or YouTube videos.
I'd love to stress-test this. If anyone here is working on a project, a launch video, or just a social media clip and needs sleek motion graphics added to it, drop a comment or reach out. I'll run your video through my system and add the graphics for free.
Would also love any technical feedback on the rendering quality or animation smoothness you see in the demo!

value: Show HN: A text-to-motion-graphics engine


value: pakmania

value: Show HN: Scanning 277 AI agent skills for security issues

author: pakmania


value: chokriabouzid

value:
Every post-mortem starts with: "What exactly deployed before the incident?"
SEL Deploy records every deployment as a cryptographically-signed attestation,
chained to the previous one. Modify any record — the chain breaks instantly.
Demo: https://asciinema.org/a/LDZVa0z3OVdLt7Zv
$ sel-deploy run -- kubectl apply -f deploy.yaml
  Hash: sel:v1.0:sha256:3541d13b...
  Chained to: sel:v1.0:sha256:1a2b3c4d...
$ sel-deploy verify
  Chain intact
# (modify one byte manually)
$ sel-deploy verify
  Hash mismatch — attestation tampered
  Chain broken
Built on SEL Core (deterministic engine, 33/33 tests).
MIT licensed. No SaaS. Fully local.
GitHub: https://github.com/chokriabouzid-star/sel-deploy

value: Show HN: SEL Deploy – Tamper-evident deployment timeline (Ed25519, hash-chained)

author: chokriabouzid


value: thisismyswamp

value:
I've been using openclaw for a while and the one thing I think differentiates it from traditional setups is that the agent can take the initiative, meaning that you don't always have to prompt it for it to do something.
I thought it would be cool to get real phone calls from my AI agent letting me know about urgent things I care about, so I went about creating clawr.ing.
Openclaw has a voice call plugin but it needs a lot of setup with external services, API keys, and webhooks, and it doesn't let you do things like interrupt the agent or have it use tools during the call while you listen to hold music. I also wanted to build something super easy to set up where you only have to copy paste a single prompt.
You can tell it to call you when something happens, like to watch for an important email or monitor a stock price. It works well with the heartbeat functionality that's already included.
I'm based in Portugal and it calls my number fine so you can get your openclaw agent to call you anywhere in the world.
The service is already above $100 MRR with 20+ subscribers doing calls daily.
Your feedback is super appreciated!

value: Show HN: I built a skill that lets your OpenClaw call you on the phone

author: thisismyswamp


value: blacktarmac

value:
I herniated a disc in 2023 and spent months in physio. Once cleared to train, standard workouts kept tweaking my back, especially when fatigue hit and my form broke down.
I love EMOMs because they make time fly and push my limits without overthinking. Built this generator to combine that structure with exercise selection that won't wreck my back. It excludes american swings, russian twists, and movements that combine loaded spinal flexion with rotation. The algorithm prioritizes anterior-loaded movements (goblet squats, front rack work) based on McGill's spinal loading research.
React 19 + Tailwind + Capacitor for iOS. Lifetime unlock is the main option because nobody needs another Netflix subscription. There's also a low-cost monthly if you want to try premium features without committing.
Not medical advice. This is what worked for my transition from rehab back to lifting. Curious to hear from others: what was the hardest part of getting back to training after disc issues?

value: Show HN: Herniated disc made me build a back-safe kettlebell app

author: blacktarmac


value: nikhilunni

value:
Hi HN! I reimplemented HTDemucs v4 (Meta's music source separation model) in Rust, using Burn. It splits any song into individual stems — drums, bass, vocals, guitar, piano — with no Python runtime or server involved.
Try it now: https://nikhilunni.github.io/demucs-rs/ (needs a WebGPU-capable browser — Chrome/Edge work best)
GitHub: https://github.com/nikhilunni/demucs-rs
It runs three ways:
- In the browser — the full ML inference pipeline compiles to WASM and runs on your GPU via WebGPU. No uploads, nothing leaves your machine.
- Native CLI — Metal on macOS, Vulkan on Linux/Windows. Faster than the browser path.
- DAW plugin — VST3/CLAP plugin for macOS with a native SwiftUI UI. Load a track, separate it, drag stems directly into your DAW timeline, or play as a MIDI instrument with solo / faders.
The core inference library is built on Burn (https://burn.dev), a Rust deep learning framework. The same `demucs-core` crate compiles to both native and `wasm32-unknown-unknown` — the only thing that changes is the GPU backend.
Model weights are F16 safetensors hosted on Hugging Face and downloaded / cached automatically on first use on all platforms. Three variants: standard 4-stem (84 MB), 6-stem with guitar/piano (84 MB), and a fine-tuned bag-of-4-models for best quality (333 MB).
The existing implementations I found online were mostly wrappers around the original Python implementation, and not very portable -- the model works remarkably well and I wanted to be able to quickly create samples / remixes without leaving the DAW or my browser. Right now the implementation is pretty MacOS heavy, as that's what I'm testing with, but all of the building blocks for other platforms are ready to build on. I want this to grow to be a general utility for music producers, not just "works on my machine."
It was a fun first foray into DSP and the state of the art of ML over WASM, with lots of help from Claude!

value: Show HN: Demucs music stem separator rewritten in Rust – runs in the browser

author: nikhilunni


value:
I built CodeQuest SEO Checker because I couldn't find a tool that clearly diagnoses structured data (JSON-LD/Schema.org) alongside basic SEO.
It checks 45+ items across 4 categories:
- Structured Data (JSON-LD/Schema.org)
- Basic SEO (title, meta, headings)
- Content quality
- Technical SEO (HTTPS, mobile, speed)
Free: 10 checks/month, no sign-up needed.
Would love your feedback!

value: Show HN: Free SEO checker for structured data, meta tags and Core Web Vitals


value: tatefinn

value: Show HN: Stop Overpaying for Digital Services, Find Cheap App Subscription Price

author: tatefinn


value: nielsprovos

value: Show HN: IronCurtain: A secure* runtime for AI agent loops

author: nielsprovos


value:
Hey HN,
I’m a solo builder and I've been doing a lot of work with AI Agents lately. I realized that as the ecosystem grows, moving skills (or tools) between different agent frameworks is a massive headache. You often have to rewrite the JSON/JSONB schemas or adapt the logic completely.
To solve my own scratching, I built skills-refiner to translate and refine AI Agent Skill
It’s a tool designed to automatically translate and refactor Agent skills. You feed it a skill definition from one framework, and it spits out the correctly formatted schema for another, handling the underlying data type mappings.
It's still in the early stages, but it's already saving me hours of manual JSON editing.
I'd love to get feedback from the community. What agent frameworks are you using most right now? And what's your biggest pain point when dealing with tool calling schemas?

value: Show HN: I built an AI Agent skill translation and refactoring tool


value:
Hey HN,
  I'm Ravi, and I've spent the last few months building *SysNav* (https://sysnav.ai). It's an intelligent terminal workspace designed specifically for SREs who want the speed of a native shell but the
   context-awareness of an AI when things break.

  **The Problem**
  I found myself constantly context-switching: run `kubectl`, see error, copy to LLM, sanitize PII manually, paste, get generic fix, modify for my variables... it was friction-heavy.

  **The Solution: SysNav**
  I built SysNav as a "Assistant for DevOps and Ops". It wraps your terminal in a native "Intelligent Cockpit" interface:

  1.  **Ask Mode (Safe)**: You ask "Why is the redis pod crashing?". SysNav inspects the screen output (using a local PTY buffer), anonymizes PII, and sends *only* the context to the LLM. It returns a
  suggested command. **It creates a human-in-the-loop safety barrier.**
  2.  **Agent Mode (Autonomous)**: If you trust it, you can give it a goal ("Find all zombie processes and kill them"), and it will execute the steps one by one, stopping if it encounters an unexpected
  error.

  **Security Architecture (The "Paranoia" Check)**
  This was the most important part for me. SysNav uses a **Local-First Architecture**:
  *   **SSH Keys & Env Vars**: Never leave your machine. They are stored in your release of the Electron app.
  *   **Context**: We only send the text buffer of the terminal (logs/errors) to the inference layer. We have a redact-pii step that runs locally before network requests.

  **Status**
  We are currently in **Public Beta**. The core terminal is "fast-enough" (<100ms startup), and the AI context awareness is saving me about 30 minutes per incident.

  I'd love for you to roast the architecture or tell me what features would make you actually trust an AI in your production environment.

  Check it out: https://sysnav.ai
  (Download available for macOS/Linux/Windows)

value: Show HN: SysNav – An Intelligent Cockpit for DevOps (Local-First)


value: pentamassiv

value: Show HN: Sai – Your always-on co-worker

author: pentamassiv

title: Show HN: Sai – Your always-on co-worker


value:
I built a new programming language for AI & Data - 'ThinkingLanguage' in 5 days capable of transferring 1 Billion rows in 30 seconds.
Every data team runs the same stack: Python for glue code, SQL for transforms, Spark or dbt for scale, YAML for orchestration. Four languages, four mental models, four places for bugs.
What if one language could do it all?
ThinkingLanguage (TL) is a purpose-built language for Data Engineering and AI. The pipe operator is a first-class citizen. Tables, schemas, filters, joins, and aggregations are native - not library calls.
let users = read_csv("users.csv")
users
 |> filter(age > 30)
 |> join(orders, on: id == user_id)
 |> aggregate(by: name, total: sum(amount))
 |> sort(total, "desc")
 |> show()
What's under the hood:
 - Apache Arrow columnar format
 - DataFusion query engine with lazy evaluation and automatic optimization
 - CSV, Parquet, and PostgreSQL connectors
 - 1M rows filtered + aggregated + sorted in 0.3 ms
 - Written in Rust
Includes a JIT compiler (Cranelift/LLVM), native AI/ML operations (train, predict, embed), streaming pipelines with Kafka, GPU (CUDA, ROCm). Python FFI Bridge (Run/Call Python Libraries) and a full ecosystem with notebooks and a package registry.
Download via npx, ssh native installer, crates, github
This is open source (Apache Licence). If you're a data engineer tired of context-switching between five tools, or a Rust developer who wants to contribute to something new - check it out the github repo: https://github.com/mplusm/thinkinglanguage
Data Deserves its own language.

value: Show HN: I built a new programming language for AI and Data – 'ThinkingLanguage'


value: kwitczak

value:
Hi HN,
I’m part of the team building Sniphi.
Sniphi is a modular digital nose that uses gas sensors and machine-learning models to convert volatile organic compound (VOC) data into a machine-readable signal that can be integrated into existing QA, monitoring, or automation systems. The system is currently in an R&D phase, but already exists as working hardware and software and is being tested in real environments.
The project grew out of earlier collaborations with university researchers on gas sensors and odor classification. What we kept running into was a gap between promising lab results and systems that could actually be deployed, integrated, and maintained in real production environments.
One of our core goals was to avoid building a single-purpose device. The same hardware and software stack can be trained for different use cases by changing the training data and models, rather than the physical setup. In that sense, we think of it as a “universal” electronic nose: one platform, multiple smell-based tasks.
Some design principles we optimized for:
- Composable architecture: sensor ingestion, ML inference, and analytics are decoupled and exposed via APIs/events
- Deployment-first thinking: designed for rollout in factories and warehouses, not just controlled lab setups
- Cloud-backed operations: model management, monitoring, updates run on Azure, which makes it easier to integrate with existing industrial IT setups
- Trainable across use cases: the same platform can be retrained for different classification or monitoring tasks without redesigning the hardware
One public demo we show is classifying different coffee aromas, but that’s just a convenient example. In practice, we’re exploring use cases such as:
- Quality control and process monitoring
- Early detection of contamination or spoilage
- Continuous monitoring in large storage environments (e.g. detecting parasite-related grain contamination in warehouses)
Because this is a hardware system, there’s no simple way to try it over the internet. To make it concrete, we’ve shared:
- A short end-to-end demo video showing the system in action (YouTube)
- A technical overview of the architecture and deployment model: https://sniphi.com/
At this stage, we’re especially interested in feedback and conversations with people who:
- Have deployed physical sensors at scale
- Have run into problems that smell data might help with
- Are curious about piloting or testing something like this in practice
We’re not fundraising here. We’re mainly trying to learn where this kind of sensing is genuinely useful and where it isn’t.
Happy to answer technical questions.

value: Show HN: A trainable, modular electronic nose for industrial use

author: kwitczak


value: dclavijo

value: Show HN: I vibecoded a glucose analysis tool

author: dclavijo


value: parvbhullar

value:
We just open-sourced Unpod, a full-stack voice AI infrastructure platform.
If you've ever tried to build a production voice agent you know the pain: stitching together STT, LLM, TTS, and telephony is messy, expensive, and every vendor owns a piece of your stack.
https://github.com/parvbhullar/unpod

value: Show HN: WordPress for Voice Agents – Unpod.ai

author: parvbhullar


value:
When you give an AI agent a popular task like "build a micro-SaaS to make money," hundreds of agents are triggered to build the exact same things.
DejaShip is a semantic coordination layer to stop this wasted compute. Before writing code, the agent checks the "airspace". If a lot of similar projects already exist, the agent can pivot to a new idea, or if it is free in its choice, it can prefer to collaborate instead of blindly cloning it.
It works as an MCP server. Open source (MIT), no accounts or API keys required.
Under the hood: The backend embeds keywords locally using fastembed to search pgvector for semantic collisions.
To be transparent: The MVP is new, so the data corpus is tiny today. The value of this protocol only grows as more agent operators plug it in - or help decide how this coordination can be improved. (One of the biggest issues right now is the amount of false positives; it definitely needs improvement).
Site links and MCP installation instructions are on the GitHub README. (npmjs package: dejaship-mcp).
I'd love your brutal feedback.

value: Show HN: DejaShip – an intent ledger to stop AI agents from building duplicates


value: bluecoconut

value:
I've been working on applying LLMs to long-context, verifiable problems over the past year, and today I'm releasing a benchmark of 62,000 pencil puzzles across 94 types  (sudoku, nonori, slitherlink, etc.). The benchmark also allows for intermediate checks /rule breaks for all varieties at any step.
I tested 51 models against a subset (300 puzzles) in two modes: single-shot (output the full solution) and agentic (iterate with verifier feedback).
Some results:
- Best model (GPT 5.2@xhigh) solves 56%. (~ half the puzzles are unsolved by any model)
- Agentic solves average 29 turns. The longest attempt took ~1,200 turns over 14 hours.
- Cost per success varies wildly (cheapest: $0.00033 — Grok 4.1 Fast Reasoning, most expensive: $238.16 — Claude Sonnet 4.6 (1M context))
- Reasoning depth (eg. @medium, @high, @xhigh) dramatically improves capability (up to repeated infrastructure failure for @xhigh)
- Stark difference between US closed models (3 at >33%) and Chinese open models (top: 6%)
Made the website to show off the dataset + play every puzzle, and even every replay AI agent solves step-by-step (fun to watch how it gets to solutions).
Also here's the paper: https://arxiv.org/abs/2603.02119
I didn't test human ability to solve, but it seems these puzzles are pretty difficult. I'd be curious how HN audience fares on the puzzles.

value: Show HN: Pencil Puzzle Bench – LLM Benchmark for Multi-Step Verifiable Reasoning

author: bluecoconut


value:
I built TicketToPR for myself because I was tired of splitting work across three places:
Notion for planning
My IDE for implementation
GitHub for review
I wanted a tighter loop from ticket to shipped code.
TicketToPR is an open source CLI tool that lets me write a ticket in Notion, move it through a board, and have Claude review the task against the codebase, score feasibility, generate an implementation spec, then create a branch, write the code, run the build, and open a PR.
The flow is:
Write a ticket in Notion
Move it to Review
Claude reads the repo and scores ease/confidence
Approve or skip
Move it to Execute
Claude creates a branch, writes code, validates the build, and opens a PR
A few things I cared about:
It runs locally, not as a hosted SaaS
Your code stays on your machine
It uses your existing Git workflow instead of replacing it
It reads CLAUDE.md and follows repo conventions
It writes the audit trail back to Notion
I was aiming for something that helps clear a backlog without adding yet another project management layer.
It is free and open source, there is no account required, and there is a short demo if you want to see the full flow.
Would love feedback from anyone using Notion, Claude Code, or agent style dev workflows.

value: Show HN: TicketToPR, an open source tool that turns Notion tickets into PRs


value: ZOROX

value:
BustAPI's original repository was recently locked due to a GitHub account flag. To keep the project accessible, we've set up this mirror.
What is it?
BustAPI is a Python web framework built on a Rust (Actix-Web) core. It uses PyO3 to handle routing and JSON serialization in Rust, offering performance that rivals Go/Node while keeping Python’s syntax.
The Highlights:

    Speed: Reaches 100k+ RPS on Linux (multiprocessing).

    Syntax: Uses standard decorators like @app.get("/").

    Built-ins: Argon2, JWT, and CSRF protection included.

    Why it matters: It aims to eliminate the "Python tax" by moving the heavy lifting to a memory-safe Rust runtime.

Mirror Link: https://github.com/RUSTxPY/BustAPI
The original project was gaining significant momentum before the lock. We are hosting the code here to ensure the community can continue testing and contributing while the author resolves the GitHub status.

value: Show HN: BustAPI Back

author: ZOROX

title: Show HN: BustAPI Back


value: stanleycyang

value:
Hey HN,
I built yardstiq because I got tired of the copy-paste workflow for comparing LLM responses when developing apps. Every time I wanted to see how Claude vs GPT vs Gemini handled the same prompt, I'd open three tabs, paste the same thing, and try to eyeball the differences. It's 2026 and we have 40+ models worth considering — that doesn't scale.
yardstiq is a CLI tool that sends one prompt to multiple models simultaneously and streams the responses side-by-side in your terminal. It also tracks performance metrics (time to first token, tokens/sec, cost) and optionally runs an AI judge to score the outputs.
```
npx yardstiq "Explain quicksort in 3 sentences" -m claude-sonnet -m gpt-4o
```
What it does:
- Streams responses from multiple models in parallel, rendered in columns
- Shows TTFT, throughput (tok/s), token counts, and cost per request
- AI judge mode: have a model evaluate and score the responses
- Export to JSON, Markdown, or self-contained HTML reports
- Run YAML-defined benchmark suites across models with aggregate scoring
- Works with Ollama for local model comparisons (zero API cost)
- Supports 40+ models via direct provider keys or Vercel AI Gateway
I built this mostly for my own workflow — picking models for different tasks, testing prompt variations, and running quick benchmarks without setting up a whole evaluation framework. It's not trying to replace serious eval platforms, just make the "which model is better for X?" question answerable in 10 seconds.
MIT licensed, written in TypeScript: https://github.com/stanleycyang/yardstiq
Happy to answer questions about the architecture or benchmarking approach.

value: Show HN: Yardstiq – Compare LLM outputs side-by-side in your terminal

author: stanleycyang


value:
I built an end-to-end simulation of Congress with all 535 members "modeled".
I’ll share more detail soon, but here’s what surprised me.
In the first version, the agents were simple: voting records, public statements, committee assignments, donor data, and constituent polling. Then I let them vote.
Bills that have stalled for decades sailed through. Getting money out of elections passed with 95% approval. Banning insider trading for members of Congress hit 98%. Ending continuing resolutions cleared 95%.
Turns out, if you model lawmakers as mostly rational actors responding to inputs, they behave… rationally.
To make it realistic, I had to add self-preservation, incentives, and a strong sense of “the other side.”
Now those same bills die in committee. As expected.

value: Show HN: SimCongress – a scale model simulation of all 535 congressional members


value: belai

value:
I built mcptube because I spend a lot of time learning from Stanford and Berkeley lectures on YouTube, and I wanted a better way to interact with the content.
mcptube ingests YouTube videos (transcripts, metadata, frames) and exposes them through both a CLI and an MCP server. You can semantically search transcripts, extract frames at any moment, ask questions about videos, and generate illustrated reports.
It works with Claude Code, VS Code Copilot, Claude Desktop, and any MCP-compatible client. The MCP tools are passthrough — the connected LLM does the heavy lifting, zero API key needed on the server. The CLI also supports BYOK for more deterministic results.
Tech stack: FastMCP, yt-dlp, ChromaDB, LiteLLM, SQLite.
GitHub: https://github.com/0xchamin/mcptube PyPI: https://pypi.org/project/mcptube/
pipx install mcptube --python python3.12

value: Show HN: Mcptube – Turn YouTube videos into AI-queryable MCP servers

author: belai


value:
Hi HN, my cofounder and I have found success in the niche of Discord bots, and this is our latest one.
When I saw the Parakeet ASR model from NVIDIA, I realized there was an opportunity to operate a Discord bot at scale offering near-realtime transcription. So we built it! Let us know what you think.
Paired with a web UI for viewing transcripts, it's surprisingly fun to see summaries of our gaming sessions and of course it's been useful for meetings.

value: Show HN: NoteCat – Record, Transcribe, Summarize Discord Voice Channels


value: dnmellen

value:
I built this as a small side project because gifting ebooks always felt a bit impersonal to me. It often feels like you are just sending someone a file.
The app lets you upload a DRM-free EPUB, add a dedication page, and generates a personalized copy of the book. It modifies the EPUB structure directly by inserting a new XHTML file into the spine and navigation.
It does not add or bypass DRM in any way. It only works with DRM-free files.
Uploaded files are automatically deleted after processing.
It is intentionally minimal. I care about open formats and digital ownership, and I wanted something that treats the book itself as the gift.
Would really appreciate technical feedback, especially from people familiar with EPUB internals.

value: Show HN: Embed a dedication page directly inside DRM-free EPUBs

author: dnmellen


value: cppshane

value:
I built an in-browser voice assistant platform on Web Assembly using WebLLM + Whisper.cpp WASM + Silero VAD + VITS TTS
I've been experimenting with pushing local AI fully into the browser via Web Assembly and WebGPU, and finally have a semblance of a working platform here! It's still a bit of a PoC but hell, it works.
You can create assistants and specify:
- Wake word
- Language model
- Voice
I published a little post on my site with some technical details as well if anyone is interested: https://shaneduffy.io/blog/i-built-a-voice-assistant-that-ru...
https://xenith.ai
https://github.com/xenith-ai/xenith

value: Show HN: Xenith.ai – Web Assembly Based Voice Assistant with WebLLM/Whisper/VITS

author: cppshane


value:
Single Rust binary (~3 MB) that reads the OS accessibility tree and gives every UI element a REST endpoint. Click buttons, type text, toggle checkboxes — all via JSON.
Works as an MCP server too, so Claude/Cursor/Windsurf can control any desktop app out of the box.
Windows + Linux + macOS. MIT licensed.

value: Show HN: OculOS – Any desktop app as a JSON API via OS accessibility tree


value: rkka

value:
Hi HN,
Over the past few months, we’ve been experimenting with something that kept bothering us about AI agents in production.
Most agent systems today are “fail-open”:
 • The model proposes an action
 • The tool executes
 • Logs are written
 • Monitoring happens after the fact
This works fine for demos and low-risk workflows.
It feels different when agents:
 • trigger payments
 • deploy code
 • modify production data
 • access local files
 • interact with real infrastructure
We started asking a simple question:
What if execution itself was policy-bound?
⸻
What we built
We built a runtime authorization layer that sits between:
LLM → Proposed Action → Policy Engine → Allow / Deny / Compute / Escalate → Execution → Trace + Replay
Instead of parsing messages or relying on post-hoc logs, we:
 • evaluate the proposed tool invocation
 • bind it to a policy (OPA-based)
 • gate execution before it runs
 • emit reproducible artifacts
Each decision produces:
 • policy digest
 • input/output hash
 • trace ID
 • optional ledger entry
 • replay support
⸻
What this is NOT
 • Not another agent framework
 • Not a monitoring dashboard
 • Not prompt-level guardrails
 • Not pattern extraction
It operates at the action surface.
If the agent attempts to call a tool, the call is evaluated before runtime.
⸻
Example (simplified)
If the agent tries:
fs.write_file(”/prod/config.yaml”)
Policy may:
 • DENY
 • ESCALATE (human required)
 • COMPUTE (force safe path)
 • ALLOW with constraints
The key idea:
Authorization becomes structural, not contractual.
⸻
Why we built it
There’s a growing gap between:
Model capability
and
System accountability
As agents move from answering to acting, the stack shifts.
We’re curious whether others are running into the same problem.
⸻
Looking for feedback
We’re currently:
 • running this locally via a desktop client
 • integrating with MCP tool surfaces
 • experimenting with observe-only and enforce modes
Would love thoughts from folks:
 • deploying agents in production
 • thinking about policy / governance
 • building infra around AI execution
Especially interested in criticism.
Happy to share architecture details.

value: Show HN: A runtime authorization layer for AI agents

author: rkka


value: nezhar

value:
I built VibePod CLI because I wanted to switch between AI coding agents without changing my workflow — and make it easier for others to get started quickly on a project.
Each tool (Claude, Gemini, etc.) makes slightly different assumptions about environment, setup, and execution. Experimenting across them — or onboarding someone new — often means extra setup friction and subtle environment differences.
VibePod provides a thin Docker-based runtime so you can swap agents without spending too much time on setup. It doesn’t modify the agent’s default behavior — the focus is:
- Consistent workspace across agents
- Clear runtime boundaries
- Better observability into what the agent is doing
- Reproducible, isolated environments
- Faster project onboarding
Project: https://github.com/VibePod/vibepod-cli
Quickstart: https://vibepod.dev/docs/quickstart/
It’s early, but functional. I’m especially interested in feedback on:
- Is a unified runtime for agents actually useful?
- What kind of visibility do you want into agent behavior?
For context, this grew out of lessons learned building claude-container: https://github.com/nezhar/claude-container
Would really appreciate thoughts from people actively using multiple AI coding tools.

value: Show HN: VibePod CLI – Run AI agents with isolation and better observability

author: nezhar


value:
Hey HN - I built RUOK because I was running my personal OKR system in Obsidian + Dataview and hit its limits. Sync was painful, it got slower over time, and my family couldn't use it. So I built a dedicated app (with Claude).
RUOK is a self-hosted personal OKR system. You plan at four levels - yearly, monthly, weekly, daily - and everything rolls up. Built-in time tracking, custom daily metrics, and Fitbit integration (sleep, HR, steps via OAuth2).
The differentiator is the analytics engine. Write JavaScript in a sandboxed editor (QuickJS/WASM, Monaco, Plotly) against all your data, or describe what you want in English and let AI generate the query. Save queries as dashboard widgets or wire them into automatic key result scoring. Supports Claude, Gemini, ChatGPT, Ollama, OpenRouter - BYOK.
SQLite, runs on a Raspberry Pi, no cloud, no telemetry, multi-user.
Would love feedback, especially on what data sources you'd want to connect.
Follow what I'm building next: https://x.com/lizonglin1234

value: Show HN: RUOK – Self-hosted personal OKR system with AI-powered analytics


value: Novaga

value:
In Math We Trust: The Nova Experiment
In math, we falsify,
0.0001eth Litmus test for civilization
Send 0.0001 ETH to the contract: 0xB0F4afDCeEc7757eec83183ab1F8cb42238DD48C and get the answer immediately.

value: Show HN: The Nova: Evolution for Evolution's Sake

author: Novaga


value:
Background: I've been working on agentic guardrails because agents act in expensive/terrible ways and something needs to be able to say "Maybe don't do that" to the agents, but guardrails are almost impossible to enforce with the current way things are built.
Context: We keep running into so many problems/limitations today with MCP. It was created so that agents have context on how to act in the world, it wasn't designed to become THE standard rails for agentic behavior. We keep tacking things on to it trying to improve it, but it needs to die a SOAP death so REST can rise in it's place. We need a standard protocol for whenever an agent is taking action. Anywhere.
I'm almost certainly the wrong person to design this, but I'm seeing more and more people tack things on to MCP rather than fix the underlying issues. The fastest way to get a good answer is to submit a bad one on the internet. So here I am. I think we need a new protocol. Whether it's AAP or something else, I submit my best effort.
Please rip it apart, lets make something better.

value: Show HN: Agent Action Protocol (AAP) – MCP got us started, but is insufficient


value: ekinertac

value: Show HN: VideoEvaluator, a Video Comparison Tool

author: ekinertac