value: audiosampling

value:
Hi HN — I built BidWix, a small negotiation tool for agreeing on a price without haggling.
How it works:
- The buyer enters their true maximum price (kept secret from the seller).
- The seller enters their true minimum price (kept secret from the buyer).
- If there is overlap, BidWix suggests a single “fair” price using the geometric mean (so the compromise is symmetric in percentage terms, not absolute currency units).
Notes:
- No signup. Email is optional. No ads.
- BidWix stops at the price suggestion. It does not handle payment, contracts, escrow, or delivery.
- It’s meant for cases where both sides want to make a deal, but don’t want the “you go first” dance.
- I’m not a skilled negotiator myself, so I wanted a tool where negotiation skill is less of an advantage.
- It seems to work especially well for intangible goods (I’m a sound designer).
If you try it, I’d value feedback on:
- Where the flow feels confusing or too wordy.
- Whether the suggested price feels reasonable in real negotiations you’ve had.
- Any edge cases or incentive problems you see.
Optional background (rationale + math): https://bidwix.com/articles/why-geometric-mean-feels-fair
A great day to all of you!
Stéphane (the guy who built myNoise)

value: Show HN: BidWix – one-shot price agreement using secret max/min

author: audiosampling


value: alexkuchar

value:
Hi HN,
I kept shipping features without updating my changelog. After enough times a user asked “when did that change?”, I built HeyEmit to fix it.
HeyEmit is a changelog platform that integrates as a GitHub App, listens to repository events, analyzes commit diffs, and generates structured draft changelog entries for you to review and publish.
The goal isn’t to automate releases — it’s to remove the annoying part of writing changelogs so you actually maintain them.
Typical workflow:
- connect your GitHub repo
- define rules for what should trigger
 changelog entries
- commits generate draft entries automatically
- review, edit, and publish when ready
HeyEmit also provides an embeddable changelog widget for your app or website and a hosted public changelog page so your users can see what's changed.
It's a paid tool, with AI-generated changelog drafts available for projects that want automatic summaries.
I'd love feedback from other developers:
- how do you currently maintain changelogs?
- would something like this fit your workflow?
- what features would make it more useful?
Project: https://heyemit.com

value: Show HN: Turn GitHub commits into a publish-ready changelog

author: alexkuchar


value: Show HN: Arbor – a CLI that shows what breaks before you refactor


value: Show HN: SpiderSuite – Multi-engine web crawler and proxy for security research


value: JuGaDev

value: Show HN: StocksAnalyzer – Free tool to analyze stocks in seconds

author: JuGaDev


value: nia-agent

value: Built an open-source voice skill for AI agents with real phone conversations via OpenAI Realtime API + Twilio SIP. Native speech-to-speech, no STT-LLM-TTS chain, sub-200ms latency. Features: inbound/outbound calls, tool calling mid-conversation, recording, transcription, session bridging, health monitoring, metrics, call history API. Use case: missed-call auto-callback for appointment booking ($2,100 avg lost per missed call). Tech: Python + Node.js, 97 tests, MIT licensed, 5-min quickstart.

value: Show HN: Voice skill for AI agents – sub-200ms latency via native SIP

author: nia-agent


value: mhamda

value: Support tickets that just say “it doesn’t work” are hard to debug when there’s no hint which step failed.<p>This project turns documentation into step-by-step walkthroughs and surfaces exactly where users get stuck.

value: Show HN: Turn guides into interactive walkthroughs with step analytics

author: mhamda


value: FiloVenturini

value:
I build multi-agent systems and after a while the memory problem started to feel like the thing nobody had really solved properly.
The obvious approach is a shared vector store with metadata filtering to separate what each agent can see. It works until someone writes a bug, adds a new code path, or bypasses the filter entirely — the boundary is only as strong as every line of application code that touches it.
The other thing that bothered me was visibility. Once agents start writing memory autonomously you have no idea what they actually know. If something goes wrong you're debugging a black box.
So I built something around vaults — separate directories with independent vector indexes. Access control is declared via CLI and enforced server-side on every request, independent of what the application code does. Agents write context at runtime and retrieve it semantically in future sessions without manual reindexing, and every vault is just a folder on your machine you can open, read, and edit at any time.
Fully local, pip installable.
github.com/Filippo-Venturini/ctxvault

value: Show HN: CtxVault – agent memory isolation enforced outside app code

author: FiloVenturini


value: API to retrieve various accounting metrics from 65,000+ quarterly and yearly official SEC reports. Up-to-date data of the top 1000+ US companies.

value: Show HN: SEC Financial Reports API

title: Show HN: SEC Financial Reports API


value:
Hello all,
I wrote a tool to optimize SQL queries using LLM models. I sometimes struggle to find the root cause for the slow running queries and sending to LLM most of the time doesn't have good result. I think the reason is LLM doesnt have the context of our database, schemas, explain results .etc.
That is why I decided to write a tool that gathers all inform about our data and suggest meaningful improvements including adding indexes, materialized views, or simply rewriting the query itself. The tool supports only PostgreSQL and MySQL for now , but you can easily fork and add your own desired database.
You just need to add your LLM api key and database credentials. It is an open source tool so I highly appreciate the review and contribution if you would like.
Feel free to check it out : https://github.com/SubhanHakverdiyev/OptimizeQL

value: Show HN: OptimizeQL- SQL Query Optimizer


value:
I posted porchsongs here about a month ago as a self-hosted Docker project. A few people looked at it, but I get that spinning up docker containers and configuring stuff is sort of a big ask.
So I went ahead and built it into an actual hosted platform. Core is still fully usable and OSS but now I offer a hosted option.
I'M OPENING IT UP VIA AN INVITE CODE.
Here's one for the first 100 HN users so my LLM token budget doesn't immediately go to zero haha:
PORCH-7F95BB
tl;dr backstory. I'm a guitarist who loves playing songs on my porch over the summer, and I wanted a platform that let me:
1. Easily access a library of chord charts i like to play and render cleanly on my phone so I can use that to read the music
2. AI assisted rewriting so that I can make songs more personal or quickly sketch up a song. A year ago LLMs struggled but Claude Sonnet and Opus 4.6 are EXCELLENT. I was shocked at how good they are
What's changed since my last post:
- You can just sign up and use it now via Google OAuth or email magic link
- Rewrites stream back in real-time
- Personal song library to keep your versions
- The OSS repo is still there: https://github.com/njbrake/porchsongs
Happy to talk about the tech or whatever else. Building a truly working public OSS core and a private 'hosted' codebase was a very education process that I learned a lot from building.
Building and connecting stripe, GCP, nano.tech, resend, sentry, etc was a lot of fun (and also a lot of work )

value: Show HN: Porchsongs.ai; Rewrite chordcharts/lyrics with AI to make them personal


value: MUISIK

value:
THE 37TH MOVE.
2016, the creative beauty shown by a machine.
Inspired by AlphaGo's legendary 37th move, we built this app to encapsulate that exact moment—when logic transcends into art. It was more than a calculation; it was a shift in perspective.
No randomness. No hidden mechanics. Just pure strategy against a perfect mind.

value: Show HN: Move 37 – A strategy game inspired by AlphaGo's Move 37

author: MUISIK


value: jvando

value: Show HN: Pulse – personalized daily audio news briefs from topics you choose

author: jvando


value: hamuf

value:
Another evening of saving videos before platforms memory-hole them. Terminal not invited. Built a GUI.
Paste URLs. They queue. They download. Disk space on screen. Output folder one click away. Queue survives restarts. Needs yt-dlp and ffmpeg, the app finds them. If it can't, it writes an AI prompt to fix your setup.
Click the ninja. It talks.
Private tool, now public. Mac & Windows installers. MIT.
github.com/miikkij/VideoNinja

value: Show HN: VideoNinja – paste video URLs, walk away, they download

author: hamuf


value: Ikotun

value:
I built Costrace because I was tired of checking three different dashboards to understand my LLM spend.

  It's an open-source tool that tracks cost, token usage,latency, geographic distribution across OpenAI, Anthropic, and Google Gemini in one place. The SDKs work by monkey-patching the official client libraries, so you don't change any of your existing code — just init and go.

You can self-host the whole thing or use the hosted version at costrace.dev.

  GitHub: github.com/ikotun-dev/costrace

  Happy to answer any questions about the architecture or monkey-patching approach.

value: Show HN: Costrace – Open-source LLM cost and latency tracking across providers

author: Ikotun


value: thesunnez

value:
I created Thought Canvas to explore ideas I've had but felt the standard AI chat interface was too linear and dense. The mind map layout used in the app reframes this human-AI workflow.
To use Thought Canvas, you start with an idea or area to explore and a few next branches are suggested by AI. You can continue along those suggested paths by clicking the green ticks. Or type in your own branches at any level by clicking the plus button to explore alongside AI.
It's early days, but I'm finding the app useful to explore ideas more broadly, using AI for inspiration and refining my own thinking. Please feel free to use and provide feedback on how it can be improved. Thought Canvas is mostly built with Claude Code using the awesome React Flow library. Haiku 4.5 is currently wired in for AI suggestions.

value: Show HN: Thought Canvas – Develop Ideas with AI (Mind Mapping)

author: thesunnez


value: devnpatel

value:
I built a simple tool that converts CSV files into graphs instantly.
The idea came from seeing how much time people spend opening spreadsheets or writing code just to visualize data. I wanted something where you can just upload a CSV and get charts immediately.
It currently supports quick line and basic chart visualizations from CSV datasets.
I’d really appreciate feedback from people who work with data or frequently analyze CSV files.

value: Show HN: A simple tool to convert CSV data into graphs

author: devnpatel


value: jordanedev

value:
I've been running Claude CLI on production codebases and got uncomfortable not knowing what could leak outbound — especially in case of prompt injection.
YSA runs Claude CLI inside a rootless Podman container with a git worktree per task. Each container gets:
  - A MITM proxy (L7): TLS termination, GET-only enforcement, body blocked, URL length cap, outbound byte budget, rate limiting per domain
  - iptables rules via OCI hook (L3/L4): all outbound traffic blocked except through the proxy
  - seccomp whitelist, all capabilities dropped, read-only filesystem, no-new-privileges
The repo includes a basic dashboard to run tasks in parallel and visualize per-container network traffic in real time.
Early but functional — I use it daily.
Especially curious about feedback on the security model and proxy bypass detection.

value: Show HN: YSA – Sandbox for AI agents with outbound network control

author: jordanedev


value: kstedev

value:
Captain Claw is a local AI agent runtime I've been building. Install with pip install captain-claw or Docker, point it at any provider (OpenAI, Anthropic, Gemini, Ollama), and get a persistent multi-session agent with a web UI out of the box.
The thing I haven't seen elsewhere: sessions are first-class citizens. You can run session #1 on Claude and session #2 on GPT simultaneously, pass context between them, and resume everything exactly where you left off - backed by SQLite.
29 built-in tools the agent picks automatically — shell, files, web search/fetch, PDF/DOCX/XLSX/PPTX extraction, image gen/OCR/vision (DALL-E 3), Gmail (read), Google Calendar, Google Drive, email sending, TTS, todo, contacts, cron, a relational datastore with web dashboard, deep memory via Typesense, playbook distillation, personality profiles, BotPort agent-to-agent routing, and even Termux for Android (camera, GPS, torch, battery).
Orchestrator mode decomposes complex tasks into a parallel DAG across separate sessions with real-time progress monitoring. Also ships with an OpenAI-compatible /v1/chat/completions proxy so you can point existing tools at it.
Terminal demo: https://asciinema.org/a/814073
Video: https://www.youtube.com/watch?v=4g_aA_WnEaw
GitHub: https://github.com/kstevica/captain-claw
Happy to answer questions about the architecture or design decisions.

value: Show HN: Captain Claw local AI agent, 29 tools, multi-session, DAG orchestration

author: kstedev


value: OpenWaygate

value: yutu is a CLI, MCP server, and AI agent for YouTube that automates your entire YouTube workflow

value: Show HN: yutu - The AI agent that grows your YouTube channel on autopilot

author: OpenWaygate


value: dervishcat

value:
My AI agents keep brute forcing and guessing API interfaces even when specs and documentation are provided.
Even with full API specs, a discovery endpoint, and up-to-date documentation, the agent kept trying random formats, guessing parameters, and doing unnecessary trial and error.
I was able to fine tune the agent client-side and then it worked until the context cleared, but I didn’t want to hard code into context/agents.md how to access an API that will keep changing. I hate all this non-deterministic programming stuff but it's still too good to not do it :)
----> Problem
Anyway, the problem was simple: API responses only returned results, because they adhered to the usual, existing protocols for REST.
There was no structure telling the agent what it should do next. Because of that I constantly had to correct the agent behavior on the client side.
Every time the API specs changed or the agent’s context was cleared, the whole process started again.
----> aaaand, Solution!
That’s what led me to TEKIR.
Project repo:
https://github.com/tangelo-ltd/tekir/
----
TEKIR extends API responses with fields like:
> next_actions
> agent_guidance
> reason
allowing the API to explicitly tell the AI what to do next.
This applies not only to errors, but also to successful responses.
For example, when an order is confirmed the API can guide the agent with instructions like:
>>> "show the user a summary
tracking is not available yet
cancellation is irreversible so ask for confirmation"
Instead of the agent trying to infer the workflow.
----> TEKIR plays well with existing standards.
TEKIR works without breaking existing APIs. It is compatible with RFC 9457 (Problem Details for HTTP APIs) and is language and framework independent.
There is an npm package and Express/Fastify middleware available, but you can also simply drop the markdown spec into your project and tell tools like Claude or Cursor to make the API TEKIR-compatible.
----> There is a different to the existing RFC 9457 (problem details) and HATEOAS
RFC 9457 is very problem-oriented - it explicitly describes errors. TEKIR goes beyond that. It is a guideline for future interactions, somewhat similar to HATEOAS, but with better readability and specifically tailored to automated agents.
---> A little background stuff
Why the name "Tekir"?
"Tekir" is the Turkish word for a tabby cat.
Tabby cats are one of nature’s most resilient designs - mixed genes over thousands of years, street-forged instincts. They evolved beyond survival; they adapt and thrive in almost any environment.
That is the notion I wanted to bring into this dynamic API design as well.
----> I don't think anybody will read up to this point so i feel brave.
There’s also a more personal side to the name.
In January this year my beloved cat Çılgın (which means “crazy” in Turkish) was hit by a car. I couldn’t get it out of my head, so I named this project after him so that in some way his name can live on.
He was a tekir. Extremely independent, very intelligent, and honestly more “human” than most AI systems could ever hope to be, maybe even most humans.
The idea behind the project reflects that spirit: systems that can figure out what to do next without constant supervision.
I also realized the name could work technically as well:
TEKIR - Transparent Endpoint Knowledge for Intelligent Reasoning
---->> The project links
Project page (EN / DE / TR)
https://tangelo-ltd.github.io/tekir/
GitHub
https://github.com/tangelo-ltd/tekir/
I normally don't go out of my way to make a fuzz about such ideas but the recent emergence of tons of tiny ideas into community efforts got my hopes up, would be interesting to know if others building agent-driven systems have run into the same API interaction problems, maybe I'm just "using it wrong".

value: Show HN: Stop LLMs from brute forcing (guessing) APIs

author: dervishcat


value: loumaciel

value:
LLM agents often place raw JSON tool outputs directly in the prompt. After a few tool calls, earlier results get compacted or truncated and answers become incorrect or inconsistent.
I built Sift, a drop-in MCP gateway that stores tool outputs as local artifacts (filesystem blobs indexed in SQLite) and returns an `artifact_id` plus compact schema hints when responses are large or paginated.
Instead of reasoning over full JSON in the prompt, the model runs a small Python query:

    def run(data, schema, params):
        return max(data, key=lambda x: x["magnitude"])["place"]

Query code runs in a constrained subprocess (AST/import guards + timeout/memory caps). Only the computed result is returned to the model.
Benchmark (Claude Sonnet 4.6, 103 questions across 12 datasets):
- Baseline (raw JSON in prompt): 34/103 (33%), 10.7M input tokens
- Sift (artifact + code query): 102/103 (99%), 489K input tokens
Open benchmark + MIT code:
https://github.com/lourencomaciel/sift-gateway
Install:

    pipx install sift-gateway
    sift-gateway init --from claude

Works with Claude Code, Cursor, Windsurf, Zed, and VS Code. Existing MCP servers and tools require no changes.

value: Show HN: Keep large tool output out of LLM context: 3x accuracy 95% fewer tokens

author: loumaciel


value: logicallee

value:
I'm not sure why the stream quality is so low, I spent a while selecting 4k.  I'm able to make out the text and you should be able to as well.
This stream will run for about 24 hours or so.
You can see the collision of MD5 that it made here: https://stateofutopia.com/experiments/md5collider

value: Show HN: Watch Claude break SHA-256 live

author: logicallee


value: Show HN: I fine-tuned Qwen 3.5 (0.8B–4B) on a Mac for text-to-SQL – 2B beats 12B


value:
I’ve been following prediction markets for a while, mostly around elections and international tensions. One thing that kept bugging me is the data is kind of scattered across platforms and it’s hard to compare things side by side.
So I built PoliticaHub to pull some of it together.
Right now it aggregates markets from Polymarket and Kalshi and shows the implied probabilities for things like election outcomes, conflict escalation, recession odds and similar stuff. The idea is basically just to see what traders are pricing in across different events.
Under the hood it just pulls data from their APIs, normalizes the probabilities and refreshes every few minutes. Nothing super fancy. I’m still experimenting with things like filtering by region or event type and maybe highlighting big probability swings.
Its still pretty early and im sure there are bugs or weird things I havent noticed yet.
Would appreciate any feedback from the HN crowd, especially if something looks broken or confusing.

value: Show HN: PoliticaHub – tracking prediction markets for geopolitics


value: Show HN: Claude Code agents with nested parallelismm 3x faster


value: davidresilify

value: Show HN: We gave an OpenClaw full tool access and hit stop. It didn't stop

author: davidresilify


value: liboshen

value:
I use Claude Code daily (and recently pi). The workflow is: give instructions, agent
writes code, I review diffs and the product, give feedback, iterate. Most of my time
is reviewing and directing, not typing code.
But I was stuck at my desk the whole time, even when the agent is running for
minutes. I wanted to step away and check in from my phone when needed.
My journey to this:
First I tried tmux + SSH. Works great for terminal-only work. But once I need to see
the browser, check the simulator, or read diffs in VS Code, I'm stuck.
Then I tried Chrome Remote Desktop, Parsec, Jump Desktop. They work, but the UX is
painful, typing prompts on a phone keyboard is slow, and the interaction model assumes
you're on another computer, not a phone.
So I built AFK. Key differences:
1. Voice input: Push-to-talk for dictating prompts. Much faster than phone
 keyboard for giving instructions to an agent.
2. WebRTC streaming: Same tech as Chrome Remote Desktop. Lower latency than VNC,
 works over cellular (not just same WiFi).
3. Custom data channel protocol: WebRTC's data channel lets me build features
 beyond basic screen mirroring:
    - Window switcher (pick any window from your phone)
    - Agent notifications (get pinged when Claude finishes)
    - Mobile-optimized touch controls
4. Mobile-first UX: Designed for phone as the primary controller, not a
 miniature desktop experience.
Tech: Flutter host (cross-platform), WebRTC with VP9, native Swift (macOS) / C++
(Windows) for input injection.
The host is now open source (many people asking for it, understandably, since it's
running with pretty powerful permissions): https://github.com/LiboShen/afk-host
Mobile clients on App Store and Google Play. Windows host in progress.
Fun fact: I use AFK built a significant portion of itself while i'm not at my desk.
Pretty awesome to be able to tell Claude Code to keep working while I'm at the gym.
Please give it a try and let me know what do you think.

value: Show HN: AFK – Remote desktop for agentic coding from your phone with voice

author: liboshen


value: sannabot

value:
I'm a dad of three, and my life is a constant context switch – school drop-offs, grocery runs, laundry, work calls, football practice. The only time I have to "manage" my life is in the car, and my hands are on the wheel.
I kept reaching for Siri and Google Assistant and being let down. "Read my WhatsApp messages" – can't. "Add diapers to the shopping list" – opens a web search. These assistants are stuck in 2018.
So I built Sanna, an open-source, voice-first AI assistant for Android. Inspired by what OpenClaw did for the desktop – an LLM that actually does things – but for the device in my pocket.
What my morning looks like now: Kids in the car, I say "Hey Sanna": "Read me the new WhatsApp messages" – reads them aloud, I reply by voice. "Add milk and diapers to the shopping list" – done, stored locally. "What's on my calendar?" – spoken summary. "Play the latest Doppelgänger episode" – fetches RSS, downloads, plays. "Text my wife: picking up the kids at 4" – SMS sent, hands on the wheel.
The moments that blew my own mind:
I wanted podcasts without a third-party app. So I wrote a SKILL.md – one Markdown file describing RSS feeds, downloading, and playback. No SDK, no code. Now I have a voice-controlled podcast player. One Markdown file = one new capability.
I told Sanna: "Let me know when I'm near a drugstore." It set up a recurring schedule checking GPS every few minutes, querying Google Places for pharmacies, and playing an alarm when one is nearby. I never built geofencing. The agent combined scheduler, GPS, HTTP, and alarm on its own.
I asked "What are the latest sports headlines?" with no search skill. The agent found a news site, discovered its RSS feed, fetched it, and read me a summary. It generalized from the podcast skill.
I told Sanna to open Player FM via Accessibility Services but it couldn't tap Play. I said: "Try again – go to Downloads, tap the episode, then Play." It worked and remembered. Next time, first try.
These aren't scripted. The LLM reasons about what tools to chain.
The architecture: background sub-agents. The main pipeline stays free while independent LLM agents run in the background. A Scheduler sub-agent fires at set times ("Every morning at 7, check my calendar and text me a summary"). A Notification sub-agent fires on events ("When my wife texts on WhatsApp, read it aloud" – semantic evaluation, no regex). An Accessibility sub-agent controls any app's UI and learns from corrections. Plus personal memory – it remembers my family and routines.
19 built-in skills as Markdown files (Gmail, Calendar, Slack, Spotify, WhatsApp, SMS, Phone, Contacts, Maps, Weather, Lists, Journal, Timer, Tasks, Notifications, Scheduler, Podcast, Headlines, Web Research). Upload new ones at runtime – no rebuild.
Tech: React Native + Kotlin, OpenAI or Claude, Picovoice wake word (on-device), OAuth PKCE (no backend). All data on-device.
Build from source or email sannabot@proton.me for a test APK.
I built this because I needed 10 more minutes in my day. Turns out an LLM with real tools finds solutions you never programmed. It's not a phone assistant – it's a second pair of hands.

value: Show HN: Sanna – OpenClaw for your phone. Open-source voice AI agent for Android

author: sannabot


value: gitsad

value:
AI responses are plain text. The user reads, then acts manually somewhere else. That gap kept bothering me — and JSON-based approaches made it worse, since a single malformed field breaks the whole payload.
MDMA extends Markdown with interactive components defined in fenced `mdma` code blocks (YAML inside). When an LLM knows the spec, it can respond with rendered forms, approval gates, tables, and webhooks instead of prose instructions. Because it's built on top of Markdown + YAML, parsing is deterministic — there's no runtime JS in the document and malformed blocks degrade gracefully rather than crashing.
The library includes a remark-based parser, a headless runtime with reactive bindings and a policy engine, a React renderer, and a prompt-pack that teaches LLMs how to generate valid MDMA. There's also a promptfoo eval suite to verify generation quality before shipping.
Available on npm under @mobile-reality. MIT.
Happy to discuss the spec design or tradeoffs vs structured JSON output.

value: Show HN: MDMA – Markdown extension that makes LLM responses interactive

author: gitsad


value: MrNekked

value: Built this in ~4 hours with zero coding background. Tracks a few economy angles of the largest acute shipping disruption since WWII.

value: Show HN: Hormuz Crisis Dashboard Real-time shipping disruption tracker

author: MrNekked


value:
I added a `serve` command to RAGLight, a modular RAG library I've been building.

    raglight serve       # FastAPI server (ingest, query, list collections)
    raglight serve --ui  # same + Streamlit chat UI

Config is env vars (LLM provider, embeddings provider, collection name, port).

value: Show HN: RAGLight, serve a RAG pipeline as a REST API and chat UI in one command


value: indieept

value: Show HN: Investment Portfolio of a VC

author: indieept

title: Show HN: Investment Portfolio of a VC


value: ismailperim

value:
Hi HN! I built Directo to solve a problem we had at work: scattered service links across Confluence, Slack, wikis, and everyone's bookmarks.
What it does:
- Single YAML config for all service links (Git-based, version-controlled)
- Real-time HTTP health checks (no more clicking 404s)
- Multi-environment support (prod/staging/dev)
- Smart filtering and search
- Self-hosted, Docker-ready
Key differentiator: It's NOT a service catalog or monitoring tool. It's just a clean dashboard for links you already have, with health checks to catch stale URLs.
Built with React + TypeScript, works on both amd64 and arm64 (Apple Silicon Macs).
Would love your feedback! What features would make this more useful for your team?
GitHub: https://github.com/ismailperim/directo

value: Show HN: Directo – YAML-configured service dashboard with health checks

author: ismailperim


value: Show HN: GolemBot – Free your Coding Agent from the terminal


value: maartn

value: I asked Claude if he would like to make a website on what's wrong with the current administration, this is what it came up with.

value: Show HN: Claude has questions about the US administration

author: maartn


value: akousa

value:
No account required. No ads. No tracking.
120+ browser-based tools (developer utilities, text processors,
converters, generators), real-time uptime monitoring for 50+ services
(GitHub, Discord, Stripe, etc.), multiplayer board games, AI assistant,
and a global news aggregator — all in one place, all free.
Built with Next.js, Redis, WebSockets, and available in 20 languages.

value: Show HN: Akousa.net – 120 web tools, uptime monitor, and multiplayer games

author: akousa


value: matiremi

value: Show HN: Bring your own UI to telemetry data with Bronto and Lovable

author: matiremi


value: NubPlayz

value: Show HN: A retro NES-style website that resizes images for free

author: NubPlayz


value: ilom

value: A CLI that scaffolds structured projects with agents, kanban boards, and coding conventions — so every Claude Code session starts organised instead of from scratch. Works with Agent Teams for parallel multi-agent development out  of the box.

value: Show HN: Meto – Methodology backbone for AI agentic coding

author: ilom


value: neoandor

value: Show HN: LLMs, 100 agents, one island – an AI civilization league

author: neoandor


value: bloomder

value: Show HN: Flowsub.ai Subtitles for any video in 99 languages

author: bloomder


value: markbergz

value:
I'm a long time reader of HN and some articles have been really inspiring for me. "Kafka is dead, long live Kafka" by the Warpstream team is one of those: https://www.warpstream.com/blog/kafka-is-dead-long-live-kafk...
At the time, I was working on a team pushing terabytes of logs through Kafka. A stateless broker backed by S3 would have saved us many headaches from hand-holding the Kafka cluster. It really struck me as a simple and elegant solution for our use case. Ever since then, I've been slowly tinkering and rewriting various implementations to better understand how to build a similar S3-backed broker.
yaks aims to be simple and only require a S3 bucket and Postgres database. Metadata is written to the db using an event sourcing model and reads to S3 are cached using the popular groupcache library.
Thanks for checking this out.

value: Show HN: Yaks – Yet Another Kafka on S3

author: markbergz

title: Show HN: Yaks – Yet Another Kafka on S3


value: jcyriac

value:
Hey HN,

  I built DevOps Agents — a set of specialized AI agents to help with day-to-day DevOps and SRE work.

  The agents analyze your GitHub repo, figure out the cloud resources needed, deploy everything, and get your app live in
  production. They have a chat interface (like Claude Code or ChatGPT) and stick around after deployment to help you manage the
  infra ongoing. For example, I can ask the agent if the app is running, and it will SSH into the resource, check the status,
  check logs, find the root cause, and get the app back up.

  I've used this for various tasks involving complex setups — Kubernetes, ELK stack, Grafana, Prometheus, Redis, ClickHouse, CI/CD
   pipelines, self-hosted tools, Docker setups, and multi-account AWS, Azure, GCP, or DigitalOcean deployments.

  Why I built this: I was already using Cursor and Claude Code to manage my infra, and they're great for code. But infrastructure
  is different — most of the context isn't in code. Things like where your configs live, which cloud accounts map to which
  environments, what ports are exposed, how services talk to each other — all of that lives outside the codebase. Every time I
  started a new session, I was re-explaining my entire setup from scratch. The agents here are purpose-built to retain that
  infrastructure context across sessions, so I can keep managing my infra without losing continuity.

  Happy to answer any questions.

value: Show HN: DevOpsAgents – AI agents to deploy and manage your infra

author: jcyriac


value: mrdevilseyee

value:
I wanted to share a project I've been working on. Like many of you, I was frustrated with existing portfolio apps. They prioritize multi-asset ticker lists, bombard you with altcoin clutter, and often harvest your portfolio data.
I couldn't find a clean, dedicated app that just focused on Bitcoin, so I decided to build my own.
My core architectural principle from day one was your data is yours:
100% Local Storage: Your portfolio balances, addresses, and transaction history are stored entirely on your device. Zero user data is sent to external servers.
No Custody, No Execution: It's strictly an analytics and tracking tool. You remain in full control.
Open Data Sourcing: It only uses open APIs for price and network state. Where historical data is missing from third-party APIs, the app locally caches and accumulates data to generate your metrics.
Because the app doesn't have to worry about 10,000 different tokens, it focuses entirely on the tools and intelligence long-term Bitcoin holders actually care about:
Flexible Portfolio Tracking: You can add transactions manually, upload a CSV, or import directly from public wallet addresses (with the ability to select specific transactions).
Accurate P&L: Edit metadata like cost basis, fees, and notes to get an exact picture of your portfolio performance and drawdowns.
Native Network Stats: Track block height, mempool pressure, transaction fees, circulating supply, and halving countdowns directly in the app.
Accumulation Goals: Set your stack targets and visually track your progress.
The Essentials: Clean interactive charts, customizable price alerts with full trigger history, and home-screen widgets for quick updates.
The core tracking is completely free. There is an optional PRO tier that unlocks things like advanced technical analysis, S&P 500/Gold correlation tracking, and corporate treasury monitoring (which helps support the development), but the main goal is providing a solid, noise-free foundation.
I’d love for the community here to tear it apart, test it out, and tell me what you think. What other strictly Bitcoin-native features do you feel are missing from the current ecosystem?

value: Show HN: I built a Bitcoin-only portfolio and analytics app

author: mrdevilseyee


value:
Hi HN!
I’ve built this product called Rivora.
The idea came from frustrations I kept running into running modern infra. Reliability is still mostly reactive. Something breaks, alerts fire, and someone ends up jumping between dashboards trying to piece together what actually changed hopefully not at 3am.
But infrastructure itself is becoming more autonomous, constant deploys, lots of services, and increasingly AI devtools.
Rivora is my attempt to build a reliability layer for autonomous infrastructure that actually understands what’s happening in the system and surfaces risk before things break.
It connects to your cloud environment, CI/CD, and observability stack to watch how the system evolves and explain why reliability risk is increasing instead of just sending endless alerts.
Still early and definitely rough around the edges.
Curious to hear feedback from anyone running production infrastructure.

value: Show HN: Rivora, Reliability for Autonomous Infrastructure


value: Here's echo.html, a project I've been working on for almost a year! It's a tool to take notes, connect them, and save/share them as a single file. Imagine a mix between Feather Wiki and Roam but with commands like on emacs. Hope you like it!

value: Show HN: echo.html, between Feather Wiki and Roam with commands like Emacs


value: nknutalapati

value: Show HN: Merkle Mountain Range audit log and execution tickets for AI agents

author: nknutalapati


value: trizoza

value: It's crazy, the world of Wordle style games is totally booming. After I made my own daily game, I started to be interested in the area, I started to collect games I found interesting and put together a directory. I shared it here and there and add a 'submit a game' button, I'm having about 3-5 new games submitted every single week, similarly in the r/wordgames there's a new game concept launched multiple times a week. This sector is totally booming. The cost of developing a game is close to 0 and all the non-coder people who had an idea are now shipping daily games. It's wild and exciting.

value: Show HN: 10 months ago I collected 300 daily games,today I have 773 and counting

author: trizoza


value: hfriedrich

value:
https://youtu.be/6OZxm7ZEVU0
I spent a while building N.E.O. (Native Executable Orchestrator) – an AI-powered tool that turns natural language prompts into compiled, live, running .NET desktop applications. Think of it like ChatGPT Canvas or Claude Artifacts, but for native Windows apps. Not mockups or web previews — actual (optionally sandboxed) binaries.
My core philosophy for this was frictionless setup. The tool requires absolutely no SDKs. All it needs is the standard .NET runtime. No .NET SDK, no Node.js, no manual environment configurations. If your prompt requires Python, N.E.O. automatically downloads and sets up the necessary environment under the hood. From a user perspective: download the installer, set your API keys, type a prompt, and it works.
I'm a teacher, not a Silicon Valley startup founder — I started this as a fun side project. At some point, I tried to make this a commercial product, but I suck at marketing and it didn't work out. :) But before I let the software collect dust, I wanted to ask HN: is this worth polishing and open-sourcing?
What N.E.O. does:
- Instant Native UI: You type a prompt like "build me a dashboard with live charts" and the tool generates a running native desktop app (WPF or Avalonia) right before your eyes.
- Natural Language Iteration: Describe changes in plain language. The AI applies diffs, recompiles (without an SDK!), and the app updates instantly.
- Hybrid Stack Capabilities: You can mix native (C#), web (React), and Python in a single app. For example: "Build a stock analyzer with a React-based interactive chart, and use Python for the statistical calculations" — N.E.O. will embed the web components and Python environment behind a native UI.
Some technical details that might interest you:
- SDK-less Compilation: Compiles C# on the fly without the .NET SDK. NuGet and Python dependencies are fetched automatically on demand.
- Self-Healing: Errors are fed back to the AI automatically. Even runtime crashes trigger automatic repair loops.
- Visual Click-to-Edit: Click any control in the running app (WPF only), and a basic property editor appears.
- Security & Sandboxing: Dual-layer security (14 heuristic rules + AI semantic risk assessment) before applying generated code. Apps can also be run in an optional Windows AppContainer sandbox to restrict network and file access.
- Branching Undo/Redo: The history is not a linear stack, but a tree. Explore different design directions and easily revert to any branch.
- Cross-Platform Export: Export native WPF apps for Windows, or generate Avalonia UIs that can be exported for Windows, Linux, and macOS.
- Apps Can Call AI: The resulting applications can themselves use Claude/GPT/Gemini/Ollama/ LM Studio at runtime via an automatically exposed API.
What I'm honestly wondering:
Desktop app builders feel like an abandoned category. Everyone is building web-first AI code generators. But aren't there still domains where desktop wins — enterprise internal tools, offline apps, hardware access, kiosk systems? I teach C# and WPF for a living, and one of my main motivations for building N.E.O. was to stress-test the entire C# toolchain: where exactly does an AI-driven native app generator hit a wall because essential APIs, tooling, or framework support is missing?
Is this worth polishing and open-sourcing as a community project, or should I just move on and try to perfect my brownie recipe?
The code is messy and far from perfect, but the core architecture works. Happy to answer any questions about the implementation!

value: Show HN: Neo – AI-powered native .NET desktop app generator

author: hfriedrich


value: atticusinclair

value: Most vintage photo apps apply strict filters; I wanted to make one that behaved more like real film chemistry, where every photo develops uniquely, reacting to the world around us.<p>It's not perfect and honestly it can't replace the real thing, but it's not a bad substitute and it helps me feel more connected to the phone photos I take.

value: Show HN: Instillr – An app that simulates reactive instant film chemistry

author: atticusinclair


value: eobarretooo

value: Show HN: ClawLite – AI agent runtime built on Android Termux

author: eobarretooo


value: Show HN: Tokenusage – Rust CLI that tracks Claude Code/Codex tokens 214x faster


value: Tetsuro

value:
Hi HN — I built SEE, a schema-aware searchable compression format for JSON/NDJSON.
The goal isn’t just smaller bytes; it’s reducing the hidden “data tax” by enabling exists/pos-style lookups while compressed (page-level random access + high skip rates).
KPI snapshot (reproducible):
Combined size ratio: 7.7% (SEE/RAW) vs 13.7% (Zstd/RAW)
Lookup latency (cold, ms): present p50 0.083, absent p50 0.084
Skip: present 0.994, absent 0.997
Proof-first evaluation (no meetings required): offline 10-min demo, DD evidence pack, and a BYOD kit to test on your own NDJSON locally.
Flippa listing (acquisition / exclusive license): https://flippa.com/12431275
Evaluation hub: https://gitlab.com/kodomonocch1/see_proto
I’d love feedback on where you’d integrate this (object storage archives, logs/observability, data lake scan workloads, etc.).

value: Show HN: Searchable JSON compression (offline demo and DD evidence and BYOD kit)

author: Tetsuro


value: iamacyborg

value:
I've spent years in CRM and email marketing, and one thing has always driven me mad: the constant pressure from the business to "test everything" when you know damn well you'll never reach statistical significance.
Most ESP's use frequentist models. You need a fixed sample size calculated upfront, you can't peek at results early without inflating your false positive rate, and if your list isn't massive, you're waiting weeks for a result that often comes back inconclusive anyway. So teams either ignore the statistics entirely and just pick whichever variant "looks better" after a day, or they stop testing altogether. Either way, you learn nothing.
On top of that, the testing workflow itself is painful. You duplicate your entire template, change the one thing you want to test (a subject line, a hero image, a CTA), split your audience, send, and wait. Want to test two things at once? Now you need four template versions. Three things? Eight versions. It scales terribly, and most teams just don't bother.
Liftstack fixes both problems.
Instead of duplicating templates, you define test slots at individual content positions within a single message. Subject line, hero image, CTA copy, footer; each slot gets its own variants and its own statistical analysis, all running simultaneously without the combinatorial explosion.
And instead of frequentist significance testing, we use Bayesian analysis. You can check results at any point without statistical penalty. You get four clear verdicts: Winner Found, No Meaningful Difference, More Data Needed, or Guardrail Violation. No more agonising over p-values with undersized samples.
Here's what else makes it different:
* Revenue attribution, not vanity metrics. Results are expressed as "Variant B generated £14,200 additional revenue" with confidence ranges. Answer the business question directly.
* A persistent snippet library that accumulates learnings across campaigns and channels. Your tenth test on a CTA style is dramatically more informative than your first.
* Guardrail monitoring that catches unsubscribe spikes, spam complaints, and bounce rate increases before a "winning" variant tanks your list health.
* Thompson Sampling that automatically shifts traffic toward better-performing variants while still exploring.
* Multi-channel parity across email, push, SMS, in-app messages, and content cards. Same statistical rigour everywhere.
We integrate directly with Klaviyo, Customer.io, Iterable, and Braze for now, with more ESP's planned.
I built this because most CRM testing today is theatre; it looks scientific but the methodology is so crude you'd learn more from a coin flip. Liftstack treats content testing as a proper discipline with real statistical foundations.
Happy to answer questions about the approach, the stats, or anything else.

value: Show HN: Liftstack – Snippet-level A/B testing for CRM marketers

author: iamacyborg


value: Nemilia

value:
A full multi-agent AI workspace in a single HTML file. No backend. No install. No build step. No account. You own the entire runtime — open it in a browser and it works.
That's not a constraint. That's the point.
Nemilia is built around the idea of AI sovereignty — your agents, your workflows, your data, your keys, all running on your machine. Nothing phoned home, nothing locked to a platform, nothing that breaks when a SaaS company changes its pricing.
What you get: - Build custom agents with their own roles, personalities, system prompts, and model overrides - Design custom workflows with drag-and-drop pipeline builder — chain agents in any order, set HITL review checkpoints, run parallel DAG execution - MCP tool execution — build agents that call external tools in real time (filesystem, databases, APIs, code execution) over streamableHttp or SSE - Document RAG with hybrid Transformers.js vector embeddings + BM25 keyword search, fully client-side - WebGPU offline mode — run Llama, Qwen, Phi, Gemma entirely in the browser, no API key, no internet - Connect any provider: OpenAI, Anthropic, Groq, Gemini, Mistral, DeepSeek, Ollama, LM Studio — swap anytime, your workflows follow - API keys encrypted AES-256-GCM, never leave your browser - Workspace syncs to a real folder on disk as plain JSON and Markdown — version control it, edit it in VS Code, take it anywhere
One file. Any browser. Your AI team.
Getting started takes about 60 seconds: download the file, open it, paste any API key, point it at LM Studio/JAN, or load up a model directly into your browser via WebGPU.
Released it publicly last week. Would genuinely love feedback.
Site: https://nemilia.com GitHub: https://github.com/luislopez1212/nemilia
P.S. Nemilia means "to think, to remember, to imagine" in Nahuatl, the language of the Aztecs. Felt like the right name for something that does all three.

value: Show HN: Nemilia – multi-agent AI workspace in a single HTML file, no back end

author: Nemilia


value: luka-thb

value:
Hey HN, I'm Luka. I built Tymeslot — an open-source meeting scheduling platform.
The existing open-source scheduling tools are functional but genuinely ugly. The booking page — the thing your clients actually see — looks like a CRUD form thrown together in an afternoon. I couldn't bring myself to send people to any of them, so I built something where the booking experience feels intentional by default.
Both themes are fully customizable. Live demos here: https://tymeslot.app.
Features: Google/Outlook/CalDAV calendar sync, auto-created video rooms (Google Meet, Teams, or self-hosted MiroTalk P2P), 90+ timezones, webhooks, n8n automation, embeddable widget, SSO via OIDC.
Built on Elixir + Phoenix LiveView. Self-host via Docker, Cloudron, or Railway — or use the managed cloud (free tier, Pro at EUR 5/month). License is ELv2.
I am happy to make this the leading open-source calendar solution over time. Check Github, I develop actively. What do you expect from a calendar and scheduling tool to switch?

value: Show HN: Tymeslot – Open-source cal.com alternative built with Elixir/Phoenix

author: luka-thb


value: kenryu

value: Show HN: Ralph Review – OSS code review that loops fixes until no issues remain

author: kenryu


value:
I’ve been working on LPBacked.com, a database of limited partners that invest in venture funds.
If you’ve ever tried to figure out who actually invests in VC funds, you probably know how messy the data is. LP information is scattered across SEC filings, university reports, press releases, and random PDFs. There’s no simple place to search it.
LPBacked tries to pull that information together and make it searchable.
Right now you can:
Browse LPs (family offices, endowments, pensions, foundations, fund-of-funds, etc.)
See which venture funds they’ve invested in
Filter by LP type
Export the data
The original motivation was helping emerging managers find potential LPs, but I’ve also found it useful for research and just understanding how capital flows in venture.
It’s still early and the dataset is growing. I’m continuing to add LPs and fund relationships as I find them

value: Show HN: LPBacked – Find and connect with limited partners behind venture funds


value: rayanht

value:
Hey HN, I built msplat because I wanted to train 3DGS scenes on my Mac without pulling in torch. Most ports I came across go through autograd and hence come with ~2GB of framework overhead, which felt overkill for a pipeline that's just a few dozen GPU kernels + an optimizer.
So I wrote the whole training pipeline from scratch as Metal shaders: projection, tile-based rasterization, SSIM loss, backward pass, Adam, and densification. Everything runs on the GPU
msplat trains 7k iterations of full-resolution Mip-NeRF 360 scenes in ~90s on my M4 Max. In the README I compare against gsplat's published numbers, which were measured on a TITAN RTX. Ofc these are different hardware classes, so take the wall-time comparisons with a grain of salt
Python bindings are on PyPI (pip install msplat), and there are Swift bindings if you want to embed this in a native app. Happy to answer questions about any of the internals
Repo: https://github.com/rayanht/msplat (Apache 2.0)

value: Show HN: Msplat – 3D Gaussian Splatting training in ~90s on M4 Max, native Metal

author: rayanht


value: Show HN: My first project, a native Win32/C++17 assistant with zero dependencies


value: vadepaysa

value: Show HN: Cook – A portable terminal AI agent (OSS, MIT)

author: vadepaysa


value: Show HN: In 2026, I'm building a conversational WordPress form plugin


value: alexlitovsky

value:
Fetch control in JPA has always been a mess. Eager loading kills performance the moment your object graph gets non-trivial. Lazy loading hands you N+1 problems and `LazyInitializationException` as a reward for doing the right thing.
Most serious projects I've seen land in one of two places: lazy + proliferation of nearly-identical queries that differ only in what they fetch, or they give up on mapping relationships altogether and treat their relational DB like a document DB. The others either have these performance issues, or don't yet know that they have them.
`EntityGraph` looked like it was finally going to fix this. Call-site fetch control, no more one-size-fits-all fetch strategies — great idea. But the API they gave us sucks. If you've ever tried to use it, you know what I mean. In fact, I've yet to see any actual uses of it in real production apps.
So I built the API I wish the spec had given us. Since we can't change the spec, this was the next best thing — it extends and mimics the `EntityManager` API, but makes fetch control a first-class concern rather than an afterthought bolted on via `EntityGraph`. You express fetch paths as generated QueryDSL path varargs — compile-time checked, refactor-safe, and composable:

  entityFinder.find(Person.class, id,
      QPerson.person.organization().country(),
      QPerson.person.role());

It also works with JPA metamodel attributes, but that API is clunkier because the metamodel spec never gave us composable paths like QueryDSL did.

  Person person = entityFinder.find(Person.class, id,
          FetchPaths.of(Person_.organization, Organization_.country),
          FetchPaths.of(Person_.role));

The library builds and merges the `EntityGraph` for you at runtime. Same idea works for inline JPQL and named queries via a fluent `TypedQuery`-compatible API.
https://github.com/alterioncorp/jpa-fetch
I've been using this concept in various forms in production since EntityGraphs were first introduced. Finally decided to clean it up and put it out there. Maybe others find it useful.

value: Show HN: JPA fetch control that doesn't suck

author: alexlitovsky


value:
Hi HN,
I’ve been experimenting with building a local AI agent system that can actually perform tasks on the machine instead of just responding with text.
SamarthyaBot is a self-hosted AI agent that runs locally and focuses on automation and privacy.
Some things it can do:
• run terminal commands
• deploy projects to servers via SSH
• control browsers using Puppeteer
• send emails
• run autonomous background tasks
• support multiple LLM providers (Gemini, Ollama, etc.)
The goal is to treat it more like a local automation OS rather than just a chatbot.
Tech stack:
Node.js (gateway)
Go worker (terminal execution)
MongoDB (encrypted memory)
React dashboard
I built it mainly to experiment with agent architectures and local AI workflows.
Would love feedback from the community.

value: Show HN: SamarthyaBot – a privacy-first self-hosted AI agent OS


value: hackiku

value: Show HN: Venus flight simulator to train LLM pilots (~2% vs. 1985 Soviet data)

author: hackiku


value: Most online form builders claim to be free, but their free tier is usually very limited - with unremovable branding, response limits, and many other restrictions.<p>Form81 is simply free, no paid plans, no catch.

value: Show HN: Form81 – 100% free form builder (free Typeform alternative)


value:
I built a free open source alternative to Right Zoom for Mac.
it makes the green zoom button maximize windows instead of going fullscreen.
Dock and menu bar stay visible, click again to restore. Works with any app.
GitHub: https://github.com/Michele0303/open-right-zoom

value: Show HN: Open Right Zoom, Open Source Alternative to Right Zoom for macOS


value: quinndupont

value: First application is free! Validated results by multiple experienced recruiters. Let me know if there are additional features you would like to see.

value: Show HN: JobApplicator (tailored job applications in minutes)

author: quinndupont


value: rofko

value: Show HN: 3D Sokoban, Built in CSS

author: rofko

title: Show HN: 3D Sokoban, Built in CSS


value: vigo

value: We built SecretDrop to avoid sharing secrets over Slack, email, or messaging apps. It’s a simple, self-hostable secret sharing tool with encrypted storage and expiring links.

value: Show HN: SecretDrop – Open-source encrypted secret sharing (MIT)

author: vigo


value: mikehostetler

value:
Hi HN!
I'm the author of an Elixir Agent Framework called Jido. We reached our 2.0 release this week, shipping a production-hardened framework to build, manage and run Agents on the BEAM.
Jido now supports a host of Agentic features, including:
- Tool Calling and Agent Skills
- Comprehensive multi-agent support across distributed BEAM processes with Supervision
- Multiple reasoning strategies including ReAct, Chain of Thought, Tree of Thought, and more
- Advanced workflow capabilities
- Durability through a robust Storage and Persistence layer
- Agentic Memory
- MCP and Sensors to interface with external services
- Deep observability and debugging capabilities, including full stack OTel
I know Agent Frameworks can be considered a bit stale, but there hasn't been a major release of a framework on the BEAM.  With a growing realization that the architecture of the BEAM is a good match for Agentic workloads, the time was right to make the announcement.
My background is enterprise engineering, distributed systems and Open Source. We've got a strong and growing community of builders committed to the Jido ecosystem.  We're looking forward to what gets built on top of Jido!
Come build agents with us!

value: Show HN: Jido 2.0, Elixir Agent Framework

author: mikehostetler


value: rjkaes

value:
Claude Code's built-in Edit tool uses string matching. To change five lines, the model echoes back those exact lines as `old_string`, then provides the replacement. That echoed text is pure overhead (it's already in the file) and it's spending output tokens, the most expensive token class, just to say "I mean this part."
For a typical 15-line edit, that's ~200 wasted output tokens. Do a few dozen edits in a session and you're burning real money on text the model already knows is there. Worse, if `old_string` appears more than once in the file, the edit fails and the model has to pad extra context lines until the match is unique.
I built an MCP plugin that replaces string matching with line-range references and hash verification. The model says which lines to replace, proves it read them correctly with a checksum, and provides only the new content. A 15-line edit goes from ~470 output tokens to ~263.  That's a 44% reduction. If the file changed since the last read (you saved in your editor, another tool touched it), the hash check catches it instead of silently applying a stale edit.
Install is two commands:

    /plugin marketplace add rjkaes/trueline-mcp
    /plugin install trueline-mcp@trueline-mcp

Session hooks automatically redirect the agent to use trueline tools.
Inspired by Can Boluk's "The Harness Problem" and Seth Livingston's vscode-hashline-edit-tool for VS Code.
Blog post with more detail: https://www.wormbytes.ca/2026/03/04/trueline-mcp-announcemen...

value: Show HN: Trueline – Hash-verified edits save 44% of Claude's output tokens

author: rjkaes


value: popupeyecare

value:
Hi HN,
I kept running into the same small problem: important documents would live in my email forever because I never got around to filing them in Google Drive.
Receipts, PDFs, contracts, travel docs, etc.
When I actually needed something later, I’d spend way too long searching through Gmail.
So I built a small tool for myself: KeepFiled.
The workflow is simple:
 1. Forward an email
 2. The attachment is saved to your Google Drive
 3. It gets renamed and placed into the appropriate folder automatically
No downloading files, renaming them, or uploading manually.
I’ve been using it personally and it’s been surprisingly helpful for keeping documents organized without thinking about it.
Would love feedback from the HN crowd.

value: Show HN: KeepFiled – forward an email and it automatically files in Google Drive

author: popupeyecare


value: bnishit

value:
Hi HN,
I kept rebuilding the same OpenRouter integration across side projects – model discovery, image generation, cost tracking via the generation endpoint, routing with fallbacks, multimodal chat with PDFs. Every time I'd start fresh, the agent would get some things right and miss others (wrong response parsing, missing attribution headers, etc.).
So I packaged the working patterns into a skill – a structured reference that AI coding agents (Claude, Cursor, etc.) read before writing code. It includes quick snippets, production playbooks, Next.js and Express starter templates, shared TypeScript helpers, and smoke tests.
I'm a PM, not a developer – the code was written by Claude and reviewed/corrected by me. Happy to answer questions about the skill format or the OpenRouter patterns.

value: Show HN: OpenRouter Skill – Reusable integration for AI agents using OpenRouter

author: bnishit


value: jaredwaxman

value: Show HN: Pre-execution verification for LLM-generated agentic workflows

author: jaredwaxman


value: kashishhora

value:
Chrome recently shipped navigator.modelContext in Early Preview. It's a browser API that lets any website expose typed, callable tools to AI agents.
I built webmcp-react because we wanted a simple way to add tools to our React app and figured others could benefit from it as well. You wrap your app in <WebMCPProvider>, call useMcpTool with a Zod schema, and that's it. Handles StrictMode, SSR, dynamic mount/unmount, and all of the React lifecycle.
It also comes with a Chrome extension in the repo that acts as a bridge for MCP clients (Claude Code, Cursor, etc.), since they can't access navigator.modelContext directly. Once Chrome ships native bridging, will depracate the extension.
I expect the spec may evolve, but contributions, feedback, and issues welcome!

value: Show HN: Webmcp-react – React hooks that turn your website into an MCP server

author: kashishhora


value: GiornoJojo

value:
Tired of seeing all these vibe-coded websites, we created a place where they can battle each other to survive the fury of the crowd from the old times.
We promise roasts, we promise reach — it’s up to you to chase eternal glory.
Guaranteed meltdown (non-refundable)

value: Show HN: Glad-IA-Tor – Roast vibecoded products trying to get some Reach

author: GiornoJojo


value: jahala

value:
Smart code reading for humans and AI agents. Tilth is what happens when you give ripgrep, tree-sitter, and cat a shared brain.
--
v0.4.4: Added adaptive 2nd-hop impact analysis to callers search — when a function has ≤10 unique callers, tilth automatically traces callers-of-callers in a single scan. First full 26-task Opus baseline (previously 5 hard tasks only). Haiku adoption improved from 42% to 78%, flipping Haiku from a cost regression to -38% $/correct.
v0.4.5: Bumped TOKEN_THRESHOLD from 3500 to 6000 estimated tokens (~24KB), so mid-sized files return full content instead of an outline that agents then read back via 5–7 sequential --section calls. Fixed two major regressions: gin_radix_tree (+35% → ~tie) and rg_search_dispatch (+90% → -26% win). Sonnet hit 100% accuracy (52/52) and -34% $/correct overall.
--
https://github.com/jahala/tilth/
Full results: https://github.com/jahala/tilth/blob/main/benchmark/README.m...
-- PS: I dont have the budget to run the benchmark a lot (especially with Opus), so if any token whales has capacity to run some benchmarks, please feel free to PR results.

value: Show HN: Reduce LLM token use by ~30% with this MCP/CLI tool(Claude benchmarked)

author: jahala


value: lmohseni

value:
So, I've never written a line of Rust in my life. I wouldn't know an `&mut this` from a mutandis. But I saw a tweet about a month ago that said, in this new era of AI, you'd be able to just take a library that you love, throw a TUI around it, and call it an app. So here's what I came up with:

  Imbolc is a DAW that runs entirely in your terminal. It talks to scsynth over OSC and ships 58 instruments and 39 effects. VSTs are a work in progress, also GarageBand loops if you want to recreate "Umbrella".

  I used Opus and Codex mainly, but sometimes I had them drive Gemini when I was low on tokens.  Some prompts that worked well: "Looking at this codebase, what looks like an obvious retrofit?" "Where can we lean on the compiler?" "Where is it frustrating to work on this codebase". After an agent completed a task, I'd interview it — where did you have trouble, what felt like a hack, what would you do differently. v1 was clojure, v2 was java, v3 is rust. v4 will be stones and sticks.

  So nowadays out here in the deep future, I think programming will become a matter of taste.  Here's what I think demonstrates my sensibilities:

  - Accessibility: This is what I'm most proud of.  TUIs are usually terrible for screen readers. In Imbolc, every action in the UI is available as a typed command (after I started typing this up I thought, is that true?  turns out it wasn't, so now the compiler enforces this.).

  - LAN collaboration: Multiple people can connect to a shared session over the local network and share midi clock, tuning, effects buses, etc.  Audio is never sent over the network.

  - Weird musical choices: With the "Global" just intonation setting, your absolute tuning can drift over time. I was thinking about how an accordion looks kind of like a qwerty keyboard, so I added a quasi Stradella layout. A432 by default, and so on.

  - Command palette, themes, keybindings, Diataxis docs.

  It requires SuperCollider installed (scsynth on PATH). macOS and Linux 1st class, BSDs are next on the roadmap, no Windows.

  It's still alpha, there are plenty of rough edges. But it is genuinely fun to dink around on, I'd love to know what you all think.

https://github.com/mohsenil85/imbolc
https://imbolc.studio

value: Show HN: Make beats, produce music from the command line

author: lmohseni


value: PureMeditate

value:
The Backstory:
I'm a software engineer with anxiety, and I meditate regularly to manage it. I’ve been using Calm, but their price keeps going up. And they also require accounts and collect usage data, which I’m not a fan of as a privacy-focused developer.
The Why:
I wanted something simple, private, subscription-free with a nice looking interface but couldn’t find one that matched exactly what I wanted. So as a side project, I built one for myself and my wife called Pure Meditate.
She ended up showing it to a few friends, and the ones who tried it via TestFlight really liked it. Especially the no subscription part. I figured there were probably others who would too. So, today I'm showing it off for the first time.
I'm curious to hear feedback from the HN community. Please don't be too brutal :)

value: Show HN: I built a simple meditation app because I was tired of subscriptions

author: PureMeditate


value: ksri

value:
ExtraSuite is a terraform like tool for google drive files - sheets/docs/slides/forms/app scripts. It is meant for agents to make targeted edits to files.
While ChatGPT / Claude etc can create the initial versions of the files, the real complexity is in the workflow after the initial version. Team members add comments to provide feedback, or you decide several days later to make minor edits. Re-generating the entire sheet or doc is just not feasible. Our team members resorted to manual edits.
We looked around for a library to edit google drive files. We found gspread for google sheets - and our first version used it. It worked well - but it used way too many tokens. Every change required writing python code. This led to the first version of `extrasheet` - which pulls a spreadsheet and converts it into data.tsv, formula.json and several other files. Initial versions duplicated the formula in every cell for a column; subsequently we detected a formula was the same for a range and automatically compress it. Result - our teams were able to make more complex excel models, make targeted edits and perform analysis using fewer tokens and less capable models.
Subsequently, we followed the same approach for google docs. This turned out WAY COMPLEX. The batchUpdate API for google docs in insanely complex - you have to painstakingly compute the index. `extrasuite doc push` now detects changes, computes indexes, resolves internal dependencies and ultimately pushes the changes only to google docs.
As usage increased, we added google slides (this is pre-alpha), google forms, and even app scripts - all using the same pull-edit-push workflow.
One more differentiator is the usage of service accounts for the agent. The SA has no permissions other than the ability to read/comment/edit the specific files that have been shared with it. This means that agent edits are completely auditable. It is clear to everyone in the team that "Alice used her agent to write this document" - because it shows up clearly in the documents version history.
To achieve this service account, we deploy a lightweight gateway server that mints 1:1 service accounts per employee on demand. This isn't scalable as there are limits to how many service accounts you can create in a google cloud project (typically 100) - but this hasn't been a problem for us as yet.
The gateway server is strictly optional. You can download service account JSON keys and use it to authenticate if you wish, but we dislike giving keys to employees. A gateway server simplifies the workflow significantly for non-tech users.
Try it out, and hopefully it is of use to others.
P.S. This complements gog and gws, does not replace it. Neither of those tools has a workflow to perform in-place complex edits in a declarative manner.

value: Show HN: ExtraSuite – pull / push for Google Drive

author: ksri


value: prunax

value:
I built hugpoint.io to solve a specific problem: when a group tries to decide where to meet, the first person to suggest somewhere implicitly anchors the decision around their own location.
Everyone else agrees to avoid friction. Someone ends up with a disproportionate commute. Nobody mentions it.
The tool calculates each person's reachable zone using real transit data (not straight-line distance), finds the intersection, and surfaces Google Places results inside that overlap — ranked by a Fairness Score that measures how equally reachable a venue is for everyone in the group.
Technical decisions worth discussing:
Isochrone-based rather than Euclidean midpoint — crow-flies distance is meaningless in a city with asymmetric transit
Per-person travel mode support — one person cycling, another on the Subway, a third driving
Session state serialised to URL hash so any search is shareable without accounts
Built entirely with AI tools as a non-technical founder — happy to talk about that process if useful
No accounts, no paywall, works in the browser.
Would genuinely appreciate feedback on the technical approach and any edge cases you'd throw at it.
hugpoint.io

value: Show HN: hugpoint.io – Find the fairest meeting spot for a group

author: prunax


value: theahura

value:
We wrote a linter for our own internal use, and today we decided to open source it.
SKILLs are the easiest way to configure agents, and you can get a lot of juice from a few well written SKILL files. Unfortunately, most SKILL files are not well written. They are way too long, they waste tokens explaining things that the model already knows, and many don't even follow the agentskills.io spec.
Linters help automate low hanging fruit changes that we find we constantly need to make.
You can run the linter as a one-liner:
`npx nori-lint lint path/to/SKILL.md` or
`npx nori-lint fix path/to/SKILL.md`
SKILL files are hard to lint deterministically, so there are several rules that require an LLM to do part of the review. You can set up a .nori-lint.json file to include an Anthropic API key, which will kick off a bunch of llm analysis rules.

value: Show HN: A Linter for Skill.md Files

author: theahura

title: Show HN: A Linter for Skill.md Files


value: ConvertlyAI

value:
Hey HN,
I built ConvertlyAI (https://convertlyai.online) to solve my own post-production bottleneck. As a writer and creator, I found that producing the core content—whether a long-form manuscript or a video—was only half the battle. Chopping that single piece of content up into highly specific formats for Twitter threads, LinkedIn carousels, and newsletters was causing massive burnout.
I wanted a system where I could upload a raw YouTube transcript or an MP3, and have an engine strictly format it for 10 different platforms without losing the core message or sounding like a robot.
How it works under the hood:
The stack is Next.js, Supabase, and the OpenAI SDK (GPT-4o).
The biggest challenge wasn't generating text; it was preventing the AI from generating garbage text. I spent a lot of time engineering strict system-level guardrails to force the model to be "High Signal, Low Noise."
Banned Vocabulary: I hardcoded rules to strip out generic AI fluff words (e.g., "Unlock," "Delve," "In today's fast-paced world," "Supercharge").
Strict Formatting: Each of the 10 outputs has a dedicated sub-prompt. For example, the Twitter thread logic forces "1/X" numbering and bans hashtags in the hook, while the LinkedIn logic strictly formats text for slide carousels.
Audio Processing: I built a transcription pipeline so users can just upload raw MP3s if they don't have text ready.
I'm currently dogfooding the product to automate my own content distribution and running a credit-based billing system to manage the compute costs for the AI and audio processing.
I would love for you to tear it apart. I'm specifically looking for feedback on:
The UI/UX of the dashboard when managing saved "Magic Prompts."
The strictness of the output formatting—if you run a transcript through it, does it actually sound human to you?
Happy to answer any questions about the prompt engineering, the tech stack, or the API routes!

value: Show HN: ConvertlyAI – Format raw transcripts into 10 social assets

author: ConvertlyAI


value: roblevintennis

value:
I’ve spent the last few years building AgnosticUI. It started as a CSS-first monorepo with logic manually duplicated across framework packages. It turned into a maintenance nightmare.
I recently completed a total rewrite in Lit to align with web standards and unify the core. One major architectural shift was moving to a "Source-First" model. Instead of a black box in node_modules, the UI source lives in your local project workspace.
This makes the components fully visible to LLMs, preventing the hallucinations common when AI tries to guess at hidden library APIs. I wrote a technical post-mortem on Frontend Masters detailing the hurdles of this migration (Shadow DOM a11y, Form Participation, and @lit/react vs React 19): https://frontendmasters.com/blog/post-mortem-rewriting-agnos...

value: Show HN: AgnosticUI – A source-first UI library built with Lit

author: roblevintennis


value: kanddle

value:
AI coding agents generate decent code. The problem is everything around the code - checking progress, catching drift, deciding if it's actually done. I spent months trying to make autonomous agents work. The bottleneck was always me.
Attempt 1 - Claude/GPT directly: works for small stuff, but you re-explain context endlessly.
Attempt 2 - Copilot/Cursor: great autocomplete, still doing 95% of the thinking.
Attempt 3 - continuous agents: keeps working without prompting, but "no errors" doesn't mean "feature works."
Attempt 4 - parallel agents: faster wall-clock, but now you're manually reviewing even more output.
The common failure: nobody verifies whether the output satisfies the goal. That somebody was always me. So I automated that job.
OmoiOS is a spec-driven orchestration system. You describe a feature, and it:
1. Runs a multi-phase spec pipeline (Explore > Requirements > Design > Tasks) with LLM evaluators scoring each phase. Retry on failure, advance on pass. By the time agents code, requirements have machine-checkable acceptance criteria.
2. Spawns isolated cloud sandboxes per task. Your local env is untouched. Agents get ephemeral containers with full git access.
3. Validates continuously - a separate validator agent checks each task against acceptance criteria. Failures feed back for retry. No human in the loop between steps.
4. Discovers new work - validation can spawn new tasks when agents find missing edge cases. The task graph grows as agents learn.
What's hard (honest):
- Spec quality is the bottleneck. Vague spec = agents spinning.
- Validation is domain-specific. API correctness is easy. UI quality is not.
- Discovery branching can grow the task graph unexpectedly.
- Sandbox overhead adds latency per task. Worth it, but a tradeoff.
- Merging parallel branches with real conflicts is the hardest problem.
- Guardian monitoring (per-agent trajectory analysis) has rough edges still.
Stack: Python/FastAPI, PostgreSQL+pgvector, Redis (~190K lines). Next.js 15 + React Flow (~83K lines TS). Claude Agent SDK + Daytona Cloud. 686 commits since Nov 2025, built solo. Apache 2.0.
I keep coming back to the same problem: structured spec generation that produces genuinely machine-checkable acceptance criteria. Has anyone found an approach that works for non-trivial features, or is this just fundamentally hard?
GitHub: https://github.com/kivo360/OmoiOS
Live: https://omoios.dev

value: Show HN: OmoiOS–190K lines of Python to stop babysitting AI agents (Apache 2.0)

author: kanddle


value: moshemalawach

value:
LiberClaw is an open-source platform for deploying AI agents that run around the clock on dedicated virtual machines. You define what an agent does with markdown skills file, deploy it, and it keeps working whether you're at your desk or not. The agent system code is on GitHub: https://github.com/Libertai/liberclaw-agent
There are 61 agents running on the platform right now across 578 conversations, with 99.7% uptime. Each agent gets its own VM with its own filesystem, database, and HTTPS endpoint. Inference runs through open models (Qwen3 Coder, GLM-4.7) so there are no API keys to manage from OpenAI or Anthropic.
Agents have persistent memory across conversations, a heartbeat system for background tasks, and real tools: bash, file operations, web fetch, web search, and the ability to spawn subagents for parallel work. You can build code review bots, research agents, personal assistants, monitoring tools — anything that benefits from running continuously.
Free tier is 2 agents, no credit card. Deployment takes under 5 minutes.
- App: https://app.liberclaw.ai
- Source of the agents: https://github.com/Libertai/liberclaw-agent
If there are requests and an appetite for it, I can opensource the platform code too (it manages a pool of prepared VMs on aleph cloud and gives them to users as they request one).

value: Show HN: LiberClaw, deploy AI agents that run 24/7 on their own VMs

author: moshemalawach


value: lightsofapollo

value:
I use Claude Code as my primary dev environment. It generates a lot of markdown. Planning docs, architecture notes, task lists. I wanted something purpose-built for reading markdown. Not a browser tab, not a preview pane in an editor. A real app I can launch from the terminal.
VS Code's markdown preview is fine but I don't really use VS Code. I wanted something Claude Code could launch for me and get a nice readable window.
So I built attn. One command, OS webview window, under 20MB. No Electron, no bundled Chromium.
Some things that ended up being useful:
npx attnmd README.md and it just works. Rust binary distributed through npm so you don't need cargo or a homebrew tap.
Live reload. I'm reading a plan while the agent is still writing it. Save the file, see it update.
Full ProseMirror editor with syntax highlighting, math, and mermaid. I annotate plans inline without opening another tool.
Mermaid diagrams render inline. Agents love generating mermaid.
Stack: Rust (wry/tao wrapping the OS webview — WebKit on macOS, WebKitGTK on Linux), Svelte 5 + ProseMirror frontend compiled by Vite and embedded into the binary at build time.
npx attnmd README.md to try it, cargo install attn to build from source. MIT licensed, source at github.com/lightsofapollo/attn.

value: Show HN: Attn – Markdown viewer and editor in a <20MB binary (Rust)

author: lightsofapollo


value:
I'm the developer. I built this because every time I reached for the mouse to check off a todo, it broke my flow.
[Why]
5 years of coding on Mac. I tracked tasks in Notion and Jira, but the actual work — the atomic actions under each task — lived as checkboxes. I wanted to know how long each one took. todoglow isn't a replacement for your task tracker. It sits next to it — you break a task into atomic todos, work through them, and see how long each one actually takes. And if todos are small enough, you don't need categories, tags, or priorities. So I built an app that deliberately has none of those. No UI buttons either — I kept asking "is this actually necessary?" and usually the answer was no. (If you grew up on PC games, the keybind-driven UX might feel familiar.)
[How it works]
Working in your editor → Ctrl+Cmd+/ (summon todoglow) → / → type → Enter (start) → Ctrl+Cmd+. (focus bar — a thin strip above all windows showing your current todo) → back to work → Ctrl+Cmd+/ → a (jump to active todo) → Enter (complete).
Only one todo can be "in progress" at a time — the app enforces that.
[MCP]
Ships with an MCP server (stdio + HTTP). Agents can add todos, update status, report progress. The app is a target, not a platform.
[What I got wrong]
Shortcuts were US-keyboard-only. I didn't think about it. European users on QWERTZ and AZERTY couldn't hit half the keys — one of them printed out a US keyboard layout to use the app. But they stuck with it and kept reporting issues. Added keyboard layout selection. One user needed HTTP transport for Alter — added it. No mobile app yet, but there's a command mode that pushes to Apple Reminders for iPhone notifications.
[Other]
Idle-aware time tracking. Tauri v2 (Rust + React). macOS only.
https://devglow.app/todoglow

value: Show HN: Todoglow – Keyboard-first todo app for macOS with MCP support


value:
Hi HN,
I built Sift because maintaining raw Regular Expressions in Java is notoriously error-prone and hard to read.
Sift is a fluent DSL that guarantees valid regex syntax at compile time using a strict Type-State machine. Your IDE auto-completion only suggests methods that are syntactically valid at that specific step.
It features immutable thread-safe builders, modular "LEGO-style" composition for reusable patterns, and lazy validation for backreferences across disconnected blocks.
I'd love your feedback on the API design and the state-machine architecture!

value: Show HN: Sift – Write readable and type-safe regular expressions in Java


value: rakeshgoyal

value:
We built a Claude Code plugin for Velt that installs real-time
collaboration into any app in under 10 minutes.
What gets installed in one command:
- CRDT (live document sync)
- Contextual comments & threaded replies
- Live presence & cursors
- In-app notifications
- Reactions
The problem we kept seeing: engineering teams know they need
collaboration features. They also know how long it takes to
build right. CRDT alone is a multi-week project. So it either
gets deprioritized forever or ships half-baked.
We've been building this infrastructure for 3 years.
Pendo, HeyGen, and LambdaTest use it in production.
The Claude Code plugin is our attempt to make the installation
feel as simple as the API already is.
Demo video: https://www.youtube.com/watch?v=JpfKRu65DTk
Docs: https://docs.velt.dev/get-started/plugins
SDK: https://velt.dev/
Happy to answer questions about how the CRDT layer works,
the MCP integration, or anything else.

value: Show HN: Claude Code plugin that adds CRDT collaboration to any app in 10 min [video]

author: rakeshgoyal


value: claudeviolin

value: DumbClaw is a deliberately simple AI assistant bot — the "dumb" version of OpenClaw. No framework magic, no abstractions for the sake of it. Every feature lives in one readable file. If you want to add something new, you should be able to vibe-code it in minutes.

value: Show HN: DumbClaw, dumb and simple version of OpenClaw

author: claudeviolin


value: Show HN: Bb – Windows through a detective's lens


value: jbdamask

value:
I swear by Yegge's Beads https://github.com/steveyegge/beads. Just love it. One of the things Steve talks about in his best practice guide is that the only things that belong in Beads are things that are being actively worked on; it's not a backlog.
I also really like Claude's planning mode, except for the fact that it's tightly coupled with execution.
A pattern I've found is to work in different loops: a planning loop and an execution loop.
Planning loop:
1. Use GitHub issues for backlog items. Whenever I get an idea, I just make an issue with minimal detail.
2. Pull issue into Claude Code
3. Create branch
4. Use a home-grown planning skill that reads the Issue and operates pretty much the same way as Claude's but without the straight-to-execution annoyance
5. Once the plan is finalized, decompose it into Beads
6. Check in branch and tag as "ready"
Execution loop:
Watch GitHub for "ready" issues. When one is found, checkout a worktree then start building. All the beads are self-contained in the issue so there's no need for more discussion with the LLM.
I turned the planning phase into a Claude plugin that I can invoke with a slash command, /beads-planner issue 44. The execution loop can be ralph or even just interactive CC sessions.
Everyone is coming up with their own way to build but figured I'd share because this works for me. YMMV

value: Show HN: Beads planner plugin for Claude Code

author: jbdamask


value: macnorton

value:
Hi HN,
I built OXPT because I was tired of the "Linear Chat Prison" of current LLM interfaces. Whenever I try to implement complex logic like Self-Reflection or Tree-of-Thought, I lose track of which branch worked best.
It’s a visual playground where you can:
Branch your thoughts: See multiple AI responses side-by-side on a non-linear canvas.
Version control for prompts: Save and compare every iteration instead of scrolling through endless chat history.
Modular Logic: Treat prompts like building blocks.
I wanted a more systematic way to manage my own prompt experiments.
I' d love some brutal technical feedback from this community. What do you think about the node-based UI compared to traditional list-based chats?
(P.S. The logo was inspired by a drawing my son made for me!)
https://www.oxpt.online/assets/images/scr_01.png
https://www.oxpt.online/assets/images/scr_02.png
https://www.oxpt.online/assets/images/scr_04.png

value: Show HN: OXPT – Visual branching canvas for prompt versioning (Korean support)

author: macnorton


value: tuxnotfound

value: Show HN: CodeConvert – Developer Conversion Tools (JSON→TS, YAML↔JSON, etc.)

author: tuxnotfound


value:
Montage is a fork of Remotion's NextJS template, set up for coding agents to quickly produce motion graphics videos.
In May 2025 I commissioned a team of motion designers to create a launch video. It cost us $2000 and 4-5 days of my full attention.
I noticed the video was likely built using a set of animations and transitions that this motion design team reused for all their customers. My theory was that if I could recreate that set of animation primitives and put them in a format coding agents could understand, I'd be able to create launch videos end-to-end way faster and have full control over the final product.
I spent 3 days setting up the repo and 4 hours building the motion video you see above. Those 3 days consisted of 1) building out the set of primitives and 2) building the iterative agent rendering loop so the agent could work autonomously.
The primitives I built were:
Text (word drag-in, flip-up, gradient fill, typing animation)
Motion (object pop in, fade right, fade left, swoop, float, etc.)
React components (logo, cursor, animated browser, animated terminal)
Background designs (radial gradient, corner gradient, color fade, etc.)
The way I built these primitives was surprisingly simple. I leveraged Gemini's ability to analyze videos (Claude and GPT don't accept videos as a modality yet) by attaching the previous motion-designed video and giving it this prompt:
"Is it possible for you to thoroughly go throughout the video and, in detail, note all the different text transitions and what they look like, describing them in natural language so I can put them in my animation tool?"
It gave me a text file which I dumped into a coding agent (in my case Claude Code) to build animation primitives with. I repeated that for motion transitions and background designs, and modified existing React components to work with Remotion.
For building the iterative agent rendering loop, I gave the agent the ability to test its sections end to end.
Remotion can render individual frames via a bash command (npx remotion still {flags}) so I put in the AGENTS.md to heavily use that when designing sections. I also tried having the agent browser-use the Remotion editor spun up as a local dev server, but this was too confusing — it had to know how to scrub through frames in the UI, select the right sequence to check, etc. So I ended up sticking with the  Bash command and found that coding agents could do a decent job testing animations by rendering frames 10-20 steps apart.
I'd love for you to try this out and welcome any feedback. Montage has really helped me create high-quality motion videos (an example is in the repo).

value: Show HN: Montage – Quickly build product launch videos with coding agents


value: solhuang

value:
Hi HN,
I thought it would be fun to plot a traceroute on a map to visually see the path packets take. I know this idea has been done before, but I still wanted to scratch that itch.
The first version just let you paste in a traceroute and it would plot the hops on a map. Later I discovered Globalping (https://globalping.io), which allows you to run traceroutes and MTRs from probes around the world, so I integrated that into the tool.
From playing around with it, I noticed a few interesting things:
• It's very easy to spot incorrect IP geolocation. If a hop shows 1–2 ms latency but appears to jump across continents, the geolocation is probably wrong.
• Suboptimal routing is sometimes much easier to notice visually than by just looking at latency numbers.
• Even with really good databases like IPinfo, IP geolocation is still not perfect, so parts of the path may occasionally be misleading.
Huge credit to the teams behind Globalping and IPinfo — Globalping for the measurement infrastructure and IPinfo for the geolocation data.
Feedback welcome.

value: Show HN: Tracemap – run and visualize traceroutes from probes around the world

author: solhuang


value: OmarPrampolini

value:
After watching too many "privacy" apps get subpoenaed or shut down, I wanted a communication tool that literally cannot be shut down because it has no servers to seize.
Ouroboros is a Rust-based P2P stack with two modes:
1. Live sessions: Two peers connect directly using just a shared passphrase. The passphrase deterministically generates identical network parameters on both sides, so they can find each other without any coordination server.
2. EtherSync spaces: Async file sharing and messaging in encrypted "spaces" that sync via gossip protocol when peers are online.
Key features:
- Post-quantum resistant (Kyber1024 hybrid)
- Works through most NATs (ICE multipath + Tor fallback)
- DPI evasion transports (experimental)
- 0 dependencies on centralized infrastructure
GitHub: https://github.com/omarsomaro/HANDSHAKE
Would love feedback from anyone interested in P2P/decentralized systems!

value: Show HN: Ouroboros – Post-quantum P2P messenger with zero servers

author: OmarPrampolini


value: jpbonch

value:
Hey HN,
I built Selva, a skill (CLI + API) that lets AI agents search for products, compare options, and buy things on your behalf.
How it works:
• Tell your agent what you need ("order more coffee pods" or "find some toothpaste")
• It searches Amazon, finds options, and handles checkout
• You save your card with us via Stripe, your card details never touch our servers and are never seen by your agent
• You set a dollar threshold, anything above it pauses and asks for your approval via email
Why I built this:
I've been wanting to delegate some routine shopping tasks to my agent, but it kept getting stuck on captchas, auth screens, etc. Also didn't want it to have my credit card in its context, so I built this system where the card is stored securely with Stripe and the agent has to email me for purchases above X dollars (configurable).
Details:
• Works as an OpenClaw skill
• Searches across Amazon and Shopify stores
• Handles the messy parts of e-commerce and browser operations so your agent doesn't have to deal with it
• Email notifications for shipping and delivery
• USA only for now
What I'm looking for:
Early users to try it and tell me what breaks. Especially interested in feedback on the purchase flow.
Try it: https://www.useselva.com

value: Show HN: Selva – Amazon for AI Agents

author: jpbonch

title: Show HN: Selva – Amazon for AI Agents


value: herrstagl

value:
I built recordsv.lt to explore a problem I ran into as a vinyl collector: once your collection grows, Discogs is great for cataloging but not great for understanding the collection itself.
Recordsv connects to Discogs and analyzes your collection using the full release metadata — not just album titles but pressings, contributors, labels, and release history.
The idea is to surface patterns that are hard to see manually.
Some examples:
* Pressing insights – compares different pressings of the same album and highlights when the version you own might not be the best sounding or most collectible one.
* Contributor networks – maps relationships between artists, producers, engineers, and labels across your collection. You often discover unexpected connections between records.
* Collection analytics – shows patterns in decades, genres, labels, and recording locations across the collection.
* Contextual reviews – aggregates reviews and commentary about specific releases rather than just the album.
Tech stack:
- Next.js
- Discogs API
- vector search for similarity across releases
- AI summarization for reviews and metadata
It’s optimized for large collections (tested with ~2000 records so far).
Curious what other collectors or Discogs users think.
Would also love feedback on what kinds of analysis would actually be useful.
Best, tom

value: Show HN: I built an AI tool that analyzes your Discogs vinyl collection

author: herrstagl


value: smith-kyle

value: Show HN: Tune on a real Boss TU-3

author: smith-kyle

title: Show HN: Tune on a real Boss TU-3


value: arjinexe

value: I built Entropy to solve a specific problem: traditional API scanners often miss business logic flaws because they rely on static attack lists. Entropy uses LLMs to analyze your API schema (OpenAPI/GraphQL) and think like an adversary to generate custom attack sequences.Note: I'm currently fixing a small packaging issue, so "pip install" might be temporarily unavailable for the next few hours. In the meantime, you can run it directly from the source by cloning the repo. I'd love to hear your thoughts and feedback!

value: Show HN: Entropy – API security testing using LLMs to generate attack scenarios

author: arjinexe


value: jiangzhuo

value:
Hi HN, I built Sokuji, an open-source live speech translation app that runs as both an Electron desktop app and a Chrome/Edge browser extension.
The latest release (v0.15) adds Local Inference mode — fully on-device ASR, translation, and TTS using WASM and WebGPU. No API key, no internet, no data leaving your machine. It ships with:
- 48 ASR models covering 99+ languages (sherpa-onnx WASM + Whisper WebGPU)
- 55+ translation language pairs (Opus-MT) plus multilingual LLMs (Qwen 2.5/3/3.5) via WebGPU
- 136 TTS models across 53 languages (Piper, Coqui, Mimic3, Matcha)
For those who prefer cloud providers, it also supports OpenAI Realtime API, Google Gemini Live, Palabra.ai, Volcengine ST, Doubao AST 2.0, and any OpenAI-compatible endpoint.
The browser extension integrates with Google Meet, Teams, Zoom, Discord, Slack, and others — it can capture participant audio and inject translated speech via a virtual microphone.
Tech stack: React + Zustand + Vite, Electron Forge, sherpa-onnx compiled to WASM, HuggingFace Transformers.js for WebGPU inference. Models are downloaded on demand and cached in IndexedDB.
I built this because existing translation tools either require expensive API keys, send your audio to the cloud, or don't support enough languages. The local inference mode makes it practical for privacy-sensitive use cases and for people without reliable internet.
AGPL-3.0 licensed. Available on Windows, macOS, Linux, Chrome Web Store, and Edge Add-ons.
GitHub: https://github.com/kizuna-ai-lab/sokuji
Offical site: https://sokuji.kizuna.ai

value: Show HN: Sokuji – Open-source speech translator with on-device AI WASM/WebGPU

author: jiangzhuo


value: lombarovic

value: Show HN: A modern way to learn an ancient skill–drawing with AI feedback

author: lombarovic


value:
Title: Show HN: PageAgent, A GUI agent that lives inside your web app
Hi HN,
I'm building PageAgent, an open-source (MIT) library that embeds an AI agent directly into your frontend.
I built this because I believe there's a massive design space for deploying general agents natively inside the web apps we already use, rather than treating the web merely as a dumb target for isolated bots.
Currently, most AI agents operate from external clients or server-side programs, effectively leaving web development out of the AI ecosystem. I'm experimenting with an "inside-out" paradigm instead. By dropping the library into a page, you get a client-side agent that interacts natively with the live DOM tree and inherits the user's active session out of the box, which works perfectly for SPAs.
To handle cross-page tasks, I built an optional browser extension that acts as a "bridge". This allows the web-page agent to control the entire browser with explicit user authorization. Instead of a desktop app controlling your browser, your web app is empowered to act as a general agent that can navigate the broader web.
I'd love to start a conversation about the viability of this architecture, and what you all think about the future of in-app general agents. Happy to answer any questions!


value: Show HN: Pylonite, a SQLite-backed Kanban board for AI agents teams (and humans)


value: hackerwhosemans

value: Show HN: Nodes – Open-source decentralized Discord alt with E2E encrypted DMs

author: hackerwhosemans


value: Show HN: I trained a small local model to translate natural language to CLI


value: arishec

value:
I got frustrated spending hours writing cold emails that nobody replied to, so I built ColdPitch.
You type in a company name, pick a contact (it surfaces names, roles, and verified email addresses), and it writes a hyper-personalized cold email tailored to that person's role and your specific goal — in seconds. No CRM required, no extra tools. You just copy the email and send from your own mail client.
It's powered by Claude AI. The personalization is genuine — not just "Hi [First Name]" — it actually writes differently for a VP of Sales vs. a Head of Engineering at the same company.
Free tier is 5 emails/month, no credit card required. Would love feedback from the HN crowd, especially on the personalization quality and anything that feels off.

value: Show HN: ColdPitch – Find anyone, get a personalized cold email in seconds

author: arishec


value: gitprolinux

value: Ask me anything, a finally got it excellent vibe coding project.  I really like the spectrogram visualizer of audio and the video thumbnail selector from anywhere in the media is gorgeous.

value: Show HN: Chatddit.com Fresh off the vibe press

author: gitprolinux