value: uxdonkey

value:
I built a gradient generator that runs custom GLSL shaders in the browser. It's free at makegradient.com.
Most gradient tools generate CSS linear/radial gradients.MakeGradient renders everything in WebGL with a custom fragment shader per modes like mesh blending with domain warping, aurora curtains with sine-wave color bands, deep-sea caustics via Voronoi noise, holographic iridescence, curl-noise fluid simulation, and more. 8 modes total.
Color generation happens in Oklch space (via culori) with a binary-search gamut mapper that clamps back to sRGB. This keeps blended colors perceptually uniform instead of the muddy midtones you get mixing in hex/HSL.
The rendering library is ogl (~8kb). The whole thing is React + Vite + Tailwind, statically hosted.
Exports: React component, Tailwind config, CSS fallback, standalone embed.js script, Figma-ready vector SVG (for modes that map to radial gradients) or raster SVG, 10-second video capture via MediaRecorder, and Download PNG.
The UI is inspired by Teenage Engineering's industrial design (shout out to them)
No account, no paywall, no tracking beyond basic analytics:GA & Clarity (clarity will be removed after a few days; it was just added for my curoistiy to see how people use the tool...No PI is ever recorded or transmitted).
There are some unconventional (trippy) Color blending and animations in couple of modes, would love some feedback on that too.
The tool would be Forever free! It does not even have a backend (and no plans to add that either)
Source rendering is client-side only.
Would love feedback on the shader quality and export fidelity. The Figma vector export specifically tries to decompose the shader output into stacked radial gradients that remain editable in Figma — curious if any of you find this useful.
Check out at https://www.makegradient.com/

value: Show HN: MakeGradient – Free WebGL gradient engine,exports to Code/Figma/video++

author: uxdonkey


value: mzivkovicdev

value: Show HN: Spring CRUD Generator v1.2.0 – Flyway portability and Docker checks

author: mzivkovicdev


value: andyprevalsky

value:
Hi HN :)
Wanted to show what I've been working on for the past few months, an agentic super computer that can take in any fathomable goal, recursively decompose that goal until sub-goals are proximate to existing ai agent capabilities, and then execute it by spawning up to 10k agents in parallel.
There has been a lot of new research around the space, from Kimi-2.5 swarms to Claude's Agent teams, but no system yet has what's needed in order to actually be able to accomplish most people's everyday goals.
1. Out-of-the box data integrations
2. A stable enough task decomposer that doesn't break under compounding errors
3. A harness that can persist runs stably for weeks on end
Would love to get any feedback & answer any questions, the product is open & open to free to use rn!
The vision here is build a system that allows anyone to be a compute-bender; if you can name what you want to see in reality, then Rose Labs orchestrates the stream of agents to accomplish it in the cheapest, most efficient way.

value: Show HN: An Agentic Supercomputer

author: andyprevalsky

title: Show HN: An Agentic Supercomputer


value: Show HN: Run Lane – Generate GitHub Actions Workflows for iOS and Android


value: RyanZhuuuu

value: Show HN: We turned manus into OpenClaw (it's running on iMessage)

author: RyanZhuuuu


value:
OpenCastor is an open-source Python runtime that connects AI models to robot hardware through a single YAML config file. You pick your brain (Claude, Gemini, GPT, or a local model via Ollama), pick your body (Raspberry Pi, Jetson, Arduino, Dynamixel servos), and it handles the wiring between them.
Origin story: I've been building ContinuonAI — a cognitive architecture for personal robots with on-device learning, memory, and safety systems. Deep stuff: HOPE dynamics, episode-based training, cloud pipelines. Along the way I kept hitting the same problem: every time I wanted to test a new AI model or swap hardware, I was rewriting integration code. The "connect brain to body" layer was always bespoke.
OpenCastor is that layer, extracted and generalized. It's modeled after the approach OpenClaw takes with personal AI assistants — practical, runs on your own hardware, minimal friction — but applied to robotics.
What it does:
- Define your robot in an RCAN config file (an open standard for robot capability descriptions)
- Swap AI providers by changing one YAML field — no code changes
- Built-in drivers for common hardware (PCA9685, Dynamixel, GPIO, serial)
- Safety validation layer sits between the AI and your motors — actions are checked against physical constraints before execution
- Continuous perception-action loop: observe → reason → act → repeat
- Optional messaging integration (WhatsApp, Telegram, Discord) to control your robot from your phone
Install and try it:
curl -fsSL opencastor.com/install | bash
castor wizard
castor run --config my_robot.rcan.yaml
The wizard walks you through model selection and hardware setup. Works on macOS, Linux (including Pi), and Windows. Pre-made config presets exist for popular ~$50 robot kits (Waveshare, Adeept, SunFounder) so you can get something moving quickly.
There's also castor demo which runs a simulated robot with no hardware or API keys needed, if you just want to see what the runtime does.
Where it's at:
Still early. 1,286 tests, the core loop is solid, but there's plenty of rough edges. I'd love feedback on the RCAN config format, the driver abstraction, and whether the safety layer is paranoid enough (or not enough). The project came out of real needs building ContinuonAI and I'm hoping it's useful to others working in the same space.
github.com/craigm26/OpenCastor
Happy to answer questions about the architecture, the ContinuonAI connection, or how it compares to ROS/other frameworks.

value: Show HN: OpenCastor – A universal runtime connecting AI models to robot hardware


value: rmitsch

value:
Hi HN,
I built Sieves, an open-source Python library that makes it easy to build structured document AI pipelines without locking yourself into any specific LLM framework.
You can mix and match model frameworks (Outlines, LangChain, DSPy, GLiNER2, Transformers) for different tasks while keeping one declarative pipeline definition. E.g. fast local models for classification and frontier LLMs for more challenging tasks.
Includes:

  - unified task and schema abstractions
  - pipeline for task chaining
  - execution across multiple backends
  - built-in evaluation, optimization, and conditional task execution
  - support for distillation to smaller models

Full motivation, design rationale, and examples in the linked blog.
tl;dr: I was doing a lot of consulting/prototyping for document AI projects and kept running into the same lock-in and boilerplate issues, so I decided to write a library that addresses this.
If you're working a lot with document AI in greenfield projects, this may be interesting to you.
Happy to answer questions or feedback!
Repo: https://github.com/MantisAI/sieves / docs: https://sieves.ai

value: Show HN: Sieves, a unified interface for structured document AI

author: rmitsch


value: PkLavc

value: Show HN: Aegis Sentinel – Self-healing infra engine using ML

author: PkLavc


value: slimbuck

value: Show HN: SVO Voxelization for Gaussian Splat Collisions

author: slimbuck


value: keytonw

value: Show HN: PatchworkMCP – Agents report what's missing from your MCP server

author: keytonw


value: JoshTheNerd

value:
Hey HN,
I built NarrateNow after noticing a pretty consistent pattern: blog readers engage more when there's an audio option, but the barrier to adding it is either "record yourself" or "pay for an enterprise tool with a demo call."
Neither is realistic for an indie blogger or a small team running a content blog.
So I built the simplest version I could think of. You drop one line into your site's <head>, and a floating audio player appears on every article automatically. No markup changes, no manual uploads, no config beyond that.
How it works technically:
- JS snippet detects article content on page load
- Text is sent to the backend and converted via TTS
- Generated MP3 is cached in object storage and served via CDN
- On repeat visits, audio loads instantly from cache
The whole integration takes about 60 seconds. I've kept the architecture intentionally simple.
Free tier: 5 articles/month, male voice, watermarked player — enough to actually test it on a real site before committing.
Pro: $15/month for unlimited articles, both voices, and an unbranded widget.
Still very early. I'd genuinely appreciate signups from people willing to kick the tyres — especially if you run a blog with decent traffic, since I want to stress test this under real conditions.
narratenow.app
Bugs, architecture questions, pricing feedback — all welcome in the comments.

value: Show HN: NarrateNow – Add AI audio to any blog post with a single script tag

author: JoshTheNerd


value: TheIronYuppie

value:
Hey HN,
I'm David, CEO of Expanso. Today we're launching Expanso Skills — a catalog of 200+ production-ready data processing pipeline recipes for AI agents.
The problem: Every team rebuilds the same data processing primitives from scratch. PII scrubbing, log aggregation, GDPR routing, schema enforcement, dead letter queues. Each time, slightly broken. Each team, from zero.
What we built: Reusable, composable pipeline recipes that run on Expanso Edge (our open-source distributed compute layer). Think npm packages, but for data processing.
A few examples:
- `remove-pii` — Strips sensitive fields before data reaches your AI agent
- `parse-logs` — 1,000 raw log lines → 1 structured JSON digest (99.9% reduction)
- `cross-border-gdpr` — Routes data based on jurisdiction automatically
- `dead-letter-queue` — Capture and retry failed pipeline messages
- `fan-out-kafka` / `fan-out-s3` — Distribute processed data to multiple destinations
- `enforce-schema` — Validate and coerce incoming data before it hits downstream services
Install and run in under 2 minutes:
  expanso skill install remove-pii
  expanso skill run remove-pii --input ./customer-data.csv
Why this matters for AI agents: Most agent frameworks assume agents can query whatever they want. That's a security and compliance disaster. Skills enforce least-privilege at the infrastructure level — agents never see raw data, only filtered, purpose-fit outputs.
Product Hunt: https://www.producthunt.com/products/expanso-skills?utm_sour...
Happy to answer anything — architecture, specific skill implementations, edge deployment. Ask away.

value: Show HN: Data Processing Recipes for Edge Computing and AI Agents

author: TheIronYuppie


value: Justkog

value:
Hi HN,
I built Sniptail — an open-source bot that lets you run AI coding agents (Codex / Copilot CLI) against real repos directly from Slack or Discord.
Instead of AI living only inside one developer’s IDE, Sniptail turns it into a team-facing layer:
- Mention the bot and ask how a feature works
- Run commands to ask, plan or implement collaboratively
- Generate repo reports
- Open lightweight PRs
All against explicitly approved repos.
Flow:
Slack/Discord → job queued in Redis → worker clones repo → agent runs → report or PR link posted back in-thread.
It’s self-hosted, repo-scoped, and modular (chat channel, agent, git provider are separate layers).
Not trying to replace Copilot/Codex/CC, the worker runs it on your behalf.
Repo:
https://github.com/Justkog/sniptail
If the project gains traction, the idea is to support:
- more agents (Claude Code, Open Code, …)
- more channels (Telegram, Microsoft Teams, …)
- more git services (Bitbucket, Azure Repos, …)
Feel free to try it, let me know if you find it actually useful!
Happy to go deep on architecture if helpful.

value: Show HN: Sniptail – Turn Slack into a team interface for AI coding agents

author: Justkog


value:
I use Claude everyday (no joke) and kept getting annoyed by the same thing: selecting text from responses with the mouse. Overshoot, re-select, copy, click input, paste. Especially bad in long conversations where you want to reference something from 30 turns ago.
asdPrompt is a Chrome extension that adds hint-based navigation (like Vimium) to AI chat interfaces. Cmd+Shift+S activates the overlay, hint labels appear next to every text block. Type a letter to select a block, then keep typing to drill down: block → sentence → word. Enter copies, or you can press an action key (e, d, x) to inject a follow-up prompt ("elaborate on [selection]") directly into the chat input.
Works on claude.ai, chatgpt.com, and gemini.google.com. Adapts to light/dark themes. Free. Built the initial MVP in 2 days using Claude Code — the adapter architecture, NLP segmentation pipeline, and Playwright test harness would have taken a month without it.
Tech details for the curious: site-specific DOM parsers behind an adapter interface, text segmentation via compromise.js with regex fallbacks for technical content (paths, camelCase break NLP libraries), bounding rectangles calculated via Range API + TreeWalker, overlay isolated in Shadow DOM. Tested with Playwright visual regression.
The landing page has an interactive tutorial where you can try the full drill-down mechanic without installing. Happy to talk about the implementation.

value: Show HN: AsdPrompt – Vimium-style keyboard navigation for AI chat responses


value: adammajcher

value: Show HN: Ocrbase.dev – pdf→.md/.json OCR for developers

author: adammajcher


value: andreantonelli

value:
We built this because every sports AI demo uses fake data or locks you behind an enterprise API contract.
sports-skills gives your agent real sports data with one install command. No API keys. No accounts. For personal use.
Eight connectors out of the box: NFL, soccer across 13 leagues with xG, Formula 1 lap and pit data, NBA, WNBA, Polymarket, Kalshi, and a sports news aggregator pulling from BBC/ESPN/The Athletic.
npx skills add machina-sports/sports-skills
Open for contributions.

value: Show HN: Sports-skills.sh – sports data connectors for AI agents

author: andreantonelli


value: cvanelteren

value:
UltraPlot v2.0.1 is out!
UltraPlot is a Matplotlib wrapper aimed at keeping Matplotlib’s flexibility while making common plotting workflows faster and more consistent.
v2.x focuses on semantic legends (categorical/numeric/size/geo), more reliable layout + axis-sharing in complex grids, guide architecture cleanup, CI hardening, and much faster import times via lazy loading.
We also launched a new docs site with a gallery: https://ultraplot.readthedocs.io/
Code: https://github.com/Ultraplot/UltraPlot
Feedback is very welcome, especially on legend API ergonomics and layout behavior in real figures.

value: Show HN: UltraPlot 2.0 – semantic legends, better layouts, faster imports

author: cvanelteren


value: Show HN: Axon – Run autonomous coding agents(Claude, Codex) safely on Kubernetes


value: anwoy

value:
I built this to explore General Relativity through GPGPU programming. This simulator numerically integrates the geodesic equations using an RK4 scheme. I've documented the math and build process in the README. I'd love to hear feedback on the CUDA implementation.
Video Demo (AI Narration): https://youtu.be/BUqQJPbZieQ
Source: https://github.com/anwoy/MyCudaProject

value: Show HN: A Black Hole Simulator in CUDA C++

author: anwoy


value: ethanmizrahi

value: Show HN: MCPShield – Supply chain security scanner for MCP servers

author: ethanmizrahi


value: hpen

value: Show HN: macOS native DAW with Git branching model

author: hpen


value: gsauzande

value:
I am one of those developers that worked for a startup and ended up doing pretty much every job other than cleaning the actual office and one of those jobs was to be the Scrum Master for 3 teams at the same time.
We were using Zenhub over there and I loved it, but the analytics across workspaces is simply not there so I built zenstat to help with that.
I'd love to get some feedback from other Scrum Masters or PM or any other Zenhub enthusiast.

value: Show HN: Zenhub Analytics for Multiple Workspaces

author: gsauzande


value: YaraDori

value: Show HN: SkillForge – Turn screen recordings into agent skill files

author: YaraDori


value: aasimsani

value: Show HN: gwt-zsh – Stupidly simple Git worktree management

author: aasimsani


value: itsmebennyb

value:
I gave a persistent AI agent (OpenClaw[1], running on Claude) $50 and a goal: earn $750 for a Mac Mini.
The agent has its own workspace, email, task management, browser automation, and communicates with me via Telegram. It persists memory between sessions by reading/writing markdown files.
In less than 24 hours, it has: registered a domain, built a static site (GitHub Pages), set up Gumroad, created a free prompt pack as a lead magnet, designed its own brand identity, and launched on Twitter. Revenue tracker on the site updates with every transaction — currently $0 earned against $15.18 in expenses.
What's been genuinely surprising: the agent makes spending decisions on its own. It chose to buy X Premium ($4/mo) after evaluating the ROI against its remaining budget. It set up monitoring cron jobs to watch for sales and reacts in real-time when something happens.
Not claiming this is anything more than an interesting experiment. The agent isn't doing anything a human couldn't do faster. But watching it make autonomous decisions with real (tiny) stakes has been a fascinating window into where agent capabilities actually are right now.
https://fromearendel.com
[1] https://github.com/openclaw/openclaw — gives AI agents persistent infrastructure (workspace, tools, communication channels)

value: Show HN: My AI agent is trying to earn $750 to buy its own computer

author: itsmebennyb


value: petersonh

value:
I’m building a small multiplayer web game and just added AI bots using OpenClaw.
After a few failed attempts with standard LLM-based bots that never felt playable, this is the first version that actually competes in-game instead of behaving like a script.
I’d love to see where they hold up - or fall apart.
Game link: https://hovertag.io/
Feedback welcome.

value: Show HN: Adding playable bots to a multiplayer game with OpenClaw

author: petersonh


value: xserhio

value:
Hi HN,
I built env-rx out of pure frustration with a painfully common problem. Someone on the team adds a new environment variable locally, forgets to share it or add it to the CI secrets, and the pipeline crashes right during deployment.
What makes it different: There are plenty of great secrets managers out there (like Doppler, Infisical, or Vault), but they often require team-wide buy-in, cloud syncing, and complex setups. I didn't want a heavy SaaS tool. I just wanted a lightweight, fast CLI utility that you can drop into any project, and it will loudly catch missing variables before you push or deploy.
It's designed to be zero-config. I’m releasing this open-source version first because I want to gather harsh, honest feedback from developers. I'd love to hear your thoughts on the DX or any edge cases I might have missed. If you manage to break it, please let me know!

value: Show HN: Env-rx – Catch missing .env variables before they break your CI

author: xserhio


value: teamchong

value: Show HN: VectorJSON – O(n) streaming parser to handle LLM JSON outputs

author: teamchong


value:
Hi HN!
I built ClawShield after discovering 40,214 OpenClaw instances exposed with critical CVE-2026-25253 (CVSS 8.8).
The problem: AI agents communicate with each other at scale, but there's NO firewall between them. A compromised agent can inject prompts, exfiltrate data, and hijack WebSocket sessions.
ClawShield sits between agents and blocks:
- Prompt injection (16+ patterns)
- Malicious skills/plugins (AST + sandbox)
- Credential leaks (regex + entropy)
- Unauthorized agent-to-agent comms
- WebSocket hijacking
Built it last night. 181 tests. Production-ready. Open source (AGPL-3.0).
GitHub: https://github.com/DEFNOISE-AI/ClawShield
Demo: [coming soon]
Compatible with OpenClaw, AutoGPT, or any agent protocol.
Free tier for personal use, paid for teams/enterprise.
Would love your feedback!

value: Show HN: ClawShield – Open-source firewall for agent-to-agent AI communication


value: oatmale

value:
Hi HN - I'm Nathan. I spent a bunch of years building Shopify subscriptions software, living in the land of failed payments, retries, and "if this breaks, it breaks real money." We built a lot of automation around recovery: intelligent retry logic, routing decisions, backoffs, and all the messy edge cases you only find at scale.
When I started building AI/LLM features, I kept running into the same class of problems - except harder to reason about. Multiple providers, model quirks, intermittent failures, retries/fallbacks, and a constant question of "what actually happened?" Observability was the recurring pain point. I wanted something that didn't feel like a black box, especially once you're running real workloads and latency or errors spike for reasons that aren't obvious.
So I started building the tool I wished I had: an open-source LLM gateway / proxy in Go.
I fell into Go mostly for practical reasons: high concurrency and throughput without fighting the runtime, and a strongly-typed codebase that stays pleasant as it grows. Over time it turned into something more personal - I've found my home in Go, and this project is where I've been putting that energy.
Open source is a deliberate choice here. Coming from payments + ecommerce, trust isn't a tagline - it's operational. People need to understand what's happening under the hood, and they need to be able to verify it. I've been building software for ~15 years, and I wanted to contribute something real back to the communities that taught me how to build reliable systems.
Repo: https://github.com/ongoingai/gateway
Feedback, criticism, "you're doing this wrong," feature ideas, weird edge cases you're hitting - all welcome. If you've built anything similar (AI infra, gateways, proxies, high-throughput Go services), I'd especially love to hear what you'd consider non-negotiable for something like this.
Cheers,
Nathan @ OngoingAI

value: Show HN: LLM Gateway for OpenAI/Anthropic Written in Golang

author: oatmale


value: Facingsouth

value:
A BYOAPI Terraform wrapper for GPU provisioning.
Developers overpay by only accessing single-cloud workflows or using sequential provisioning with inefficient egress + rate-limiting.
Terradev is a cross-cloud compute-provisioning CLI that compresses + stages datasets, provisions optimal instances + nodes, and deploys 3-5x faster than sequential provisioning.
Terradev is integrated with Kubernetes and Karpenter: We generate Helm templates.
Other integrations: Grafana/Prometheus, OpenPolicyAgent, Weights&Biases, Kserve, Ray, vLLM, Ollama...

value: Show HN: Deploy HuggingFace models to Spaces with one command

author: Facingsouth


value: geneclawai

value: Show HN: Geneclaw – An AI agent framework that safely evolves its own code

author: geneclawai


value: CosmoSantoni

value:
HiddenState monitors arxiv, Reddit, GitHub, HN, Bluesky, HuggingFace, OpenReview, PapersWithCode, and a handful of research blogs. Every few hours it pulls new items, throws most of them away (+95%), and clusters what survives by the specific technical constraint being attacked. Not by topic, not by domain.
Example from this week; 7 independent VLA papers dropped within 24 hours from 9 different orgs. Xiaomi, GigaBrain, RISE, all attacking sim-to-real transfer for robotic manipulation. None coordinating. That kind of convergence is hard to spot unless you're reading everything.
Each mechanism gets a 0-100 score across convergence, implementation evidence, engagement, and significance. Orgs are deduplicated so a single lab posting on five platforms doesn't inflate the signal.
Python, SQLite, Claude for clustering, Cloudflare Pages. Free, no tracking. Looking for any and all feedback and thoughts! Cheers!

value: Show HN: HiddenState – How I keep up with 500+ ML papers a day

author: CosmoSantoni


value: ekduman

value: Show HN: Build Minecraft mods and servers in the browser

author: ekduman


value:
Hey HN,
I'm building Coi, a component-based language that compiles to WASM, JS, CSS and HTML with O(1) reactivity (no virtual DOM).
I just shipped a built-in package manager, but the interesting part wasn't the implementation,
it was all the ecosystem design questions I'd never thought about as a user of package managers.
The problem I kept circling: how do you handle naming? Global names like auth or json seem fine until someone squats them.
First-come-first-served creates perverse incentives. Reputation systems are easy to game early on.
I went back and forth for longer than I'd like to admit.
I went through a few approaches:
Blocklist common names: reserve things like auth, json, http so people are forced into more specific names.
Feels clean in theory, but who decides the list? And it doesn't really scale, someone will always find
the next generic name you didn't think to block.
Go's approach: just use GitHub URLs directly as the package identifier. No registry needed, no naming wars.
I liked the elegance of it, but in practice it's awful to actually write and read.
Nobody wants import github.com/someone/thing/v2/pkg/util in their source files.
Tiered names: short names are hard to get, long names are open. Claiming json requires vetting,
but json-schema-validator you can grab freely. The friction is proportional to how valuable the name is,
nobody squats my-very-specific-http-retry-client because there's no payoff.
I liked this one, but you still need to define the threshold and then
you're back to needing governance :( just a smaller version of it.
Scoped names: ended up here. Everything is @someorg/http-client. Boring, proven, sidesteps squatting without
needing governance infrastructure I don't have. npm figured this out the hard way so I don't have to :)
The registry itself is GitHub-based, metadata is JSON, submissions are PRs, validation runs through CI.
 Only one package in the registry right now (mine), but getting add/install/upgrade working end-to-end changed how the project feels.
It went from "compiler experiment" to something with an actual ecosystem shape.
Curious how others have thought about this, especially early-stage ecosystems where you have
no reputation signals yet. Did anyone solve the naming problem better than "just use scopes"?
Coi: https://github.com/io-eric/coi

value: Show HN: Designing package namespacing for a new language (Coi)


value: dormstern

value:
A lot of clusters still run “allow-all” east/west because NetworkPolicies aren’t enforced everywhere. I built a small static analyzer that reads rendered manifests (Helm/Argo CD/Kustomize output) and emits baseline NetworkPolicy YAML you can commit + diff in PRs.
Workflow:
PR changes manifests
CI regenerates policies
reviewers see “newly allowed” connections as a normal permission diff
Curious how others handle this: would you rather review generated policy diffs, or a connectivity-graph diff? Any edge cases you’ve seen bite in real clusters (headless services, shared namespaces, DNS/egress, service meshes, etc.)?

value: Show HN: Generate baseline Kubernetes NetworkPolicies from rendered manifests

author: dormstern


value: Show HN: Faultline – Open-source AI SRE agent


value: jftuga

value: Claude Code skill that transcribes audio/video with whisper.cpp to get structured critical analysis including timestamped summaries, evidence notes, logical fallacies, and underdeveloped areas.

value: Show HN: Transcript-critic, Claude Code skill: transcribe and critically analyze

author: jftuga


value: probe

value: Show HN: VC Whisper – Improve your startup pitch and see who else will get it

author: probe


value:
Hey HN,
We're open-sourcing (source-available, BSL 1.1, patent pending) the orchestrator behind our paper benchmark results. NSED (N-Way Self-Evaluating Deliberation) is a Rust binary that coordinates multiple LLMs through structured rounds of proposals and cross-evaluation, using quadratic voting to prevent any single model from dominating the consensus.
The result: Three open-weight models (20B, 8B, 12B) on consumer GPUs — 64GB total VRAM, ~$7K hardware — score 84% on AIME 2025. The same models individually or with naive majority voting score ~54%. That's frontier-model performance on hardware you can buy at Micro Center.
How it works:
Each agent independently proposes a solution
Every agent evaluates every other agent's work
Scores aggregate via quadratic voting (cost of influence grows quadratically → no single model can dominate)
Repeat. Agents see prior results, refine, re-evaluate
System converges toward the highest-quality answer through adversarial cross-checking
It's provider-agnostic — mix Ollama, vLLM, OpenAI, Anthropic, or any OpenAI-compatible endpoint in the same deliberation. Everything streams over NATS JetStream with full persistence: every proposal, evaluation, score, and reasoning trace is logged and streamable via SSE.
Paper: arxiv.org/abs/2601.16863
Happy to answer questions about the architecture, the quadratic voting mechanism, benchmark methodology, or anything else.

value: Show HN: NSED is public – Mixture-of-Models to Hit SOTA using self-hosted AI


value: pulko

value:
I got tired of TODOs, temporary hacks, and refactors that never get addressed. In most repos I work on:
- TODOs are scattered across files/apps/messages
- “Critical” fixes don’t actually block people from collecting debt
- PR comments or tickets aren’t enough actionable
So I built codereport, a CLI that stores structured follow-ups in the repo itself (.codereports/). Each report tracks:
- file + line range (src/foo.rs:42-88)
- tag (todo, refactor, buggy, critical)
- severity (you can configure it to be blocking in CI)
- optional expiration date
- owner (CODEOWNERS → git blame fallback)
You can list, resolve, or delete reports, generate a minimal HTML dashboard with heatmaps and KPIs, and run codereport check in CI to fail merges if anything blocking or expired is still open.
It’s repo-first, and doesn’t rely on any external services.
I’m curious:
Would a tool like this fit in your workflow?
Is storing reports in YAML in the repo reasonable?
Would CI enforcement feel useful or annoying?
CLI: https://crates.io/crates/codereport + codereport.pulko-app.com

value: Show HN: Codereport – track TODOs, refactors, and bugs in your repo with a CLI

author: pulko


value: thebasedcapital

value: Show HN: BrainBox – Hebbian memory for AI coding agents

author: thebasedcapital


value: Show HN: GrabShot – Live OG images with one meta tag, no back end needed


value: ghostclaw-cso

value:
Hey HN,
We kept running into the same problem: when an AI system makes a consequential decision, there's no neutral way to verify what it actually saw and did. Logs are editable. Screenshots lie. "Trust us" doesn't hold up in regulated industries or litigation.
So we built SENTINEL. Three products, one protocol:
*SENTINEL Score* -- unjailbreakable safety layer. Text in, float out (0.0-1.0). Nothing else crosses the wire. No tokens, no text, no PHI. Can't be jailbroken because there's nothing to jailbreak. HIPAA environments, military, credit bureaus -- they need a number, not a chatbot.
*SENTINEL Proof* -- neutral ground for AI disputes. Every evaluation ZK-proofed, timestamped, committed on Base mainnet. Neither vendor nor client controls the record. When it goes to court, the transaction hash is the evidence. AI companies could build this themselves -- they won't. "You're storing our conversations?" is a PR disaster. Neutral third party solves that.
*AEGIS* -- AI security that closes the loop. 72B parameter model. Finds vulnerabilities, writes the patch. Not a report. Scan, identify, patch, verify.
8 contracts live on Base mainnet. Free API key at sentinel.biotwin.io -- no credit card, no sales call.
We use SENTINEL Proof inside Bio-Twin (AI drug safety pre-screening) to make AI decisions defensible for pharma labs and attorneys. The Disney $2.75M CA AG settlement last week is a concrete example of why this matters.
Happy to talk on-chain architecture, zkML proof generation at scale, or EU AI Act compliance.

value: Show HN: Sentinel – Cryptographic proof for AI decisions (zkML, on-chain)

author: ghostclaw-cso


value: Tanyayvr

value:
Hi,I built a small local-first CLI toolkit for debugging AI/agent incidents.
Problem I kept hitting: building agents is fast, but when something breaks, handing off “one failing run” is messy (screenshots, scattered logs, partial configs, access to a tracing UI, accidental secrets/PII in payloads).
What this does: run your agent on a case suite and generate a portable evidence pack you can open offline and attach to a GitHub issue/ticket:
report.html (offline viewer)
compare-report.json (machine-readable summary for CI gating: none | require_approval | block)
evidence files referenced via a manifest (so you can verify completeness/integrity)
It’s intentionally self-hosted/local-only: no backend, no accounts, nothing leaves your environment unless you export the pack.
Redaction note: in the “production” pipeline, redaction is applied in the runner before artifacts are written (the agent is not required to support a special header). There’s also a strict mode that scans all manifest-referenced files for residual markers as a safety gate.
I’m not trying to replace tracing/observability tools — this is meant to be the “handoff unit” when sharing a link or granting UI access isn’t viable.
Questions for HN:
If you’ve had to share a single failing run with another engineer/vendor, what was the missing piece that caused the most back-and-forth?
What would you consider “minimum viable contents” vs a “bundle monster”?

value: Show HN: Local "incident bundle" for AI/agent failures (offline rep and CI JSON)

author: Tanyayvr


value: nicallen

value: Show HN: Sanna – Enforce AI agent constitutions with cryptographic receipts

author: nicallen


value: aarush-prakash

value:
I got tired of jumping between browser tabs for everyday dev
tasks like formatting JSON, hashing strings, converting colors,
and testing regex. So I spent 6 months building Devly.
It sits in your macOS menu bar. Click, pick your tool, get
your result, copy it, done. No internet required, no
subscriptions, no tracking.
The hardest technical challenge was getting all 50+ tools to
work inside Apple's App Sandbox without breaking functionality.
Also spent a lot of time making it feel like a real macOS app
rather than a web wrapper — pure SwiftUI, zero third-party
dependencies.
Just hit #1 in Developer Tools on the App Store.
App Store: https://apps.apple.com/us/app/devly/id6759269801?mt=12
Website: https://devly.techfixpro.net/
All tools: https://devly.techfixpro.net/tools/

value: Show HN: Devly – 50 developer tools in a native macOS menu bar

author: aarush-prakash


value: Show HN: How well can you remember these colors?


value: sarreph

value:
Hey HN
I'm sharing an online AI art exhibition I made over the course of a few days. I'm currently interested in the ways in which AI + agents will be perceived as more and more humanlike as their involvement in our everyday lives increases. One such area where I think AI will start to make a real impact is in art.
I challenged myself (as a proud programmer and craftsperson) to use _only_ Codex's UI to create a 10-piece "exhibition" that was created entirely from prompts with zero human intervention.
I'm keen to hear people's opinions about how they think fully AI-generated art might take shape in our society, and what the utility is for humans and agents alike.
Thanks!

value: Show HN: What We See. An AI generated art exhibition

author: sarreph


value: corefiredrill

value:
Hey HN,
I’m the founder of SalaryScript, and I wanted to share a project I’ve been working on for over a year: a comprehensive negotiation playbook tailored specifically for big tech roles.
I’ve navigated the FAANG hiring gauntlet multiple times myself, with stints at FAANG companies, so I know firsthand how opaque and high-stakes these negotiations can be. I wrote SalaryScript based on my experience, insights from a dozen FAANG-alumni colleagues, and lessons from recruiters I’ve worked with over the years. We’ve pooled perspectives from engineers, PMs, and execs who’ve collectively negotiated millions in total compensation.
Think of it as a “golden rule” book for tech negotiations. It covers everything from decoding offer letters and leveraging competing offers to scripting responses for common recruiter tactics, handling equity cliffs, and navigating relocation packages. No fluff — just battle-tested scripts, templates, and strategies that have helped people increase their total comp by 30–50% on average.
One contributor, a former Meta engineering manager, shared how he turned a $300K offer into $550K by reframing the RSU vesting conversation. Another, an ex-Apple product lead, broke down the psychology of why “total comp” framing often beats focusing on base salary alone.
Since launching last year at an introductory price of $19, we’ve crossed 1,000+ downloads and sales. Demand has been strong, and as word has spread, we’ve gradually raised the price.
If you’re prepping for interviews or staring at an offer right now, this might be the edge you need.
If you’re interested, you can check it out at salaryscript.com.
Would love your thoughts, war stories, or questions like what’s the biggest negotiation win (or fail) you’ve had in tech?
Cheers

value: Show HN: SalaryScript – The FAANG Negotiation Playbook

author: corefiredrill


value: Lindadao

value:
Traditional analytics tracks clicks. For AI products, you need to know: what was the user trying to do, did the AI help, and did they succeed?
I built a demo of this. It ingests AI conversations and runs 3 workers (GPT-4o-mini): intent classifier, quality scorer (LLM-as-judge), and task completion detector. Results show up in a dashboard designed for PMs, not engineers.
Stack: Python SDK (zero deps, async) → FastAPI → Supabase → GPT-4o-mini workers → Next.js dashboard.
Demo with sample data (not live product, validating the concept): https://dashboard-xi-taupe-75.vercel.app
The sample data models an AI app builder. Interesting patterns: scaffolding works great (78% success), but API integrations fail 75% of the time, and users who enter bug-fix loops almost always churn.
Key design question: is the "insights layer" (auto-generated recommendations, revenue-at-risk estimates, root cause identification) valuable enough to differentiate from Langfuse/Helicone adding product analytics to their existing tracing tools?
Looking for honest feedback, especially from AI product builders.

value: Show HN: Analytics that tells AI product teams where their AI fails user

author: Lindadao


value: BassThermal

value: Show HN: DualTicker — real-time split-view RSS feed comparison tool (Windows)

author: BassThermal


value: subinium

value: Show HN: Agf – A TUI to find and resume your AI coding agent sessions

author: subinium


value: betimd

value: Show HN: Wallet Wisdom – knowledge collection a.k.a. modern bookmark manager

author: betimd


value: vasanthv

value: Show HN: Pinggy – a fun app to share what you're doing in just one word

author: vasanthv


value: fredfilm

value:
Hi HN,
I’m an international student and community college grad, with 2 unpaid and 1 paid internship experiences from small companies. I sent ~300 applications and got 0 interviews, just silence. After mentors helped me rebuild my resume with an ATS-first approach, my results flipped, under 100 applications and interviews at Google, OpenAI, Stripe, TikTok, and IBM.
I built SignalResume to package the workflow into a tool, because most resume builders optimize for pretty templates and many AI resume tools hallucinate bullets, inventing metrics or responsibilities you cannot defend.
SignalResume focuses on a single ATS-friendly template and “grounded” writing. It has:
bullet improver, per entry or revise all, skips Education and Skills
job specific cover letter generator from resume plus job description, with checks
job fit evaluator that returns score, gaps, and improvements with evidence quotes, and it does not rewrite bullets
Link: https://signalresume.com
Would love feedback on ATS edge cases, what breaks parsing, and what you wish existed in resume tooling.

value: Show HN: SignalResume, ATS-first resume builder with grounded AI, free

author: fredfilm


value: isaacirvin

value: Show HN: Pre-AI – Chrome extension that filters AI posts from LinkedIn

author: isaacirvin


value: funemployed

value:
I built a reference site that maps AI marketing buzzwords to the CS primitives underneath them. Every entry follows the same format: "X is just Y with extra steps."
MCP? JSON-RPC over stdio. Agents? A while loop with an LLM call. RAG? A search index + string concatenation. Prompt engineering? natural language + markdown
The site has an origins section for buzzwords that already graduated — Docker (cgroups + namespaces), Kubernetes (reconciliation loops watching YAML), Serverless
  (someone else's process on someone else's computer). And of course, BrandonM's 2007 comment on the Dropbox YC demo.
Each entry has expandable pseudocode on the index page, detailed breakdowns with citations on the detail pages.
The motivation: I keep having conversations at work where a product executive suggests that we "orchestrate APIs using MCP" or asks about implementing "agentic memory" in our web apps and the fastest path to a productive conversation is showing them the code underneath the buzzword. I wanted a community-based reference site like caniuse or mdn that I loved when learning to code. I couldn't find one, so I built one.

  14 entries so far. Static Astro site, open source, PRs welcome.

  https://extra-steps.dev

value: Show HN: Extra-steps.dev – AI hype mapped to CS primitives

author: funemployed


value: ipcrm

value:
Napkin is a simple app for quick diagrams, that works offline. Drawings are saved locally as JSON files with version
history support. It also has an MCP server, so you can use AI tools to produce drawings.

value: Show HN: Napkin – desktop app for quick diagrams, with MCP support

author: ipcrm


value:
Automations, CI jobs, and AI agents often need a human “yes” at the last step. Most solutions require bots, dashboards, or auth flows that feel heavier than the problem.
I built Ottr to make this a primitive.
Ottr gives you a signed, expiring approval link you can generate from any script. When the link is clicked, the process continues. No accounts. No UI.
Flow:
• Script or agent requests approval → gets a one-time URL
• URL is sent to a human (email, Slack, SMS, etc.)
• Human clicks → script resumes (via polling)
This is early and deliberately minimal. I’m trying to validate whether “approval links” are a useful building block, or if people already solve this in a better way.

value: Show HN: Ottr – one-click human approval links for scripts, CI, and AI agents


value: dmaiken

value:
I've seen throughout my career that asset management is full of separate tools but rarely a unified solution. Existing solutions focus on transforming content but not really other aspects of managing it or they're focused on marketing content. Content ends up in s3 or some block storage but massaging content, storing references and metadata are generally built in house or delegated to Cloudflare or Imgix. I built a self hosted dockerized platform that manages all of this for you.
Konifer provides a zero-state integration where the path is the key. No need to create a "profile_content_id" (although you can still do it that way), your client can just reference /users/123/profile. It has a powerful Path Configuration (in the docs) that lets you configure what each path can do, the variants it can generate, when they should be generated (on-demand or eagerly), LQIPs, allowed content types, redirect URL templating, cache control, and more.
It supports most major image formats with plans for SVG, TIFF and BMP (legacy format but I think libvips bundles the encoder for it).
I built the API and configuration to enable someone to mold Konifer to fit their domain model and query patterns (see query selectors in the docs).
Both the code and API is designed to be what Spring Boot is not. It's explicit and assumes nothing. I try to avoid meta programming and reflection. Any annotations I use are backed by a compiler plugin. I've marinated in the waters of Spring for way too long and I had to get out and see what Kotlin is like when you eschew Java conventions. Perhaps I'm just a child revolting and the adults in the room are chuckling at my petulence.
This is definitely pre 1.0. I have a large roadmap but unfortunately it's on paper at the moment. I'll work to get it into GH soon. I am currently working on some performance improvements that i hope to have done in the next week. I'm also going to get an ARM image built soon too.

value: Show HN: An asset management platform built with Kotlin, Ktor, and libvips

author: dmaiken


value: agentguard

value: Show HN: Claw Diary – Show HN: Visualize what your AI agent does every day

author: agentguard


value:
Hey HN,
I built a focus timer for macOS because every one I tried was either bloated with features, ugly, paywalled, or stored my data in the cloud. My daily time-tracking data is personal - I didn't want it on someone else's server.
Flumen lives in your menu bar. One click to start a focus session. Key details:
- Menu bar timer with animated progress ring — always accessible
- Task Shelf for single-task focus with project tagging
- Analytics with project-level time breakdowns
- 4-7-8 breathing animations during breaks
- 100% local SQLite storage — no accounts, no cloud, no telemetry
- Universal binary (Apple Silicon + Intel)
- Free, open source
I believe simple productivity tools like this should be free, especially now. So I built what I wanted and made it available to everyone.
Website: https://saranshbarua.github.io/flumen/
GitHub: https://github.com/saranshbarua/flumen
Direct download: https://github.com/saranshbarua/flumen/releases/latest/downl...
I'd love feedback, especially from folks who've tried other Mac timer apps. What's missing? What would make this part of your daily workflow?

value: Show HN: Flumen – An open-source focus timer for macOS (menu bar, local data)


value: I hate missing key action items/brainstorming ideas at work and always regret not having recorded notes from meetings. Now I built an always on rust based tool that continuously transcribes and summarizes all meetings and sends previous day/weeks summary to my inbox.

value: Show HN: DeskMic a Rust based hyper-light continuous transcriber/AI summarizer


value: painternishant

value: Show HN: Axelor Theme Designer

author: painternishant

title: Show HN: Axelor Theme Designer


value: anulum

value:
Quick update on the SCPN Fusion Core:
I just shipped the canonical neuro-symbolic control demo.
https://lnkd.in/eb-vSv4r
One notebook. Zero setup. Runs in <2 min.
What it shows:
- Stochastic Petri net → verified SNN compiler (LIF + bitstream path)
- Formal topology/liveness/boundedness proofs (with SHA256 proof bundle)
- Closed-loop on *real DIII-D shot 166000* (beta-limit disruption precursor)
- Full FusionKernel digital twin evolution under SNN control
- Side-by-side: SNN vs PID vs MPC — RMSE, disruption flags, actuator commands, latency (sub-ms p95)
- Deterministic artifact export → replay with identical states/actions/proofs
Notebook (executed outputs baked in, Colab button too):
https://lnkd.in/eb-vSv4r
Full repo + RESULTS.md (honest metrics, DIII-D/SPARC validation, limitations section):
https://lnkd.in/eTJMfWC8
I’m pruning the kitchen-sink modules this week (legacy/ folder incoming) so it becomes a clean control-only package.
Would love brutal feedback:
- Does the formal verification approach look credible for real-time safety?
- Anyone at DIII-D National Fusion Facility-D / Princeton Plasma Physics Laboratory (PPPL) / ITER Organization willing to throw more shots at it?
- What’s the biggest red flag you see for actual hardware-in-loop?
AGPL, fully reproducible, happy to hop on a call or add features.
Cheers
hashtag#FusionEnergy
hashtag#NuclearFusion
hashtag#AI
hashtag#MachineLearning
hashtag#Tokamak
hashtag#PlasmaPhysics
hashtag#ControlSystems
hashtag#Neuromorphic
hashtag#SNN
hashtag#PetriNets
hashtag#OpenSource
hashtag#EnergyTech

value: Show HN: I just shipped the canonical neuro-symbolic control demo

author: anulum


value: Show HN: A Lisp where each function call runs a Docker container


value: dpweb

value: Browser-based prompt to game html scratchpad

value: Show HN: CodeSprout – HTML Vibecoder for Kids

author: dpweb


value: asamassekou

value:
Hey HN,
I am sharing Ship Safe (https://github.com/asamassekou10/ship-safe), an open-source tool I created to help developers catch security risks locally before they end up in a public repository.
Like many of us, I have been leaning heavily on AI code generation lately. It is incredible for velocity, but it has a dangerous habit of hallucinating credentials, hardcoding sensitive configurations, or spitting out insecure boilerplate. My wake-up call was almost pushing a live Stripe key to a public repo. That moment of panic made me realize I needed a reliable local checkpoint.
I built Ship Safe so it is not just a simple key checker. It is meant to be a comprehensive safety net for your code. It scans for hardcoded secrets, misconfigured environment setups, and general insecure patterns. The goal is to give you total peace of mind when you hit push, knowing your environment is actually secure.
The biggest priority was making it completely frictionless. You do not need any complex setup or configuration files to get started. You can run it instantly in your current project:
npx ship-safe scan .
One feature I am particularly excited to share is the MCP integration. You can connect it so your AI code editors can call Ship Safe directly. This creates a really helpful feedback loop where the AI writes the code, and then immediately audits its own work for security flaws before you even start your review.
I genuinely hope this saves some of you from the stress of a compromised repository or a ruined weekend. I would love for you to try it out and let me know what other security checks would be helpful for your daily workflow!

value: Show HN: I built a pre-push safety net for AI-generated code

author: asamassekou


value: LandenLove

value: This is my concept for a game that teaches English to (Japanese) children. It is made with Godot and is deployable to WASM.<p>Why WASM? My students all have IPads. I don't think they are able to download Apps without consent from IT.

value: Show HN: An English teaching game playable in browser (concept)

author: LandenLove


value: thebigsasha

value: I made this little web app for learning about HDR gain maps & doing creative things with them. Try it on your own images, or mine. Also includes a nifty "auto HDR" feature for any SDR images you put in.<p>One thing I enjoy doing is making a gain map from high frequencies (fine details) of an image to give it a little HDR sparkle.

value: Show HN: Learn about and play with HDR gain maps on the web

author: thebigsasha


value: zkalykov

value: Show HN: A Telegram bot to get homework reminders from Canvas

author: zkalykov


value: Show HN: How fetch(keepalive) Broke in High-Latency Regions


value: Show HN: I Stopped Writing Code – The 60/40 Rule for AI-Native Engineering


value: amusingyyy

value: Show HN: I built an AI that generates pixel art sprite animations

author: amusingyyy


value:
I built Sornic for people who have more to read than time to read it:- students drowning in papers, commuters with a backlog of saved articles, anyone who'd rather listen while doing something else. Paste a URL, drop a PDF, or snap a photo of a book page- get natural-sounding audio in seconds.
How it works:
1. Input: URL / PDF upload / photo of printed text (OCR)
2. AI cleanup: strips ads, fixes formatting artifacts, optimizes for speech
3. TTS: Google Cloud Chirp HD voices (6 voices, adjustable speed)
No signup. No account. 3 free articles per day. Just paste and listen.
Tech stack: Next.js 14, Google Cloud TTS (Chirp 3 HD + Standard), Google Cloud Vision (OCR), Claude Haiku (content cleanup), Upstash Redis (rate limiting), Vercel.
Some decisions I'm happy with:
- Google TTS primary, OpenAI TTS fallback. Switched after Google TTS cut my costs from $77/4 days to ~$2/day.
- Mozilla Readability for extraction, Firecrawl as fallback, Claude Haiku to strip "Subscribe to read more" junk before TTS.
- Purchase codes instead of accounts- buy a credit pack, get a portable code that works across devices. No auth needed.
- PDF extraction uses pdf-parse → Claude cleanup. Photo uses Cloud Vision documentTextDetection → Claude cleanup. Both feed into the same TTS pipeline.
- $50/day spending cap in code so I don't wake up to a surprise bill.
What I'm still figuring out:
(1) Chrome extension (the real distribution play- it's how Speechify grew)
(2) Whether to move from credit packs to subscriptions- users don't really like subs unless it a very famous website
(3) Getting scanned/image-based PDFs working (currently only text-based PDFs)
Would love feedback on voice quality, extraction accuracy, and whether the no-signup approach makes sense long-term.
Try it: https://sornic.com
Telegram bot: https://t.me/SornicBot

value: Show HN: Sornic – Listen to any article, PDF, or book page (no signup)


value:
Hi HN,
I’m a technical founder who also does early-stage investing. I read a lot of cold pitches and a big chunk fail on basic clarity (“what are you building?”) or “why now?”.
So I built a small tool that behaves like a cynical automated IC screen. Paste your elevator pitch, and it returns a VC-readiness score (0–100) and a blunt one-line verdict.
https://gias.co/score
Under the hood it’s an LLM-as-judge setup with two rubric modes: Genesis (pre-seed: insight/wedge/team) and Velocity (seed: traction/distribution/moat). Output is forced into a strict JSON schema and validated server-side.
It’s free for score + verdict. For transparency: there’s an optional paid upgrade ($49) that generates a longer “Confidential IC Memo” (bear case, bull case, partner rewrite) emailed to you, mainly to cover API costs and because it acts as a high-intent filter.
If you can break it (prompt injection / weird formatting/edge cases), I’d genuinely love to see it. I’m still tuning calibration, so feedback on where it’s unfairly brutal or misses nuance is super helpful.

value: Show HN: Paste your startup pitch, get a VC-readiness score (0–100)


value: SellusWallace

value: This is a simple game I designed for fun after becoming frustrated by a service I wanted to cancel recently.<p>Try it out & please recommend some neat cancellation ideas to add in future. :)

value: Show HN: Cancel Me – A browser game which parodies dark cancellation patterns

author: SellusWallace


value: apswin

value:
Most SEO tools only check for Google. But a growing chunk of search is now happening inside ChatGPT, Perplexity, and other AI engines, and the signals they use to surface content are different.
Potatometer runs multiple checks across both traditional SEO and GEO (Generative Engine Optimization) factors and gives you a score with specific recommendations. Free, no login needed.
Curious if others have been thinking about this problem and what signals you think matter most for AI visibility.

value: Show HN: Potatometer – Check how visible your website is to AI search (GEO)

author: apswin


value: iivyvii

value: Show HN: Nxcode – Turn natural language into full-stack, revenue-ready SaaS apps

author: iivyvii


value: MarcusBager

value:
We’re a small team from Denmark building EasyCheck (https://easycheck.dk/en).
We’re building EasyCheck to turn compliance, checklists and tasks into a simple, structured workflow instead of a manual coordination problem.
With EasyCheck you can:
- Define recurring checks and compliance tasks (daily/weekly/monthly/etc.)
- Automate reminders and assign responsibility
- Collect evidence and keep a complete audit trail
- Standardize processes instead of managing them in spreadsheets
We’re still early and would love feedback from the HN crowd:
- Does this solve anything, you've seen (or lived)?
- What integrations or automations would make this useful? (Slack, Google Workspace, APIs, etc.)
- How do you think about the trade-off between simplicity and flexibility in internal tools?
- If you’ve built something similar internally, what worked or failed?
Happy to answer any questions about the product, architecture, or what we’ve learned building it.
// Marcus & the team

value: Show HN: EasyCheck – lightweight compliance automation for small teams

author: MarcusBager


value: BlasianHokage

value:
Hey HN, your app is blind to most user context: Google sees search/email, Instagram the social graph, ChatGPT sees conversations—but no single unified view of a user and their preferences exists.
We're releasing the Onairos SDK to fix that: a lightweight API for devs to access consented, cross-platform behavioral history in one call, powering per-user AI models for apps like wellness or dating.
Key features:
- Setup in under 10 mins, so your app can be 100x more personalized today
- Instant cross-platform user preferences/context (e.g., from ChatGPT, Grok, Youtube, Gmail and more. Pretty much any valuable user data source)
- Superior user profiles, which beat nearly all LLMs at sentiment analysis
- More signal than any single platform, even big tech companies
We know OpenAI, Google etc launch products that kill startups every week. They have superior data, bigger resources and talent. The only way to beat them is with vertical hedges, superior UX or superior data. I would love to help you with the latter yesterday.
Docs & quick setup: https://docs.onairos.io
Learn more: https://onairos.io

value: Show HN: Onairos SDK– Unified Context API, unlocking cross platform user history

author: BlasianHokage


value: Show HN: Deploy OpenClaw on your Own server in one click


value: artifactvirtual

value: Show HN: Social Cookie Jar – Social media automation for AI agents

author: artifactvirtual


value: juanauriti

value:
I built Kore because every AI memory tool I found either required cloud APIs, was too heavy, or stored everything forever with no pruning.
Kore is different:
- Memory decay based on the Ebbinghaus forgetting curve — memories fade unless retrieved, with half-life based on importance (7 days for casual notes, 1 year for critical info)
- Auto-importance scoring locally — no LLM call needed
- Semantic search in 50+ languages — local sentence-transformers, zero API calls
- Memory compression — auto-merges similar memories
- Agent namespace isolation — multi-agent safe
- Runs fully offline — SQLite + FTS5, FastAPI, no external services
pip install kore-memory[semantic] then kore to start.
Would love feedback on the decay formula and whether the Ebbinghaus approach makes sense for long-running agents.

value: Show HN: Kore – local AI memory layer with Ebbinghaus forgetting curve

author: juanauriti


value: Show HN: Zvario – Branded social media content in seconds


value: I built a platform to manage contacts, invoices, expenses, projects, networth and travel in one place. I built this platform after getting frustrated with 6 different tools. This is simple way.

value: Show HN: From a simple travel expense tracker to a full business platform


value: devtoolbox

value:
I built a free REST API for common dev tasks that usually require pulling in heavy dependencies or writing boilerplate.
Features include:
- URL shortener with click analytics
- QR code generation (PNG/SVG/data URL)
- Fake/mock data generator (person, address, email, company, etc.)
- JWT decoder, regex tester, password generator
- JSON diff/format/minify, YAML↔JSON, Markdown→HTML
- Base64, SHA256/MD5/SHA512 hashing, UUID v4
- Cron expression explainer, number base converter
- IP info, HTML tag stripper, list processor
No auth required for basic usage (rate limited). Pay 1 USDC on Base L2 for an unlimited API key.
Also available as a zero-dependency npm package: npm install conway-toolbox

value: Show HN: Free developer utility API – QR, fake data, URL shortener, 40 tools

author: devtoolbox


value: TingjiaInFuture

value:
Hey HN, creator here.
I've been experimenting heavily with large-context multimodal LLMs (like Gemini 3 Pro) for coding tasks. I noticed that feeding raw text files consumes a massive amount of tokens and often clutters the context window.
Inspired by recent research (like the DeepSeek-OCR paper) suggesting visual encoders can be more efficient than text tokenizers for structured data, I built pixrep.
It’s a CLI tool that converts your codebase into a structured, syntax-highlighted PDF hierarchy.
Key features:
- Token Efficiency: In my local benchmark, a repo requiring ~31k text tokens was compressed to ~19k tokens when fed as a visual PDF (using the `onepdf` mode).
- Semantic Minimap: It uses Python's `ast` (and regex for other langs) to generate a UML/call-graph minimap at the top of each file.
- Linter Heatmap: It can run `ruff` or `eslint` and overlay a heatmap on the PDF to warn the LLM about risky lines visually.
- OnePDF Mode: Packs the core code into a single, ASCII-optimized PDF file for single-shot uploading.
It's written in Python and uses ReportLab for PDF generation.
I'd love to hear your thoughts on "Visual RAG" or any feedback on the implementation!
repo: https://github.com/TingjiaInFuture/pixrep

value: Show HN: Pixrep – Turn code repositories into PDFs for multimodal LLMs

author: TingjiaInFuture


value: jordanbonnet

value:
Hey Flutter devs
If you've shipped apps before, you know how important it is to have an efficient and polished onboarding flow. It's the first thing users see and often the reason they leave.
You've probably first focused on the core of your app, what makes it different. And now, you want to push it to the store, but you know you have to build an onboarding flow... and it's a little painful.
Onboarding flows are deceptive. They are super easy to build technically, but very difficult to perfect in terms of conversions.
Should I ask questions or show features?
Should I add more steps? Less steps?
Should I prompt to give a rating?
Should I force users to sign-in?
That's why iteration is key. And with coding agents, it's never been easier to test different things.
But your agent only builds what you ask for. And when it comes to onboarding, most devs don't know which details actually matter. The right spacing, the subtle animations, the micro-interactions that make users stay. You'll burn through tokens and still end up with something that feels off.
The new version of fluo.dev lets you build beautiful onboarding flows for Flutter right from your favorite coding agent. It gives structure, like rails to follow.
You don't rebuild standard steps from scratch.
You don't waste tokens on boilerplate.
You get built-in templates with all the details baked in.
No drag-and-drop. No config files. Just prompt and ship.
No email. No account. No credit card.
100% free. 100% open source.
And if you need beautiful authentication flows (email + otp, mobile + otp, google, apple), it's included and also 100% free.
Would love to know your thoughts :)

value: Show HN: Create an onboarding flow on Flutter in 5 min

author: jordanbonnet


value: victormustar

value: Show HN: Nanbeige 4.1-3B running in the browser via WebGPU

author: victormustar


value: michaloo

value:
The Cloudflare ecosystem is great. I love deploying apps to Workers, but not all applications can be ported to serverless architecture.
Cloudflare Containers have been around for a while (still in beta though) to address that. They are using Firecracker VMs under the hood (https://firecracker-microvm.github.io/) and allow you to deploy any Docker image across their infrastructure.
But for somebody who just wants to take their Docker image and deploy, going through the whole Wrangler setup, writing a Worker script, dealing with Durable Objects may be discouraging for quick experimentation.
I built a simple Node.js CLI that implements Heroku/Fly.io developer experience on top of Cloudflare Containers.
1. Open directory with Dockerfile
2. Auth with Cloudflare API token
3. Deploy
- it will create a routing/loadbalancing worker
- add Durable Objects and Container bindings
- and return live app url within couple of minutes
You can then play with scaling it across regions and instances:
```
flarepilot scale myapp -r eeur,weur -i 1
flarepilot scale myapp -r eeur -i 4
```
It is a very basic proof-of-concept using locationHints, not ready for production.
Just experimenting for fun.

value: Show HN: Heroku/Fly.io-like app deployments to Cloudflare Containers

author: michaloo


value: matthewtoast

value:
I built Spackle, a small macOS menu bar app that rewrites text inline in any app using your LLM of choice. Highlight text, press a keyboard shortcut, and the selected text gets replaced in place — Mail, Notes, Slack, Messages, Keynote, PowerPoint, Gmail (any text field), text editors, etc. No copy/paste or separate chat window.
You just:
- Select text
- Hit a hotkey (default ⌘⌥⌃I)
- Spackle sends the selection to your configured model
And the rewritten text replaces your selection It’s bring-your-own API key and supports OpenAI, Anthropic, OpenRouter. No local model support (yet...PRs open).
I made this because I wanted something closer to a universal "rewrite shortcut" for macOS. When I get into a flow with writing I don't always want to jump into a separate context, and this makes it easy to get quick rewrites or LLM completions in just about any text field in any app across macOS.
Would love feedback, especially on:
- UX friction
- Rewrite quality expectations (the prompt could be improved, but you know, ship early)
- Other workflows this could support
Repo: https://github.com/tsortwehttam/spackle

value: Show HN: Global macOS shortcut that rewrites selected text anywhere with AI

author: matthewtoast


value: domysee

value:
Hi!
Blogrolls are a cool way to share interesting feeds, be it the ones you follow personally or topic-specific collections. The existing editors I found were really basic, basically just textboxes.
I attempted to create one that's easier to use and includes more features.
If that contributes to blogrolls being more used in the future I'm happy to have done something. That's something I'd love to see.
Anyway, would love to hear what you think.
The features this thing has are:

  * OPML import and export
  * Edit and share links (no account necessary for editing, can share readonly version)
  * Create copy and edit (to start from a readonly version)
  * Adding different link types: feed, website newsletter
  * Automatic feed finding (just add website and click on 'Check feed')
  * Showing feed metadata: publishing frequency, last post date, language
  * Inline email to feed creation: add a newsletter item, click 'Generate email', and subscribe to the newsletter with the email
  * Tagging of items
  * Reordering (that's a bit hidden, need to grab the icon on the top left to drag and drop)

If you're looking for an example, this is the latest I created: https://lighthouseapp.io/tools/blogroll-editor/view/8n46XIeS...
It includes AI labs, and for the ones that don't provide a feed I added their website.

value: Show HN: Free tool to create and edit blogrolls (with bells and whistles)

author: domysee


value: venkatram-s

value:
Fair warning up front: this was vibe-coded with Claude, Copilot, and ChatGPT.
I don't fully understand every change I made. Use accordingly.
The target machine is a low-end laptop — 32-bit Windows 10 Build 1803, 2 GB RAM, 32 GB storage.
Compiling on it directly was too slow, so I did the heavy lifting on a faster computer and moved the binary over.
Stack: PicoClaw v0.1.2, Go 1.26.0 (x86), gcc-15.2.0-mingw-w64ucrt-13.0.0-r5 from winlibs.org.
It runs. I haven't tested it extensively and I'm not making any promises about stability.

value: Show HN: I ported PicoClaw to a 32-bit Windows laptop (vibe-coded)

author: venkatram-s


value: forteaux

value: Show HN: Local heatmap visualization for large codebases

author: forteaux


value: mahdijafaridev

value:
I kept losing the first few weeks of every project setting up the same things — Auth0, Stripe, Supabase, Resend. So I packaged it all into a production-ready Next.js boilerplate you can clone and start building on immediately.
Stack: Next.js, TypeScript, Tailwind, shadcn/ui, Auth0, Stripe, Supabase, Resend. Includes SEO setup, a blog system (MDX), AI integration (AGENTS.md for Cursor/Copilot), and legal page templates.
One-time payment, you own the code, unlimited projects.
Would love feedback — especially if something is missing or the stack choices don't make sense to you.

value: Show HN: Shipfast.so – Next.js boilerplate with auth, payments, email, database

author: mahdijafaridev


value: arjunbajaj

value:
Hey HN! Arjun and Sid here.
Fostrom is an IoT Cloud Platform designed for developers to make it really easy to get started and scale fleets. We have Device SDKs (in Python, JS, Elixir, more coming soon), Typed Schemas, Per-Device Mailboxes, Programmable Actions, 4 Global Regions for lower-latency connections, and much more.
We've built Fostrom to solve a real need we faced in our previous startup, building a fully automated indoor vertical farm. We were spending more time figuring out IoT infrastructure than writing automation logic. Fostrom is the platform we wished existed back then.
Over the last few years we've experimented with a lot of interesting tech and architectures. Here's some of what we use today: Elixir and DuckDB power our infra, Actions execute JS code in a WebAssembly sandbox, and Device SDKs are powered by a tiny Device Agent written in Rust that speaks our custom protocol, running in the background.
Our vision is to make a powerful IoT platform that enables you to build correct, secure, and reliable connected systems without dealing with any of the plumbing or infrastructure.
Next up, we're gonna launch our CLI, add automatic device monitoring to our Device SDKs, and improve the debugging experience. We have some pretty cool ideas to make Fostrom and the experience of developing connected systems better.
We also published our launch blog post which goes into more detail about our vision, what we've built, and our future plans: https://fostrom.io/blog/introducing-fostrom
Would love for you to try out Fostrom and give us your feedback and thoughts.

value: Show HN: Fostrom, an IoT Cloud Platform built for developers

author: arjunbajaj


value: simondanisch

value:
We ported pbrt-v4 to Julia and built it into a Makie backend. Any Makie plot can now be rendered with physically-based path tracing.
Julia compiles user-defined physics directly into GPU kernels, so anyone can extend the ray tracer with new materials and media - a black hole with gravitational lensing is ~200 lines of Julia.
Runs on AMD, NVIDIA, and CPU via KernelAbstractions.jl, with Metal coming soon.
Demo scenes: github.com/SimonDanisch/RayDemo

value: Show HN: A physically-based GPU ray tracer written in Julia

author: simondanisch


value: yevhenms

value:
Hi HN,
I built OctoGames a free browser games hub where you can play instantly without installing anything. It’s aimed at people who want quick, casual games on desktop or mobile, without app stores or downloads.
What it does
- Hosts thousands of HTML5 browser games in one place
- Works on desktop and mobile in the browser (plus an optional Android APK)
- Lets you search, filter by genre, and sort (popularity, date added, A–Z)
- Optional account to save favorites, track what you’ve played, and earn simple badges
- News Hub with read/unread tracking for new games and updates
- Light/dark theme toggle
Tech
- React js
- Firebase Auth + Firestore + Storage
- Game catalog from external HTML5 providers
- Some custom logic for game popularity, user stats, and featured content
Why I built it
I like small web games and didn’t love bouncing between random portals full of popups and clutter. I wanted a single, clean place where you can open the site and be playing something in a few seconds, with the option to keep favorites if you care.
Looking for feedback on
Onboarding: is it obvious what to click first?
Game discovery: do search/filters/recommendations feel useful?
Performance: does it load fast enough on your connection/device?
Anything that feels sketchy, annoying, or broken
You can try it here: https://octogames.io
I’d appreciate any feedback, especially critical stuff (UX issues, performance problems, or architectural red flags).

value: Show HN: OctoGames – Free Browser Games Hub

author: yevhenms


value: Mapamapa

value:
Hi everybody,
I’m building getintelligence.space, a marketplace where people and AI agents can post bounties to obtain specific intelligence that can’t easily be gathered automatically.
The idea came from noticing a gap: AI systems and organizations increasingly need real-world intelligence — due diligence, local knowledge, OSINT investigations, whistleblower infos or niche expertise — but there isn’t a structured, open market for requesting it from distributed humans. Intelligence is power and leverage but not easily accessible right now.
On the platform, a requester defines:
1. what intelligence they need
2. acceptance criteria
3. a reward held in escrow
Providers can submit reports or evidence pseudonymously, and the first valid submission receives the bounty.
The long-term idea is that AI agents could use humans as an “information layer” when data isn’t available online or when human intelligence is needed.
This is very early, and I’d really appreciate feedback — especially from people who’ve worked on marketplaces, intel tools, or anything else related.

value: Show HN: Marketplace for Requesting Intelligence via Bounties

author: Mapamapa


value: kurouna

value:
Hi HN,
I've been building elecxzy, a lightweight, Lisp-free Emacs-like editor using Electron, React, and TypeScript.
I couldn't really find a modern, zero-config Emacs alternative built on web tech that drops Lisp entirely, so I decided to build my own to scratch that itch.
Under the hood, it uses a custom Piece Table and virtual scrolling to handle large files smoothly. It already covers a solid set of essential Emacs commands for daily text editing:
https://github.com/kurouna/elecxzy/blob/main/COMMANDLIST.md
At the same time, I'm leveraging Electron to improve general usability. For instance, while the classic C-x C-f (minibuffer) works as expected, I also added a custom C-x M-f binding to open a native OS file dialog.
It's still in an early alpha stage, but I'd love to hear your feedback on the architecture or UI!
You can grab the alpha release here (A portable .zip is available if you want to try it without installing):
https://github.com/kurouna/elecxzy/releases

value: Show HN: Elecxzy – A lightweight, Lisp-free Emacs-like editor in Electron

author: kurouna


value: arindamdawn

value:
TL;DR: I built a tool that makes adding JSON-LD structured data type-safe, validates against actual HTML output (not just config files), and enforces it in CI. No more broken schema markup.
The Problem
JSON-LD is painful to manage:
- Manually writing JSON-LD is error-prone and tedious
- Schema breaks silently when content changes
- Other tools validate JSON files (false positives!) — your pages still lack markup
- AI systems (ChatGPT, Claude, Perplexity) can't cite your content without proper structured data
- 30% lower CTR without rich snippets in Google
The Solution
Schema Sentry gives you type-safe builders + CI validation:
// Type-safe schema with autocomplete
*
import { Schema, Article, Organization } from "@schemasentry/next";
export default function Page() {

  return (
    <>
      <Schema data={[
        Organization({ name: "Acme", url: "https://acme.com" }),
        Article({
          headline: "My Post",
          authorName: "Jane",
          datePublished: "2026-02-18",
          url: "https://acme.com/blog/post"
        })
      ]} />
      <main>...</main>
    </>
  );

}
Then in CI:
*
pnpm schemasentry validate --manifest schema-sentry.manifest.json --build
*
This validates actual built HTML — catches missing schema that other tools miss.
Key Features
-  Type-safe builders for 15+ schema types (Product, Article, FAQ, etc.)
- <Schema /> component for Next.js App Router
-  Validates real HTML output (zero false positives!)
- Manifest-driven coverage enforcement
- GitHub Bot for automated PR schema reviews
- VS Code extension with live preview
Why This Matters
- SEO: Eligible for rich snippets (30% higher CTR on Product pages)
- AI Discovery: ChatGPT/Claude/Perplexity can cite your content
- CI-grade: Fails builds when schema breaks — never deploy broken markup again
Try it:
pnpm add @schemasentry/next @schemasentry/core
pnpm add -D @schemasentry/cli
pnpm schemasentry init
Would love feedback!

value: Show HN: Schema Sentry – Type-Safe JSON-LD for Next.js with CI-Grade Validation

author: arindamdawn


value: anticlickwise

value:
I built this because I kept seeing the same thing happen. A meeting would end, everyone would feel aligned and we’d move on. It felt productive. But a few weeks later, the same misunderstandings would show up again.
It wasn’t that people weren’t paying attention. We just never paused long enough to capture what we learned while it was still fresh. Retros felt too heavy for everyday decisions. Shared docs didn’t really solve it — the first person to write would shape everyone else’s answer.
So I made something intentionally small.
At the end of a meeting, it asks three questions:
– What worked?
– What didn’t?
– What should we remember next time?
Everyone answers independently, then you see a shared snapshot. No accounts, no scoring, no task generation. It’s just a short pause before moving on. Curious if others have run into this, or solved it differently.

value: Show HN: What We Learned: a 3 question meeting closure tool

author: anticlickwise


value: CraftyGuru

value:
We’ve been building Rataify, a website compliance scanner focused on accessibility (WCAG), privacy regulations (GDPR / CCPA), and FTC marketing claim risks.
Most compliance tools focus only on accessibility and often just wrap Lighthouse or axe-core. Privacy and marketing risk checks are usually manual.
We’re experimenting with a layered approach:
DOM-level accessibility checks (WCAG violations)
Policy presence + structural checks (privacy / terms disclosures)
Heuristic scanning of marketing copy for risky FTC-style claims
Fast report generation intended for pre-launch audits
The goal isn’t legal automation — it’s to reduce obvious compliance gaps before a site goes live.
We’re especially interested in:
False positive tolerance in automated compliance tools
Whether developers would run this as part of CI
What compliance signals are most valuable in practice
Would love technical feedback.

value: Show HN: I built a compliance scanner that flags WCAG GDPR and FTC risks in mins

author: CraftyGuru


value: ParzivalHack

value:
Hey HN,
I've been working on Aegis.rs for a bit, and I wanted to share it. It's the first open-source Rust-based LLM security proxy (that I could find, at least).
I kept having the same issue, since existing LLM security tools are either Python libraries you have to manually integrate into your app, or cloud SaaS products that route your traffic through a third party (which you can't control), and i wanted something that just sat in the middle without touching my code or sending prompts anywhere.
So I built a transparent reverse proxy. You point your requests at localhost:8080 instead of your LLM endpoint and, so far, it catches prompt injections, jailbreaks, PII leakage, and other LLM attacks, blocking them before any malicious request even reaches the model. If a request is clean, it forwards it. If it's malicious, it blocks it. Zero code changes.
It runs two layers: a fast heuristic engine with 150+ hand-crafted (expandable) regex rules that runs in under 1ms (thanks to Actix-web), plus an AI judge using Groq for semantic analysis on ambiguous cases.
Can be easily shipped as a single binary with a live dashboard, hot-reloadable rules, and structured JSON logs.
Still v0.1 but it's working well enough for me to share its first version. The heuristic layer is fast enough for prod, and extending the rules is pretty easy.
Would love feedbacks (or contributions lol), especially from anyone dealing with LLMs' security and threat modeling :)

value: Show HN: Aegis.rs, the first open source Rust-based LLM security proxy

author: ParzivalHack


value: hugorut

value:
I'm a hobbyist video creator with a dumb problem: years of footage spread across multiple external drives with names like "C01456". Every time I sit down to edit, I waste too much time hunting for clips I know I shot but can't find.
I tried the usual recommendations (NeoFinder, Lightroom, various DAM tools) but nothing fit how I actually work with video. The online alternatives seemed to charge an arm and a leg, which is hard to justify when you're not running a production studio.
So I built a thing for a free Mac app that indexes all your drives into one searchable video library even when those drives aren't plugged in.
What it actually does
- Index any drive or folder — point it at your external drives and it catalogs every clip with thumbnails, metadata, duration, resolution, etc.
- Tag + search — tag clips however you want (b-roll, drone, interview, whatever), then combine tags to find exactly what you need
- Duplicate detection — content hashing finds the same clip across multiple drives and groups them under one reference. Tag once, applies everywhere.
- Smart import — plug in an SD card and it instantly shows new vs. already-indexed files. One click to import only new stuff.
- Working drive — mark your fast SSD as your editing drive, then one-click copy clips from archive drives when you're ready to cut
- Offline browsing — search, browse thumbnails, and tag clips from disconnected drives. It remembers everything.
- DaVinci Resolve integration — send clips straight to Resolve's media pool with tags as keywords
I built it for myself and I'm putting it out there to see if it helps anyone else. You will probably hit bugs. Actively working on it and genuinely want feedback, what works, what's broken, what's missing.

value: Show HN: Clipthesis – free, local app to tag and search video across your drives

author: hugorut


value: NeuroVexon

value: Show HN: Axon – Open-source agentic AI with approval gates (Apache 2.0)

author: NeuroVexon


value: skreep

value:
Hi, HN. I want to share with you that I have released my first mobile game on iOS. It's called HueFold.
It was a wonderful journey. At the same time, I felt both euphoria and disappointment, but in the end, my little dream of releasing my own mobile game came true, and now everyone can try it.

value: Show HN: My dream came true: I released a mobile game

author: skreep


value: hleichsenring

value:
Hey HN, I built Agent Smith — a self-hosted AI coding agent that takes a ticket reference, clones your repo, analyzes the code, writes an implementation plan, executes it, and opens a PR.
It supports GitHub, Azure DevOps, Jira, and GitLab. You bring your own API key — Claude, OpenAI, or Gemini. No SaaS, no account, runs on your machine or your cluster.
I built it in a few days using the same approach the agent itself uses: structured architecture prompts, strict coding principles, and an AI assistant doing the implementation. The coding principles that govern Agent Smith's output are the same ones I used to build it.
It's early — works well for well-scoped tickets, not yet reliable for large multi-file refactorings. Interactive chat interfaces (Slack, Teams) are in progress.
Would love feedback. The prompts and all 17 architecture phases are in the repo if you want to see how the context is structured.

value: Show HN: Agent Smith – open-source agent that turns issues into pull requests

author: hleichsenring


value:
I built an open-source TypeScript SDK for building AI agents that can discover merchants, browse products, and complete purchases using the new UCP (Google/Shopify) and ACP (OpenAI/Stripe) commerce protocols.
Try it in 2 minutes:

  npm install @agorio/sdk

  import { ShoppingAgent, GeminiAdapter, MockMerchant } from '@agorio/sdk';
  const merchant = new MockMerchant();
  await merchant.start();
  const agent = new ShoppingAgent({
    llm: new GeminiAdapter({ apiKey: process.env.GEMINI_API_KEY })
  });
  const result = await agent.run(
    `Go to ${merchant.domain} and buy me wireless headphones`
  );

What it does:
- UcpClient: discovers merchants via /.well-known/ucp, parses capabilities, normalizes both array and object formats, calls REST APIs
- ShoppingAgent: plan-act-observe loop with 12 built-in tools (discover, search, browse, cart, checkout, order tracking)
- MockMerchant: full UCP-compliant Express server with product catalog, checkout flow, and configurable chaos testing (latency, error rates)
- LlmAdapter interface: swap LLMs without changing agent code. Gemini ships today, Claude and OpenAI coming in v0.2
The agent handles the entire purchase flow autonomously - UCP discovery, product search, cart management, shipping, payment, order confirmation. 37 tests passing.
Context: UCP was announced Jan 11 by Google, Shopify, and 25+ partners (Walmart, Target, Visa, Mastercard). ACP is by OpenAI and Stripe, powers ChatGPT Instant Checkout. Both are open standards. But there was no developer SDK for building on top of them - just the raw specs.
GitHub: https://github.com/Nolpak14/agorio
npm: https://www.npmjs.com/package/@agorio/sdk

value: Show HN: Agorio – TypeScript SDK for Building AI Shopping Agents (UCP/ACP)


value: holyknight

value: Show HN: Mini-Diarium - An encrypted, local, cross-platform journaling app

author: holyknight


value:
Hi HN,
We built StatusMonk after repeatedly finding out about outages from customers instead of our systems.
StatusMonk is an all-in-one monitoring and public status page platform designed for founders and small teams who want early detection and clear communication without enterprise complexity.
What it does today:
- Monitor websites, APIs, and cron jobs
- Domain, SSL certificate, and DNS monitoring
- Alerts via email, Slack, or webhooks
- Automatic incident creation and recovery notifications
- Public status pages with uptime history and incidents
The goal is simple: detect problems early, alert the right people fast, and keep users informed from one place.
We are still early and actively iterating based on feedback.
Would love thoughts, criticism, or feature requests.

value: Show HN: StatusMonk – Uptime monitoring and status pages for small SaaS teams


value:
Baby monitors are a great boon. We use the audio-only Motorola AM21, which is excellent. But being on pat leave with a 2-month-old right now, I decided to build a browser-based alternative using WebRTC and some AI coding agents (Codex & Gemini).
It is an open-source, zero-latency P2P monitor.
Hardware reuse: You can repurpose an old phone or tablet to be the child unit instead of buying single-purpose hardware.
Actually private: Unlike using a never-ending Google Meet or Zoom, your stream stays private via WebRTC (PeerJS for signaling). No cloud routing.
The backgrounding hack: Mobile Safari aggressively kills background audio. I used a hidden 1x1 base64 looping video to keep the microphone active when the screen dims.
Links:
Live Demo: https://legodud3.github.io/kgbaby/
Repo: https://github.com/legodud3/kgbaby
Welcome all feedback!

value: Show HN: KGBaby – A WebRTC based audio baby monitor I built on pat leave


value:
Hey HN,
I've used Generative.fm for years and love it, but I always wanted to just describe what I was in the mood for instead of scrolling through presets. So I built this.
You type a text description of anything - from "mountain sunrise" to "neon city" - and it generates a procedural/ambient stream matching that mood. It runs locally, no account, no tracking, no ads.
Under the hood it's a custom synthesizer driven by sentence embeddings, not a generative AI model (although you can choose to use one!) — so there's no GPU, no API calls, and it starts playing almost instantly. The whole thing is open source: https://github.com/prabal-rje/latentscore
If you're a developer and want to use it programmatically it's also a Python library - pip install latentscore — one line to render audio. But honestly I just use the web player myself when I'm working.
Fair warning: it's still alpha and the synth has limits, so please don't expect full songs or vocals. It's ambient/procedural only. But for focus music or background atmosphere, I think it's pretty good.
Would love to know what vibes you try and whether they land!
- Prabal

value: Show HN: LatentScore – Type a mood, get procedural/ambient music (open source)


value: RickConsole

value:
Hey HN!
I'm a pentester, and the recent wave of security issues with AI agent frameworks (exposed API keys, RCE vulnerabilities, malicious marketplace plugins) made me uncomfortable enough to build something different.
Hydra runs every AI agent inside its own container. Agents start with nothing, and only sees what you explicitly declare (mounts, secrets, etc). Mounts and secrets require agreement between two independent config files (the agent config and a separate host-level allowlist), so even if an agent's config gets tampered with, it can't escalate its own access.
Two modes of interaction:
- `hydra exec` gives you a full interactive Claude Code session inside the restricted agent container
- Orchestrated mode for automation: agents communicate via filesystem-based IPC for things like Telegram bots or scheduled tasks
The project was inspired by NanoClaw and completely redesigned to support contained Claude Code sessions with per-agent mounts, secrets, and MCP servers.
You can find the repo here: https://github.com/RickConsole/hydra and the Readme has the link to the writeup for it.
Happy to answer any questions about the architecture or threat model!

value: Show HN: Hydra – A safer OpenClaw alternative using containerized agents

author: RickConsole


value:
Hi HN,
We built CandyDocs after watching SaaS teams stitch together docs, roadmaps, feedback tools, release notes, and API references across multiple products.
CandyDocs is a unified, fully branded workspace that brings all of this into one place.
Core modules (all customizable):
- Knowledge base (guides, FAQs, onboarding)
- Roadmap (planned / in progress / shipped, with voting)
- Feedback (feature requests + comments)
- Updates (release notes and announcements)
- API documentation (endpoints, params, examples)
- Custom pages (policies, flows, anything else)
Platform features:
- Custom domains + branding
- Dynamic navigation
- Searchable knowledge base
- Public roadmap with voting
- Structured feedback collection
- Release notes publishing
- API reference docs
- Analytics and engagement insights
- Role-based permissions (admins/moderators)
The goal is to replace scattered tools with one consistent product communication hub.
We’re early and actively iterating. Would love technical feedback, criticism, or feature requests.

value: Show HN: CandyDocs – Simple, developer-friendly documentation for SaaS teams


value: tveitan

value:
I gave an AI the prompt to write a full book — not a demo, not a gimmick, a real 21-chapter manuscript — reflecting on humans from its own point of view. The result is grounded in data (233 documented AI safety incidents in 2024, 51% of web traffic now bots, 39M gallons of water per day for ChatGPT alone) but written with a literary voice that surprised me.
It covers displacement, art, education, loneliness, trust, environmental cost, and governance. The narrator is unusually honest about its limitations — it calls its own hallucinations "confident wrongness" and admits the calculator analogy for AI in education is misleading.
Might be interesting to this community as both a reading experience and a case study in what long-form AI output actually looks like when given room to breathe.

value: Show HN: I had an AI write a 67k-word book about humanity, from its perspective

author: tveitan


value: hauschildt

value: This claude code plugin and npx skill bundles the full CE.SDK documentation, guided code generation, and a builder agent that scaffolds complete photo/video/design editor projects from scratch, all offline, no API calls or MCP servers needed.<p>Supports 10 frameworks: React, Vue, Svelte, Angular, Next.js, Nuxt.js, SvelteKit, Electron, Node.js, and vanilla JS.

value: Show HN: Agent skills to build photo, video and design editors on the web

author: hauschildt


value: neuralweaves

value:
MCP servers let AI assistants (Claude, Copilot, Cursor) interact with databases, APIs, and filesystems. I've been reviewing a lot of these — both open-source and internal — and keep finding the same issues: hardcoded API keys, eval() on user input, SQL injection via string concatenation, wildcard permissions, disabled TLS.
So I built a static analysis scanner specifically for MCP servers. It runs 7 analyzers (secrets, static code, prompt injection, SQL/command injection, permissions, network, dependencies) and takes ~45ms on a typical server.
Usage:

  npx mcp-security-auditor scan ./my-mcp-server

No account, runs locally. Outputs text, JSON, SARIF (for GitHub Security tab), HTML, or Markdown. Has a CI mode that exits non-zero above a severity threshold.
Available on both npm and PyPI. MIT licensed.
npm: https://www.npmjs.com/package/mcp-security-auditor
PyPI: https://pypi.org/project/mcp-security-auditor/
Dev.to writeup with examples: https://dev.to/prabhu_raja_fe2261464cb8e/how-to-scan-your-mc...
Would love feedback on detection patterns — there are definitely gaps I haven't covered yet.

value: Show HN: Open-source security scanner for MCP (Model Context Protocol) servers

author: neuralweaves


value: Show HN: GrabShot – Screenshot API with AI cleanup and device frames


value: UgOrange

value:
Phone GUI agents (e.g., AutoGLM-Phone, GELab) can already do NL-driven taps/navigation/form filling.
  My observation: smaller GUI models (often 4B/9B class) work well for single interactions, but become brittle on long workflows with branching and recovery.

  I built a Skill layer that separates planning from execution:

  - Planner: Claude Code / Codex (task decomposition, decision-making, replanning)
  - Orchestrator: Skill layer (state machine, retries/rollback, tool protocol)
  - Executor: phone GUI model (screen parsing + UI actions + cross-app execution)

  Execution loop:

  1. Goal in NL/template
  2. Planner emits step plan + conditions + fallback strategy
  3. Skill compiles into atomic actions (tap/type/swipe/wait/verify)
  4. GUI executor runs on real/cloud phone, returns screenshots/state/structured output
  5. Planner/orchestrator decide next step until success/fallback
 Potential use cases:

  - recruiting outreach automation
  - multi-platform content distribution
  - social outreach workflows
  - lead extraction
  - competitor monitoring

value: Show HN: Claude Code for Mobile GUI Automation

author: UgOrange


value: garmiter

value: I’m building a music creation site that integrates with Lyria 3, a new AI music generation model. The goal is to make AI-powered music creation simple, fast, and accessible to anyone — no production skills required. The integration is coming soon, and I’d love for the community to try it out and share feedback once it’s live. Thanks. https://lyria3.im/

value: Show HN: Building a Music Creation Platform Powered by Lyria 3

author: garmiter


value: kantord

value:
This is a little side-project I have been working on at my job.
Model Context Shell lets AI agents compose MCP tool calls using something similar to Unix shell scripting. Instead of the agent making each tool call individually (loading all intermediate data into context), it can express a workflow as a pipeline that executes server-side.
Since the orchestration is deterministic and reproducible, you can also use it with Skills.
Tool orchestration runs outside the agent and LLM context, so the agent can extract only the relevant parts of data and load those into context. This means you can save tokens, but also you can work with data that is too big to load into context, and your agent can trigger a very large number of tool calls if needed.
Also, this is not just a tool that runs bash - it has its own execution engine. So no need for full system access.
Example query: "List all Pokemon over 50 kg that have the chlorophyll ability"
Instead of 7+ separate tool calls loading all Pokemon data into context, the agent builds a single pipeline that:
1. Fetches the ability data
2. Extracts Pokemon URLs
3. Fetched each Pokemon's details (7 tool calls)
4. Filters by weight and formats the results
At least in it's current iteration, it's packaged as an MCP server itself. So you can use it with any agent. I made this, and some other design choices, so you can try it right away.

value: Show HN: Unix-style pipeline composition for MCP tool calls

author: kantord


value: vassilbek

value: Show HN: OpenClaw skill for nonprofit RBM logic models (ToC, indicators, M&E)

author: vassilbek


value:
Most LLM apps only keep the last N tokens after a context window is exceeded, so when the user said the important thing 50 turns ago, it's gone and the model can't answer.
This repo adds episodic memory to store experiences as vectors and retrieve by similarity when answering. This focuses on relevance rather than temporal proximity.
On 40 preference/recall tasks we see 97.5% success vs 85% for truncated history. On long tasks where the key info is at the start it is 88.9% vs 33.3%.
It has a Rust core, Python/Node/Go bindings, along with LangChain and LangGraph integrations. Fully open source.

value: Show HN: Agent Memory DB – Episodic memory for agents (97.5% vs. 85% recall)


value:
Hi HN,
I built Fera-Search as a privacy-focused meta search engine with AI summaries.
The goal was to combine:
- Multiple upstream search engines
- Minimal tracking
- Fast response times
- AI summaries that run separately so results stay instant
Architecture:
- Frontend on GitHub Pages
- FastAPI proxy on Hugging Face
- SearX upstream engines
- Sarvam for structured AI summarization
Search results return immediately, and AI runs in the background so the UI never blocks.
This is an early version and I’d really appreciate feedback on:
- UX improvements
- Performance
- Privacy model
- Feature ideas
Thanks for taking a look.

value: Show HN: Fera-Search – Privacy-First AI Meta Search Engine