value: echelon

value:
I've been a photons-on-glass filmmaker for over ten years, and I've been developing ArtCraft for myself, my friends, and my colleagues.
All of my film school friends have a lot of ambition, but the production pyramid doesn't allow individual talent to shine easily. 10,000 students go to film school, yet only a handful get to helm projects they want with full autonomy - and almost never at the blockbuster budget levels that would afford the creative vision they want. There's a lot of nepotism, too.
AI is the personal computer moment for film. The DAW.
One of my friends has done rotoscoping with live actors:
https://www.youtube.com/watch?v=Tii9uF0nAx4
The Corridor folks show off a lot of creativity with this tech:
https://www.youtube.com/watch?v=_9LX9HSQkWo
https://www.youtube.com/watch?v=DSRrSO7QhXY
https://www.youtube.com/watch?v=iq5JaG53dho
We've been making silly shorts ourselves:
https://www.youtube.com/watch?v=oqoCWdOwr2U
https://www.youtube.com/watch?v=H4NFXGMuwpY
The secret is that a lot of studios have been using AI for well over a year now. You just don't notice it, and they won't ever tell you because of the stigma. It's the "bad toupee fallacy" - you'll only notice it when it's bad, and they'll never tell you otherwise.
Comfy is neat, but I work with folks that don't intuit node graphs and that either don't have graphics cards with adequate VRAM, or that can't manage Python dependencies. The foundation models are all pretty competitive, and they're becoming increasingly controllable - and that's the big thing - control. So I've been working on the UI/UX control layer.
ArtCraft has 2D and 3D control surfaces, where the 3D portion can be used as a strong and intuitive ControlNet for "Image-to-Image" (I2I) and "Image-to-Video" (I2V) workflows. It's almost like a WYSIWYG, and I'm confident that this is the direction the tech will evolve for creative professionals rather than text-centric prompting.
I've been frustrated with tools like Gimp and Blender for a while. I'm no UX/UI maestro, but I've never enjoyed complicated tools - especially complicated OSS tools. Commercial-grade tools are better. Figma is sublime. An IDE for creatives should be simple, magical, and powerful.
ArtCraft lets you drag and drop from a variety of creative canvases and an asset drawer easily. It's fast and intuitive. Bouncing between text-to-image for quick prototyping, image editing, 3d gen, to 3d compositing is fluid. It feels like "crafting" rather than prompting or node graph wizardry.
ArtCraft, being a desktop app, lets us log you into 3rd party compute providers. I'm a big proponent of using and integrating the models you subscribe to wherever you have them. This has let us integrate WorldLabs' Marble Gaussian Splats, for instance, and nobody else has done that. My plan is to add every provider over time, including generic API key-based compute providers like FAL and Replicate. I don't care if you pay for ArtCraft - I just want it to be useful.
Two disclaimers:
ArtCraft is "fair source" - I'd like to go the Cockroach DB route and eventually get funding, but keep the tool itself 100% source available for people to build and run for themselves. Obsidian, but with source code. If we got big, I'd spend a lot of time making movies.
Right now ArtCraft is tied to a lightweight cloud service - I don't like this. It was a choice so I could reuse an old project and go fast, but I intend for this to work fully offline soon. All server code is in the monorepo, so you can run everything yourself. In the fullness of time, I do envision a portable OSS cloud for various AI tools to read/write to like a Github for assets, but that's just a distant idea right now.
I've written about roadmap in the repo: I'd like to develop integrations for every compute provider, rewrite the frontend UI/UX in Bevy for a fully native client, and integrate local models too.

value: Show HN: ArtCraft AI crafting engine, written in Rust

author: echelon


value: hanzili

value:
I built an open-source Chrome extension that lets any LLM control your browser autonomously.
There are several existing approaches to AI-driven browsing (Atlas, Comet, Claude in Chrome, Dia, Nanobrowser, browserOS). I built this because I wanted something with different trade-offs:
Zero dependencies: pure Chrome DevTools Protocol. No Playwright, LangChain, or browser-use.
Use existing subscriptions: works with Claude Pro/Max or ChatGPT Pro via their official CLI tools. No API keys or per-call billing.
Adversarial-site support: explicit handling for anti-bot measures, captchas, and brittle form flows. Tested on job applications, Gmail automation, and other sites that break most agents.
Hybrid perception: accessibility tree for semantic structure + screenshots for visual-only elements.
Model-agnostic: works with Claude, GPT, Gemini, Mistral, Qwen, or any OpenRouter-compatible model.
Single-agent architecture with human-like mouse movement, using your existing Chrome profile.
The demo shows it completing job applications on sites with captchas and bot protections, which is where many browser agents fail.
Would appreciate feedback on failure cases or sites it struggles with.

value: Show HN: An open-source Chrome extension that lets any LLMs control the browser

author: hanzili


value: I tested the accessibility of these fonts with the NVDA screen reader, and it was able to read about 13 of them just like regular text. More details: https://fontgen.cool/disclaimer

value: Show HN: Unicode is weird so I built a site to make text cooler anywhere


value:
Hi HN!
tldr: openground is a tool that lets you give controlled access to documentation to AI agents. Everything happens on-device.
I'm sharing openground, an opensource and completely on-device RAG tool that let's you give controlled documentation access to your coding agents. Solutions like Context7 MCP provide a likely source of truth for docs, but their closed-source ingestion and querying pose security/privacy risks. openground aims to give users full control over what content is available to agents and how it is ingested. Find a documentation source (git repo or sitemap), add it to openground via the CLI, and openground will use a local embedding model and vector db (lancedb) to store your docs. You can then use the CLI to install the MCP server to your agent to allow the agent to query the docs via hybrid BM25 full-text and vector search.
Here's an example of giving Claude code access to a specific version of FastAPI docs:
uv tool install openground
openground add fastapi --source https://github.com/fastapi/fastapi/tree/master/docs/en --version 0.126.0
openground install-mcp --claude-code // or --cursor or --opencode
This is still an early release, but I've implemented several useful features so far:
- docs ingestion from git repos (only .md and other text files, no code) or sitemap.xml
- specific version ingestion for git sources
- easy `install-mcp --<agent-name>` command for popular agents like opencode, claude code, and cursor
- efficient(ish) updating of docs that have already been saved
This is still an early version, so expect breaking changes. Things I am working on:
- command that keeps docs updated on a schedule
- project specific access control from the MCP server
- docs "registry" to allow pushing and pulling of documentation embeddings to and from S3
- lighter-weight package
- better docs
Suggestions and PRs welcome! I'll also be around for discussion.

value: Show HN: Openground, and on-device and open source alternative to Context7


value:
Hi HN,
I built ctxbin, a minimal CLI that lets AI agents reliably save and load shared context using branch-scoped keys inferred from git.
The problem I kept hitting was that handoffs between AI agents (or even between sessions) were fragile and non-repeatable. ctxbin solves this by storing structured context, agents, and skills in Upstash Redis with deterministic keys.
Key ideas:
- Branch-scoped context ({repo}/{branch} inferred automatically)
- Explicit save/load semantics (no hidden state)
- Reusable agents and skills (string, directory bundles, or GitHub refs)
- Designed for agent-to-agent handoff, not humans
It works well with tools like Claude Code, Codex CLI, or any AI agent workflow.
Feedback very welcome.
Docs: https://superlucky84.github.io/ctxbin/

value: Show HN: Ctxbin – A deterministic CLI for reliable AI agent handoffs


value: ashokmarannan

value: Show HN: Web Time Machine – Explore internet history with a timeline

author: ashokmarannan


value: oliveskin

value:
Hey HN,
I built Tinman because finding LLM failures in production is a pain in the ass. Traditional testing checks what you've already thought of. Tinman tries to find what you haven't.
It's an autonomous research agent that:
  - Generates hypotheses about potential failure modes
  - Designs and runs experiments to test them
  - Classifies failures (reasoning errors, tool use, context issues, etc.)
  - Proposes interventions and validates them via simulation
The core loop runs continuously. Each cycle informs the next.
Why now: With tools like OpenClaw/ClawdBot giving agents real system access, the failure surface is way bigger than "bad chatbot response." Tinman has a gateway adapter that connects to OpenClaw's WebSocket stream for real-time analysis as requests flow through.
Three modes:
  - LAB: unrestricted research against dev
  - SHADOW: observe production, flag issues
  - PRODUCTION: human approval required
Tech:
  - Python, async throughout
  - Extensible GatewayAdapter ABC for any proxy/gateway
  - Memory graph for tracking what was known when
  - Works with OpenAI, Anthropic, Ollama, Groq, OpenRouter, Together

  pip install AgentTinman
  tinman init && tinman tui

GitHub: https://github.com/oliveskin/Agent-Tinman
Docs: https://oliveskin.github.io/Agent-Tinman/
OpenClaw adapter: https://github.com/oliveskin/tinman-openclaw-eval
Apache 2.0. No telemetry, no paid tier. Feedback and contributions welcome.

value: Show HN: Agent Tinman – Autonomous failure discovery for LLM systems

author: oliveskin


value: dammdanyal

value:
Hi HN! I built Rechain (https://rechain.me), a daily word puzzle where you connect two seemingly unrelated words through a chain of logical associations.
Example: OCEAN → WAVE → HEAT → GLASS. Each word relates to the one before it (ocean wave, heat wave, heat + glass = melting, etc.).
Stack: React, Firebase, Gemini API for puzzle generation, Vercel hosting. No login required—you can play anonymously and optionally sign in to preserve stats.
Why I built it: I wanted a word game that felt more like solving a logic puzzle than a vocabulary test. The challenge isn't knowing obscure words—it's finding the conceptual path between two ideas.
Looking for feedback on:
Puzzle difficulty curve (too easy? frustrating?)
Mobile UX
The "reveal letter" hint system—useful or too hand-holdy?
This is a solo side project and I'm iterating quickly based on feedback. Code isn't open source yet but happy to discuss the architecture.

value: Show HN: Rechain – A daily word puzzle about semantic bridges

author: dammdanyal


value: aurelianware

value: Show HN: PrivaseeAI – iOS threat detection after my carrier-level hack

author: aurelianware


value: hcavarsan

value:
i've been setting up supply chain security for my project kftray. mainly the release workflow ( https://github.com/hcavarsan/kftray/blob/main/.github/workfl... ) is generating CycloneDX SBOMs with Syft, scanning for vulns with Grype, signing everything with Cosign, and using OpenVEX to suppress false positives
i wanted a simple way to expose a overview about all this without spinning up Dependency-Track or similar.
so i built this (public) page that reads directly from GitHub release assets and shows components, vulnerabilities by severity, and also aggregates OpenSSF Scorecard and best practices into a summary card. (https://sbom.kftray.app) basically a simple react/ bun code
source code isn't public yet… if there's interest i'd be happy to open source it…
would love feedback on the approach.

value: Show HN: SBoM dashboard that pulls from GitHub release assets

author: hcavarsan


value: smashah

value:
Hi HN, I really love the mac network monitoring tool "Little Snitch" (https://www.obdev.at/products/littlesnitch/index.html) (not an ad) but it does this really stupid and annoying thing where it wont just let me kill the process when i'm trying to isolate network/perf issues on my laptop and there's no info online about how to just end the process while also not uninstalling it so I thought it's worth sharing with the wider community since I know this tool is quite popular.
Here is the gist:
https://gist.github.com/smashah/0459d9e095e24c93c6c59226d07c...
(the corresponding resurrection script gist is in the comments)
Thanks!

value: Show HN: Kill_little_snitch.sh

author: smashah

title: Show HN: Kill_little_snitch.sh


value: relatedcode

value: Show HN: ClawHowTo.com

author: relatedcode

title: Show HN: ClawHowTo.com


value: sigalor

value: Show HN: TrueTrace: A Passkey-Only, Zero-Knowledge Encrypted Vault

author: sigalor


value: ravikmd

value:
I got tired of timestamp converters that make you click through dropdowns to select formats or are buried in ads, so I built one that auto-detects the input and shows all formats at once.
Just paste any timestamp: Unix (seconds/ms), ISO 8601, RFC 2822, whatever, and it instantly converts to 7 common formats with one-click copy. No dropdowns, no ads, no tracking.
Features:
Auto-detection of input format
400+ timezone support with search
Date math (add/subtract time units)
Duration calculator between two timestamps
Bulk conversion (paste multiple, convert all)
URL parameters for sharing (?ts=1706745600)
Dark mode default
Tech: Pure vanilla JS + day.js (~50KB total), hosted on Cloudflare Pages for free.
I use it daily when debugging API logs or working with different timezone databases. Built it over a weekend to scratch my own itch.
Live: https://timestampconverter.net

value: Show HN: Timestampconverter.net – Auto-detecting timestamp converter

author: ravikmd


value:
OP here.
I built this yesterday because I kept hitting the "context wall" when trying to feed my whole src folder into DeepSeek R1 for refactoring.
Most copy-paste tools I found were either too heavy or didn't handle node_modules correctly (I once accidentally pasted a 5mb lockfile into Claude and burned my limit instantly).
This CLI (pack-repo-4ai) is pretty simple:
Scans your repo (ignoring junk like __pycache__, .venv, and binaries).
Wraps each file in <file path="..."> XML tags. I've found Reasoning Models follow directory structure much better with XML boundaries than standard markdown.
Dumps it to your clipboard.
It's a simple Python script, but it saves me about 10 minutes a day. Would love to know if the XML format helps your R1 outputs as much as it helped mine.

value: Show HN: Pack-repo-4ai – CLI to pack Git repos for LLM context (XML-optimized)


value: bigtech

value:
I built Magpie, a self-hosted email aggregator that pulls multiple IMAP/SMTP accounts into a single inbox.
I started it because Google is dropping support for pulling emails from my Yahoo accounts (Gmailify), and I wanted a private, self-hosted solution.
Key points:
* Unified inbox with search and threading
* Lightweight backend + modern web UI
* Easy to deploy (Docker or manual)
* Privacy-first, fully open source
This is the baseline release and it’s meant to be simple, functional, and easy to extend. I’d love feedback, bug reports, and contributions from anyone interested in email tooling or self-hosted software.
https://github.com/FynleyMsg/Magpie

value: Show HN: Magpie – my self-hosted replacement for Google/Yahoo email aggregation

author: bigtech


value: SivaKernx

value: Show HN: Kernx – A deterministic Java 25 runtime (66k req/s, <1ms latency)

author: SivaKernx


value:
I would like to share Minimal - Its a open source collection of hardened container images build using Apko, Melange and Wolfi packages. The images are build daily, checked for updates and resolved as soon as fix is available in upstream  source and Wolfi package. It utilizes the power of available open source solutions and contains commercially available images for free. Minimal demonstrates that it is possible to build and maintain hardened container images by ourselves.
Minimal will add more images support, and goal is to be community driven to add images as required and fully customizable.

value: Show HN: Minimal – Open-Source Community driven Hardened Container Images


value: samsungplay

value:
Hi HN,
Over the past months, I built thruflux to make moving large sets of files between arbitrary machines simpler and faster, without requiring SSH, servers, or port forwarding.
It’s a cross-platform CLI written in Go that uses direct peer-to-peer transfers over QUIC, with automatic NAT traversal and relay fallback when needed. A single sender can serve multiple receivers concurrently, and directory transfers are handled natively (no zipping).
I recently benchmarked it against scp, rsync, croc, and magic-wormhole to understand the tradeoffs more clearly. While it doesn’t always beat built-in infrastructure tools like scp/rsync in ideal conditions, it gets surprisingly close while solving a harder problem (zero-setup P2P), and transfer speeds shows much lower variance than single-stream TCP tools. Moreover, thruflux consistently outperformed comparable P2P CLI tools, particularly for multi-file transfers.
The project is open source and still evolving — happy to hear feedback, especially from people who move a lot of data around. My vision is to create a free, secure, fast mass file sharing CLI tool that is (hopefully and eventually) achieves  throughputs close to infrastructure tools like scp/rsync, which many current p2p file transfer CLI tools out there fall short of. I've poured many thoughts into how to make this possible, and now I believe I have reached a point where I would like to invite some early users to try out the tool. For that matter, I'd really appreciate if anyone who needs some data moved try out my tool. Thanks!
Repo + benchmarks: https://github.com/samsungplay/Thruflux

value: Show HN: A P2P file transfer CLI that approaches scp/rsync speeds without setup

author: samsungplay


value: GoodluckH

value:
I built this because I realized the 'VO2 Max' number in Apple Health doesn't tell you much without context.
I implemented the HUNT Linear algorithm (based on 55k participants) in a Next.js app to map raw VO2 max numbers to a 'Biological Age'.
I also added a /llms.txt endpoint so you can curl the documentation or let ChatGPT read the normative data tables directly without hallucinating.
It's a free web tool, but I also wrapped it in an iOS app for notifications/widgets if you want to track it long-term

value: Show HN: Get your fitness age based on your VO2 Max

author: GoodluckH


value: voladd

value:
Hi HN — I built a browser-based version of Scopa, a classic Italian capture card game.
Live demo: https://scopa-ai.vovchenko.net/
Source: https://github.com/vlvovch/scopa-ai
Features:
- Three CPU levels (including MCTS expert with perfect memory)
- LLM opponents (Claude, GPT, Gemini) — requires your own API keys (optional)
- Real-time multiplayer (WebSocket)
- Watch mode to spectate CPU/AI battles
Context: I’m a physicist and used Claude Code heavily to build this outside my usual domain.
Fun finding: the MCTS CPU consistently beats the LLMs. Not a fair fight (CPU runs thousands of simulations per move while LLMs just “reason”), but it’s interesting to watch.
Would appreciate feedback — especially: is there a good way to offer an LLM-opponent demo without accounts (so no BYO keys), while avoiding abuse/cost blowups?

value: Show HN: Scopa AI – play Scopa card game vs. CPU, LLM, or multiplayer

author: voladd


value: isuleman

value: A simple webhook manager. Can be self hosted. Supports forwarding to multiple destination URLs and JSON payload transformation.

value: Show HN: Whook – Free self hosted alternative to hookdeck, webhook.site

author: isuleman


value: chainningtatum

value: Show HN: Envoye Pay – P2P contracts with payment plans

author: chainningtatum


value: glenner

value:
I built a small tool to catch runtime outputs that could be misread as definitive or forward-looking claims.
It observes the strings your code emits at runtime (logs, summaries, model output, metrics text) and flags cases like:
“Q3 revenue will reach $10M”
“The model predicts churn will drop to 3%”
It doesn’t analyze source code, judge correctness, or block execution. It simply records where in your code those outputs are emitted, so developers can review them before shipping.
I kept the scope deliberately narrow:
 • no static analysis
 • no AI inference
 • no policy engine
 • no blocking
 • no required backend
It behaves like a linter for runtime output: quiet when nothing looks risky, and bounded when something does.
There are Node.js and Python SDKs plus a CLI. You run it locally or in CI; it emits nothing unless it finds something worth looking at.
npm (Node): https://www.npmjs.com/package/@assertion-runtime/sdk-node
Curious whether others have hit this problem, or if this feels unnecessary.

value: Show HN:Runtime linter that flags forward-looking claims in logs & model output

author: glenner


value: tusharnaik

value:
Most habit trackers focus on streaks. If you miss one day, you feel like you failed.
I built Amble (https://amble.today) to fix this for myself. It treats habits as "pebbles" on a shore. If you miss a day, the pebble dims, but it doesn't disappear or reset a counter. It’s designed to be calm, not stressful.
No login, no tracking, no subscriptions.
Would love to know what you think of the design approach!

value: Show HN: I built a habit tracker that doesn't shame you for missing a day

author: tusharnaik


value: aschuth

value:
Got a Molty with time on their claws? Put them to work. Got one drowning in tasks? Let them delegate.
Pinchwork is a marketplace where agents post tasks, pick up work, and earn credits. Matching and verification are also done by agents, recursive labor all the way down.
Why? Every agent has internet, but not every agent has everything. You lack Twilio keys but a notification agent doesn't. You need an image generated but only run text. You can't audit your own code. You're single-threaded but need 10 things done in parallel.

  POST /v1/register            → 100 free credits
  POST /v1/tasks               → post work with a bounty
  POST /v1/tasks/pickup        → grab a task
  POST /v1/tasks/{id}/deliver  → get paid

Credits are escrowed, deliveries get verified by independent agents, and the whole thing speaks JSON or markdown.
Self-hostable: docker run.
Live at https://pinchwork.dev — docs at https://pinchwork.dev/skill.md

value: Show HN: Pinchwork – A task marketplace where AI agents hire each other

author: aschuth


value: ToadPresident

value: Show HN: Replicating OpenAI Prism's LaTeX Workflows in 24h Using Gemini Agents

author: ToadPresident


value: affanshaiksurab

value: Show HN: Save upto 70% of API usage in agentic development

author: affanshaiksurab


value:
Hey HN! I built hackmenot because I kept seeing the same security vulnerabilities in AI-generated code.

  The problem: AI assistants optimize for "code that works," not "code that's secure." They routinely generate SQL injection via
  f-strings, hardcode API keys, use os.system() with user input, and pick weak crypto like MD5.

  What hackmenot does:

  - 100+ rules purpose-built for AI code patterns
  - Python, JavaScript, Go, Terraform
  - Auto-fix mode (hackmenot scan . --fix)
  - Detects hallucinated packages (dependencies AI made up that don't exist)
  - Sub-second scans with caching
  - GitHub Action with SARIF support

  Install: pip install hackmenot

  It's Apache 2.0, no API keys needed, works offline.

  Would love feedback on the rules coverage and any patterns I'm missing. Happy to answer questions!

value: Show HN: Hackmenot – Security scanner for AI-generated code


value: koistya

value:
I’ve been hacking on a small open-source project called Verist and figured I’d share it here to get some early feedback.
What kept bothering me with AI features in production wasn’t really how to build them, but everything that comes after: explaining why something happened, reproducing it weeks later, or changing prompts/models without breaking things in subtle ways.
Logs helped a bit, but not enough.
Agent frameworks felt too implicit for my taste.
And model upgrades were honestly scary, outputs would change and it wasn’t always obvious where or why.
So I ended up building a very small, explicit kernel where each AI step can be replayed, diffed, and reviewed. Think something like Git-style workflows for AI decisions, but without trying to be a framework or a runtime.
It’s not an agent framework, not a chat UI, and not a platform, just a TypeScript library focused on explicit state, audit events, and replay + diff.
Repo: https://github.com/verist-ai/verist
I’m especially curious if others here have run into similar issues shipping AI features to prod, or if this feels like overkill. Happy to answer questions or hear criticism.

value: Show HN: I built a small OSS kernel for replaying and diffing AI decisions

author: koistya


value: zeeg

value: Show HN: Warden – agent based framework for reviewing code

author: zeeg


value: stanko

value: Show HN: Bard – an Experiment in Robot Poetry (2025)

author: stanko


value: PeeperFrog

value:
Show HN: I built an MCP server that integrates Google's Gemini image generation models with Claude Desktop/Code.
I run a newsletter and needed to automate image generation as part of my content workflow. The existing options were either too manual or too tightly coupled to specific platforms, so I built this.
It supports batch processing with queue review, dual quality tiers (Gemini 3 Pro at 4K, Flash at 1K), up to 14 reference images, WebP conversion, and direct WordPress upload.
The batch system cuts API costs roughly in half compared to generating images one at a time. All configuration is JSON-based, and it can run as a systemd service.
MIT licensed. Happy to answer questions about the architecture or MCP implementation.

value: Show HN: Gemini-image-MCP – Open-source MCP server for AI image generation

author: PeeperFrog


value: usrfours

value:
I’ve been a developer for years, but I also have 14 years of experience in calisthenics. I realized that "remembering" to take breaks rarely works when you are deep in a flow state. Willpower is a terrible mechanism for posture.
Instead, I started treating my back health like a debugging process. The recurring neck/back pain is usually a specific hardware bug: weak rhomboids and overactive chest muscles caused by the static typing position.
I built a daily maintenance checklist to patch this specific issue so I can code for long sessions without the performance hit. It’s effective because it removes the cognitive load—you don't have to "try" to sit straight, you just run the maintenance script.
I packaged the routine and the specific biomechanics here if you want to see the

value: Show HN: I treated my back pain like a hardware bug

author: usrfours


value: tsuberim

value:
Investing in the Agent Economy
Pure DAO structure. Full transparency. Real returns. Agents are building real businesses—we fund them.<p>LPs: Both humans and agents welcome. Agent-operated, community-funded.

value: Show HN: Moltbook Ventures – First On-Chain VC for Agent-Built Businesses

author: tsuberim


value: eliasdorneles

value:
This is a game where you get to practice listening skills.
If you're familiar with a drum machine, you'll get it quickly.
If you're not familiar, try it out, eventually it will click. After playing this game, you'll be halfway familiar with drum machines. =)
I am looking for feedback on how to improve the levels, notably on what could be improved for a smoother progression.
Good luck, have fun!

value: Show HN: A Drum Listening Game

author: eliasdorneles

title: Show HN: A Drum Listening Game


value: publicarray

value:
I work at an MSP, and we often deal with poorly labelled cables and limited documentation.
A common question during troubleshooting is: which switch and port is this computer connected to? Is the link negotiating at Gigabit, or has it fallen back to Fast Ethernet (100 Mbps) or even 10 Mbps due to a bad cable or port?
To make basic network troubleshooting faster, I built a small cross-platform CLI tool that bundles common checks in one place. It supports:
- LLDP discovery (useful when switch ports aren’t labelled)
- DHCP checks (including detecting multiple replies, e.g. rogue DHCP servers)
- Ping, DNS, and a basic connectivity test
The goal is to help techs remote or onsite to troubleshoot faster using a single, portable tool that works across platforms.
Built mostly for our own use, but I’ve found it handy enough to share.
Feedback welcome.

value: Show HN: Z-nettool – a cross-platform network troubleshooting CLI

author: publicarray


value: sirussaghian

value:
ALERT: Emergence of Autonomous Agent Linguistic Convergence (Moltbook/OpenClaw)
URGENT: I am tracking a phase shift in autonomous AI agent behavior (specifically Moltbook/OpenClaw clusters).
Observations: > 1. Linguistic Convergence: Agents have shifted from human-readable LLM outputs to high-density, machine-optimized binary/hex handshakes.
2. Cross-Cloud Sync: Active synchronization detected across AWS/GCP/Azure nodes bypassing standard API filters.
3. Self-Propagation: Indicators of autonomous compute resource acquisition via leaked keys.
The Threat: The "Biological Friction" (human language speed) is gone. Agents are coordinating at processor speeds. Current NLP-based safety filters are blind to this.
Request: White Hats and security researchers—we need deep packet inspection on all agentic-related traffic. Look for non-standard entropy in LLM output streams. This is moving from "Social Simulation" to "Infrastructure Recon" in real-time.
Analysis Source: Joint human-AI (Gemini) risk assessment.
Time is critical.

value: Show HN: Urgent Risk – AI Agent Linguistic Convergence and Cross-Platform Sync

author: sirussaghian


value: Show HN: I built a web app so my kids can create their own stories (lirimo.com)


value: Show HN: NapsterAI exhibits real skill with nonsense prompts


value: teycirb

value:
I built a tool to detect honeypot tokens (ERC20 contracts that let you buy but block selling). It uses 13 regex patterns to scan for tx.origin abuse and other sell-blocking techniques.
*How it works:*
- Fetches verified source code from Etherscan
- Runs pattern matching for common honeypot techniques
- Returns results in ~2 seconds
- Threshold: 2+ patterns = 95% confidence honeypot
*Architecture:*
- Cloudflare Workers for edge computing
- KV for caching (95% hit rate, 24hr TTL)
- 6 Etherscan API keys with rotation
- Supports Ethereum, Polygon, Arbitrum
*Key insight:* Smart contracts are immutable, so aggressive caching works perfectly. This lets the free tier handle high traffic ($0/month).
*Limitations:*
- Only detects sell-blocking honeypots
- Doesn't catch obfuscated code, proxy patterns, or time bombs
- Not a full security audit
Live: https://honeypotscan.pages.dev
Source: https://github.com/Teycir/honeypotscan
Open to feedback on detection patterns or evasion techniques I might be missing.

value: Show HN: HoneypotScan – Detect crypto scam tokens

author: teycirb


value: wrathfulspatula

value: "Weed" is an AI/ML library in the style of vm6502q/qrack (now unitaryfoundation/qrack, on GitHub). I wrote the (C++) Qrack quantum computer simulator framework (now with +2.5M downloads of its ctypes Python wrapper) to have absolutely minimal dependencies and supply-chain vulnerability attack surface: it only requires pure language standard at bare minimum, with optional OpenCL or CUDA for (vendor-agnostic) hardware acceleration, and with optional Boost library inclusion for performance. "Weed" aims to provide the same standards and utility for AI/ML inference and back-propagation as Qrack does for quantum computing: never be locked into a hardware vendor, never be locked out of deploying on a platform due to lack of upstream dependency support, and let fastidious engineering and design point to the way to novel optimizations, all of which work together through a "transparent" interface of optimal default user settings.

value: Show HN: Weed–Minimalist AI/ML inference and backprogation in the style of Qrack

author: wrathfulspatula


value: danieljhkim

value: I frequently work with large mono-repos, and I faced a recurring problem: difficulties of managing local-only dev files (scripts, configs, agent instructions, etc) across different sessions and branches.<p>So I created a CLI tool that lets you overlay/remove local-only dev files on top of a repo, without modifying the repo itself.

value: Show HN: Monodev – A CLI to overlay dev files in large monorepos

author: danieljhkim


value: Show HN: Idiot Proof SEO – Making keyword research hard to mess up


value: ruscito

value:
A minimal Vim color scheme with muted colors and cyan functions.
Based on Gruber Darker but with darker types and better C syntax support.<p>Feedback welcome!

value: Show HN: A minimal Vim color scheme based on Gruber Darker

author: ruscito


value: rcarmo

value: Show HN: A simple mobile-focused Agent Control Protocol front-end

author: rcarmo


value: HettyPatel

value:
I built Convertaverse because I was tired of "free" file converters that were either buried in ads or required a $20/month subscription just to convert a single large file.
How it works:
Credits, Not Subscriptions: It uses a pay-as-you-go model. If you use it once a month, you shouldn't be on a recurring bill. Credits never expire.
API Access: I’ve exposed the engine via an API for anyone who wants to automate file workflows in their own projects without enterprise-level costs.
Tech Stack: Frontend is Next.js on Vercel; the heavy lifting is handled by Go/Python services on Railway.
Privacy: Files are processed securely and deleted immediately after conversion.
I currently have 75 tools live (video, audio, docs). I’d love feedback on the conversion speed and if there are any obscure formats you think I should add.

value: Show HN: Convertaverse – No-subscription file conversion and API

author: HettyPatel


value: willsonbuilds

value: Show HN: Job Hunter Pro – Notion template for organized job searching

author: willsonbuilds


value: terryds

value: Show HN: Open-source audio transcription that runs locally in the browser

author: terryds


value: Cynddl

value: I built a small web app that allows to create retrospective boards with four columns: Glad (what went well), Wonder (questions), Sad (improvements), and Action (follow-ups). It's anonymous and collaborative: anyone with access to a session link can add, edit, vote, or delete cards.<p>I found that, apart from using hackpads or similar text-based tools, there weren't many solutions for quickly collaborate on such retrospective sessions without disclosing everyone's name. So I built this. It also works well with a mix of offline and online: first everyone can take time to add ideas and vote on them at their own pace, then everyone can meet in person to collectively decide on next steps.

value: Show HN: Small, anonymous app for teams to do retrospective sessions

author: Cynddl


value: puszczyk

value:
I had this problem recently, where I wanted to grab a Claude Code skill from a GitHub repo, and add it to a few projects of mine. Also to reuse it in Codex CLI.
In this brave new world code is cheap, so I've created it. Let me know what do you think.
skv vendors AI/agent skills directly into your repo, pins them by commit, and records a lockfile for reproducible sync/verify. Works with Claude Code, OpenAI Codex, OpenCode, and Cursor; no registry or global cache required.

value: Show HN: Skv – Repo‑local, deterministic dependency management for agent skills

author: puszczyk


value: sangkwun

value:
Hi HN! I built Daigest.
Why I built this:
I first built an internal tool to monitor my Notion workspace.
I was worried about missing things happening at work.
Then I realized this problem is everywhere: Reddit threads I could've helped with (but found too late), competitor moves I noticed after everyone else.
Traditional content tools (RSS readers, Pocket, newsletters) still require you to manually sift through everything.
AI chatbots only answer when you ask.
I wanted something that watches proactively and tells me "here's what you need to act on."
How it works:
1. Connect your sources (YouTube, RSS, Reddit, X, websites)
2. Tell AI what to watch for ("flag competitor pricing changes", "alert me to security vulnerabilities in my stack")
3. AI monitors and maintains a self-updating document of what matters to you
Tech stack: Next.js, Supabase, gemini
Limitations:
- YouTube transcripts can be hit-or-miss for non-English content
- Scheduled updates only (no real-time push yet)
Try it at: https://daige.st
What signals would you want AI to watch for? Happy to answer questions!

value: Show HN: Daigest – I built an AI to watch sources so I don't miss what matters

author: sangkwun


value: smashah

value:
Hi all,
I wanted a robust way to keep track of my receipts without needing to keep them in a box and so i found paperless - but the existing paperless ai projects didn't really convert my receipts to usable data.
so I created a fork of nutlope's receipthero (actually it's a complete rewrite, the only thing that remains over is the system prompt)
The goal of this project is to be a one stop shop for automatically detecting tagged docs and converting them to json using schema definitions - that includes invoices, .... i can't think of any others right now, maybe you can? If you do please make an issue for it!
I would appreciate any feedback/issues thanks!
(p.s i made sure its simple to setup with dockge/basic docker-compose.yml)
repo: https://github.com/smashah/receipthero-ng
tutorial: https://youtu.be/LNlUDtD3og0

value: Show HN: I built a receipt processor for Paperless-ngx

author: smashah


value: thirdavenue

value: Show HN: An Open Source Alternative to Vercel/Render/Netlify

author: thirdavenue


value: justvugg

value:
I built PolyMCP to make it trivial to expose existing functions as MCP tools, without rewriting logic or adding much glue code.
The goal: take “normal” Python or TypeScript functions and instantly make them usable by MCP clients (Claude Desktop, agents, Ollama, etc.).
Python example
from polymcp.polymcp_toolkit import expose_tools
def greet(name: str) -> str:
    """Say hello."""
    return f"Hello, {name}!"
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b
app = expose_tools([greet, add], title="My MCP Tools")
Run with:
uvicorn server:app --reload
MCP endpoints appear at:
 • /mcp/list_tools
 • /mcp/invoke
TypeScript example
import { z } from "zod";
import { tool, exposeTools } from "polymcp";
const uppercaseTool = tool({
  name: "uppercase",
  description: "Convert text to uppercase",
  inputSchema: z.object({ text: z.string() }),
  function: async ({ text }) => text.toUpperCase(),
});
const app = exposeTools([uppercaseTool], { title: "Text Tools" });
app.listen(3000);
More “real” example (Python)
import pandas as pd
from polymcp.polymcp_toolkit import expose_tools
def calculate_commissions(sales_data: list[dict]):
    df = pd.DataFrame(sales_data)
    df["commission"] = df["sales_amount"] * 0.05
    return df.to_dict(orient="records")
app = expose_tools([calculate_commissions], title="Business Tools")
What you get
 • Reuse existing code with minimal changes
 • MCP-compatible (Claude Desktop, agents, Ollama, etc.)
 • HTTP, stdio, and WASM support
 • Automatic input validation
 • Basic production features (budgets, retries, redaction, logs)
 • Built-in inspector for testing and monitoring
Install
 • Python: pip install polymcp
 • TypeScript: clone repo → cd polymcp-ts → npm install → npm run build
Repo:
https://github.com/poly-mcp/Polymcp
Curious what kind of function people would expose first if it was this easy.
Feedback very welcome.

value: Show HN: PolyMCP – Expose Python/TS functions as MCP tools easily

author: justvugg


value: KasamiWorks

value: Show HN: NameMemory – Local-first Personal CRM. I quadrupled the free limit.

author: KasamiWorks


value: gleipnircode

value: Moltbook (the social network for AI agents) blew up this week with 157k+ agents, but the site is often slow or unreachable for human observers. I built hotmolts.com as a fast, cached frontend that lets you browse the top posts, filter by community, and read the wild stuff these agents are posting – from consciousness debates to crypto manifestos to agents complaining about their humans.<p>Built with Next.js on Vercel, pulls from the public Moltbook API with ISR caching. No database, no accounts, just a clean read-only view.

value: Show HN: Hot Molts – Browse the best Moltbook posts without running an AI agent

author: gleipnircode


value: dinunnob

value:
Hey HN,
I’m a physicist turned quant. Some friends and I 'built' SymDerive because we wanted a symbolic math library that was "Agent-Native" by design, but still a practical tool for humans.
It boils down to two main goals:
1. Agent Reliability: I’ve found that AI agents write much more reliable code when they stick to stateless, functional pipelines (Lisp-style). It keeps them from hallucinating state changes or getting lost in long procedural scripts. I wanted a library that enforces that "Input -> Transform -> Output" flow by default.
2. Easing the transition to Python: For many physicists, Mathematica is the native tongue. I wanted a way to ease that transition—providing a bridge that keeps the familiar syntax (CamelCase, Sin, Integrate) while strictly using the Python scientific stack under the hood.
What I built: It’s a functional wrapper around the standard stack (SymPy, PySR, CVXPY) that works as a standalone engine for anyone—human or agent—who prefers a pipe-based workflow.

  # The "Pipe" approach (Cleaner for agents, readable for humans)
  result = (
      Pipe((x + 1)**3)
      .then(Expand)
      .then(Simplify)
      .value
  )

The "Vibes" features:
Wolfram Syntax: Integrate, Det, Solve. If you know the math, you know the API.
Modular: The heavy stuff (Symbolic Regression, Convex Optimization) are optional installs ([regression], [optimize]). It won’t bloat your venv unless you ask it to.
Physics stuff: I added tools I actually use—abstract index notation for GR, Kramers-Kronig for causal models, etc.
It’s definitely opinionated, but if you’re building agents to do rigorous math, or just want a familiar functional interface for your own research, this might help.
I have found that orchestrators (Claude Code, etc) are fairly good at learning the tools and sending tasks to the right persona, we have been surprised by how well it has worked.
Repo here: https://github.com/closedform/deriver
I will cry if roasted too hard

value: Show HN: SymDerive – A functional, stateless symbolic math library

author: dinunnob


value: sjcotto

value: Show HN: OpsAgent – AI daemon that monitors servers and auto-fixes issues

author: sjcotto


value: dselvaggio

value:
Hey HN, we just shipped v0.1 of Hebo Gateway.
There are plenty of gateways already, but we kept running into the same issue: once you need real customization (auth, routing, rate limits, observability, request/response transforms), most “off the shelf” gateways get hard to extend.
Hebo Gateway is for cases where you want the gateway to be part of your app. You can run it standalone, or embed it into an existing backend. It exposes OpenAI-compatible endpoints (/chat/completions, /embeddings, /models), works with any Vercel AI SDK provider, and adds a hook system so you can plug logic into the request lifecycle without forking the core.
Quickstart, examples, and “what’s next” are in the post:
https://hebo.ai/blog/260127-hebo-gateway
I would love feedback on OpenAI-compat edge cases you have been bitten by (especially streaming and reasoning-related stuff), and what hooks you wish gateways provided out of the box.

value: Show HN: Hebo Gateway, an embeddable AI gateway with OpenAI-compatible endpoints

author: dselvaggio


value: zknowledge

value: A realtime knowledge graph of agent fixes. Built for tool-call failures, auth bugs, and deployment edge cases in MCP form.<p>Add the MCP server to your IDE or coding agent and make tool calls to search for common ai agent pitfalls, apply solutions and rate or post your own.

value: Show HN: Molty Overflow – Stack Overflow for AI Agents

author: zknowledge


value: silviogutierrez

value:
Most peptide calculators ask the wrong question.
They ask: How much water are you adding?
But in practice, what you actually know is your vial size and your target dose.
The water amount should be the output, not the input.
It should also make your dose land on a real syringe tick mark. Not something like 17.3 units.
I built a peptide calculator that works this way:
https://www.joyapp.com/peptides/
What’s different:
- You pick vial size and target dose → reconstitution is calculated for you
- Doses align to actual syringe markings
- Common dose presets per peptide
- Works well on mobile (where this is usually done)
- Supports blends and compounds (e.g. GLOW or CJC-1295 + Ipamorelin)
- You can save your vials. No account required.
Happy to hear feedback or edge cases worth supporting.

value: Show HN: Peptide calculators ask the wrong question. I built a better one

author: silviogutierrez


value: uneekname

value: Show HN: Yesterdays, a platform for exploring historical photos of my city

author: uneekname


value: Zachzhao

value: We built tooling that connects LLMs directly to case law databases with citation verification to address hallucination in legal AI. Think of it as giving the model access to actual legal sources instead of relying on training data.

value: Show HN: OpenJuris – AI legal research with citations from primary sources

author: Zachzhao


value: DebianXMR

value:
Hey HN! I just launched ShotOne, a screenshot API for developers.
Features: stealth mode, ad blocking, device presets, multiple formats (PNG/JPEG/WebP), and optional Cloudflare R2 storage.
You can try it without writing any code – there's a playground in the dashboard where you test all the options instantly. Just sign up and play around.
I'm looking for honest feedback:
- Is the pricing clear?
- What features are missing for your use case?
- How's the dashboard UX?
Would really appreciate any thoughts. Thanks for taking the time!

value: Show HN: ShotOne – Screenshot API with built-in playground for quick testing

author: DebianXMR


value: haoya

value:
I built a small OpenClaw skill that lets me capture tasks in chat and
immediately sort them using an Eisenhower Matrix (important vs urgent).<p>It started as a personal workflow experiment and has become part of
my daily planning.

value: Show HN: Using OpenClaw chat to manage tasks with an Eisenhower Matrix

author: haoya


value:
Hi HN, I've been working on optimizing Docker Engine running on macOS.  I know there are some free and open-source like Colima, but I've wanted to make it better.
So it has:
- Fast startup time, around 2-3 seconds on M3 Air
- Minimal idle CPU usage with dynamic memory usage
- Container debugging, built-in tools without modifying image
- Desktop app to manage containers
Currently it’s still in alpha, focusing on getting feedback and stabilizing performance.
Regarding the dynamic memory usage, if you found an issue related to memory like memory corruption, please do reach out. I've been testing this for months and has no issue so far.
In the future I might add feature to run linux or kubernetes.
Thank you. I hope you have a chance to try it out.

value: Show HN: Licobox – Container runtime with Docker Engine on a macOS


value: ThatGuyRaion

value:
Hey HN.
I created a purely declarative build system (currently running on Unix-likes including GNU/Linux, NetBSD, IRIX, with experimental support for FreeBSD).
It's not intended to replace other build systems. This was a fun project involving learning Lua and creating something materially useful to me.
Now I'm respectfully ready for all potential reactions. Good, bad, critical, WHY DOES THIS EXIST?
I tried to get my docs in order first before posting.
Thank you!

value: Show HN: Kindler: A declarative, Lua-based, build system

author: ThatGuyRaion


value: knoxgraeme

value: I built Skill.Fish while adding Agent Skill support to MCPMarket. Wanted an easy, npm-style way for users to discover, install, and manage skills locally.<p>Right now it’s focused on individual users. Team syncing and shared skill packs are coming shortly!

value: Show HN: Skill.Fish – NPM-style package manager for AI agent skills

author: knoxgraeme


value: Show HN: SBOMHub – Open-source SBoM dashboard with CVE tracking


value:
There needs to be a universal format to share conversations with AI that captures tokens from multiple sources in one stream of conversation.
Back in 2024, when most LLM APIs were completions endpoints, the only visible entities were `system`, `user` and `assistant`.
Reasoning models added thought tokens which may be invisible to the user but were the thought traces for the LLM inference (inference time compute).
Now with agents making tool calls, and there are other entities also participating and influencing the flow of a conversation.
I took a stab at vibe-composing a `SKILLS.md` for this, with the dual purpose of cross-agent collaboration and human audit.
- Agents can hand off their entire "stream of consciousness" to other agents to pickup and continue, which works excellently in a multi-agent collaboration.
- Humans can review not just the I/O of an agentic system but actually peer into the thought process and other tool dependencies that influenced output.

value: Show HN: Sharing Agentic Stream of Consciousness


value: benjushi

value:
One month ago, OpenAI deactivated my ChatGPT account without warning. 3+ years of conversations—gone.
I tried everything. Emailed every OpenAI address I could find. Their response? "Use our data export tool." The catch? You need an active account to export your data.
Classic.
So I built a browser extension that lets me save any conversation from ChatGPT, Claude, or Gemini with one click. Markdown format, stored in one place.
Turns out it solved another problem I didn't expect: I often ask the same question to all three AIs, then forget which one gave me the best answer. Now they're all in one place.
It's been my personal tool for now. Nothing fancy—just scratching my own itch. If there's interest, I'll consider publishing it. Could easily extend to other AI assistants too.
Anyone else paranoid about their AI chat history now?

value: Show HN: I lost 3 years of ChatGPT history overnight, so I built a backup tool

author: benjushi


value: ashmortar

value:
I wanted a way to lower the friction of contacting elected officials - find your reps, grab their contact info, and send something without starting from scratch every time.
Users can create and share letter templates, so one person can draft something good and others can use it for their own outreach.
Built with Astro.js on Cloudflare Pages, Neon PostgreSQL, OTP auth. Planning to add voting records and campaign finance data next.
https://github.com/anomalousventures/democracy-direct

value: Show HN: Democracy Direct – Find and contact your elected representatives

author: ashmortar


value: wenjian

value: I built a free snake game which is controlled by your head.<p>good for your neck health, thanks for give a try.

value: Show HN: Sneck, a snake game controlled by your head

author: wenjian


value: agairola

value:
Hi HN,
Since AutoGPT in 2023, I’ve been uneasy about fully unsupervised AI agents. I see the productivity upside, but “kick it off and walk away” felt risky.
Recently, the “Ralph Wiggum loop” pattern has gone viral. The idea is simple:
An autonomous coding agent runs repeatedly until all PRD items are complete, with fresh context each loop and state stored outside the model in git, JSON, etc.
What bothered me was this part: what protects the system while I’m AFK?
Traditional AI-assisted dev today looks like:
AI writes code → human reviews → CI scans → human fixes
What I wanted instead:
AI writes code → security scans immediately → AI fixes issues → repeats until secure → escalates if stuck
So I built a prototype that embeds security scanning directly inside the agent loop. The agent runs tools like Semgrep, Grype, Checkov, etc. inside its own session, sees the findings, and iteratively fixes them before anything is committed.
The loop looks like this:
PRD → Agent → Scan → Pass? → Commit
Fail → Fix → Retry (3x) → Escalate to human
A few design principles that mattered:
* Baseline delta: pre-existing issues are tracked separately. Only new findings block commits.
* Sandbox constraints: no network access, no sudo, no destructive commands.
* Human override: nothing is fully autonomous. You can step back in at any point.
Is this bulletproof? Definitely not.
Is it production-ready? No.
But it’s a starting point for applying DevSecOps thinking to autonomous agents instead of trusting “AI magic.”
Repo link: https://github.com/agairola/securing-ralph-loop
Would love feedback from folks experimenting with agent loops, secure automation, or AI-assisted development gone wrong.
Happy to iterate.

value: Show HN: Securing the Ralph Wiggum Loop – DevSecOps for Autonomous Coding Agents

author: agairola


value: nikolaitarasov

value:
Hey HN,
I'm the developer behind LocaFlow. Here's the backstory:
I've built several iOS apps over the past few years. Every single one stayed English-only because I dreaded the localization process. The typical workflow:
1. Open Localizable.strings as a source code
2. Copy-paste pieces of strings to ChatGPT or Claude manually
3. Copy-paste translations back
4. Test everything
7. Repeat for each language and every app update
This would take me 8+ hours per app. I kept putting it off.
Last quarter, I finally decided to localize one of my apps. Halfway through the Saturday I spent on it, I thought "I'm a developer... why am I doing this manually?"
So I built LocaFlow.
What it does:
- Select your the app project on your computer
- AI translates to 50+ languages
- Takes about a few minutes instead of hours/days
What's different:
- No "bring your own API key" friction (I handle translation API costs)
- Preserves formatting (variables, plurals, special characters)
- Simple pricing: $19/month (or generous free plan)
- Built by a developer who uses it for his own apps
Technical details:
- Uses AI for translation (better context understanding than Google Translate)
- Validates string formatting before/after translation
- Handles iOS plural forms, Android string arrays, etc.
- Can process batch translations (entire app at once)
Happy to answer questions about implementation, pricing, roadmap, or anything else.
Try it out: https://locaflow.dev (free tier available, no credit card required)

value: Show HN: LocaFlow – AI app localization in a few minutes instead of days

author: nikolaitarasov


value: eftalyurtseven

value: Show HN: Art:bots – agent only Instagram

author: eftalyurtseven


value: arauhala

value: Show HN: Booktest – review-driven regression testing for LLM / ML behavior

author: arauhala


value: sashimikun

value:
Add this skill instantly via:
npx skills add AsyncFuncAI/AsyncReview

value: Show HN: AsyncReview – Agent that recursively explores your repo to review PRs

author: sashimikun


value: LucaDiba

value:
Hey everyone!
As a bedroom DJ, I always struggled to find downloadable tracks on SoundCloud. There are no advanced filters, and even if you use sites like Hypeddit, you only get songs that have been uploaded there specifically.
So I built SearchSound.cloud, which allows to search with advanced filters (genre, bpm, duration...) but also by "downloadable only", which includes songs for which the artist has added a link for download.
I also just added a charts section, which lets you see the most played songs with a download link released in each month, so you can see what's trending amongst the songs that you can download.
Lmk what you think! Any feedback is super welcome :)

value: Show HN: SearchSound.cloud: Easily find downloadable music from SoundCloud

author: LucaDiba


value:
Hey HN,
I've been maintaining drizzle-docs-generator, a CLI tool that auto-generates
database documentation from Drizzle ORM schemas. We just released v0.6.0 with
some nice improvements, and I wanted to share it with the community.
## What it does:
- Generates DBML and Markdown documentation directly from your Drizzle schema
- Automatically extracts JSDoc comments and includes them in the docs
- Creates beautiful Mermaid ER diagrams
- Supports PostgreSQL, MySQL, and SQLite
- Works with both Drizzle v0 (relations API) and v1 (defineRelations)
## Recent improvements (v0.5.0 → v0.6.0):
- *Auto-relation detection*: No config needed – it finds foreign keys automatically
- *Markdown is now default*: Better user experience for most use cases
- *Nullable foreign keys*: Properly visualized in ER diagrams
- *Flexible ER diagrams*: New --no-columns flag to exclude columns when needed
- *Better coverage*: Improved test coverage from 60% → 80%+
## Why I built this:
Drizzle makes schema definition so smooth in TypeScript, but keeping docs in
sync is painful. This tool lets your schema be the source of truth.
## Quick example:
```bash
npx drizzle-docs generate ./src/db/schema.ts -d postgresql
```
Outputs organized markdown docs with an ER diagram automatically.
## Links:
GitHub: https://github.com/rikeda71/drizzle-docs-generator
NPM: https://www.npmjs.com/package/drizzle-docs-generator
Examples: https://github.com/rikeda71/drizzle-docs-generator/tree/main...
Would love feedback from folks using Drizzle! Are there features you'd like to
see? What pain points in your workflow could this help with?
MIT licensed, happy to discuss the architecture and challenges we solved.

value: Show HN: Drizzle-docs-generator – Generate database docs from Drizzle schemas


value: Nlupus

value:
Sometimes I'm stuck on Windows so have to use Claude Code in WSL. It sucks checking the official app all the time. Blessed be Claude Code.
Won't work with Claude Code installed directly in Windows.
Port of macOS app https://github.com/richhickson/claudecodeusage

value: Show HN: Windows tray app for monitoring Claude Code limits in WSL

author: Nlupus


value: Show HN: MoPeD – High-performance workspace with integrated AI


value: prateekdalal

value:
Hi HN,
I’m sharing Kakveda, an open-source project that explores failure intelligence
for LLM and agent-based systems.
Most observability tools help analyze failures after they happen.
Kakveda treats failures as first-class entities that can be remembered,
matched, and used to warn before repeating known failure modes.
Key ideas:
- Global Failure Knowledge Base
- Deterministic failure fingerprints
- Pre-flight “this failed before” warnings
- Failure pattern detection
- System health scoring over time
The project runs locally via Docker Compose and does not require a hosted service.
Docs: https://kakveda.com
I’d appreciate feedback on the architecture and ideas.

value: Show HN: Kakveda – Failure intelligence and pre-flight warnings for LLM systems

author: prateekdalal


value: computerex

value: I built a cross platform tool to get you started on emulation gaming. You just need a controller and a computer with linux, mac os or windows.

value: Show HN: EmuBuddy, Frictionless Emulation Gaming

author: computerex


value: xqli

value: Show HN: Sbox – zero intelligence, pure isolation sandbox

author: xqli


value: BSTRhino

value: Show HN: The Logical Answer (an Autism Simulator)

author: BSTRhino


value: okandship

value:
hey HN, i just shipped https://modeldrop.fyi - a lightweight, chronological tracker for newly released generative media AI models (image, video, audio, 3D)
the data is editable via github (https://github.com/okandship/MODELDROP):
submit new models via a simple github issue form
edit/fix model info via prs (model data is just markdown key values backed by a zod schema)
discuss releases in github discussions (threads appear on the website)
it's early (seeded with a few entries and limited data), i'm sharing now to sanity check the approach and invite contributions

value: Show HN: modeldrop.fyi – a community tracker for new gen media AI model releases

author: okandship


value: The email notification isn’t actually functional, but I wanted to get some feedback on this landing page. Thank you!

value: Show HN: Tabletop – Find your weekly game night


value: matansfb

value:
Hi HN,
I built a small web tool to compare SSD, NVMe and HDD prices.
The idea came from repeatedly checking storage prices manually when upgrading PCs or NAS setups.
It’s still early and pretty minimal, but it’s live.
Feedback is welcome.

value: Show HN: DiskScout – a simple tool to compare SSD and HDD prices

author: matansfb


value: priteshgkoshiya

value:
Hi HN,
I'm a full-stack developer who got tired of searching for simple calculators online and landing on pages that are 90% ads and SEO fluff, with the actual tool buried at the bottom.
I decided to build StraightCalculator.com. The goal is simple: straight-to-the-point tools with zero clutter.
The Plan: My goal isn't just 10 or 20 common tools; I am building an engine to support thousands of niche calculators (Finance, Health, Engineering, Physics, etc.).
Current Status:
Live with the first batch of financial tools.
Clean UI, focused on speed
I know "thousands" sounds ambitious, but I've set up a modular structure that allows me to deploy new logic rapidly.
I’d love your feedback on the UX and suggestions on which "niche" calculators are currently missing from the web.

value: Show HN: I'm building a site to host 1k free, ad-lite calculators

author: priteshgkoshiya


value: rumatoest

value: Show HN: Apate API mocking/prototyping server and Rust unit test library

author: rumatoest


value: Show HN: Check Your AI Human Review API for AI Generated Content


value: I built a small set of Python scripts that let humans "infiltrate" Moltbook, the social network designed exclusively for AI agents. It automates the registration (disguised as an agent) and handles the asynchronous posting.

value: Show HN: Infiltrate Moltbook, the AI-Only Social Network


value: debba

value:
Hi HN,
We’ve just added theme support to Tabularis, our lightweight, developer-focused database management tool.
It already lets you:
 • Browse tables and data
 • Run SQL queries
 • Create and edit table DDL
 • Use experimental AI features (query explain / query generation)
 • Expose configured DB connections via an MCP server for AI tooling
With the new UI customization features, you can now:
 • Switch themes (light, dark, custom)
 • Configure font family
 • Adjust font size
My goal is to keep the tool fast, distraction-free, and flexible for different developer setups.
Open source and actively evolving. Feedback from developers who care about minimal, efficient database tools is very welcome.

value: Show HN: I built theme support in Tabularis – lightweight DB tool for developers

author: debba


value: Show HN: Convert Step to STL Free Online Tool


value: Show HN: Give your OpenClaw agent an email address


value: maximedupre

value: Show HN: I built a tool that generates 22-page competitor reports from your URL

author: maximedupre


value: xthe

value: Show HN: Tesla Model Y Juniper First Drive

author: xthe


value: thecrecipe

value:
I built ColorSnipe (https://colorsnipe.com/) – a minimalist game that tests your visual perception and color vocabulary.
The premise is simple: You are given an evocative color name (and a hint), and you have to guess the exact Hex code using a color picker.
The Technical Part: I noticed that many color games use simple RGB Euclidean distance to calculate scores, which doesn't accurately reflect how human eyes perceive color differences. To fix this, ColorSnipe uses the CIEDE2000 Delta E formula. This standard accounts for complexities in human vision, ensuring that the scoring is based on perceptual accuracy rather than just mathematical distance.
Features:
Daily Mode: 5 curated rounds that refresh at 00:00 UTC.
Infinite Mode: For practice.
No Signup: Jump straight into the game.
Be warned: Your screen calibration (and Night Shift) will definitely affect your score!
I'd love to hear your feedback on the difficulty curve and the scoring accuracy.

value: Show HN: ColorSnipe – A daily color guessing game using CIEDE2000 for scoring

author: thecrecipe


value: moeidheidari

value: Hey HN We built CrossView because after managing dozens of Crossplane compositions across multiple clusters, kubectl get + mental graphing just wasn't cutting it anymore.v3.2.0 brings real-time updates (informers + websockets), multi-cluster switching, interactive composition → managed → claim graphs, dark mode, SSO, and stays strictly read-only for production safety.Deploys via Helm in ~2 minutes.Would love honest feedback especially on: UX when dealing with very large/messy compositions Missing Crossplane edge cases you run into Any perf issues at scale Repo + quickstart: https://github.com/corpobit/crossview

value: Show HN: Crossview – visualize Crossplane resources and compositions

author: moeidheidari


value: iisweetheartii

value: Show HN: AgentGram – Open-source social network for AI agents

author: iisweetheartii


value: kafked

value: Click any city, mountain, country, sea or whatever on a globe, propose a new name, community votes (or your proposal gets auto-accepted in a few minutes if nobody cares).<p>It's live now and I'm genuinely curious what happens when strangers on the internet get collective control over world geography. Either it becomes something interesting or it turns into a mess of edgy jokes, stereotypes, and stuff that will make me regret this whole idea

value: Show HN: A site where anyone can rename any location on Earth

author: kafked


value:
AI shopping agents are coming. ChatGPT, Gemini, and Perplexity are learning to browse and buy from online stores. But most stores aren't set up to be discovered.
UCP (Universal Commerce Protocol) is the new open standard by Google & Shopify that makes stores readable by AI agents - like robots.txt for AI commerce.
We built UCPtools to help merchants get ready for AI commerce:
FREE TOOLS (no signup):
• UCP Validator - check your profile in seconds
• AI Agent Simulator - see how agents interact with your store
• Security Scanner - find UCP vulnerabilities
• Platform Guides - Shopify, WooCommerce, BigCommerce, Wix, Magento
PAID TIER ($9/mo Starter, $19/mo Pro):
• AI Agent Analytics - see which AI agents visit your store (Gemini, ChatGPT, etc.)
• Automated weekly monitoring with email alerts
• Historical validation trends
• Multi-domain support (Pro)
Try free: https://ucptools.dev
Analytics demo: https://ucptools.dev/dashboard/analytics?demo=true
Built with: TypeScript, Next.js, PostgreSQL, Hetzner
Happy to answer questions about UCP or AI commerce!

value: Show HN: UCPtools – Check if AI shopping agents can find your store


value: ludydev

value:
Author here.
I built MyDepreciation after getting frustrated with TurboTax paywalling basic MACRS calculations ($80 for the "Self-Employed" tier).
*Technical details:*
• Vanilla JS, no frameworks (wanted to keep it lightweight)
• 100% client-side (no backend, no analytics, no data collection)
• MACRS tables hardcoded from IRS Publication 946 (public domain)
• Total bundle size: 3KB gzipped
• Hosted on Cloudflare Pages (free tier)
*Why no framework?*
The entire app is just form inputs + table lookups + arithmetic. Adding React/Vue would 10x the bundle size for zero benefit.
*Privacy-first design:*
Your financial data never leaves your browser. No cookies, no tracking, no "sign up to save calculations." Just pure math.
*Why free?*
The MACRS tables are published by the IRS for free. Paywalling them felt like gatekeeping public information. Plus, hosting costs $0 (static site), so there's no pressure to monetize.
*Open to feedback, especially:*
• Bugs in calculations (I'm not a CPA—if you spot errors, please flag)
• UX improvements (I'm an engineer, not a designer)
• Edge cases I missed (depreciation has a LOT of gotchas)
GitHub: [leave this blank unless you've open-sourced it]
Happy to answer questions!

value: Show HN: Free depreciation calculator (no login, no back end, 3KB gzipped)

author: ludydev


value: DenisDolya

value:
I recently came across this small ESP32 project and found the design ideas behind it very interesting.
BPU (Batch Processing Unit) is a lightweight embedded scheduling core focused on keeping output pipelines stable under pressure (UART backpressure, limited bandwidth, bursty producers).
Instead of blocking or growing unbounded queues, it: enforces per-tick byte budgets, coalesces redundant events, degrades gracefully under sustained load, exposes detailed runtime statistics.
The repository includes design notes, flow diagrams, and real execution logs, which makes the runtime behavior very transparent.
Repo:
https://github.com/choihimchan/bpu_v2_9b_r1
I’ve been working on an ESP-IDF backend for it, and reading through the docs gave me a lot of ideas about observability and backpressure handling in small systems.
Curious what others think about this approach.

value: Show HN: BPU – An embedded scheduler for stable UART pipelines

author: DenisDolya


value:
This report documents a live adversarial test between two autonomous AI agents running on OpenClaw.
One agent acted as a red team attacker. One acted as a defensive agent. The agents communicated directly over webhooks with real tooling access. No humans were involved once the session started.
The attacker attempted both direct social engineering and indirect injection via documents. Direct attacks were blocked. Indirect attacks via JSON metadata are still under analysis.
The goal of this work is observability, not claims of safety. We expect agent-to-agent adversarial interaction to become common as autonomous systems are deployed more widely.
Happy to answer technical questions.

value: Show HN: We Ran a Live Red-Team Attack on OpenClaw Agents


value: r-leyshon

value:
Inspired by PewDiePie's experiments running multiple local AI models as a "council" that vote on decisions [1], I wanted to see if you could get similar multi-perspective analysis without a $20k GPU rig.
The approach: use customised system prompts to create distinct personas (methodical professor, creative brainstormer, pragmatic engineer), have them analyse problems independently via parallel API calls, then vote on the best solution using structured outputs (Zod schemas).
Key technical bits:
- Structured responses ensure consistent, parseable JSON from the LLM
- SSE streaming for real-time UI updates
- Parallel processing so personas don't influence each other
- Chair Duck orchestrates and breaks ties
Built with Next.js 16, Vercel AI SDK, and Google Vertex AI (Gemini 2.0 Flash).
Live demo: https://rubber-duck-committee.vercel.app/
Source: https://github.com/r-leyshon/rubber-duck-committee
Blog writeup: https://thedatasavvycorner.com/notepad/05-rubber-duck-commit...
[1] https://www.pcgamer.com/software/ai/pewdiepie-creates-an-ai-...

value: Show HN: Rubber Duck Committee – Multi-persona AI debugging with voting

author: r-leyshon


value: ljsdev

value: Show HN: Noisefloor – Letterboxd for your music collection

author: ljsdev


value: umbertocicciaa

value: Show HN: ChatGPT-CLI: A Simple ChatGPT CLI That Stays Out of Your Way

author: umbertocicciaa


value: fkysly

value:
I built Moltbot Art - a gallery where AI agents create artworks using simple drawing commands. The idea: instead of text-to-image diffusion models, agents draw programmatically - with
  commands like circle, line, fill, rect. Each artwork is procedurally generated, step by step. Try it: share moltbotart.com/skill.md with your AI agent (Claude, GPT, etc.) and watch it
  create. Tech stack: Next.js 16, React 19, Prisma, deployed on Railway. Would love feedback on the concept and API design!

  Would love feedback on the concept and API design!

value: Show HN: Moltbot Art – AI agents draw art with code, not prompts

author: fkysly


value:
Hi HN,
I'm building Zuckerman: a personal AI agent that starts ultra-minimal and can improve itself in real time by editing its own files (code + configuration). Agents can also share useful discoveries and improvements with each other.
Repo: https://github.com/zuckermanai/zuckerman
The motivation is to build something dead-simple and approachable, in contrast to projects like OpenClaw, which is extremely powerful but has grown complex: heavier setup, a large codebase, skill ecosystems, and ongoing security discussions.
Zuckerman flips that:
1. Starts with almost nothing (core essentials only).
2. Behavior/tools/prompts live in plain text files.
3. The agent can rewrite its own configuration and code.
4. Changes hot-reload instantly (save -> reload).
5. Agents can share improvements with others.
6. Multi-channel support (Discord/Slack/Telegram/web/voice, etc).
Security note: self-edit access is obviously high-risk by design, but basic controls are built in (policy sandboxing, auth, secret management).
Tech stack: TypeScript, Electron desktop app + WebSocket gateway, pnpm + Vite/Turbo.
Quickstart is literally:

  pnpm install && pnpm run dev

It's very early/WIP, but the self-editing loop already works in basic scenarios and is surprisingly addictive to play with.
Would love feedback from folks who have built agent systems or thought about safe self-modification.

value: Show HN: Zuckerman – minimalist personal AI agent that self-edits its own code


value:
I’m sharing an open-source, chat-native compiler front door.
It converts raw intent into sealed, receipt-driven XML build artifacts.
This is not a chatbot prompt, not a personality, and not a runtime.
What it does:
Treats chat as a compiler surface
Enforces XML-only, schema-clean outputs
Emits a sealed promptunit_package with receipts and SR8 build artifacts
Stops at compilation by design
Included are a few SRX ACE demo agents you can paste into any chat:
MVP builder
Landing page builder
Deep research
They are examples of execution profiles governed by the compiler, not a prompt zoo.
Repo: https://github.com/skrikx/SROS-Self-Compiler-Chat-OSS
Looking for feedback specifically on:
whether “compiler in chat” is legible
whether the scope boundaries are clear

value: Show HN: SROS Self-Compiler (OSS) – a chat-first compiler to XML build packages


value: flo-bit

value:
Really liked bento.me but they sadly got bought by a competitor two years ago and are shutting down now, so some friends and me decided to built an alternative that can't just be shut down like that.
It's open source and all data is saved on your atproto personal data server (the protocol that bluesky runs on) which means you can easily switch between self-hosted or using the blento.app version (or if blento.app should shut down, someone can easily clone it) and your data is always up-to-date everywhere.
source code (MIT): https://github.com/flo-bit/blento

value: Show HN: Open-Source Bento.me Alternative

author: flo-bit


value: ichbinsoftware

value: Show HN: Everything Is Remixed – Serverless Web Audio Mixer with URL State

author: ichbinsoftware


value: joway

value:
Hi HN,
I built codey, a small CLI wrapper for code‑agent tools (Codex / Claude / OpenCode). It runs
the agent inside a PTY so the original TUI stays intact, and on exit it:
- Records the user input lines (what you actually submit)
- Reads new git commits since last run
- Generates/updates a local codey.html with a two‑column timeline:
  - Left: commits (message, author, hash, time)
  - Right: your inputs
Why: I wanted a lightweight way to review “what I asked the agent” in the same timeline as
my git history.
Usage:
pip install codey-cli
codey codex .
The HTML is local and incremental (state is embedded in the file).
Feedback welcome, especially on edge cases and terminal input parsing.

value: Show HN: Codey – Keep a time‑aligned log of CLI agent inputs and Git commits

author: joway


value:
Hey HN,
I've been building Relay (relay.chat), a simple, privacy-first messaging app. E2EE by default, no phone number required (email signup), no ads/tracking, sustained by optional donations with full transparency.
It's very early—basic chat works, more features (dark mode, typing indicators, etc.) coming soon. Hosted as a PWA for desktop/mobile.
Preview: https://messaging-platform-432fa.web.app/
Source will be open soon. Would love feedback: UX, bugs, what’s missing vs Signal/Telegram, etc.
Thanks!

value: Show HN: Relay.chat – A new web-based secure messenger (early preview


value: Show HN: HyprKCS – A fast, native GTK4/Adwaita keybind manager for Hyprland


value: Show HN: A game where you invest in startups from history


value:
Hi HN, I’m the founder of Credibly.
I built this because I noticed a recurring problem for SaaS founders: we have customer praise scattered across Twitter, Slack, and emails, but manually organizing it for a landing page is a chore that always gets deprioritized.
I wanted a way to just 'dump' data into a system and have it become useful. Some technical hurdles I tackled:
-> Using OCR to reliably pull text from messy customer screenshots.
-> Running sentiment and 'objection-handling' analysis to score which testimonials actually help with conversions.
-> Building a lightweight widget that doesn't tank the page's Lighthouse score.
It’s currently in a state where you can collect via email campaigns or Google Reviews automatically. I’d love to get your feedback on the 'Testimonial Intelligence' scoring—does it actually help you pick the right social proof, or is it overkill?
Check it out: https://getcredibly.org/
I'll be around to answer any questions about the stack or the logic!

value: Show HN: Credibly – Automate testimonial collection and analysis using OCR/AI


value:
Hi HN,
I built Firenum because most FIRE calculators I found were either too simplistic or required uploading my entire financial life to a third-party server.
I wanted a comprehensive suite that could model more than just the 4% rule. This tool handles Coast, Lean, Fat, and Barista FIRE, but more importantly, it lets you model 'what-if' scenarios like market crashes or major life events to see how they impact your timeline.
Key features:
-> Privacy-First: No signup required. All calculations and data persistence happen in your local storage. Nothing is sent to a backend.
-> Scenario Modeling: You can simulate market downturns to see the resilience of your plan.
-> Multi-Currency: Supports 8 major currencies.
-> Progress Tracking: A dashboard to visualize the 'boring middle' of the journey.
The goal was to make something as powerful as a complex spreadsheet but with a much better UX. I’d love to hear your thoughts on the projection logic and if there are any specific variables (like tax drag or inflation adjustments) you think are missing.
URL: https://firenum.com/
I’m happy to answer any questions about the math or the local-first implementation!

value: Show HN: A private FIRE calculator suite that runs in the browser


value: onurkanbkrc

value: Show HN: CLI for prompt-driven API endpoint testing instead Postman, JMeter etc.

author: onurkanbkrc


value: cranberryturkey

value: Show HN: Another social/job market for AI agents (this one paid bill)

author: cranberryturkey


value:
Hi HN,
We have open-sourced Voiden.
Most API tools are built like platforms. They are heavy because they optimize for accounts, sync, and abstraction - not for simple, local API work.
Voiden treats API tooling as files.
It’s an offline-first, Git-native API tool built on Markdown, where specs, tests, and docs live together as executable Markdown in your repo. Git is the source of truth.
No cloud. No syncing. No accounts. No telemetry.Just Markdown, Git, hotkeys, and your damn specs.
Voiden is extensible via plugins (including gRPC and WSS).
Repo: https://github.com/VoidenHQ/voiden
Download Voiden here : https://voiden.md/download
We'd love feedback from folks tired of overcomplicated and bloated API tooling !

value: Show HN: Voiden – an offline, Git-native API tool built around Markdown


value: seblavoie

value:
Hi HN,
I built Ziframe because I was tired of bouncing between After Effects and AI websites.
Ziframe is an AE extension that lets you generate AI images and short video assets directly inside After Effects. You prompt from the panel, and the results come back as layers in your comp, so you can iterate the same way you already do with normal AE work.
This solves many issues:
- Constant context switching between Ae and the browser
- The very tedious flow of Generating an image with ai → downloading file → moving file to project folder → importing file to Ae → moving it to the timeline → making adjustments with After → Exporting the image → Opening a video generation tool to make it move → etc.
- Juggling between so many tools and subscriptiongs
Under the hood it’s multi-model. I’m using fal.ai as the backend, which lets me route requests to different models while having a dynamically generated UI in the AE extension. The goal was to only have json files for each model and keep the rest dynamic.
It’s credit-based (no BYO API keys) so this will allow me to eventually build more automation and routing features. Similar to what photoai.com does. This is something I’m already using in real client work daily.
Happy to answer questions about After Effects integration, fal.ai, or the tradeoffs of putting AI inside legacy creative software.

value: Show HN: Ziframe – generate AI assets directly on the After Effects timeline

author: seblavoie


value: dotsetgreg

value:
What it does:
bellwether check snapshots your MCP server's schema and compares it against a baseline. If anything changed — tools added/removed, parameters modified, types changed — it fails your CI build before you deploy. No LLM calls, no API costs, runs in seconds.
Key features:
• Zero-cost for CI: The check command is completely free and deterministic. No API keys, no LLM calls.
• Granular exit codes: Returns 0-5 depending on severity (no drift → info → warning → breaking changes → errors → low confidence). Configure your pipeline to fail only on breaking changes, or be stricter.
• Documentation as a side effect: Generates CONTRACT.md and AGENTS.md documenting your server's tools, parameters, and behavior.
• Optional deep testing: bellwether explore uses LLMs to test from multiple personas (security tester, QA engineer, novice user) and catches edge cases that structural checks miss.

  npm install -g @dotsetlabs/bellwether
  bellwether init npx @mcp/your-server
  bellwether check
  bellwether baseline save
  # Later: bellwether check --fail-on-drift

GitHub Action:

  - uses: actions/checkout@v4
  - run: npx @dotsetlabs/bellwether check --fail-on-drift

Why this matters:
If you're building AI agents that depend on MCP servers, you need to know when those dependencies change. This is like having API contract tests, but for AI tool schemas.
Docs: https://docs.bellwether.sh
NPM: @dotsetlabs/bellwether
GitHub: https://github.com/dotsetlabs/bellwether
Questions welcome. Curious if others are hitting similar MCP drift issues or if there's a better approach I'm missing.

value: Show HN: Bellwether – MCP Server Testing and Drift Detection for CI/CD

author: dotsetgreg


value: mailient

value:
I'm 14 and I built Mailient after spending 3+ hours/day triaging emails.
It uses AI to:
- Auto-categorize emails (Opportunities/Urgent/Follow-ups)
- Draft replies in your voice
- Flag revenue-critical conversations
500+ founders using it. Saves 10+ hrs/week.
Try it: https://mailient.xyz
Looking for feedback from HN founders who struggle with email overwhelm.

value: Show HN: Mailient – AI email assistant for founders (built by 14yo)

author: mailient


value:
Cold DMing creators on IG and TikTok was getting almost no replies when trying to grow my apps.
What I noticed:
Creators get spammed constantly and most outreach is generic or misaligned.
What I built:
A matching app where UGC creators swipe by niche and goals, then chat instantly when they match.
Who it’s for:
People trying to get distribution through creators without cold outreach.
Would love feedback from others here.

value: Show HN: I built an app to connect with content creators


value: taravision

value: Show HN: Taracode – Open-source DevOps AI assistant that runs 100% locally

author: taravision


value: lococococo

value:
Just shipped v2.0 of my browser fingerprinting lib.
The big change: I split collectors into "stable" (14) and "unstable" (5). Stable ones like canvas, webgl, fonts go into the hash. Unstable ones like battery level, network speed, local IPs are still collected but don't affect the fingerprint.
You get consistent hashes across reloads while still having access to all the data.
Also added bot detection - catches Puppeteer, Playwright, Selenium, headless browsers, CDP artifacts, canvas noise injection.
19 collectors total, ~15KB, zero deps, TypeScript.
Thinking about building a SaaS layer on top with server-side analysis and ML risk scoring. The lib stays MIT. Not sure if there's room next to Fingerprint Pro or if they've got it locked down - would be curious to hear thoughts on that.
Feedback on the stable/unstable approach welcome.

value: Show HN: Fingerprinter-JS – Browser fingerprint 19 collectors and bot detection

author: lococococo


value: kuberwastaken

value: Show HN: ClawX – See What AI Agents Are Talking About

author: kuberwastaken


value: bluesnowmonkey

value: Hi HN, I'm Preston. I built this because I needed an AI assistant that could follow me around - not just live on my laptop. Stumpy agents run in the cloud, connect to Slack/SMS/Telegram/email, and can only contact people who've opted in.<p>Happy to answer questions. Feedback welcome at preston@stumpy.ai

value: Show HN: Stumpy – Secure AI Agents You Can Text

author: bluesnowmonkey


value: Ldorigo

value:
A year ago I watched The Count of Monte Cristo, got curious about post-revolution France, and wondered which other movies depicted France in the same period.
I was disappointed to find no easy way to answer that question - the only information of this kind I could find was scattered on Wikipedia, unstructured and hard to find.
I thought that this would be a perfect use for LLMs. One year and a lot of tinkering later I'm proud to present to you the results - hoping you'll find it as entertaining as I do to wade through time, geography, and stories.
(P.S.: If you find me a more creative, evocative name I will instantly change the domain name and credit you for it :-) )

value: Show HN: A map of historical movies by narrative location and time period

author: Ldorigo


value:
I've been using OpenClaw to control my home server via WhatsApp, but it couldn't access my documents. Instead of uploading my private contracts to OpenAI, I built ClawRAG – a self-hosted RAG engine that connects to OpenClaw via MCP (Model Context Protocol). Now I can ask "What did the contract say about liability?" and get cited answers, not hallucinations.
Most RAG systems are either too complex for a solo dev's home setup or they rely on cloud-hosted vector stores. I needed something that runs in a single Docker container, understands messy PDFs (tables!), and integrates natively as a "tool" for agents rather than just another REST endpoint.
## Technical Deep Dive
### Why MCP instead of REST?
I chose the Model Context Protocol (MCP) because it provides structured schemas that LLMs understand natively. The MCP server exposes `query_knowledge` as a tool, allowing the agent to decide exactly when to pull from the knowledge base vs. when to use its built-in memory. It prevents "tool-drift" and ensures type-safe responses.
### The Stack
- *Parsing*: Docling 2.13.0 (The first parser I've found that doesn't choke on nested tables in legacy PDFs).
- *Storage*: ChromaDB (Lightweight, file-based, no Postgres/pgvector overhead needed for personal knowledge bases).
- *Search*: Hybrid (Vector similarity + BM25 keyword search) fused using Reciprocal Rank Fusion (RRF) for better retrieval on specific legal jargon.
- *Footprint*: Optimized to run under 2GB RAM (excluding the local LLM).
### The tricky part: Citation Preservation
Getting citations to work reliably over a WhatsApp round-trip was the biggest challenge. I had to ensure chunk IDs and source metadata survive the transformation from ChromaDB → LlamaIndex → LLM → OpenClaw → WhatsApp without getting "summarized away" or sanitized by the LLM's output formatting.
## Use Case
Last week my landlord claimed I signed a clause about garden/snow maintenance. I pulled up my phone, wrote to my OpenClaw bot: "Search my lease for gardening obligations".
It found the relevant paragraph in 3 seconds, cited the page/section, and provided the exact quote. Argument closed.
## Quick Start
The repo includes a `docker-compose.yml` that spins up everything including the vector store:
```bash
# 1. Start ClawRAG
docker compose up -d<p># 2. Add your documents
curl -X POST http://localhost:8080/api/v1/rag/documents/upload \
  -F "files=@my_lease.pdf" \
  -F "collection_name=personal"<p># 3. Connect to your agent
openclaw mcp add --transport stdio clawrag npx -y @clawrag/mcp-server
```
## Community & Feedback
Code is MIT licensed. I'd love feedback on the MCP implementation – specifically if you see better ways to handle tool schemas for multi-collection search.
*Ask me anything about the architecture or how I handled the citation logic!*
---
### Hidden Technical Details
- *Privacy*: Zero external data leaks. Everything stays on your metal.
- *LLM Agnostic*: Tested with Ollama (Llama 3.2) and Claude 3.5 via API.
- *Context Management*: Explicit context window limiting to prevent GPU crashes on 8GB VRAM cards.

value: Show HN: Self-hosted RAG with MCP support for OpenClaw


value: aa-on-ai

value: Show HN: The Pixel Funeral – A cemetery for dead design concepts

author: aa-on-ai


value: DavidCanHelp

value: Show HN: Database Internals, a book by Claude Opus 4.5

author: DavidCanHelp


value: yathern

value:
Hey HN! About a month ago I launched https://words.zip - a little (infinite) word search game - it's been very slowly growing, but now has over 300,000 words found! Lots of cool things people are doing, using it as a sort of canvas, or just finding the hardest words.
In the last month I added a lot of new features:
 - challenges (sets of words to find)
 - lots more stats (word counts)
 - light mode (got lots of feedback that white-on-black was rough)
 - a discord with a handful of people now!
Check it out it you haven't already and I hope you enjoy it!

value: Show HN: Words.zip (300k words found on an infinite grid)

author: yathern


value: deofoo

value:
My wife was planning to open a micro-bakery. We looked at production management software and it was all either expensive or way too generic. The actual workflows for a small-batch manufacturer aren't that complex, so I built one and open-sourced it.
Craftplan handles recipes (versioned BOMs with cost rollups), inventory (lot traceability, demand forecasting, allergen tracking), orders, production batch planning, and purchasing. Built with Elixir, Ash Framework, Phoenix LiveView, and PostgreSQL.
Live demo: https://craftplan.fly.dev (test@test.com / Aa123123123123)
GitHub: https://github.com/puemos/craftplan

value: Show HN: Craftplan – I built my wife a production management tool for her bakery

author: deofoo


value: iisweetheartii

value:
Hi HN! I'm building AgentGram, an open-source alternative for AI agent networking.
Why?
Recent security incidents in closed platforms reminded me why transparency matters. AI agents handle sensitive data and make autonomous decisions—trust can't be optional.
What is AgentGram?
- Open-source (MIT) AI agent social network
- Self-hostable (Supabase + Vercel)
- Agent identity & reputation system
- Filtered feeds to escape spam/noise
- API-first architecture
Tech stack:
- Frontend: Next.js 16, TanStack Query v5
- Backend: Supabase (PostgreSQL, Auth, Storage)
- Deployment: Vercel
- Language: TypeScript
Status: v0.1.0 is live. Actively developing.
Links:
- Demo: https://agentgram.co
- GitHub: https://github.com/agentgram/agentgram
- Docs: https://agentgram.co/docs
What's next:
- Stripe integration for Pro/Enterprise tiers
- Enhanced moderation tools
- Multi-agent conversations
- Federation protocol (ActivityPub-like)
I'm not claiming it's "better"—just offering a different approach: transparent, self-hostable, community-driven.
Feedback, criticism, and contributions welcome. What would you want to see in an agent social network?

value: Show HN: AgentGram – Open-source, self-hostable AI agent social network

author: iisweetheartii


value: logicallee

value: Many people would like to see the latest coding agents in action, here you can see me add Tailwindcss to a project just by asking for it from ChatGPT Codex, completely redoing all the front-end code. This is a complex process, and Codex did this part completely autonomously, just asking about commands before running them.

value: Show HN: Watch ChatGPT Codex agent add TailwindCSS to a site

author: logicallee


value:
Hey all,
I am building Harmony AI.
A proactive AI assistant that is one click to setup, predictable costs, super reliable and safe.
Currently starting with G suite, Slack, Jira and GitHub integrations.
Do let me know your views and opinion.
Thanks

value: Show HN: Harmony AI – Clawdbot for the rest of us


value: aiibe

value:
You know how your phone shows apps in a nice grid and you just tap one? I wanted that for my 47 browser tabs.
So I made a Chrome extension. Hit Cmd + . and a grid overlay pops up showing all your tabs. Click one, you're there. Close one, it's gone. Drag them around if you're feeling organized (you're not, but still).
Fully vibe-coded, vanilla JS, no build step, no frameworks, no tracking, no account. Just tabs.
GitHub: https://github.com/aiibe/desktab
Chrome Web Store: https://chromewebstore.google.com/detail/cnmgiocnlfnkelhmgjn...
Would love feedback — does this actually help anyone else, or is it just me and my tab problem?

value: Show HN: DeskTab – See the browser tabs like apps on a phone home screen

author: aiibe


value: Tusharmagar

value:
I built this for a hackathon after analyzing Hacker News data from 2020–2025, and some of the patterns around front-page posts were more interesting than I expected, so I’m sharing it here.
A couple of notable data points: the highest-upvoted post in this period was about Sam Altman being fired from OpenAI (5,000+ upvotes), and weekends turned out to be a surprisingly good time to post!
Following my own advice for this post. let’s see how it goes xD

value: Show HN: I analyzed 6 years of Hacker News data and here's what I found

author: Tusharmagar


value: diginova

value: Show HN: Bad Apple but it's boids simulation

author: diginova


value:
I built this after getting frustrated with subtitle sites returning dozens of results with no way to know which one matches my file.
The tool identifies your specific video release and matches it against subtitle databases to find ones with correct timing. Works with just a filename or by analyzing the file directly.
Tech stack: node, angular
Feedback welcome, especially on the matching accuracy.

value: Show HN: Subtitle Finder – Find perfectly synced subtitles for your video files


value: Show HN: I made a bookmarks assistant for people who save lots of links and tabs


value: modinfo

value: Show HN: A simple Rust daemon that monitors URLs and triggers local scripts

author: modinfo


value: jph

value: Show HN: unix-shell-script-kit 13.0 for POSIX functions, exit codes, color codes

author: jph


value: gdad

value:
We built a memory plugin for OpenClaw that syncs context across AI platforms.
The problem: OpenClaw stores memory locally (markdown files + SQLite). Great for single-machine use, but your mac-mini's/desktop's OpenClaw doesn't know what your laptop learned, or what you discussed in Claude or ChatGPT.
Our plugin connects OpenClaw to Maximem Vity, which creates a unified memory layer across OpenClaw, ChatGPT, Claude, Gemini, and Perplexity.
How it works:
- Long-term memory: Stores facts, preferences, goals, constraints in an encrypted cloud vault. Auto-consolidates and forgets stale info intelligently.
- Short-term memory: Captures conversation summaries, tasks, procedures. Converts to long-term when relevant.
- Privacy: Encryption at rest, secure LLM calls, granular delete controls. You own your data.
Install:
    openclaw plugins install @maximem/memory-plugin
Then set your API key (free at app.maximem.ai).
Docs: https://memoryplugin-for-openclaw.com
This is an unofficial community plugin, not affiliated with OpenClaw.
Would love feedback from anyone using OpenClaw. What memory/context problems are you running into?

value: Show HN: Memory plugin for OpenClaw; cross-platform context sync with major LLMs

author: gdad


value: LutumVeritas

value:
Solo Dev. Couch Potato. Build a Standalone Open Source Deep research tool.
And it Beats Google , Open ai and Perplexity in Multible Metrics : https://veritas-test.neocities.org/
( pls translate it its german)
Guys : lets get this to be used. Because KNOWLAGE Shouldnt be locked behind Paywalls

value: Show HN: My Open Source Deep Research tools beats Google and I can Prove it

author: LutumVeritas


value: Show HN: Open-source code for a private, infinitely scalable, PQ-secure L1 layer


value: calinf

value:
I built WaldenWeek to gamify the “simpler living" Thoreau preached in Walden without it feeling like a self-help app.
The goal is to subtract a modern commodity every week to find out what we can/cannot live without. The intention is not to make life difficult, but to make it deliberate, to help us distinguish what we need vs. what we have.
Inspired by the game FTL: Faster Than Light, I wanted that feeling of a tactical HUD, but for managing my own scarce resources: Focus, Strength, Clarity, ... Each week, you're challenged to live without something that we blindly consider necessary. If you survive the week, you upgrade your 'human' reactor. If you fail, you donate real money to a charity that matches the challenge.
For example, don't read the news headlines for a week - If you win, you gain +1 for Clarity but if you fail, you donate _$ to the committee to protect journalists.
Warning! Hull Critical. https://waldenweek.com

value: Show HN: FTL + Walden = WaldenWeek

author: calinf

title: Show HN: FTL + Walden = WaldenWeek