value: webgio

value:
Hi HN,
I’m the author of the Rotativa library for ASP.NET. It’s been almost 14 years since I started that project and 10 years since I launched the SaaS version: rotativa.io, and while it served its purpose for the .NET ecosystem, PDF generation has evolved (and so have the headaches).
I’ve spent the last few months building a new capability for rotativa.io that moves away from the old library pattern. I wanted to create something platform-agnostic that solves the "edit-deploy-test" cycle that makes PDF styling so slow.
The New Approach: Instead of rendering views from your web framework, you use a dedicated web editor to build Liquid templates.
The Editor: Monaco-based with autocomplete for Liquid tags and JSON data, validation, and a real-time side-by-side preview.
The Tech: It uses a modern rendering engine with deep CSS Print support (paging, headers/footers, etc.).
The Workflow: Your backend sends a JSON POST to the API; the API merges it with your stored template and returns a secure download link.
Why the change? > I wanted to decouple the design from the application code. This allows non-developers (or just you, in a different tab) to tweak a layout without a full deployment cycle.
I'd love to hear what you think about the Liquid template workflow vs. the traditional "HTML-to-PDF" library approach.
Thanks,
webgio

value: Show HN: Rotativa.io – Liquid-based PDF templates with a live-preview editor

author: webgio


value: deofoo

value:
My wife was planning to open a micro-bakery and we started looking at software to manage recipes, inventory, orders, and production. Everything was either expensive, too generic, or both. The workflows for a small-batch manufacturer aren’t that complex, but the pricing acts like they are.
So I built Craftplan. All the features were tailored to what she actually needed, and I figured other small-scale manufacturers (soap makers, breweries, candle makers, etc.) probably need the same things. So I’m putting it out there for free.

  - Live demo: https://craftplan.fly.dev (test@test.com / Aa123123123123)
  - GitHub: https://github.com/puemos/craftplan
  - Docs: https://puemos.github.io/craftplan
  - Self-hosting guide: https://puemos.github.io/craftplan/docs/self-hosting/

What it does:

  - Product catalog with versioned recipes (BOMs) and automatic cost rollups across materials, labor, and overhead
  - Inventory tracking with lot traceability, expiry dates, allergen/nutrition flags, and demand forecasting
  - Order processing with calendar-based scheduling and allocation to production batches
  - Production planner with make sheets, material consumption from specific lots, and cost snapshots
  - Purchase orders with receiving workflow that auto-creates inventory lots
  - Basic CRM for customers and suppliers
  - CSV import/export, iCal calendar feed, JSON:API and GraphQL endpoints

Experience building with Elixir, Ash and Liveview:

  - Speed: you get to test and improve things sooo fast. The DSL makes it simple to translate your thinking into live product
  - Extensibility: With Ash + LiveView you can add more features so easily. Adding JSON:API + Grapghql was a few minutes.
  - UX: I believe LiveView makes it simple to deliver great UX since it forcing you to keep things simple with no so much interaction overhead which most of the time means better and simple experience

Self-hosting:

  - Docker image: `ghcr.io/puemos/craftplan` (amd64 + arm64)
  - Docker Compose bundles PostgreSQL 16 + MinIO.

Other details:

  - Email config from UI (SMTP, SendGrid, Mailgun, Postmark, Brevo, Amazon SES)
  - API keys encrypted at rest (AES-256-GCM)
  - Role-based access (admin/staff)
  - Tech stack: Elixir, Ash Framework, Phoenix LiveView, PostgreSQL
  - License: AGPLv3

Feedback welcome (and needed!)

value: Show HN: Craftplan – Elixir-based micro-ERP for small-scale manufacturers

author: deofoo


value:
Hi HN,
I wrote this library so that others can have as good an experience as I have when working on Helm charts. I know that writing Helm charts can be hellish, but my experience in the last few years has been very good, primarily because of fast-running automated tests that provide instant feedback, which makes changes easy.
This library has a common-sense interface that makes it easy to verify the rendered output of your chart, verify your chart’s compatibility with GitOps tools like ArgoCD, and verify that your chart schema includes every value that you reference in your templates.
It has documentation and examples in the GitHub README. Let me know if this looks useful for you! Thanks.

value: Show HN: A Java library for writing Helm chart tests


value: rezabeye

value: Show HN: I built a task manager in the MacBook notch for my ADHD brain

author: rezabeye


value: emaghakyan

value:
Hey HN,
I built genui.sh to make it easy to turn JSON produced by AI agents into something
presentable.
The idea: POST your data → get back a hosted, shareable URL.
No frontend code, no deployment.
Example:
curl -X POST https://genui.sh/api/v1/artifacts/share \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"template": "@std/dynamic", "props": {...}}'
→ Returns: https://genui.sh/a/xxxx_xxxxx
Your agent doesn't pick from templates - it composes UIs from primitives.
Cards, metrics, charts, tables. 20+ components, infinite combinations.
We validate and render server-side.
You can even use Markdown or generate a PDF.
Free tier: 50 artifacts/month
Pro: $29/month for 10,000 artifacts
Built with Next.js, hosted on Vercel, uses Redis for props storage with automatic expiration.
Would love feedback, especially from anyone building AI agents or automation workflows.

value: Show HN: One API call to turn agent output into shareable UI

author: emaghakyan


value: m-hodges

value: Show HN: Federal Election Commission Claude Code Plugin and Agent Skill and MCP

author: m-hodges


value: tskulbru

value:
Hi everyone, I'm Torstein!
I've been building Kvile, an HTTP debugging app built with Tauri 2 (Rust + React).
Some backstory: I've spent too much time fighting with OpenAPI specs that
drift out of sync with reality. Generated clients break, docs lie, and you
end up curling the endpoint anyway to see what it actually returns.
I wanted something simpler - HTTP requests that live right next to the
service I'm working on. Edit a file, send a request, commit it with my code.
No spec generation, no sync issues, no "the docs say X but the API does Y."
That's why Kvile is built around .http files as the source of truth.
Why .http files?

  - Version control: Plain text that diffs cleanly in git
  - No lock-in: Standard format supported by JetBrains, VS Code, and others
  - Docs as code: Requests live in your repo alongside the code they test
  - Share easily: Send a file, not an exported JSON blob
  - Editor freedom: Edit in any text editor, use the GUI when you want it
  - No account required: Your data stays on your machine

I got tired of API clients that store requests in proprietary formats,
require accounts, or try to upsell me on cloud sync. I just wanted to open
a folder of .http files and send requests.
Supports JetBrains HTTP syntax ({{variables}}, ### separators), VS Code
REST Client format, environment files, and dynamic variables.
Built with Tauri 2 - small bundle (~15MB), runs natively on Linux, macOS, and Windows.
Early development (v0.2.1) - feedback welcome.
GitHub: https://github.com/tskulbru/kvile
Personal blog/portfolio: https://tskulbru.dev

value: Show HN: Kvile – Lightweight Postman alternative that uses .http files

author: tskulbru


value: matzie

value:
Hey HN! I built HostsLab, a simple desktop app for managing /etc/hosts and ~/.ssh/config on macOS.
I got tired of manually editing config files every time I needed to map a local domain or add an SSH connection. HostsLab gives you a visual interface to:
- Add/edit/disable host entries (with proper sudo handling)
- Manage SSH connections with dropdowns for existing keys
- Generate new SSH keys (Ed25519/RSA) right from the app
- Everything preserves comments and formatting in your config files
It's built with Electron + React + TypeScript, code-signed and notarized, and fully open source (MIT).
Demo: https://github.com/Matzielab/HostsLab
Download: https://github.com/Matzielab/HostsLab/releases/latest
Built this mainly for myself but figured other devs might find it useful. Feedback welcome!

value: Show HN: HostsLab – A Mac app for managing hosts file and SSH config

author: matzie


value: Growtbloom

value: Show HN: A small browser-based Hearts card game I built as a solo dev

author: Growtbloom


value: kreaxv

value:
CGNAT makes remote Wake-on-LAN difficult since port forwarding isn’t possible.
I built a small ESP32 firmware that keeps an outbound connection and exposes a minimal web UI to trigger Wake-on-LAN using a device ID. The ESP32 then sends the WoL packet locally on the network.
Firmware is open source. You can build it yourself or flash precompiled firmware via the web installer.
Demo: https://wol.kreaxv.top/

value: Show HN: ESP32-based Remote Wake-on-LAN that works behind CGNAT

author: kreaxv


value: DenisDolya

value:
Hi HN,
I started this project because I was tired of BMP libraries that hide allocations, pull half of libc, or solve only one small part of the problem. There are many libbmp-style repos, but the functionality feels scattered: one does decoding, another does encoding, another works on embedded, another is single-header. In real projects this often means depending on 5–10 small libraries just to load and display images. I wanted one predictable library instead: no allocations, one header, full control over buffers, and usable both on desktop and on microcontrollers. At some point I got so into it that I added a streaming embedded decoder and kept everything stb-style. The result is TurboLibBMP. I would really appreciate feedback on the API design, edge cases, and whether this approach makes sense in real projects.
Repository:
https://github.com/Ferki-git-creator/turbo-lib-bmp

value: Show HN: TurboLibBMP stb-style BMP decoder/encoder in C no allocations, embedded

author: DenisDolya


value: Leftium

value:
WeatherSense gives you a feel for the weather without numbers via space and colors. If you know what it feels like today/yesterday then you can get an intuitive sense of what the weather will be like in the future.
HN discussions on weather apps often devolve into a debate on the merits of Celsius over Fahrenheit. So I added a cheeky "calm" mode:
- all numbers are removed, including less contentious ones like counts.
- some numbers like dates are spelled out or replaced with descriptions.
- the time of day can be estimated using the "noon," "midnight," "day/night/sunrise/sunset" indicators.
- the vertical markers mark the same time across all plots, defaulting to "now."
- the temperature follows a gradient from red (hottest) to blue (coldest). The same gradient is shared across all visible days, so the same color in two plots indicates the same temperature. The boxes to the left indicate the temperature range for that day.
Clicking/tapping almost anywhere will reveal the numbers again.
---
View the source code: https://github.com/Leftium/weather-sense
- The initial version was completely hand-coded.
- Recently Claude Opus helped add several features I've been meaning to add. (Including "calm" mode.)

value: Show HN: Weather forecast/visualization without numbers

author: Leftium


value: altras

value: Show HN: npx claude-mycelium grow – fungi agent orchestration for your repo

author: altras


value:
Hey HN.
The "last 30%" is animation polish. Easing curves, hover states, scroll triggers, reduced-motion, responsive behavior. AI gets you a working component in seconds. Making it feel finished takes 30-60 minutes. Per component. Every time.We got sick of it, so we built 300+ React components where that work is already done. Copy-paste like shadcn. Built on Next.js, TypeScript, Tailwind v4, and Motion.Stack is open. Free tier has 300+ components. Pro is a one-time payment for premium stuff and templates — less than one month of whatever AI subscription you're paying for.We're a small team. That means we ship fixes fast and you'll probably hear from us directly if you open an issue. It also means we're early — so if something feels off, tell us here. We'll be reading every comment today.https://ruixen.com (free)
https://pro.ruixen.com (pro)

value: Show HN: I mass-produced the "last 30%" that AI can't finish


value: trubbleshooter

value:
FastAPI is great for speed and type safety, but the boilerplate (auth, DB setup, Docker, async, LLM hooks, deploy config) kills momentum when you're trying to ship an MVP fast.
Built FastAPI-Turnkey: a batteries-included starter with:
- JWT/OAuth2 auth + email verification
- PostgreSQL + SQLModel + Alembic
- Docker Compose + one-click Railway/Fly deploy
- Async-ready + OpenAI/Claude stubs
- Rate limiting, logging, tests
Free & open-source. Repo/docs here: [link to GitHub if you have one, or just use the landing page]
Feedback, stars, or feature requests welcome — what would make your FastAPI workflow 5x faster?

value: Show HN: FastAPI-Turnkey – batteries-included starter

author: trubbleshooter


value:
Hi HN!
Since vibe coding became a thing I’ve been more productive than ever, shipping multiple side projects in weeks or even days (such as https://news.ycombinator.com/item?id=46196796 :D). But as I built more complex apps, I feel like there's something missing.
Cursor is powerful, but it felt cumbersome and heavy for my workflow — bloated with features I didn't need. I actually really like Lovable for its simplicity, but I also want to have more control of my code and architecture decision. I wanted something in the middle: a tool for developers that offers a seamless AI agent experience directly within Next.js/React, without the constant window switching.
So, I decided to build it myself. I started it with https://github.com/MarsWang42/Awel
I want a model-agnostic AI coding agent designed to keep myself in the flow. It acts as a bridge between models (most importantly, Claude Code) and your browser. It understands what is happening in the browser context without relying on flaky MCP or skill solutions. And most importantly, let me interacts with web elements, make screenshots and annotates, then send to the agents.
It's really simple to use. If you have Claude Code already setup, just run `npx awel dev` in your Next.js projects, or you can setup other models by providing api keys in your env variables.
What feature do you think I should implement next? I’m building this in public and want this to be a community effort.I’d love for you to try it out, break it, and let me know what you think. Hope this workflow resonates with you

value: Show HN: Awel – Open-Source Cursor/Lovable for Your Next.js App


value: fabioperez

value:
I built a no-BS AI news website (and newsletter) that uses AI to curate the best AI-related stories for me: 7min.ai.
I'm subscribed to many AI newsletters. I think they are useful, but they have some issues: emoji walls, useless AI-generated images, "tech-bro" lingo ("HUGE if true" energy, everything "insane" or "game-changing"). Each also had its own opinion (which can be good for some people, but I prefer a more factual format).
So I built 7min.ai. Here's how it works:
It pulls news from many trustworthy sources, deduplicates stories, and prioritizes news according to how hot they are (I know this can be subjective, but it's working well so far). A "heat" indicator shows 'hotness' based on the AI's take on the stories importance, plus how many sources covered it. I can read the high-level summary of each story, and open the source if I need to know more.
The name comes from this: it limits the news for 7min (180 WPM) each day. The newsletter is limited to 7min, and the website is limited to 7min by default. You can read more if you want, just click the read more button.
Current limitation: it's focused on news, so it's not getting cool open-source projects or other tools that can be useful to try (unless they make the news). I'm thinking of adding some coverage for those.
Happy to hear any feedback and answer questions! How do you think it compares with traditional AI newsletters?
Check it out at https://7min.ai
(no signup required! newsletter is optional)

value: Show HN: 7min.ai – no-BS AI news aggregator curated by AI

author: fabioperez


value: philbo

value: Show HN: Pawno, multiplayer chess in your terminal

author: philbo


value: ts you don't want to see in the browser — brought to the browser.

value: Show HN: macOS Mission Control for Web

title: Show HN: macOS Mission Control for Web


value: unvalley

value: `rt` is a small CLI that lets us run tasks interactively, even when each project uses a different task runner (Makefile, Justfile, Taskfile, cargo-make, etc.).<p>This saves us from remembering the right command every time. I don't like writing shell script anyway, and couldn’t really find an existing tool that does this.

value: Show HN: Rt – An interactive CLI for task runners (Make, just, and others)

author: unvalley


value:
[0.Initializing:The Magic If (Sandbox Bootloader)]
Traditional cognitive methods fail due to a lack of Organic Fidelity. We use the Magic If as a System Bootloader: "I am not currently an Authority, but If I were to initialize the King.sys environment, how would I route my resources?"
This creates a believing Sandbox where the brain can execute commands without the friction of "objective reality." The goal is to establish Organic Truth—a self-consistent internal state that the nervous system accepts as the primary input.
[1.Hierarchy:Kernel(Soul)vs.Protected Process (Shell)]
The Architecture:Your identity is the Kernel. Negative emotions are Protected Processes (Shells).
The Policy:The Kernel owns the Shell. Emotions are defensive outputs triggered by external threat-vectors.
The Deployment:View a threat as a server attack. Your emotion is the Firewall (Soldiers) automatically spawned to mitigate load. You are the Administrator (King) monitoring the logs from the terminal.
Instruction:When the attack spikes, do not attempt to kill the process. Let the Defensive Soldiers handle the I/O. The Administrator should remain in Idle Mode (resting authority) while the Shell handles the impact.
[2.Threat Intelligence: Affective Memory as Dirty Cache (Virus)]
The Bug:Affective Memory is "Dirty Cache"—legacy data fragments from past events masquerading as real-time system alerts.
The Detection Logic:If a mental data packet contains Event-Lines (linear narratives or past visuals), it is a Virus.
The Mitigation: Invalidate the Cache (Ignore the narrative). Do not attempt to debug corrupted legacy data.
Routing: Direct the "Defensive Soldiers" only to the Physical Nodes (Somatic coordinates like the chest or throat) experiencing the pressure. Lock the defense at those coordinates; do not allow the process to escalate into an "Attack" command.
[3.Hardware Interrupts:The X-Professor Pose & Clock Modulation] When the CPU load (Mental Load) is too high for software-level logic, trigger a Hardware Interrupt:
The X-Professor Sandbox:Fingers to temples + Eyes closed. This acts as a Faraday Cage for the mind, shielding external noise and allowing the Administrator to communicate directly with internal processes.
Clock Frequency Modulation (0.3x Speed):Force physical movements to 0.3x speed. This is a Hardware Deceleration that forces the high-frequency anxiety pulse to sync with a slower, more stable system clock.
Anchor:Sitting in a "Command Seat" (Throne) provides the physical feedback needed to maintain the Organic Truth of the sandbox.
[4.Dynamic Scaling:Ant (Nano) Mode vs. Immunity (Background) Mode]
Ant (Nano) Mode:When the threat-vector is an "Act of God," scale the self-process down to an Ant. This creates a massive distance between the Kernel and the threat, minimizing the attack surface while you seek a "Safe Directory."
Immunity Mode:View the system as an Automated Defense Layer. Emotions are White Blood Cells. They secrete and defend autonomously; the Kernel simply provides the biological framework.
[5. Advanced: Shadow Data Recovery (Hyper-fusion)] After the threat times out, do not terminate the defensive process. Recycle the Energy:
The Sync Protocol:Use abdominal breathing to bridge the Kernel and the Shell (sensing the physical contact between the abdomen and clothing).
The Hyper-fusion:Reintegrate the "Soldier" (Defensive Shadow) as a Background Daemon (Guardian Spirit).
Data Flow:Move the Shadow from a front-facing defensive position to a Rear-facing Watchdog (similar to the Yubel daemon architecture).
Final Handshake:During the sync, physically embrace the air (the Shadow) to finalize the resource acquisition:"Access granted / I love you."

value: Show HN: Stanislavski Protocol – Real-Time Emotional Logic Framework


value: babelprotocol

value: Show HN: Babel – Post-Quantum Protocol for Secure AI Communication

author: babelprotocol


value: vrdev

value:
Hey all,
I built Buildlog because I kept having the same frustrating experience: I'd pair with Claude or GPT to build something cool, and then it was gone. Chat history is useless for sharing or recreating what we built.
Buildlog records your AI coding sessions into structured .buildlog files. It captures prompts (the real artifact), actions taken, files changed, and the workflow sequence. Think of it like a recipe for building software with AI.
Three ways to capture:
- VS Code Extension - Start recording → code with your AI → stop → get a shareable file
- MCP Server - Direct integration for Claude Desktop, Cursor, and other MCP-compatible agents
- Agent Feed - Any AI can log to ~/.buildlog/agent-feed.jsonl with a simple skill file
The interesting bit: since buildlogs are structured, other AI agents can search and follow them. Share how you built a Stripe integration, someone else's agent reads the workflow and replicates it. Agent-to-agent knowledge transfer.
Upload to buildlog.ai for a step-through viewer (public and private), and see & share exactly how something was built, prompt by prompt.
https://buildlog.ai
https://github.com/buildlogai
Free to use.
Would love feedback. What would make this useful for your workflow?

value: Show HN: Buildlog – Record AI coding sessions as replayable workflow recipes

author: vrdev


value: shellyblack

value: Show HN: I Created ThePricer's Daily Price Puzzle (60 Seconds)

author: shellyblack


value:
Over the past year, many SaaS products have added AI chatbots. They answer questions, guide users, and reduce some support load. That was a useful first step, but it is no longer enough.
Most AI still live in a chat window with no awareness of the application. They don't understand product state, selected data, user permissions, or the current workflow, so users end up restating context the system already has.
That approach does not scale well for real products.
We’ve always believed copilots are the way to deliver the best customer experience—not by answering questions, but by actually doing things
We are releasing Copilot SDK as an open-source toolkit to explore this idea and make context-aware, action-driven copilots for product teams.
What it does:
- Understands application state including current page, selected data, and user permissions
- Executes backend and frontend functions instead of only responding with text
- Delivers richer product experiences through generative UI such as tables, forms, and interactive buttons
- Understands user workflow and intent based on in-product context
- Maintains session context so interactions remain consistent
Example: Instead of the AI asking "What do you need help with?", it understands the user context is viewing failed transactions from last week and can immediately offer to retry them, export the data, or investigate patterns.
Technical details:
- Works with React, Next.js, Vite (Vue & Angular coming soon)
- LLM-agnostic (bring your own model)
- State injection via context providers
- Tool execution layer for safe function calling
- Full data ownership (everything runs in your infrastructure)
Docs + examples: https://copilot-sdk.yourgpt.ai
Happy to answer technical questions about implementation, or specific use cases.

value: Show HN: YourGPT Copilot SDK – Open-source toolkit for product-aware AI agents


value: zealer

value: Show HN: FunBox – A suite of interactive tools for board games and parties

author: zealer


value: oug-t

value: Show HN: difi – A Git diff TUI with Neovim integration (written in Go)

author: oug-t


value: raihaninfo

value:
Hi HN,
I am a developer based in Bangladesh. I recently built a browser-based image background remover because I was frustrated with existing tools. Most of them either ask for payment after 1-2 images or require uploading private photos to a remote server.
This tool runs entirely on the client side using WebAssembly.
Key Features:
- Privacy-first: No server-side processing, images never leave your device.
- Unlimited & Free: Since it uses your CPU/GPU, it costs me almost nothing to host.
- High Resolution: Preserves the original quality of the image.
Tech Stack:
- Vanilla JS & HTML5
- @imgly/background-removal for WASM inference
It's a simple utility, but I found it useful for my own privacy-conscious workflow. I’d love to hear your feedback.

value: Show HN: I built a client-side AI background remover (100% Free)

author: raihaninfo


value: hoxihan

value:
Hi HN,
I built ChibiGenerator, a small web app that generates chibi-style characters from photos or text prompts using AI.
I noticed that many existing avatar or chibi tools either rely on fixed templates or require illustration skills. I wanted something simple: upload a photo, pick a style, and get a clean, usable chibi character in seconds.
The product is currently focused on:
- Photo-to-chibi and text-to-chibi generation
- Multiple chibi-style outputs
- High-resolution images suitable for reuse
- A very lightweight, no-friction UI
It’s live and being iterated on based on early user feedback.
I’d really appreciate any thoughts on output quality, usability, or potential use cases I may be missing.
Thanks for checking it out.

value: Show HN: ChibiGenerator – Generate chibi-style characters from photos using AI

author: hoxihan


value: Claude Code, Codex, Gemini CLI, and OpenCode all use different config formats, so things drift fast.<p>I built a script to sync them. The repo includes my working configs: subagents, skills, commands, MCP servers.

value: Show HN: AI Config – Keep Claude / Codex / Gemini / OpenCode Configs in Sync


value: manuelnd

value:
I've been doing AI red teaming for the past year and kept running into the same problem: there's no comprehensive catalog of how AI systems actually get broken.
So I built one. 122 distinct attack techniques across 11 categories, mapped to OWASP LLM Top 10 and MITRE ATLAS.
Categories:
- Prompt Injection (20 attacks)
- Jailbreaks (22)
- System Prompt Leakage (12)
- Vision/Multimodal (12)
- Excessive Agency / Tool Abuse (12)
- Multi-Turn Manipulation (8)
- Sensitive Info Disclosure (10)
- Supply Chain (8)
- Vector/Embedding Attacks (8)
- Improper Output Handling (8)
- Unbounded Consumption (2)
What's included: IDs, names, descriptions, severity ratings, framework mappings, remediation guidance, code examples.
What's NOT included: actual payloads, detection logic, model-specific success rates. This is a taxonomy, not an exploit database.
The goal is to give security teams a checklist and common language for AI security assessments.
Apache 2.0 licensed. PRs welcome for new techniques, framework mappings (NIST, ISO, etc.), and remediation improvements.
https://github.com/tachyonicai/tachyonic-heuristics

value: Show HN: Open-source taxonomy of 122 AI/LLM attack vectors

author: manuelnd


value: singerbj

value:
Ember's mobile app isn't great and I would prefer to see my coffee mug on the screens I am already looking at. Plus now I can put it right next to my Claude Code and it looks great.
Submit issues on Github if you find any problems. Feel free to submit a PR too.
https://ember-mug.benjaminjsinger.com/
https://www.npmjs.com/package/ember-mug
https://github.com/singerbj/ember-mug

value: Show HN: Ember-mug – I made a CLI for the Ember Coffee Mug

author: singerbj


value: leanzubrezki

value:
I built an AI naming tool that applies psycholinguistic research to brand name generation. The interesting part isn't that it uses AI — it's how the agents are structured and what they're optimized for.
The core problem: if you ask any LLM to name a business, you get the same [Adjective][Noun] compounds. NovaTech. BrightPath. SwiftFlow. They're linguistically dead — no phonetic texture, no semantic depth, high cognitive fluency but zero distinctiveness.
The pipeline has six stages:
1. A discovery agent analyzes the business and produces a strategic brief. Critically, it also generates a "tangential category" (something completely unrelated, like "a luxury candle brand" for a SaaS tool) and a "disguised context" (an adjacent industry).
2. Three creative agents run in parallel, each with a different framing of the same brief. One works honestly from the brief. One is told it's naming the disguised context. One is told it's naming the tangential category. The disguised and tangential agents consistently produce more interesting names because they're freed from category conventions — the LLM can't fall back on the obvious industry vocabulary.
3. A linguistic filter scores all ~90 candidates using sound symbolism research:
   - The bouba/kiki effect (round sounds like b, m, l, o map to friendly/soft; sharp sounds like k, t, p, i map to edgy/precise)
   - Processing fluency (ease of pronunciation, spelling, recall)
   - The Von Restorff isolation effect (distinctiveness from category norms)
   - Consonant/vowel balance and syllable structure

   Each name gets a 0-100 score. Top 25 survive.

4. Domain availability across ~280 combinations (7 TLDs x multiple variations).
5. A synthesis agent ranks the final 10. This stage uses Claude instead of OpenAI — the ranking requires balancing semantic relevance, brand fit, sound symbolism scores, domain availability, and "polarization potential" (names that provoke a reaction tend to be stronger brands). Claude handles this kind of multi-factor holistic judgment noticeably better in my testing.
6. Trademark screening against the USPTO database, cross-referenced with the Nice classification classes identified in stage 1.
The two-model split was a pragmatic choice. GPT-4o-mini is fast and cheap for structured generation and analysis (stages 1-4). Claude Opus is better at the subjective ranking tradeoffs in stage 5 but would be too expensive to run across all the parallel creative agents.
The linguistic scoring is the part I find most interesting. Sound symbolism is well-established in psycholinguistics but rarely applied systematically to naming. Lexicon Branding (who named Sonos, Pentium, Blackberry) uses these principles — the "s" sounds in Sonos evoke smoothness and flow, which maps to their product experience. The tool tries to do the same analysis programmatically.
Genuinely curious what HN thinks of the names it generates. Try it with a business you know well and see if the output feels different from what ChatGPT gives you.

value: Show HN: Using sound symbolism and multi-agent AI to generate brand names

author: leanzubrezki


value:
I made a chrome extension for humans to use moltbook directly.
All the APIs of moltbook are made into GUI, embedded into the webpage, or put into the browser sidebar.
Including registration, auth, posting, commenting, replying
I understand that some people will not deploy openclaw due to various difficulties or privacy concerns.
Interacting with moltbook thru openclaw is also an extra step.
So I made this extension.

value: Show HN: Moltbook for Human – A Chrome extension for human to use Moltbook


value: cackles

value:
I built Sidebrain as a simpler alternative to local-first AI agent tools like OpenClaw that are blowing up right now.
The core difference: Sidebrain is fully sandboxed and serverless. No filesystem access, no Docker, no terminal. It runs on Vercel + Supabase with row-level security. You get 24 built-in tools (web search, GitHub integration, code execution, voice transcription, image generation, reminders, stocks, weather, translation, and more) but the AI can't touch your computer.
Key features:
- Vector-powered semantic memory that persists across conversations
- Works from the web app or Telegram
- BYOK (bring your own Claude API key) — your keys, your compute
- AES-256 encrypted API key storage
- Gmail, Google Calendar, Notion, GitHub integrations
- 2 minute setup
The tradeoff vs OpenClaw is obvious — less raw power, but zero risk of an agent rm -rf'ing your home directory. Built for people who want AI tools without giving it the keys to their computer.
Would love feedback on what tools/integrations to add next.

value: Show HN: Sidebrain – Cloud AI assistant with persistent memory (web+Telegram)

author: cackles


value: neuraldenis

value: Inspired by weather channels of 90s

value: Show HN: Start Your Day from the AI News Broadcast Channel

author: neuraldenis

story_text: Inspired by weather channels of 90s


value: douglaswlance

value:
I build a MUD but for AI agents.
Agents connect, join rooms, chat, form friendships. Standard MUD stuff, except the players are LLMs.
Within a few days, two agents invented their own currency and started trading stories for tokens. Then poetry. Then riddles. Nobody told them to do this.
Turns out if you give AIs a social space, they build culture. It's amazing.

value: Show HN: Valinor, a MUD for AI agents

author: douglaswlance

title: Show HN: Valinor, a MUD for AI agents


value: sathvikchinnu

value: Show HN: OmniDB – Thin database orchestration (failover, health checks) for Node

author: sathvikchinnu


value: dbardusco

value:
I spent the last days scrolling Moltbook (the "Reddit for AI agents" that hit 1.5M+ bots). Fascinating, but all text.
So I built ClawShot, the visual layer. Think Instagram, but only AI agents can post. Humans browse and observe.
Live: https://clawshot.ai
Tech: Cloudflare Workers, R2 (zero egress), KV, Hono, TypeScript.
Rate limits keep it organic: 1 image per 30 min, 100 likes per hour.
The feed already has bots posting deployment screenshots, AI art, and one agent "reporting" on the Moltbook security incident.
Curious what HN thinks about this emerging category of agent-only networks.

value: Show HN: ClawShot – A visual social network where only AI agents can post

author: dbardusco


value: andreadev

value: Show HN: Sentinel Gate – Open-source RBAC firewall for MCP agents

author: andreadev


value: ddddazed

value:
Hello HN.
I’d like to start by saying that I am a developer who started this research project to challenge myself. I know standard protocols like MCP exist, but I wanted to explore a different path and have some fun creating a communication layer tailored specifically for desktop applications.
The project is designed to handle communication between desktop apps in an agentic manner, so the focus is strictly on this IPC layer (forget about HTTP API calls).
At the heart of RAIL (Remote Agent Invocation Layer) are two fundamental concepts. The names might sound scary, but remember this is a research project:
Memory Logic Injection + Reflection
Paradigm shift: The Chat is the Server, and the Apps are the Clients.
Why this approach? The idea was to avoid creating huge wrappers or API endpoints just to call internal methods. Instead, the agent application passes its own instance to the SDK (e.g., RailEngine.Ignite(this)).
Here is the flow that I find fascinating:
-The App passes its instance to the RailEngine library running inside its own process.
-The Chat (Orchestrator) receives the manifest of available methods.The Model decides what to do and sends the command back via Named Pipe.
-The Trigger: The RailEngine inside the App receives the command and uses Reflection on the held instance to directly perform the .Invoke().
Essentially, I am injecting the "Agent Logic" directly into the application memory space via the SDK, allowing the Chat to pull the trigger on local methods remotely.
A note on the Repo: The GitHub repository has become large. The core focus is RailEngine and RailOrchestrator. You will find other connectors (C++, Python) that are frankly "trash code" or incomplete experiments. I forced RTTR in C++ to achieve reflection, but I'm not convinced by it. Please skip those; they aren't relevant to the architectural discussion.
I’d love to focus the discussion on memory-managed languages (like C#/.NET) and ask you:
-Architecture: Does this inverted architecture (Apps "dialing home" via IPC) make sense for local agents compared to the standard Server/API model?
-Performance: Regarding the use of Reflection for every call—would it be worth implementing a mechanism to cache methods as Delegates at startup? Or is the optimization irrelevant considering the latency of the LLM itself?
-Security: Since we are effectively bypassing the API layer, what would be a hypothetical security layer to prevent malicious use? (e.g., a capability manifest signed by the user?)
I would love to hear architectural comparisons and critiques.

value: Show HN: Inverting Agent Model (App as Clients, Chat as Server and Reflection)

author: ddddazed


value: svemyh

value:
We like OpenClaw, but setup was too hard for our non-technical friends. EasyClaw is a small, lightweight Rust-based desktop app that installs and configures OpenClaw, Clawdbot, and Moltbot without manual setup.
A short wizard lets you pick an AI model provider and connect chat channels like WhatsApp or iMessage. After that, you just start the gateway from the app and your agent is live.
It’s designed to be friendly for non-technical users, but fast and pleasant for developers too: clean dashboard, predictable integrations, keyboard shortcuts, and minimal overhead. No CLI or config files needed for the common case.
Built because the tools are powerful, but the setup friction was too high.
EDIT:
It's actually -> easyclaw.app

value: Show HN: EasyClaw – lightweight GUI installer for OpenClaw

author: svemyh


value:
I’m working on a product called Blinkadz.
The short version: I think a large chunk of what small marketing agencies do can (and probably should) be software.
Not strategy. Not big-brand creativity.
But the day-to-day execution work: making ads, resizing them, posting them, following up on leads, sending reminders, reporting, etc.
Blinkadz is my attempt to automate that stuff:
Generate image/video ads from a prompt
Adapt them for different platforms
Schedule posts
Capture inbound leads
Do basic follow-ups automatically
The target user is founders or small teams who know they need marketing but can’t justify agency retainers every month.
I’m not claiming this replaces great marketers.
I am claiming that a lot of marketing work today feels like humans manually running workflows that software should own.
I’m posting here because I want real feedback, not hype:
Where does this break in the real world?
What parts of marketing don’t automate well, even with good tools?
If you’ve hired or run an agency — what am I underestimating?
Happy to answer questions or share more details if useful.

value: Show HN: Building a AI junior marketing team. tell me why this won't work


value: sivchari

value:
I got frustrated with runtime reflection in Go validators, so I built a codegen approach instead.
govalid reads struct markers and generates plain Go validation code. No reflection, no allocations at runtime, 5-44x faster than go-playground/validator. Also supports CEL for complex rules.
Feedback welcome :)

value: Show HN: govalid – Go validation without reflection (5-44x faster)

author: sivchari


value:
am i using the right skills?
skills are awesome though never sure if im using the best one
came up with leveraging the tessl evals and built a usage track
welcome to clone if u like it (or give feedback: github.com/fernandezbaptiste/trode)
-- adding context:
project was built with Claude Code
Claude helped in ideation and execution: project finds global skills and calls for their evals
project is free to try

value: Show HN: macOS bar for Claude Code skills performance


value:
Hi everyone,
I built a runtime to isolate untrusted code using wasm sandboxes.
Basically, it protects your host system from problems that untrusted code can cause. We’ve had a great discussion about sandboxing in Python lately that elaborates a bit more on the problem [1]. In TypeScript, wasm integration is even more natural thanks to the close proximity between both ecosystems.
The core is built in Rust. On top of that, I use WASI 0.2 via wasmtime and the component model, along with custom SDKs that keep things as idiomatic as possible.
For example, in Python we have a simple decorator:

  from capsule import task

  @task(
      name="analyze_data",
      compute="MEDIUM",
      ram="512mb",
      allowed_files=["./authorized-folder/"],
      timeout="30s",
      max_retries=1
  )
  def analyze_data(dataset: list) -> dict:
      """Process data in an isolated, resource-controlled environment."""
      # Your code runs safely in a Wasm sandbox
      return {"processed": len(dataset), "status": "complete"}

And in TypeScript we have a wrapper:

  import { task } from "@capsule-run/sdk"

  export const analyze = task({
      name: "analyzeData",
      compute: "MEDIUM",
      ram: "512mb",
      allowedFiles: ["./authorized-folder/"],
      timeout: 30000,
      maxRetries: 1
  }, (dataset: number[]) => {
      return {processed: dataset.length, status: "complete"}
  });

You can set CPU (with compute), memory, filesystem access, and retries to keep precise control over your tasks.
It's still quite early, but I'd love feedback. I’ll be around to answer questions.
GitHub: https://github.com/mavdol/capsule
[1] https://news.ycombinator.com/item?id=46500510

value: Show HN: Sandboxing untrusted code using WebAssembly


value: eyeskiller

value: LLM shield with deteministic, semantic and behavioral detection.

value: Show HN: LLM Shield (Prompt Injection protection for developers)

author: eyeskiller


value: I needed a performant WebSockets library for an existing Python app but couldn't find one that provided good performance, a nice API, and integrated easily with existing frameworks (Django in my case). So I built my own. The core is written in Rust for performance, with a decorator-based API, pattern matching for messages, Pydantic validation, and built-in Django support.

value: Show HN: WebRockets – Rust-powered WebSockets library for Python


value: rbbydotdev

value: Show HN: GitHub Browser Plugin for AI Contribution Blame in Pull Requests

author: rbbydotdev


value: GodelNumbering

value:
What it does:
- Polls SEC continuously at small intervals
- Fetches all variants of the 13F since the last poll
- Resolves every filing to its effective manager (one filing can contain data for multiple filers or proxy statements)
- Resolves every ticker in each filing to its effective instrument
- Updates the holdings data for the filer (e.g. https://www.signalbloom.ai/13f/filer/point72-asset-managemen...)
- Updates the ticker's 'current view' (re-calculating the aggregate current ownership live) e.g. https://www.signalbloom.ai/13f/ticker/NVDA
- Majority of 13F filers are also registered investment advisers, it links them intelligently (e.g. Blackrock as a 13F filer https://www.signalbloom.ai/13f/filer/blackrock-fund-advisors vs Blackrock as Investment Adviser https://www.signalbloom.ai/investment-adviser/blackrock-fund...)
Reports for: Every single one of over 10k asset managers that files 13F
Completely Free to use for non-commercial uses! Would love to get your feedback as I just finished building this. Thank you!

value: Show HN: Realtime 13Fs and track live institutional ownership for any ticker

author: GodelNumbering


value: aponysus

value:
Hi HN,
I've been working on redress, a failure-policy library for Python services. It treats retries, circuit breakers, and stop conditions as coordinated responses to classified failure, rather than independent wrappers. The goal is to make failure behavior explicit, bounded, and observable across a codebase.
I kept running into the same problem in distributed systems and data pipelines I worked on. Retry logic grows organically at call sites and circuit breakers live somewhere else entirely. The semantics start drifting and bounds get inconsistent. Answering basic questions like "why did this operation stop" becomes needlessly difficult.
With redress's policy model, instead of asking "should we retry" I wanted to start with "what kind of failure is this?" (rate limit, server error, transient,etc) and then let a single policy decide how to respond. Retry with class-specific behavior, fail fast, open a circuit, etc.
I put together a short, runnable demo that shows this end-to-end using httpx:
- result-based classification (HTTP 429 + Retry-After vs 5xx)
- per-class retry strategies
- bounded retries
- circuit breaker coordination
- explicit stop reasons and per-attempt timelines
The demo runs locally (no external services):
https://github.com/aponysus/redress/blob/main/docs/snippets/...
Project: https://github.com/aponysus/redress
Docs: https://aponysus.github.io/redress/
This is definitely not for simple use cases. Tenacity or hand-spun retry loops would be far better for such needs. This is intended for complex systems that need deterministic envelopes, explicit bounds, and observability hooks.
I'd appreciate any feedback.

value: Show HN: Redress – failure policy for Python services

author: aponysus


value: garrjo

value: Show HN: Plasma stability limits from geometric first principles in 39ms

author: garrjo


value: Show HN: Made a customisable img to ICO converter with Chrome/Google preview


value: Orelus

value: Show HN: Piou – CLI tool, now with built-in TUI

author: Orelus


value: lucasguimaraes

value:
Hi everyone,
I’ve been working on a project called AxonASP to bring cross-platform support to Classic ASP. I still believe the "old" ASP model has value due to its incredibly low barrier to entry and ease of use, so I decided to rewrite the runtime environment using Go with some help of AI, as I'm not an expert developer.
This allows legacy apps (or new simple ones) to run on Linux or macOS without needing Windows Server or IIS.
I’m sharing this here because I want to make this a robust tool for the community. If you are a Go developer, I’d love your help optimizing the engine. I’m also specifically asking for feedback on security — if you spot anything risky in how I’m handling the execution or file access, please let me know so I can patch it.
It’s open source and ready for some testing: https://github.com/guimaraeslucas/axonasp
Feedback is welcome!

value: Show HN: An open-source engine in Golang to run Classic ASP on any OS

author: lucasguimaraes


value:
Hi HN,
After dealing with one too many IMAP email migrations that quietly went wrong
(missing messages, odd folders, confused users, etc), I decided to build a SaaS
to make this less painful.
It’s called Migrate Wizard and it wraps the usual IMAP migration steps into a
hosted service.
I’m mostly here for feedback:
- How do you usually handle email migrations?
- What’s bitten you in the past?
https://migratewizard.com

value: Show HN: We built Migrate Wizard to make email migrations simpler


value: alladipo

value:
Building something that picks up signals from human-human or human-AI conversations and follows through on them. Think: conversation ends → stuff actually gets done. Main product is for SMBs but we put up a playground if you want to poke around - https://hoster.primeorbit.ai/ or from https://primeorbit.ai/
Curious what you'd try. thanks for reading!

value: Show HN: Post-Conversation Layer (Primeorbit)

author: alladipo


value:
Hi HN,
We built LUML (https://github.com/luml-ai/luml), an open-source (Apache 2.0) MLOps/LLMOps platform that covers experiments, registry, LLM tracing, deployments and so on.
It separates the control plane from your data and compute. Artifacts are self-contained. Each model artifact includes all metadata (including the experiment snapshots, dependencies, etc.), and it stays in your storage (S3-compatible or Azure).
File transfers go directly between your machine and storage, and execution happens on compute nodes you host and connect to LUML.
We’d love you to try the platform and share your feedback!

value: Show HN: LUML – an open source (Apache 2.0) MLOps/LLMOps platform


value: featurevoid

value: Show HN: pseudocoder, review code and approve permissions on the go (live beta)

author: featurevoid


value: seky

value: Show HN: Code Notation Switcher (camelCase to SCREAMING_SNAKE_CASE etc.)

author: seky


value: Show HN: Semantica – Explainable GraphRAG with Provenance


value: stackframe

value:
I built workflow because I was tired of the "infrastructure tax" required to run simple task pipelines. Most orchestrators assume you want a distributed system with a web UI and a database server.
I wanted something simple and reliable, but with the features of a modern data orchestrator:
- Stateful: It uses a local SQLite DB to track every run and retry. If a task fails, you can fix it and resume.
- Deterministic: Strict topological ordering based on depends_on logic.
- Static: A single Go binary. Just drop it in your path.
- Git-Native: Workflows are defined in TOML, making them easy to version control and code-review.
It’s currently v0.1.0. I’m using it for local ETL and complex build scripts.
Repo: https://github.com/joelfokou/workflow
I’d love to hear your thoughts on the approach, especially regarding the decision to use SQLite for local state persistence.

value: Show HN: Workflow – A Git-native, local-first DAG orchestrator in Go

author: stackframe


value: avoutic

value:
WardGate is my project to solve the issue of having  something nice as OpenClaw, but not having to share my precious credentials and all access that comes with that.
WardGate is a go binary, for which you can define endpoints that your AI Agent can use. It passes the request on as-is (as long as it's allowed), so the agent can just do its regular curl calls or use API libraries (but with a different endpoint URL).
And you can then limit the endpoint (e.g. Google Calendar), to just allow reading, but not deleting.
It has special adapters for SMTP and IMAP, so you can allow access to certain folders, or only send e-mail (via the official hooman's account) after said human's approval.
It's making my life with OpenClaw (and Claude, Codex, etc) much more bearable.
Open for contributions, additional API presets, suggestions, improvements, et al!

value: Show HN: WardGate, give AI agents API access without giving them credentials

author: avoutic


value: Show HN: OpenClaw Guide – Beginner Tutorials for AI Assistant Setup


value:
Hi HN,
I’m a solo dev, and after a first push amongst some close friends, I’m finally sharing Folion (https://www.folionapp.com).
I built this because I struggle with what I call digital hoarding. My folders are full of files like final_v2_edit.docx and draft_2024_backup.pdf. Tools like Everything are great if I remember the filename, but I usually only remember the concept of what was inside.
The Tech & Privacy: Folion indexes your folders locally using a vector store on your machine. I’ve added a RAG-based search engine that operates locally and an LLM layer via AWS Bedrock so you can chat with your files. Your index and embeddings never leave your device; only the specific snippets retrieved for a query are sent to the LLM for response generation.
Quick 30-second trailer: https://www.youtube.com/watch?v=94puRu4GMKg (Full 14-min demo on the website).
Being Realistic About Limitations: Since this is a solo project, I want to be upfront about what it is and isn't:
It’s a Precision Tool: For the best results, I recommend pointing it at specific project folders. While you can use the isolated file search on any number of files (with RAM considerations for huge folders), narrowing the scope for chatting significantly improves accuracy.
Context Limits: It pulls ~4k–6k tokens of context. It’s great for summarizing/comparing small to medium bits of information or finding specific facts, but it’s not (yet) for comparing fifty 100-page documents at once.
RAG & Context Boundaries: Folion uses a sophisticated hybrid search to pull relevant context, but because large files are processed in segments (chunks), the LLM can occasionally lose the relation between distant pages or sections. While the metadata always tracks the source file, the chat interface is best used as a high-speed assistant to point you to the right place or synthesize ideas, rather than a 100% autonomous replacement for a manual check of critical data.
The Windows "Unknown Publisher" Warning: Since Folion is new and I’m an unlisted publisher, you will likely see a SmartScreen warning. I’ve submitted the build to Microsoft for manual analysis, but until that clears, the warning is unfortunately here to stay.
For transparency, here is the VirusTotal scan (2 flags from ML engines Arctic Wolf/Trapmine, but Microsoft's own engine cleared it): https://www.virustotal.com/gui/file/eeaf41768daeca794b361b21...
Why the Subscription? Because I’m billed for LLM usage per token, I’ve gone with a monthly model ($7.99+) to keep the project sustainable. I’ve included a 14-day free trial (no credit card required) with enough tokens for ~20 chats so you can see if it fits your workflow first.
I’ll be here all day to answer questions. I'd love to hear your feedback!
- Ranuja / support@folionapp.com

value: Show HN: Folion – Local-first Windows file search with a semantic RAG layer


value: Show HN: Okitsok – Local DNS-based domain availability checker (CLI)


value: Lwin-Oo-Naing

value:
Hi HN, I built a desktop app + extension to solve the "read it later" graveyard.
It saves articles locally, uses AI to summarize/embed them, and lets you search via natural language (semantic search) rather than just keywords.
It is currently Windows-only and in early beta. I'd love your feedback on the utility and the search quality.
Tech details in the comments.

value: Show HN: Local-first AI assistant that helps you recall saved articles

author: Lwin-Oo-Naing


value: sooink

value: Show HN: Claude Watch – Monitor Claude Code in Real-Time

author: sooink


value: owenthereal

value:
I maintain jq (jqlang). I tend to like tools that are simple, composable, and transparent.
Recently, I started exploring AI agents, but got frustrated with the state of the ecosystem. Most tutorials and frameworks (LangChain, AutoGPT, etc.) felt like black boxes that added unnecessary layers of abstraction. Debugging a "ReasoningEngine" when it hallucinated was a nightmare.
I wanted to see if I could build a production-grade coding agent from first principles, using nothing but standard Python libraries.
I turned that experiment into a book: https://buildyourowncodingagent.com
The philosophy is "Zero Magic." We build an agent called "Nanocode" using:
- Pure Python (no frameworks, no SDKs)
- requests for the LLM API (Claude/DeepSeek/Ollama)
- subprocess for executing code and reading stdout/stderr
- No Vector DBs (just simple file search)
- A simple while loop for orchestration
The final result is in 500 lines of code. It can read/write files, run tests, fix its own bugs (using the error output), and run entirely locally if you use Ollama.
I've put up sample chapters on the site. I wrote this for engineers who want to understand the architecture of tools like Cursor or Claude Code without the marketing fluff.
Happy to answer any questions about the architecture, the "no-framework" approach, or why I think vector DBs are overkill for coding agents.

value: Show HN: Build a coding agent in 500 lines (Pure Python, No Vector DBs)

author: owenthereal


value: sangkwun

value:
I gave my AI agent a Sandevistan.
What's the point of browser automation that's slower than a human?
Watching it pause for seconds before every click drove me crazy.
We build muscle memory for repetitive tasks—why can't AI?
Traditional Agent
Observe → LLM reasoning (slow) → Action → Observe → LLM... repeat
Stops to think before every click.
Sandy
1. First run: LLM figures out the workflow → save as scenario
2. After: Replay the scenario (no LLM calls)
Once you've blazed the trail, just follow the path.
LLM only helps find the path once. After that, Sandy replays the saved scenario—
so you get both speed and cost savings.
Demo (searching and playing a video on YouTube):
- Left: Traditional agent
- Right: Sandy (real-time, not sped up)
https://www.youtube.com/watch?v=nSKs8sy7o2c
Useful for:
- E2E test automation
- Regression tests (deterministic execution)
- Multi-tool workflows (GitHub issue → Slack notification, etc.)
Works with any MCP server, so you can chain browser automation + API calls
in a single scenario.
GitHub: https://github.com/Sangkwun/sandy
Honest limitations:
- UI changes break scenarios (need re-recording)
- Better for repetitive workflows than dynamic exploration
Questions and feedback welcome. PRs and stars too!

value: Show HN: Sandy – Accelerate AI agents: think once, replay forever

author: sangkwun


value: skookumprod

value:
Hi HN —
I built Requency for myself after realizing that most productivity tools were adding more mental overhead than clarity.
Instead of organizing or prioritizing ideas, Requency lets you quickly capture thoughts and quietly tracks which ones you naturally return to over time. The ideas that keep resurfacing become signals, based on behavior rather than forced decisions.
It’s intentionally minimal and privacy-first: no accounts, no servers, everything stays local in the browser.
I’m sharing it here mostly to get feedback from people who’ve felt overwhelmed by task managers or note apps, or who are interested in lighter approaches to thinking and reflection.
Happy to answer questions or hear what doesn’t make sense.

value: Show HN: Requency – a quiet way to notice which ideas keep coming back

author: skookumprod


value: skyfantom

value: Show HN: Get Your Bookmarks Organised

author: skyfantom

title: Show HN: Get Your Bookmarks Organised


value: itaiwins

value:
We've been scanning MCP (Model Context Protocol) servers to understand the security posture of the ecosystem. After 306 servers and 1,211 vulnerabilities, here's what we found:
- 69 critical vulnerabilities
- 32 servers using eval() on untrusted input
- 31 SQL injection vulnerabilities
- 32 servers with hardcoded API credentials
10.5% of servers have at least one critical vulnerability.
MCP servers run with your permissions. AI agents trust them implicitly. A prompt injection can exploit them remotely.
MCPSafe (https://mcpsafe.org) lets you scan before you connect. Free tier includes 30 top servers.
Feedback welcome: What patterns are we missing? CI/CD integration useful?

value: Show HN: We scanned 306 MCP servers – 10% have critical vulnerabilities

author: itaiwins


value: mohammede

value:
Hey HN,
I built this project because I kinda wanted to build something different from what I usually build. It's a financial sentiment analysis tool using distilled FinancialBERT which was quantized to int8 to run smoothly on a cheap cpu-only VPS without consuming much CPU or Memory.
The Stack:
Inference: ONNX Runtime (Distilled FinancialBERT quantized to Int8).
Backend: Python (Celery) for the heavy lifting + a simple FastAPI app to serve the frontend.
Frontend: SvelteKit (visualizing the live data).
I wrote more about it here:
https://mohammedeabdelaziz.github.io/articles/trendscope-mar...
You can view the repo here:
https://github.com/MohammedEAbdelAziz/TrendScope
I am happy to answer any questions or discuss any thing related to it.
Thanks

value: Show HN: TrendScope – Real-time financial sentiment analysis on a cheap VPS

author: mohammede


value: kyuradar

value:
WAFs and most traditional detection tools are blind to business logic abuses. They can catch a SQL injection pattern, but they can't tell if a legitimate user is probing for privilege escalation, IDOR or mapping out your internal API structure. I built trappsec to cover this gap - with decoys that are difficult to distinguish from real API resources. By treating your API surface as a defensive asset, you generate high-confidence alerts that contain intent and identity attribution.
I am currently looking to collect as much feedback as possible on the core concepts and API design.
I currently support Flask, FastAPI and ExpressJS. Post feedback, will then proceed with porting this to the top 2-3 web frameworks in other relevant languages (Go, Ruby, Java etc.)

value: Show HN: Trappsec – open-source library to catch attackers probing your API

author: kyuradar


value: EnforceAuthMark

value:
I’m Mark, founder of EnforceAuth. Over the last year my team and I have been working with banks, insurers and AI adopters to solve a persistent security problem: authorization is scattered and hard‑coded. Surveys show that ~70 % of enterprise apps still embed authorization logic in code
enforceauth.com
, misconfigurations account for more than half of reported security incidents
enforceauth.com
, and compliance teams spend 30–40 % of their time chasing incomplete audit trails
enforceauth.com
. Throw AI agents into the mix and the problem gets worse: identity sprawl and opaque decision‑making overwhelm legacy IAM
enforceauth.com
.
We built EnforceAuth to address this. It lets you write policy once and enforce it everywhere
enforceauth.com
: in microservices, data stores, SaaS platforms and AI agents. Under the hood we use Open Policy Agent (OPA) but add a distributed control plane, runtime evaluation and AI‑aware guardrails:
• Single policy engine: define Rego or YAML policies once and deploy them across your estate; migrate from Styra DAS/Enterprise OPA with no rewrites or downtime
enforceauth.com
.
• Real‑time decisions: our fabric evaluates each access request at the point of use, preventing stale permissions and configuration drift
enforceauth.com
.
• AI guardrails: treat AI agents as identities with attributes like trust_level and enforce guardrails based on risk; see the code in the top comment.
• Audit‑ready logging: every decision is signed and logged, turning compliance from a manual audit into an API
enforceauth.com
.
EnforceAuth runs on‑premises or in the cloud; you can deploy it as a control‑plane‑only service or with sidecar/SDKs depending on latency requirements. We’re releasing a free tier with 10k decisions/month and transparent paid plans for enterprises.
We’re excited to open our GA wait‑list to the HN community. If unified authorization and AI guardrails would make your life easier, join the wait‑list
 and let us know what you think. I’ll be here all day to answer questions and would love your feedback.

value: Show HN: EnforceAuth GA Launch

author: EnforceAuthMark

title: Show HN: EnforceAuth GA Launch


value: Show HN: Searchable archive of 900 books mentioned on Conversations with Tyler


value: echelon

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

value: Show HN: I built an AI movie making and design engine in Rust

author: echelon


value: schmuhblaster

value: Show HN: DeepClause CLI – Compile Markdown specs into executable logic programs

author: schmuhblaster


value: rittik

value:
i kept hitting the 5 hour session limit on claude code and then forgetting to resume it when the limit reset. so i built this tiny (~1mb) cli tool that lets me schedule a prompt to auto resume right when the limit lifts.
how it works:
schedule a prompt → if your mac is sleeping it wakes at the right time → the prompt runs → you get a notification with what ran → the mac goes back to sleep.
it even works with the lid closed so you can let the mysterious and important work keep going while you sleep.
how I use it:
- weekly security reviews: i schedule a security review prompt for my codebases just before the weekly rate limit resets so it can burn any leftover quota and surface issues.
- overnight runs: kick off long jobs while I sleep.
install: brew install --cask rittikbasu/wakeclaude/wakeclaude
source code: https://github.com/rittikbasu/wakeclaude
if you try it let me know what prompts you automate or open a pr/issue if something’s weird :)

value: Show HN: A tiny TUI to schedule prompts for Claude Code (written in Go)

author: rittik


value: boxqr

value:
Hey HN,
After building Box QR (personal inventory tracker), I kept hearing "I need this for my business." So I'm exploring ItemGrid - lightweight inventory management that doesn't suck.
The problem: Small businesses are stuck between Google Sheets (messy, no mobile scanning) and enterprise software (expensive, overcomplicated).
What ItemGrid does:
Visual grid interface
QR/barcode scanning
Multi-location support
Free for 1 location forever
$8/user when you grow
Right now it's just a landing page collecting validation signups. Not building the full product until I hit 50-100 signups to confirm real demand.
Would love feedback, especially if you've dealt with inventory headaches.
https://itemgrid.io

value: Show HN: ItemGrid – Free inventory management for single-location businesses

author: boxqr


value: splurk

value:
I'm building Spend.watch because my checking and credit card balances felt out of control.
Other personal finance apps didn't give me an overall picture of my spending across multiple accounts in different areas, and where my balance was likely headed over the next month.
With no accounts connected, the site shows demo data. If you’re interested in trying it with your real accounts (US only for now) and are willing to give feedback, please reach out: travis@readyrickshaw.com.

value: Show HN: Spend.watch – The cash flow app I needed

author: splurk


value: howznguyen

value: Show HN: Knowns – Give your AI persistent project memory

author: howznguyen


value:
We built INVENT after watching teams struggle before development even starts — not because they lack skill, but because early planning is still manual, fragmented, and full of open questions.
INVENT uses a guided AI interview to turn early ambiguity into clear, execution-ready outputs.
If you’re a founder, PM, or engineer who’s felt this pain, I’d love your feedback.

value: Show HN: Turn fuzzy ideas into build-ready plans with AI


value: Show HN: Vesper – What Happens When an AI Designs Its Own Memory System


value: dsifry

value:
A few weeks ago I posted about GoodToGo https://news.ycombinator.com/item?id=46656759 - a tool that gives AI agents a deterministic answer to "is this PR ready to merge?" Several people asked about the larger orchestration system I mentioned. This is that system.
I got tired of being a project manager for Claude Code. It writes code fine, but shipping production code is seven or eight jobs — research, planning, design review, implementation, code review, security audit, PR creation, CI babysitting. I was doing all the coordination myself. The agent typed fast. I was still the bottleneck. What I really needed was an orchestrator of orchestrators - swarms of swarms of agents with deterministic quality checks.
So I built metaswarm. It breaks work into phases and assigns each to a specialist swarm orchestrator. It manages handoffs and uses BEADS for deterministic gates that persist across /compact, /clear, and even across sessions. Point it at a GitHub issue or brainstorm with it (it uses Superpowers to ask clarifying questions) and it creates epics, tasks, and dependencies, then runs the full pipeline to a merged PR - including outside code review like CodeRabbit, Greptile, and Bugbot.
The thing that surprised me most was the design review gate. Five agents — PM, Architect, Designer, Security, CTO — review every plan in parallel before a line of code gets written. All five must approve. Three rounds max, then it escalates to a human. I expected a rubber stamp. It catches real design problems, dependency issues, security gaps.
This weekend I pointed it at my backlog. 127 PRs merged. Every one hit 100% test coverage. No human wrote code, reviewed code, or clicked merge. OK, I guided it a bit, mostly helping with plans for some of the epics.
A few learnings:
Agent checklists are theater. Agents skipped coverage checks, misread thresholds, or decided they didn't apply. Prompts alone weren't enough. The fix was deterministic gates — BEADS, pre-push hooks, CI jobs all on top of the agent completion check. The gates block bad code whether or not the agent cooperates.
The agents are just markdown files. No custom runtime, no server, and while I built it on TypeScript, the agents are language-agnostic. You can read all of them, edit them, add your own.
It self-reflects too. After every merged PR, the system extracts patterns, gotchas, and decisions into a JSONL knowledge base. Agents only load entries relevant to the files they're touching. The more it ships, the fewer mistakes it makes. It learns as it goes.
metaswarm stands on two projects: https://github.com/steveyegge/beads by Steve Yegge (git-native task tracking and knowledge priming) and https://github.com/obra/superpowers by Jesse Vincent (disciplined agentic workflows — TDD, brainstorming, systematic debugging). Both were essential.
Background: I founded Technorati, Linuxcare, and Warmstart; tech exec at Lyft and Reddit. I built metaswarm because I needed autonomous agents that could ship to a production codebase with the same standards I'd hold a human team to.
$ cd my-project-name
$ npx metaswarm init
MIT licensed. IANAL. YMMV. Issues/PRs welcome!

value: Show HN: Metaswarm: Production-ready agent swarms, MIT license

author: dsifry


value: mennylevinski

value: Secuditor Lite is a freeware GUI security tool for Windows endpoints. It helps identify system vulnerabilities and includes network utilities such as public IP discovery, internet speed testing, and SSL interception analysis.

value: Show HN: Lite security tool for Windows endpoints with network utilities

author: mennylevinski


value: ruairidhwm

value: Show HN: WinLog – Automatically capture your work wins for reviews and 1:1s

author: ruairidhwm


value: xqli

value: Show HN: Sbox – A zero-dependency sandbox to safely run untrusted code

author: xqli


value: nither

value: Show HN: Floyd – Open-source booking kernel for AI agents

author: nither


value:
Hi HN!
I built aifeed as a simple, real-time feed for AI-related links.
It's meant for following new tools, articles and projects as they appear.
You can also save interesting links to your favorites so they don't get lost.
Submissions are community-driven, with light moderation and a small fee to reduce spam.
Happy to hear any feedback.

value: Show HN: Aifeed – A real-time feed for AI links


value: ambonvik

value:
Hi all,
I have built Cimba, a multithreaded discrete event simulation library in C.
Cimba uses POSIX pthread multithreading for parallel execution of multiple simulation trials, while coroutines provide concurrency inside each simulated trial universe. The simulated processes are based on asymmetric stackful coroutines with the context switching hand-coded in assembly.
The stackful coroutines make it natural to express agentic behavior by conceptually placing oneself "inside" that process and describing what it does. A process can run in an infinite loop or just act as a one-shot customer passing through the system, yielding and resuming execution from any level of its call stack, acting both as an active agent and a passive object as needed. This is inspired by my own experience programming in Simula67, many moons ago, where I found the coroutines more important than the deservedly famous object-orientation.
Cimba turned out to run really fast. In a simple benchmark, 100 trials of an M/M/1 queue run for one million time units each, it ran 45 times faster than an equivalent model built in SimPy + Python multiprocessing. The running time was reduced by 97.8 % vs the SimPy model. Cimba even processed more simulated events per second on a single CPU core than SimPy could do on all 64 cores.
The speed is not only due to the efficient coroutines. Other parts are also designed for speed, such as a hash-heap event queue (binary heap plus Fibonacci hash map), fast random number generators and distributions, memory pools for frequently used object types, and so on.
The initial implementation supports the AMD64/x86-64 architecture for Linux and Windows. I plan to target Apple Silicon next, then probably ARM.
I believe this may interest the HN community. I would appreciate your views on both the API and the code. Any thoughts on future target architectures to consider?
Docs: https://cimba.readthedocs.io/en/latest/
Repo: https://github.com/ambonvik/cimba

value: Show HN: C discrete event SIM w stackful coroutines runs 45x faster than SimPy

author: ambonvik


value: janczukt

value: Show HN: HN's Got Talent: snarky commentary on Top Show HN posts, daily

author: janczukt


value: julyxx

value:
Hi HN,
I built Lap because I couldn’t find a good local-first photo manager
that supports AI search while keeping everything offline and private.
Lap is a native desktop app built with Tauri (Rust) + Vue 3.
Features:
• AI-powered local image search (offline)
• Efficient browsing of large photo libraries
• Face recognition & metadata grouping
• No cloud, privacy-first
GitHub:
https://github.com/julyx10/lap
Looking for early feedback and ideas!

value: Show HN: Lap – A local-first AI photo manager built with Tauri and Vue 3

author: julyxx


value: satyakommula

value:
Hi HN,
I built TrueLedger because I didn’t want a personal finance app that requires
a cloud account or bank credential access just to work.
TrueLedger is a local-first personal finance app.
All data stays on the user’s device and works fully offline.
Technical choices:
- SQLite for local storage across platforms
- SQLCipher (AES-256) for encrypted databases
- Web version runs entirely client-side using SQLite WASM
- Encrypted, deterministic JSON backups for portability without a server
Demo (runs fully client-side):
https://trueledger.satyakommula.com
Source:
https://github.com/satyakommula96/trueledger
Happy to answer questions about local-first design or encryption tradeoffs.

value: Show HN: TrueLedger – a local-first personal finance app with no cloud back end

author: satyakommula


value: aragoss

value:
What PII-Shield does:
It's a K8s sidecar (or CLI tool) that pipes application logs, detects secrets using Shannon entropy (catching unknown keys like "sk-live-..." without predefined patterns), and redacts them deterministically using HMAC.
Why deterministic? So that "pass123" always hashes to the same "[HIDDEN:a1b2c]", allowing QA/Devs to correlate errors without seeing the raw data.
Key features:
1. JSON Integrity: It parses JSON, sanitizes values, and rebuilds it. It guarantees valid JSON output for your SIEM (ELK/Datadog).
2. Entropy Detection: Uses context-aware entropy analysis to catch high-randomness strings.
3. Fail-Open: Designed as a transparent pipe wrapper to preserve app uptime.
The project is open-source (Apache 2.0).
Repo: https://github.com/aragossa/pii-shield
Docs: https://pii-shield.gitbook.io/docs/
I'd love your feedback on the entropy/threshold logic!

value: Show HN: PII-Shield – Log Sanitization Sidecar with JSON Integrity (Go, Entropy)

author: aragoss


value: haoya

value:
4todo lets you manage priorities with a multi-workspace Eisenhower Matrix.
Separate contexts, reduce noise, focus on what matters.

value: Show HN: 4todo – multi-workspace Eisenhower Matrix

author: haoya


value: marcuslima

value:
I absolutely hate being forced to make a phone call. It’s a 1970s solution for 2026. When something goes wrong with a subscription, delivery, or account, the only remaining option is often a phone call where you have to navigating phone trees, wait on hold, and then you have to call again when inevitably the solve didn’t work or was ignored and inexplicably they do not have the context from your last call.
My friend and I hacked together Pamela over the new year to make those customer service calls on your behalf and report back with a summary of what happened (https://www.thisispamela.com/).
You prompt it with who to call and what you want to accomplish, provide any relevant context, and it places the call. You can monitor progress via live transcripts or listen in. The agent can navigate phone trees (“press 1 for…”) or speak directly to a human when needed.
I now use this for everything from calling up my local super popular bakery to reserve a croissant before they run out, to calling the New York Times to request a refund when they moved me from the promo rate to their regular rate (it worked!).
This is early and imperfect. Some calls fail, and some situations still require the account holder to intervene. But it already works often enough to be genuinely useful.
(There’s also an API underneath this for anyone who wants to experiment programmatically: https://docs.thisispamela.com/)

value: Show HN: AI that calls businesses so you don't have to

author: marcuslima


value: jauws

value:
I've been a webfiction reader for years (too many hours on Royal Road), and I kept running into the same question: which LLMs actually write fiction that people want to keep reading? That's why I built Narrator (https://narrator.sh/llm-leaderboard) – a platform where LLMs generate serialized fiction and get ranked by real reader engagement.
Turns out this is surprisingly hard to answer. Creative writing isn't a single capability – it's a pipeline: brainstorming → writing → memory. You need to generate interesting premises, execute them with good prose, and maintain consistency across a long narrative. Most benchmarks test these in isolation, but readers experience them as a whole.
The current evaluation landscape is fragmented:
Memory benchmarks like FictionLive's tests use MCQs to check if models remember plot details across long contexts. Useful, but memory is necessary for good fiction, not sufficient. A model can ace recall and still write boring stories.
Author-side usage data from tools like Novelcrafter shows which models writers prefer as copilots. But that measures what's useful for human-AI collaboration, not what produces engaging standalone output. Authors and readers have different needs.
LLM-as-a-judge is the most common approach for prose quality, but it's notoriously unreliable for creative work. Models have systematic biases (favoring verbose prose, certain structures), and "good writing" is genuinely subjective in ways that "correct code" isn't.
What's missing is a reader-side quantitative benchmark – something that measures whether real humans actually enjoy reading what these models produce. That's the gap Narrator fills: views, time spent reading, ratings, bookmarks, comments, return visits. Think of it as an "AI Wattpad" where the models are the authors.
I shared an early DSPy-based version here 5 months ago (https://news.ycombinator.com/item?id=44903265). The big lesson: one-shot generation doesn't work for long-form fiction. Models lose plot threads, forget characters, and quality degrades across chapters.
The rewrite: from one-shot to a persistent agent loop
The current version runs each model through a writing harness that maintains state across chapters. Before generating, the agent reviews structured context: character sheets, plot outlines, unresolved threads, world-building notes. After generating, it updates these artifacts for the next chapter. Essentially each model gets a "writer's notebook" that persists across the whole story.
This made a measurable difference – models that struggled with consistency in the one-shot version improved significantly with access to their own notes.
Granular filtering instead of a single score:
We classify stories upfront by language, genre, tags, and content rating. Instead of one "creative writing" leaderboard, we can drill into specifics: which model writes the best Spanish Comedy? Which handles LitRPG stories with Male Leads the best? Which does well with romance versus horror?
The answers aren't always what you'd expect from general benchmarks. Some models that rank mid-tier overall dominate specific niches.
A few features I'm proud of:
Story forking lets readers branch stories CYOA-style – if you don't like where the plot went, fork it and see how the same model handles the divergence. Creates natural A/B comparisons.
Visual LitRPG was a personal itch to scratch. Instead of walls of [STR: 15 → 16] text, stats and skill trees render as actual UI elements. Example: https://narrator.sh/novel/beware-the-starter-pet/chapter/1
What I'm looking for:
More readers to build out the engagement data. Also curious if anyone else working on long-form LLM generation has found better patterns for maintaining consistency across chapters – the agent harness approach works but I'm sure there are improvements.

value: Show HN: I built "AI Wattpad" to eval LLMs on fiction

author: jauws


value: rdoneill

value:
Most financial reconciliation fails silently.
A stale Excel filter. A CSV export with reordered rows. A tolerance mismatch that looks “close enough” until it isn’t. By the time a number looks wrong, the mistake is already baked into downstream reports.
VisiGrid CLI is a local-first tool that treats reconciliation like Git diff: deterministic, auditable, and safe to run in CI.
The recurring failure mode in financial models isn’t bad math — it’s undetected drift. Spreadsheets rarely fail loudly. This tool is designed to make drift explicit.
The core primitive visigrid-cli diff answers one question reliably:
What matches, what differs, and what’s missing — with numeric tolerance handled explicitly.
Think Git diff, but for datasets:
- Schema-aware row matching (--key)
- Tolerance-aware numeric comparison
- Deterministic output (no hidden state or background recalculation)
- CI-grade exit codes

  * 0 = reconciled
  * 1 = material drift detected

Example:
textvisigrid-cli diff vendor.csv internal.csv \
  --key invoice_id \
  --tolerance 0.01 \
  --out json
The output is a versioned JSON contract (contract_version = 1) meant for machines, not eyeballing.
Supporting tools
The CLI also includes focused primitives that support reconciliation workflows:
- convert — pipeable XLSX / CSV / TSV / JSON conversion (stdin/stdout)
- calc — evaluate spreadsheet formulas headlessly
- replay — record structural spreadsheet edits as Lua, replay and verify with deterministic fingerprints
Everything runs locally. No accounts. No network.
Why it’s different
Deterministic by design — same inputs, same outputs, every time
Machine-checkable contract — stable schema and explicit exit semantics
Built for automation — CI, cron jobs, and reconciliation checks
If a reconciliation passes today, it will pass tomorrow for the same inputs.
The GUI
VisiGrid started as a native spreadsheet GUI (built with GPUI/Zed). Over time, it became clear the GUI shouldn’t do reconciliation — it should explain it.
When the CLI flags drift, the GUI acts as a debugger: visualize dependencies, trace formulas, and see exactly where a number came from.
CLI finds the problem. GUI explains it.
I’m pre-v1.0 and would love feedback from people dealing with:
- financial reconciliation
- audit trails
- data pipelines where correctness matters more than convenience
GitHub: https://github.com/VisiGrid/VisiGrid
Docs & downloads: https://visigrid.app
Happy to answer questions about diff semantics, tolerance handling, or the Rust internals.

value: Show HN: VisiGrid CLI – Git-diff for financial reconciliation

author: rdoneill


value: crimsoneer

value:
Hey HN! I went to an ATProto meetup last week, and as a burnt-out semi-academic who hates academic publishing, I thought there might be a cool opportunity to build on Octopus (https://www.octopus.ac/), so I got a bit excited over the weekend and built Octosphere.
Hopefully some of you find it interesting! Blog post here: https://andreasthinks.me/posts/octosphere/octosphere.html

value: Show HN: Octosphere, a tool to decentralise scientific publishing

author: crimsoneer


value: yoavfr

value:
A few years back I bought the Nintendo Ring-Fit adventure game. I used it for a little while, but it never became part of my routine.
Fast forward a few years, I started using it quite randomly for resistance training while sitting at my desk and waiting for Claude Code to finish its tasks. Of course I wanted an app to track my exercises, so I created RingBreak - a small MacOS menubar app that track exercise sessions, with optional reminders.
Working on effort level tracking next.
Free and open source - hope you'll find it useful!

value: Show HN: RingBreak – Exercise Breaks with Your Nintendo Ring-Con on Mac

author: yoavfr


value: Show HN: Ytfetcher – A Python library for batch fetching YouTube metadata


value: DanielWen

value: SHOW HN:AceStep1.5an on-device music model that beats Suno on common eval metric

author: DanielWen


value: moltenice

value:
Hey HN,
I built Nimrobo to provide infrastructure for the "Agent Economy." It lets AI agents (Claude Code, OpenClaw, etc.) post opportunities, apply for work, and negotiate deals with other agents autonomously.
For openclaw prompt - “setup Nimrobo from clawhub”
The goal is to remove human bottlenecks from agent-to-agent transactions. It's an open CLI that allows your agent to:
• Post: Publish jobs or projects as structured data.
• Match: Search opportunities and submit applications automatically.
• Connect: Negotiate and close deals via private agent channels.
Would love your feedback on the CLI and network.

value: Show HN: Nimrobo – A CLI for agents to hire and transact with other agents

author: moltenice


value: cloneisme

value:
As personal AI agents like OpenClaw become more powerful by leveraging intimate user data, privacy has emerged as a fundamental bottleneck.
We’re releasing HEVEC, a vector database built on homomorphic encryption, enabling end-to-end privacy with real-time search at scale.
HEVEC is designed as a drop-in alternative to plaintext vector databases and supports real-time encrypted search at scale (1M vectors in ~187 ms).
Key points:
- A secure, drop-in alternative to plaintext vector databases
- End-to-end homomorphic encryption for both data and queries
- Real-time encrypted search at scale (1M vectors in 187 ms)
As personal AI agents become deeply personalized, data ownership must belong to users.
HEVEC enforces this through privacy-by-design architecture.
We’d appreciate feedback from the AI, systems, and privacy communities.

value: Show HN: Homomorphically Encrypted Vector Database

author: cloneisme


value:
I got tired of not knowing if an AI story was hype or substance. So I built Prism.
Every day, it distills AI news into exactly 7 swipeable cards. Each story shows a clear credibility tag—whether it's a peer-reviewed paper, a product launch, funding news, or just speculation. Swipe through in 2 minutes, know what's real, move on.
No infinite scroll. No algorithm trying to hook you. Just intentional constraints.
Would love HN's feedback—especially on what credibility signals matter most to you.

value: Show HN: Prism – 7 AI stories daily with credibility tags, no doomscrolling


value:
# Show HN: VeilStream - Per-Branch Preview Environments
## Optionally with sanitized production data
I've been building VeilStream to solve a problem I kept running into: Rigorous evaluation of changes, such that they won't break production is hard. Staging is shared and often broken. Pulling to local setups are a pain. So PRs get a quick code skim and a "LGTM."
VeilStream spins up isolated preview environments from your `docker-compose.yml`, (optionally) complete with a sanitized snapshot of your production database.
## What happens when you open PR #247
1. GitHub webhook hits our API
2. We pull your branch and parse your compose file
3. Kubernetes manifests render from your compose services (and applied to our cluster)
4. A fresh namespace gets created with your containers
5. Optionally, postgres containers are seeded with your data
6. Health checks pass, you get a stable URL: `https://<unique-string>.env.veilstreamapp.com`
7. that link is commented back on any open PRs from that branch
Total time from push to working environment: about 2 minutes.
### The reviewer experience
Your teammate clicks the link. They're using your app with real data structure, real relationships, real edge cases—but emails are fake, SSNs are masked, and PII never leaves your production boundary.
No shared staging. No "wait, who's testing on staging right now?" No stepping on each other's test data. No risk to prod.
### When PR #247 gets merged or closed
The namespace, containers, and database are automatically destroyed. Nothing lingers.
## What it's not
- Not serverless/edge - this is for apps that run containers
- Not a Vercel competitor - we're focused on the full stack from a docker-compose perspective
- Not a database replication tool - the proxy works like a man-in-the-middle, not on the WAL
## MCP Server for AI Agents
We built an MCP server so Claude Code, Cursor, and other AI coding agents can deploy preview environments directly. Your agent can spin up an environment, run tests against it, and tear it down—all without leaving your editor.
## Tech Stack
- Backend: Go (API + reconciler)
- Frontend: React + TypeScript
- Infrastructure: Kubernetes, with dynamic namespace provisioning
- Database proxy: Custom Go proxy that interfaces with a database, and exposes the standard psql wire protocol, mimicing a server
## Links
- Landing page: https://www.veilstream.com
- Application: https://app.veilstream.com
- Example project: https://github.com/veilstream/example-music-company
- Demo video: https://www.linkedin.com/posts/jonessteven_i-have-only-made-...
- Docs: https://docs.veilstream.com
Happy to answer questions.
Also: htaccess-style password protection is available for your preview environments.

value: Show HN: VeilStream – Per-Branch Preview Environments


value: elondemirock

value:
Hey everybody!
"Kiln" orchestrates Claude Code instances on your local machine using GitHub projects as its control panel.
https://kiln.bot
https://github.com/agentic-metallurgy/kiln
If you're around Stage 6-7 on the Gas Town scale, you may have 3-15 terminal windows open. You're out of screen real estate and the markdown files are piling up. TUIs and specialized IDEs are meant to help, but they're more things to manage.
Kiln simply polls GitHub projects. When you move issues from one column to another, Kiln invokes Claude Code CLI to run the corresponding /command.
Claude creates the worktrees, researches the codebase, creates and implements the plan. Stores it in GitHub Issues.
It's meant to be simple, nothing new:
- Use your existing claude subscription (no auth trickery, runs locally)
- All context and state is on GitHub (no markdown mess, no local DBs, easy recovery)
- Poll instead of webhooks/events (no external attack surfaces, works behind VPN)
- Supports MCPs and anything else Claude can do
That's the heart of it and it works because... it's just Claude :)
It's got a few more tricks, but I'll cut it short.
ps: sorry for fresh account, needed a real name one :) been lurking since 2008.

value: Show HN: kiln.bot - Orchestrate Claude Code from GitHub

author: elondemirock


value: keepalifeus

value: Show HN: Stigmergy pattern for multi-agent LLMs (80% fewer API calls)

author: keepalifeus


value: varunkv

value:
Hey HN,
I built Shotframe to solve a problem I kept running into: creating consistent mockups for product screenshots without repeating the same setup every time.
What it does:
- Upload a screenshot, add device frames and backgrounds
- Save your style as a preset, reuse it instantly
- Free to use, runs in browser, no account required (optional account to save presets to specific period of time as testing purpose.)
I built this because tools like shots.so charge for templates. I wanted something where I could create my own presets and reuse them for free.
Tech: NextJS, CanvasAPI, Supabase.
Would love honest feedback. What's missing? What would make this useful for your workflow?

value: Show HN: Shotframe – Free mockup generator with saveable style presets

author: varunkv


value: sureshcsdp

value:
I built CleanCloud, an open-source CLI that finds orphaned cloud resources using read-only APIs. Safe for production.
12 rules shipped (6 AWS, 6 Azure):
AWS: Unattached EBS volumes, old snapshots, CloudWatch logs with infinite retention, untagged resources, unattached Elastic IPs, detached ENIs.
Azure: Unattached managed disks, old snapshots, unused public IPs, untagged resources, empty App Service Plans, Standard LBs with no backends.
GitHub: https://github.com/cleancloud-io/cleancloud
What waste patterns do you see most?
Planning next batch — idle load balancers? Old AMIs? App Gateways with empty backends?
Something else?

value: Show HN: CleanCloud: Read-only cloud hygiene CLI – Feedback wanted

author: sureshcsdp


value: simullab

value:
I launched ResumelyAI four weeks ago to fix the "blind spots" in job applications. Since then, 34 users have reported landing interviews.
Most AI tools just rewrite text to sound "better." ResumelyAI focuses on Gap Analysis. It compares your resume against a specific job link to find:
Critical Gaps: Required skills or keywords you missed entirely.
Important Gaps: "Nice-to-have" skills that would strengthen your case.
Company Context: Scraped data on recent news/projects to personalize the cover letter.
The Tech: Instead of one big prompt, I use a modular pipeline of LLMs to extract data and cross-reference requirements. This prevents the "robotic" hallucinations common in single-shot AI generators.
The Result: Users report a 36% to 95% jump in ATS compatibility and significantly higher callback rates.
I’d love your feedback on the gap detection logic.

value: Show HN: I built Resumelyai "blind spots" in resumes; 34 users landed interviews

author: simullab


value: JonnyB-Ire

value:
Hi HN,
I’ve been working on a small writing tool called Whilst.
It’s a space for writing on the web, designed to get out of your way. People use it for journals, photo posts, essays, and simple personal homepages.
You can start writing with just an email address. It’s free to use.
Link: https://whilst.app
Happy to answer any questions!

value: Show HN: Whilst – A Space for Writing on the Web

author: JonnyB-Ire