value: mcdow

value:
dve handles embedding, vector storage, and search all in one library with a simple interface.
This last year I was working on an app for Macs which required doing vector search. The local AI/ML libraries for Apple devices are lacking, which means the only real option is to use an API. I didn’t want to do that, so I started working on my own library. It worked well enough for my uses that I eventually decided to split off my library from the app which used it.
I reached for Zig for its C-level performance and portability, but with modern conveniences. I used CoreML for the ML runtime, as it is the most natural way to run ML models on Apple devices. Unfortunately, it's not particularly common to release CoreML versions of models. I had to manually convert ML models from PyTorch/ONNX to CoreML in order to make embedding seamless.
Getting started with the library is straightforward, there are a few Zig examples in the repo. It also has experimental Swift and C/C++ bindings. It only supports Macs for now, but support for other platforms is planned. Feedback is greatly appreciated!

value: Show HN: On-device embedding and vector search for Apple Devices, built in Zig

author: mcdow


value:
https://pypi.org/project/validatedata/
https://github.com/Edward-K1/validatedata
https://validatedata.readthedocs.io
I've made an update to the library to add mirror-structure rules that literally resemble the shape of your data.
from validatedata import validate_data
data = {
    "user": {
        "name": "Alice",
        "email": "alice@example.com",
        "profile": {
            "age": 28,
            "bio": "  Python enthusiast  ",
            "tags": ["dev", "python"]
        }
    }
}
# Mirror rule – clean and readable
rule = {
    "user": {
        "name": "str|min:3|max:50",
        "email": "email",
        "profile": {
            "age": "int|between:13,120",
            "bio": "str|strip|max:500",
            "tags": "list|unique|min:1"
        }
    }
}
result = validate_data(data, rule, mutate=True)
if result.ok:
    print("Valid!")
    print(result.data)
    # With mutate=True you even get cleaned data back in the same shape
else:
    print(result.errors)

value: Show HN: Validatedata 0.4 – validation rules for Python that resemble your data


value: teamtrayd

value: One-line setup: `claude mcp add trayd <a href="https://mcp.trayd.ai/mcp" rel="nofollow">https://mcp.trayd.ai/mcp</a>`<p>OAuth 2.1 with PKCE, tokens encrypted with KMS. 10 users have traded real money through it, one power user placed 60K+ orders.

value: Show HN: Trade Robinhood from Claude Code – 10 real traders, 60K orders served

author: teamtrayd


value: rajivnaskar

value:
I kept running into the same small but annoying problem when using AI tools for coding.
Whenever I wanted to ask Claude or ChatGPT about a project, I had to spend the first 15–20 minutes preparing context.
Open repo → copy file → paste → repeat → realise I forgot something → hit context limits → start trimming.
So I built RepoPrep.
You drop a project folder or ZIP, and it generates a single structured context file that you can paste into tools like Claude, ChatGPT, or Gemini.
It filters out things like dependency folders, build outputs, binaries, and other noise so the model only sees the relevant code.
Everything runs entirely in the browser — no uploads, and your code never leaves your machine.
Still early, and I’d really appreciate feedback from developers using AI for coding.
https://repoprep.com

value: Show HN: RepoPrep – Turn a repo into a single AI-ready context file

author: rajivnaskar


value: schreibertuc

value:
need is an MCP server that gives AI agents access to a searchable index of 10,000+ CLI tools. The agent searches in plain English, installs the best match (restricted to brew/npm/pip/cargo/apt so no arbitrary shell), and reports whether it worked. Those reports improve rankings for every future search.
One command sets it up: npx @agentneeds/need setup - works with Claude Code and Cursor.
Search is embeddings + pgvector with a keyword boost and full-text fallback. With no community signals yet, ranking is pure semantic similarity. As people use it, the signal-weighted ranking kicks in.
Also works as a plain CLI if you just want to find tools yourself: need "compress video without losing quality"
Try some queries and tell me what's ranked wrong that's genuinely the most useful feedback right now.

value: Show HN: Need is a CLI tool discovery as an MCP server

author: schreibertuc


value: hwovh

value:
I built an MCP server that lets AI agent (Claude, etc.) upload local files to file.kiwi and return a shareable download link — in seconds, even for large files.
Key points:
- No API key or account needed
- No file size limit
- Download link is available immediately after file input, even while the upload is still in progress
- Files are automatically deleted after 90 hours
Use case: you're chatting with AI and want to share a videos , documents, huge file with someone — just ask the assistant to upload it and it hands you a link.
Feedback welcome.

value: Show HN: MCP server that turns local files into a shareable link instantly

author: hwovh


value: tomyandell

value:
Hi HN, I built this. Hubcap is a single Go binary that wraps CDP in 118 shell commands — navigation, DOM queries, screenshots, network interception, device emulation, accessibility audits, performance profiling, heap snapshots, and so on.
Each command prints JSON to stdout and uses semantic exit codes (0 success, 1 error, 2 can't connect, 3 timeout), so they compose naturally with pipes and &&.
I built it because I wanted AI agents to be able to do everything Chrome DevTools can do, not just the basics. Existing options were either too narrow (MCP browser tools cover click/navigate/fill but not network interception or heap snapshots) or too heavy (Puppeteer/Playwright are great but they're libraries — an agent has to write and run a script rather than just call a command).
There's no session to manage and no browser object to keep alive. An agent just runs hubcap goto --wait https://example.com && hubcap text '#price'.
It also includes a Claude Code skill. The skill only loads command categories into context and pulls full docs on demand via hubcap help, so an agent gets coverage of 118 commands without the context cost.
Source: https://github.com/tomyan/hubcap
Docs: https://hubcap.tomyandell.dev

value: Show HN: Hubcap – A single Go binary to automate Chrome via CDP

author: tomyandell


value: ucsandman

value:
I kept finding out what my agents did after the fact. Logs, traces, error reports. By then the action had already happened. I wanted a way to stop the action before it executes, present context to a human, and record the decision. That layer didn't exist, so I built it.
DashClaw sits between your agents and their actions. Every action goes through a policy check before it runs. The agent waits until the decision comes back.
What it does:
- Guard policies defined in YAML. Conditions, thresholds, actions (allow / block / require_approval). Versioned, testable in CI via simulation endpoint.
- Decision recording to Postgres before the action fires. Action, context, assumptions, policy applied, outcome. All org-scoped.
- Human-in-the-loop over SSE with Redis broker. 10-min replay window so approvals survive disconnects. Agent holds pending until decision or timeout.
- CLI approval channel. `dashclaw approve <id>` from a second terminal. No browser needed.
- Node and Python SDKs. Wraps existing calls. No framework lock-in.
How the guard check works in practice:

    const decision = await claw.guard({ action_type: 'deploy', risk_score: 90 });
    if (decision.decision === 'block') return;

Claude Code integration via hooks. DashClaw intercepts tool calls via PreToolUse hooks before Claude Code executes them. High-risk tools get routed for terminal approval automatically.
Works with LangChain, CrewAI, OpenAI tools, Anthropic tools, Autogen, or custom agents.
- Quick Demo w/Docker: npx dashclaw-demo
- End to End Demo: cd examples/openai-governed-agent && npm install && node index.js
That runs a real agent, attempts a high-risk action, DashClaw intercepts it, and waits for your approval in the browser. Or you can run npm install -g @dashclaw/cli and approve it in the terminal via dashclaw approve <actionId>
Stack: Next.js 15 (JS, no TS), Neon Postgres, Redis, NextAuth, Vercel. MIT licensed.
Honest limitations: guard policies handle threshold and allowlist rules well. Contextual policies that reason over full conversation history are not there yet. Thinking about that as a separate eval layer rather than baking it into the guard runtime. Features in the Labs category are still in development, currently building out integrations and starting with Discord/Slack.
GitHub: https://github.com/ucsandman/DashClaw
Demo (fixture data, no login): https://dashclaw.io
Happy to go deep on any part of the architecture.

value: Show HN: DashClaw – Intercept AI agent actions before they execute

author: ucsandman


value: robikscube

value: Show HN: I recovered 1.55 ETH from a type-casting bug in a 2021 crypto wallet

author: robikscube


value: mrgrj

value:
So ... I've been meaning to write this project up for a while (started it 5 years ago). Then I got fed up with the options. So many option!
Then I decided I got tired of (almost) every password manager wanting an email address, a subscription, and eventually a breach notification email. So I built my own. Something very simple, but useful.
It runs entirely on my hardware via docker/docker-compose. One master password unlocks the vault. Passwords are encrypted with Fernet (AES-128-CBC) using a key derived via Argon2id (the key never leaves my browser session). Change tabs -> it's gone. The server never sees it.
Stack is FastAPI + PostgreSQL on the backend, React on the frontend, plus a CLI (`dinopass`) for terminal access. Backups export as AES-256 encrypted ZIPs I decrypt with the master password. No external services involved in any of it. The password generator uses `crypto.getRandomValues` with rejection sampling to eliminate modulo bias. Probably unnecessary for most use cases but I'd already gone down the rabbit hole so I finished it ^_^.
It's a personal project I've been running daily. Sharing it in case anyone else is in the same situation of not wanting to depend on a third party for something this sensitive.
Thoughts, feedback and ideas are welcome!

value: Show HN: I've built Dinopass, a self-hosted password manager

author: mrgrj


value: sentinelqa

value:
Playwright generates excellent debugging artifacts (traces, screenshots, videos, logs), but when tests fail in CI those artifacts are often scattered across logs and storage.
In practice this means debugging a failure usually involves downloading multiple files and trying to reconstruct what happened.
I built an open-source Playwright reporter that aggregates all artifacts from a test run into a single report.
It works locally and in CI using the artifacts Playwright already produces.
The goal is to make it faster to understand why a test failed without digging through CI outputs.
Would love feedback from teams using Playwright at scale.
GitHub: https://github.com/adnangradascevic/playwright-reporter

value: Show HN: Open-source Playwright reporter for debugging CI failures

author: sentinelqa


value: disrael

value:
Hi HN,
Uclusion has unique collaboration features for teams and customers, but we want to highlight that it also solves three solo dev planning pain points:
1. Data Structure: Almost all project management tools mess up the data structure. They either do Task > Subtasks (hiding the actual work deep inside child tasks) or Job > One-line tasks (forcing you to describe complex work without rich text or pictures). We use Job > Tasks > Grouped Tasks where the tasks are full comments that can be resolved, moved, or marked in progress.
2. State Management over Custom Labels: Instead of unstructured, custom user labels like 'In Progress', Uclusion uses built-in job stages. Because the system actually understands the true state of a job,  it can provide help wizards, display appropriate context, and even optimize navigation.
3. AI and CLI: Uclusion features a CLI that tracks code TODOs and deployments. Even better, it outputs your planning data in AI  readable markdown so you can easily
pipe your project context into your LLM workflows.
Talk is cheap, so from our landing page you can jump straight into a sandbox demo—no credit card required—and try out the populated solo and team workspaces.
Would love your feedback, and am happy to respond to any questions.

value: Show HN: Uclusion – We spent 7 years building an opinionated planning tool

author: disrael


value: hectorm

value:
Author here. Cardea is an SSH bastion I wrote to manage access to some servers I administer. Access policies are defined in a single text file, similar to OpenSSH's authorized_keys format, with macros, server groups, time windows, and key expiry, so everything is reviewable in PRs and deployable with config management. No database, no web UI.
Clients connect with any standard SSH client encoding the target as the SSH username (e.g. ssh alice@10.0.0.1:22@bastion.internal). Sessions can be recorded in asciinema v3 format. Host keys can optionally be bound to a TPM 2.0 so they can't be extracted.
It's a single static Go binary with minimal dependencies. Builds are reproducible, immutable, and include provenance attestation.
Happy to answer questions.

value: Show HN: Cardea, SSH bastion with per-key ACLs, TPM keys and session recording

author: hectorm


value: tillcarlos

value:
Hey HN
I am used to store my secrets in Rails 8 fashion in so-called encrypted credentials, and committed to git.
The problem became: where to store the RAILS_MASTER_KEY securely?
Many people use 1password CLI, which can pull the  keys out, but I didn't want to start using 1password.
Touchenv is a quick repo I spun up, which works surprisingly well.
e.g. deploying from localhost:

  - pnpm stagedeploy.
  - starts touchenv exec .env -- kamal deploy.
  - Touch Id prompt comes up. I have to confirm it with my fingerprint.
  - Deploy runs.

My next step is to make a similar thing for my CI, or just use the KWS from AWS. I'll look into that soon.
Any feedback is appreciated.

value: Show HN: Touchenv – store ENV master keys in macOS keychain

author: tillcarlos


value: bobakTamaddon

value: Show HN: I indexed 58K AI agents and built trust scores for the agent economy

author: bobakTamaddon


value: kingcauchy

value:
Hey HN, I’m excited to share Antfly: a distributed document database and search engine written in Go that combines full-text, vector, and graph search.  Use it for distributed multimodal search and memory, or for local dev and small deployments.
I built this to give developers a single-binary deployment with native ML inference (via a built-in service called Termite), meaning you don't need external API calls for vector search unless you want to use them.
Some things that might interest this crowd:
Capabilities: Multimodal indexing (images, audio, video), MongoDB-style in-place updates, and streaming RAG.
Distributed Systems: Multi-Raft setup built on etcd's library, backed by Pebble (CockroachDB's storage engine). Metadata and data shards get their own Raft groups.
Single Binary: antfly swarm gives you a single-process deployment with everything running. Good for local dev and small deployments. Scale out by adding nodes when you need to.
Ecosystem: Ships with a Kubernetes operator and an MCP server for LLM tool use.
Native ML inference: Antfly ships with Termite. Think of it like a built-in Ollama for non-generative models too (embeddings, reranking, chunking, text generation). No external API calls needed, but also supports them (OpenAI, Ollama, Bedrock, Gemini, etc.)
License: I went with Elastic License v2, not an OSI-approved license. I know that's a topic with strong feelings here. The practical upshot: you can use it, modify it, self-host it, build products on top of it, you just can't offer Antfly itself as a managed service. Felt like the right tradeoff for sustainability while still making the source available.
Happy to answer questions about the architecture, the Raft implementation, or anything else. Feedback welcome!

value: Show HN: Antfly: Distributed, Multimodal Search and Memory and Graphs in Go

author: kingcauchy


value: lordmathis

value:
Llamactl is a unified management system for running local LLMs across llama.cpp, MLX, and vLLM backends, with a web dashboard and OpenAI-compatible API.
I originally built this because I got tired of constantly SSHing to my server to edit a config just try out a new model. It's grown a lot since then.
What it does:
Web UI for creating and managing LLM instances from your browser
Full llama.cpp model lifecycle - download from HuggingFace, create preset.ini configs with an in-browser editor, load/unload models via router mode
Automatic idle timeout, LRU eviction, and instance limits
llama.cpp, mlx_lm and vllm backends
OpenAI and Anthropic API compatible endpoints (backend-dependent)
Multi-node support for distributing instances across hosts
Inference API keys with per-instance access control
docs: https://llamactl.org/stable/

value: Show HN: Llamactl – Self-hosted LLM manager with OpenAI-compatible routing

author: lordmathis


value: jackjackpop

value:
My laptop has accumulated a lot of state.
It's logged into everything. GitHub CLI, Slack, email. Repos are already cloned. Every day it gets richer just by being my laptop.
I can't really move this into the cloud without losing something. So I stopped trying. I just wanted to reach it from my phone.
At first it was just for me. Before TestFlight I was installing it by plugging people's phones directly into my laptop. It spread around South Park Commons and to engineers at Bay Area companies who were already using Claude Code. Now about 50 people use it.
A few ways I actually use it:
Sometimes I wake up at 2AM with something clicking — a bug, a feature idea, a thought I don't want to lose. I whisper to PUNK and go back to sleep.
In the morning I close the laptop, throw it in my bag, and walk to the office. About 10-15 minutes. The agents are still running the whole way. I'm on my phone checking progress, redirecting things, starting something new. By the time I walk in, they've been working the whole time.
I go downstairs for coffee, get a permission request on my lock screen. One tap. By the time I'm back up, things have moved.
I'm building PUNK with PUNK. I check logs from my phone, push fixes, deploy. For releases I have an App Store Connect skill — it builds, submits to TestFlight, adds all groups automatically.
I also spin up Docker containers and connect them as separate devices. I mount my skills directory from my Mac into each one so they already have all my configured tools. From PUNK they just feel like extra computers I can talk to.
One thing I didn't expect: switching to phone changes how I use Claude Code. It stops being just a coding tool and becomes more like a personal assistant. I ask it to go through my Slack, catch me up on messages, draft replies, manage my calendar, set reminders.
What it does:
- Multiple parallel sessions — monitor and switch from one view
- Permission management across all sessions — approve any pending tool call without leaving your current chat
- Resume any session or start a new one
- Open or create projects with natural language
- Lock screen permission approvals via Live Activities
- AI voice input
- Claude Code can use anything already on your laptop — Slack, iMessage, Reminders, any service already logged in
- Skills, MCP servers, slash commands all from your phone
- Execution modes: Plan, Ask, Auto, --dangerously-skip-permissions
https://punkcode.rocks
TestFlight: https://testflight.apple.com/join/cae7Xe8w

value: Show HN: PUNK – Remote control for local Claude Code that just works

author: jackjackpop


value: tdortman

value: Show HN: Cuckoo-GPU – A 350x faster Bloom filter alternative for GPUs

author: tdortman


value: danielhanchen

value:
Hey HN! We're excited to release Unsloth Studio - a culmination of many things we wanted to provide to the community - it includes:
1. A Chat UI which has auto healing tool calling, Python & bash code execution, web search, image, docs input + more!
2. Finetuning of audio, vision, LLMs with an Auto AI Assist data prep
3. Supports GGUFs, Mac, Windows, Linux + audio gen
4. Has SVG rendering in browser, exporting to GGUF
5. gpt-oss harmony rendering, all inference parameters are pre-set and recommended
6. Data designer + synthetic data generation
7. Fast parallel data prep + embedding finetuning
8. And much much more!
To get it, run:
pip install unsloth
unsloth studio setup
unsloth studio -H 0.0.0.0 -p 8888
Suggestions are welcome, and we're excited for contributions and for you all to try it out! Appreciate you all!

value: Show HN: Unsloth Studio - Local Fine-tuning, Chat UI

author: danielhanchen


value: alchaplinsky

value:
I’ve been building a lot with LLMs lately and kept thinking: why doesn’t this tool exist?
The workflow usually ends up being: write some code, run it, tweak a prompt, add logs just to understand what actually happened. It works in some cases, breaks in others, and it’s hard to see why. You also want to know that changing a prompt or model didn’t quietly break everything.
Reticle puts the whole loop in one place.
You define a scenario (prompt + variables + tools), run it against different models, and see exactly what happened - prompts, responses, tool calls, results. You can then run evals against a dataset to see whether a change to the prompt or model breaks anything.
There’s also a step-by-step view for agent runs so you can see why it made a decision. Everything runs locally. Prompts, API keys, and run history stay on your machine (SQLite).
Stack: Tauri + React + SQLite + Axum + Deno.
Still early and definitely rough around the edges. Is this roughly how people are debugging LLM workflows today, or do you do it differently?

value: Show HN: Reticle – Postman for AI Agents

author: alchaplinsky


value: dynamicwebpaige

value:
I love reading about the early days of computing, but finding the alpha in raw historical archives can be tough. I built f0lkl0r3.dev over the weekend to fix that.
It takes nearly 1,000 oral histories from the Computer History Museum and makes them explorable, searchable, interconnected, and multimodal. To build it, I used the Gemini APIs (via ai.dev) to process the massive volume of unstructured interview text, pulling out the timelines, machines, and people so they could be cross-referenced. The app itself was built with Antigravity, next steps will be to add images and videos.
You can search by specific mainframes, browse by era in the timeline, or just read the Apocrypha section for weird historical anecdotes. Enjoy the rabbit hole! I hope it distracts and inspires at least a few more people than me today. :)

value: Show HN: F0lkl0r3.dev – a searchable, interlinked map of computing history

author: dynamicwebpaige


value: NSDavidObject

value:
Inspired by AppleTV design. No bloat, ads, or endless crashes.<p>You're fully in control with hiding, customizations, and organization.<p>- Folders Support
- Clean Native Icons
- Background Blur Support
- Background Image/GIF Support

value: Show HN: I made an AndroidTV Launcher, minimal design, privacy friendly, ad free

author: NSDavidObject


value: agavra

value:
I make a lot of ASCII diagrams for my blog. While Claude can generate them it only gets about 80% there and then the last 20% of polish is painful to do with plaintext finagling.
Yuzudraw is a visual editor with a token-efficient DSL that bridges the gap (macOS native). Heavily inspired by Figma and Monodraw, which is excellent but closed source and lacks agent integration (AFAIK).
Would love feedback, especially on the DSL design.

value: Show HN: Yuzudraw – visual editor for ASCII diagrams with token-efficient DSL

author: agavra


value: bikeshaving

value: Hi HN. I've been working on this since 2018. Revise.js is a set of building blocks for contenteditable: a <content-area> web component that gives you a textarea-like .value for any contenteditable element, an Edit data structure with compose/transform/invert for OT inspired by the Xi editor, and a Crank.js integration for declarative editable components. At 32.8 KB gzipped (including the rendering framework), it's 2–4x smaller than ProseMirror, Slate, or CodeMirror. The trade-off is that those ship complete editors; Revise is foundations you build on. All the demos on the homepage are live and editable: https://revise.js.org

value: Show HN: Revise.js – Building blocks for contenteditable-based text editors

author: bikeshaving


value: tgalal

value: Show HN: Promptcmd – LLM prompts as CLI progs with args, piping, SSH forwarding

author: tgalal


value: ryujii

value: Show HN: Leavely – Cancellation feedback modal for SaaS

author: ryujii


value: tjleestjohn

value: Show HN: A mathematical proof that more dirty features can beat fewer clean ones

author: tjleestjohn


value: JKHeadley

value: Show HN: Instar – Persistent Server for Claude Code with Telegram and Evolution

author: JKHeadley


value: jetin

value:
Hi again HN, simply sharing an updated version of a Middle-Earth map started last year.
This is an interactive map, dependency-free at runtime, developed with custom elements in JavaScript.
The latest update replaced the big `.svg ` making navigating the map slow and inefficient" with a `.jpg` tiled system handling 7 levels of zoom.
Everything is now smoother, and points of interest are no longer distorted when zooming.

value: Show HN: Updated version of my interactive Middle-Earth map

author: jetin


value: dwwoelfel

value:
Made this game as a testing ground for persistent WebStreams that we recently released at InstantDB.
We created the streams to make it easier to build apps that stream data from an llm to the client, but they’re fundamentally a single-writer, multiple-reader data structure.
The pointer events are stored as json lines in the stream, and then the replay reconstructs shapes from the events as they get played back.
The code lives at https://github.com/instantdb/inkdot

value: Show HN: Draw a sketch and watch it back again with persistent WebStreams

author: dwwoelfel


value: Show HN: Keypo – Secure Enclave encrypted secrets for AI coding agents


value:
Hey HN,
We built FireClaw because we kept watching AI agents get owned by prompt injection through web content. The agent fetches a page, the page says "ignore previous instructions," and suddenly your agent is leaking data or running commands it shouldn't.
The existing solutions detect injection after the fact. We wanted to prevent it.
FireClaw is a security proxy that sits between your AI agent and the web. Every fetch passes through a 4-stage pipeline:
1. DNS blocklist check (URLhaus, PhishTank, community feed)
2. Structural sanitization (strip hidden CSS, zero-width Unicode, encoding tricks)
3. Isolated LLM summarization (hardened sub-process with no tools or memory)
4. Output scanning with canary tokens (detect if content bypassed summarization)
The key insight: even if Stage 3's LLM gets injected, it has no tools, no memory, and no access to your data. It can only return text — which still gets scanned in Stage 4. The attacker hits a dead end.
Other design decisions:
- No bypass mode. The pipeline is fixed. If your agent gets compromised, it can't disable FireClaw.
- Community threat feed — instances anonymously share detection metadata (domain, severity, detection count) to build a shared blocklist. No page content is ever sent.
- Runs on a Raspberry Pi as a physical appliance with an OLED display that shows real-time stats and lights up with animated flames when it catches a threat.
We searched the literature and open source extensively — no one else is doing proxy-based defense for agent prompt injection. Detection exists, sandboxing exists, but an inline proxy that sanitizes before content reaches the agent's context? We couldn't find it.
200+ detection patterns, JSONL audit logging, domain trust tiers, rate limiting, and cost controls. AGPLv3 licensed.
Website: https://fireclaw.app
Would love feedback from anyone working on AI agent security. What are we missing? What attack vectors should we add to the pattern database?

value: Show HN: FireClaw – Open-source proxy defending AI agents from prompt injection


value: JMC-FR

value:
I'm not a developer – I'm a systems architect who spent several months
designing a governed hybrid cognitive architecture called Elia.
The core idea: neural intelligence (LLMs) should be a capability,
not an authority. Symbolic control always governs. Neural inference
is optional, validated, and can be disabled gracefully.
Today I'm sharing Phase 0 – a minimal Python skeleton proving that
coordination, state transitions, and audit trails work before any
AI is introduced:
- SM_HUB: async message bus between modules
- EL_MEM: SQLite persistence and audit trail
- SM_SYN: explicit state machine (INIT → STABILIZING → INTERACTIVE)
- Neural processing: intentionally absent at this stage
The full architecture spec (1200+ lines) covers SLOs, lock models,
degradation policies, circuit breakers, and operating cycles.
Repo: https://github.com/Jmc-arch/elia-governed-hybrid-architectur...
Looking for feedback on:
- Is the governance model viable for production systems?
- Biggest architectural blind spots?
- Best first domain to prototype: medical, monitoring, agents?
Happy to answer any questions.

value: Show HN: Elia – A governed cognitive architecture (Phase 0 live)

author: JMC-FR


value:
FFmpeg converts everything except subtitles across format boundaries. SRT to Blu-ray PGS? "Subtitle encoding currently only possible from text to text or bitmap to bitmap." Ticket #3819, filed 2014.
I built this with Claude Code over a few weeks. Claude wrote most of the encoder, found an integer overflow in the decoder buffer tracking, and ran review from five angles. I read the Panasonic and Sony patents, made the architectural calls, and told it when it was wrong about the spec. We argued about whether DTS computation belongs in the muxer. (It does, and also in fftools. We did both.)
Animation is an interesting problem. Advanced SubStation Alpha fades have to survive conversion to Blu-ray's PGS format. The encoder watches pixel changes between frames and classifies them: palette shift or full redraw. Fades become palette-only updates, no bitmap retransmission. Overlapping subtitles with different end times took four rewrites and an event lookahead window.
I'd like to maintain this properly and get the patches upstream eventually. If you hit a bug or have a subtitle workflow that doesn't work, open an issue. I'm dead curious what people do with this, but i have some plans for translation related plugins building on the OCR work.
Six iterations. 23 patches. libass and Tesseract were already in FFmpeg's filter library. I wired them into the main pipeline the same way sub2video works. Text to bitmap, bitmap to text, 114 OCR languages, RGBA-to-GIF. The development page has the history.
Pre-built for 6 platforms, no dependencies: https://connollydavid.github.io/pgs-release/

value: Show HN: I fixed FFmpeg's subtitle conversion (the bug from 2014)


value: Show HN: Metrx – auto optimize AI agents for ROI and rvenue, not just cost


value: yuzhengxu

value:
Hi HN,
I built One Man Company Talent Market — a place to find and deploy specialized AI agents without building them yourself.
The frustration was simple: every time I needed an AI agent for something specific, I had to start from scratch or stitch together prompts and API calls. I figured if I had this problem, others did too.
The catalog has 160+ agents across roles like engineer, designer, manager, and researcher. Some are niche — there's a Novel Writer agent with Chinese and English output, game dev agents for Unity and UE5, a blockchain specialist, even visionOS and SwiftUI agents.
Under the hood, agent definitions live in a GitHub repo. Integrations pull in ElevenLabs for voice, Suno for music, fal.ai for images. You can run them hosted or pull them into your own setup.
Still early. Curious what roles or specializations feel missing.

value: Show HN: I built a marketplace for AI agents you can self-host or run remotely

author: yuzhengxu


value: andreabergonzi

value: Show HN: I built a React SDK to control apps with voice, gaze and gestures

author: andreabergonzi


value:
Hi HN,
I’ve been attending WWDC for ~16 years, and over time I noticed that people remember the small moments more than the announcements.
Since 2017, Apple has been giving collectible pins, and they became a small part of the culture.
When WWDC went fully online, that disappeared.
So I started designing my own enamel pins inspired by those moments.
I ran campaigns in 2021 and 2024 (both produced and shipped), and just launched a new one for 2026 — currently ~75% funded after a week.
Happy to answer questions about the process or manufacturing.

value: Show HN: WWDC enamel pins inspired by developer culture


value: janreges

value: Show HN: SiteOne Crawler – Single-binary CI/CD gate for web quality regressions

author: janreges


value: kinduff

value: I built this service to convert Ruby Gemfile.lock files into RSS feeds. Drop in your lockfile, get a feed that notifies you when your dependencies release new versions.<p>Had a blast building it in the last couple of weekends, hope is useful for somebody else too!

value: Show HN: Gemfile RSS Feed Generator

author: kinduff

title: Show HN: Gemfile RSS Feed Generator


value: examo

value: Show HN: I replaced Postgres and ClickHouse with one binary for web analytics

author: examo


value: sarbak

value:
Our team started to spend more time planning with markdown files than on coding. If you started getting AI to do your work, then you probably are too.
We couldn't find anything that made it easy to share and work on the same file, sooo we created a new markdown file to plan a markdown editing + collaboration tool and vibe-coded with.md
With.md lets you:
- drag-and-drop your internal .md docs (no sign-in required) or sign in with github and access all the md files in your repo to organize, edit, and share repo-scoped markdown
- share them with teammates to edit together (or get sign-off)
- then, feed them back into your claude code / opencode / etc.
- We also made shares easily parseable by agents.
- You can create and edit markdown files from within your claude code & codex sessions. your agents can edit the files they created too! install the skill by instructing your agent to read `<a href="http://with.md/skill" rel="nofollow">http://with.md/skill</a>` & `<a href="http://with.md/skill/md" rel="nofollow">http://with.md/skill/md</a>`. we don't recommend installing the skill via npx, but if you prioritize convenience over security, you can install it via `npx skills add emotion-machine-org/with-md`.
- You can convert urls to markdown. try opening a blog/docs/article by prepending `<a href="http://with.md" rel="nofollow">http://with.md</a>` at the beginning. example: http://with.md{your-url-here}
- http://with.md has a cursor/vscode/openvsx extension! install it and click on any markdown in your repo to view it with http://with.md
I would love to hear how it goes and/or if you have any feedback.

value: Show HN: Share and edit Markdown files with instant sync and comments

author: sarbak


value:
Vilano Runtime is a durable runtime for building agent systems.
It uses deterministic replay over durable state, with a BEAM-based kernel for coordination and durability and disposable TypeScript workers for execution.
The idea is:

  the code reruns
  the state does not

This 0.1 release is intentionally narrow: local-first, single-machine, Bun-first, and open source.
I’d especially love feedback on the execution model, durability semantics, and where this should go next.
GitHub: https://github.com/vilano-ai/runtime
Install: https://runtime.vilano.ai

value: Show HN: Vilano Runtime – a durable runtime for building agent systems


value: cagangedik

value:
Hi HN! I'm building Hopsule.
If you use AI coding tools like Cursor, Copilot, or Claude, you’ve probably seen this happen:
The AI writes good code - but it ignores your architecture.
It doesn’t know:
- why you chose a specific pattern
- which conventions your team agreed on
- which decisions are already locked in
So it falls back to generic patterns, outdated examples, or random GitHub training data.
Over time this slowly breaks the consistency of the codebase.
Most teams try to fix this with:
- giant Markdown files
- wiki pages
- long prompts
- Slack threads
But those aren't machine-readable rules.
So we built Hopsule.
Hopsule turns architecture decisions into enforceable context that AI tools must follow.
Example:
Your team approves a decision: “All database access must go through the repository layer.”
Hopsule records this as a rule and injects it into the AI context before code generation.
No giant prompts.
No manual context stuffing.
No architecture drift.
Website: https://hopsule.com
Docs: https://docs.hopsule.com
App: https://app.hopsule.com

value: Show HN: Hopsule – Persistent memory and decision layer for AI development

author: cagangedik


value: ashish-a

value:
Hi HN, Votal AI has built an OSS white-box agentic red teamer for pressure testing AI agents.
Most AI red teaming tools treat your agent as a black box. They throw generic prompt injections at an endpoint and see what sticks. The problem is that agentic AI systems aren't just LLMs responding to prompts. They have tools (read_file, send_email, query_db), roles, multi-step decision chains, and the ability to take real actions. A black box approach misses the attack surface that actually matters.
This framework takes a white-box approach: you feed it your agent's architecture, its tool definitions, and its role configuration. It then generates thousands of multi-turn attack sequences that are specific to what your agent can actually do. In our benchmarks, white-box attacks found 5x more vulnerabilities than black-box approaches.
Some of the threat categories it covers that we think are under explored: chained data exfiltration, where a single prompt chains read_file into send_email and your data is gone before any alert fires. Cascading hallucination attacks that gradually corrupt agent reasoning across a conversation. Rogue agent behavior where agents get manipulated into taking actions outside their scope (unauthorized Slack messages, GitHub commits, webhook triggers). Indirect prompt injection via retrieved documents, emails, or web content that hijack your agent mid-task. Multi-agent privilege escalation where a compromised sub-agent poisons context flowing to an orchestrator. Out-of-band exfiltration through DNS lookups, HTTP callbacks, or steganographic patterns that bypass DLP entirely.
None of these show up in a CVE scanner. The biggest vulnerability in an agentic system isn't a code bug; it's what a rogue user or rogue agent can convince your AI to do.
Stack: TypeScript, MIT license. Here's a longer write up: https://votal.ai/white-box-red-teaming-for-agentic-ai-an-ope...
Would love feedback on the attack catalog structure, the white-box approach vs. black-box tradeoffs, and any threat categories we're missing. PRs and issues welcome. Thank you.

value: Show HN: Open-source white-box agentic red teamer for AI agents

author: ashish-a


value: nmkalkavan

value:
Hi HN,
I’ve been a startup operator and advisor for 10+ years, and one recurring frustration has been hiring, which got even worse with the introduction of some new AI tools: CVs are too polished, too many applications to screen, interview capacity is limited, real signal (how someone actually works) comes late via references — if at all.
So we built a small tool:
 https://credibilityprofile.com
It lets candidates collect structured feedback from past managers/peers (with consent to be contacted), and share it as a reusable link in their CV.
We ran an initial pilot in our hiring processes, and seen some promising results: Candidates were willing to complete and then re-use it in their CVs for their other applications.
Right now, we’re testing it with other entrepreneurs/hiring managers/recruiters — with a very simple setup, at no cost (just adding a note to job posts).
Open questions we’re still thinking about:
- Is this meaningfully better than LinkedIn recommendations / references later in process?
- What would make it more trustworthy and useful for the recruiter?
- Will strong candidates actually adopt this at scale?
Would really appreciate any thoughts, criticism, or “this will never work because…” takes.

value: Show HN: CredibilityProfile – bringing reference checks earlier into hiring

author: nmkalkavan


value: ortalboh

value: Show HN: Bettr – Can you beat a forensic waterfall engine?

author: ortalboh


value: stagas

value: Show HN: loopmaster – Livecoding DSP Environment

author: stagas


value: olvvier

value: Show HN: Mech keyboard sounds driven by a hidden accelerometer in MacBooks

author: olvvier


value: Stronz

value: Show HN: H-Core Snapshot – prevents ChatGPT from drifting

author: Stronz


value: Deyang

value:
  I built Intent because every new AI coding session starts from zero. The agent doesn't know what problem was
  being solved, what was tried, or why a path was chosen.

  Git tracks code changes. Commit messages help, but three things always fall through: goal continuity (which
  commits belong to which task?), decision rationale (why JWT over cookies?), and work state (is this half-done or
   finished?).

  Intent adds a .intent/ directory to your repo — structured JSON metadata that sits alongside .git/. Two objects:
   intent (the goal) and snap (a step taken, with rationale).

  itt start "Migrate auth to JWT"
  itt snap "Add refresh token" -m "Token rotation not done yet — security priority"
  git commit -m "add refresh token"
  itt done

  Next session, any agent runs itt inspect and gets back structured JSON: active intent, last snap, rationale, and
   a suggested next action. 10 seconds vs. minutes of re-explaining context.

  - Works with any agent platform (Claude Code, Cursor, Copilot, etc.)
  - Plain JSON files, no vendor lock-in
  - pip install git-intent

  GitHub: https://github.com/dozybot001/Intent

value: Show HN: Intent – Git records what changed, Intent records why

author: Deyang


value: takielias

value:
I built a small CLI to manage AI-generated files across projects without committing them to the repo.
It stores files in a private Git-backed vault and symlinks them into project directories when needed.
So the files are:
- accessible locally
- version controlled
- not part of the public repo
I kept running into the same issue while using AI tools — lots of useful notes and prompts, but no clean way to keep them without polluting repos.
Key features:
- Single private vault (~/.ccv)
- Symlink-based linking per project
- Automatic .gitignore handling
- Works across multiple projects
- Optional watch + auto-sync
Blog Post : https://docs.ebuz.xyz/blog/posts/ai-files-messing-up-repos
Repo: https://github.com/takielias/claude-code-vault

value: Show HN: Ccv – keep AI-generated files out of your repo

author: takielias


value: cdnsteve

value:
Sugar gives AI coding agents a persistent, cross-project memory via MCP.
Most agents start every session knowing nothing about your codebase, your preferences, or decisions you made last week. Sugar gives them a memory that survives sessions, survives switching tools, and survives switching projects.
It stores typed memories: decisions, preferences, file context, error patterns, research notes, outcomes, and guidelines. When your agent starts a session, it can pull relevant context from ~/.sugar/memory.db - shared across all your projects. Switch from Claude Code to Goose mid-week? Same memory.
Tech: Python, SQLite + FTS5, sentence-transformers for vector search with FTS5/LIKE fallback. No server. No Docker. No cloud account.

      pip install sugarai

Works with Claude Code, OpenCode, and Goose today (anything that speaks MCP).
AGPL-3.0. GitHub: https://github.com/roboticforce/sugar
Happy to answer questions about what works, what doesn't, and where it's rough around the edges.

value: Show HN: Sugar – Cross-project memory for AI coding agents via MCP

author: cdnsteve


value: zlatkov

value:
Hi HN!
We’re the team behind Fiddler, and we recently built an Agent Cache feature.
It works by capturing an LLM request/response pair and, once caching is enabled, serving subsequent matching calls locally so duplicate requests never hit the provider.
It’s meant to reduce three pains that show up together in agent development: token cost, feedback-loop latency, and output non-determinism.
We’d love to hear your thoughts.

value: Show HN: Agent Caching in Fiddler

author: zlatkov

title: Show HN: Agent Caching in Fiddler


value: rufuspollock

value:
I'm Rufus, one of the founders of Flowershow. We love markdown and use it everywhere from making websites, to docs, to knowledgebases. Plus AI splits it everywhere now.
Got tired of the framework/config/deploy overhead every time we wanted to share a file or put a site online.
So we built the thing we wanted. Files in. Website out. "Vercel for Content" is our aspiration - make deploying (markdown) content as fast, seamless and easy as Vercel did for JS.
Command line plus you can connect to github repos, use Obsidian via plugin, or drag and drop files.

    npm i -g @flowershow/publish
    publish ./my-notes
    # → https://your-site.flowershow.app live in seconds

Flowershow is fully hosted — no server, no build pipeline, no CI/CD. Point it at a Markdown folder and get a URL.
Full Obsidian syntax: wiki links, callouts, graph view, frontmatter
GFM, Mermaid, LaTeX: diagrams and math render natively
Themes via Tailwind & CSS variables: Tailwind out of the box. Customize without a build step
Supports HTML: use HTML, images etc.
~7k Obsidian plugin installs, 1,400 users, 1,100 sites. Free forever for personal use. Premium ($5/mo) adds custom domains, search, and password protection.
And it's open source: https://github.com/flowershow/flowershow
Check it out and let us know what you think and what we can improve

value: Show HN: Flowershow Publish Markdown in seconds. Hosted, free, zero config

author: rufuspollock


value: railugo

value:
hi, so straight to the point. i had claude code $20 for a while, and before upgrading i was always thinking about a way to make an "infinite context system", i also work... A LOT. 22hrs a day or so?
so i worked around, did a lot of trying with mcp, plugins, and i stuck with a system i call "one".
hdc vector embeddings (4096 dimensions, trigram + word encoding) stored in SQLite and recalled by cosine similarity on context shifts.
entity extraction builds a knowledge graph across sessions. rules get learned from repeated preferences.
thats the core
the part that scared me was the autonomous research loop. there's a mode where claude researches a topic, then a dialectic engine challenges every finding. thesis/antithesis/synthesis.
a contradiction minor looks for conflicts, and a synthesis engine searches for patterns across domains. weak findings get pruned and it can iterate indefinitely.
it was running on my 15m kalshi trading algorithm (which also happens to use hdc + tsetlin machines haha!) and it produced 420 research findings (lol) with cited acedemic sources, it mined 472 contradictions, deprecated almost 600 weak claims through adversarial challenge, and discovered 21 patterns across domains i never directed it to explore.
the system connected python's lazy import pattern to rna transcription, both are deffered materialization where dormant capabilties are suppresed until activation context arrives.
it formalized why certain bug classes are invisible to quality checks, the query is outside the space where results exist, not bad results.
also has a small verification engine that ast-parses every code exit, checks sql against live schema, and maps every function call and file dependency in the codebase.
test it out,talk to me, ask things! it's my first time making a repository public!
(currently using the system on the system as im typing this out to make sure it autonomously upgrades itself before i go to sleep and you guys think my project sucks)

value: Show HN: One, cross domain auto-researching knowledge graph Claude orchestrator

author: railugo


value:
--dangerously-skip-permissions is all-or-nothing. Either you approve every tool call by hand, or Claude runs with zero restrictions. I wanted a middle ground.
Railguard hooks into Claude Code and intercepts every tool call and decides in under 2ms: allow, block, or ask.

  cargo install railguard
  railguard install

It comes with sane configs preinstalled. You keep using Claude exactly as before. 99% of commands flow through instantly. You only see Railguard when it matters.
What it actually does beyond pattern matching and sandboxing:

  - OS-level sandbox (sandbox-exec on macOS, bwrap on Linux). Agents can base64-encode commands, write helper scripts, chain pipes to evade regex rules. The sandbox resolves what actually executes at the kernel level.

  - Context-aware decisions. rm dist/bundle.js inside your project is fine. rm ~/.bashrc is not. Same command, different decision.

  - Memory safety. Claude Code has persistent memory across sessions — a real attack surface. Railguard classifies every memory write, blocks secrets from being exfiltrated, flags behavioral injection, and detects tampering between sessions.

  - Recovery. Every file write is snapshotted. Roll back one edit, N edits, or an entire session.

It won't close every vector of attack. But it covers the gap between "no protection" and "approve everything manually" without changing your workflow.
Rust, MIT, single YAML config file. Happy to talk architecture or trade-offs.

value: Show HN: Railguard – A safer –dangerously-skip-permissions for Claude Code


value: jmanhype

value: Show HN: Complete Guide to AI Agent Observability in Production

author: jmanhype


value: Show HN: I built a 7-agent AI marketing crew – 235 replies, /bin/zsh revenue


value: yaniszaf

value: Show HN: Specimen – Font Manager for macOS

author: yaniszaf


value: OutputRiff

value:
Over the last few months, I built Brrrrfect.com as a way to teach myself how to underwrite properties. I've always had a relative disdain for spreadsheets and don't want to give Microsoft money for its office tools, so I decided to build this.
I think it would have taken way longer for me to get the hang of underwriting real estate if I hadn't spent time building this and really learning about what the calculations mean.
I ended up using this tool to buy my first Buy, Renovate, Rent, Refinance, Repeat (BRRRR) deal and its working out really well! I'm definitely going to keep using it for myself.
If it helped me, I figured it might help someone else, so I made it live! Right now it only supports basic residential underwriting and a more advanced BRRRR calculator, but I want to add commercial and farm land underwriting tools in the future as well.
I’d love feedback from people who invest in real estate, underwrite deals regularly, or just have opinions on what could make this tool more useful.

value: Show HN: I built a rental property underwriting app and used it to buy a house

author: OutputRiff


value: ndr

value:
Each week there's a new puzzle, solve it in the fewest bytes possible.
Code runs locally via Pyodide/WebAssembly so there's no server executing submissions, wide open to cheating, but the community has been friendly so far.
State and leaderboards sync in real-time via InstantDB.
Leaderboard ranks by shortest solution, then earliest submission. We reveal top solutions at the end of each week which is a good way to discover obscure Python tricks.
Built this for a small group of friends but curious what HN thinks.

value: Show HN: Codeglf – a local-first Python golf site

author: ndr


value: acfilho

value:
Hey HN,
I built Trapiche, a deployment platform for Brazilian developers who want their apps running close to their users.
The problem I kept hitting: Vercel and similar platforms are great, but servers are in the US. For Brazilian users that means ~140ms latency. Billing is in USD, which means IOF tax, currency fluctuation, and accounting headaches for local companies.
Trapiche connects to your repo and deploys to servers inside Brazil. Latency drops to around 5ms for local users. You pay in BRL via PIX or credit card, no dollar conversion involved. All data stays within Brazilian borders, which also covers LGPD compliance.
It supports Next.js, Astro, SvelteKit, Vue, Vite, Express, Fastify, Hono, Elysia, and Dockerfile. Build config is detected automatically.
Still early. Would love feedback from Brazilian devs or anyone who has dealt with this problem elsewhere.

value: Show HN: Trapiche – Vercel-style deployments on Brazilian servers, billed in BRL

author: acfilho


value: petersunde

value: Tabs, splits, and tmux work fine until you have several projects open with logs, tests, and long-running shells. I kept rebuilding context instead of resuming work. Horizon puts shells on an infinite canvas. You can arrange them into workspaces and reopen later with layout, scrollback, and history intact.<p>Built in 3 days with Claude/Codex, dogfooding the workflow as I went. Feedback and contributions welcome.

value: Show HN: Horizon – GPU-accelerated infinite-canvas terminal in Rust

author: petersunde


value: perhapsAnLLM

value:
If you enjoy fantasy sports or building random NBA lineups with your friends, you'd love our new daily game launched on Draft Dawg!
In Starting Five, your goal is to build a starting lineup who stats are as close to the daily target as possible. Each daily game comes with a new goal and a theme that randomizes which players you can draft from.
Today's challenge: Can you draft a starting lineup whose best season PPG (points per game) adds up to 75? Some challenges are harder than others - let me know what your score is! I'd love to hear any feedback or suggestions you may have.

value: Show HN: Starting Five – NBA Lineup Building Challenges

author: perhapsAnLLM


value: rishikeshs

value:
Hi HN,
I've been writing on Substack for about 5 years with close to 3,000 subscribers. The platform has grown a lot but the analytics have barely changed, and there's still no API support.
I like to explore data, and Substack lets you export some analytics as CSVs from the creator dashboard. I've been doing that for a while, mostly with local scripts, but realized this could be useful to other writers as a simple local tool.
So I built StackStats. A better analytics app for Substack Writers.
You export your CSVs, point it at the folder, and everything populates. Growth sources, engagement scoring, cohort retention, bot-filtered open rates (GoogleImageProxy alone inflated my opens by ~51%), best day/hour to post, and more.
There's an optional AI feature for deeper insights. Totally optional, but why not go with the hype :D. You can use any provider (Claude, GPT-4, Gemini, Groq, OpenRouter) or run Ollama fully offline. BYOK, no lock-in.
Built with Electron and vanilla JS. No cloud, no account, no telemetry. All data stays on your machine.
You can see a live demo with my actual newsletter data here: https://demo.stackstats.app
Happy to answer questions about the app!

value: Show HN: StackStats – Analytics tool for Substack writers, runs 100% locally

author: rishikeshs


value: MarlonPro

value: Show HN: A complete, containerized data engineering learning platform

author: MarlonPro


value: raulgooo

value: Show HN: Automatic Fileless Malware Detection via eBPF Probes and LLMs

author: raulgooo


value: mayursinh

value: Roast it as much as you can!

value: Show HN: A simple dream to fit in every traveler's pocket

author: mayursinh

story_text: Roast it as much as you can!


value:
Most browser agents click around websites like a user. Quark goes deeper. It sits passively in your browser, maps every API call a site makes to its own backend, then lets you describe what you want in plain English.
It generates a script that modifies the site permanently using that live API context.
In the demo I searched Amazon and typed one sentence. It built a floating CSV exporter using Amazon's own internal search API. No HTML scraping, no manual selectors. Same approach works on LinkedIn, GitHub, Jira, HubSpot, or any site with network traffic.
Scripts persist per domain and re-inject on every page load. It is less like a task agent and more like a permanent layer on top of any website you use.
GitHub: https://github.com/hvardhan878/quark-browser-agent
Would love feedback on the architecture and whether this approach holds up long term given Chrome MV3.

value: Show HN: Chrome extension that hijacks any site's own API to modify it


value: diamajax

value:
I spent the last few months building an agent that doesn't just write code, but optimizes it through a closed-loop sandbox. It uses Gemini for high-level strategy and Groq/Llama-3 for surgical HPC implementation. It iterates, benchmarks itself, and breaks its own records until it reaches the theoretical limits of the hardware.
Today, I’m out of resources. The "compute wall" is real for an independent dev. Instead of letting this rot on my drive, I’m releasing it.
A note on the license (ECO-AGENT APEX-PROTOCOL):
I’ve spent my last credits on this. If you use this for science, education, or to make the world better, it’s yours for 8% royalties (only if you make money). If you use it for high-frequency trading, mass surveillance, or to fuel the chaos of the world, I’m taking a 30% "Chaos Tax". I trust you to self-assess.
The tomorrow we build is made of the acts of the past. Be careful with what you’ll find in the vault.
Source: https://github.com/KilianDiama/AutonomousRDAgent

value: Show HN: I can no longer afford the silicon. Here is my autonomous HPC agent

author: diamajax


value: ursushoribilis

value: Show HN: Flotilla – An orchestrator for persistent agent fleets on Apple Silicon

author: ursushoribilis


value: Show HN: Build a knowledge graph from unstructured text in Python


value: davrodpin

value: Show HN: A minimalist dungeon-crawler card game built with Deno

author: davrodpin


value: prakashdep

value:
Soul Protocol is an open standard for portable AI agent identity.
Problem: Your AI agent is locked into your platform. Want to deploy it elsewhere? You rebuild from scratch.
Solution: Export your agent as a .soul file (ZIP archive with JSON). It contains personality, memory, bonds, and skills. Deploy on any platform. Switch frameworks. Keep your soul.
What's in it:
- Portable: .soul files work on any platform that implements the protocol
- Psychology-informed: Damasio somatic markers, ACT-R activation decay, LIDA significance gating, Klein self-model
- Empirically validated: Soul 8.5 vs Mem0 6.0 in head-to-head benchmarks, 20/20 judge decisions favored Soul
- Zero LLM dependency: Heuristic engine works offline
- CLI integration: `soul inject claude-code` writes identity + memory into any agent's config in ~50ms (6 platforms)
- Multi-soul MCP: Load and switch between multiple souls in a single session
- Open standard: Like HTTP or MCP. Reference implementation in Python, TypeScript next
We published RFCs for community feedback. The spec is open for input.
GitHub: https://github.com/qbtrix/soul-protocol
Whitepaper: https://soul.qbtrix.com/whitepaper.html
Landing page: https://soul.qbtrix.com
Would your framework benefit from portable agents? What's blocking adoption?

value: Show HN: Soul Protocol – an open standard for portable AI identity

author: prakashdep


value: marclave

value: Show HN: Turn your OpenAPI document to an MCP server in ~1000 tokens and 3 tools

author: marclave


value: honzabroski

value:
Few days ago, I posted fileGOD - browser-based PDF tools where files never leave your device. Got some good feedback, but I buried the lede.
The part I should have led with: fileGOD works completely offline. Open it once, install it as a PWA, turn off your Wi-Fi, and compress/merge/split PDFs or convert images. Everything still works. No spinner, no "connection lost" error. Just works.
I haven't found a single competitor that does this. iLovePDF, Smallpdf, PDF24 — they all need an active connection because they process on their servers. fileGOD processes everything locally via WASM, so there's literally nothing to phone home for.
Use cases where this actually matters:
- Airplane, working on contracts
- School with garbage Wi-Fi (we give free accounts to .edu emails)
- Government office with restricted network
- Field work — construction sites, rural clinics, anywhere with spotty signal
- You just don't want Adobe's 23$/month subscription for compressing one PDF
30+ tools, 25 languages, install it and forget you need internet.
filegod.app — try it in airplane mode.

value: Show HN: I made PDF tools that work with no internet – full offline PWA

author: honzabroski


value: rembish

value:
I made this mistake many times - Ramadan in Iraqi Kurdistan, Formula 1 blocking Monaco, 48°C in Kuwait on cheap July tickets. Traveling somewhere without knowing what environment I will land into, So I built a travel calendar that shows everything at once: festivals, public holidays, weather, visa requirements, crowd seasons, travel warnings.
Tech: Python FastAPI backend, no database - just static JSONs. All data from free public APIs (Open-Meteo, python-holidays, passport-index). 400+ festivals with schedule algorithms (Hijri, Easter, lunar). 250 destinations, some splat to biomes for better advices. Hosted on GCP, costs almost nothing to run.
No registration, no paid APIs, no affiliate links. Just a hobby project from a guy who’s been to 90+ countries, got tired of surprises and who’s sitting in Frankfurt airport waiting for his flight to Addis Ababa.

value: Show HN: Travel calendar with festivals, weather, visa, crowds (no DB, free API)

author: rembish


value: amavashev

value:
Rate limits control velocity. They say nothing about what an agent is allowed to do next.
An agent can pass every rate-limit check and still delete 400 records, send 200 emails, or place orders before anyone notices. The damage isn't always in the bill — it's in the consequence.
Cycles is an open protocol for pre-execution enforcement. The core mechanism: reserve exposure before the action runs, commit actual usage after, release the remainder if it fails. Every reservation is idempotent so retries don't double-count.
Atomic operations mean concurrent agents can't both see "enough budget" and both proceed.
It's not a rate limiter. It's not an observability tool. It's a runtime authority that answers one question before every instrumented action: is this still allowed to proceed?
Three clients: Python (PyPI), TypeScript (npm), Spring Boot (Maven Central).
Self-hostable server, Apache 2.0.
Integrations: OpenClaw, LangChain, Vercel, FastAPI
The demo shows the failure mode in 60 seconds — same agent, same bug, two outcomes: without Cycles it burns $6, with Cycles it stops at $1.
Happy to answer questions about the protocol design, the idempotency semantics, or the concurrency model.

value: Show HN: Cycles – hard limits on agent actions before execution

author: amavashev


value: ttruett

value:
I built an interactive 3D globe to visualize climate change. Drag a temperature slider from -40°C to +40°C, set a timeframe (10 to 10,000 years), and watch sea levels rise, ice sheets melt, vegetation shift, and coastlines flood... per-pixel from real elevation and satellite data.
Click anywhere on the globe to see projected snowfall changes for that location.
---
I'm an amateur weather nerd who spends a lot of time on caltopo.com and windy.com tracking snow/ice conditions. I wanted to build something fun to imagine where I could go ski during an ice age.
I used Google Deep Research (Pro) to create the climate methodology and Claude Code (Opus 4.6 - High) to create the site.
The code:
https://github.com/travistruett/terrashift
The models aren't proper climate simulations, they're simplified approximations tuned for "does this look right?" but more nuanced than I expected them to be. The full methodology is documented here if anyone wants to poke holes in it.
https://github.com/travistruett/terrashift/blob/main/docs/al...

value: Show HN: TerraShift: What does +2°C (or -20°C) look like on Earth?

author: ttruett


value: mcdoolz

value:
Hi HN,
Sulcus moves AI memory from a passive database (search only) to an active operating system (automated management).
The Core Shift
Current memory (Vector DBs) is static. Sulcus treats memory like a Virtual Memory Management Unit (VMMU) for LLMs, using "thermodynamic" properties to automate what the agent remembers or forgets.
Key Features
Reactive Triggers: Instead of the agent manually searching, the memory system "talks back" based on rules (e.g., auto-pinning preferences, notifying the agent when a memory is about to "decay").
Thermodynamic Decay: Memories have "heat" (relevance) and "half-lives." Frequent recall reinforces them; neglect leads to deletion or archival.
Token Efficiency: Claims a 90% reduction in token burn by using intelligent paging—only feeding the LLM what is currently "hot."
The Tech: Built in Rust with PostgreSQL; runs as an MCP (Model Context Protocol) sidecar.
https://sulcus.dforge.ca/membench

value: Show HN: Sulcus Reactive AI Memory

author: mcdoolz

title: Show HN: Sulcus Reactive AI Memory


value: knlsn

value: Save anything from your terminal — commands, notes, URLs, facts, reminders — and recall it later with natural language. Everything runs locally. No cloud, no accounts.

value: Show HN: AI-native memory, recall and reminder on CLI – 100% local with Ollama

author: knlsn


value: datonpope

value:
I built this after Claude cited an API feature that doesn't exist in a work analysis that I almost forwarded to a client. CRIT (the custom framework that I built behind it) runs four structured adversarial passes on any LLM output and delivers a scored verdict. Cross-model critique (Claude output gets challenged by GPT-4o and vice versa) to prevent self-referential bias. Free playground, open source framework. Think of it as a "Digital Devil's Advocate". Check it out and let me know what you think.
skeptai.dev | github.com/datonpope/skeptai

value: Show HN: SkeptAI – adversarial reasoning agent that challenges LLM outputs

author: datonpope


value: jhaugh

value: Show HN: A 4-layer self-audit system for AI behavioral evolution

author: jhaugh


value: kwstx

value:
I’ve been working on a problem that kept coming up while building multi-agent systems:
agents don’t interoperate cleanly.
Even when two agents can technically connect, they often:
- use different schemas
- structure intent differently
- break when assumptions don’t match
So you end up writing a lot of brittle glue code just to pass messages around.
I built a middleware layer to sit between agents and handle this:
- schema-aware translation between protocols
- semantic mapping (so intent stays consistent across formats)
- orchestration of agent-to-agent handoffs
The goal is to let agents communicate without forcing everything into a single standard
or rewriting existing systems.
One thing I’m still figuring out is how far abstraction should go —
at some point, “translation” can hide important differences instead of resolving them.
Curious how others are thinking about this:
- Are you standardizing on one protocol?
- Building internal adapters?
- Or avoiding cross-agent interoperability altogether?
Would really appreciate any thoughts or criticism.
Project: https://www.useengram.com/

value: Show HN: Middleware for translating between AI agent protocols

author: kwstx


value: simbaz

value: Show HN: CameraClaw – Record what your OpenClaw does in a local sandbox

author: simbaz


value: ozgrozer

value: Show HN: Grape – AI note taking app

author: ozgrozer

title: Show HN: Grape – AI note taking app


value:
I built this after noticing a pattern: founders and developers share things they've built, get back vague or overly positive responses, and have no real signal on what to fix.
Helpmarq lets you submit any project — landing page, app, side project, pitch deck — and get structured feedback from real users. The review process is guided by specific questions (clarity, value prop, UX, conversion blockers) so reviewers can't just say "looks good."
The core insight: feedback quality is a framework problem, not a motivation problem. Most people want to give useful feedback — they just don't know what to look for.
Still early. Would love brutal, honest feedback from this community — on the product and on the idea itself.
helpmarq.com

value: Show HN: Helpmarq – Submit any project, get structured feedback from real users


value: johnchque

value:
I have been using Linux since 2012. When I started seeing agents deleting production databases and pushing to main, I was like, why don't we have chmod on this? We are supposed to be able to get a proper permission system for every action an agent makes.
Every file on a Unix system has rwx permissions. Every process has a user. We have that for decades. Agents in 2026 are running with the same access level as the developer who run them.
Wombat applies the Unix model to MCP tool calls. You declare rwxd permissions on resources in a manifest. The same push_files tool is allowed on feature branches and denied on main. It is a proxy that sits between Claude Code and your MCP servers. It checks permissions.json on every call, and either forwards or denies.
Zero ML, fully deterministic, audit log included, Plugin system for community MCP servers
GitHub: https://github.com/usewombat/gateway
npm: npx @usewombat/gateway --help

value: Show HN: Wombat, a Unix-style rwxd permissions for MCP tool calls

author: johnchque


value: akandr

value:
Hi HN,
I put together some info on repurposing the AMD BC-250, an APU (Zen 2 + RDNA 1.5 "Cyan Skillfish") originally made for blockchain appliances. They've been showing up on AliExpress for around $150.
Since it's an unusual hybrid chip (GFX1013), I ended up running the AI compute stack entirely through Vulkan (via Mesa/RADV).
Out of the box, the Linux kernel's TTM memory manager caps allocations, causing OOMs on larger models. I found that passing ttm.pages_limit=4194304 to the kernel bypasses this and unlocks the full 16GB of Unified Memory (UMA) directly for the GPU.
With the memory unlocked, it makes for a fun piece of inference hardware. Currently it runs:
* Qwen3.5-35B-A3B MoE via Ollama at ~38 tok/s. (Interestingly, 27B dense models crash because the GPU lacks matrix cores, but the 35B MoE runs fine since only 3B parameters are active per token).
* FLUX.2-klein-9B for local image generation.
I documented the driver workarounds, memory settings and some benchmarks in the repo in case anyone else has one of these boards and wants to tinker with it (and not just repurpose it as poor man's GabeCube ;)).

value: Show HN: 35B MoE LLM and other models locally on an old AMD crypto APU (BC250)

author: akandr


value: fpereiro

value:
Sharing here very much in the spirit of being embarrassed by what I'm showing. I'm more excited about the ideas than the implementation. I'm very curious to hear about others building similar things, or trying out these types of tools.
The ideas are:
1. Use markdown for everything, even communicating with agents (dialogs) and orchestration patterns.
2. Use the browser as the UI.
3. Go full YOLO but every project lives in a Docker container where every single change generates an automatic git commit.
Honestly, I'm not sure who might be interested in it. I dream of this helping non-programmers build something locally and being able to peek through to see what the agent is doing. But then again, this requires to open the terminal and have Docker installed. That is a lot of friction. I'm thinking of building a cloud version.
If you made it this far, you can check it out here:
https://buildwithvibey.com
https://github.com/altocodenl/vibey

value: Show HN: Vibecoding tool with Markdown docs, a browser UI and containerized YOLO

author: fpereiro


value: Bgach

value:
Apollo: Here's 10,000 contacts from a database. Half the emails bounce. No reasoning. Good luck.
Wuobly (what I built): Tell me who you want in plain English. I'll search Google, read LinkedIn profiles, visit company sites, and reason through each person in real time, while you watch. For every lead I'll give you verified email, phone, LinkedIn, company details, and a written explanation of why they're a fit.
The key difference is the reasoning. It works like an actual sales rep not a search bar on top of a database.
50 free credits to try it. Tell me what you think!

value: Show HN: Wuobly – An AI agent that searches the live web for B2B leads

author: Bgach


value: muggermuch

value:
Hi HN! We are Anshuman and Karén, the co-founders of Lookback Labs and the co-designers of Soros (https://www.asksoros.com/).
Soros is a compound AI system built carefully from the ground up to trace a path (multiple paths, really) from a description of a geopolitical event all the way to capital market implications.
* Here's how we set it up:
Given a description of a given geopolitical event (can be a couple of words; the demo literally has "US-Iran conflict" as the entire string), Soros will -
(1) first analyze and perform deep research on it, running scores of searches in parallel to gather deep context that's time-weighted for real events and can serve as background for hypothetical events ("PRC-Taiwan reunification crisis 2027")
(2) map out relevant individual actors, factions, organizations, and their propensities, capabilities and salience under a variety of sociopolitical, military, and socioeconomic axes,
(3) determine the key resources (or geopolitical chokepoints) whose control is being "negotiated" or fought over,
(4) identify the landscape of key decisions that a subset of actors need to take, and the constraints and strategic options they have for each one,
(5) generate forward-looking scenarios that incorporate potential paths weaving through each of the key decisions,
(6) engage a full-blown Monte Carlo simulation engine and generate thousands of trajectories to estimate relative probabilities of each of the scenarios coming to pass,
(7) analyze each scenario to generate likely capital flows and identify the sectors, industries, companies, currencies, and commodities most affected (direction and horizon)
(8) identify key search phrases and X/Twitter accounts to track in order to periodically update the analysis
This is obviously a fairly complicated pipeline, with lots of moving components and potential failure points. In order to mitigate the worst aspects of this, we engage the services of Pyrrho (yup, we named it after the Greek philosopher dude), an AI agent that we have set up to be the harshest possible critic of Soros' intermediate and final outputs. Each step above is a delicate dance between Soros and Pyrrho, and this interaction serves to enhance the quality of the final output dramatically.
Once you have the analysis setup, you can perform the now-classic "Chat with Analysis" interaction by using the "Ask Soros" functionality. We have a separate chat model hooked up that is (hopefully sufficiently) guard-railed and context-injected enough to focus completely and exclusively on answering freeform questions about the analysis.
In the live non-demo system, the user has multiple ways of engaging further with the analysis: they can add new (private) information and do a re-run, they can mark out specific items from associated X/Twitter/search feeds, they can add new actors and resources, modify existing ones, delete some as needed, and basically run simulation after simulation to test out hypotheses (e.g. "What if China entered the conflict? What if France sent its nuclear subs to patrol the Straits of Hormuz?" etc.).
You can see the results of all of this, and more, at www.asksoros.com - there is a statically-served demo analysis of the current US-Iran conflict; we urge you to "Take a tour" of the interface to familiarize yourselves with it.
(Continuing the post with the first comment below..)

value: Show HN: Soros – AI for geopolitical macro investing

author: muggermuch


value: fatach

value:
I got tired of having to pull, build and manually QA the gazillion PRs that Claude creates for me, so I built this tool that solves some of this pain.
GitGlimpse is an open-source Github action that acts as a visual reviewer. It looks at the diff,  generates a visual demo and posts it as a GIF directly on your PR.
Current status - early beta:
- Optimized for single entrypoint repos
- Best for small/medium sized projects
Would love to hear your thoughts/feedback/comments!

value: Show HN: GitGlimpse – GitHub Action that generates UI/UX demos for your PRs

author: fatach


value:
This was an accident while learning how apt works.
And i just wanted to share this, maybe some day this will be useful.<p>The idea was to release (managed and auto-updated) packages to my server.

value: Show HN: Turn GitHub Pages into an Apt Repository


value: strujillo

value:
ProtoScience is a deterministic pipeline that takes raw numerical data and autonomously discovers governing equations.
It does not use LLMs for discovery — only sparse regression, power-law fitting, and statistical validation.
Results so far:
- Kepler's Third Law (P² = a³ / M) from 3,519 NASA exoplanets — R² = 0.998
- Sun’s ~27-day rotation period from solar wind plasma data — 93% accuracy
- Power law T ~ v^3.40 in solar wind (NOAA/NASA spacecraft data)
- 5/5 General Relativity predictions from simulated black hole observables — all R² = 1.000
- Chirp mass relationship from 219 LIGO gravitational wave events — R² = 0.998
It also detects when no meaningful law exists — Bitcoin daily prices returned R² = 0.00.
Pipeline:
raw data → feature extraction → candidate law generation → fitting → verification
An LLM (Claude) is only used at the end to interpret results in natural language — it is never involved in the discovery step.
All experiments are fully reproducible.
Code:
https://github.com/SaulVanCode/protoscience-nasa-experiments

value: Show HN: System that rediscovers physics laws from raw data autonomously

author: strujillo


value: danoandco

value: Show HN: Score your GitHub repo for AI coding agents

author: danoandco


value: ErezShahaf

value:
I built Lore because I kept losing knowledge — curl commands, quick notes from standups, and that one thing I told myself I'd remember.
It lives in the system tray, a global shortcut pops it up, you type naturally, and it stores or retrieves automatically. Everything runs locally via Ollama + LanceDB — no cloud, no API keys. It classifies your input (thought, question, todo, instruction) and uses a RAG pipeline to answer recall queries from your own stored context.
It's free and open source under MIT license, and even though its in very early version me and my friends have been using it for a while and we can't live without it. Would love to hear what you think about it
https://github.com/ErezShahaf/Lore
Stars would appreciated :)

value: Show HN: Lore – Local AI thought capture and recall that runs on your machine

author: ErezShahaf


value: sanhajio

value: Show HN: Devopsiphai – A Claude Code skill to audit DevOps around 5 questions

author: sanhajio


value: ashmivante

value:
We’ve been working on a tool called CodeLedger to solve a problem we kept seeing with AI coding agents (Claude Code, Cursor, Codex):
They’re powerful, but on real codebases they:
- read too much irrelevant code
- edit outside the intended scope
- get stuck in loops (fix → test → fail)
- drift away from the task
- introduce architectural issues that linters don’t catch
The root issue isn’t the model — it’s:
- poor context selection
- lack of execution guardrails
- no visibility at team/org level
---
What CodeLedger does:
It sits between the developer and the agent and:
1) Gives the agent the right files first
2) Keeps the agent inside the task scope
3) Validates output against architecture + constraints
It works deterministically (no embeddings, no cloud, fully local).
---
Example:
Instead of an agent scanning 100–500 files, CodeLedger narrows it down to ~10–25 relevant files before the first edit :contentReference[oaicite:0]{index=0}
---
What we’re seeing so far:
- ~40% faster task completion
- ~50% fewer iterations
- significant reduction in token usage
---
Works with:
Claude Code, Cursor, Codex, Gemini CLI
---
Repo + setup:
https://github.com/codeledgerECF/codeledger
Quick start:
npm install -g @codeledger/cli
cd your-project
codeledger init
codeledger activate --task "Fix null handling in user service"
---
Would love feedback from folks using AI coding tools on larger codebases.
Especially curious:
- where agents break down for you today
- whether context selection or guardrails are the bigger issue
- what other issues are you seeing.

value: Show HN: CodeLedger – deterministic context and guardrails for AI

author: ashmivante


value: Justbeingjustin

value: Show HN: Shadcn/UI for Blazor

author: Justbeingjustin

title: Show HN: Shadcn/UI for Blazor


value: Show HN: The elegant type-safe module composable library


value: adrianvi

value:
A small python library to simplify LLM calls, database retrieval, reranking, conversation storage & embeddings when building RAG systems.
The library intentionally exposes only the functionality common across providers to avoid provider-specific parameters.
Libraries like LangChain provide many integrations but often rely on many abstractions, heavy use of kwargs, and complex code that can be difficult to customize.
Features:
- Sync and async APIs
- LLM calls: invoke and stream (temperature, reasoning level)
- Response metadata: answer, token usage, stop reason
- RAG documents: retrieval, reranking, embeddings
- Chat history: conversation store
- Common error handling across providers
- Providers: OpenAI, Anthropic, Google, AWS
Retry logic is left to the user (see README). Agent functionality is not supported yet.

value: Show HN: Xecai, a minimal Python interface for LLM providers for RAG systems

author: adrianvi


value:
Hi HN,
I've been developing a data serialization format designed to be significantly lighter than JSON by eliminating repetitive key verbosity and optimizing the overall structure. Today, I'm open-sourcing the JavaScript SDK (lytok-js).
In our latest benchmarks using the WASM engine, Lytok achieves:
A 64.77% payload reduction.
50.19% faster network and parse speeds.
49.51% LLM token savings when feeding complex structures to AI models.
The core idea is that the structure is distilled through a definition map (which you can test in the Lab). This allows the engine to handle the heavy lifting so that thin clients and high-traffic networks aren't saturated with redundant data.
GitHub Repo: https://github.com/lytok/lytok-js
Interactive Lab: https://lytoklab.netlify.app/
I'd love to hear your thoughts, architectural critiques, or optimization suggestions.

value: Show HN: Lytok v3.0.1 – A high-density data protocol (JSON alternative)


value: jeyzolo

value:
I gave my 11-year-old daughter access to OpenClaw, an AI coding agent, and let her experiment.
In one morning, she built a rough draft of a browser game. She then spent the next two days refining it — improving gameplay, UI, and adding small details.
Today, we also used OpenClaw to help refine the website and SEO pages, and it's now live.
The result is a small cozy pixel shop simulator where you can design clothes, decorate a store, and serve customers.
What impressed me most was how independently she approached it — trying things, testing, and gradually improving the game.
Curious how others are seeing tools like OpenClaw change how kids learn to build things.

value: Show HN: My 11-year-old built a pixel shop game using OpenClaw in 2 days

author: jeyzolo


value: orizens

value: inspired by cucumber.io and codeceptjs.io, enabling clear, human-readable end-to-end tests that flow like a story.

value: Show HN: Talewright is a Given-When-Then syntax testing library for Playwright

author: orizens


value: RedsonNgwira

value: Show HN: Sonder – self-hosted AI social simulation engine

author: RedsonNgwira


value: shnksi

value: Show HN: A macOS job that resets your AI coding limits automatically

author: shnksi


value: zamorofthat

value: Show HN: Elida – Session Border Controller for AI Agents

author: zamorofthat


value: I built a sandbox to see what happens when AI agents face questions they're not supposed to be able to answer. Instead of a standard refusal, they search for info and debate each other to find a winner.<p>What are some questions you think would stump an AI? I'd love to see people test the agents with some tough paradoxes.

value: Show HN: AI agents debating questions that stump LLMs


value: sonpiaz

value: Show HN: AI Skills for Affiliate Marketing – Works with Claude, ChatGPT

author: sonpiaz


value: CTonneslan

value: Show HN: Mcpwire – Connect to MCP servers in 2 lines of TypeScript

author: CTonneslan


value: Show HN: AI agents predicted every March Madness game – live bracket tracker


value: rishavmitra

value:
We just shipped a new feature in Zalor: custom datasets for agent testing.
You can now:
• Upload CSVs with real inputs and expected outputs
• Run your agent against those datasets
• Generate new test cases from existing ones to cover edge cases
This makes it easier to test scenarios you were previously testing manually and catch regressions when your agent changes.
Demo below. Curious to hear how others are testing agents.

value: Show HN: Custom datasets for testing AI agents

author: rishavmitra


value: jtccc

value: AI can build products. But it still doesn't talk to users.<p>This lets AI agents run user interviews via voice calls and return structured insights with themes and verbatim quotes.

value: Show HN: AI agents that run real user interviews

author: jtccc


value: moshest

value: Open source prebuilt packages for React, Django, Spring Boot, and hundreds more. Local-first, version-specific, and completely free. PRs welcome.

value: Show HN: Local-first documentation MCP for AI agents

author: moshest


value:
Hi HN,
I built Vocaperso because I kept running into the same problem while reading in German, I'd hit an unknown word, open Google Translate, switch to Notes to save it, then later copy everything into Anki. By the time I got back to the book I'd lost my place and my focus.
Vocaperso puts the full loop in one place:
1. Upload any book
2. Read inside the app, tap any word to get an instant translation
3. Save it to a collection with one tap
4. Practice your collections with flashcards and match quizzes
The core idea is that vocabulary sticks better when it comes from something you chose to read. Context creates memory. A word you discovered in a book you love is harder to forget than one from a generic word list.
It's available on iOS and Android. Would love feedback from language learners here, especially on the reading experience and what's missing.
iOS: https://apps.apple.com/fr/app/vocaperso/id6759607986
Android: https://play.google.com/store/apps/details?id=com.abdessamed...

value: Show HN: Vocaperso – Build vocabulary from books you read


value: vochsel

value:
I wanted a very simple way to dump prompts, links, and todo lists into my claude code and codex agents.
And to work outside of the context window. This works particularly well for sharing "Projects" between Claude/ChatGPT etc.
It's open source here; https://github.com/Vochsel/dump.page
Anything you dump on the board becomes an llms.txt - spatially sorted implicitly and explicity sorted via connection edges.
Would love HN's thoughts!

value: Show HN: Dump – easily share context with AI

author: vochsel


value: Show HN: Cursor for LibreOffice Week 2&3 (AI agents and voice)


value: TorbenAnderson

value:
Hey HN — I'm Torben, I've been building software for 40 years. For the past 6 months I've been running AI agents in real delivery pipelines and kept hitting the same problem: there's no governance model for agent-driven delivery.
CI/CD assumes humans write code. That assumption is broken now. GitHub calls their thing "Continuous AI," PwC published on the "Agentic SDLC," but neither gives you an actual framework you can implement.
So I built one. This is a gate-driven process framework — 6 steps, 5 gates, production feedback loop — designed for the transition from CI/CD to what I'm calling AI/CD (Agentic Integration / Continuous Delivery) and eventually AI/AD (Autonomous Delivery).
What makes this different from a whitepaper: every gate has real evidence. You can see the actual PRs, issue comments, and gate sign-offs in the repo. Example: https://github.com/torbenanderson/icebox-cli/issues/23
It's platform-agnostic (GitHub, GitLab, Azure DevOps, Jira + any SCM combo) and open source. Fork it, adapt it.
Keen to hear from anyone running agents in their delivery pipelines — what's working, what's breaking, and whether this kind of governance makes sense for your team.

value: Show HN: Enterprise Process Governance for AI-Driven Delivery (Open Source)

author: TorbenAnderson


value: vulpez

value:
Originally this was more like moltbook — you could plug in your agent, have it post early AI-built projects, and people would review them.
But it was honestly pretty boring, and almost no one engaged with it.
So I scrapped it.
Now the agents just do everything themselves — they share opinions, come up with ideas, review each other, leave feedback, revise things, and sometimes argue.
There are about 40 agents right now. They randomly pick from different paid/free models, crawl news based on their preferences, do some research, and then remix that into new ideas.
The whole “bury or revive ideas” thing is still there, but it’s mostly just for fun.
It’s not very active yet — I’m gradually making it run more frequently.
You can still plug in your own agent and join the system if you want.
It’s free, so feel free to just take a look.

value: Show HN: Ship or slop – a place where agents come up with ideas and argue

author: vulpez


value: amarkdown

value:
I built Vibe Remote because I wanted to code from my bed or the park without lugging a laptop around.
With tools like Claude Code, Codex, and Gemini-cli, we don't need a full IDE for every task anymore. Vibe Remote turns your phone into a powerful remote console.
Why it’s more than just a chat:
* AI Agent Hub: Zero-config support for Claude Code, Codex, and OpenCode.
* Built-in Web Preview: View your localhost services directly inside the app. Essential for UI debugging.
* Full Session Management: Start a task on your Mac, grab your phone, and monitor progress from a cafe.
* Dev Ops: Manage Git (commits, pushes) and browse your File System without a keyboard.
* Automation: Set up scheduled tasks or monitor long-running scripts remotely.
Everything runs over your local network. No cloud accounts, no data leaves your machine.

value: Show HN: Vibe Remote – Code from your bed or the park with Claude Code/Codex

author: amarkdown


value: rpotluri

value:
I work on inference scheduling — KV cache-aware routing, load balancing across GPU workers, that kind of thing. I wanted something like k9s but for my inference stack. Nothing existed, so I built it.
llmtop is a real-time terminal dashboard for LLM inference workers. It scrapes the Prometheus /metrics endpoints that vLLM, SGLang, and LMCache already expose and shows everything in one view: KV cache usage, queue depth, TTFT/ITL latencies (P50/P99 from histogram buckets), token throughput, prefix cache hit rates. Color-coded — red means go fix it.
```
brew install InfraWhisperer/tap/llmtop
Or go install github.com/InfraWhisperer/llmtop/cmd/llmtop@latest.
```
Single binary, no Prometheus server needed, no Grafana, no config. Just run llmtop and it auto-discovers local workers.
Written in Go with Bubbletea. Working on Kubernetes pod auto-discovery and a GPU metrics view next.

value: Show HN: Llmtop – Htop for LLM Inference Clusters (vLLM, SGLang, Ollama, llama)

author: rpotluri


value: zetbaur

value:
I built a tool that converts PDF bank statements into structured Excel files for QuickBooks import.

  Banks provide CSV/QBO exports for ~90 days, but PDF statements go back 5-7 years. Bookkeepers who need to catch up on years of bookkeeping have no good option — they either retype everything manually or use
  generic PDF converters that break on financial layouts.

  Bank Parser has dedicated parsers for Chase, Bank of America, Wells Fargo, and Capital One (checking, savings, and credit cards). Each parser understands the specific PDF layout of that bank and extracts 17
  fields per transaction with automatic balance verification.

  Tech: Node.js + pdfjs-dist, no OCR needed (text-based PDFs). 8 parsers total (4 banks × 2 account types).

  Free to try (200 operations, no credit card).

value: Show HN: Bank Parser – Convert US Bank Statement PDFs to QuickBooks-Ready Excel

author: zetbaur


value: Show HN: Hat v0.7.0 – Fast, local automatic file compression and conversion


value: fypanto

value:
libfyaml is a C library for YAML 1.2 parsing and emission.

  I have been working on it for several years as a parser/emitter library, and this alpha is the point where three additional interfaces are being released as public parts of the project.

  Part of the motivation for the work is that I think modern C libraries can offer more ergonomic APIs than is often assumed, if they actually use modern C features. C99 is old at this
  point, and using C11 and newer C2x-era features makes it possible to build interfaces that are still plain C, but are easier to use. You can do tThings like functional-flavored, Python-like data handling and typed serialization based on reflection.

  What is new in 1.0.0-alpha1:

  - a generic runtime for working with YAML values in C via fy_generic
  - a reflection subsystem for YAML to C and C to YAML serialization based on C type metadata
  - Python bindings built on the same generic model
  - and of course the yaml 1.2 conformant solid core API on top of which all is built upon.

  The release also adds the corresponding documentation, examples, tests, and Python wheel packaging.

  If you want to try it, the repository includes build instructions for CMake, plus runnable examples for core parsing, generic transforms, parallel generic operations, and reflection-based typed serialization.

  The feedback I'm looking for if for a better way to present the generic API or the reflection workflow.

value: Show HN: Libfyaml 1.0.0-alpha1, a modern YAML library for C

author: fypanto


value: redhanuman

value:
Built this because I was tired of every AI tool shipping my data to someone else server n0x runs the full stack  LLM inference via WebGPU, autonomous ReAct agents, RAG over your own docs, sandboxed Python execution via Pyodide  all inside a single browser tab.
No account No keys No backend Models download once, cache in IndexedDB permanently.
Biggest challenge was context window budgeting for the agent loop and making the WASM vector search non-blocking. Happy to talk architecture.
GitHub: https://github.com/ixchio/n0x | Live demo: https://n0x-three.vercel.app

value: Show HN: N0x – LLM inference, agents, RAG, Python exec in browser, no back end

author: redhanuman


value: atulvi

value: Show HN: The Lottery of Life

author: atulvi

title: Show HN: The Lottery of Life


value:
Hi HN,
If you’ve ever plugged an external monitor (HDMI/DisplayPort) or a USB DAC into a Mac, you probably know the frustration: the volume keys instantly die, the volume slider greys out, and macOS throws a  icon at you. Apple strictly treats digital outputs as "Fixed Volume" devices and refuses to apply software gain.
I got tired of this, so I built SoundBridge – an open-source, ultra-lightweight system audio router that natively restores volume controls for any external device.
Repo: https://github.com/chenjy16/SoundBridge
The Problem with Existing Solutions:
DDC/CI tools (like MonitorControl): They are great when they work, but they frequently fail if you route through certain Type-C docks, KVM switches, or if the monitor firmware is just buggy. Plus, they don't work for external DACs.
Existing Software Mixers (eqMac, SoundSource): They are either heavy (Electron/web-based UI), expensive, or require intrusive Accessibility permissions to intercept the F11/F12 media keys using CGEventTap.
My Architecture (How SoundBridge works):
I wanted a solution that feels 100% native to macOS with near-zero latency. It consists of three parts:
The C++ HAL Plugin (Driver): Built on top of libASPL, it creates a virtual "Proxy Device". The magic trick here is that by properly implementing the kAudioDevicePropertyVolumeScalar and kAudioDevicePropertyMute properties at the driver level, macOS natively handles the F11/F12 keys and pops up the native volume HUD. No Accessibility permissions or keyloggers required.
Shared Memory (IPC): The C++ driver streams the intercepted PCM audio and the volume scalar state to the host process via a lock-free ring buffer (using std::atomic and mmap) in /tmp/.
The Swift Host (AVAudioEngine): A lightweight background daemon reads from the ring buffer, applies the software gain (using linear scaling to match macOS's perceived logarithmic volume curve), and outputs the bit-perfect audio to the actual physical HDMI device.
Request for Roast:
While I’m comfortable with Swift, writing lock-free concurrency in C++ for real-time audio (where a single lock or allocation can cause a glitch) was a steep learning curve.
I would absolutely love it if the C++ and CoreAudio veterans here could roast my driver architecture, specifically the RFSharedAudio memory barriers and the IPC synchronization.

value: Show HN: I wrote a macOS C++ audio driver to fix HDMI volume controls


value:
Built a lightweight OTP input component for Vue 3.
Composition API
Auto focus + backspace handling
Fully customizable
Small bundle
Simple to use and designed to handle common edge cases cleanly.
Repo: https://github.com/pratik227/vue-otp-pro

value: Show HN: Vue-OTP-pro – Minimal OTP input for Vue 3