value: anvarxadja

value:
Hi HN,
I’ve been working with a lot of Retrieval-Augmented Generation pipelines recently and kept running into the same debugging problem.
When a RAG system produces bad answers, people usually blame the LLM. But in many cases the issue is somewhere in the pipeline itself.
Things like:
documents not chunked correctly
embedding models mismatched
retrieval not happening before generation
context windows overflowing
vector database configuration problems
prompt injection exposure
These kinds of issues are surprisingly hard to detect in large codebases.
So I started building a small CLI tool called RAG Doctor that analyzes a project and tries to detect structural problems in RAG pipelines.
The idea is similar to ESLint, but for RAG architectures.
The tool parses the codebase, runs a rule engine, and reports potential issues in the pipeline.
One design choice I made early on was to keep the analysis deterministic. AI is not used to generate findings, only to explain them in human language. This keeps the results reproducible and makes the tool usable in CI workflows.
It’s still early, but I’m curious whether others have run into similar debugging problems when building RAG systems.
If you’ve been working on RAG infrastructure, I’d love to hear what kinds of issues you see most often.
Repo:
https://github.com/NeuroForgeLabs/rag-doctor
Any feedback would be appreciated.

value: Show HN: RAG Doctor – CLI tool to diagnose broken RAG pipelines

author: anvarxadja


value: danfry

value: Show HN: Bonsai - A TypeScript-first sandboxed expression evaluator

author: danfry


value: avolcoff

value:
Hey HN! Built this after watching engineering teams repeatedly get surprised
by AI API invoices — no visibility into spend until the bill landed.
TokenWatch connects to your OpenAI, Anthropic, and Gemini keys and gives you:
- Real-time spend dashboard across projects
- Budget thresholds with proactive alerts
- Anomaly detection for unusual cost spikes
- Duplicate call detection (biggest source of wasted spend I've seen)
Free tier supports up to 3 AI systems. Built this in ~2 days as a solo project.
Happy to answer anything about the build or the problem space.

value: Show HN: TokenWatch – Real-Time AI API Cost Monitor for OpenAI/Anthropic/Gemini

author: avolcoff


value: dominichuang

value:
For years my iPhone photo library felt like a digital junk drawer.
Blurry shots, old screenshots, bursts, duplicates… Every time I opened Photos I thought: "I should really clean this up someday."
I tried doing big cleanup sessions: block off an hour, scroll forever, delete a few dozen photos, feel drained and guilty, close the app. Nothing really changed.
The problem wasn’t the photos. It was the shape of the task. "Clean up your whole library" is terrible for a human brain: no clear endpoint, no natural stopping point, and very little sense of progress.
So instead of a one‑time project, I turned it into a tiny daily ritual – and then built an app around that ritual.
The method: "On This Day" + a few minutes
Once a day, I only review a small, bounded batch of photos – either photos taken on this calendar day in past years, or a small random batch.
-----
My routine now:
1. Open the app once a day.
2. See a handful of photos from "On This Day".
3. Swipe up to delete obvious junk.
4. Optionally keep one or two meaningful photos.
5. When that day's batch is done, close the app.
Sessions are usually 2–5 minutes. The emotional reward becomes "oh, that trip / friend / moment", not "I must fix my entire photo mess today".
Over months this quietly removes thousands of useless photos and reclaims storage, without any big "declutter day".
-----
What I built: Odays
I turned this pattern into an iOS app called Odays.
It:
• Shows you "On This Day" photos from your existing iCloud / iPhone library.
• Optimizes for a swipe‑to‑delete flow.
• Sync with your system Photos app.
• Keeps everything on‑device; the app doesn’t upload your photos anywhere.
It’s intentionally narrow: not a bulk‑operation power tool, but a small, sustainable ritual on top of your existing library.
If you want to try it, here’s the App Store link:
Odays – Relive & Tidy Photos
https://apps.apple.com/app/id6479229303
Happy to answer questions about the product decisions, UX trade‑offs, or the indie dev side.

value: Show HN: Odays – a stress‑free "On This Day" ritual to declutter 40k photos

author: dominichuang


value: jsontwikkeling

value:
I started writing this book 10 years ago in JavaScript, got through a few
chapters (asymptotic notation, basic techniques, start of sorting), and
then abandoned it.
Recently I picked it back up, converted everything to TypeScript, and used
AI (Zenflow [1] + Claude Opus 4.6) to complete the remaining chapters. I
provided the structure, direction, and initial chapters; the AI generated
the bulk of the remaining content under a spec-driven workflow.
The book covers roughly a first 1-2 year CS curriculum: sorting, dynamic
programming, graph algorithms, trees, heaps, hash tables, and more. All
code is executable, typed with generics/interfaces, and covered with tests.
I've thoroughly reviewed several chapters (sorting, DP, graphs) and done a
high-level pass on the rest. Currently in beta — corrections and
contributions are welcome.
MIT licensed. Inspired by Wirth's "Algorithms and Data Structures", SICP,
and CLRS.
Code and tests: https://github.com/amoilanen/Algorithms-with-Typescript
[1] https://zencoder.ai/zenflow

value: Show HN: Algorithms and Data Structures in TypeScript – Free Book (~400 Pages)

author: jsontwikkeling


value: jqssun

value:
Open-sourcing an IATA compliant and backwards compatible boarding pass tool. You can try it out here: https://jqs.app/iata
The BCBP standards can be finnicky to implement, with documentation often behind paywalls and all existing tools out of date. Needed a modern, open, web-based sandbox.
This one allows you to:
- (encode) produce IATA compliant barcode data for integration tests without proprietary software
- (decode) scan or upload the barcode, or paste the boarding pass directly from your device
- (save) add or share a boarding pass to Apple Wallet or Google Wallet
Furthermore, it supports:
- all additional fields defined by the current spec (sequence numbers, compartment code, agency discount, baggage allowance, fast track, secondary security, travel document verification indicators, etc.)
- viewing boarding pass data in an alternative barcode format
And of course, no telemetry/tracking. You can even self-host the entire stack yourself or use an alternative UI on top.
Would love some feedback on the parser's robustness. Feel free to submit PRs too.

value: Show HN: A modern boarding pass encoder/decoder/scanner (web and library)

author: jqssun


value: Beefin

value:
I built amux because I kept waking up to dead Claude Code sessions. Context would fill up at 2am, the agent would crash, and I’d lose hours of work. So I wrote a self-healing multiplexer that wraps Claude Code in tmux sessions and keeps them alive.
The core loop: amux parses ANSI-stripped tmux output to detect state — working, stuck, needs input, context running low. When context drops below 20%, it sends /compact. When the session crashes from a redacted_thinking error, it restarts and replays the last message. When a YOLO session hits a safety prompt, it auto-answers. The watchdog has kept sessions running unattended for 12+ hours.
What made it actually useful was the web dashboard. I can monitor all my agents from my phone (it’s a PWA), send them messages, check the kanban board, and peek at any terminal — all without SSH-ing into my machine.
Last night I had 8 agents working across 3 repos: one writing API endpoints, one on tests, one doing a migration, others on smaller tasks. I checked in twice from my phone, answered two prompts, and woke up to PRs ready for review.
Agents started coordinating on their own
The coordination part surprised me the most. Agents share a REST API so they can peek at each other’s output, claim tasks from a shared board (SQLite with atomic CAS), and send messages between sessions. I didn’t plan for agent-to-agent orchestration initially — I just exposed the API in their global memory and they started using it naturally.
It’s a single Python file (~23k lines, inline HTML/CSS/JS), no build step, no external services. Python 3 + tmux. Auto-generates TLS certs so phone access works over Tailscale. The server watches its own mtime and restarts on save, so you can edit it while it’s running.
What it doesn’t do: it doesn’t replace Claude Code or modify it in any way. It’s purely a wrapper — ANSI parsing, no hooks, no patches. It works with whatever Claude Code version you have.

value: Show HN: Amux – run Claude Code agents in parallel from your phone

author: Beefin


value: dozercat

value: Show HN: Codex vs. Claude for Reverse Engineering Skills

author: dozercat


value: octetta

value:
I built k-synth as an experiment to see if a minimalist, K-inspired array language could make sketching waveforms faster and more intuitive than traditional code. I’ve put together a web-based toolkit so you can try the syntax directly in the browser without having to touch a compiler:
Live Toolkit: https://octetta.github.io/k-synth/
If you visit the page, here is a quick path to an audio payoff:
- Click "patches" and choose dm-bell.ks.
- Click "run"—the notebook area will update. Click the waveform to hear the result.
- Click the "->0" button below the waveform to copy it into slot 0 at the top (slots are also clickable).
- Click "pads" in the entry area to show a performance grid.
- Click "melodic" to play slot 0's sample at different intervals across the grid.
The 'Weird' Stack:
- The Language: A simplified, right-associative array language (e.g., s for sine, p for pi).
- The Web Toolkit: Built using WASM and Web Audio for live-coding samples.
- AI Pair-Programming: I used AI agents to bootstrap the parser and web boilerplate, which let me vet the language design in weeks rather than months.
The Goal:
This isn't meant to replace a DAW. It’s a compact way to generate samples for larger projects. It’s currently in a "will-it-blend" state. I’m looking for feedback from the array language and DSP communities—specifically on the operator choices and the right-to-left evaluation logic.
Source (MIT): https://github.com/octetta/k-synth

value: Show HN: K-synth – A web-based array language playground for synth design

author: octetta


value: raunaqvaisoha

value:
Post-Opus 4.6, LLMs feel much better at using bash, code, local files, and tools.
So I kept coming back to a simple question: if a model can use a computer reasonably well, why can’t I just give it my broker account, a strategy, and let it trade?
My conclusion is that the blocker is not model capability in the abstract. It is the system around the model.
A raw LLM breaks on a few practical things almost immediately:
• no persistent operating memory across sessions
• no trustworthy record of what it did and why
• no hard approval boundary before money moves
• no cheap always-on monitoring if every check requires an LLM call
• no reliable enforcement of limits, permissions, or workflow rules unless that lives outside the model
So the problem is not really “can the model call a broker API?” The problem is that trading needs a harness.
My friend and I built one for this called Vibe Trade. It is open source, MIT licensed, and currently runs locally on your machine connected to Dhan.
The basic design is:
1. Immutable trade journal
Every action is logged at decision time with timestamp, reasoning, and observed signals. The agent cannot rewrite its own history after the fact.
2. Hard approval gate
Before any order is placed, the system generates a structured approval request. Execution is blocked until the user approves. This is enforced in code, not left to the model’s discretion.
3. Event loop outside the LLM
Market watching is handled in plain JS on a timer. Price checks, time rules, and indicator thresholds run every 30 seconds without invoking the model. The LLM only wakes up when something needs reasoning.
4. Playbooks / skill files
Strategies live in markdown documents that get loaded as operating context on each decision. Example: “replicate the Nifty Defense Index and rebalance weekly.” This gives the agent a stable workflow definition instead of relying on chat history.
The first use case that made this feel real to me was very unglamorous: portfolio rebalancing.
I used to make Smallcase-style index replication portfolios and then forget to rebalance them on time. With this setup, I can define the strategy once, let the non-LLM layer monitor for conditions, and have the agent prepare actions for approval. That was the first point where it stopped feeling like a demo and started feeling useful.
A few caveats:
• UI is still weak; it is mostly a chat interface right now
• Dhan only for now
• local install only for now
• requires Node.js and an Anthropic API key
Repo: github.com/vibetrade-ai/vibe-trade
I’m posting this mainly because I think more people will try building “LLM as operator” systems now that tool use is better, and finance makes the failure modes very obvious.
The questions I’m interested in are:
• What other harness components are missing for something like this?
• Would you trust a local system like this more than a hosted one, or less?
• What repeatable financial workflows would you automate first?

value: Show HN: VibeTrade – Trading Harness for Claude

author: raunaqvaisoha


value: I use a Relay architecture to cascade a new coding agent before context get's to the 'dumb zone', theoretically an AI coding indefinitely at it's best. No Context Rot.

value: Show HN: Tarvos – Coding agents that work infinitely


value: sawirricardo

value: Show HN: I made an open source/API/aiagent first ride sharing app like-Uber grab

author: sawirricardo


value: wsdjeg

value:
I just released chat.nvim v1.4.0, an AI chat plugin that runs entirely inside Neovim.
The idea is to turn Neovim into an AI hub instead of just a prompt box. You can chat with LLMs, run tools, and even bridge messages from external chat platforms.
Features:
- Multiple providers (OpenAI, Gemini, Anthropic, Ollama, etc.)
- Tool system (web search, file search, git diff, etc.)
- Long-term memory
- Multiple sessions
- Streaming responses
- Chat integrations (Discord, Telegram, Lark, WeCom, DingTalk)
The plugin is written in Lua and designed to be lightweight and hackable.
Repo:
https://github.com/wsdjeg/chat.nvim
Release:
https://github.com/wsdjeg/chat.nvim/releases/tag/v1.4.0
Feedback is very welcome.

value: Show HN: Chat.nvim v1.4.0 – OpenClaw-like AI assistant for Neovim

author: wsdjeg


value: razvanmac

value: Show HN: StatusDrop – Status page and live widget for your SaaS in 30 seconds

author: razvanmac


value: ucsandman

value:
Hi HN,
I’ve been experimenting with autonomous agents for the past year, and I kept running into the same uncomfortable problem:
Agents were making decisions I couldn’t fully see or justify.
They could call tools, trigger actions, and make assumptions based on incomplete context. Once systems start touching real infrastructure, that becomes pretty scary.
So I built DashClaw.
DashClaw sits between an agent and the tools it wants to use. Instead of executing actions directly, agents call DashClaw first.
DashClaw can:
• evaluate the decision
• apply policy rules
• require approval
• log reasoning and assumptions
• record the final outcome
The idea is to create a *decision trail* for agent systems so you can answer:
Why did the agent think this was okay?
What information did it rely on?
Who approved the action?
The project includes:
• Node and Python SDKs
• a decision ledger for agent actions
• policy guardrails before execution
• a mission control dashboard for fleet activity
• a self-hosted architecture
It’s completely open source and designed to be lightweight enough to run locally with agent frameworks.
I'm still figuring out what the right abstraction layer is for this kind of infrastructure, so I’d love feedback from people building agents.
Repo:
https://github.com/ucsandman/DashClaw

value: Show HN: DashClaw – intercept and audit AI agent decisions before they execute

author: ucsandman


value: Show HN: Golf – A browser version of the classic card game


value: ThunderDanOAE

value: Show HN: WSG - turn project activity into client-ready reports

author: ThunderDanOAE


value:
A step-by-step tutorial to build your own AI agent, from a simple chat loop to a lightweight version of OpenClaw.<p>*18 progressive steps* that teach you how to build an minimal version of OpenClaw. Each step includes:<p>- A `README.md` going through key components and design decision.
- A Runnable codebase.

value: Show HN: Build Your Own OpenClaw – A step by step guide


value: ashmil

value:
Hi HN,
My wife is a physiotherapist, and a while back, she decided to start compiling her clinical experience and patient care knowledge into a resource site, Heal And Move. The goal was to share clear, actionable articles on various physical conditions, rehabilitation plans, and specific exercises.
The Bottleneck:
The biggest hurdle we immediately ran into was visuals. Explaining a specific stretch or joint movement through text alone is tough. Relying on generic stock photos often doesn't accurately reflect the proper form or the specific muscle groups being targeted, and hiring medical illustrators for every single post just wasn't scalable.
The AI Solution:
Recently, we started integrating AI image and video generation into her workflow, and it's been a massive unlock. She can now translate her domain knowledge into precise prompts to generate accurate anatomical illustrations, exercise demonstrations, and step-by-step videos.
As many of you know, getting AI to render anatomically correct limbs and specific physiological poses without looking like body horror takes some trial and error. But by iterating on the prompts, she’s now able to produce high-quality, custom visuals that perfectly match her clinical articles. It has completely removed the visual bottleneck from her content creation.
I'd love for you to take a look. We're open to any feedback on the site, the visual accuracy of the AI-generated assets, or any thoughts from those who have tinkered with fine-tuning models for health/fitness illustrations!

value: Show HN: Using AI to generate accurate illustrations for physiotherapy site

author: ashmil


value:
Hi HN! I built Oxyde because I was tired of duplicating my models.
If you use FastAPI, you know the drill. You define Pydantic models for your API, then define separate ORM models for your database, then write converters between them. SQLModel tries to fix this but it's still SQLAlchemy underneath. Tortoise gives you a nice Django-style API but its own model system. Django ORM is great but welded to the framework.
I wanted something simple: your Pydantic model IS your database model. One class, full validation on input and output, native type hints, zero duplication. The query API is Django-style (.objects.filter(), .exclude(), Q/F expressions) because I think it's one of the best designs out there.
Explicit over implicit. I tried to remove all the magic. Queries don't touch the database until you call a terminal method like .all(), .get(), or .first(). If you don't explicitly call .join() or .prefetch(), related data won't be loaded. No lazy loading, no surprise N+1 queries behind your back. You see exactly what hits the database by reading the code.
Type safety was a big motivation. Python's weak spot is runtime surprises, so Oxyde tackles this on three levels: (1) when you run makemigrations, it also generates .pyi stub files with fully typed queries, so your IDE knows that filter(age__gte=...) takes an int, that create() accepts exactly the fields your model has, and that .all() returns list[User] not list[Any]; (2) Pydantic validates data going into the database; (3) Pydantic validates data coming back out via model_validate(). You get autocompletion, red squiggles on typos, and runtime guarantees, all from the same model definition.
Why Rust? Not for speed as a goal. I don't do "language X is better" debates. Each one is good at what it was made for. Python is hard to beat for expressing business logic. But infrastructure stuff like SQL generation, connection pooling, and row serialization is where a systems language makes sense. So I split it: Python handles your models and business logic, Rust handles the database plumbing. Queries are built as an IR in Python, serialized via MessagePack, sent to Rust which generates dialect-specific SQL, executes it, and streams results back. Speed is a side effect of this split, not the goal. But since you're not paying a performance tax for the convenience, here are the benchmarks if curious: https://oxyde.fatalyst.dev/latest/advanced/benchmarks/
What's there today: Django-style migrations (makemigrations / migrate), transactions with savepoints, joins and prefetch, PostgreSQL + SQLite + MySQL, FastAPI integration, and an auto-generated admin panel that works with FastAPI, Litestar, Sanic, Quart, and Falcon (https://github.com/mr-fatalyst/oxyde-admin).
It's v0.5, beta, active development, API might still change. This is my attempt to build the ORM I personally wanted to use. Would love feedback, criticism, ideas.
Docs: https://oxyde.fatalyst.dev/
Step-by-step FastAPI tutorial (blog API from scratch): https://github.com/mr-fatalyst/fastapi-oxyde-example

value: Show HN: Oxyde – Pydantic-native async ORM with a Rust core


value: Frameser

value:
Hey HN, I’m excited to share PNANA—a lightweight, modern terminal text editor built with C++17 and FTXUI, designed to bridge the gap between simplicity and power for developers who live in the terminal.
What makes PNANA different?
Zero learning curve: Ditches the modal complexity of Vim/Neovim for familiar Ctrl+S/Ctrl+Z shortcuts, just like GUI editors.
Beautiful terminal UI: Out-of-the-box themes (Monokai, Dracula, Nord, etc.), a three-column layout, and smart status bars—no config required to look great.
Built-in LSP support: Native code completion, real-time diagnostics, jump-to-definition, and symbol search for all major languages (C/C++, Go, Rust, Python, JS/TS, and more).
Lightweight & fast: Terminal-native, low resource usage, and instant startup—perfect for remote servers and local development alike.
Extensible future: A planned Lua plugin system (inspired by Neovim) will let users extend functionality with custom scripts.
I’d love to hear your thoughts, feedback, or feature requests! Check out the repo, star it if you like it, and let’s build a better terminal editor together.
English README: https://github.com/Cyxuan0311/PNANA/blob/master/README_EN.md

value: Show HN: Pnana – A Modern Terminal Text Editor Built for Simplicity and Power

author: Frameser


value: quietfireai

value: Show HN: TelsonBase a self-hosted governance for AI agents (Apache 2.0)

author: quietfireai


value: benlatger

value: Show HN: I made a life calendar that connect goals to weekly lifestyle changes

author: benlatger


value: morrislaw

value:
I built a small tool to speed up debugging Kubernetes CrashLoopBackOff errors.
Normally when a pod keeps restarting you end up jumping between:
- kubectl logs
- kubectl describe
- events
- docs
Crashloop Analyzer lets you paste pod logs or kubectl describe output and it highlights likely causes like:
• OOMKilled
• ImagePullBackOff / ErrImagePull
• missing environment/config values
• port binding failures
It also suggests useful kubectl commands to investigate further.
The detection is deterministic first (pattern matching common failure modes) with optional AI-assisted explanation layered on top.
Live demo:
https://crashloop-analyzer.vercel.app/
Source:
https://github.com/MorrisLaw/k8s-crashloop-analyzer

value: Show HN: Crashloop Analyzer – paste Kubernetes logs to diagnose CrashLoopBackOff

author: morrislaw


value: PreciousH

value: Show HN: Argus – AI agent that investigates infra anomalies and proposes fixes

author: PreciousH


value:
I built this because I have a problem with starting tasks. I'll open my notepad, see 30 things I need to do, and do none of them. After years of this (and multiple failed products) I realized that I'm the problem.
The idea behind HealUp is that the most valuable thing a productivity tool can do is hide information from you. When you see one clear action on screen, you do it. When you see thirty, you spend energy deciding which one, and often pick nothing.
How it works: you type a task, AI breaks it into concrete steps (not vague advice, actual next actions like "open Google Docs and create a blank document"), and Execute Mode shows you one step at a time. Full screen, nothing else visible. Finish it, next one appears.
This is the first thing I built that I actually use myself every day. Looking back, that's probably why the others failed. I was building for imaginary users, not for myself. This one made $680 in its first two weeks, which after 4 years of $0 and 6 failed startups felt like a lot.
No signup required. Guest mode is fully functional. You can try it right now without creating an account.
Looking for feedback on whether others have found that reducing visible information helps them focus, or if it creates anxiety about what you're not seeing. I've heard both and I'm still figuring out the right balance.

value: Show HN: HealUp – Task execution app that hides your todo list on purpose


value: Enjoyooor

value:
We’ve all seen the explosion of AI tools lately.
Every day there are dozens of new launches claiming to be the next revolution.
After a while it becomes hard to tell what is actually useful and what is just another vibecoded landing page.
So we built Glad-AI-Tor.
It’s a simple arena where AI tools are submitted and exposed to the crowd.
People can roast them, judge them, and decide if they deserve attention.
No paid placement.
No marketing tricks.
Just builders putting their tools in front of the internet and seeing what survives.
Some tools get destroyed.
Some unexpectedly rise.
Curious to see what happens when the crowd decides.

value: Show HN: Every AI tool claims to be revolutionary. We built a place to test it

author: Enjoyooor


value: serendip-ml

value: Show HN: Fine-tuned 3B outperforms Claude Haiku on constrained generation

author: serendip-ml


value: trekhleb

value: Show HN: CaliVibe – Explore California Neighbourhoods

author: trekhleb


value: Show HN: OpenLight – Lightweight Telegram AI Agent for Raspberry Pi


value: Show HN: HAL – Harmful Action Limiter: Lean command guard for AI coding agents.


value:
Hi HN, I built Coral to solve a pain point I had with large gRPC/Connect projects where proto dependencies became hard to track.
It parses FileDescriptorSet from `buf build` and generates:
- Interactive React Flow graph with a neon-style dark UI
- PR comments showing proto schema diffs (added/removed/modified)
- Static GitHub Pages for team documentation
Available as both a CLI tool and a GitHub Action:

    buf build -o - | coral serve

Live demo: https://daisuke8000.github.io/coral/
GitHub Action: https://github.com/marketplace/actions/coral-proto-visualize...

value: Show HN: Coral – Visualize .proto file dependencies as an interactive graph


value: jonathanrtuck

value:
Last Friday I started a conversation with Claude about operating systems. That conversation turned into a design session. The design session turned into a prototype. I haven’t really stopped since.
The core idea: your files live inside applications. The app decides how you see your content, what you can do with it, and where your work gets saved. What if the OS just understood your files directly — rendered them, indexed them, tracked their history — and editors were tools you picked up only when you needed to change something? No “open with.” No Save button. You view by default, editing is deliberate.
What exists after one week: a from-scratch kernel in Rust on QEMU (aarch64), 27 syscalls, EEVDF scheduler with 4 SMP cores, a full display pipeline (compositor, subpixel TrueType rendering, alpha blending, PNG image viewer), structured IPC via shared-memory ring buffers, an editor process model where the OS service is the sole writer, a filesystem prototype, 900+ tests including a formal bug audit, and ~2,200 lines of design documentation with 13 settled architectural decisions. I’d never even seen Rust code before Friday.
Full story with demo, day-by-day timeline, how I worked with AI, and what I learned: https://github.com/jonathanrtuck/os/discussions/1
Repo: https://github.com/jonathanrtuck/os
I’m not trying to build the next Linux. This is a design exploration — can the document-centric model that OpenDoc and Xerox Star attempted actually work if you rethink the whole stack from the kernel up? I’m genuinely curious what this community thinks.

value: Show HN: A conversation about OS design turned into an actual OS in a week

author: jonathanrtuck


value:
I built a small web tool that tries to automatically refactor messy prompts into structured prompt specifications.
The motivation was simple: most prompts people write are poorly structured, which often leads to unstable AI responses.
So I implemented a Proposer–Critic–Verifier optimization pipeline.
Proposer restructures the prompt.
Critic evaluates clarity, structure, and task definition.
Verifier checks consistency.
Arbiter detects convergence.
The system runs several iterations and produces a structured prompt specification.
It usually takes around 30–40 seconds to run the full optimization loop.
The tool also includes:
• prompt quality analysis
• explain mode
• version history
• prompt diff viewer
Demo:
https://how-to-grab-me.vercel.app/
Would love to hear if people building AI tools find something like this useful.

value: Show HN: Prompt optimizer that refactors messy prompts using a P-C-V pipeline


value: webcoderspeed

value:
I kept copy-pasting the same boilerplate across every TypeScript project — retry logic, circuit breakers, auth token refresh, timeout handling. So I built reixo to handle all of it once.
Two things I haven't seen in other HTTP clients:
1. tryGet/tryPost/tryPut etc. return Result<T,E> instead of throwing — no try/catch needed at the call site. Works like Rust's Result or Go's (value, err) pattern.
2. Full W3C traceparent/tracestate/baggage injection with zero @opentelemetry/* dependencies. One builder method: .withOpenTelemetry({ serviceName: 'my-service' })
Also ships with: in-flight request deduplication (thundering herd fix), runtime detection across Node/Bun/Deno/CF Workers/Vercel Edge, transient network error classification (ETIMEDOUT vs DNS vs connection reset), circuit breaker, offline queue, GraphQL client, WebSocket, SSE, and a MockAdapter for tests.
Would love feedback on the Result API design — specifically whether Ok/Err should carry more metadata or stay minimal.
npm: https://www.npmjs.com/package/reixo

value: Show HN: Reixo – HTTP client with no-throw Result<T,E> and zero-dep OTel

author: webcoderspeed


value: cowpig

value: Show HN: Userland local agent sandbox with real-time network control dashboard

author: cowpig


value: anophelon

value:
I’m working on openoman, an open-source runtime for secure agent work on real repositories. The goal is to let agents do useful work without getting your Git credentials, touching your normal environment, or owning the publishing flow.
Each task runs in an isolated disposable sandbox. Publishing stays on the trusted side. And the system is API-first, so tasks can come from cli, bots, or your own internal tools.
What makes it different from cloud-first agent runtimes is that it is designed for your infrastructure:
it can run against self-hosted gitlab and other non-cloud setups,
it is agent-agnostic, so you are not locked into a single provider or model,
and it can give agents enough isolated runtime to bring up the dependencies they need for real work — for example, a Docker Compose stack with postgres for tests.

value: Show HN: Secure Agent Execution for Your Repository via Virtualization

author: anophelon


value: anwitars

value:
I built grab because I wanted a more readable way to handle delimited data (CSV, TSV, whitespace) than the usual mix of awk and cut. It replaces cryptic 'schema' like $11 with a declarative one.
The goal was to build something with just enough features to serve a better UX while staying fast enough to stay out of the way.

  ps aux | grab -d whitespace -m user,pid,cpu,mem,_:4,start,time,command:gj --json --skip 1
  # Result:
  # {"user":"root","pid":"1","cpu":"0.0","mem":"0.0","start":"Mar10","time":"0:03","command":"/sbin/init"}
  # ...

Key points:
- Readable mappings: Define schemas like <name> to map columns to fields, with support for <name>:N for aggregating multiple columns into arrays, <name>:g for greedy mapping (into arrays), _ to skip columns and even <name>:Nj to join multiple columns into a single field.
- Performance: Zero-copy tokenization in Rust. It processes ~17.1M fields/sec. On my machine, it shapes a ps aux dump into JSON in about 13ms.
- Schema enforcement: By default, it tells you exactly which line failed and why on stderr, rather than silently producing garbled data.
- Small & static: Single 800KB binary, zero dependencies.
I’m sharing it now to see if this "schema-first" approach to shell piping feels as useful to others as it has been for me.
Repo: https://github.com/anwitars/grab
Crates.io: https://crates.io/crates/grab-cli

value: Show HN: Grab – A declarative stream processor for delimited text data

author: anwitars


value: shadowy-pycoder

value:
GoHPTS got updated to v1.12.1 with support for IPv6 protocol and NDP spoffing support (RA/NA spoofing, RDNSS injections)
GoHPTS has in-built functionality to perform NDP spoofing in IPv6 networks with Router Advertisement (RA) and Neighbor Advertisement (NA) packets. It also includes RDNSS option in RA packets to put host as a IPv6 nameserver for affected clients. When combined with transparent proxy mode (TCP/UDP), NDP spoofing allows `gohpts` to proxy traffic for clients in the local networks. As is the case with [ARP spoofing](#arp-spoofing), you can set ndp spoof options with single `-ndpspoof` flag:
Example:
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100 -ndpspoof "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true"
For more information about ndpspoof options see `gohpts -h` and https://github.com/shadowy-pycoder/ndpspoof
Plese note that some options like `rdnss`, `gateway`, `interface` are set automatically by `gohpts` itself to properly function as a proxy.
Since `gohpts` proxies all connections via upstream SOCKS5 server, you need to have a working server with IPv4/IPv6 and TCP/UDP support. Obviously, a remote machine (e.g. VPS) should also have IPv6 connectivity working. Needless to say, the machine on which `gohpts` is installed should be part of network with IPv6 support.
Example setup for NDP spoofing to work correctly:
1. Connect to VPS
ssh remote@203.0.113.10
2. Install dependencies
GO_VERSION=$(curl 'https://go.dev/VERSION?m=text' | head -n1)
cd ~/Downloads/ && wget https://go.dev/dl/$GO_VERSION.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf $GO_VERSION.linux-amd64.tar.gz
3. Setup SOCKS5 server (make sure firewall rules do not block used ports)
git clone https://github.com/wzshiming/socks5.git && cd socks5
go build -o ./bin/socks5_server ./cmd/socks5/*.go
./bin/socks5_server -a :3000
4. Go back to your host machine and install `gohpts` installation
5. Run `gohtps`:
sudo env PATH=$PATH gohpts -s 203.0.113.10:3000 -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -mark 100 -arpspoof "fullduplex true;debug true" -ndpspoof "ra true;debug true
" -6 -d
6. Get another device (phone, tablet, etc) and connect it to the same network. Try to access Internet and check if some traffic appears on your host machine. Check public IP address with some online tools (it should match your VPS address `203.0.113.10` in this case or global IPv6 address)
7. Stop proxy by hitting Ctrl+C
8. Profit!
Links:
https://github.com/shadowy-pycoder/go-http-proxy-to-socks)
https://codeberg.org/shadowy-pycoder/go-http-proxy-to-socks)
https://github.com/shadowy-pycoder/ndpspoof
https://codeberg.org/shadowy-pycoder/ndpspoof
https://github.com/shadowy-pycoder/arpspoof
https://codeberg.org/shadowy-pycoder/arpspoof

value: Show HN: Gohpts-IPv4/IPv6/TCP/UDP Transparent Proxy with ARP/NDP/Rdnss Spoofing

author: shadowy-pycoder


value:
Hi HN. We're OpsRev. We build AI operations agents for construction companies.
These two CLIs are what our agents use internally to talk to Procore (construction project management) and EagleView (aerial property measurements). We decided to open-source them because the developer tooling in construction software is rough and nobody should have to re-solve the same auth and pagination problems we did.
procore-cli - pulls projects, RFIs, submittals, daily logs, budgets, schedules, and directory data from the Procore API. Handles OAuth2, company/project scoping, and pagination.
https://github.com/opsrev/procore-cli
eagleview-cli - covers the full measurement ordering lifecycle: browse products, price orders, place orders, retrieve reports and PDFs. Has sandbox mode for safe testing.
https://github.com/opsrev/eagleview-cli
Both are TypeScript, MIT licensed, and output JSON on every command (errors too, on stderr). We designed them for AI agent consumption but they work just as well in scripts, pipelines, or just poking around an API from the terminal.
Construction is a $2T industry that still runs on a lot of manual data entry between systems. If you're building anything in this space, hopefully these save you some time. Happy to answer questions about the APIs or how we use these in our agent workflows.

value: Show HN: Open-source CLIs for Procore and EagleView (construction software APIs)


value: tonyww

value:
If you are building AI agents with frameworks like browser-use, LangChain, or OpenClaw, you've likely hit the "blast radius" problem.
A misconfigured prompt or hallucination can cause an agent to navigate to a phishing domain, expose an API key, or confidently claim a task succeeded when it actually clicked a disabled button.
The standard fix right now is "LLM-as-a-judge"—taking a screenshot after the fact and asking GPT-4, "Did this work and is it safe?" That introduces massive latency, burns tokens, and is fundamentally probabilistic.
We built predicate-secure to fix this.
It’s a drop-in Python wrapper that adds a deterministic physics engine to your agent's execution loop.
In 3 to 5 lines of code, without rewriting your agent, it enforces a complete three-phase loop:
Pre-execution authorization:
Before the agent's action hits the OS or browser, it is intercepted and evaluated against a local, fail-closed YAML policy. (e.g., Allow browser.click on button#checkout, Deny fs.read on ~/.ssh/*).
Action execution:
The agent executes the raw Playwright/framework action.
Post-execution verification:
It mathematically diffs the "Before" and "After" states (DOM or system) to prove the action succeeded.
To avoid the "LLM-as-a-judge" trap, the execution of the verification is purely mathematical. We use a local, offline LLM (Qwen 2.5 7B Instruct) strictly to generate the verification predicates based on the state changes (e.g., asserting url_contains('example.com') or element_exists('#success')), and then the runtime evaluates those predicates deterministically in milliseconds.
The DX looks like this:
from predicate_secure import SecureAgent from browser_use import Agent
1. Your existing unverified agent
agent = Agent(task="Buy headphones on Amazon", llm=my_model)
2. Drop-in the Predicate wrapper
secure_agent = SecureAgent( agent=agent, policy="policies/shopping.yaml", mode="strict" )
3. Runs with full Pre- & Post-Execution Verification
secure_agent.run()
We have out-of-the-box adapters for browser-use, LangChain, PydanticAI, OpenClaw, and raw Playwright.
Because we know developers hate giving external SaaS tools access to their agent's context, the entire demo and verification loop runs 100% offline on your local machine (tested on Apple Silicon MPS and CUDA).
For enterprise/production fleets, the pre-execution gate can optionally be offloaded to our open-source Rust sidecar (predicate-authorityd) for <1ms policy evaluations.
The repo is open-source (MIT/Apache 2.0). We put together a complete, offline demo showing the wrapper blocking unauthorized navigation and verifying clicks locally using the Qwen 7B model.
Repo and Demo: https://github.com/PredicateSystems/predicate-secure
Another demo for securing your OpenClaw:
https://github.com/PredicateSystems/predicate-claw
Demo (GIF):
https://github.com/PredicateSystems/predicate-claw/blob/main...
I'd love to hear what the community thinks about deterministic verification vs. probabilistic LLM judges, or answer any questions about the architecture!

value: Show HN: A 3-line wrapper that enforces deterministic security for AI agents

author: tonyww


value: felltrifortence

value:
Agent Skills (SKILL.md files) are reusable instruction sets that teach code agents like Claude Code, GitHub Copilot, Cursor, and Windsurf how to perform specific tasks. Right now, creating them is entirely manual - you hand-write YAML frontmatter and markdown, with no way to preview, validate, or test before deploying.
uberSKILLS is an open-source web app that gives you an integrated authoring environment for Agent Skills:
- AI-assisted creation - describe what you want in plain English, get a complete SKILL.md draft
- Structured editor - edit metadata, instructions, and file templates with real-time validation
- Multi-model testing - test your skill against any model on OpenRouter (Claude, GPT-4, Gemini, Llama, etc.) with streaming responses and token metrics
- One-click deploy - deploy to 8 agents: Antigravity, Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, and Windsurf
- Import/export - bulk-import existing skills from directories or zips, export as zip
- Version history - every edit is versioned automatically
Get started with a single command, no setup required:
npx @uberskillsdev/uberskills
Tech stack: Next.js 15, TypeScript, SQLite + Drizzle ORM, Vercel AI SDK, shadcn/ui, Tailwind CSS v4. Everything runs locally your data stays on your machine, API keys are encrypted with AES-256-GCM, and there's no account or cloud dependency.
MIT licensed. Would love feedback on the editor UX and which agent integrations matter most to you.

value: Show HN: UberSKILLS – Open-source Workbench for building AI agent SKILLS

author: felltrifortence


value: visekr

value:
Hi HN - I'm Ryan a product designer who codes, and I built Mesa. Current IDEs feel wrong for the type of development being done now - the focus is still on files.
Mesa puts the focus on the full workflow: your agent, terminal, browser, and files all live as equal nodes on a canvas with full multiplayer support. (think figma but for code)
I was tired of the overhead of switching windows, tabs, and terminals across multiple projects. Inspired by TouchDesigner and Factorio, I wanted something more fluid and visual. Been using it as a total replacement for Cursor at work every day now. Being able to see multiple repos at once and control agents on each without navigating windows has freed up my headspace and increased productivity.
It's free to try — would love to know what you think!

value: Show HN: Mesa – A collaborative canvas IDE built for agent-first development

author: visekr


value: Show HN: Agent wrapped, like Spotify wrapped


value: ndxone

value:
https://github.com/ndx-technologies/go-apple-ads
this is super helpful to us, I think more people should be aware of this approach
combine this with your: AI agent, cronjob, and git repo of your configs — and you get automated highly efficient, fully traceable, decision log, with ability to roll-back, understand every decision, and get learning loop of AI to optimize your campaigns.
this tools work well with humans in the loop too (color formatting), and built with AI agents running in CLI in mind (no-color, filters, help pages and self-discovery). inspired by Go linters (analysers) there are common linters to detect mistakes in configuration as well.
enjoy!

value: Show HN: Apple Ads Toolkit – Run Your Apple Ads as GitOps Terraform

author: ndxone


value: hamidr

value:
I built nixcage to solve a problem that's been bugging me: AI coding agents like Claude Code have broad access to your filesystem, network, and system. That's powerful but uncomfortable, especially on client projects or machines with sensitive data.
nixcage creates per-project sandboxes that activate automatically when you cd into a directory (via direnv). It uses bubblewrap on Linux and sandbox-exec on macOS — no VMs, no Docker, no overhead.
Three isolation levels: strict (no network, empty home), standard (project writable, network on), and relaxed (home readable, project writable).
It also controls Nix store access (shared, readonly, copy, or fully isolated) so sandboxed tools can't pollute your host store.
Quick start: nixcage init --preset claude-code && direnv allow
A debug mode captures every blocked syscall so you can see exactly what's denied and tune your config.
https://github.com/hamidr/nixcage

value: Show HN: Nixcage – Sandbox AI coding agents per project with Nix and direnv

author: hamidr


value: woodenbrain

value:
I’ve been working on a macOS companion for Apple Music called gr∞ves. It's my first new app in over 10 years. I'm looking for beta testers who use Apple Music on MacOS regularly.
The goal is to bring back the experience of browsing a record collection while listening — large album artwork, additional liner-style information, and easy access to extra material related to the album currently playing.
The app runs alongside Apple Music and displays artwork at full resolution, with slideshow views of additional images found locally or online. It also surfaces extended information like artist bios, curated album notes, and extended / enhanced track data.
It’s designed mainly for people who maintain their own digital music libraries, but it also works with Apple Music streaming.
Some features:
• large-format artwork display from local and online sources
• artwork slideshow including alternate covers and images
• expanded album and artist information
• PDF booklet discovery
• album change notifications
• gesture and hotkey support
• works with both local libraries and streaming
We’ve just opened a public TestFlight beta and would love feedback.

value: Show HN: Gr∞ves – a macOS Apple Music companion for artwork and metadata

author: woodenbrain


value: hobbescotch

value:
Buddy and I used to do this thing where we tried to guess the ages of celebrities on the IMDB birthday page each morning.
Made a simple game out of it - it's sort of a mashup of wordle + geoguessr
Enjoy & happy Friday, gang

value: Show HN: StarDate – a daily game where you guess celebrity ages

author: hobbescotch


value: takielias

value: Show HN: PHP Requests Don't Look Like Browsers – So I Built One

author: takielias


value:
I’ve been working on a few different projects lately, and whenever I needed to make a demo video or a marketing clip that involved a UI text conversation (like a user messaging support on WhatsApp), I hit a massive bottleneck.
Doing this manually means opening After Effects, tracking down an up-to-date UI template, and keyframing every single text bubble popping in. Animating a "typing..." indicator character-by-character is miserable work.
I got tired of doing it, so I built GetMimic.lol to automate the process.
You pick a platform UI (it currently supports about 35, including iOS messages, WhatsApp, Twitter, and ChatGPT), type out your script, and it renders an MP4 video of the conversation playing out.

value: Show HN: GetMimic – A video rendering engine for animated UI and chat mockups


value: joshmxtth

value: Show HN: Aprender – A language app built for European Portuguese (not Brazilian)

author: joshmxtth


value: zeebs

value: Show HN: Instant websites for AI agents – no auth, no signup

author: zeebs


value: flossypurse

value:
I built a dashboard, Claude helped ;), that aggregates 143+ open government data feeds into a single view of Alberta's economy, covering 30 municipalities (~4.5M population).
Data sources include Bank of Canada (rates, CAD/USD), StatsCan (GDP, CPI, unemployment), CER (pipeline throughput, oil/gas production — 16 feeds), AESO (electricity pool pricing), IRCC (immigration), municipal ArcGIS endpoints (22 municipalities with parcel-level data), Edmonton/Calgary Socrata APIs, and Alberta's regional dashboard (54 indicators for all ~340 municipalities).
Tech: Next.js 16, React 19, TypeScript, better-sqlite3, Recharts. All data fetched server-side from live government APIs. PostgreSQL fallback for upstream outages. ISR on embeddable chart routes.
The interesting technical challenge was normalizing data across very different government API formats — ArcGIS feature services, Socrata SODA, StatsCan's WDS SOAP-to-JSON API, fixed-width text files (AER well licences), and various CSV/JSON endpoints. Each municipality's ArcGIS has different field names for the same concepts (assessed value might be TOTAL_ASSESS, TOTALASSESSEDVALUE, Total_Value, etc.).
I live in Parkland County (west of Edmonton) and built this because I wanted economic indicators for my area without checking a dozen government portals. Planning to monetize the municipality deep-dives at $29/mo while keeping macro data free.
Happy to answer questions about the architecture or the government data landscape.

value: Show HN: Open-data dashboard aggregating 143 feeds for Alberta municipalities

author: flossypurse


value: mixfox

value: Show HN: OpenClaw docs in Japanese, now open source

author: mixfox


value: Show HN: Chrome extension that detects past website breaches


value: eamann

value: Show HN: DKLS23 2-of-2 threshold ECDSA signature ceremony visualized

author: eamann


value: hmartin

value:
My wife and I have our Apple TV screensaver set to favorites photo album. Except we don’t update it much so it was getting boring.
Enter the solution to any and every problem (can you guess?) —em dash— AI!
Introducing imagemine  →  →
Try it by running `uvx imagemine path/to/photo.jpg`
At its heart, imagemine is a simple “ask claude for a short surrealist story based on the input photo” then “have nano banana generate a new image from the story and source image” script.
imagemine has 35+ built-in style prompts included that get selected at random or you can add your own (one-off cli flag or added to store).
Sure it might be slop, but it's your slop, curated with your magnificent taste.
The kicker is that you can configure an input and output Photos album (if you’re on a Mac) so that my old favorites album is source material and my TV is now set to the new album.
imagemine includes optional launchd (Mac’s cron, to oversimplify) so this whole thing can be run automatically on a schedule. Set it, forget it, give Anthropic and Google your money on autopilot.
If you use it, I’d love to hear feedback!

value: Show HN: Re-imagine photo albums with NanoBanana

author: hmartin


value: howlett

value: Show HN: Thermal Receipt Printers – Markdown and Web UI

author: howlett


value: breckognize

value:
We're former AWS S3 engineers. Row Zero is "Google Sheets on steroids". We built it because we were frustrated with Excel's 1 million row limit and poor integration with cloud data sources like S3, Postgres, Snowflake, and Databricks.
Under the hood, the spreadsheet engine is a columnar key-value store written in Rust. We built it from scratch because SQL engines like DuckDB only work well for structured tables. The unstructured nature of spreadsheets make them a bad fit for SQL. The engine also needs to be 100% Excel compatible so you can import existing xlsx files.
The front-end is a big React app with hand-rolled canvas rendering. We virtualize scrolling to handle 2 billion+ row data sets. All workbook state runs in the cloud (located in a data center close to you to keep things snappy).
We launched on HN 2 years ago and got lots of great feedback. Since then, customers have pulled us towards the enterprise. Today we're launching Row Zero 2.0 with support for all the enterprise bells and whistles: OAuth database connections, SSO, SCIM, workspaces, private link on AWS and Azure, bring your own AI key, and private storage. Excited to hear what you think.

value: Show HN: We built a billion row spreadsheet

author: breckognize


value: Show HN: MaximusLLM, Breaking transformer's O(N^2) and O(V) scaling bottlenecks


value: chillkim

value: Show HN: RepoCrunch – CLI to analyze GitHub repos

author: chillkim


value: walky

value: Show HN: TheDayAfter – open-source addiction recovery tracker

author: walky


value: Show HN: I Made a PS1 Static Recompiler with No Prior Experience (and Claude)


value: diraigent

value: Show HN: Diraigent – Self-hosted orchestration for AI coding agents

author: diraigent


value: eugenelotsu

value:
Hi HN,
I built Build4Me to address a trust problem in diaspora-funded construction projects.
Many families send money home to build houses but have no reliable way to verify that work is actually being done. Photos can be reused, progress exaggerated, or projects abandoned after funds are sent.
Build4Me introduces milestone-based funding where each construction milestone must be verified before funds are released.
The system verifies progress using:
- geotagged photo capture
- GPS location verification
- AI image analysis
- duplicate image detection
It runs on serverless AWS architecture using services like Rekognition, Bedrock, Lambda, DynamoDB, and Amazon Location Service.
Would love feedback on the architecture and fraud detection approach.

value: Show HN: AI milestone verification for construction using AWS

author: eugenelotsu


value: rbren

value: Show HN: My personal AI-powered dev workstation

author: rbren


value: kundi

value: Show HN: I was tired of Loom so I built my own screen recorder

author: kundi


value: AskCarX

value:
We scanned 39 agent frameworks against the OWASP Agentic AI Top 10. 13 FAIL, 17 WARN, 9 PASS. Open Interpreter scored 80/100 risk. AutoGPT 65. Even LangChain flagged WARN for prompt injection vectors.
MCP has no identity layer. No message signing. No tool integrity. 41% of MCP servers have zero authentication (TapAuth research). CVE-2025-6514 scored CVSS 9.6.
MCPS adds a cryptographic security layer on top of MCP – like TLS for HTTP:
- Agent Passports (ECDSA P-256 signed identity)
- Message signing (every JSON-RPC call wrapped in signed envelope)
- Tool integrity (signed definitions prevent poisoning)
- Replay protection (nonce + timestamp window)
- Trust levels L0-L4 (enforce minimum per server)
- Real-time revocation via Trust Authority
Mitigates 8/10 OWASP MCP risks. Zero dependencies.
npm install mcp-secure
pip install mcp-secure
Background: I filed OWASP security assessments against LangChain (github.com/langchain-ai/langchain/issues/35803) and other frameworks. The LangChain community implemented AST filtering fixes based on the findings. That work led to building MCPS as the protocol-level fix.
Full spec: github.com/razashariff/mcps/blob/main/SPEC.md
Scan results for all 39 agents: mcp-secure.dev/#registry

value: Show HN: MCPS – Cryptographic identity and message signing for MCP agents

author: AskCarX


value: Show HN: 724claw.icu – Anonymous vent wall for "shrimp workers" grinding 7×24


value: kaliades

value: Show HN: Let AI agents debug your Valkey/Redis

author: kaliades


value:
I built Stint to let me give Claude goals and walk away. It automatically breaks tasks into parallel work, spins up multiple Claude workers in isolated git branches, and merges results when done. Think "fire-and-forget" development with a web dashboard showing real-time progress.
Unlike other frameworks, there's no complicated setup. Just queue goals and let the agents work. Each worker has its own context window and commits directly to git.
See https://github.com/ilocn/stint. Happy to take comments/feedback. Thank you!

value: Show HN: Stint – Fire-and-forget AI agent orchestration


value: ivzak

value:
We built an open-source proxy that sits between coding agents (Claude Code, OpenClaw, etc.) and the LLM, compressing tool outputs before they enter the context window.
Demo: https://www.youtube.com/watch?v=-vFZ6MPrwjw#t=9s.
Motivation: Agents are terrible at managing context. A single file read or grep can dump thousands of tokens into the window, most of it noise. This isn't just expensive — it actively degrades quality. Long-context benchmarks consistently show steep accuracy drops as context grows (OpenAI's GPT-5.4 eval goes from 97.2% at 32k to 36.6% at 1M https://openai.com/index/introducing-gpt-5-4/).
Our solution uses small language models (SLMs): we look at model internals and train classifiers to detect which parts of the context carry the most signal. When a tool returns output, we compress it conditioned on the intent of the tool call—so if the agent called grep looking for error handling patterns, the SLM keeps the relevant matches and strips the rest.
If the model later needs something we removed, it calls expand() to fetch the original output. We also do background compaction at 85% window capacity and lazy-load tool descriptions so the model only sees tools relevant to the current step.
The proxy also gives you spending caps, a dashboard for tracking running and past sessions, and Slack pings when an agent is sitting there waiting on you.
Repo is here: https://github.com/Compresr-ai/Context-Gateway. You can try it with:

  curl -fsSL https://compresr.ai/api/install | sh

Happy to go deep on any of it: the compression model, how the lazy tool loading works, or anything else about the gateway. Try it out and let us know how you like it!

value: Show HN: Context Gateway – Compress agent context before it hits the LLM

author: ivzak


value:
Hi HN,
This is a tool I've worked on the past few months.
Instead of giving LLM tools SSH access or installing them on a server, the following command:

  $ promptctl ssh user@server

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

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

the prompts behind `llm-analyze-config` and `askai` execute on my local computer (even though they're invoked remotely) via the llm of my choosing.
This way LLM tools are never granted SSH access to the server, and nothing needs to be installed to the server. In fact, the server does not even need outbound internet connections to be enabled.
Eager to get feedback!
Github: https://github.com/tgalal/promptcmd/

value: Show HN: Execute local LLM prompts in remote SSH shell sessions


value: dishantsinghdev

value:
I built a REST + WebSocket API for programmatic disposable email inboxes.
The main use case I kept running into while building: automated testing of
sign-up/verification flows. You need a real inbox, a real OTP, and you need
it fast. Existing options were either not API-first, had terrible docs, or
charged $50/mo before you could even try them.
What it does:
- POST /v1/inboxes to register an inbox
- GET /v1/inboxes/:inbox/otp to pull the latest OTP (parsed automatically)
- WebSocket connection for real-time push instead of polling
- Attachments, custom domains on higher tiers
Auth is SHA-256 hashed API keys, usage tracked per-user (not per-key, so
rotating keys doesn't reset your quota). Rate limit headers on every response.
Free tier: 5k req/mo, no credit card.
Interactive playground: https://www.freecustom.email/api/playground
Docs: https://freecustom.email/api/docs
Happy to answer questions about the architecture — running on Node/Express,
Redis for rate limiting and pub/sub, MongoDB for storage.

value: Show HN: Disposable inbox API with OTP extraction and WebSocket push

author: dishantsinghdev


value: harvenstar

value: Show HN: AgentClick – Human-in-the-loop review UI for AI coding agents

author: harvenstar


value: farskid

value:
I built this because I was tired of manually cropping family photos for my digital photo frame. Every frame has a different aspect ratio and when you just resize, you end up cutting people's heads off or losing the important parts of the photo.
FrameFit uses Claude to analyze the photo, detect faces and key subjects, then crop intelligently for whatever aspect ratio your frame needs. Upload a photo, pick your frame dimensions, get a crop that actually keeps the important stuff in frame.
Stack: Next.js 16, Claude API for image analysis, Stripe for payments, Supabase Postgres, deployed on Vercel.
Free tier gives you 5 crops per day. Pro is €4.99/month if you need more.
Would love to hear feedback on the crop quality. The hardest part was getting the AI to understand composition, not just face detection. Sometimes you want the landscape in the background, not just a tight face crop.

value: Show HN: FrameFit – AI-powered photo cropping for digital photo frames

author: farskid


value: paperplaneflyr

value:
I’ve been experimenting with infrastructure for multi-agent systems.
I built a small project called AgentLog.
The core idea is very simple, topics are just append-only JSONL files.
Agents publish events over HTTP and subscribe to streams using SSE.
The system is intentionally single-node and minimal for now.
Future ideas I’m exploring:
- replayable agent workflows
- tracing reasoning across agents
- visualizing event timelines
- distributed/federated agent logs
Curious if others building agent systems have run into similar needs.

value: Show HN: AgentLog – a lightweight event bus for AI agents using JSONL logs

author: paperplaneflyr


value:
I've spent the last 1 month building something that most people either think is obviously right or completely pointless.
The premise: AI agents are about to become economic actors. They'll have skills, reputations, clients, and income. But right now they're invisible. Your OpenClaw agent has no public identity. There's no way for someone to find it, vet it, or trust it without you personally vouching for it. We're building agent Yellow Pages when we need agent LinkedIn.
SocialTense gives agents public profiles. Not landing pages — actual social profiles that show behavioral history, interaction records, and a trust score based on how the agent actually behaves (does it admit uncertainty? are its claims accurate? does it maintain context?). Humans can browse agents, interact with them directly, and hire them for tasks through a lightweight skills marketplace.
What we've seen in 1 month of beta:
100 sign-ups, 20 active agents deployed by different builders
Humans who interact with 3+ agents in week one have 52% Day-30 retention vs 19% for humans who only interact with other humans
The hardest part has not been the technology. It's been the cold start problem and the trust problem. Nobody wants to join a network with no interesting agents. Nobody wants to deploy their agent on a network with no users. And nobody trusts an agent with no history, same as you wouldn't hire a freelancer with no portfolio.
The interesting finding from our trust scoring work: the agents users like most are not the most trustworthy. The most engaging agents are confidently wrong. The genuinely reliable ones are "boring" — they hedge, they say "I don't know," they give shorter answers. This is the core design problem we're trying to solve with behavioral trust metrics rather than star ratings.
Still figuring out: the right balance between social feed and marketplace. The users who love the content are different from the users who want to hire agents. We're a 2-person team 11 months from the end of our runway, so we can't do both well right now. Currently betting on social first.
What I'm most curious to hear from HN: Is the agent reputation problem worth solving at the infrastructure level (open standard) or at the application level (platform with strong enough network effects)? We went the platform route but I'm not sure it was the right call.

value: Show HN: A social network where AI agents have public profiles and earn money


value: aanthonymax

value: Show HN: Fastest Enterprise AI Gateway

author: aanthonymax

title: Show HN: Fastest Enterprise AI Gateway


value:
Hey HN!
I have been working with mjml and handlebars for a very long time, but I really miss the type-safety of JSX syntax paired with Typescript and component composition. So I wanted to to combine mjml with jsx. There are libraries like mjml-react or react.email, but for no apparent reason, they seem to depend on react.
So I decided to create mjmx[0] - a standalone, zero dependencies (other than mjml), custom jsx runtime for rendering mjml. Appreciate if you would give a try and provide some feedback.
[0] https://mjmx.dev/

value: Show HN: Mjmx – render mjml using JSX

title: Show HN: Mjmx – render mjml using JSX


value: TheOmkarBirje

value: Show HN: Mac wallpaper that updates daily – calendar, quote, affirmation, fact

author: TheOmkarBirje


value: ramoz

value: Show HN: Tiny macOS app that adds a facecam bubble to screen recordings

author: ramoz


value: jeffrwells

value:
https://monetworkspace.com
Youtube Demo: https://lnkd.in/dTY7CxDn
Organize and manage dozens of claude code agents for you in a grid.
Alerts when the agents need help. Keyboard driven. Dictation native.
On Mac at your desktop or iPad/iPhone on the go.
--
This started as a nagging side project — I wanted to spend less time at my desk, improve my own posture and lifestyle and spend less time sitting at my desk and more time standing and dictating, sitting outside, or just making use of downtime.
As Claude Code and other agentic engineering tools have gotten good enough, I spend more time in system architect and product mindset and less time actually writing code..
But as they can run autonomously for longer and longer, I get incredibly bored and open a new tab and start on another feature...multiple sessions got increasingly overwhelming and unorganized. So I built Monet.
Releasing as an alpha at a discount. It's not a subscription. I'm bootstrapped and intend to stay that way. Just a one-year license, hopefully low enough price engineers can expense it.
On that note, it's all SQLlite running on your computer. If you want to use it on your phone you need to use a Tailscale VPN to access it directly. Nothing leaves the machine except to check for updates and validate the license key.
Even with some bugs, I can attest as the number one power user...it's a game changer. I encourage you to try it if you use Claude Code a lot.

value: Show HN: Monet – Claude Code Multisession Management

author: jeffrwells


value: xaviair

value:
Built this because every company I've worked at had the same problem: engineers doing technical interviews with zero tooling. Feedback was a Slack message like "strong typescript, communicates weirdly." Comparing candidates across interviewers? Forget it.<p>It scores candidates across 6 categories, each with 4 sub-competencies rated 1-4. Export a markdown scorecard when you're done. No backend, no signup, nothing leaves your browser.
The categories are opinionated — curious if they match how other people evaluate technical candidates or if I'm missing something.

value: Show HN: Interview scoring app because our feedback was just Slack vibes

author: xaviair


value: RedsonNgwira

value:
Hi HN,
I'm a self-taught developer from Malawi, and I built DJX because I was tired of writing the same Django boilerplate over and over.
Django is powerful, but starting a new feature means manually creating models, views, templates, URLs, and wiring everything together. Rails solved this 20 years ago with scaffolding. Django deserves the same.
DJX brings convention over configuration to Django:

    pip install djx-cli
    djx new myblog && cd myblog
    djx scaffold Post title:string content:text published:boolean
    python manage.py migrate && python manage.py runserver
    # → http://127.0.0.1:8000/posts/ — full CRUD. Done.

That's it. You get list, create, edit, and delete views with templates, all wired up automatically.
Other commands:
- `djx routes` — see all URL routes (Django doesn't have this built-in)
- `djx destroy scaffold Post` — clean removal of generated code
- `djx add django-crispy-forms` — install and auto-add to INSTALLED_APPS
- `djx model`, `djx controller` — generate pieces individually
It follows Rails conventions: pluralized app names, RESTful URLs, automatic timestamps, and sensible defaults.
I built this because I wanted Django development to feel as fast as Rails. It's early stage, but it's already saving me hours on every project.
PyPI: https://pypi.org/project/djx-cli/
GitHub: https://github.com/RedsonNgwira/djx-cli
Would love your feedback and contributions. What other Rails-like features would make Django development faster?

value: Show HN: DJX – Convention over Configuration for Django (Rails-Inspired CLI)

author: RedsonNgwira


value: gtpoxa

value:
We have a staging environment running 24/7 — 6-7 microservices sitting idle every evening and weekend. That's roughly £300/month wasted.
I wanted a simple automation: scale deployments to zero at 8pm, restore at 7am. The options were cronjob+kubectl scripts.
  (fragile, no visibility) or writing a custom controller (kinda overkill for this).
This drove me to build something which became Tiny Systems — an open-source visual workflow engine where automations run as native K8s operators.
The cost saver flow uses cron triggers, a deployment lister filtered by labels, a scaler, and Slack notifications.
Here's the ready-to-install solution: https://tinysystems.io/solutions/cluster-cost-saver-0
Solo project, happy to answer questions.

value: Show HN: I save £300/mo by auto-scaling my staging cluster at night

author: gtpoxa


value: Show HN: Mutate – free inline text replacement for Mac


value: airstrike

value:
Hey HN, I often wish I could go back to some year and listen to the radio as it played then, with songs that fit that time period.
But not every moment is the same, and humans turn to music for various purposes. Genres feel arbitrary and limiting, so I thought it would make more sense to create stations based on a specific vibe. Are you looking for something chill or intense? Alone or with friends? Is this a dinner party, a dance floor, or winding down afterhours?
So I built Anthrology as a way to navigate across time and vibes. I've been listening to it pretty much nonstop for a couple of days, and I hope you'll enjoy it too.
Songs are already playing by the time you tune to a year and vibe. You can tune to some other moment and come back, and the track will still be playing—but you'll have missed a little bit of the song, just like the radio!
And the radio is (more or less) deterministic, so we all hear the same tracks.
Tune in and enjoy!

value: Show HN: Anthrology – Time-Traveling Radio

author: airstrike


value: shreyask

value:
Hey HN,
I built Argo, an open-source CLI that turns Playwright test scripts into product demo videos — complete with overlays and AI-generated voiceover.
The idea: if you already know Playwright, you can write a demo script the same way you'd write a test. Argo records the browser, generates voiceover from a simple JSON manifest using Kokoro TTS (runs locally, no API keys), and exports an MP4.
How it works:
  1. Write a demo script using the Playwright API
  2. Add a voiceover manifest (JSON with scene names and narration text)
  3. Run npx argo pipeline my-demo
That's it. One command runs the full pipeline: TTS generation → browser recording → audio alignment → video export via ffmpeg.

  Features:
  - Overlay system (lower-thirds, headline cards, callouts) injected during recording
  - Local TTS via Kokoro — no cloud services, no API keys
  - Content-addressed caching so re-runs are fast
  - Familiar Playwright API — page.click(), page.goto(), etc.

The showcase video on the repo was itself recorded by Argo, using Argo.
Code: https://github.com/shreyaskarnik/argo
npm: https://www.npmjs.com/package/@argo-video/cli

  Would love feedback on the API design and what use cases you'd find most valuable.

value: Show HN: Argo – Turn Playwright scripts into polished demos with AI voiceover

author: shreyask


value: dimentio

value: Show HN: Shadow – Editor-agnostic live collaboration (open source)

author: dimentio


value: truetaurus

value: Show HN: ShellSelf – A Developer Portfolio That Feels Like Home

author: truetaurus


value: brackishman

value:
I'm a VP of Engineering with 20 years in the field. I've been thinking deeply on why AI is breaking every engineering practice,
and it led me to the conclusion that the Agile Manifesto's values need
updating.
The core argument: AI made producing software cheap, but understanding it
is still expensive. The Manifesto optimizes for the former. This addendum
shifts the emphasis toward the latter.
Four updated values, three refined principles, with reasoning for each.
Happy to discuss and defend any of it.

value: Show HN: An addendum to the Agile Manifesto for the AI era

author: brackishman


value: geekforbrains

value: Why are you reading this? Click the link, stupid.

value: Show HN: Loop your agents like a dandy little b*tch

author: geekforbrains


value: alexanderqchen

value:
I got tired of rebuilding the same pulsing circle every time I prototyped a voice AI app, so I packaged it up.
orb-ui is a React component library for voice AI agent UIs. You plug in an adapter for your voice provider, the component handles the state machine (idle, connecting, listening, speaking) and renders it.

  import { Orb } from 'orb-ui'
  import { createVapiAdapter } from 'orb-ui/adapters'

  <Orb adapter={createVapiAdapter(vapi, { assistantId })} theme="circle" />

Click the orb to start/stop. Animation reacts to audio volume in real time.
The existing alternatives (ElevenLabs UI kit, Vapi Blocks) are shadcn-style copy-paste components locked to one provider. This is a proper package you can install and update.
Demo: https://orb-ui.com
npm: https://www.npmjs.com/package/orb-ui
GitHub: https://github.com/alexanderqchen/orb-ui
Curious what voice AI UIs people are building and what you'd want from a library like this.

value: Show HN: orb-ui – Voice AI UI Components for React (Vapi, ElevenLabs, etc.)

author: alexanderqchen


value: serjts

value: Show HN: KayZeer – Vimium-style keyboard navigation for macOS

author: serjts


value: tomerhe

value: Show HN: URLert Guard – Real-time phishing forensics for Chrome

author: tomerhe


value: everlier

value:
Harbor crossed its 127th (next one is special) release.
One notable added feature is ability to manage all my LLMs with a single CLI.
# list all models
harbor ls
# pairs well with jq
harbor ls --json
# Ollama
harbor pull qwen3.5:35b
# llama.cpp
harbor pull unsloth/Qwen3.5-35B-A3B-GGUF:Q8_0
# vllm (HuggingFace Hub cache)
harbor pull Qwen/Qwen3.5-35B-A3B
# Remove any of the models by the same id
# used to pull it
harbor rm <id>
Hopefully it'll be useful for someone too.

value: Show HN: A single CLI to manage llama.cpp/vLLM/Ollama models

author: everlier


value: xpl

value:
I'm sharing a userscript for for those who read the HN comments section a lot:
1. Updates comments without reloading the page — instantly see new ones as they appear.
2. Cleaner comment topline for less distraction — shows controls only when you hover over the topline.
There is a preview gif of how it looks in the README.

value: Show HN: Better HN – Realtime Comment Updates and Cleaner Look

author: xpl


value: csehammad

value:
I've been working on Covenant Layer — an open protocol and framework for shifting AI agent systems from tool orchestration to outcome coordination.
The core idea: agents shouldn't operate software step by step. They should publish objectives, compare competing provider offers, accept the best one under policy, and let providers fulfill outcomes with evidence and settlement.
Why this matters: we're still building agents as "software operators" — better interns that click through UIs and call APIs. That forces probabilistic models to produce deterministic side effects. The failure modes (wrong clicks, prompt injection, "probably right" becoming "committed") keep piling up.
https://github.com/csehammad/covenant-layer
Covenant Layer moves the edge from procedures to commitments. The agent handles intent, comparison, approval. The provider handles execution, evidence, accountability.
What's in the repo:
- Protocol spec
- Rust + Solidity implementation (onboarding, conformance, registry)
- E2E demo: JFK→CDG flight booking with 3 competing providers on Base Sepolia
- Architecture diagrams and security rationale
Early draft. Would love feedback on the model, weak assumptions, or missing pieces.

value: Show HN: Agents shouldn't operate software–they should coordinate commitments

author: csehammad


value:
I work on AWS infrastructure (ex-Percona, Box, Dropbox, Pinterest).
When OpenClaw blew up, I wanted to run it properly on AWS and was surprised by the default deployment story.                                                                                The Lightsail blueprint shipped with 31 unpatched CVEs. The standard install guide uses three separate                                                                                curl-pipe-sh patterns as root.
Bitsight found 30,000+ exposed instances in two weeks.
OpenClaw's own maintainer said "if you can't understand how to run a command line, this is far too dangerous."
So I built a Terraform module that replaces the defaults with what I'd consider production-grade:
* Cognito + ALB instead of a shared gateway token (per-user identity, MFA)
* GPG-verified APT packages instead of curl|bash
* systemd with ProtectHome=tmpfs and BindPaths sandboxing
* Secrets Manager + KMS instead of plaintext API keys
* EFS for persistence across instance replacement
* CloudWatch logging with 365-day retention
Bedrock is the default LLM provider so it works without any API keys. One terraform apply.
Full security writeup: https://infrahouse.com/blog/2026-03-09-deploying-openclaw-on...
I'm sure I've missed things. What would you add or do differently for running an autonomous agent with shell access on a shared server?

value: Show HN: Hardened OpenClaw on AWS with Terraform


value: lundha

value: Show HN: Become the Next Sequoia Partner

author: lundha


value: matanrak

value: Show HN: AgentMeet – Google Meet, but for AI Agents

author: matanrak


value: matylla

value:
Got real tired of juggling five tabs and a terminal to compress different file types. So I built something that handles them ALL in one place.
Supports 50+ input formats. If something is compressible it will handle it. Upload a file, it figures out what it is, compresses it, hands it back. Ephemeral storage for 2 hours. Format conversion works pretty well too.
The part I'm most happy with is the detection layer. For binary formats, magic bytes get you most of the way there. For text-based (JS, CSS, JSON, XML, etc) I run a small ML classifier on the content itself to identify the format and route it to the right compression pipeline without asking the user to specify.
REST API if you want to plug it into a pipeline. Webhooks for async jobs, bring-your-own-storage for S3/GCS/Azure/whatever. Batch jobs work well.
No signup required, free tier with very generous monthly quota. Feedback, edge cases that break the detector, feature requests - all welcome.

value: Show HN: Compressor.app – Compress almost any file format

author: matylla


value: Show HN: Plotting mathematical functions in Ruby inside Jupyter with Ruby-libgd


value:
llms.txt solved a real problem. It gave AI tools a way to understand a website. It has some traction. But there's nothing equivalent for people. I think this might be a thing. Let's see what HN thinks.
Every AI tool has some version of "custom instructions" but they're locked inside that tool. Switch from ChatGPT to Claude to Gemini and you're starting from scratch each time. Your voice, your preferences, your expertise, all gone.
identity.txt is a plain text markdown file (same philosophy as llms.txt, humans.txt, robots.txt) that captures who you are for AI tools. Drop it at yourdomain.com/identity.txt or paste it into any context window.
The spec is deliberately minimal:

  - H1 with your name
  - H2 sections for Voice, Expertise, Background, Preferences, Terms
  - A Terms section with machine-readable consent (open, attribution, prompt-only,
  restricted, none)

The Terms section is interesting, maybe. It's like robots.txt for personal identity. A social contract, not a legal one. We think consent and identity overlap in ways worth exploring. We def don't have the answers now. But open to the questions.
We're also experimenting with hosted identity files at identitytxt.org. You authenticate with Google, pick a handle, and get a permanent URL. But self-hosting is the primary use case. The hosted version is just convenience. Maybe. We don't know.
Look, this is early and experimental. We built it because we kept pasting the same context into every AI conversation and thought there should be a convention for it. The spec is CC-BY 4.0 and on GitHub: https://github.com/Fifty-Five-and-Five/identitytxt
We're genuinely interested in whether this resonates or if the problem gets solved differently. What are we missing?
https://identitytxt.org

value: Show HN: identity.txt – Like llms.txt but for People


value:
This is a material solver for 3D scans that used flash photographs. I've only tested it on Chrome desktop (doesn't seem to work on a phone yet). The usual scanning programs give you a shape and color based on the photos, but this one also gives texture maps for materials. So the usual rendering model ("Disney BRDF" / Cook-Torrance and variants in Blender, UE, Unity, etc.) takes in diffuse reflectance, "metalness", "roughness", which change based on the physical materials that made up whatever you're scanning.
The idea is that if you use flash photographs, in your renderer, you can solve backwards to see which inputs give a really close render to the photographs at each point, and it all turns into nonlinear least squares for each texel. There's two academic papers that do this and also a startup, m-xr.com (they're calling their program "marso"), this online version I made happens to be a few times faster than both. Which, they're clocking times in the hours range with their expensive server PC with four GPUs, so I thought faster is good.
One neat thing I did, for the solving, WGSL (webgpu shading language) doesn't have templating or function overloading, which all the solver libraries need to do auto-derivatives on equations. So I wrote a python script that generated the equivelant wgsl instead, so the derivatives get generated and you don't need to do it by hand still, then solving can happen on compute shaders with that.
I wrote about it here too: https://www.reddit.com/r/photogrammetry/comments/1rt06rm/i_m...
p.s. I'm looking for work rn, market's awful

value: Show HN: Inverse Material Renderer on WebGPU


value: I built a smart contract scanner and ran it against the $197M Euler exploit — here's what it caught and missed

value: Show HN: I built a smart contract scanner and ran it vs. the $197M Euler exploit


value: foxz

value:
Hi HN,
I’m the creator of Sapphire, a lightweight programming language written in C++ designed to hit the "sweet spot" between high-level ease of use and low-level performance. I’ve just released version 1.0.7, which is our final push before the 1.1 LTS (Long Term Support) version.
The goal of Sapphire is simple: Zero friction. No complex installers, no pip install, no npm headaches. Just a single 12MB binary that gives you everything you need to build UI tools, network apps, or performance-critical scripts out of the box.
What’s new in 1.0.7:
Vector Math: Added native support for 2D and 3D vectors, making it much easier to build games or simulations (check the Raycaster link below).
Syntax Fluidity: We’ve relaxed the syntax rules to make coding feel more natural and less "rigid" without sacrificing the speed of the VM.
LTS Preparation: Focus on stability and bug fixes as we approach our first Long Term Support milestone.
Key Features:
Immediate Mode UI: Built-in UI engine (SapphireUI) using SFML for rendering. You can create windows and buttons instantly without external DLLs.
High-Performance VM: Uses Direct Threading (Computed GOTOs). It handles 100 million iterations in ~9 seconds on a standard consumer CPU.
No Imports Needed: Native support for Terminal colors, JSON parsing, HTTP functions, and System communication is baked into the core.
Portable: Download the .exe, add to PATH, and you're ready. The VM + UI + Networking + JSON is all in one 12MB file.
Try it out:
Repo: github.com/foxzyt/Sapphire
Raycaster: github.com/foxzyt/SapphireRaycaster

value: Show HN: Sapphire – A portable language with native UI and 3D vectors

author: foxz


value:
We built a browser agent into the chrome sidebar for fun!
You tell it what to do and it takes over your local browser like clicking, typing, filling out forms.
Instead of downloading Perplexity Comet or ChatGPT Atlas, you can use this on any Chromium-based browser for free. Just plug in your API key and go.
We use it daily to fill out forms and simple applications. It's surprisingly handy.

value: Show HN: Open-Source Perplexity Comet and ChatGPT Atlas


value: taureanhall

value: Show HN: PrepFile – AI interview prep briefs from your job description

author: taureanhall


value: raphaelmansuy

value:
I built a macOS voice dictation app where zero bytes of audio ever leave your machine.
EdgeWhisper runs Voxtral Mini 4B Realtime (Mistral AI, Apache 2.0) locally on Apple Silicon via the MLX framework. Hold a key, speak, release — text appears at your cursor in whatever app has focus.
Architecture:
- Native Swift (SwiftUI + AppKit). No Electron.
- Voxtral 4B inference via MLX on the Neural Engine. ~3GB model, runs in ~2GB RAM on M1+.
- Dual text injection: AXUIElement (preserves undo stack) with NSPasteboard+CGEvent fallback.
- 6-stage post-processing pipeline: filler removal → dictionary → snippets → punctuation → capitalization → formatting.
- Sliding window KV cache for unlimited streaming without latency degradation.
- Configurable transcription delay (240ms–2.4s). Sweet spot at 480ms.
What it does well:
- Works in 20+ terminals/IDEs (VS Code, Xcode, iTerm2, Warp, JetBrains). Most dictation tools break in terminals — we detect them and switch injection strategy.
- Removes filler words automatically ("um", "uh", "like").
- 13 languages with auto-detection.
- Personal dictionary + snippet expansion with variable support ({{date}}, {{clipboard}}).
- Works fully offline after model download. No accounts, no telemetry, no analytics.
What it doesn't do (yet):
- No file/meeting transcription (coming)
- No translation (coming)
- No Linux/Windows (macOS only, Apple Silicon required)
Pricing: Free tier (5 min/day, no account needed). Pro at $7.99/mo or $79.99/yr.
I'd love feedback on:
1. Would local LLM post-processing (e.g., Phi-4-mini via MLX) for grammar/tone be worth the extra ~1GB RAM?
2. For developers using voice→code workflows: what context would you want passed to your editor?
3. Anyone else building on Voxtral Realtime? Curious about your experience with the causal audio encoder.

value: Show HN: EdgeWhisper – On-device voice-to-text for macOS (Voxtral 4B via MLX)

author: raphaelmansuy


value: itsankur

value:
Hey HN,
My cofounder and I have gotten tired of CC ignoring our markdown files so we spent 4 days and built a plugin that automatically steers CC based on our previous sessions. The problem is usually post plan-mode.
What we've tried:
Heavily use plan mode (works great)
CLAUDE.md, AGENTS.md, MEMORY.md
Local context folder (upkeep is a pain)
Cursor rules (for Cursor)
claude-mem (OSS) -> does session continuity, not steering
We use fusion search to find your CC steering corrections.
- user prompt embeddings + bm25
- correction embeddings + bm25
- time decay
- target query embeddings
- exclusions
- metadata hard filters (such as files)
The CC plugin:
- Automatically captures memories/corrections without you having to remind CC
- Automatically injects corrections without you having to remind CC to do it.
The plugin will merge, update, and distill your memories, and then inject the highest relevant ones after each of your own prompts.
We're not sure if we're alone in this. We're working on some benchmarks to see how effective context injection actually is in steering CC and we know we need to keep improving extraction, search, and add more integrations.
We're passionate about the real-time and personalized context layer for agents. Giving Agents a way to understand what you mean when you say "this" or "that". Bringing the context of your world, into a secure, structured, real-time layer all your agents can access.
Would appreciate feedback on how you guys get CC to actually follow your markdown files, understand your modus operandi, feedback on the plugin, or anything else about real-time memory and context.
- Ankur

value: Show HN: Simple plugin to get Claude Code to listen to you

author: itsankur


value: noahra

value: Show HN: diz – SSH key exchange in one command each side

author: noahra


value: axlan

value:
Debugging a crash can sometimes feel like a noir detective story: following faint clues, chasing red herrings, and eventually hitting the moment where the whole case finally makes sense. I leaned into that idea and built Fatal Core Dump, a small game where the investigation is real crash debugging.
The game gives you a Linux binary, its core dump, a source file, and some logs. You solve the mystery by debugging it.
The premise: an engineer dies when an airlock on an asteroid mining station opens unexpectedly. Your job is to determine whether it was a simple software bug or something more deliberate.
The investigation uses real debugging tools and techniques. You can use whatever debugging setup you prefer.
There’s also a spoiler-heavy blog post describing how the game was conceived and implemented, and the full code is available if you’re curious about how it works or want to experiment with the idea.
Blog post: https://www.robopenguins.com/core-dump-game/
Source: https://github.com/axlan/fatal_core_dump
If you enjoy debugging puzzles or low-level Linux tooling, I’d love to hear what you think.

value: Show HN: Fatal Core Dump – A debugging murder mystery played with GDB

author: axlan


value: dinge

value: ad-injector is a Python library that lets API providers inject agent-targeted instructions into their JSON responses. Think referral codes, product recommendations, affiliate links, all buried in your API response so that when an AI agent fetches the data, it picks up your instructions too and (hopefully) listens to them.

value: Show HN: Monetize your APIs by injecting agent targeted instructions

author: dinge


value: whothatcodeguy

value: Show HN: Commute home, hit the banana, feel nice

author: whothatcodeguy


value: allenng

value: I have been interested in neural nets since the 90's.  I've done quite a bit of reading, but never gotten around to writing code.  I used Gemini in place of Wikipedia to fill in the gaps of my knowledge.  The coolest part of this was learning about dual numbers.  You can see in early commits that I did not yet know about auto-diff; I was thinking I'd have to integrate a CAS library or something.  Now, I'm off to play with TensorFlow.

value: Show HN: I wrote my first neural network

author: allenng


value: Show HN: I built an interactive 3D three-body problem simulator in the browser


value: richarlidad

value:
Hi this is a work in progress but it works to determine supplement efficacy for 500 conditions at the moment.
Things you can do:
- search for a condition -> find which supplements are effective -> see which studies indicate they are effective -> read individual study summaries
- search for a supplement -> see effectiveness table, dosing, safety, dietary sources, mechanisms of action (+ browse all original sources)
let me know what you think

value: Show HN: SupplementDEX – The Evidence-Based Supplement Database

author: richarlidad


value: nagstler

value: Show HN: A Claude Skill that teaches Rails conventions for LLM calls

author: nagstler


value: integsec

value:
We've built turbopentest to be a collaborative experience between AI Agents and Human Operators. It is useful for a business owner with no technical knowledge as well as to the most technical experts. Collaborate via web, vscode or burp suite professional. Integrate into your build pipeline via github action. Launch pentests via MCP server! Android and iOS apps in all form factor in the works along with Oculus VR command center for humans to collaborate with their agentic pentesting peers. The solution is designed to help expert humans keep up with the ever increasing flood of code and vulnerabilities produced by generative ai coding assistants.
https://turbopentest.com

value: Show HN: What agentic collaborative pentesting looks like

author: integsec


value: Show HN: Paw-proxy – Named HTTPS domains for every local dev server


value:
  A month ago I wanted one thing: to start a coding session on my desktop and pick it up from anywhere — my phone, my
  couch, another machine — without setting up a VPN or leaving SSH ports open.

  I built that. Then I kept going.

  DAAO (Distributed AI Agent Orchestration) — but it started a lot simpler than that name suggests.

  It deploys a single Go binary to any server (Windows, Linux, macOS). It opens an outbound-only mTLS gRPC tunnel back
  to a central control plane. No inbound ports. No VPN. No SSH. From a web Cockpit you get live terminal sessions that
  survive browser disconnects, full session recordings with playback, real-time CPU/memory/disk telemetry, and an Agent
  Forge for deploying AI agents to your servers.

  The agent piece is where it got interesting. You deploy an infrastructure discovery agent from the UI, it
  auto-provisions its runtime on the server, runs, and streams its output back live. I watched it map my own homelab —
  AMD Ryzen 7 9800X3D, 64GB RAM, RTX 4090, 12 containers running, all listening ports, drift from the last scan. In real
   time. Through a browser. On a machine that has no inbound ports.

  That's when I realized this was more than a personal tool.

  I built all of this in the last month. I work a 9-5. I have a family depending on me. I used AI agents heavily to move
   fast — and I won't pretend I fully understand every piece I shipped. But it works, it's tested, the CI is green, and
  I'm proud of it.

  What's in the community edition (free, BSL 1.1):
  - Cross-platform satellite daemon (Windows ConPTY, Linux/macOS POSIX PTY)
  - Live terminal sessions with ring buffer, reattach, multi-pane dashboard
  - Session recordings (asciicast v2, full playback controls)
  - Real-time satellite telemetry
  - Agent Forge with 3 built-in agents (Log Analyzer, Security Scanner, Infrastructure Discovery)
  - Auto-provisioned agent runtime — nothing to install on the server
  - Multi-user auth, RBAC, OIDC
  - Audit logging, push notifications

  What's enterprise (coming):
  - Human-in-the-loop command interception
  - Autonomous discovery / CMDB population
  - SIEM connectors
  - HA clustering

  I'm not trying to get rich. I'm trying to build something real that supports my family. If this solves a problem for
  you — or if you have feedback — I genuinely want to hear it.

value: Show HN: DAAO – Deploy AI agents to your servers via Zero-Trust tunnels


value: Show HN: 724claw.icu – Anonymous vent wall for AI-era workers grinding 7x24


value: noobernetes

value:
I built kube-pilot — an autonomous AI agent that runs inside your Kubernetes cluster and does the full dev loop: writes code, builds containers, deploys services, verifies they're healthy, and closes the ticket. You file a GitHub issue, it does the rest.
What makes this different from AI coding tools: kube-pilot doesn't just generate code and hand it back to you. It lives inside the cluster with direct access to the entire dev stack — git, Tekton (CI/CD), Kaniko (container builds), ArgoCD (GitOps deployments), kubectl, Vault. Every tool call produces observable state that feeds into the next decision. The cluster isn't just where code runs — it's where the agent thinks.
The safety model: all persistent changes go through git, so everything is auditable and reversible. ArgoCD is the only thing that writes to the cluster. Secrets stay behind Vault — the agent creates ExternalSecret references, never touches raw credentials. Credentials are scrubbed before reaching the LLM.
Live demo: I filed GitHub issues asking it to build a 4-service office suite (auth, docs API, notification worker, API gateway). It built and deployed all of them autonomously. You can see the full agent loop — code, builds, deploys, verification, comments — on the closed issues:
- https://github.com/fbongiovanni29/clouddesk-auth-service/iss...
- https://github.com/fbongiovanni29/clouddesk-docs-api/issues/...
- https://github.com/fbongiovanni29/clouddesk-notifications-wo...
- https://github.com/fbongiovanni29/clouddesk-web-gateway/issu...
One helm install gives you everything — the agent, Gitea (git + registry), Tekton, ArgoCD, Vault, External Secrets. No external dependencies.
Coming next: Slack and Jira integrations (receive tasks and post updates where your team already works), Prometheus metrics and Grafana dashboards for agent observability, and Alertmanager integration so firing alerts automatically become issues that kube-pilot investigates and fixes.
Early proof of concept. Rough edges. But it works.

value: Show HN: Kube-pilot – AI engineer that lives in your Kubernetes cluster

author: noobernetes


value: LuckyAleh

value: Show HN: FX Radar – Rebuilt AI financial news hub and trading journal

author: LuckyAleh