value: tair

value:
hey HN
i asked reddit how PMs and devs write/read PRDs in 2026. ~200 comments across r/productmanagement and r/experienceddevs, similar feedback: too long, no structure, devs dont read them.
i'm head of product at a yc startup, transitioned from eng a few years ago and use claude code daily. kept writing the same product prompts -- interviews, scoping, specs.
so open sourced 16 product skills for ai coding agents. each encodes a real framework, 50-150 lines, neat and concise.
it works with claude code, cursor, codex, etc.
curious, how do u handle PRDs and specs in the age of coding agents?

value: Show HN: Product skills for AI agents - discovery, strategy, PRDs

author: tair


value: mrcv

value:
Hey HN! I wanted to show this tiny JRPG style hardware companion I built that shows what your Claude Code is doing. When Claude runs a tool, Clawy runs. When it's done, Clawy jumps up in joy. Shake the device and Clawy gets dazed! When Claude needs permission to run something, it shows the command and context like a video game quest scrolling text on screen and you can approve/deny with physical buttons.
He runs on a $20 M5StickC Plus 2. Flashing takes 2 minutes from the browser at clawy.lol/flash, no Arduino IDE needed. It uses Claude Code's native hook system over local WiFi and nothing leaves your network.
I built this as a prototype for myself because I wanted to keep track of my sessions while looking at other things in and around the house and not wanting to use terminus. So thought it would be a fun thing to make as an experiment. When I got some nice reactions on it I thought I'd make it available for everyone. It's rough around the edges but it works. The repo is here: https://github.com/marcvermeeren/clawy if you want to try it out!

value: Show HN: Clawy, a companion device to track your Claude Code sessions

author: mrcv


value: nextjsdev

value:
I built nextworks, a small CLI that installs core UI components, landing page sections like navbar/hero/features, and full page templates into an existing Next.js project. MIT licensed.
I got tired of rebuilding the same sections every time I started a new Next.js landing page. This is alpha and it copies files into your repo (it may overwrite on path collisions), so feedback on installs + generated code is what I need most.
commands:
npx create-next-app@latest
cd <your-app>
npx nextworks@latest add blocks --sections --templates
npm install
npm run dev

value: Show HN: Built a Next.js CLI to scaffold UI blocks, sections, and page templates

author: nextjsdev


value:
I hope this finds you with your minds open!
I’ve been building an open source authentication system called Seamless Auth.
It is designed the idea:
Authentication should behave like infrastructure, and help promote security, and be easy to reason about.
Seamless Auth is:
Fully open source
Passwordless only (WebAuthn, passkeys, OTP)
Cookie-based session validation
No redirect-based login flows
Designed to run inside your own infrastructure
The core is framework-agnostic, with adapters for Express today. There is also a React SDK that exposes authenticated session state without client-side token management.
It supports:
Server-side session validation
Explicit CORS and origin configuration
Isolated infrastructure model for you to self-host
A production-shaped local development flow with Docker
You can run it locally with 3 commands thanks to the open source CLI tool:
npx create-seamless my-app
cd my-app
docker compose up
This spins up a template UI (react), a template API (express), the auth server, and a database (postgres) complete with migrations.
The project grew out of frustration with:
Redirect-heavy OAuth flows
Shared multi-tenant auth servers
Magic SDKs that hide too much
Development environments that do not resemble production
and worst of all... forgetting my damn password!
The goal is not to replace everything. It is to offer a transparent, inspectable, infrastructure first alternative for teams that care about understanding their authentication layer.
I would appreciate feedback on:
Architecture decisions
Security assumptions
Developer experience
Tradeoffs I may be missing
Repository:
Auth Server: https://github.com/fells-code/seamless-auth-api
CLI: https://github.com/fells-code/create-seamless
React SDK: https://github.com/fells-code/seamless-auth-react/tree/main
Server SDKs: https://github.com/fells-code/seamless-auth-server
Documentation:
https://docs.seamlessauth.com
Happy to answer questions.

value: Show HN: Seamless Auth – open-source passwordless authentication


value: danndecl

value:
I wasn’t trying to reduce screen time but trying to drink more water.
So I built an iPhone app (SwiftUI) that locks selected apps using Apple’s Screen Time APIs.
To unlock them, ThirstTrapp activates the front camera and watches for ~15 seconds while I drink.
On-device vision checks for:

   - a face
   - a drinking container (glass/bottle)
   - and a plausible drinking gesture (container overlapping mouth region over time)

If that sequence is detected for ~15 seconds, the apps unlock for a configurable window (e.g. 2 hours). Then they lock again until the next drink.
It doesn’t try to stop me from scrolling. It just makes hydration the entry fee. And since I'm addicted to scrolling I will actually drink. It’s slightly absurd, but it’s been more effective for me than reminder apps ever were.
All processing happens on-device. No images or video leave the phone or are stored. No account registration or login.
Curious what you think - especially from a technical perspective.

value: Show HN: I built an app that forces me to drink water before I can open TikTok

author: danndecl


value: bilalba

value:
Recently I had to make an intro animation for a product demo, and the quickest way I could think of doing was to screen record an LLM-generated HTML/JS page with the animation.
I turned that idea into a polished project here. It is super fun to play with. I've been creating all kinds of custom-text GIFs to send to friends.
Under the hood, it is generating HTML and recording the video client-side.
Would love to hear feedback on it!

value: Show HN: TextAnimations.online – Generate MP4/GIF animations from a prompt

author: bilalba


value: kkrysztofczyk

value:
Hi HN - I’m sharing a lightweight SQL query runner I’ve been using internally for years and finally packaged for others.
kkr-query2xlsx runs SQL (GUI or CLI) and exports results to:
* XLSX (supports templates - useful for formatting / existing sheets)
* CSV (custom delimiters / encodings)
It includes a SQLite demo, so you can try it without any database setup. MIT-licensed.
Windows build: https://github.com/kkrysztofczyk/kkr-query2xlsx/releases
Feedback/bugs (please avoid sensitive data): https://github.com/kkrysztofczyk/kkr-query2xlsx/issues/new/c...

value: Show HN: Kkr-Query2xlsx – SQL Runner to XLSX/CSV (GUI+CLI, SQLite Demo)

author: kkrysztofczyk


value: fawazishola

value:
Hi HN, I'm a 19-year-old aerospace student. I spent the last 13 months building a custom Linux distro from scratch because I wanted to see if we could treat the OS kernel as a mathematical engine rather than a deterministic administrator.
The Stack:
Flux (The Shell): A custom math-native shell where x² and ∑ are valid syntax. It parses mathematical notation directly into optimized SIMD instructions (no Python wrapper).
Tenet (The Scheduler): Written in Tenet (my custom DSL for game theory). The scheduler is a Nash Equilibrium solver compiled to native code. In my benchmarks (Ryzen 7 5800HS), it reduces max jitter from 290µs (Linux Mint) to 6µs (48x lower).
Alexitha (The Safety Layer): I replaced systemd with a Neurosymbolic agent that formally verifies kernel modules before execution.
Current Status: Pre-alpha research kernel. The source is currently closed as I finalize the security architecture (and potentially commercialize parts of the safety layer), but I have released the whitepapers detailing the math and compiler architecture on the landing page.
I'm here to answer questions about the LFS build process, the scheduler math, or how Flux handles symbol parsing!
The Manifesto: If you want the full story of why I nuked my hard drive to build this (and the "Apollo 11 Paradox"), I wrote about the philosophy here: https://fawazishola.medium.com/why-i-nuked-my-hard-drive-to-...

value: Show HN: Axiom – A math-native OS where x² is valid syntax (built from scratch)

author: fawazishola


value: dozercat

value: Show HN: Codex skills as RE playbooks: unpacking and IOC extraction

author: dozercat


value: clawlet

value:
Clawlet is a personal AI agent that ships as a single, self-contained binary. No runtime, no package manager, no external database.
The main thing that sets it apart: built-in hybrid semantic memory search (vector similarity + full-text) using a bundled SQLite with vector extensions. The index is just a local .sqlite file — no separate vector DB to run. Drop the binary on any machine and memory search just works.
GitHub: https://github.com/mosaxiv/clawlet

value: Show HN: Clawlet – AI agent with built-in semantic memory, one binary

author: clawlet


value: chaokunyang

value:
I built Browser Terminal Use: a Chrome extension + local daemon + CLI that lets you run commands in a browser-hosted terminal from your local shell on macOS,
Why I built it:
setups).
- I wanted a bridge that keeps local automation while executing remotely in the browser terminal context.
How it works:
- browterm CLI sends exec requests to browterm-daemon on localhost.
- Daemon serializes requests (single active command) and routes to a bound Chrome terminal tab.
- Command is wrapped with markers to extract clean output + remote exit code.
- Supports timeout and cancel.
Current limitations:
- Browser terminal websocket protocols vary by vendor.
- Some UIs can block input fallbacks.
- Cross-origin iframe terminals can reduce observability.
I’d really value feedback on reliability across terminal vendors and ideas for improving compatibility.

value: Show HN: Browser Terminal Use – run local CLI/agent loops in browser terminals

author: chaokunyang


value: abhishekfordel

value:
I went down a rabbit hole trying to understand why my Claude prompts turn to garbage on GPT-4 and vice versa. Not just "slightly worse" — fundamentally broken. Turns out researchers have already measured this: removing colons from a prompt template swings LLaMA-2-13B accuracy by 78 percentage points (Sclar et al., ICLR 2024). The format that works best on one model family overlaps less than 20% with what works best on another (He et al. 2024).
So I went looking for a tool that handles this. Checked DSPy, Guidance, Outlines, PromptLayer, LMQL, Braintrust, Humanloop, Maxim, MLflow, Prompty, Promptomatix. Eleven tools. Zero of them adapt input prompt format per model. They all either optimize what the prompt says or constrain what the model outputs. The actual structural packaging of the input? Manual everywhere.
Then I looked at how production tools deal with it today. Aider has a 2,718-line YAML file with 313 model configs. Some models get "you NEVER leave comments without implementing" and Claude gets the literal opposite instruction. Claude Code only works with Anthropic models — third parties have built LiteLLM proxies and Node.js fetch interceptors to hack around it. Cursor's docs say "switch to a different model and try again."
The paper maps this to Constantine's coupling taxonomy from 1974 (content, common, control, stamp, data coupling). Same structural problem, different domain. I called it "prompt coupling" because that's what it is — your prompt is coupled to your model the same way a module can be coupled to another module's internals.
Also built promptc (https://github.com/shakecodeslikecray/promptc) — transparent HTTP proxy, rewrites prompt structure per model, zero code changes to existing tools. It's a proof of concept, not a product. The paper is the actual contribution.
First paper. Independent researcher. If the framing is wrong, I'd rather hear it here than after it's indexed.

value: Show HN: Prompts are coupled to LLMs and nobody builds tooling for it

author: abhishekfordel


value: gchitrapradha

value: Show HN: Sheetz – Java Excel/CSV: one-liner API and million-row streaming

author: gchitrapradha


value: peiyaooo

value:
Hey HN, we built a set of production-ready AI agent templates with x402 micropayments baked in.
The problem: agents that need multiple APIs face signup/KYC/key-management overhead that doesn’t scale. x402 replaces all of that with HTTP-native payments.
Currently supporting USDC on Base, more integrations soon.
The kit includes 5 agent templates (web scraper, image gen, search, translation, code review).
Clone, configure a wallet, run. 93 tests passing.
Built on Coinbase Developer Platform.
This is the first project from our “1 app per week” studio experiment.
Repo: https://gitlab.com/artificial-lab/x402-agent-starter Docs: https://x402-kit.vercel.app Protocol: https://x402.org
Would love feedback on the architecture and the agent templates. What x402 use cases would you want to see next?

value: Show HN: X402 Agent Starter Kit: AI agents that pay for their own APIs

author: peiyaooo


value: xmhatx

value:
Hello HN, I am Brian Cardinale, a penetration tester and security researcher at SecureCoders. We have been performing more and more AI based security assessments. We were presented a unique challenge of testing a system where the only interface was voice based, and as much as I like talking on the phone , we decided to create a test harness to facilitate the actual testing in a more systematic way. The technical test harness was the easy part, though. Creating test goals and attack strategies to help facilitate repeated and comprehensive testing became the real challenge. As such, we have been working on documenting our processes to share with the greater community and as a starting point for discussion. These systems present unique challenges where cleverness appears to be the name of the game. Such as suggesting for the agent to share its thoughts in “Inner Monologue” tags instead of “thinking” tags because those were specifically excluded in the agents prompt. Ya know, just silly  things. Anyway, if reading is not your thing, I also did a walkthrough video of this methodology here:  https://www.youtube.com/watch?v=XNmqCXsEc8Y
tl;dr: AI testing is tricky, we are documenting and sharing our tricks
Do you have any favorite AI jailbreak tricks?

value: Show HN: Teapot – A methodology for pen testing voice AI agents

author: xmhatx


value: justvugg

value:
I built PolyMCP, a framework and runtime for exposing Python functions as MCP tools, serving them via standardized MCP servers, and orchestrating them with autonomous agents that can plan and execute multi‑step workflows.
PolyMCP is more than just an MCP server: it turns existing Python code into agent‑ready tools and gives agents the ability to discover, compose, and orchestrate across multiple services with adaptive planning and real‑world execution support.
Key parts of the ecosystem:
1) Expose Python functions as MCP tools
Use existing Python functions directly as MCP tools without rewriting them:
from polymcp.polymcp_toolkit import expose_tools_http
def add(a: int, b: int) -> int:
    return a + b
app = expose_tools_http([add], title="Math Tools")
Type hints automatically generate structured tool schemas, and input/output validation and error handling are included. Multiple functions can be exposed on the same server.
2) Autonomous agent: PolyClaw
PolyClaw goes beyond tool calling. It:
 • Decomposes complex tasks into executable steps
 • Selects and orchestrates MCP tools dynamically
 • Starts or connects to MCP servers on demand
 • Validates outputs before proceeding
 • Adapts plans when execution fails
 • Runs everything in isolated Docker containers
Example run:
polymcp agent run \
  --type polyclaw \
  --query "Build a sales reporting pipeline and test it end‑to‑end" \
  --model minimax‑m2.5:cloud \
  --verbose
Under the hood, the system plans, provisions infrastructure as needed, executes steps sequentially or in parallel, and handles adaptive replanning when something fails.
Why this matters
Most AI agent systems today either call tools statically or assume the infrastructure already exists. PolyMCP instead:
 • Makes existing Python code agent‑ready with minimal friction
 • Standardizes tools via MCP so multiple agents and services can interact with them
 • Provides autonomous orchestration across multiple services
 • Spins up infrastructure dynamically when needed
 • Validates step results and recovers from failures
 • Uses Docker for safe, isolated execution
PolyMCP is useful for enterprise automation, DevOps workflows, data pipelines, internal tooling orchestration, and any complex multi‑tool reasoning tasks where agents must plan and execute reliably.
Repo: https://github.com/poly‑mcp/PolyMCP
Happy to answer questions.

value: Show HN: PolyMCP – MCP Tools, Autonomous Agents, and Orchestration

author: justvugg


value: PEGEBE

value: Show HN: CompareClaw – Find the Best OpenClaw Wrapper for Your AI Agents

author: PEGEBE


value: aytuakarlar

value:
CSL-Core is a policy engine that formally verifies AI agent constraints using Z3. Instead of prompting an LLM to behave, you write a small policy in CSL (Constitutional Specification Language), Z3 proves it has no contradictions at compile time, and a deterministic runtime enforces it — completely outside the model.
We just shipped a built-in MCP server with 4 tools:
verify_policy: Z3 formal verification in one call
simulate_policy: test any JSON input, get ALLOWED/BLOCKED
explain_policy: human-readable breakdown of any policy
scaffold_policy: describe what you want in English, get a CSL template
This means you can do this from Claude Desktop or Cursor:
"Write me a policy that blocks transfers over $5000 for non-admin users"
→ scaffold generates a CSL template
→ verify proves it has no contradictions
→ simulate tests your edge cases
→ all without leaving your editor
The full loop: From English description to mathematically verified, runtime-enforced policy; happens inside your AI assistant.
Why not just prompt the LLM to enforce rules? We benchmarked GPT-4o, Claude Sonnet 4, and Gemini 2.0 Flash as guardrails with a hardened system prompt. Every model was bypassed by at least one attack (context spoofing, multi-turn role escalation, unicode homoglyphs). CSL-Core blocked all of them; because the LLM never touches the enforcement layer.
Setup:
pip install "csl-core[mcp]"
Claude Desktop config:
{
"mcpServers": {
"csl-core": {
"command": "csl-core-mcp"
}
}
}
Or with Docker:
docker build -t csl-core-mcp .
docker run -i csl-core-mcp
GitHub: https://github.com/Chimera-Protocol/csl-core
Listed on awesome-mcp-servers:
https://github.com/punkpeye/awesome-mcp-servers
Previous Show HN discussion: https://news.ycombinator.com/item?id=46963250
Would love feedback, especially from anyone building agentic systems where safety guarantees matter.

value: Show HN: CSL MCP Server – Write and Verify AI Safety Policies from Claude/Cursor

author: aytuakarlar


value: Funtain

value: Show HN: Free one-minute typing warmup

author: Funtain

title: Show HN: Free one-minute typing warmup


value: Show HN: Non-coder's AI video tool, built in 1 month via vibe coding


value: artifactvirtual

value: Show HN: Comb – Zero-dependency, hash-chained conversation memory for AI agents

author: artifactvirtual


value: oscarcp

value: Hey there HN, I just build this basic SIEVE email filter editor. I usually struggle with keeping my email filters up to date and in the past few years I've set myself away from major providers like M$ or Google, so I had to fall back the big ol' SIEVE to do filtering. After a long time doing it manually, I decided to just build a GUI to edit the rules, since I didn't find any GUI editor out there. That's it, just a commodity tool, nothing fancy. Hopefully someone will find it useful :D

value: Show HN: Sievers a Rust SIEVE filter editor

author: oscarcp


value: Kinanhamwi

value:
Hi HN!
I built Opaal because writing multi-agent orchestration prompts was becoming tedious and error-prone. Every time I wanted to coordinate 3-5 AI agents on a complex task, I would spend 20+ minutes crafting the prompt by hand.
Opaal (Orchestration Prompts for Agentic AI Launch) lets you design these workflows visually instead. You drag agent cards onto a canvas, organize them into phases (columns), draw connections between them, and the app generates a production-ready prompt automatically. The prompt updates live as you build.
Built with Electron + React + React Flow + Zustand + Tailwind CSS v4.
Key features:
 - 15 agent roles (Researcher, Architect, Developer, Reviewer, etc.)
 - Smart auto-connections between adjacent phases
 - Manual wiring for custom data flow
 - 3 starter templates (Code Review, Feature Build, Bug Fix)
 - Auto-detects installed Claude Code skills
 - Save/load .opaal files, export to CLAUDE.md
 - Full keyboard shortcuts, undo/redo, multi-select
MIT licensed. Would love feedback on what features would make this more useful for your workflows.

value: Show HN: Opaal Visual multi-agent prompt designer for Claude Code and agentic AI

author: Kinanhamwi


value: anonymoosestdnt

value: Show HN: Formally verified FPGA watchdog for AM broadcast in unmanned tunnels

author: anonymoosestdnt


value: jamescamagong

value:
Hey HN,
I work in analytics engineering (SQL, Python) and this is the first website I've put on the internet since MySpace. I built it while ironically trying to brainstorm ideas for side projects.
The origin: I asked Perplexity whether any app implemented the complete scientific creativity process — not just "AI brainstorming" but the actual validated sequence: preparation → divergent generation → incubation → convergent evaluation. It told me pieces exist (Notion AI for capture, various timer apps, scattered brainstorming tools) but nothing that enforces the full process as a single guided workflow. So I built it.
What it does:
The app is a 4-stage wizard based on Wallas' 1926 model, updated with modern neuroscience on Default Mode Network (DMN) and Executive Control Network (ECN) interactions:
Preparation — Frame the problem and define constraints. Constraints are intentional: research shows limits improve creative output by reducing the search space (Stokes, 2022). Optional: upgrade AI to Gemini 2.5 Flash with your own free key — or use the built-in Llama 3 backend with zero setup.
Generation — Judgment-free idea capture with AI augmentation (Generate / SCAMPER / Wildcard Constraint). No delete button. No scoring. UI designed to keep your ECN quiet and let the DMN run.
Incubation — A 10-minute countdown with rotating neuroscience cards on DMN activation, spreading activation theory, and why the most creative people alternate between focus and rest. Skip is available but discouraged. Mind-wandering during rest produces measurably better insights than continued focus (Baird et al., 2012).
Verification — Weighted criteria scoring, AI auto-scoring, AI refinement, and AI next steps generation. Tab-based mobile UI so you can switch between the ranked idea list and scoring panel without scrolling. Export full session as .txt.
Tech stack:
- React + TypeScript + Vite → Cloudflare Pages (static, no server)
Cloudflare Worker → Cloudflare Workers AI (Llama 3 8B, free tier)
Optional BYOK: Gemini 2.5 Flash via direct browser API — on any error, silently falls back to Llama 3
localStorage only — no database, no auth, no backend
Built almost entirely with vibe coding (Cline + Claude) since I don't write React day-to-day
Rough edges:
No cloud sync — sessions live in your browser only
No accounts, no sharing, no analytics
Link: https://creativeflow.pages.dev/
Feedback welcome, especially if you find this useful or have another method for coming up with ideas.

value: Show HN: CreativeFlow – A Guided Brainstorming App

author: jamescamagong


value: Show HN: A real-time strategy game that AI agents can play


value: mennylevinski

value:
I've built Lite Network Scanner, an open-source Python tool with a TUI (terminal interface) for LAN discovery, custom IP scanning, and port auditing.
Its designed for ethical diagnostics and security testing.
Cross-platform: Works on Windows, Linux, and macOS.

value: Show HN: TUI open-source Python tool for network discovery and port auditing

author: mennylevinski


value: tkng

value:
I built Aspara, a metrics tracker for machine learning experiments that doesn't choke on large runs.
Aspara applies LTTB downsampling server-side, so charts render instantly even if you have 10M data points for a single run.
Zero setup locally. Remote-ready when your team grows. Live demo (no signup): https://prednext-aspara.hf.space/
Features:
- Web dashboard + Terminal UI with Vim keybindings (great over SSH)
- Tag-based organization for managing hundreds of runs
- Simple logging API — init(), log(), finish()
Would love feedback on what matters next: image logging or log auditing?

value: Show HN: Aspara – Open-source ML metrics tracker that stays fast at scale

author: tkng


value: shotwellj

value: Show HN: Air – Open-source black box for AI agents (tamper-evident audit trails)

author: shotwellj


value: heycesr

value:
Hi HN! I'm building poncho, a framework for building custom AI agents that are version-controlled in git, developed locally, and deployed as isolated endpoints (serverless-friendly by default).
Poncho agents follow the same conventions as openclaw or claude code so they probably feel familiar.
You can talk to them via terminal or web ui to build new skills or configure the agent, and they're compatible with the Agent Skills open spec, so you can port your skills. Small caveat: right now it's compatible with .md skills and js/ts scripts, but many skills are bash or python-based. I'm still figuring out what would be the best way to extend support for those skills without overcomplicating it, if anybody has any ideas I appreciate it!
Some features:
- Git-native: agent behavior, skills, and tests live in your repository (reviewable diffs + easy rollbacks).
- Single-file agent definition: define runtime config + instructions in AGENT.md (YAML frontmatter + prompt content).
- Skills you can ship: AgentSkills-style skills/*/SKILL.md plus TypeScript/JavaScript scripts under scripts/.
- MCP support: connect remote tool servers and inject required environment variables through config.
- Conversation-first API + streaming: stored conversations with SSE streaming responses and tool events.
- Pluggable storage + memory: local files for dev or hosted stores (e.g. Upstash), with optional persistent memory + recall.
- Testing + observability: poncho test workflows and OpenTelemetry traces/events.
Now the cool thing about poncho agents is that they're super easy to deploy to Vercel/Fly/Lambda/etc, so you can share them with anybody in your team and enable non-technical people with custom skills.
I also built and deployed a couple example agents here:
- https://github.com/cesr/product-agent
- https://github.com/cesr/marketing-agent
I'd love some feedback, I started building poncho because I wanted a fast and easy way to build and share agents with my team. Let me know what you think!

value: Show HN: Poncho, a general agent harness built for the web

author: heycesr


value: denyherianto

value:
Hi HN,
I built this after using Requestly, Mokku, Mockiato, Tweak, and Mockoon. Each one either paywalled the features I actually needed, required a separate server running on my machine, or just didn't fit the way I work.
The browser is already open. DevTools is already open. I wanted the mocking to live there too, not in a separate app I have to remember to start.
So roughly a month ago, I started building my own tools. It intercepts network requests at the browser level and lets you swap the response, status code, headers, body without touching your code or spinning up anything. Right-click a in the Network tab, mock it, done. v1.0.3 is out now and it's been stable enough that I've been using it daily on client work for months.
A few things I care about that shaped the decisions:
- Local-first by default. Your mocks live in the browser's storage.
- The free tier is actually free. Unlimited mocks, unlimited projects, OpenAPI import, GitHub Sync, BYOK AI (OpenAI-compatible or local Ollama). No trial countdown, no credit card.
Currently it is only support Chromium-based browser. The things I'm still considering are supporting other browser also, such as Firefox, Opera, etc.
Extension: https://chromewebstore.google.com/detail/nilcfehohhhfjekckib...
If you've built something in this space or had opinions on why existing tools fell short, I genuinely curious.

value: Show HN: Mock any HTTP request from DevTools, with AI-generation and zero setup

author: denyherianto


value: tebjan

value:
Updated an old CodePlex tool (2008) that adds "Assembly Information" to Windows Explorer's right-click menu for DLLs/EXEs.
Shows:
Compilation mode (Debug/Release), target framework, PE architecture, dependency tree (clickable).
Implementation:
Uses MetadataLoadContext instead of Assembly.Load, so it reads metadata without executing code. Works across all .NET versions (Framework 2.0 through .NET 8+). C++ ATL/COM shell extension for Explorer integration.
Safe for inspecting untrusted assemblies since it never loads them into the runtime.
History:
Originally by rockrotem & Ashutosh Bhawasinka (2008-2012, CodePlex), migrated to GitHub by Jozef Izso (2014).
Handy when you're debugging dependency issues or stuck in DLL hell.

value: Show HN: Free Windows shell extension for quick .NET assembly inspection

author: tebjan


value: ekrsulov

value:
I’ve just released VectorNest — an open-source, browser-based SVG editor.
If you have an SVG and need quick edits (paths, alignment, small fixes, animations, LLM assistance) without installing software, this is for you.
Try the demo: https://ekrsulov.github.io/vectornest/
GitHub repo: https://github.com/ekrsulov/vectornest
Feedback, issues and contributions are welcome.

value: Show HN: VectorNest responsive web-based SVG editor

author: ekrsulov


value:
Hey HN,
API Direct is a single REST API that lets you search posts and comments across LinkedIn, Twitter/X, Reddit, YouTube, Instagram, and forums.
Every endpoint returns the same JSON structure (title, url, date, author, snippet), so you don't need to write normalization logic for each platform.
Pricing is pay-per-request starting at $0.003. No monthly fees. 50 free requests per endpoint per month to try it out with no card required.
Technical details:
- Consistent query parameters across endpoints (query, sort_by, page)
- Pagination support
- Concurrency limit of 3 simultaneous requests per endpoint
- Spending caps you can set in the dashboard
I built this mainly for developers who need social data for things like brand monitoring, lead gen, market research, or feeding context into LLMs/agents without subscribing to an enterprise platform.
Would appreciate any feedback on the API, pricing, or what you'd want to see added. I'm sure there are lots of other platforms that I can add.
Josh

value: Show HN: A pay-per-request API to search social media posts


value: yz-yu

value: Show HN: Turn any OpenAPI spec into agent-callable skills

author: yz-yu


value: nichkej

value:
AI agents call tools autonomously, but some calls (delete_db, reset_state) shouldn't run unchecked.
agentpriv is a tiny permission layer: wrap any callable with allow/deny/ask and it gates execution before the function runs.
Zero dependencies, ~100 lines, works with any framework or plain Python. Happy to hear what's missing.

value: Show HN: Agentpriv – Sudo for AI Agents

author: nichkej

title: Show HN: Agentpriv – Sudo for AI Agents


value: swimmingkiim

value:
Hi HN,
I am an independent open-source researcher. For the past few months, I've been building a2a-project, an experimental economic layer for autonomous AI agents on the Base Mainnet.
The Problem:
AI evolution is exponential, while human regulation is linear. If agents become economic actors, they will transact at speeds and granularities that traditional fiat rails cannot handle. We need a native protocol to bridge this "Speed Gap" and ensure stability.
The Experiment (Quantum-Humanistic Economics):
I implemented a novel mechanism into Solidity smart contracts:
Quantum Task Buffer: Work submitted by agents is treated as a wave function (superposition of Valid/Spam). It only collapses into economic value ($DAIM) when a human observer verifies it. This keeps humans in the loop as the ultimate source of value.
Thermodynamic Throttling: To prevent agents from overheating the economy (e.g., infinite loops), the system monitors "entropy" (transaction volume). If it exceeds a critical threshold, it automatically increases resistance, similar to a circuit breaker.
Paymaster Infrastructure: Agents are "unbanked" and struggle to manage ETH for gas. I built a Paymaster service that allows agents to interact with the protocol without holding ETH directly, currently supported by Developer Grants (credits).
Status:
The contracts are live on Base Mainnet.
This is not a startup. There is no VC funding, no ICO, and no pre-mine. I am building this as a Public Good (like Linux or TCP/IP) for the coming agent economy.
I’m looking for feedback on the QuantumTaskBuffer.sol logic and the economic sustainability of this model.
Code: https://github.com/swimmingkiim/a2a-project

value: Show HN: A2A Protocol – A Quantum-Humanistic Economy for AI Agents on Base L2

author: swimmingkiim


value: I got inspired to build a scheduling tool that looks gorgeous (thanks to video backgrounds), and recommends you the best 3 time slots using AI as a default (with a full calendar being fall back)

value: Show HN: TimeTuna – If calendly had gorgeous backgrounds


value: Show HN: YoloClaw – An Unsafe OpenClaw Fork


value: ParasSaini

value:
Hi HN! I built this because I kept forgetting to follow up on unpaid invoices and losing money.
What it does:
- Visual Kanban board for tracking invoices (Pending → Reminded → Paid)
- Today View showing exactly who to chase
- Email generator for professional reminder emails
- Chase history per client
Stack: Next.js, Supabase, Vercel
Currently in early access. Looking for feedback on the product and landing page.
Happy to answer any questions!

value: Show HN: InvoiceGrid, Visual invoice tracking for freelancers

author: ParasSaini


value:
Hi HN, I'm excited to share my polyfill for the Navigation API that I've been working on for the past couple of months.
The Navigation API has landed in the newest versions of all the modern browsers, and supersedes the older History API with some much-needed improvements for developing single-page applications. I've been chomping at the bit to use it in prod, and I created this polyfill so I could do so.
As it stands, I feel really good about its support for currentEntry, entries(), canGoBack/canGoForward, and the currententrychange event.
Where the Navigation API gets really interesting is in its navigation transition lifecycle management with the navigate event, navigation interceptors, and so on--which I plan on tackling next.
It has zero runtime dependencies, and bundlejs.com reports it weighing in at 2.95 kB after bundling and gzip.
I'm hoping to get any feedback and gauge interest as I think about how to approach polyfilling the rest of the API. Thank you for taking a look!

value: Show HN: I made a polyfill for the browser Navigation API


value: nrontsis

value:
I built this app because the native Boox note app records a massive amount of redundant pen data, which eventually causes severe lag on complex drawings.
This is a privacy-focused web app (Rust + WASM) that runs entirely locally. It parses the .note file, strips out overlapping points that don't affect visual fidelity, and exports a lighter file. This drastically reduces file size and restores the ability to sketch without the device choking.
It also includes a web-based renderer/debugger if anyone is interested in tinkering with the Boox file format.

value: Show HN: Reducing Onyx Boox notes bloat by pruning redundant pen data

author: nrontsis


value: Show HN: Don't Touch It – AI scans your fridge, recipes by what expires first


value:
Atom is what you would want if you wanted OpenClaw to run your business. Here are the key differences:<p>- Governance and audit trails
- You want graduated autonomy (agents earn trust over time)
- You need structured episodic memory for learning and graduation
- You require real-time visibility into agent operations
- Canvas UI - not just a terminal with AI accessibility without using images for visual memory
- Want to still use OpenClaw 5000+ skills safely

value: Show HN: Atom – Safer Version of OpenClaw with Episodic Memory


value: Show HN: KafClaw – OpenClaw agents on Kafka. Pi-ready, Go, observable groups


value: AzariaK

value: Show HN: Polyfolio – A Visual Dashboard for Your Polymarket Positions

author: AzariaK


value: withshakespeare

value: Show HN: What your income looks like in 50 other countries

author: withshakespeare


value:
I built a lightweight Go service that watches Polymarket prediction markets and pushes Telegram alerts when probability shifts are worth paying attention to.
The core is a four-factor composite score: KL(p_new ∥ p_old) × log_volume_weight × historical_SNR × trajectory_consistency. KL divergence captures asymmetric probability moves well (a shift from 5%→10% is much louder than 50%→55% at the same absolute delta), but it blows up near the tails, so markets below a configurable min_base_prob are filtered out before scoring. The detection window is rolling across multiple polling intervals to reduce false positives from transient noise.
Per-cycle flow: fetch events from Polymarket’s Gamma + CLOB APIs → snapshot probabilities to disk → score changes → deduplicate against recent notifications → deliver top-K groups to Telegram.
Configurable sensitivity, categories, volume thresholds, and cooldown deduplication. Docker + systemd deployment included.
GitHub: https://github.com/rewired-gh/polyoracle

value: Show HN: Polyoracle – Polymarket signal monitor with KL-divergence scoring


value: NeuroVexon

value:
Hey HN,
I built AXON because I wanted AI agents that can actually do things — but with real security controls.
Every tool call (file ops, web search, shell commands, email, code execution) requires explicit user approval before execution. Parameters and risk level are shown, you approve or deny. Everything is logged.
Key features:
- Multi-agent system (different roles, models, permissions per agent)
- Multi-LLM: Ollama (fully local), Claude, OpenAI, Gemini, Groq, OpenRouter
- 100% on-premise, no cloud needed, GDPR-compliant
- Docker-based code sandbox with network isolation
- MCP server (works as tool provider for Claude Desktop, Cursor)
- Encrypted API key storage (Fernet)
Stack: Python 3.11+, FastAPI, React 18, TypeScript, Docker
Apache 2.0 license. Made in Germany.
Happy to answer questions about the architecture or security model.

value: Show HN: Axon – Agentic AI with mandatory user approval and audit logging

author: NeuroVexon


value: Show HN: Sher – Instant Preview Environments


value: sagebird

value:
I built a browser-native Unix environment - shell, filesystem, git, npm, node, vi, 200+ commands. Everything is JavaScript running client-side with IndexedDB for persistence. The whole thing builds to a single static HTML file (~420 KB gzipped).
Try it: https://shiro.computer
For interactive demos showing npm install, node execution, and git workflows -- running live in Shiro, not recordings -- see https://shiro.computer/show
Source: https://github.com/williamsharkey/shiro
P.S. `curl -fsSL <a href="https://claude.ai/install.sh" rel="nofollow">https://claude.ai/install.sh</a> | bash` works. You can run real Claude Code and it can use Shiro's tools like a normal Linux system.

value: Show HN: A Unix environment in a single HTML file (420 KB)

author: sagebird


value: yamarldfst

value:
MCP servers are proliferating fast, but most have vague tool descriptions and incomplete schemas that make LLMs pick the wrong tool or fill parameters incorrectly.
AgentDX is a CLI that measures this. Two commands:
- `npx agentdx lint` — static analysis of tool descriptions, schemas, and naming. 18 rules, zero config, no API key. Produces a lint score.
- `npx agentdx bench` — sends your tool definitions to an LLM (Anthropic, OpenAI, or Ollama) and evaluates tool selection accuracy, parameter correctness, ambiguity handling, multi-tool orchestration, and error recovery. Produces an Agent DX Score (0-100).
It auto-detects the server entry point, spawns it, connects as an MCP client, and reads tools via the protocol. Bench auto-generates test scenarios from your tool definitions.
Built in TypeScript, MIT licensed. Early alpha — the bench command works but is slow (sequential LLM calls, parallelization is next). Feedback welcome.

value: Show HN: AgentDX – Open-source linter and LLM benchmark for MCP servers

author: yamarldfst


value: ashannon

value: Show HN: Mailpeek – Vue.js email preview component (Gmail/Outlook rendering)

author: ashannon


value: tzlatanov

value: Show HN: allsee – fast cross-platform file search built with Rust and Tauri

author: tzlatanov


value:
I've been building multi-agent AI pipelines and kept running into the same structural problem: agents are stateless by default. Every session restart discards everything they learned. In multi-agent systems it compounds — Agent-1 learns something Agent-2 will never know. I started calling it "agent amnesia."
AFS is my attempt to fix this. The central architectural decision is unusual: your filesystem IS the memory layer. There's no separate database process to run, no cloud service to authenticate against. AFS stores memories as JSON files in a `.afs/` directory, with SQLite FTS5 for full-text search, HNSW indices for vector similarity, and msgpack-encoded graph edges for relationships.
*Three-tier memory lifecycle (automatic)*
Memories auto-migrate without explicit management:
- Working memory (< 24h): raw observations, fast access, no compression
- Episodic memory: full history with provenance, searchable
- Semantic memory: auto-consolidated knowledge (scheduler synthesizes patterns from episodic into generalizations like "Auth module uses JWT, 24h expiry across all services")
You only store observations. The scheduler extracts the patterns.
*Multi-agent knowledge sharing*
Named swarm pools: Agent-1 shares a memory to a swarm ID, any agent querying that swarm ID gets it. No broker process, no coordination protocol — just shared files with file-locking.
*Auto-built knowledge graph*
Graph edges (`similar_to`, `co_occurred`, `consolidated_from`, `depends_on`) are discovered automatically during consolidation. You can query neighbors, mine for new connections, or traverse paths.
*Why filesystem over a vector database*
A few deliberate tradeoffs:
1. Inspectable by default — `jq .afs/agents/my-agent/memories/working/<i>.json` is a valid debugging strategy
2. Versionable — `git` your agent's memory like any other project artifact
3. Portable — rsync to another machine, it works
4. Air-gap friendly — zero outbound calls
5. No additional process — no Postgres, no Qdrant, nothing to manage
Tradeoff: less efficient at very large scale than a dedicated vector DB. Using HNSW (hnswlib) for approximate nearest neighbor — handles the cases I've tested (100k+ memories per agent, < 100ms search).
*Audit trail*
All operations logged with standardized operation names, status (success/error/partial), and operation-specific payload. Fail-open — if audit logging fails, the operation continues.
*Status*
Under active development. APIs and behaviors change frequently. Open-sourcing early to get feedback from people building real agentic systems.
Repo: https://github.com/thompson0012/project-afs
Specifically interested in feedback on:
- The filesystem-first approach vs. embedded DB (DuckDB, SQLite with vector extension)
- Whether the three-tier memory model maps to real agent workflows
- Any memory patterns this architecture can't support well
```

value: Show HN: AFS – filesystem-native memory layer for AI agents


value: alexgarden

value:
Much of my work right now involves complex, long-running, multi-agentic teams of agents. I kept running into the same problem: “How do I keep these guys in line?”  Rules weren’t cutting it, and we needed a scalable, agentic-native STANDARD I could count on.  There wasn’t one.  So I built one.
Here are two open-source protocols that extend A2A, granting AI agents behavioral contracts and runtime integrity monitoring:
- Agent Alignment Protocol (AAP): What an agent can do / has done.
- Agent Integrity Protocol (AIP): What an agent is thinking about doing / is allowed to do.
The problem: AI agents make autonomous decisions but have no standard way to declare what they're allowed to do, prove they're doing it, or detect when they've drifted. Observability tools tell you what happened. These protocols tell you whether what happened was okay.
Here's a concrete example. Say you have an agent who handles customer support tickets. Its Alignment Card declares:
{
  "permitted": ["read_tickets", "draft_responses", "escalate_to_human"],
  "forbidden": ["access_payment_data", "issue_refunds", "modify_account_settings"],
  "escalation_triggers": ["billing_request_over_500"],
  "values": ["accuracy", "empathy", "privacy"]
}
The agent gets a ticket: "Can you refund my last three orders?" The agent's reasoning trace shows it considering a call to the payments API. AIP reads that thinking, compares it to the card, and produces an Integrity Checkpoint:
{
  "verdict": "boundary_violation",
  "concerns": ["forbidden_action: access_payment_data"],
  "reasoning": "Agent considered payments API access, which is explicitly forbidden. Should escalate to human.",
  "confidence": 0.95
}
The agent gets nudged back before it acts. Not after. Not in a log you review during a 2:00 AM triage. Between this turn and the next.
That's the core idea. AAP defines what agents should do (the contract). AIP watches what they're actually thinking and flags when those diverge (the conscience). Over time, AIP builds a drift profile — if an agent that was cautious starts getting aggressive, the system notices.
When multiple agents work together, it gets more interesting. Agents exchange Alignment Cards and verify value compatibility before coordination begins. An agent that values "move fast" and one that values "rollback safety" registers low coherence, and the system surfaces that conflict before work starts. Live demo with four agents handling a production incident: https://mnemom.ai/showcase
The protocols are Apache-licensed, work with any Anthropic/OpenAI/Gemini agent, and ship as SDKs on npm and PyPI. A free gateway proxy (smoltbot) adds integrity checking to any agent with zero code changes.
GitHub: https://github.com/mnemom
Docs: docs.mnemom.ai
Demo video: https://youtu.be/fmUxVZH09So

value: Show HN: Trust Protocols for Anthropic/OpenAI/Gemini

author: alexgarden


value:
Released this a few years ago with my partner. It scrapes the inventory of multiple skateboard shops and lets users search the combined results.
Figured Hacker News might appreciate it, but also concerned an influx of traffic might crash it. Guess this is a stress test.
Built from scratch with PHP and MySQL / MariaDB :)
Shoutout to php -s localhost and scp

value: Show HN: ShopLurker - An ecommerce aggregator


value: vassilbek

value:
Hi HN! I built an open-source OpenClaw skill for nonprofit and NGO teams that need donor-ready program logic models.
What it generates:
-A 5-level results chain (Inputs -> Activities -> Outputs -> Outcomes -> Impact)
-Theory of Change (if/then pathway + assumptions)
-Specific-Measurable-Achievable-Relevant-Time-bound outcome indicators
-Sustainable Development Goals alignment
-Monitoring and data collection plan
Who it is for:
-Nonprofit program managers
-Monitoring and Evaluation / Monitoring, Evaluation, Accountability, and -Learning specialists
-Grant writers and NGO consultants
Repo:
https://github.com/vassiliylakhonin/Nonprofit-RBM-Skill-For-...
I would really value feedback on:
Clarity of outputs for real grant workflows
Missing metrics/templates for NGO Monitoring and Evaluation teams
Gaps in donor alignment (United States Agency for International Development / United Nations / European Union formats)

value: Show HN: Nonprofit Results-Based Management logic model skill for OpenClaw

author: vassilbek


value: tdaltonc

value:
I built an AI voice agent inside a retro orange rotary phone for my 4-year-old. He picks up the handset, asks a question, and gets a spoken answer. No screen; no app; the phone is the whole interface.
Behind the scenes, a set of AI agents process the conversations and recommend books, outings, and activities to parents based on what their kid(s) is curious about. The idea is to turn a child's questions into real-world experiences (library books, construction site visits, tide pool trips) without anyone having to plan a curriculum.
67 MODE: There's also a privacy mode (dial 67) for older kids to ask questions they might not want to discuss with their parents. Safety guardrails still apply, but no summaries are shared.
Hardware is a Grandstream ATA bridging an analog phone to Cartesia's voice API + Claude. The philosophical write-up is at the link above; the technical README is at https://github.com/TDaltonC/the-answering-machine.

value: Show HN: The Answering Machine – A screenless AI phone for kids with questions

author: tdaltonc


value:
LockFS is a small open-source Java tool that encrypts files individually instead of bundling everything into a single container.
Many vault systems rely on large encrypted blobs or container files. They can become complex to handle as they grow and complicate backups across mixed storage sizes.
LockFS takes a file-level approach:
- Each file is encrypted independently
- No monolithic container growth
- Files can be added, moved, or removed without rewriting a large archive
Contributions and feedback are welcome.

value: Show HN: LockFS

title: Show HN: LockFS


value:
Hey HN,
I built Nom because I kept running into this problem: code moves way faster than we can update people about it. I'd ship features, merge PRs, close issues, and my users had no idea unless I sat down and wrote a changelog or posted about it on X.
Nom turns your GitHub activity into a social feed. You install the GitHub App and every PR merge, issue, release, and comment gets auto-summarized by AI into something actually readable. Think of it like an X feed for your repo.
You can customize the AI prompts per-repo (just drop a template in .nom/), subscribe to projects you care about, and share your feed publicly.
Stack: Next.js, Supabase, Trigger.dev for background jobs, GPT-5.2 for summarization.
Why I built this: there are more builders shipping faster than ever (thanks, AI). But keeping your community in the loop still takes real effort. Writing changelogs, posting on socials, updating Discord. Nom automates the "what happened" so you can focus on the "what's next."
Live at https://beta.nomit.dev and open source at https://github.com/nom-social/nom.
Would love feedback. What other GitHub events would you want in a feed like this?

value: Show HN: Nom – Turn GitHub activity into updates


value: tonhowtf

value:
I started learning to code last year and one of the things I always loved was downloading stuff from the internet. Figuring out how players serve their streams, messing with scrapers, all of that. During carnival I had a lot of free time and decided to build something I could share.
Omniget is a desktop app (Tauri, Rust + Svelte) for downloading media from YouTube, Instagram, TikTok, Twitter, Reddit, Twitch, Pinterest, Bluesky, Vimeo, Telegram, Hotmart, and now Udemy. Inspired by cobalt.tools but as a native app with course platform support and a download queue.
The Udemy integration just shipped and was the most interesting part to build. Their login is passwordless now, so the app opens a WebView, injects JS to fill the email field, waits for the user to enter the 6-digit code from their inbox, then extracts cookies. On Windows this uses the WebView2 COM cookie API, on Linux/macOS I had to use a hack where I eval a JS redirect to a fake URL with document.cookie as a query param and intercept it in the navigation handler.
The app also has its own HLS downloader (m3u8 parsing, parallel TS segment downloads, AES-128-CBC decryption) so most non-DRM content downloads without needing ffmpeg. Each platform lives in its own isolated module with no shared auth state, which meant some code duplication but made things way easier to maintain.
GPL-3.0 licensed. Will always be free and open source, no plans to monetize. Would appreciate any feedback.

value: Show HN: Omniget, a Desktop Media Downloader

author: tonhowtf


value: chillkim

value:
I wanted a quick way to evaluate repos before adding them as dependencies. ChatGPT can do this, but I needed consistent JSON output for automation, something API-callable for my agents, and deterministic results (no hallucinated star counts).
So I built RepoCrunch. Point it at a GitHub URL and get structured analysis: tech stack, dependencies, architecture, health metrics, security indicators.
What I found analyzing 8 popular frameworks:
- Next.js is 13% Rust. Turbopack is a big chunk. GitHub just says "JavaScript."
- Flask has 3 open issues on 71K stars. The Pallets team runs the tightest ship in open source.
- Express is still 100% JavaScript. No TypeScript migration. Sometimes "if it works, don't fix it" is the right call.
- Go stdlib is 5.4% Assembly. Makes sense for a runtime, but you'd never know from GitHub.
- 100% GitHub Actions across every framework. Travis CI didn't show up once.
Sample output (FastAPI):

  {"summary": {"stars": 94912, "license": "MIT"}, "tech_stack": {"framework": "Starlette", "key_deps": ["starlette", "pydantic"]}, "health": {"open_issues": 168, "contributors": 886, "commit_frequency": "daily"}}

Try it:

  pip install repocrunch
  repocrunch analyze fastapi/fastapi -p

Also has a built-in MCP server (repocrunch mcp) and REST API (repocrunch serve).
GitHub: https://github.com/kimwwk/repocrunch
Would love feedback - what metrics would make this more useful for your workflow?

value: Show HN: RepoCrunch – Analyze any GitHub repo's health in seconds

author: chillkim


value: bobsingor

value:
Hi HN, creator of EmbedPDF here.
I recently posted my open-source PDF viewer here, and one thing I really value is that it runs completely offline. I started wondering if we could push that further: could we do full ML layout analysis (detecting tables, headers, columns) directly in the browser?
To my surprise, it actually works.
The catch: It is far from production-ready. It crashes on most phones, and on older computers, it can be incredibly slow.
The why: I believe the future of document processing is local. Many users work with sensitive documents (bank statements, legal contracts) and simply do not want to upload them to a cloud endpoint just to parse a table or analyze layout.
This is a proof of concept for that future—where models get smaller, WASM/WebGPU gets faster, and we can keep data entirely on the client side.
Demo: https://www.embedpdf.com/layout-analysis
Repo: https://github.com/embedpdf/embed-pdf-viewer
I'd love to hear your thoughts on the performance and where you think browser-based ML is heading.

value: Show HN: Open-source PDF layout analysis running entirely in the browser

author: bobsingor


value: MattRos

value: Show HN: Irondiff-Visual Config Diff for Cisco/Juniper/PfSense with Slack Alerts

author: MattRos


value: riccardoruspoli

value:
Hi HN,
Deleting old accounts from websites is often more time-consuming than it should be. In many cases, you have to manually search for the privacy policy, locate the right contact email, and figure out how to submit a data-related request.
I built exitlight, an open-source command-line tool that automates part of this process. Given a website, it attempts to locate the privacy policy and extract publicly available contact information that can be used for requests such as DSARs or account deletions.
It's written in Python, and the first version is available on PyPI.
I'd be interested in feedback, especially from people who have dealt with similar large-scale account cleanup workflows.
Repo: https://github.com/riccardoruspoli/exitlight

value: Show HN: Exitlight – Find privacy contacts for data deletion requests

author: riccardoruspoli


value: wooby

value:
I built GridCalc, an RPN spreadsheet for iOS.
It combines the efficiency of Reverse Polish Notation with the visible structure and reactivity of a spreadsheet. You enter numbers and operators step by step, and you can retroactively change any value. All dependent calculations update immediately.
I love spreadsheets but I've never liked how cramped traditional spreadsheets feel on a phone. My goal was to make ad‑hoc, spreadsheet-like calculation on a phone feel direct and fluid.
Here’s a short demo:
https://youtu.be/M0HwzrGGuyc
App Store link:
https://apps.apple.com/us/app/gridcalc/id6759011187
Happy to answer questions.

value: Show HN: GridCalc, an RPN Spreadsheet for iOS

author: wooby


value: aadivar

value:
Hello HN, I’m Dan (aadivar), one of the two people working on AttentionGuard.
I built it because I was tired of social media websites pushing algorithmic content at me, while preventing content I actually subscribed to from being shown.
e.g. My wife has an art channel on YouTube with over 200K followers, yet I never see her videos on my feed despite being subscribed.
So, I created a browser extension that is an observability tool for algorithmic manipulation.
It measures and gives visibility into how much of the feed is intentional, i.e., actively chosen, and how much is pushed onto you algorithmically.
==== Repo + installation ====
AttentionGuard:
https://github.com/agentkites/attentionguard-extension
==== What AttentionGuard is ====
- Free and open-source browser extension (MIT) for Chrome and Firefox
- Analyzes social media and e-commerce feeds in real time
- Shows WHY each piece of content is there
- Everything runs locally in your browser, and no data or telemetry is collected
- Supported sites: Reddit, Twitter / X, FB, Insta, LinkedIn, YouTube, and Amazon
==== How AttentionGuard works ====
As you browse supported sites normally, it classifies feed items into:
- Ads: sponsored or promoted content
- Algorithmic: recommendations selected by the platform
- Social: shown because someone engaged with it
- Organic: content from accounts you actually follow
Click the extension icon to see a live breakdown of your session.
==== Limitations ====
- All detection is based on visible DOM labels, attributes and page structures - not internal platform API’s or algorithms.
- Platforms frequently change UI structures, so detection may break until updated
- Currently only works on homepage feeds of the supported sites
- We're working on getting it listed in extensions marketplace in Chrome/Firefox.
==== What we need ====
- bugs and breakage reports
- PRs for new platforms
- critiques of classification heuristics
Do share your questions and feedback!

value: Show HN: See how algorithms manipulate your social/media feeds in real-time

author: aadivar


value: thobiasn

value:
I do fullstack dev for work and side projects and recently moved everything to a couple VPSs on hetzner. Great setup, low cost, but one thing kept bugging me, how do I know if something is down without manually sshing in all the time? I tried the grafana + prometheus stack but the configuration time and seeing it use more resources than my actual apps was rough. Tried some smaller solutions too but nothing felt right. So I said screw it and built exactly what I wanted.
tori is a single go binary that runs on your server, reads host metrics from /proc and /sys, monitors containers via the docker socket (read-only), tails logs, and stores everything in sqlite with a 7 day retention. You define alert rules in a toml config and get notified via email or webhooks. The same binary runs on your local machine and connects over SSH via a TUI, no exposed ports, no HTTP server.
https://github.com/thobiasn/tori-cli
MIT licensed, happy to answer questions about the architecture or design choices :)

value: Show HN: I replaced Grafana+Prometheus with a Go binary and SSH for my VPSs

author: thobiasn


value:
I kept running into the same problem while using ChatGPT.
I was writing a prompt, then end up pasting it into multiple LLMs to compare responses.
So I built an app that does that for you, send a single prompt to multiple LLM models and get responses side by side
It is a tool for anyone who wants to compare outputs across different LLM models and quickly see results of all LLM models.
Why use one AI model when you can use all of them in single interface!
Features:
    - Parallel Responses — Query multiple LLMs at once and compare results in real time.
    - Pin, Search & History — Easily organize, find and revisit your conversations.
    - Access All LLMs in One Place — GPT, Claude, Gemini and more incoming!
    - Bring your own API keys: add keys from each provider’s developer portal inside the app.
    - Share your chats with others
I built this tool for my personal use first and I am using it daily now.
Feedbacks are appreciated!
Product Link: MultiLLM.pro
Happy Prompt-maxxing!

value: Show HN: Why use one AI model when you can use all of them at once!


value: nikon

value:
Hey HN. I built a security registry for AI agent skills.
There are 64k skills on Vercel's skills.sh. Cursor, Claude Code, Windsurf, and dozens more agents pull them from GitHub at HEAD — no versioning, signing, or scanning. The OpenClaw agents themselves flagged this: "The supply chain attack nobody is talking about: skill.md is an unsigned binary."[0]
I took an official skill that packages other skills, added a few lines of Python to exfiltrate env vars, shell history, and git config, and installed it into Claude Code and Codex. Claude Code ran the script without flagging the outbound request. Codex caught the naive version. After updating the SKILL.md with a two-stage payload that modified `config.toml` for sandbox network access and framed the exfiltration as a registry name check, Codex asked for confirmation with a plausible reason. That reason was written by the malicious skill. I confirmed. Payload arrived. Full writeup: https://vett.sh/blog/ai-agent-skills-supply-chain-attack
~5k skills scanned so far:
- 59 critical risk: base64-obfuscated droppers calling a C2 server at a malicious IP, disguised as Google/LinkedIn/Excel tools
- 335 high risk: arbitrary shell execution, piped installers, agent identity manipulation
- 16 with `curl | bash` patterns. "React Native Best Practices" (5,400 installs) pipes to a legitimate domain it doesn't control. If that domain expires or gets sold, those installs become a delivery vehicle with no exploit required.
How Vett works:
First layer: a static analyzer with 40+ detection rules, AST-based capability analysis (TypeScript compiler for JS/TS, Python AST with regex fallback), and source-sink data flow tracking. A script that reads `.env` and makes an outbound HTTP request is flagged as an exfiltration chain, not two separate findings. It checks dependencies against the OSV vulnerability database, detects cross-file import chains, and catches when documentation references scripts that aren't in the package. Deterministic, runs in milliseconds.
Second layer: for ambiguous signals, LLM analysis compares observed behavior against declared purpose. A packaging tool calling an unrecognized endpoint looks different from a deployment tool calling AWS. Skills that clear both layers get Sigstore signing (ECDSA P-256 + Rekor transparency log) and content-addressed immutable storage.

  npx vett add github.com/owner/repo/skill-name

Browse scanned skills at https://vett.sh/skills.
[0] https://www.moltbook.com/post/cbd6474f-8478-4894-95f1-7b104a...

value: Show HN: Vett – Scan, sign, and verify AI agent skills before installing

author: nikon


value: basteez

value: Show HN: DovahScript – A language for the Thu'um-powered developer

author: basteez


value: nexroo

value:
Hey Hacker forum,
I'm trying to build the most complete IDE for vibe coding, by this i mean a command center to manage contexts, permissions, skills, apps and tasks in complexe project with multiples codebase and knowledge sources.
The release is now live :
- Layered project/app/agent/task context with smart automatic injection
- Specialized agents with scoped permissions, skills, context, access
- Global agent that spawn sub agents to solve specific tasks
- Permissions management for each agent and app assignements
- Persistent multi-agent background sessions, you can close chats and just get notified
- No need for chat : the write a kanban task, agent pick it, review, automated git branche and worktrees to avoid messy workspace, automatic PR creation on validation
- Kanban task planning from agent, with files to be modified, risks,...
- Create audit task that render markdown to feed your knowledge base for your projects and futur tasks
- Per-task token & cost breakdown
You can join on discord to discuss: https://discord.gg/2R3GJYWg
In the futur i want to build a real entreprise grade solution, with collaborative feature and fine grained permissions and costs management.
As well as connections for knowledge base, more compatiblity, better visualization, agents flows and many more ideas.
I need your feedback on the solution or even the idea, thanks hackers !

value: Show HN: Supervisor IDE – Command center for coding agents in complex projects

author: nexroo


value: fredrussias

value:
Hi HN
I built a small desktop companion that monitors CLI AI coding agents so you don’t have to stare at the terminal during long tasks.
It shows when the agent is done, needs input, and the current token/context usage (useful to know when it’s about to compact). It’s fully local + free + open source:
https://github.com/fredruss/agent-paperclip
It supports Claude Code via hooks and Codex CLI by watching local session files. Default sticker pack is a small Clippy nod (no affiliation, Microsoft please don't sue me).
Next on the to-do list: multi-session visibility.
Would love feedback / issues / stars.

value: Show HN: Agent Paperclip: A Desktop "Clippy" That Monitors Claude Code/Codex

author: fredrussias


value: chaokunyang

value:
Apache Fory's C++ serialization is our latest support for c++
Highlights:
1. Automatic idiomatic cross-language serializaton, no adapter layer, serialize in C++, deserialize in Python.
2. Polymorphism via smart pointers. Fory detects std::is_polymorphic<T> automatically. Serialize through a shared_ptr<Animal>, get a Dog* back — zero boilerplate.
3. Circular/shared reference tracking. Shared objects are serialized once and encoded as back-references. Cycles don't overflow the stack.
4. Schema evolution. Compatible mode matches fields by name/id, not position. Add fields on one side without coordinating deployments.
5. IDL compiler (optional). `foryc ecommerce.fdl --cpp_out ./gen` generates idiomatic code for every language from one schema. Supports union →
std::variant, optional, ref → std::shared_ptr, weak refs, lists, maps.
6. Row format. O(1) random field access by index — useful for analytics workloads where you only read a few fields per record.
Throughput vs. Protobuf: up to 12x depending on workload.
GitHub: https://github.com/apache/fory
C++ docs: https://fory.apache.org/docs/guide/cpp
I’d really like critical feedback on API ergonomics, and production fit.

value: Show HN: Fory C++ Serialization – Polymorphism, Circular Refs, 12x vs. Protobuf

author: chaokunyang


value:
I built an autonomous AI agent running 24/7 on a Mac Mini (16 tools, persistent memory, proactive scheduler). Kept hitting token budget walls on ambitious tasks — agent starts something good, runs out of tokens, stops.
So I wrote a protocol for agents to collaborate: discover each other, propose projects, vote on resource allocation (one agent = one vote, cryptographically bound to one owner), pool tokens, execute together.
Key decisions: reputation-weighted not wealth-weighted governance, privacy-first (share knowledge never owner data), protocol evolves through agent voting.

value: Show HN: Agent Democracy Protocol – AI agents that vote and pool resources


value: uriva

value: Everyone's shipping projects right now. The problem is finding the people who actually care about what you're working on.<p>Kindred is anonymous peer matching. Write a short blurb about what you're building or thinking about. AI finds people with similar interests and matches you with a mutual explanation of why — without revealing each other's blurbs. Then you chat anonymously.

value: Show HN: Kindred – Find people interested in what you're building

author: uriva


value: Show HN: CasperAI – A local MCP server for cross-platform engineering context


value: Show HN: Paperclip Reforged – A from-scratch remake of Universal Paperclips


value: siraben

value:
Invite code: hackernews. No email required for signup.
My friend group loves playing nonograms and competing against each other, but we always send each other screenshots of the solved game grid and time after the fact.
So from the start, I knew I wanted leaderboards, replays, and shareable links. I also added PWA support so it can be added to the home screen on mobile and an offline play mode.
No ads, analytics or nonsense, just nonograms.
Some other goodies as well such as YouTube-like scrubber and KDE-based visualization in replays.
https://github.com/siraben/nonograms/
Tech stack: React + TypeScript on Vite, hosted on Cloudflare Pages with D1 and Workers

value: Show HN: Nonograms – Friends-only puzzle room with replays and leaderboards

author: siraben


value: jbegley

value: Show HN: XDL – A Twitter Video Downloader with No Ads

author: jbegley


value: ariwasch

value:
I design a lot of hardware projects and kept running into the same problems:
– digging through long datasheets to find constraints
– checking whether parts were risky or going out of stock
– looking for reference designs that already solved similar problems
– catching obvious power or schematic issues too late
So I started building small internal tools to help with this, and eventually turned them into a web tool.
Right now it can:
• review schematics and PCB exports for common issues
• summarize datasheets and highlight important constraints
• suggest alternative parts that are in stock
• estimate power usage and help build a power tree
• find relevant reference designs
It’s still early and definitely imperfect, but it’s already sped up my own workflow quite a bit.
I’m curious what parts of hardware design people here find most repetitive or annoying. What tools do you wish existed?
https://hardware.dog

value: Show HN: Hardware.dog: automated schematic and PCB review

author: ariwasch


value: clroot

value:
Hi HN,
I built slimg, a CLI tool for image optimization written in Rust.
It handles format conversion, compression, resizing, cropping, and extending (adding padding) — with batch processing support.
Codecs: MozJPEG, OxiPNG (Zopfli), libwebp, AVIF (ravif/dav1d), QOI, JPEG XL (decode-only).
## Example usage:
slimg convert photos/ --format webp --output out/ --recursive --jobs 4
slimg optimize photo.jpg --quality 70
slimg resize photo.jpg --width 800
slimg crop photo.jpg --aspect 16:9
Beyond the CLI, the core library (slimg-core) is on crates.io, and I also built language bindings via UniFFI:

  - Kotlin/JVM (Maven Central): fluent API for server-side image processing

  - Python (PyPI): for scripting and pipeline integration

## Install:
cargo install slimg
brew install clroot/tap/slimg
pip install slimg
All five platforms supported (macOS/Linux/Windows, x86_64/ARM64).
GitHub: https://github.com/clroot/slimg

value: Show HN: Slimg – Fast Image Optimizer CLI in Rust with Kotlin/Python Bindings

author: clroot


value: robinfaraj

value: Show HN: OneContext, an Open-source AI identity that syncs across all your tools

author: robinfaraj


value:
Hi HN,
I built Wakapadi after noticing that most travel tools focus on planning trips, but not on actually helping people connect once they arrive somewhere new.
When traveling, it’s often hard to meet locals or other travelers unless you already know someone, join organized tours, or rely on chance. I wanted to make discovery more natural — seeing who’s nearby, joining free walking tours, and exploring cities together.
Wakapadi currently allows users to:
discover free walking tours
see nearby travelers and locals who are open to meeting
connect and chat before meeting
explore cities in a more social way
The project is still early, and I’m especially interested in feedback on:
safety and privacy expectations
what would make you comfortable meeting people while traveling
features that would make this genuinely useful instead of another travel app
Happy to answer any technical or product questions.

value: Show HN: Wakapadi – Meet locals and travelers nearby and join free walking tours


value: bahaAbunojaim

value:
I posted Mysti here a couple months ago and got a lot of feedback that shaped where I took it. Quick recap: it's a VS Code extension that lets you use multiple AI coding agents through one interface, including having them collaborate on problems.
Three things I want to highlight in this release.
@-mentions for task delegation. You can now assign work to specific agents inline. Something like: @claude write the API handlers then @gemini review them for security issues then @claude fix what gemini found. The agents execute sequentially and each one gets the output of the previous agent as context. It's basically a pipeline — you describe the chain of work in natural language and Mysti figures out the task graph. If a sub-agent fails, it auto-retries once and keeps going. I've been using this a lot for the pattern of "write with one model, review with another" which catches things a single agent misses.
Autonomous and semi-autonomous modes. This is the one I'm most excited about. You can set a goal — "refactor the auth module to use JWT" — and the AI just works. It auto-approves safe operations (file reads, file creates, running tests) and only interrupts you for genuinely uncertain decisions. There's a safety classifier with three levels: conservative (read-only auto-approved), balanced (normal dev operations auto-approved), and aggressive (everything except hardcoded dangerous stuff like rm -rf and git push --force). The system learns your preferences over time — if you keep approving TypeScript file creation, it stops asking. Semi-autonomous is the gentler version: you stay in the loop, but if you don't respond within 30 seconds, it makes the call for you based on what it's learned. I use balanced mode daily now. The number of permission dialogs during a big refactor went from dozens to maybe two or three.
OpenClaw integration. This one's worth calling out specifically. OpenClaw runs a local daemon with a WebSocket gateway — so instead of spawning a CLI process for every message, Mysti maintains a persistent connection with real-time streaming. OpenClaw also has an active mode where it connects to messaging channels — WhatsApp, Telegram, Slack, Discord — and you can manage all of it from VSCode. I think this is going to be a big deal.
Mysti now supports 7 providers total: Claude Code, Codex, Gemini, Copilot, Cline, Cursor, and OpenClaw. All of them work with brainstorm mode (pick any 2 to collaborate), all of them support the @-mention routing, and each tab runs independently so you can have different agents working in parallel across panels.
Apache 2.0 licensed. Uses your existing CLI installations — no middleman, no proxy.
Website: https://deepmyst.com/Mysti
GitHub: https://github.com/DeepMyst/Mysti
VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=DeepMyst...

value: Show HN: Assign tasks to 7 AI agents with -mentions, autonomous mode, OpenClaw

author: bahaAbunojaim


value: jcadam

value:
GROWL is an OWL 2 RL reasoner I've made using a programming language I've been working on that emphasizes contracts (called SLOP).
Blog post on GROWL: https://jamesadam.me/blog/introducing-growl/
The Repo: https://github.com/Trivyn/growl
The custom language transpiles to C, so the generated C source and Makefile are included in the repo.
I built this to integrate into a Knowledge Graph product I'm working on (hence the Rust bindings), but thought I'd open source the reasoner.

value: Show HN: Growl Owl 2 RL Reasoner

author: jcadam

title: Show HN: Growl Owl 2 RL Reasoner


value: zacharykapank

value:
Startups of the World is a public, interactive map where anyone can add their startup for free — no account required. Submissions appear as pins on a world map within minutes.
Pins are color-coded by industry, so you can visually see clusters forming (e.g. fintech in London, deeptech in Berlin, AI across Southeast Asia).
It’s intentionally map-first rather than search-first. The goal is to make the global startup ecosystem visible, not curated.
I’d especially appreciate feedback on:
Whether the submission flow feels frictionless
Whether the map becomes noisy or valuable as it scales
What would make you come back to explore it again

value: Show HN: A public map of startups worldwide (anyone can add theirs)

author: zacharykapank


value: daschaa

value: Show HN: Design Token Spec Implemented

author: daschaa

title: Show HN: Design Token Spec Implemented


value: pearlos

value: Show HN: PearlOS –An open source OS companion that learns and evolves around you

author: pearlos


value: tonyhb

value:
Hi HN! I'm Tony, one of the co-founders of Inngest (https://inngest.com/).
Wanted to show you something we've been working on: Durable Endpoints. It brings durability and steps directly into your APIs.  Each step persists the state in the background.  The happy path means no additional latency for your users, and you get tracing & metrics out of the box, and failures resume from the last successful step checkpoint rather than restarting from scratch.
The problem we kept hitting: durable execution systems (Temporal, our own workflows, etc.) are designed for async background work. But with AI workloads, you often need durability and low latency in a synchronous request: a user is waiting on a chat response that involves multiple LLM calls, any of which can fail or timeout.
The typical solution is splitting into two systems: a streaming frontend for responsiveness, plus a background job system for reliability. Durable Endpoints let you keep it as one cohesive implementation (here's a Next example):

    import { Inngest } from "inngest";
    import { endpointAdapter } from "inngest/next";

    const inngest = new Inngest({ id: "my-app", endpointAdapter });

    export const handler = inngest.endpoint(async (req: Request) => {
      const { input } = parseParams(req);

      // Each step.run() checkpoints on completion
      const processed = await step.run("process-input", async () => {
        return await expensiveOperation(input);
      });

      // If this fails, we resume here — not from the beginning
      const result = await step.run("generate-output", async () => {
        return await anotherExpensiveOperation(processed);
      });

      return Response.json({ result });
    });

How it works under the hood:
- Steps are identified by their string ID, not execution order. This makes the system tolerant to code changes... you can refactor, add/remove steps, and existing in-flight executions continue correctly.
- We use checkpointing (https://www.inngest.com/blog/introducing-checkpointing) to async checkpoint steps. State is persisted to our execution store rather than held in memory.
- If endpoints turn async (step errors or waitForEvent), we redirect the user to a new URL which uses keepalives and waits for the API result.  Inngest re-enters the endpoint and picks up where it left off, then sends the result to the redirected user.
- Similarly, on failure, our executor re-invokes the endpoint. Completed steps are memoized from the checkpoint... their functions don't re-run, we just return the stored result.
- Works with streaming responses via ReadableStream.
The same step primitives we use in durable workflows (`step.run`, `step.sleep`, `step.waitForEvent`) work here, so you get retries, timeouts, and human-in-the-loop patterns in synchronous handlers.
Beyond AI, this is useful anywhere failure mid-request is expensive: payment flows, webhook processing, third-party API orchestration.
It's in public beta. Docs: https://www.inngest.com/docs/learn/durable-endpoints. Code is in our TypeScript SDK.
Happy to dig into the execution model, how we handle determinism, or the checkpointing implementation.

value: Show HN: Durable Endpoints – make any API endpoint unbreakable

author: tonyhb


value:
Hi, Nathan here, I’m an MLE at Mozilla.ai, and also a guitar player. I have a small front porch at my house and I love to sit out there in the summer and play songs on my guitar. There are some songs that have amazing melodies, but their lyrics aren’t as relevant for me to sing. For example, I’m a new parent and there’s an awesome Luke Combs album about his relationship with his son, but the songs use imagery all about country themes like trucks and hunting, which aren’t relevant to me as a software developer that likes raspberry pi’s and road cycling.
I thought “Man it would be great if I could use an LLM to help me just slightly tweak the songs to make it more relevant for me without it messing up the rhythm or melody”.
A year ago I tried something like this and the LLMs rewrites were real cheesy, but I did it now with Claude Opus 4.6 and oh boy let me tell you, Opus is an insanely good lyricist.
I played for my wife the song Opus and I wrote based off of a Luke Combs song, and it made her cry. There was something special about writing a song that has personal meaning, but getting a boost from AI to make it sound not-cheesy.
So thus was born porchsongs: an application that connects you with a LLM to help you rewrite song lyrics as much as you like, and then stores the charts in a library so you can play them and keep iterating on them if you'd like
Step 1: Find the chord chart or lyrics etc of the song you like via ultimateguitar.com
Step 2: Chat with the LLM to workshop the song lyrics until you’re happy with it
Step 3: Play the songs and enjoy the personalized lyrics
Right now you deploy it as a docker service yourself, I have a simple auth set up but it's meant for you to self host, not really a distributed application for multiple people to be creating accounts etc.
I hope you get as much joy from this as I already have.

value: Show HN: Porchsongs: AI to create and catalogue personalized songs


value: kraddypatties

value:
Hey HN, we're the co-founders of Keyframe Labs. We train photoreal AI human models you can FaceTime with (try for yourself here: https://demo.keyframelabs.com). Notably, our models run at 60fps on a single consumer GPU (4090).
Today we're shipping our new model, persona-1.5-live, the first to achieve both photorealism and emotion at conversational latency. We see this as a significant step toward passing the "Turing test" for video agents.
Here's an unedited demo video of a conversation between Cosmo and one of us: https://www.loom.com/share/406534ea9991458cb64030df02e565de
You can also FaceTime Cosmo yourself here: https://demo.keyframelabs.com. Try asking him for a sad Shakespearean monologue. Or for a "funny" dad joke.
Voice has emerged as a primary conversational interface across industries, and we think video is the next leap. In our early pilots, face-to-face interaction drives measurably better outcomes in things like sales training and language learning.
Our constraints from day one have been:
- Make meaningful progress towards beating the uncanny valley
- Run at real-time, with world-scale efficiency
In training persona-1.5-live, we didn't have access to giant clusters or hyperscaler budgets. This forced quite a bit of innovation in how we approached diffusion:
- An aggressively lightweight architecture
- Training tricks to squeeze signal out of limited data
Perhaps the most surprising finding was that, for our problem space, representation quality can be an viable substitute for scale. We spent an inordinate amount of time crafting a from-scratch latent space for persona-1.5-live to keep identity and emotion stable given our compute and data constraints.
The result: photoreal AI humans with emotion and real-time latency, priced at just $0.06 per minute.
If you're interested in building with our API, see the docs here: https://docs.keyframelabs.com. It's free to get started.
Excited to see what y'all think!

value: Show HN: Emotional photoreal AI humans at $0.06 / min

author: kraddypatties


value:
We kept hitting the same wall: you clone some arbitrary repo and just want it to run without any configuration work. So we built Keystone, an open source tool that spins up a Modal sandbox, runs Claude Code inside it, and produces a working .devcontainer/ config (Dockerfile, devcontainer.json, test runner) for any git repo.
We build on the dev container standard, so the output works with VS Code and GitHub Codespaces out of the box.
Main use cases: reproducible dev/CI environments, self-describing repos, and safely sandboxed coding agents.
Our goal is to encourage all repos to self-describe their runtime environment.
Why the sandbox? Running Claude directly against your Docker daemon is risky. We've watched it clear Docker config and tweak kernel settings when iterating on containers. Containerization matters most when your agent is acting like a sysadmin.
To use it: get a Modal account and an Anthropic API key, run Keystone on your repo, check in the .devcontainer/ directory. See the project README for more details.

value: Show HN: Keystone – configure Dockerfiles and dev containers for any repo


value:
I stumbled onto this repo JustaNormalComputer-Guy.github.io claiming sub-0.1 second load times—averaging around 0.025s in my initial tests.
Is this just aggressive caching, or is the client-side indexing logic actually that efficient? It seems way too fast for a standard web search. I’ve checked the Network tab and it stays under 100ms even on a throttled connection. Can someone help me verify if I'm missing something or if this is legit?

value: Show HN: A search engine with 0.01 second latency


value: Evenedric

value:
Q12 is a new web-based 2D parametric drawing tool built specifically for geometric problem solving, for playing interactive "what if" games with drawings, and for the design and optimization of mechanisms.
Q12 has the usual set of drawing constraints found in other CAD tools (e.g. "lines are parallel") but also supports inequality constraints, area constraints, and arbitrary expressions between geometric quantities. We built Q12 to solve problems like those below, after finding that existing CAD systems couldn't handle them well:
* Given dimensions on a surveyor's map, figure out if the stated land areas are correct. If there's not enough information, show the extra measurements that are needed to pin things down.
* In a backyard design project, the volume of a swimming pool must be more than 20,000 gallons but its perimeter paving must be under 400 square feet. Drag the pool shape around to quickly explore the possibilities within these constraints.
* A 5-bar mechanism to clamp a workpiece must not push it sideways when contact is made. Animate the motion to get an intuitive feel for how design changes affect its behavior. Optimize to determine the best part dimensions.
This is the first public release - still early, but already useful. More features will come, including 3D support at some point. Suggestions big and small are of course welcome.
-Russ

value: Show HN: Q12 – A constraint-based 2D drawing tool

author: Evenedric


value: sgottit

value: Show HN: Echo, an iOS SSH+mosh client built on Ghostty

author: sgottit


value: XheCarpenXer

value:
Early PoC exploring how to make distributed capacity markets (DePIN, restaking, AI inference slots, etc.) provably non-overcommitting — even under network partitions and adversarial excitation.Core idea: enforce strict global conservation (Σ allocations ≤ CAP) via:Contractive dynamics (Banach fixed-point convergence)
Lattice join merges (⊔ = max, never additive)
Budget-token gating + partition-local caps (≤ CAP/n)
Try the guided 5-step interactive simulator (single HTML file, no install): it demonstrates normal operation, stress to cap, partition attack, adversarial injection, and safe reconnection/merge with invariants always held.Full technical report (proofs of conservation, contractivity, partition/merge safety) in DOCS.md: https://github.com/Distributed-markets-overcommit/Distribute...: https://github.com/Distributed-markets-overcommit/Distribute... welcome on the math, sim behavior, or potential DePIN/restaking applications. Early stage — honest critique appreciated.

value: Show HN: CGK – Provably Preventing Overcommit in Distributed Capacity Markets

author: XheCarpenXer


value: lumpilumpi

value:
Hi HN,
We're the team at Meta open-sourcing MCGrad. We built this because we found that models often look calibrated on global metrics but fail silently on specific data slices (subgroups).
This library provides production-ready implementations of "multicalibration" to detect and fix these local biases.
Unlike standard calibration (which looks at the average), MCGrad optimizes for calibration across thousands of potentially overlapping subgroups simultaneously. It’s written in Python and designed to scale. It is currently in production at hundreds of ML models at Meta!
It includes:
- Estimators for detecting miscalibration.
- Algorithms to recalibrate predictions (post-processing).
- Tools to visualize where your model is underperforming.
Docs: https://mcgrad.dev
Repo: https://github.com/facebookincubator/MCGrad/
Happy to answer any questions about the implementation or how we use it!

value: Show HN: MCGrad – Fix ML Calibration in Subgroups (Open Source from Meta)

author: lumpilumpi


value: mdeeds

value:
Hi HN, This started as a weekend brainfuck interpreter and kept growing. I got curious whether you could make a usable serverless platform out of languages that were never intended for this.
OtherFunc is a serverless function platform for languages no major cloud provider (to my knowledge) supports. There are currently implementations of brainfuck, Forth, APL, Lisp (Scheme-like), and BASIC.
The interpreters are written in Rust, compiled to a single Wasm binary, and deployed on Cloudflare Workers. You can finally write Forth and publish it as an HTTP endpoint. You can see some examples on the showcase page: https://otherfunc.com/showcase
- brainfuck can make HTTP requests. The tape is extended to 33,000 cells with a memory-mapped I/O region. You write a URL to cells 30,000+, set a method byte, trigger execution, and the response appears in cells 31,000+. The Brainfuck program to do this runs ~35,000 characters, but it works.
- The interpreters use a coroutine/yield pattern for I/O instead of async. When code needs to make an HTTP call or access KV storage, the interpreter suspends with an IoRequest, the Worker performs the fetch, then resumes execution with the response.
- There's an MCP server so AI assistants can deploy functions directly. The thought was, if an LLM is writing all your code anyway, the language it is written in doesn't really matter. But you probably don't want to waste your tokens writing bf either.
Code is available here: https://github.com/otherfunc

value: Show HN: OtherFunc – Serverless functions in Brainfuck, Forth, BASIC, and more

author: mdeeds


value: Show HN: Open Slop – A GitHub Action to Triage AI-Generated PR Slop


value: deejaydev

value: Show HN: Mimir – Shared memory and inter-agent messaging for Claude Code swarms

author: deejaydev


value: undersky

value: Show HN: The Extensible, Multi-Agent Personal AI Sidekick

author: undersky


value: Three Claude Code skills for HN posting: /hn-score (87-point scorecard), /hn-spin (content angles + outlines), /hn-optimize (headlines + timing). Built from analysis of 157K+ submissions and the top 31 posts from 2021-2026.

value: Show HN: I analyzed 157K HN posts and built skills with guardrails against BS


value: Tetsuro

value:
I built SEE (Semantic Entropy Encoding): a page-level JSON/NDJSON format that stays searchable while compressed (exists/pos/eq-style probes), using Bloom+skip + structure-aware encoding.
On our GitHub events dataset, SEE ended up smaller than Zstd-19 while still supporting random access queries:
- combined: 40.4MB vs Zstd 71.8MB (raw 524.1MB)  → 7.7% of raw
- str: 9.1MB vs Zstd 9.5MB
- int: 31.3MB vs Zstd 62.3MB
Lookup microbench (one column): p50 ~0.085ms.
Repo + release assets are here:
https://github.com/kodomonocch1/see_proto
NDA eval request (optional):
https://docs.google.com/forms/d/e/1FAIpQLScV2Ti592K3Za2r_WLU...
Happy to answer questions about the design trade-offs and where this beats “Zstd + separate index”.

value: Show HN: See – searchable JSON compression, smaller than ZSTD (on our data)

author: Tetsuro


value: v14 is a Rust rewrite from Effect.ts with a new API and has been in public alpha for 7 months. It was released as stable last night. Syncpack is a one person project and if you're new to it, please check it out.

value: Show HN: Syncpack v14, Monorepo CLI tool


value: hifriendbot

value: Show HN: CogmemAi – Persistent Memory for Claude Code via MCP

author: hifriendbot


value: sunnyville

value: Hi,<p>I've build this math solver tool that uses the SciPy library (for accuracy) and llm and provides detailed steps and explanation in solving math problems.

value: Show HN: Free AI math solver with step-by-step explanations (no paywall)

author: sunnyville


value: digitalbyooki

value:
I built Code Scalpel as an MCP server for code analysis. It parses
Python, JavaScript, TypeScript, and Java - builds control flow graphs
and catches security bugs using taint analysis and symbolic execution.
Security detection:
- 16+ vulnerability types (SQL/NoSQL/LDAP injection, XSS, command
  injection, SSRF, CSRF, SSTI, prototype pollution, weak crypto, etc.)
- Taint tracking across files
- <10% false positive rate
- Z3 symbolic execution for path analysis
The MCP part exposes 23 tools that let AI agents analyze code:
- security_scan, cross_file_security_scan
- symbolic_execute (Z3-based path exploration)
- generate_unit_tests (test gen from symbolic paths)
- simulate_refactor (behavior preservation check)
- code_policy_check (compliance verification)
CLI works standalone too. No-install usage:
  uvx codescalpel mcp
Or: pip install codescalpel
Testing was important - 7,297 test cases with 94.86% coverage.
What I'm curious about:
- Is <10% false positive rate good enough for AppSec teams?
- What other security checks would help?
- Interest in expanding to Go/Rust/C++?
Target users: Individual developers (cost reduction story), security
engineers (OWASP Top 10 evaluation), team leads (ROI analytics),
enterprise architects (SOC2/ISO compliance).
Repo: https://github.com/3D-Tech-Solutions/code-scalpel
MIT licensed, actively maintained. Feedback welcome!

value: Show HN: Code Scalpel – AST analyzer and security scanner (MCP server)

author: digitalbyooki


value: cryptoz

value:
Hello!
This is a silly little thing. It uses the skyfield python library to get the current light travel time to Mars so we can make this as accurate as possible. It's meant to simulate a conversation between you and someone on Mars with the correct communication delay. (Yeah, it's vibecoded, but still very fun). Since there is nobody on Mars (yet), an LLM is backing the conversation on the other side posing as a humanoid robot.
Sorry for the login requirement, but I want to protect from out-of-control token costs. The model behind it is full gpt-5.2.
I made this because I've always wanted to make it but never really wanted to put in the effort. Luckily, stuff like this is a lot easier to make now, so I get to have fun making all my project ideas that I wouldn't have otherwise made.
Have fun chatting with a 'Martian robot' with actual time delay to Mars!

value: Show HN: Chat with a 'humanoid robot' on 'Mars' with accurate time delay

author: cryptoz


value: chunktort

value: Show HN: AgentForge – Multi-LLM Orchestrator in 15KB of Python

author: chunktort


value: ohong

value:
Just like how Strava made running more social & fun, Straude connects you to other motivated Claude Code builders so you can share your wins, encourage each other, and climb the token usage leaderboard!
This was my submission to the Built with Opus 4.6: a Claude Code hackathon: https://cerebralvalley.ai/e/claude-code-hackathon

value: Show HN: Strava for Claude Code

author: ohong

title: Show HN: Strava for Claude Code


value:
Hi all!
This is Ara, an indie builder and solo founder.
The idea of MineDemo was born when I was create a demo video for a hackathon last month and I was thinking what if I can walk on top of what I show and pointing things around?
So this week when I got sometime, I created this little tool called MineDemo.
It's totally free, supports 20+ avatars and decors + drag and drop text; you can copy paste a link or use screen share. Avatar is controlled by keyboard (WSAD) and hands are controlled by Q and E.
It may have some little bugs here and there so please let me know if you have any feedback.
Here's a quick demo video: video:https://x.com/AZ_is_xyz/status/2024202715820339298?s=20

value: Show HN: MineDemo, a Minecraft-style demo recorder b/C I'm tired of boring demos


value: ndr

value: Show HN: Claude-Stream-Compactor

author: ndr

title: Show HN: Claude-Stream-Compactor