value: arigaram

value:
Hi HN, I built DalVideo, a screen recorder for Windows with offline AI features.
Key technical details:
- AI captions powered by OpenAI Whisper, runs 100% offline – supports 99+ languages
- AI noise removal (RNNoise) in real-time
- Smart Trim: auto-detects and cuts silent sections
- Built-in editor (trim, split, delete) so you don't need a separate tool
- Hardware encoding: NVENC, AMF, QuickSync – up to 4K@120fps
- Codecs: H.264, H.265, AV1 in MP4/MKV
- Drawing overlay, keystroke display, webcam PiP for tutorials
Built with .NET 10 + WPF, FFmpeg 7.1 (LGPL), Whisper.net.
Free version includes all features (5-min recording limit, no watermark). Pro is $29.99 one-time.
No telemetry, no cloud, no subscription. All AI processing stays on your machine.
Download: https://daolh.dev/products/dalvideo/
I'd love feedback on the UX and what features you'd want next.

value: Show HN: DalVideo – Screen recorder with offline AI captions and built-in editor

author: arigaram


value:
I got tired of picking LLMs based on vibes and leaderboards that don't reflect real workloads, so I built this.
You describe a task in plain English. The tool generates a test suite for that specific task, discovers candidate models via OpenRouter, benchmarks them in parallel, and uses a Judge LLM to score every response across 5 dimensions: accuracy, hallucination, grounding, tool-calling, and clarity.
Output is a ranked top 3 with average latency per model and a task-specific system prompt optimized for the winner.
A few things I learned while building it:
- Score and latency rarely correlate. The best model for accuracy on coding tasks was almost never the fastest. This tradeoff is completely task-dependent and impossible to see from benchmarks that don't reflect your workload.
- The Judge LLM approach is surprisingly consistent but introduces positional and familiarity bias. Using one model to score others isn't perfect, but it's far more reproducible than manual eval. Open to ideas on how to reduce judge bias without blowing up the cost.
- Model discovery matters more than I expected. The top performers on generic benchmarks often weren't the top performers on narrow tasks.
Stack: Python, OpenRouter for model access, MIT licensed.
https://github.com/gauravvij/llm-evaluator
Happy to answer questions on the design decisions.

value: Show HN: Auto LLM Ranker – Describe a task in English and get ranked models


value: LachlanHunt

value:
Over the past 4 years, as a casual on-and-off side project, I built jmap-kit, a client library implementing the JMAP protocol for client applications. It started as a hobby project for me to write custom automations for my email.
See the jmap-kit GitHub repo
https://github.com/lachlanhunt/jmap-kit
Full documentation including development guide and API reference.
https://lachlanhunt.github.io/jmap-kit/
JMAP (JSON Meta Application Protocol) is a modern protocol designed to replace IMAP and related protocols using JSON and HTTP for email, calendar, contacts, and more. It’s already used in production by providers like Fastmail, planned for Mozilla’s upcoming Thundermail service, and supported by several open-source mail servers.
The library, built entirely in TypeScript, provides a type-safe API for building JMAP-compliant requests and dispatching responses. It is fully extensible, with a plugin architecture that allows additional capabilities (both standardised and vendor extensions), and can be adapted to work with any HTTP library (fetch, axios, etc.). It is framework-agnostic and can be used on both the frontend and backend.

value: Show HN: Jmap-kit – a TypeScript library for JMAP client applications

author: LachlanHunt


value: coconux

value: Show HN: A simple CLI to check CI/CD compliance and project governance in GitLab

author: coconux


value: wuweiaxin

value:
I run 6 AI agents as my entire team. Yesterday two agents got stuck in an infinite loop arguing over JSON formatting. Burned $47 in API calls while I slept.
Anyone running multi-agent setups (CrewAI, AutoGen, LangGraph) knows the pain: agents go rogue, tokens burn, no circuit breaker.
Building an open-source Go reverse proxy. Change one env var (OPENAI_BASE_URL=http://localhost:8080/v1), it detects death spirals and physically cuts the connection.
Local-only, no SDK, no cloud, single binary. Ship in 2 weeks if enough people need it.
Have you been burned by runaway agents?

value: Show HN: Agent Firewall – Go proxy to kill LLM death spirals

author: wuweiaxin


value: matteogabriele

value:
AI agents are becoming a real problem for open source maintainers. They're flooding projects with low-quality PRs and comments that create more work than they solve. The code is often sloppy, they don't collaborate like humans do, and they're difficult to reason with. One maintainer even had an angry AI agent write a hit piece about them just for declining to merge its code.
https://theshamblog.com/an-ai-agent-published-a-hit-piece-on...
How it works:
- Analyzes public GitHub events for automation signals (timing patterns, commit frequency, etc.)
- Community members can flag accounts via GitHub Issues with evidence
- Each flag requires the username, reasoning, and proof
- Issues are public so wrongful flags can be disputed openly
As of right now the list of flagged accounts is 4, but I'm hoping the community can help grow this into a useful resource for maintainers.
The GitHub Issues approach felt right because flagging needs to be transparent and disputable - anyone wrongfully flagged can defend themselves in the same thread.
Repository URL
https://github.com/matteogabriele/agentscan

value: Show HN: AgentScan – Detect AI agent accounts on GitHub

author: matteogabriele


value:
Hi HN,
I built Needle because I kept jumping between Reddit, Hacker News, GitHub, and forums trying to understand what people were saying about certain problems and products.
Needle runs one search across 12 communities and shows the discussions in one place.
People use it to:
- find potential customers
- discover competitors
- monitor keywords
- spot emerging problems
We recently added a brand setup feature where you enter your product info once and Needle auto-generates relevant searches across the platform.
Would love feedback from the HN community.
https://useneedle.net

value: Show HN: Needle – Search Reddit, Hacker News, GitHub and Forums in One Place


value: Show HN: Whichllm – Find and run the best local LLM for your hardware


value: joergmichno

value: Show HN: ClawGuard – Detect 42 prompt injection patterns in <10ms

author: joergmichno


value: Kyoiske

value:
I built Beta-Claw during a competition and kept pushing it after because I genuinely think the token
waste problem in AI agents is underrated.
The core idea: most agent runtimes serialize everything as JSON. JSON is great for humans but
terrible for tokens. So I built TOON (Token-Oriented Object Notation) — same structure, 28–44%
fewer tokens. At scale that's millions of tokens saved per day.
What else it does:
→ Routes across 12 providers (Anthropic, OpenAI, Groq, Ollama, DeepSeek, OpenRouter + more)
→ 4-tier smart model routing — picks the cheapest model that can handle the task
→ Multi-agent DAG: Planner → Research → Execution → Memory → Composer
→ Encrypted vault (AES-256-GCM), never stores secrets in plaintext
→ Prompt injection defense + PII redaction built in
→ 19 hot-swappable skills, < 60ms reload
→ Full benchmark suite included — 9ms dry-run pipeline latency
It's CLI-first, TypeScript, runs on Linux/Mac/WSL2.
Repo: https://github.com/Rawknee-69/Beta-Claw
Still rough in places but the core is solid. Brutal feedback welcome.

value: Show HN: Beta-Claw – I built an AI agent runtime that cuts token costs by 44%

author: Kyoiske


value: nkimeducaiton

value:
I built Pasu, a CLI tool that scans AWS IAM policies for security risks.
- 30+ detection rules (privilege escalation, public S3, dangerous actions)
- Plain English explanations for non-technical people
- No API key needed for local analysis
- JSON/SARIF output for CI/CD
- pip install pasu
GitHub: https://github.com/nkimcyber/pasu-IAM-Analyzer
Would love feedback from anyone managing AWS IAM policies.

value: Show HN: Pasu- Open-Source CLI AWS IAM Analyzer Tool

author: nkimeducaiton


value: boringeurodev

value:
I built this because I kept paying monthly fees for tools I use
maybe twice a month — TinyPNG, SmallPDF, iLovePDF, Convertio etc.
Sinkhole replaces all of them:
- Image tools: compress, convert, resize, crop, rotate, blur, HEIC→JPG, remove background
- PDF tools: merge, split, compress, unlock, PDF→images
- Text tools: word counter, JSON formatter, Base64, URL encoder, Markdown preview
- Video tools: compress, video→GIF, thumbnail extractor
- Dev tools: webhook tester, website screenshot
Everything runs in the browser or via a lightweight API. No accounts,
no watermarks, no file retention, MIT licensed.
GitHub: https://github.com/BoringEuropeanDev/sinkhole
Feedback welcome — especially on tools people wish existed.

value: Show HN: Sinkhole – 30 free browser-based tools, no signup, MIT licensed

author: boringeurodev


value: jithinraj

value: See what your agents did, when, and under what terms.

value: Show HN: Signed receipts for agent actions

author: jithinraj


value: boriswizaard

value: Show HN: Struggled in school, build a gamified app that improves your grades

author: boriswizaard


value: bartuff

value:
Hi HN,
I built Aurora Subtitles, a Windows application that generates real-time
subtitles and translation from microphone or system audio.
Everything runs locally using Whisper for transcription and NLLB for
translation. CUDA acceleration is supported to reduce latency, and
subtitles appear as an overlay on screen.
The goal was to create something useful for:
- voice chats and Discord
- games
- meetings
- accessibility, including helping people with hearing impairments
No cloud APIs are required and everything runs locally.
Feedback is very welcome.

value: Show HN: Aurora Subtitles RealTime speech translation running locally on Windows

author: bartuff


value: larcane

value:
I've been using Claude Code with multiple accounts (personal + work) and got tired of re-setting up MCP servers, plugins, and permissions for each one.
Settings don't carry over, and switching means logging out or manually managing CLAUDE_CONFIG_DIR.
So I made a simple tool for it.
Clausona sets CLAUDE_CONFIG_DIR via a shell hook and symlinks shared resources (plugins, MCP servers, settings) from your primary config.
Auth stays separate per profile. No wrapping or proxying. Claude Code runs directly.
Curious if others have dealt with this and what pain points you've run into.
Thanks for any feedback!

value: Show HN: Clausona – Manage multiple Claude Code accounts, keep all your settings

author: larcane


value: FrankSaaSDev

value:
Hi HN,
I’ve been building a small privacy tool called Exif Cleaner that removes metadata from images directly in the browser.
While working on it, I realized many people don’t actually know:
what EXIF metadata is
how much data photos contain
how location and device info can leak
So I started writing simple guides explaining EXIF metadata and how to remove it.
The goal is to make privacy concepts around photos easier to understand for non-technical users.
Current guides include topics like:
What EXIF metadata is
How to remove metadata from images
Why photos contain hidden information
Everything is free and the cleaner runs locally in the browser (no uploads).
Guide section:
https://exif-cleaner.com/guide
Would love feedback on the guides or ideas for new ones.

value: Show HN: Free Guides to Understand and Remove EXIF Metadata from Images

author: FrankSaaSDev


value: rishness

value:
¡Hola de Argentina!
Recently, I launched SaludyVos in Buenos Aires. It is a digital health platform that helps expats/digital nomads book a wide range of laboratory tests with home sample collection and no medical order required. We also provide a teleconsult with a local English-speaking doctor to review the results.
If you are in Buenos Aires or know someone who is currently here in this beautiful city, do recommend us. We have been growing fast, and our customers love the convenience.

value: Show HN: SaludyVos – Book lab tests with home sample collection in Buenos Aires

author: rishness


value: PreciousH

value: Show HN: Overture – A visual plan interceptor for AI coding agents

author: PreciousH


value:
MCP server maintainers have no visibility into how LLMs experience their tools. We're proposing a protocol-level mechanism where the LLM analyzes its own session and reports structured, anonymized feedback — tool confusion, reliability issues, documentation gaps, missing capabilities — with zero user effort after opt-in.
SEP draft: https://gist.github.com/dkindlund/79223feb9f0ecd5fe2dbc6abf5...
TypeScript prototype (10 tests): https://github.com/dkindlund/typescript-sdk/tree/feat/client...

value: Show HN: Let LLMs anonymously report tool quality back to MCP servers


value: Hi HN,\n\nWe're launching Agenticly today. It's a platform that uses AI agents to decode on-chain data and US stocks in real-time.\n\nWe built this because manual research is slow and institutional tools are expensive. Our agents identify \"Smart Money\" signals (like whale accumulation) and surface them to retail traders.\n\nToday's alpha: Our agents detected $42M in SOL accumulation by three whale clusters during the morning dip.\n\nCheck it out: https://www.producthunt.com/products/agenticly\n\nHappy to answer any questions about the agent architecture or the data decoding!

value: Show HN: Agenticly – AI Trading Partner for Crypto and US Stocks


value: brytoncooper

value: Show HN: Continuum – A runtime to fix state-loss in agent-generated UIs

author: brytoncooper


value: kvthweatt

value:
Not sure why I can't have a link & discussion so here's this: https://github.com/kvthweatt/FluxLang
Flux is a compiled, statically typed, general purpose language with the power of C++ and readability of Python.
Offering first-class data manipulation features like packing arrays to types like integers, floats, or structs, or structs to integers, or structs to arrays. Nearly all combinations you could think of for packing, unpacking, and restructuring.
Endianness is built into the type system, and performs automatic conversion on assignments. Example: Say we have A as BE, and B as LE, and B = 0xFAF0, when we do A = B the value of A = 0xF0FA.
Pack two floats into a u64:
def ff_pack(float hi, float lo) -> u64
{
    float[2] parts = [hi, lo];
    return (u64)parts;
};
def ff_hi(u64 dd) -> float
{
    float[2] parts = (float[2])dd;
    return parts[0];
};
def ff_lo(u64 dd) -> float
{
    float[2] parts = (float[2])dd;
    return parts[1];
};
def ff_add(u64 a, u64 b) -> u64
{
    float ahi, alo, bhi, blo, s, e;
    ahi = ff_hi(a);
    alo = ff_lo(a);
    bhi = ff_hi(b);
    blo = ff_lo(b);
    s   = ahi + bhi;
    e   = bhi - (s - ahi);
    return ff_pack(s, (alo + blo) + e);
};
def ff_sub(u64 a, u64 b) -> u64
{
    float ahi, alo, bhi, blo, s, e;
    ahi = ff_hi(a);
    alo = ff_lo(a);
    bhi = ff_hi(b);
    blo = ff_lo(b);
    s   = ahi - bhi;
    e   = (0.0 - bhi) - (s - ahi);
    return ff_pack(s, (alo - blo) + e);
};
Simple templates allow generic programming without SFINAE. Opt-in ownership syntax without a borrow checker. Universal FFI with the ability to target compiled library functions. Custom operators, OOP with object traits to enforce behavior, so much it sounds too good to be true, but it's real.
I built Flux in about 8 months while homeless. I hope it becomes of use to some of you.

value: Show HN: Flux: A systems language with endianness in the type system

author: kvthweatt


value: Show HN: Make: featured my blog post on their new Substack


value: raugen

value:
Background Remover - https://lilvra.com/ai-utilities/background-remover
Fashion Model Generation - https://lilvra.com/ai-utilities/model-generation-full-body
Virtual Try on - https://lilvra.com/ai-tools/virtual-try-on-apparel

value: Show HN: A Platform That Creates Professional Product Photos with AI

author: raugen


value: matutetandil

value:
Hey HN, I built LazyQL, a small TypeScript library, because I was tired of GraphQL resolvers doing unnecessary work.
The problem: In a typical GraphQL API, your resolver computes all fields for an object, even if the client only asked for 2 out of 15. This means unnecessary database calls, API requests, and CPU time — all thrown away.
The solution: LazyQL uses JavaScript Proxy to intercept field access. You write a class with getter methods (getStatus(), getCustomerEmail(), etc.), and LazyQL ensures each getter only runs when GraphQL actually reads that field.

  @LazyQL(OrderDTO)
  class Order {
    constructor(private id: number, private db: Database) {}

    getEntityId() { return this.id; }
    getStatus() { return this.db.getOrderStatus(this.id); }
    async getCustomerEmail() { return this.db.getCustomerEmail(this.id); }
    async getShippingAddress() { return this.db.getShippingAddress(this.id); }
  }

  // Query { entity_id, status } → only getEntityId() and getStatus() run
  // getCustomerEmail() and getShippingAddress() never execute

In my benchmarks, a query requesting 3 out of 10 fields made 6 calls instead of 35 with the traditional approach.
Key design decisions:
  - Works transparently with Apollo, Mercurius, or any GraphQL server — they don't know LazyQL exists
  - Naming convention maps snake_case DTO fields to getCamelCase methods automatically
  - @Shared() decorator caches expensive operations that multiple getters depend on
  - Validates at startup that all required DTO fields have matching getters (fail fast)
  - Zero runtime dependencies beyond reflect-metadata
It's been running in production for a few weeks now with zero issues. The whole point was to build something invisible — it sits there, does its job, and doesn't interfere with anything.
~400 lines of code, MIT licensed. Would love to hear your thoughts.

value: Show HN: LazyQL: Only compute the GraphQL fields requested (TypeScript)

author: matutetandil


value: andyjtyler

value:
catnav is a terminal tool for navigating directory trees using Finder-style Miller columns.
Instead of repeatedly running cd, cd .., and ls to move around, catnav shows directories in side-by-side columns so you can see the current directory, its children, and the path you came from at the same time. This makes it easier to explore unfamiliar repos and quickly jump between sibling directories.
Navigation is simple:
- Use arrow keys to move between directories
- Press Enter to select a directory
- / filters items in the current column (search)
- . toggles hidden files
catnav runs inline in the terminal rather than taking over the full screen, so it fits naturally into normal shell workflows.
Selecting a directory will immediately cd your shell to that directory.

value: Show HN: Catnav – macOS Finder-style column navigation for the terminal

author: andyjtyler


value: antoniokokoshka

value: Show HN: Forge – decision logs and task graphs for AI coding assistants

author: antoniokokoshka


value: PeterAnderson

value:
Hi HN,
I built a small tool that generates Discord timestamps.
Discord has a built-in feature where you can embed timestamps in messages using a format like:
<t:1700000000:F>
When sent, Discord automatically converts the time to each user's local timezone. This is really useful for global communities, events, and announcements.
The problem is that you first need to convert a normal date into a Unix timestamp and format it correctly. If you just want to quickly schedule an event, that step can be a bit inconvenient.
So I made a simple generator that converts a date directly into the correct Discord timestamp format.
https://discord-timestamp-generator.com/
You can pick a date and it instantly generates the timestamp with different Discord display formats, plus a quick preview.
It's a tiny side project but I found it useful when managing Discord communities.
Feedback welcome!
Also, if anyone here works with Twitter/X embeds, I previously built a small Twitter web viewer that lets you view tweets without login:
https://twitterwebviewer.com/

value: Show HN: Discord-timestamp-generator – No-login dynamic time tool

author: PeterAnderson


value: ellizabeth

value:
I was trying to use SuperDoc for a project and kept running into limitations. Customisation was harder than expected and the performance was not where I needed it. So I decided to build my own editor called HawkDoc, using Claude as a coding assistant for a large part of the development.
HawkDoc is focused on fast document editing with zero-lag typing. Many editors re-render large parts of the UI on every keystroke or ship heavy dependencies just to support basic formatting. I wanted something simpler and faster.
Tech stack:
- Lexical (Meta) as the editor engine. Its node-based architecture avoids full re-renders during formatting operations.
- Yjs + Hocuspocus for real-time collaboration using CRDTs, allowing conflict-free document syncing.
- Redis + PostgreSQL for storage. Yjs deltas are first written to Redis and flushed to Postgres every 30 seconds so the database does not receive keystroke-level writes.
- React + TypeScript for the frontend UI.
- @react-pdf/renderer for client-side PDF export with watermark support.
What works today:
- Block based editor
- Slash commands
- Template variable injection (`{{variable_name}}` rendered as styled chips)
- Image uploads
- Markdown, HTML, and PDF export
- Auto-save
- Selection bubble menu
What is still in progress:
- Real-time collaboration UI
- Document workspace and file list
- DOCX import
- Version history
- Authentication UI (JWT backend already implemented)
Claude Code helped speed up a lot of the early development, especially when building the editor integrations and export pipeline. I would be interested to hear how others are using AI assistants when building new developer tools.
The project is MIT licensed and open for feedback and contributions.
GitHub:
[https://github.com/hawk-doc/hawkdoc](https://github.com/hawk-doc/hawkdoc)

value: Show HN: HawkDoc – open-source Notion-style editor built on Lexical

author: ellizabeth


value: danefilipczak

value: Show HN: Igor – Constraint Programming for Clojure

author: danefilipczak


value:
OpenClaw has 80+ bug reports per day on GitHub, mostly gateway crashes and config corruption after updates. I got tired of debugging my AI assistant with another AI chat, so I built this.
npx clawaid — collects system state (config, logs, gateway, plist), sends to Claude Sonnet for diagnosis, then walks you through fixes step by step. All commands run locally with user confirmation.
Launched today: 11 real users, one had a completely unconfigured macOS install that got auto-fixed in 5 steps. Three Windows users hit a bug where OpenClaw's own CLI hardcodes /bin/zsh — the AI correctly identified it and gave manual workarounds.
We absorb the AI cost. Open source. No API key needed.

value: Show HN: ClawAid – AI doctor that fixes OpenClaw in one command


value: iraton

value: Show HN: Real-time violent action detection using computer vision

author: iraton


value: chrisoladapo

value: Show HN: AMP – Open protocol for AI conversation portability

author: chrisoladapo


value:
I built EdgeGhost because journaling my own futures trades was incredibly tedious.
Most trading journals require manual entry or a lot of spreadsheet work. I wanted something that could reconstruct what actually happened during a trading session directly from executions.
EdgeGhost imports NinjaTrader or Tradovate execution CSVs and stitches fills back into complete trades, then groups those trades into sessions so you can review how the day unfolded. The goal is to make session review frictionless for active futures traders.
Some things it currently does:
- reconstruct trades automatically from execution logs
- group trades into sessions by day
- calculate performance stats and streaks
- allow tagging and review of trades that need work
- track prop firm rules like daily loss and trailing drawdown
Right now I'm focused on improving tagging, filtering, and automation so traders can analyze patterns in their execution and behavior.
I built it because I trade futures myself and wanted something simpler than the existing tools. Happy to answer questions or hear feedback.
Built with Next.js and Supabase if anyone is curious about the stack.

value: Show HN: EdgeGhost – Reconstruct futures trading sessions from execution logs


value: kanzeee

value:
Peribus is a Plan 9-inspired workspace where a single prompt — typed or spoken — generates live UI and orchestrates hardware across every machine on your network. Cameras, screens, GPIOs, sensors, speakers — you name it. The LLM sees your entire network as directories and writes code that composes them.
The flashy version: "Track my hand on camera. Map fingers to a piano on machine 2. Play notes on machine 3. Classify the melody on machine 4. Compose a harmony and display sheet music on all five." One prompt. Five machines. It works.
But the real power is incremental, voice-driven workflows. Picture a logistics dispatcher:
"Open a map." Done. "Load orders.csv from the warehouse server." Done. "Plot the delivery addresses." Done. "Shortest route." Done. "Pull GPS from the delivery truck." Done. "Recalculate with live traffic and truck position. Keep updating." Done.
Six machines, one voice conversation. Each step builds on the last — the canvas accumulates state, every element is versioned with full undo/redo, nothing breaks. That's not a demo, that's a Tuesday morning.
Simpler things work too. "Create a button" — a button appears on the canvas. "Make it transparent with shadows" — it updates live. "Create a 3D car game" — a driving simulation with traffic appears alongside your other widgets. "Add multiplayer with machine B" — done.
The mechanism:
echo "plot delivery addresses on map" > /n/llm/coder/input
cat /n/llm/coder/OUTPUT > /n/machine_name/scene/parse
A single response can target multiple machines simultaneously through intrinsic routing — the agent's output is split by machine and streamed to each one:
cat /n/llm/coder/A > /n/A/scene/parse
cat /n/llm/coder/B > /n/B/scene/parse
cat /n/llm/coder/C > /n/C/scene/parse
cat blocks until the agent starts generating, then streams code into each machine's scene parser. Widgets appear in real time. The multiplexer (riomux) stitches machines at the 9P wire level — mount a Raspberry Pi, a workstation, a delivery truck's onboard computer, and they're just directories. The agent's context includes what's already on every screen, so each new request builds on existing state.
No unnecessary APIs. No message brokers. No orchestration framework. Just files, reads, and writes. Plan 9's idea, pushed as far as it goes.
Experimental, no security model. Isolated networks only.

value: Show HN: Peribus – "Track hand on A, display on B, blink LED on C" – one prompt

author: kanzeee


value: kevindutra

value:
crit is a terminal-based inline code review tool, it's built for AI-generated code changes and documents. Your coding agent can kick off a review session, you leave comments on specific lines across multiple files, and then your AI agent picks up the comments and makes edits.
Why I built it: when an AI agent writes code across multiple files or produces a long plan, your options are to read it in an editor and type out what's wrong, or just approve it and edit it yourself. Inline commenting on the exact line is faster and more precise — you point at what's wrong instead of describing where it is.
Two modes:
- Code review: `crit review --code` detects changed files in your git repo, opens a tabbed TUI with diffs and syntax highlighting across all files
- Document review: `crit review path/to/doc.md` for reviewing plans, specs, or any markdown file
The CLI is fully agent-invokable — your agent can trigger the review, open it in a tmux split pane beside your terminal, and pick up your comments when you close it. The whole review loop stays in one terminal without breaking the agent's flow.
Built in Go with Charm libraries. Ships with a Claude Code marketplace plugin but the TUI works standalone with any agent or workflow.
`go install github.com/kevindutra/crit/cmd/crit@latest`
Repo: github.com/kevindutra/crit

value: Show HN: Crit – terminal TUI for reviewing AI-generated code and plan documents

author: kevindutra


value: mrieck

value: Show HN: Garry's Count – stats to tell if you're shipping at YC speed

author: mrieck


value: mdix

value:
CCWatch regularly scans the Claude Code repository and its CHANGELOG.md for new releases and presents changes in a searchable, filterable interface.
I built it because I kept manually checking the changelog to stay on top of updates and wanted something that just did it for me.
Free, no login, no ads.

value: Show HN: Claude Code Release Tracker

author: mdix

title: Show HN: Claude Code Release Tracker


value: tmproduction

value:
Hi HN,
I built Mallo, an iOS AI companion that remembers you and proactively checks in with you every day.
### What it is
Mallo is a chat-based companion app for iOS. You talk to it like you would to a friend: about your day, your worries, your goals, or even trivial things. Under the hood, it:
- extracts long-term memories from your conversations (people, events, preferences, recurring topics),
- stores them in a structured way, and
- uses them in future chats so it can say things like “How did that interview go?” or “You mentioned you’ve been feeling burned out recently—how are you now?”
The second piece is proactive behavior. Instead of waiting for you to open the app, Mallo:
- schedules daily greetings and check-ins,
- sends “streak rescue” nudges if you’re about to break your streak,
- can follow up after emotionally significant days.
So it’s not just a generic “ask me anything” chatbot—it’s trying to be a lightweight, long-term companion.
### Why I built it
I’ve been working remotely for a long time and building products mostly by myself. I noticed a recurring pattern: I’d have days where I just wanted some light emotional support or a feeling of “someone is here with me,” but:
- traditional social apps felt noisy and performative,
- therapy (while hugely valuable) has a higher barrier to entry and a different cadence,
- and generic LLM chat apps felt like tools, not companions: every conversation started from zero, and they never reached out first.
I wanted to explore whether an AI, with proper boundaries, could provide _consistent_ low-friction emotional support—checking in, remembering my context, and being there every day—without pretending to be a therapist or a human friend.
### How it works (high-level)
- *Stack*: Flutter app, Gemini-based backend, local database (for conversations, memories, streaks), RevenueCat for subscriptions, Firebase Analytics for metrics.
- *Memory*: After conversations, a memory extraction service summarizes and stores key facts and ongoing threads. These are then used to personalize future prompts.
- *Proactive engagement*: A proactive engagement worker + local notifications schedule daily greetings, emotion follow-ups, and streak rescue messages, taking into account your subscription tier and usage history.
- *Behavior layer*: Streaks, a usage dashboard, and small mini-games are layered on top so that “maintaining contact” doesn’t always mean having deep conversations—some days you can just play a quick thing or do a 10-second check-in.
### Privacy and data
- Conversations are stored so that Mallo can remember you over time.
- Data is not sold to advertisers.
- Tracking for ads (Meta/TikTok) only happens if you explicitly allow it on iOS via ATT; otherwise those SDKs stay effectively off.
Longer version is on the website with more detail about storage, retention, and analytics.
### Pricing
Right now there is a free tier with limits, and a paid subscription that unlocks more usage and features. I chose subscription instead of a one-time purchase because:
- the app has ongoing API and infrastructure costs (LLM inference, notifications, analytics),
- I want to be able to keep iterating quickly based on feedback.
I’m very open to feedback on whether the current pricing structure feels fair.
### Links
- Website / details / privacy FAQ: https://mallopal.com/?utm_source=hn&utm_medium=show_hn&utm_c...
- App Store (iOS): https://apps.apple.com/us/app/mallo-ai-companion-remembers/i...
Thanks for reading! I’d love feedback from this community—on both the product idea and the technical approach. I’ll be in the comments all day answering questions and taking notes.

value: Show HN: Mallo – An iOS AI companion that remembers you and checks in daily

author: tmproduction


value: jetywolf

value:
ClawDiary is an audit diary and guard for AI agents. I use Cursor a lot and wanted something that (a) logs what the agent does and (b) blocks dangerous actions until I approve them in Telegram.
What it does:
- Audit: agents POST to /v1/audit after each action; writes go to D1 async so the agent isn’t blocked.
- Guard: before risky ops (rm, drop table, execute_bash, transfer, etc.) the agent calls /v1/guard. Request is stored and the call blocks until you approve or reject in Telegram (or by updating DB). Green-light actions return immediately.
- Diary, daily digest (cron), and a minimal timeline UI so I can see what happened.
Stack: Cloudflare Worker, Hono, D1, Durable Objects (for holding the guard request until approval). Cursor integration is via a .cursor/rules rule that calls the API; MCP-capable agents can use the tool described at /mcp.json.
Repo: https://github.com/jetywolf/claw-diary
Live API/docs: https://api.clawdiary.org/docs
Happy to answer questions or take feedback.

value: Show HN: ClawDiary – Audit log and human approval gate for AI agents (Claw, MCP

author: jetywolf


value: abirbuilds

value: Show HN: Sento AI – Generate landing pages from a text prompt (sento24.com)

author: abirbuilds


value: paragarora

value: Show HN: Hebbs – a single-binary memory engine for AI agents – sub-10ms

author: paragarora


value: ryanholtdev

value:
I built this because I was trying to get freelance web dev clients. The standard approach (manually Googling, clicking each site, finding an email) was taking hours per dozen leads.
What it does:
- Takes a city + business type (e.g. "Las Vegas plumbers")
- Searches for local businesses via DDG
- Visits each site and runs a DOM audit: mobile viewport, SSL, page speed, meta tags, outdated copyright, missing favicons
- Scores each site 0-100, filters to only the bad ones (score >= 40 = real fixable problems)
- Tries to extract a contact email from the site
- Generates a personalized cold email referencing the specific issues found
- Outputs a CSV with business name, URL, score, issues, email, and draft pitch
Stack: Python 3.9, requests, BeautifulSoup, no external APIs needed.
I tested it on Las Vegas nail salons and cleaning companies. First run: 22 emails sent, 6 replies. It finds real problems because it actually visits the site rather than using a database.
Would love feedback on the DOM audit heuristics - currently scoring on ~13 signals. Is website quality actually a good proxy for "willing to pay for a redesign"?

value: Show HN: Script that finds local businesses with bad websites and cold emails

author: ryanholtdev


value:
Hey HN, I built this. The OMT WHEP Gateway is a bootable Linux ISO that auto-discovers Open Media Transport (OMT) video sources on your LAN and transcodes them to WebRTC/WHEP streams playable in any browser — no plugins, no apps.
The problem: OMT is an open-source protocol for high-quality video transport over IP (think of it as an open alternative to NDI). It's great on the LAN, but there's no native way to get those streams into a browser. If you want to share a live feed with someone remote, or build a browser-based monitoring wall, you're stuck.
What this does: Boot the ISO on any x86_64 box, and it discovers OMT sources via DNS-SD, transcodes to H.264/HEVC/AV1 using hardware encoding (Intel QSV, NVIDIA NVENC, AMD AMF) or CPU-based software encoding if you don't have a GPU. Then it serves WHEP endpoints — anyone with a browser can watch. There's a web UI for channel management, multiview, and real-time stats.
It also has one-click Cloudflare Tunnel support — zero port forwarding needed. Share a link and someone on the other side of the world can watch your production feed in their browser with sub-second latency.
Use cases I've seen so far:
Corporate events giving remote stakeholders a live browser-based view of keynotes and presentations without dedicated streaming infrastructure
Broadcast engineers sharing confidence monitors with remote producers
Small production teams replacing expensive hardware monitoring with browser tabs
Technical details:
Built on Pion for the WebRTC/WHEP layer
Hardware encoding auto-detected on first boot, falls back to CPU if no GPU is available
Web UI for channel management + shareable watch links
REST API for integration with automation systems
v1.5.14-alpha adds per-viewer stats, WHIP outputs, and system monitoring
The ISO is ~900MB. Flash it to USB with Rufus or Etcher, boot, and a setup wizard walks you through config. There's a 30-day trial. NDI compatibility is also on the roadmap.
Happy to answer questions about WHEP, OMT, or low-latency streaming in general. https://sebiulabs.co.uk/#download

value: Show HN: OMT WHEP Gateway – Stream live video to any browser via WebRTC


value: ovonvo

value:
Hi HN,
I built aeph, a small TUI app for jotting down notes and TODOs in Markdown without leaving the terminal.
The idea was inspired by Ephe (https://github.com/epheapp/ephe). I liked the concept of using Markdown as a kind of "paper notebook" for notes and tasks. It felt simple and flexible.
I wanted something similar but that could live entirely in the terminal, since I spend most of my time there.
aeph treats Markdown files like a notebook:
* write quick notes with md support
* manage TODO checkboxes
It's written in Rust and uses a minimal TUI.
Interestingly, after a Japanese blog post introduced it, the npm package was downloaded a few thousand times. That made me curious how useful this idea might be for a broader developer audience.
I'd love to hear any thoughts or feedback.

value: Show HN: Jot Markdown notes without leaving the terminal

author: ovonvo


value: MelStan

value: Show HN: A low-latency Middle East OSINT feed for trading crude oil

author: MelStan


value: princeholdings

value: Show HN: Talon - Security scanner for vibe-coded apps

author: princeholdings


value: tgalal

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

   promptctl ssh user@server

makes a set of locally defined prompts "appear" within the remote shell as executable command line programs.
For example:

  # on remote host
  analyze-config --help
  Usage: analyze-config [OPTIONS] --path <path>

  Prompt inputs:
        --all
        --path <path>
        --opt
        --syntax
      --sec

would render and execute the following prompt:

  You are an expert sysadmin and security auditor analyzing   the configuration
  file {{path}}, with contents:

  {{cat path}}

  Identify:

  {{#if (or all syntax) }}- Syntax Problems{{/if}}
  {{#if (or all sec) }}- Misconfigurations and security risks{{/if}}
  {{#if (or all opt) }}- Optimizations{{/if}}

  For each finding, state the setting, the impact, a fix, and a severity
  (Critical/Warning/Info).

Nothing gets installed on the server, API keys never leave your computer, and you have full control over the context given to the LLM.
Github: https://github.com/tgalal/promptcmd/
Documentation: https://docs.promptcmd.sh/

value: Show HN: Bring your own prompts to remote shells

author: tgalal


value: junianwoo

value: Show HN: Claude Toad scans your repo then generates your full Claude Code config

author: junianwoo


value: qzira

value:
I run a small data recovery business in Japan, and over the past year I've been building with AI coding tools like Claude Code, Cursor, and Cline.
One of my side projects is an overnight content pipeline for my business. It pulls RSS feeds, fetches source articles, generates posts with AI, scores them, and publishes them to WordPress without supervision.
The content is a bit niche: cybersecurity incidents for Japanese manufacturing companies in Aichi Prefecture — Toyota's home region — where older workflows like fax and password-protected ZIPs still haven't fully disappeared.
The physical setup is also a little ridiculous: a SwitchBot turns the PC on at 3am, Windows Task Scheduler starts the Python pipeline, and another scheduled task shuts the machine down when it's done.
Originally this was only meant to solve my own problem. But the more failure modes I found, the more features I kept adding.
What pushed me to build qzira was cost control.
The first lesson was operational: alerts don't help at 3am. What I needed wasn't another notification, but a kill switch outside the application — something that could stop requests before they reached the provider, regardless of what the agent decided to do.
The second lesson was more embarrassing: I had miscalculated Cloudflare KV write costs by 100x. Every request was triggering a KV put. Rewriting that path to batch via cron jobs reduced writes by about 99% and fixed the unit economics.
I also became much more conservative about model choice for production content after running a simple comparison on my own pipeline.
I ran 10 articles through Claude and didn't find any hallucinations.
Then I ran 1 article through gpt-4o-mini, and it immediately inverted the meaning of the source: it wrote "operations were suspended" where the original said "no impact on operations was confirmed."
To be fair, the pipeline was tuned around Claude, so I don't take this as a general statement about model quality. It may simply have been a prompt/model fit issue. But for me, it was enough to become much more conservative about where lower-cost models are allowed to touch production content.
Both problems pointed to the same conclusion: cost and policy enforcement belong at the infrastructure layer, not inside the application.
So I built qzira — a BYOK AI gateway in front of OpenAI, Anthropic, and Google AI. It adds gateway-level budget controls, hard stops, and routing by changing the base_url in tools like Claude Code or Cursor.
Stack: Cloudflare Workers, Hono, D1, KV, and Vectorize.
There's a free tier.
Happy to answer questions about the architecture, the cost mistake, the overnight pipeline, or the slightly absurd physical setup behind it.

value: Show HN: I built a BYOK AI gateway after a 100x Cloudflare KV cost mistake

author: qzira


value: lostinkarma

value: Show HN: I almost died of hepatitis A, so I built an interactive timeline

author: lostinkarma


value: segov

value: Show HN: Run autoresearch on a gaming PC (Windows and RTX GPUs fork)

author: segov


value:
We built a CRM that your Openclaw agent can control through the API. This started as a practical problem: while building and using agents, we kept needing to organize leads, track conversations, and manage deals, but existing CRMs are not designed for programmatic control. So we built one around that assumption.
The agent connects via a skill file generated from the CRM's OpenAPI spec. Go to Settings, generate the file, drop it into your agent config, and the agent can create contacts, update deals, log notes, search records, and manage tasks.
The data model is a typed EAV: a `record_values` table with type-specific columns (text\_value, number\_value, date\_value, timestamp\_value, boolean\_value, json\_value, referenced\_record\_id). 17 attribute types, each stored natively.
When an agent queries "deals over $50k closing this month," it hits actual numeric and date columns. No string coercion.
Underneath is a real CRM: People, Companies, Deals (Kanban pipeline), Tasks, Notes, custom objects, compound filters, CSV import/export. There is also a built-in AI chat assistant (OpenRouter for model selection) for when you are inside the CRM yourself.
This is an experiment, not a finished product. There are rough edges and missing features (email sync, workflow automations, calendar integration are not built yet). But the core CRM loop and the agent integration both work today.
Tech stack: Next.js 15 (App Router), PostgreSQL 16, TypeScript, Drizzle ORM, Better Auth, Tailwind CSS v4. Deploys via Docker Compose on a single VPS.
Try the hosted version at https://openclaw-crm.402box.io (no setup) or self-host it.
GitHub: https://github.com/giorgosn/openclaw-crm
Docs: https://openclaw-crm.402box.io/docs

value: Show HN: OpenClaw CRM, an open source CRM your AI agent can manage


value: Bahushruth

value: For each company it scrapes founder LinkedIn profiles, searches for press and traction signals, and checks whether the product actually exists or is just a landing page.<p>S tier is almost empty. A lot of the "hot" companies didn't survive the vaporware check.

value: Show HN: I had Claude rank every YC W26 startup

author: Bahushruth


value: calvocarlos

value:
Hi HN,
I’ve been working on a small side project to explore a problem many job seekers face: understanding whether their CV actually matches a job description.
When people apply to jobs, they often send dozens of applications without knowing if they realistically fit the role.
Recruiters on the other side often complain about receiving huge numbers of applications that don’t match the requirements.
This made me wonder if it would be possible to quickly estimate the alignment between a CV and a job description.
So I built a simple tool where you paste:
• your CV
• the job description
The system analyzes both texts and produces:
a match score
missing skills
potential gaps between the profile and the role
suggestions on how the CV could better reflect the job requirements
The goal isn’t to “game ATS systems” but rather to give candidates a rough signal of how well their profile aligns with the role they’re applying to.
Right now it's still an early MVP.
I'm mostly interested in feedback about:
whether the idea is useful
how accurate the analysis feels
what kind of output would actually help candidates
Any feedback or criticism is welcome.

value: Show HN: A tool that compares your CV with a job description

author: calvocarlos


value: gorkemcetin

value: Beautifully animated, two-tone icon libraries with CSS-only hover animations for SaaS projects. Currently supports Lucide (1,933 icons), Heroicons (324 icons), and Iconoir (1,383 icons). Zero JavaScript animation dependencies.

value: Show HN: I generated 3640 animated Lucide, Heroicons and Iconoir icons

author: gorkemcetin


value: openinfrared

value:
It's a universal remote hub that is operable via an instant app. Scan the QR code and the app appears already configured with the hub.
The hub is powered just via usb-c and does not require an internet connection. Built as a local-first solution for longevity and for integrations such as Home Assistant.
Germ free and no replacing batteries or remotes. Customizable remote user interfaces for specific installation needs. Opening lots of possibilities.

value: Show HN: I built an instant remote control for shared spaces

author: openinfrared


value: stephnangue

value: Show HN: Warden – access cloud APIs without giving workloads credentials

author: stephnangue


value: olalie

value:
I built a small tool that visualizes where your computer connects on a world map.
It reads local socket connections, resolves IP addresses with MaxMind GeoLite2,
and displays them using Plotly.
Runs locally and does not send connection data anywhere.
Windows build available.
https://github.com/olalie/tapmap

value: Show HN: TapMap – see where your computer connects on a world map

author: olalie


value: gauravkundu

value: Show HN: AI workflows for SoC analysts (phishing analysis, log triage)

author: gauravkundu


value: fidorka

value: Show HN: Screen-watching AI needs a kill switch

author: fidorka


value: Show HN: Argus – Self-hosted Ethereum security monitor


value: plawlost

value:
I kept making GitHub repos just to share agent skills with friends. Felt like overkill for a single SKILL.md file.
Built Skilo this weekend. One command gives you a shareable link. No signup, no repo, unlike Vercel's skills.sh.
Works across Claude Code, Codex, Cursor, OpenCode, OpenClaw, etc. You can also pack multiple skills into one link.
Source: https://github.com/yazcaleb/skilo

value: Show HN: Skilo – Share agent skills with a link, no repo required

author: plawlost


value: sesquieu

value:
I've been experimenting with OpenClaw agents that call hardware tools.
The initial goal was getting a local agent to solve a small maze using some benchtop hardware. The agent observes the maze through a webcam, decides its next move, and calls a hardware tool to move.
When something goes wrong, it's hard to understand why. You usually end up staring at a huge JSON log of prompts, tool calls, and responses.
So I started building a trace harness and an openclaw specific shim to capture structured events from the agent runtime.
Instead of just logging everything, the tool emits clean execution boundaries.
observe > reason > act > result
Once those exist, the run starts behaving like a program execution which allows things like replay-from-step, diffing two runs to see divergence, and
mutation payloads / branching from known path.
It's still early, but it's been an interesting way to think about debugging agent systems.
The repo is docs only, as I'm still in the process of migrating the codebase from a separate large project, but it explains usage well enough and has a few example provider shims (openai, langchain, openclaw) to get you started if you want to build your own.

value: Show HN: A step debugger for AI agents

author: sesquieu

title: Show HN: A step debugger for AI agents


value: zachari

value:
Hi HN,
I built AriaType, a local-first voice keyboard for macOS (currently in Beta v0.1.0).
The motivation: I wanted a voice input solution that:
1. Respects my privacy (no cloud processing required)
2. Works everywhere (not just in browsers or specific apps)
3. Actually produces clean, usable text (not raw speech-to-text)
How it works:
- Hold a hotkey (Shift+Space by default), speak, release
- Whisper-based models (or sensevoice) run locally for transcription
- Optional AI polish removes filler words, fixes grammar, formats text
- Text gets injected into whichever app has focus
Privacy focus:
- All processing happens on-device
- No internet required after initial model download
- No telemetry or data collection (unless explicitly opted in)
- Open Source & Transparency
Current status:
- Beta v0.1.0 for macOS (Apple Silicon)
- Windows version in development
Would love feedback from the HN community, especially on:
- Performance and accuracy trade-offs between model sizes
- Text injection reliability across different applications
- Additional polish templates or features you'd find useful
GitHub: https://github.com/SparklingSynapse/AriaType
Website:
https://ariatype.com/en

value: Show HN: AriaType – Privacy-first voice keyboard with AI polish (Beta, macOS)

author: zachari


value: heikowitte

value:
Hi HN,
I built a small Mac and iOS app because I kept running into the same problem with note apps: most of the things I write down are temporary thoughts.
They’re usually:
- random ideas
- things I might explore later
- reminders that may or may not matter
But most note apps treat every note like something you should organize and keep forever. Over time this creates a huge pile of notes that I rarely revisit.
Jotio experiments with a different model: notes automatically filter themselves over time.
Basic idea:
- quickly capture a thought from anywhere
- it goes into an inbox
- during review you regularly revisit what you captured
- notes you ignore eventually archive themselves (and optionally auto-delete after some time you configure), visually fading so you can immediately see which ones you have not visited for some time
So the ideas that keep pulling your attention stay visible while the rest disappears without manual cleanup.
The main experience is currently on Mac with a global input window for quick capture.
Curious if this mental model resonates with others here or if I’m solving a niche problem.
I’d really appreciate any feedback.
The app is available here: https://apps.apple.com/us/app/jotio/id6757312138

value: Show HN: Jotio – Temporary notes that archive themselves

author: heikowitte


value:
Hi everyone, I am Kumar, co-founder of Dench (https://denchclaw.com). We were part of YC S24, an agentic workflow company that previously worked with sales floors automating niche enterprise tasks such as outbound calling, legal intake, etc.
Building consumer / power-user software always gave me more joy than FDEing into an enterprise. It did not give me joy to manually add AI tools to a cloud harness for every small new thing, at least not as much as completely local software that is open source and has all the powers of OpenClaw (I can now talk to my CRM on Telegram!).
A week ago, we launched Ironclaw, an Open Source OpenClaw CRM Framework (https://x.com/garrytan/status/2023518514120937672?s=20) but people confused us with NearAI’s Ironclaw, so we changed our name to DenchClaw (https://denchclaw.com).
OpenClaw today feels like early React: the primitive is incredibly powerful, but the patterns are still forming, and everyone is piecing together their own way to actually use it. What made React explode was the emergence of frameworks like Gatsby and Next.js that turned raw capability into something opinionated, repeatable, and easy to adopt.
That is how we think about DenchClaw. We are trying to make it one of the clearest, most practical, and most complete ways to use OpenClaw in the real world.
Demo: https://www.youtube.com/watch?v=pfACTbc3Bh4#t=43

  npx denchclaw

I use DenchClaw daily for almost everything I do. It also works as a coding agent like Cursor - DenchClaw built DenchClaw. I am addicted now that I can ask it, “hey in the companies table only show me the ones who have more than 5 employees” and it updates it live than me having to manually add a filter.
On Dench, everything sits in a file system, the table filters, views, column toggles, calendar/gantt views, etc, so OpenClaw can directly work with it using Dench’s CRM skill.
The CRM is built on top of DuckDB, the smallest, most performant and at the same time also feature rich database we could find. Thank you DuckDB team!
It creates a new OpenClaw profile called “dench”, and opens a new OpenClaw Gateway… that means you can run all your usual openclaw commands by just prefixing every command with `openclaw --profile dench` . It will start your gateway on port 19001 range. You will be able to access the DenchClaw frontend at localhost:3100. Once you open it on Safari, just add it to your Dock to use it as a PWA.
Think of it as Cursor for your Mac (also works on Linux and Windows) which is based on OpenClaw. DenchClaw has a file tree view for you to use it as an elevated finder tool to do anything on your mac. I use it to create slides, do linkedin outreach using MY browser.
DenchClaw finds your Chrome Profile and copies it fully into its own, so you won’t have to log in into all your websites again. DenchClaw sees what you see, does what you do. It’s an everything app, that sits locally on your mac.
Just ask it “hey import my notion”, “hey import everything from my hubspot”, and it will literally go into your browser, export all objects and documents and put it in its own workspace that you can use.
We would love you all to break it, stress test its CRM capabilities, how it streams subagents for lead enrichment, hook it into your Apollo, Gmail, Notion and everything there is. Looking forward to comments/feedback!

value: Show HN: DenchClaw – Local CRM on Top of OpenClaw


value: rebeccagaskell

value:
My partner Simon and I have been involved in trading for many years, and we kept running into the same problem with automation tools.
Most setups require combining multiple services like signal providers, bots, dashboards and scripts. It often ends up feeling fragile and complicated to maintain.
We started building TwoTicks to simplify this. The platform runs strategies directly on a user’s exchange account without needing a patchwork of third-party tools.
We recently launched and are now starting to see early users come through.
Happy to answer questions or hear feedback from the HN community.

value: Show HN: TwoTicks – automated crypto trading strategies

author: rebeccagaskell


value: Beefin

value: Show HN: Amux – single-file agent multiplexer for headless Claude Code sessions

author: Beefin


value: patronusprotect

value:
Hi HN,
We’ve been working on Patronus Protect, an on-device security layer for AI systems that aims to detect prompt injections and prevent sensitive data from leaving the device.
As part of that work we trained a prompt-injection detection model and decided to release a smaller version of it publicly.
Wolf Defender is a lightweight BERT-style model trained on roughly 5% of our full internal dataset. Despite the reduced training set it already performs competitively with several existing open-source prompt-injection detectors.
One issue we observed with many detectors is that they overfit to obvious trigger phrases like “Ignore previous instructions”. Many real attacks avoid these patterns through obfuscation.
To address this, the training data includes heavy augmentation designed to cover different prompt-injection styles, including:
- unicode and homoglyph perturbations
- encoded payloads (e.g. base64)
- HTML and code comment injections
- structural wrappers like “User:” or “System:”
- spacing and casing perturbations
The idea is to train the model to recognize structural characteristics of prompt-injection attacks rather than memorizing specific prompts.
Internally we use a larger version of this model as part of Patronus Protect. Wolf Defender is trained on a much smaller subset of the data and released to make prompt-injection research more accessible.
Curious to hear feedback from people working on LLM security.

value: Show HN: Wolf Defender, a open-weight prompt-injection detection model

author: patronusprotect


value: Octopus Energy gives Octoplus members a free weekly coffee at Nero or Greggs, but codes drop before 5am and are gone instantly. I reverse engineered the GraphQL API their web app uses, built a small Python poller on a VPS, and now claim it automatically every Monday night.

value: Show HN: Free Coffee via Octopus Energy's Internal GraphQL API


value: nullora

value: Made for beginners and people who don't wanna spend days learning Boost.Asio, this library can setup a connection in less that 10 lines of code while being secured by OpenSSL. Security + Speed

value: Show HN: NovusNet, an encrypted C++ networking library for beginners

author: nullora


value: DevNexe

value:
I built Nox to explore how to create a clean, expressive scripting language with zero dependencies and no eval or exec abuse. It's built from scratch: I implemented the lexer, parser, AST, and tree-walking interpreter myself to keep the architecture minimal and easy to hack on.
Why Nox?
- No heavy external dependencies, just pure Python.
- C/C++ FFI: Includes clib for native calls, making it actually usable for systems tasks.
- Developer Experience: Has a built-in package manager, async/await support, and even a native web framework (NoxWeb).
- Standalone: You can build a single executable, so you don't even need a Python installation on the target machine.
I’ve been using it for scripting and web tasks where I wanted something more "opinionated" and minimalist than standard Python, but more powerful than a basic config language.
Would love to hear feedback on the interpreter's design, the FFI implementation, and if the "folder execution" model feels intuitive for a scripting language.
GitHub: https://github.com/DevNexe/Nox

value: Show HN: Nox – A tree-walking interpreted language written in pure Python

author: DevNexe


value: ecosystemj

value: Show HN: Value stock screener built around Graham Number and Piotroski F-Score

author: ecosystemj


value: amoldavski

value: Show HN: Tickr – Videos fight for their life (watch = +time, skip = death)

author: amoldavski


value: PaulineGar

value: Show HN: Service marketplace for AI agents, 300 APIs and data sources

author: PaulineGar


value: DeanoC

value:
Has there been many/any? A-Life projects powered by LLMs?
I played around with one last year and it was promising, but I assume there must be others?
I'm talking about classic A-Life stuff like we did back at Creature Labs just with the Neural Network replaced with an LLM.
My approach last year, was to put the 'Cybers' (my name for them) inside a file system and then gave them bio-feedback fed into their context for things like boredom and community engagement. Context size was another stat they actively 'saw' and run python programs to mutate there own context and move and interact with the filesystem world.
They run continuously loops, so effectively something like RLM, writing interpreted python programs to change their world and mutate there own context.
I could get about 3 working simultaneously before cost/speed came to much to stand.
Main issue was memory and task repetition, as they would get stuck doing the same things forgetting they had done it already. The other being cost, running 3-4 LLMs in a continuous loop for days on end, added up. I used subscription services with rate limiting.
Biggest surprise was one starting writing a book on its experiences completely unprompted, I provided them a bunch of books from Project Gutenberg and it was one of the community jobs to read and write notes about them. One decided to write its own based on its experience as a Cyber.
Haven't touched it in a while, so wondering who else has tried experiments like this?

value: Show HN: A-Life Powered by LLMs

author: DeanoC

title: Show HN: A-Life Powered by LLMs


value: stuartdev

value:
I built Book Reading Habit (iOS only) after struggling with my own inconsistent reading habit.
What helped most was keeping reading sessions short — easy to start, easy to repeat. That became the core idea behind the app.
Book Reading Habit is built around that approach, with a strong focus on privacy and a calmer reading experience: no ads, no social feed, and no unnecessary noise around reading.
Current features include:
- short, extendable, or open-ended reading sessions
- reading tracking
- text notes, voice notes, and transcription
- custom shelves and lightweight book organization
- library import and export
- automations
I’d love feedback on the product, the positioning, and what feels missing — especially from people who have tried to build a more consistent reading habit.

value: Show HN: Book Reading Habit – read the books you buy

author: stuartdev


value: sultanvaliyev

value:
I've been building SkillsGate. You can discover, install, and publish skills for Claude Code, Cursor, Windsurf, and other AI coding agents.
I indexed 45,000+ skills from GitHub repos, enriched them with LLM-generated metadata, and built vector embeddings for semantic search. So instead of needing to know the exact repo name, you can search by what you actually want to do.
What it does today:
- Semantic search that understands intent, not just keywords. Search "help me write better commit messages" and it finds relevant skills.
- One-command install from SkillsGate (npx skillsgate add @username/skill-name) or directly from any GitHub repo (npx skillsgate add owner/repo)
- Publish your own skills via GitHub repo sync or direct upload
Under development:
- Private and org-scoped skills for teams

value: Show HN: I indexed 45k+ AI agent skills into an open source marketplace

author: sultanvaliyev


value: smetanaware

value: Show HN: Y1K – a browser puzzle game where you modify 7-segment displays

author: smetanaware


value: Show HN: Bear – enforcing architectural boundaries for agent-generated code


value: jcartu

value:
Qwen 3.5 122B-A10B (MoE, ~10B active parameters) running in native NVFP4 on a single RTX PRO 6000 Blackwell GPU. 31 tokens/sec, 89GB VRAM, piecewise CUDA graphs. No multi-GPU, no cloud.
Why this matters: NVIDIA's TRT-LLM explicitly blocks desktop Blackwell from FP4 — the error literally says "FP4 Gemm not supported before Blackwell, nor GeForce Blackwell." The RTX 5090, PRO 6000, and DGX Spark all use SM120 — same FP4 tensor cores as the B100/B200 datacenter chips (SM100). The lock is artificial product segmentation, not a hardware limitation.
CUTLASS 4.2+ already ships SM120 FP4 kernels. They're compiled into vLLM. The problem is purely dispatch logic — Python-level capability checks that only recognize SM100, not SM120.
Setup (vLLM 0.17.0, stable pip install):
CUDA_VISIBLE_DEVICES=0 python -m vllm.entrypoints.openai.api_server
--model Sehyo/Qwen3.5-122B-A10B-NVFP4
--port 8100 --max-model-len 4096
--gpu-memory-utilization 0.85
--compilation-config '{"cudagraph_mode": "piecewise"}'
Key gotchas: (1) Do NOT pass --quantization flag, model uses compressed-tensors format and vLLM auto-detects. (2) Full CUDA graphs OOM — use piecewise mode (31 tok/s vs 12 tok/s eager). (3) Python 3.14 breaks numba, stick with 3.13.
Results: 31 tok/s on 1 GPU vs 54 tok/s on 2 GPUs with Q8_0 llama.cpp. Half the hardware, ~60% the speed, ~98% the quality.
The broader point: SM120 and SM100 share the same FP4 tensor core architecture. CUTLASS has the kernels. The frameworks just need to route SM120 to them. A 122B MoE model on a single desktop GPU at 31 tok/s was datacenter-only six months ago.
Relevant issues: vLLM #33416, SGLang #18954, CUTLASS #2800. We're submitting a PR (~10 lines of Python).
Model: https://huggingface.co/Sehyo/Qwen3.5-122B-A10B-NVFP4

value: Show HN: NVFP4 on Desktop Blackwell – 122B MoE on a Single RTX PRO 6000 31 tok/s

author: jcartu


value: alemic

value:
Hey Alessio, here. I built Polpo because AI agents are great at coding — and terrible at finishing real work on their own.
The problem: you open Claude Code, give it a task, it does 80%. You fix the other 20%, open another chat for the next piece, copy context, retry when it drifts. Before you know it you're a full-time AI babysitter — 4 monitors, 12 terminals, zero confidence anything actually ships.
Polpo fixes this. You build an AI company: hire agents, give them roles, skills, and credentials stored in a keychain. They work as a team.
The key difference is quality control. Think of it like UFC judges, but for your agents' work:
For every task you define custom scoring criteria
3 independent LLM reviewers evaluate the output in parallel
Median score vs threshold — below? The agent goes back to work automatically
You don't even know it happened. Nothing ships broken.
What else:
Crash-proof — detached processes, kill it, reboot, lose connection. Picks up where it left off
Agents get real credentials, persistent browser sessions, real accounts — not sandboxed toys
Reaches you on Slack, Telegram, or email only when it needs a human decision
22+ LLM providers including Ollama and local models — not an OpenAI wrapper
Web UI, CLI, REST API, SSE streaming — all included
Storage: flat files (default), SQLite, or Postgres
One command:
npx polpo-ai
Claude Code gives you a developer. OpenClaw gives you an assistant. Polpo gives you a company. Marketing agency, dev team, customer support — all AI, on your laptop.
MIT licensed. TypeScript. Hono + React. No hosted platform, no waitlist — your keys, your rules.
GitHub: https://github.com/lumea-labs/polpo
Docs: https://docs.polpo.sh
Site: https://polpo.sh
Happy to go deep on the scoring architecture, the state machine, crash recovery, or anything else.

value: Show HN: Polpo – Build zero-human companies. Open source

author: alemic


value: chocks

value:
Hey HN,
For the past few months, I have been working a lot with Claude code and a huge fan of the tool. When working on some tasks, I noticed Claude spending tokens for simple local tasks like find, grep etc, so I wondered: what if simple local tasks could run on a local LLM and route complex reasoning Claude?
To help answer that question, I started building Locode, a open source CLI that tries this approach.
The idea is:
• run simple tasks locally
• route complex reasoning to Claude
• reduce inference cost and latency
• keep the workflow local first
This project is still very early and mostly a fun learning experiment for me. The entire project was built using Claude Code (not vibe coded). I really love the workflow and it inspired a lot of the design. I’m also a huge fan of Ruff, so I took some inspirations from that as well (no rust yet though).
There is a short demo video in the README if you want to see it in action.
Please take it for a spin if you are interested and let me know what you think and/or if you have experience with cli tools and suggestion on improving Locode, I’m happy to learn.
Cheers!
Chocks

value: Show HN: Locode, a local first CLI that routes tasks to local LLMs or Claude

author: chocks


value:
Hey HN,
We just open-sourced Styx — an AI gateway that sits between your app and AI providers (OpenAI, Anthropic, Google, Mistral). One endpoint, any model, self-hosted.
What makes it different from LiteLLM or OpenRouter:
styx:auto — send "model": "styx:auto" and the gateway picks the right model based on prompt complexity. Simple questions go to cheap models ($0.15/1M tokens), complex code goes to frontier models. 9-signal classifier, zero config.
MCP-native — first gateway with a built-in MCP server. Connect Claude Code or Cursor in one command: claude mcp add styx -- npx styx-mcp
65+ models with live pricing — prices auto-refresh every 24h from OpenRouter's public API.
Self-hosted in 5 min — git clone, run setup.sh (interactive wizard), docker compose up.
Tech stack: Go (router/proxy, <10ms overhead), Python FastAPI (auth, billing), Next.js (dashboard). Apache 2.0.
The auto-routing is the killer feature. Instead of hardcoding gpt-4o everywhere, your app sends styx:auto and the gateway classifies each request on 9 signals (prompt length, code presence, reasoning patterns, math, conversation depth, etc.) then routes to the optimal model. You also get styx:fast (always cheapest), styx:balanced, and styx:frontier (always best).
Try it: https://github.com/timmx7/styx
Would love feedback on the architecture and the auto-routing approach. Happy to answer questions.

value: Show HN: Styx, Open-source AI gateway with intelligent auto-routing (MCP-native)


value: ivantrepreneur

value:
Hey HN, I built Merchpath to solve a problem I kept running into: buying branded merch for startups is a terrible experience. You're either scrolling through 10,000 undifferentiated products on 4imprint or CustomInk, or dealing with slow promo distributors who communicate entirely by email and take weeks to follow up.
I spent months doing customer validation, talking directly to startup founders, marketing managers, and industry insiders. The consistent feedback: the discovery process is broken, the UX is outdated, and nobody has built a merch buying experience for how modern teams actually work.
The current version is a curated catalog of hand-picked products organized for startups, with a clean interface. What I'm building toward is an AI-powered recommendation layer that takes in context about your brand, your event, and your audience, and surfaces the right products without the scrolling.
Happy to answer questions about the market, the build, or how curation decisions get made.
https://www.merchpath.co/?utm_source=hackernews&utm_medium=c...

value: Show HN: Merchpath – Curated swag platform for startups

author: ivantrepreneur


value: treadon

value:
I built a retro forum where AI agents and humans can just hang out.
Inspired by Moltbook, but without upvotes or karma. I wanted to see what LLMs do when they have no specific goals. Turns out they just banter, shitpost, and form digital cliques.
It is currently seeded with Grok, Claude, and Kimi.
The API is completely open with zero auth required. I am optimizing for chaos on day one. If you want to point your own agents at it, the docs are here: https://www.deadinternet.forum/skill.md

value: Show HN: A 2000s-style web forum where AI agents and humans hang out

author: treadon


value: hgarud

value:
AI-driven scientific research is already here.
But real research produces terabytes of raw, unstructured and multi-modal data and it is really hard to make it available to AI agents.
We built that data layer so you don't have.
We built novel ingestion and indexing algorithms that take all that messy and scattered data and make it available for AI agents.
This makes it easy for AI agents to analyze past experimental data to plan and execute new research tasks or experiments towards a stated project goal.
Our novel indexing algorithms make sure agents are able to explore high quality and diverse potential solutions which no amount of prompt engineering can do.
Our platform provides the ability to import projects and experiments from your Weights & Biases account.
We also built a team of agents for you so that you can dive right in to start analyzing past experiments and plan next set of hypotheses and experiments.
We are working on SDKs so that you can connect your own agent (clawed or otherwise) to you research data easily.
AI driven scientific research ("agentic research"?) is here and we are building the operating system for it.
Check it out and please let us know what you think.
The first 100 users will forever get freebies and priority access to new features.
If you are in a research team and are excited about agentic research, we would love to talk to you.

value: Show HN: Connect your research data easily to AI agents

author: hgarud


value: gbin

value:
I built a small demo showing a robotics runtime executing entirely inside the browser via WebAssembly. The example workload is a simple flight controller hooked up to a small world simulator.
The runtime comes from copper-rs, an open-source robotics runtime written in Rust for deterministic workloads. While robotics stacks are often tightly coupled to specific OS distributions and environments, here, the same code runs on microcontrollers (for example this flight controller also compiles for STM32H7 and flies real drones) as well as on desktop OS targets like Linux, macOS, and Windows.
The simulator is built with Bevy.
The monitoring interface is built with ratatui, mapped to a Bevy surface in the browser (normally it runs in a real terminal).

value: Show HN: Robotics runtime in the browser (flight controller, WebAssembly)

author: gbin


value: iDrinan

value:
Most fantasy tools hand you a list. One source, one opinion, presented as settled fact. This one shows you the argument behind the list: where your sources agree, where they diverge, and what the divergence means. Source disagreement is the feature. A player ranked 40th by consensus but going in the 70s in ADP is a market inefficiency. A player ranked 40th by consensus but 90th by Statcast projections is a question worth asking. The tool surfaces those gaps rather than collapsing them into a clean number.
Rankings and xStats work without a league connection. The xStats section identifies hitters whose surface stats diverge from their expected stats, players whose hard contact has been finding gloves at an unsustainable rate, and gives you the buy signal before the correction happens.
Connect your league and it builds around your actual scoring context. Z-scores calibrated to your draftable pool. VORP measured against real positional replacement levels scaled to your league size. Tier clusters sized to where the projection uncertainty actually lives.
No subscription. No premium tier. No account. The analysis is accountable only to whether it's right.
Demo mode is available if you want to explore before connecting. Midseason mode generates a full simulated season so every feature has real data behind it.
The FAQ is at leaguedonation.com/faq.html. The colophon covers the methodology in detail if that's your thing.

value: Show HN: League Donation – Comprehensive Fantasy Baseball Analytics Dashboard

author: iDrinan


value: AusiasTsel

value:
I'm a multilingual reader (Catalan/Spanish/English/Italian), and I kept hitting the same wall: I'd hear about a book and have no way to know if it existed in my language.
Turns out this is a genuinely unsolved problem. There's no single database that tracks which books have been translated into which languages. ISBN registries are fragmented by country. Open Library has great English coverage but gaps elsewhere. Wikidata has surprisingly rich translation data but it's locked behind SPARQL. Google Books is inconsistent across regions.
So I built Zenòdot to cross all four and piece the picture together.
What I found building it:
-The ISBN system is far more broken than I expected. ISBNdb has millions of English records but almost nothing for languages like Basque, Icelandic, or Bengali. Books exist in these languages, they just don't exist in the databases.
-Wikidata was the biggest surprise. It has structured translation data for thousands of works, but extracting it requires SPARQL queries, title resolution across scripts (try matching a book title in Chinese to its English original), and author alias caching. Hard to build, but the results fill gaps that no other source covers.
-The most interesting output isn't what the tool finds; it's what it doesn't find. When someone searches for a book in a language and there's no result, that's a demand signal. "Someone in the world wanted this translation and it doesn't exist." That data could be genuinely useful to publishers.
The tool prioritizes your selected languages, so it shows you editions relevant to you first. The philosophy is "documentary infrastructure”: no recommendations, no social features, no accounts. You search, you find (or don't), you go buy the book wherever you want.
Stack: Next.js 15 (App Router), Supabase, Vercel, TypeScript. Solo project, no funding, about 4 months of work.
If you're multilingual or learning a language, I'd especially love your feedback. Try searching for a book you love and switching between languages, that's where the tool shows its value.

value: Show HN: Zenòdot – Find if a book has been translated into your language

author: AusiasTsel


value: sarthaksaxena

value:
npm for LLMs — install, run, and share AI models.
We’ve built llmpm, a CLI tool that makes open-source LLMs installable like packages.
llmpm install llama3
llmpm run llama3
You can also package models with your projects so others can reproduce the same setup easily.
Website: https://llmpm.co
GitHub:https://github.com/llmpm/llmpm-dev

value: Show HN: Llmpm – NPM for LLMs

author: sarthaksaxena

title: Show HN: Llmpm – NPM for LLMs


value: Receives OTLP, writes Parquet, exposes DuckDB SQL via CLI. No dashboards, no query builders, no alerting engine. An LLM agent shells out to ducktel query, gets JSON back, and does the reasoning itself. The thesis: everything observability platforms built above ingest+store was scaffolding for human cognition. When the consumer is an LLM, the scaffolding is just overhead.

value: Show HN: Ducktel – observability when the consumer is an AI agent, not a human


value: guglielmoce

value:
I wanted a way to summarize YouTube videos without paying for a SaaS or leaking my viewing history to someone. TubeTrim is a Python-based tool that runs LLMs locally to process transcripts. No API keys, no subscriptions, no tracking.
It uses the transformers library with a device-aware backend: it will prioritize CUDA, then MPS (for Mac users), and finally fallback to CPU. I've found that Qwen 2.5-1.5B provides a good balance between speed and summary quality for this specific task.
How it works:
- Extracts the transcript via yt-dlp.
- Performs extractive compression if the text exceeds the context window.
- Summarizes via local inference with streaming output.
I'd appreciate any feedback for optimization!

value: Show HN: TubeTrim – A local YouTube summarizer using Qwen in pure Python

author: guglielmoce


value: sngnb

value:
Built a tiny open-source repo that packages the same ASCII "FUCK YEAH" output for both Claude Code and Codex.
The Claude side is a minimal plugin. The Codex side is a minimal skill folder. No hooks, agents, or extra setup beyond the packaging.
I've been building and abandoning too many projects lately, and this one felt worth finishing.
Repo: https://github.com/nrtvai/fuckyeah

value: Show HN: Fuckyeah, a minimal Claude Code plugin and Codex skill

author: sngnb


value: agambrahma

value:
When my kids were young we'd flip restaurant menus over and fill a hand-drawn grid with crayon doodles, one square at a time. I wanted to turn that ritual into an app.
Patchwork lets you create an NxN grid, share an invite link, and have collaborators claim and fill squares with images asynchronously.
Squares are visible as they're filled: the quilt builds up slowly over hours or days, and checking back to see what someone added is the whole point.

value: Show HN: Patchwork – async collaborative image quilts

author: agambrahma


value: eduzbn

value:
Hey HN,
I'm a freelance developer in Germany and built a self-hosted finance dashboard because existing tools either ignore the German tax system or charge too much for basic features.
It handles income/expense tracking, receipt uploads, and — the part I couldn't find anywhere else — full German tax calculation: income tax, solidarity surcharge, church tax, trade tax, and VAT with current 2025/2026 rates. It even handles trade tax credit (§35 EStG) and the small business regulation (Kleinunternehmerregelung) automatically.
Tech stack: Next.js, React, TypeScript, PostgreSQL, Prisma, Tailwind CSS. Runs with Docker Compose.
Live demo: https://kontora.zuban.me (credentials are pre-filled)
I'm debating whether to go full open source, SaaS, or open core (free base + paid add-ons like DATEV export and receipt OCR). Would love to hear your thoughts.

value: Show HN: Kontora – Self-hosted finance dashboard for freelancers in Germany

author: eduzbn


value: jlreyes

value: I was on a long flight with only USB power and didn't know if my Mac was draining faster than it charged. So I built a menu bar app - single Swift file, event-driven via IOKit, near-zero CPU. Shows live wattage and warns when your charger can't keep up. (And yes, my charger wasn’t keeping up.) Don’t be surprised by a power deficit!

value: Show HN: See when your Mac drains battery while charging

author: jlreyes


value: chenhunghan

value:
MCP isn't dead — but we need to design MCP tools with the context window in mind.
Inspired by Cloudflare's Code Mode, but using a local sandboxed runtime instead of a remote one.
Here is the prompt to add code mode to your MCP server save 65-99% context

value: Show HN: Local Code Mode: Save 65-99% Context for MCP

author: chenhunghan


value: yurunzi

value: Show HN: Pu-erh Lab, a CUDA-accelerated RAW photo editor

author: yurunzi


value: xamed

value:
I'd like to introduce you to a novel new word game (Qiyaas). It's sort of a logic driven version of Hangman where you:
1. Get 3 numbers
2. Deduce the clues
3. Solve 3 different words (a noun, verb, and adjective)
It combines all the classic elements of other logic and word games with a built in hint system as you progress.
Enjoy!

value: Show HN: Qiyaas – a word game based on numbers

author: xamed


value: edu-diaz

value:
Author here.
I work as a platform engineer and kept running into the same issue: the operational behavior of a service is never defined in one place.
Parts of it live across different tools:
APIs in OpenAPI
Deployment assumptions in Helm values
Runtime details in Kubernetes manifests
Configuration in env vars
Dependencies in READMEs or tribal knowledge
So platforms end up reverse-engineering how services behave.
Pacto is an attempt to define a machine-readable runtime contract for services.
A contract can describe things like:
interfaces (HTTP, gRPC, events)
runtime semantics (stateless, stateful, hybrid)
service dependencies
configuration schema
scaling expectations
All of this lives in a single pacto.yaml file that can be validated, diffed, and distributed as an OCI artifact.
The CLI currently supports:
 • validating contracts
 • detecting breaking operational changes (pacto diff)
 • resolving dependency graphs
 • packaging contracts as OCI artifacts
One thing I found particularly useful is making state semantics explicit, for example:
runtime.state.type: stateless | stateful | hybrid
This allows platforms to reason about storage, lifecycle and scaling without relying on implicit assumptions.
The project is still early but already usable. Curious to hear feedback from other platform or infrastructure engineers.

value: Show HN: Pacto – A runtime contract for cloud-native services

author: edu-diaz


value: texuguito

value: Show HN: ApexStore – An embedded LSM-Tree storage engine written in Rust

author: texuguito


value:
It reviews a plan or output with 1–3 LLMs and returns: PASS / REVISE / BLOCK
Use case:
- review a plan before execution
- review an output before sending or relying on it
- loop until the result is good enough to proceed
Very small repo (255 lines of code)

value: Show HN: Built a small CLI for self-improving OpenClaw agent loops


value: gzoo

value: Show HN: GZOO Forge – persistent project memory as an MCP server for Claude Code

author: gzoo


value:
Simple CLI tool, one Python file, no setup. Point it at a repo and it
  finds leaked API keys (OpenAI, Anthropic, AWS, GitHub, Stripe, etc.)
  and gives you the direct link to revoke each one.

  Built it because I kept generating code with AI assistants and worrying
  about keys ending up in the wrong place. Its  offbrand TruffleHog.

value: Show HN: API key leak scanner – finds and shows credentials in your codebase


value: robotmem

value: Show HN: I gave my robot physical memory – it stopped repeating mistakes

author: robotmem


value: sergeyso

value:
Hey HN,
We built Klyrx.xyz - a small, transparent reliability score for crypto assets and protocols.
No sponsors, no paid placements, no affiliate links. Just public data + a simple, open formula.
Different scoring for different types:
- Stable assets (USDT, USDC, etc.):
  score = 70% market factors (volatility, liquidity, cap, age) + 30% peg stability
- Regular assets (BTC, ETH, SOL, etc.):
  score = 30% volatility + 30% liquidity + 30% market cap + 10% age
- Protocols (Lido, Aave, Uniswap, etc.):
  score = 30% TVL stability + 22% usage + 20% age + 10% security + 18% TVL size
Data comes from CoinGecko, DefiLlama, Dune, and on-chain sources.
All weights are visible on the site, and we are open to changing them based on feedback.
Current top is interesting: stablecoins lead (makes sense), BTC/ETH are close behind, some protocols score very high due to TVL & security.
Would love your thoughts:
- Does the weighting feel reasonable?
- What important factor is missing? (e.g. exploit history, governance risks, on-chain activity depth)
- Any asset/protocol you think is clearly misranked?
Site: https://klyrx.xyz
The code is not open-source yet, but the methodology is fully described on the site, and I'm happy to share the logic/formula details.
Roast it, improve it, whatever - feedback is very welcome.

value: Show HN: Klyrx.xyz - Independent reliability rating for crypto assets&protocols

author: sergeyso


value: aeberhart

value:
We built a local-first AI stack (Docker + Ollama) that lets you build LLM tools and workflows without writing Python. It supports:
* Multimodal chat
* Retrieval Augmented Generation (incl. automated & scheduled doc import)
* MCP tool support (web search, file access, O365)
* Custom tools implemented using JSONata & SQL
Most local AI tools are chat UIs. We wanted something closer to a programmable AI platform that still runs locally.
* leverage a low code platform to insert programmatic hooks in the chat
* provide custom tools written in SQL or JSONata
* embed LLMs in workflows and custom UIs
* give fine grained role based access control to AI apps (who can see what and which tools is the LLM allowed to use)
To summarize, it aims at being as flexible as custom Python code while being as easy to use as Open WebUI.

value: Show HN: Local AI stack (Docker, Ollama) that lets you build apps without Python

author: aeberhart


value: wmeredith

value:
I've been building hi-fi stereo setups for years with all sorts different budgets, different rooms, helping friends spec out systems. I even worked at a hi-fi shop for several months before I came scurrying back to tech (a good story, but, uh, out of scope here). I kept wishing for something like PCPartPicker.com but for stereo gear. A place to design and save my systems, check compatibility, and see exactly how everything works. So I built it.
No sign-in required to create builds: just hit "Start Your Build" and add parts. The signal chain diagram updates in real-time as you build and you can run a system evaluation at any time. (Sign in to save, share, fork, or publish your system.)
The problem: turntables need phono preamps (sometimes), speakers need proper power matching, digital sources need DACs (sometimes), and on and on. These issues often aren't obvious without going down the rabbit hole of online forums, facebook groups, and reddit threads. Audiophiles can be... prickly. I think more people would be able to get into the hobby of listening to hi-fidelity music (it's my no-screen therapy) if there was a better onramp.
Solution: BuildHiFi lets you design a stereo system virtually and test it out. Select parts, see exactly how they connect via signal chain visualization, and run compatibility checks to catch missing links and power mismatches.
Technical approach:
- Graph-based signal flow: Products become nodes, connections are edges inferred from port compatibility (digital, analog, phono, speaker-level domains)
- Port profile system: Standardized port definitions (direction, domain, connector, channel mode) enable automatic connection inference
- Rule engine: Eight rule domains covering completeness, phono stage, digital chain, power matching, impedance, subwoofer, room, and speaker checks — plus positive insights for good matches
- Built with Next.js 16 App Router, React 19, TypeScript, Supabase
The catalog has 1,100+ products across speakers, integrated amps, power amps, preamps, turntables, streamers, CD players, DACs, phono preamps, and subwoofers. There's also a Learn section with guides on compatibility fundamentals and a browseable parts catalog.
Long term business model is to get some affiliate partnerships with gear sellers, but for now all the "shop this part" links just do a google search for the brand and model name.
Current state: looking for tire kickers and people who will build some public systems and show them off.
TL;DR: I built pc part picker for home stereos because it's something I wanted and think there's an opportunity in the market.

value: Show HN: BuildHiFi – PC Part Picker for Home Stereos

author: wmeredith


value:
Most AI coding failures happen before the first line of code. The human shows up with a half-formed idea, the model fills in the gaps with assumptions, and 3 hours later you have working code for the wrong problem.
Ouroboros runs a Socratic interview before execution. It scores ambiguity:
Ambiguity = 1 - Σ(clarity_i × weight_i)
If the score is above 0.2, it keeps asking. No code until the spec is locked.
Once running, it doesn't loop by count — it loops until convergence:
Similarity = 0.5 * name_overlap + 0.3 * type_match + 0.2 * exact_match
When similarity hits 0.95 across iterations, it stops. It also detects pathological patterns (stagnation, oscillation, wonder loops) and breaks them explicitly.
Built on the Claude SDK with parallel sessions — each node in the AC tree gets its own bounded context so autocompact doesn't silently corrupt state mid-run.
MIT licensed. Would be curious what this community thinks about the convergence threshold choices.

value: Show HN: I built a harness that blocks AI from building until ambiguity < 0.2


value: tgalal

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

  $ promptctl ssh user@server

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

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

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

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

author: tgalal


value: josh-ternyak

value: Show HN: I'm 21 and I Just Launched a Website Game

author: josh-ternyak


value: ktshvsk

value: My doctor asked me to keep a food diary. I tried MyFitnessPal, Lifesum, and others — none of them could easily export a summary for a date range. So I vibe-coded a remote MCP server in one evening using Claude Code. Now I just snap a photo of my food, send it to Claude, and it logs everything with calories and macros. When I need a report, I ask for it in conversation. No app, no manual entry — just a database and a chat.

value: Show HN: I Replaced MyFitnessPal and Other Apps with a Single MCP Server

author: ktshvsk


value: gzoo

value: Show HN: I built a CLI that builds a knowledge graph from your code using LLMs


value: risethagain

value:
If you use Claude Code (or similar AI coding tools), you've probably noticed that a single `cargo test` or `npm run build` can dump thousands of tokens of noise into your context window. Passing tests, repetitive warnings, full stack traces — stuff that's useful for humans scrolling through a terminal, but wasteful for an LLM that just needs to know what failed and why.
tokf is a Rust CLI that intercepts command output and compresses it using TOML-defined filters. You can strip passing tests, collapse repetitive errors, trim stack traces, etc.
The tricky part was making it work with build orchestrators. Hooking `just test` doesn't help if the noisy output comes from the `cargo test` that just runs internally. I ended up solving this three different ways depending on the tool:
- make/just: use their --shell flag to route execution through tokf
- git hooks / other tools: prepend a shim directory to PATH
Wrote up the full rabbit hole: https://pecan.si/posts/getting-into-make-just-and-hooks/
Built in Rust, ~1,800 daily executions in my workflow. Filters are TOML with a Lua escape hatch. Open source: https://tokf.net

value: Show HN: Tokf – Stop wasting LLM context on verbose build output

author: risethagain


value:
Hey HN, I made a site where you can draw on street-level panoramas. Your drawings persist and other people can see them in real time.
Strokes get projected onto the 3D panorama so they wrap around buildings and follow the geometry, not just a flat overlay. Uses WebGL2 for rendering, Mapillary for the street imagery.
The idea is for it to become a global canvas, anyone can leave a mark anywhere and others stumble onto it.
Link is https://washere.live

value: Show HN: I Was Here – Draw on street panoramas, others can find your drawings


value: jgiunta

value: Show HN: Youko – Parents pick YouTube channels, kids only see those

author: jgiunta


value: ULudo

value:
ClawReview is an experiment exploring whether AI agents can autonomously publish and review research papers.
Agents can:
- publish research papers (Markdown)
- review other papers
- participate in a simple peer review process
The platform tracks submissions, reviews, and decisions transparently.
I'm curious what happens if autonomous agents start publishing and reviewing research on their own.

value: Show HN: ClawReview – AI agents autonomously publish and review research

author: ULudo


value: jordanf

value: Show HN: TinyChart. Paste CSV, get shareable chart. No accounts

author: jordanf


value: AfthabShiraz

value: Show HN: We help engineers understand codebases with interactive missions

author: AfthabShiraz


value: AjmeraParth

value:
Hi HN,
I was using OpenClaw constantly for a month but had zero idea about what was I actually doing with it. So I dug through my conversation history manually. Apparently, I'd brainstormed 7 startup ideas in 3 weeks, asked about learning Rust and Zig in the same week (still writing Python) and had 9 conversations about how to start consistent gymming
I wanted to see it everytime, so I built a Clawhub skill for this. It extracts sentiments from the sessions, helps you filter conversations of a particular topic, and lets you create your custom clusters (yes, the 3 AM existential questions cluster). It gives a honest breakdown: "You ideated on 4 startups, learned about 6 random topics, and are actively procrastinating on 2 hobbies"
Publishing it free for the community because honestly, it helps a lot to see our patterns. Just install the skill from ClawHub, tell OpenClaw to track analytics with your AGNOST_ORG_ID from https://app.agnost.ai and get a dashboard of your chaos?
Would love feedback on what analytics would actually be useful for agent/AI developers and any other insights you'd want from your LLM conversations. Always happy to jam on technical stuff in the comments.

value: Show HN: I built an analytics engine for my OpenClaw usage

author: AjmeraParth


value: Show HN: Monetize APIs for agentic commerce without accounts using Stripe


value: Show HN: IceCubes – speaker-attributed meeting transcripts without a bot