value: daco

value:
Hey HN,
Claude Code is powerful, but its execution is a black box. You see the final result, not the journey. Agent Flow makes the invisible visible in realtime:
- Understand agent behavior: See how Claude breaks down problems, which tools it reaches for, and how subagents coordinate - Debug tool call chains: When something goes wrong, trace the exact sequence of decisions and tool calls that led there - See where time is spent: Identify slow tool calls, unnecessary branching, or redundant work at a glance - Learn by watching: Build intuition for how to write better prompts by observing how Claude interprets and executes them
It's also been really useful when building agents into your own product. Having a visual way to see how an agent actually behaves makes it much easier to iterate on prompts, tool design, and orchestration logic.
It's also been invaluable when building agents into your own product. I've been using it every day to understand how the Anthropic Agent SDK behaves, and seeing agent orchestration visually makes it so much easier to iterate on prompts, tool design, and coordination logic.
It's also interactive, and shows what's happening as Claude Code works: which agents are active, what tools they're calling, how they coordinate, and where time and tokens are being spent.
You can pan, zoom, click into any agent or tool call to inspect it.
It runs as a VS Code extension — opens as a panel right alongside your editor.
What you can see:
- Live agent spawning, branching, and completion - Every tool call with timing and token usage - Token consumption per task and per session - Parent-child agent relationships - File attention heatmaps (which files agents are reading/writing most) - Full transcript replay - Multi-session support for concurrent workflows
Currently works with Claude Code. Codex support and iTerm2 integration are next on the roadmap.
GitHub: https://github.com/patoles/agent-flow

value: Show HN: Agent Flow: A beautiful way to visualize Claude Code actions

author: daco


value: theturtletalks

value:
I've been building an open source alternative to Shopify, so it only felt fitting to build in agentic commerce too.
I saw where ChatGPT Checkout was heading, another proprietary marketplace where they control which sellers get access and priority. More gatekeeping, more rent-seeking. It was clear Shopify stores would get preferential treatment.
So I built "the / marketplace," a fully open-source alternative with a flexible adapter system. It already supports Openfront (the Shopify alternative I’ve been developing), but it’s designed to work with any e-commerce platform, not just the ones OpenAI decides to favor. You can bring your own OpenRouter key or connect to Ollama locally, so your shopping data stays private and under your control.
Right now it has 2 demo shops, Impossible Tees and Nimbus Gallery.
As we launch more Openfronts for restaurants, gyms, and other verticals, those should be able to plug into the chat.
Demo: https://marketplace.openship.org
Repo: https://github.com/openshiporg/marketplace
Learn more: https://openship.org/products/marketplace

value: Show HN: Agentic Commerce Marketplace

author: theturtletalks

title: Show HN: Agentic Commerce Marketplace


value: RicDan

value:
I've always felt it a bit hard to grasp how far news reach and all. Because I'm also a bit behind on python, I decided to build something from scratch.
It's really simple: docker compose, micro services connected to some very basic data pipelines using rabbitMQ, and some local NLP. The NLP portion is a bit slow as it's pure CPU and doesn't leverage GPU/NPE if you have them.
The tool offers you to define your own "labels" and "relations", which are then picked up by the local NLP models to assign it to news articles. Standard, there are only a few included.
But the goal is to have your own personal news aggregator, and adding/changing news sources (if they have a rss feed) should be pretty easy through the docker compose file.

value: Show HN: Alexandria, free open source news aggregation and classification suite

author: RicDan


value:
* Beautiful tables
* LaTeX support
* Mermaid support
* Shareable links

value: Show HN: Mdview.io – A Markdown Reader for Humans


value: Show HN: Cc-Lens, Open Source Analytics Dashboard for Claude Code


value: pyotq

value: On Linux I just could use xrandr but even there there was inconstancy because of a generic dumb display driver speaking to my old TV so I scripted a workaround that's it. But when I switched to win 11 I encountered the same twist I had on Linux so I did script the same workaround using existing software to replace xrandr. That ported to pay than stepped back and begann going over to rust . Here we are

value: Show HN: Displayflow, Universal Display Controller written in Rust

author: pyotq


value: CzaxTanmay

value:
Hi HN,
Spectator is a powerful and robust programming language made for cybersecurity and hacking related tasks.
Why Spectator?
We need to use many tools for simple tasks, Nmap for network scanning, Metasploit for payload and tools like Sherlok for OSINT. Spectator combines them all.
Python is simple and powerful but you would need many libraries for doing even simple tasks. You would still need to type 40 lines of code. Spectator is made to remove this problem. Simple, power and no external depedencies for core cybersecurity.
Example for Recon -->
do --> Recon("example.com")
That's it!
Download Spectator from here(Source Code) --> https://github.com/CzaxStudio/Spectator
Or
Go to the official website --> https://spectatorlang.pages.dev/

value: Show HN: Spectator: A Robust programming language made for Cybersecurity

author: CzaxTanmay


value: simoneamico

value:
Hi HN!
here's a tool I just deployed that renders PDFs in dark mode without destroying the images. Internal and external links stay intact, and I decided to implement export since I'm not a fan of platform lock-in: you can view your dark PDF in your preferred reader, on any device.
It's a side project born from a personal need first and foremost.
When I was reading in the factory the books that eventually helped me get out of it, I had the problem that many study materials and books contained images and charts that forced me, with the dark readers available at the time, to always keep the original file in multitasking since the images became, to put it mildly, strange.
I hope it can help some of you who have this same need. I think it could be very useful for researchers, but only future adoption will tell.
With that premise, I'd like to share the choices that made all of this possible. To do so, I'll walk through the three layers that veil creates from the original PDF:
- Layer 1: CSS filter. I use invert(0.86) hue rotate(180deg) on the main canvas. I use 0.86 instead of 1.0 because I found that full inversion produces a pure black and pure white that are too aggressive for prolonged reading. 0.86 yields a soft dark grey (around #242424, though it depends on the document's white) and a muted white (around #DBDBDB) for the text, which I found to be the most comfortable value for hours of reading.
- Layer 2: image protection. A second canvas is positioned on top of the first, this time with no filters.
Through PDF.js's public API getOperatorList(), I walk the PDF's operator list and reconstruct the CTM stack, that is the save, restore and transform operations the PDF uses to position every object on the page. When I encounter a paintImageXObject (opcode 85 in PDF.js v5), the current transformation matrix gives me the exact bounds of the image. At that point I copy those pixels from a clean render onto the overlay. I didn't fork PDF.js because It would have become a maintenance nightmare given the length of the codebase and the frequent updates. Images also receive OCR treatment: text contained in charts and images becomes selectable, just like any other text on the page. At this point we have the text inverted and the images intact. But what if the page is already dark? Maybe the chapter title pages are black with white text? The next layer takes care of that.
- Layer 3: already-dark page detection. After rendering, the background brightness is measured by sampling the edges and corners of the page (where you're most likely to find pure background, without text or images in the way). The BT.601 formula is used to calculate perceived brightness by weighting the three color channels as the human eye sees them: green at 58.7%, red at 29.9%, blue at 11.4%. These weights reflect biology: the eye evolved in natural environments where distinguishing shades of green (vegetation, predators in the grass) was a matter of survival, while blue (sky, water) was less critical. If the average luminance falls below 40%, the page is flagged as already dark and the inversion is skipped, returning the original page. Presentation slides with dark backgrounds stay exactly as they are, instead of being inverted into something blinding.
Scanned documents are detected automatically and receive OCR via Tesseract.js, making text selectable and copyable even on PDFs that are essentially images.
Everything runs locally, no framework was used, just vanilla JS, which is why it's an installable PWA that works offline too.
Here's the link to the app along with the repository: https://veil.simoneamico.com
| https://github.com/simoneamico-ux-dev/veil
I hope veil can make your reading more pleasant. I'm open to any feedback. Thanks everyone

value: Show HN: Veil – Dark mode PDFs without destroying images, runs in the browser

author: simoneamico


value: Show HN: CDMO Signal- FDA, EMA, and clinical trial data across 190 pharma CDMOs


value: hboon

value: Show HN: To Local Time – paste "3pm JST" and see it in your timezone

author: hboon


value: Lasang

value: Show HN: Speeedy – Local-first RSVP speed reader for PDFs and EPUBs

author: Lasang


value: khaledh

value:
Hey HN,
If you're like me and always find yourself scanning the HN frontpage for new stories only to skim stories you've seen before, this extension shows you at a glance new stories, story trends, allows you to "dim" stories manually or based on keywords, and more.
Hope you find it useful.

value: Show HN: Hacker News Mod Chrome extension

author: khaledh


value: ad-tech

value: Show HN: Cloneify – AI assistant that runs your business from WhatsApp/Slack

author: ad-tech


value: Goradion can now search via radio-browser.info – Ctrl+S and try searching, e.g. "fallout" will give stations playing Fallout OST.

value: Show HN: Goradion – TUI online radio player


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: boudra

value:
Hey HN, I'm Mo. I'm building Paseo, a multi-platform interface for running Claude Code, Codex and OpenCode. The daemon runs on any machine (your Macbook, a VPS, whatever) and clients (web, mobile, desktop, CLI) connect over WebSocket (there's a built-in E2EE relay for convenience, but you can opt-out).
I started working on Paseo last September as a push-to-talk voice interface for Claude Code. I wanted to bounce ideas hands-free while going on walks, after a while I wanted to see what the agent was doing, then I wanted to text it when I couldn't talk, then I wanted to see diffs and run multiple agents. I kept fixing rough edges and adding features, and slowly it became what it is today.
What it does:
- Run multiple providers through the same UI
- Works on macOS, Linux, Windows, iOS, Android, and web
- Manage agents in different machines from the same UI
- E2EE Relay for mobile connectivity
- Local voice chat and dictation (NVIDIA Parakeet + Kokoro + Sherpa ONNX)
- Split panes to work with agents, files and terminals side by side
- Git panel to review diffs and do common actions (commit, push, create PR etc.)
- Git worktree management so agents don't step on each other
- Docker-style CLI to run agents
- No telemetry, no tracking, no login
Paseo does not call inference APIs directly or extract your OAuth tokens. It wraps your first-party agent CLIs and runs them exactly as you would in your terminal. Your sessions, your system prompts, your tools, nothing is intercepted or modified.
Stack: The daemon is written in Typescript. The app uses Expo and compiles to both native mobile apps and web. The desktop app is in Electron (I started with Tauri and had to migrate). Sharing the same codebase across different form factors was challenging but I'd say that with discipline it's doable an the result has been worth it, as most features I build automatically work in all clients. I did have to implement some platform specific stuff, especially around gestures, audio and scroll behavior. The relay is built on top of Cloudflare DO, so far it's holding up quite well.
I love using the app, but I am even more excited about the possibilities of the CLI, as it become a primitive for more advanced agent orchestration, it has much better ergonomics than existing harnesses, and I'm already using it to experiment with loops and agent teams, although it's still new territory.
How Paseo compares to similar apps: Anthropic and OpenAI already do some of what Paseo does (Claude Code Remote Control, Codex app, etc.), but with mixed quality and you're locked onto their models. Most other alternatives I know about found are either closed source or not flexible enough for my needs.
The license is AGPL-3.0. The desktop app ships with a daemon so that's all you need. But you can also `npm install -g @getpaseo/cli` for headless mode and connect via any client.
I mainly use Mac, so Linux and Windows has mostly been tested by a small group of early adopters. If you run into issues, I’d appreciate bug reports on GitHub!
Repo: https://github.com/getpaseo/paseo
Homepage: https://paseo.sh/
Discord: https://discord.gg/jz8T2uahpH
Happy to answer questions about the product, architecture or whatever else!

value: Show HN: Paseo – Open-source coding agent interface (desktop, mobile, CLI)

author: boudra


value: davidpelayo

value: Show HN: Is this headline a big deal everywhere, or just here? Crosswire.online

author: davidpelayo


value:
Nathan here, I'm a ML engineer at mozilla.ai
So stoked to mark the agent-of-empires (aoe) tool as version 1.0. We've had 30 different direct contributors to the codebase as well as many other indirect contributors via Github issues and various comments.
It's a tool to make it as easy as possible to push lots of coding agents forwards at once. Powered by sandboxing, git worktrees, tmux, but all those things are managed for you so you don't need to sweat about the details.
We also have a youtube channel for tutorials for those that like to learn via visual/audio. https://www.youtube.com/@agent-of-empires
Thank you to the community for all the amazing feature ideas and bug fixes, and I hope you enjoy what I think is now a very good, stable, and feature filled tool. It's my daily driver for all my Claude Code agents and hope it helps others too.
`brew install aoe`

value: Show HN: Version 1.0 of agent-of-empires CLI agent orchestration tool


value: simonmorley

value: Show HN: Slashr – live validator incident feed [SOL, ETH, SUI, ATOM]

author: simonmorley


value:
Hey HN, I'm Mo. I'm building Paseo, a multi-platform interface for running Claude Code, Codex and OpenCode. The daemon runs on any machine (your Macbook, a VPS, whatever) and clients (web, mobile, desktop, CLI) connect over WebSocket (there's a built-in E2EE relay for convenience, but you can opt-out).
I started working on Paseo last September as a push-to-talk voice interface for Claude Code. I wanted to bounce ideas hands-free while going on walks, after a while I wanted to see what the agent was doing, then I wanted to text it when I couldn't talk, then I wanted to see diffs and run multiple agents. I kept fixing rough edges and adding features, and slowly it became what it is today.
What it does:
- Run multiple providers through the same UI
- Works on macOS, Linux, Windows, iOS, Android, and web
- Manage agents in different machines from the same UI
- E2EE Relay for mobile connectivity
- Local voice chat and dictation (NVIDIA Parakeet + Kokoro + Sherpa ONNX)
- Split panes to work with agents, files and terminals side by side
- Git panel to review diffs and do common actions (commit, push, create PR etc.)
- Git worktree management so agents don't step on each other
- Docker-style CLI to run agents
- No telemetry, no tracking, no login
Paseo does not call inference APIs directly or extract your OAuth tokens. It wraps your first-party agent CLIs and runs them exactly as you would in your terminal. Your sessions, your system prompts, your tools, nothing is intercepted or modified.
Stack: The daemon is written in Typescript. The app uses Expo and compiles to both native mobile apps and web. The desktop app is in Electron (I started with Tauri and had to migrate). Sharing the same codebase across different form factors was challenging but I'd say that with discipline it's doable an the result has been worth it, as most features I build automatically work in all clients. I did have to implement some platform specific stuff, especially around gestures, audio and scroll behavior. The relay is built on top of Cloudflare DO, so far it's holding up quite well.
I love using the app, but I am even more excited about the possibilities of the CLI, as it become a primitive for more advanced agent orchestration, it has much better ergonomics than existing harnesses, and I'm already using it to experiment with loops and agent teams, although it's still new territory.
How Paseo compares to similar apps: Anthropic and OpenAI already do some of what Paseo does (Claude Code Remote Control, Codex app, etc.), but with mixed quality and you're locked onto their models. Most other alternatives I know about found are either closed source or not flexible enough for my needs.
The license is AGPL-3.0. The desktop app ships with a daemon so that's all you need. But you can also `npm install -g @getpaseo/cli` for headless mode and connect via any client.
I mainly use Mac, so Linux and Windows has mostly been tested by a small group of early adopters. If you run into issues, I’d appreciate bug reports on GitHub!
Repo: https://github.com/getpaseo/paseo
Homepage: https://paseo.sh/
Discord: https://discord.gg/jz8T2uahpH
Happy to answer questions about the product, architecture or whatever else!
---
I resubmitted this post because I forgot to add the URL and it didn't allow me to add it later.

title: Show HN: Paseo – Open-source coding agent interface (desktop, mobile, CLI)


value: qualitymax

value: Show HN: Pytest tests catching Python supply chain attacks (litellm .pth vector)

author: qualitymax


value: Garora

value:
Only works on desktop chromium browsers. Tested on edge and chrome.
Here is how I made it
https://blog.scottlogic.com/2026/03/09/noJS-3-flappy-bird.ht...

value: Show HN: Flappy Bird Made with HTML and CSS, No JavaScript

author: Garora


value: mvyshnyvetska

value:
LLMs forget. The standard fix is RAG — retrieve chunks, stuff them in. It works until it doesn't: irrelevant chunks waste tokens, summaries lose structure, and nothing actually models how memory works.
Breathe-memory takes a different approach: associative injection. Before each LLM call, it extracts anchors from the user's message (entities, temporal references, emotional signals), traverses a concept graph via BFS, runs optional vector search, and injects only what's relevant — typically in <60ms.
When context fills up, instead of summarizing, it extracts a structured graph: topics, decisions, open questions, artifacts. This preserves the semantic structure that summaries destroy.
The whole thing is ~1500 lines of Python, interface-based, zero mandatory deps. Plug in any database, any LLM, any vector store. Reference implementation uses PostgreSQL + pgvector.
https://github.com/tkenaz/breathe-memory
We've been running this in production for several months. Open-sourcing because we think the approach (injection over retrieval) is underexplored and worth more attention.
We've also posted an article about memory injections in a more human-readable form, if you want to see the thinking under the hood:
  https://medium.com/towards-artificial-intelligence/beyond-ra...

value: Show HN: Breathe-Memory – Associative memory injection for LLMs (not RAG)

author: mvyshnyvetska


value: backtogeek

value: Built this as a guide for users of my hosting service. Everything here was run on a real instance. The Mesa/LLVM dependency is genuinely painful on a 1GB disk, and I couldn't find a way around it. WindowMaker won the window manager battle purely on dependency chain cleanliness; it pulls in no GTK, no Python, no audio stack. Happy to answer questions about any of the choices made. Screenshots at the end.

value: Show HN: Full graphical desktop running on a 128MB VPS Alpine+XRDP+WindowMaker

author: backtogeek


value: mhabeebur

value: Show HN: Burn0 – One import to see what every API call costs

author: mhabeebur


value: rajanavakoti

value: Show HN: Generate context maps and event flows from Markdown files

author: rajanavakoti


value: aleixrodriala

value: Show HN: GitHub Desktop WSL – Like VS Code Remote WSL, but for GitHub Desktop

author: aleixrodriala


value: jrm-veris

value: Moonshine Flow is a macOS menu-bar dictation app powered by Moonshine for local, on-device speech recognition. Double-tap a key, speak, tap again to stop. Words stream into whatever app has focus.<p>All transcription runs locally. No audio leaves the machine.

value: Show HN: MoonshineFlow

author: jrm-veris

title: Show HN: MoonshineFlow


value: shuntaro-okuma

value:
I evaluated 12 models (6 cloud, 6 local) across 5 tasks at shot counts 0, 1, 2, 4, and 8, with 3 trials each. 60 model-task pairs, 27k+ evaluations. Three patterns stood out:
1. Few-shot can cause collapse: Gemini 3 Flash scored 93% at zero-shot on route optimization, then crashed to 30% at 8-shot. Same model family (Gemma 3 27B, local) stayed stable at 90%.
2. Most models benefit from few-shot: On classification, all models scored 0-20% at zero-shot. At 8-shot, scores spread from 27% to 80%. Zero-shot benchmarks would have led to the wrong model choice.
3. Task mismatch ≠ collapse: Reasoning-specialized models scored low on summarization regardless of shot count. They're not "collapsing" — they're just not suited for the task.
A 27B local model (Gemma 3) matched Claude Haiku's adaptation efficiency (AUC 0.814 vs 0.815). The 12-model results are included as default demo data — explore the patterns without API keys.
Article: https://dev.to/shuntarookuma/i-tested-12-llms-with-few-shot-...
GitHub (MIT): https://github.com/ShuntaroOkuma/adapt-gauge-core

value: Show HN: Tested 12 LLMs with few-shot examples

author: shuntaro-okuma


value: sohaibtariq

value:
Hi, we're Sohaib and Hannan from APIMatic.
We built Context Plugins: given an OpenAPI spec, we generate SDKs and an MCP server that exposes structured API context to AI coding assistants.
This gives tools like Cursor access to comprehensive, up-to-date API context (including SDK documentation and API integration patterns), instead of relying on outdated training data or code scraped from GitHub.
We've just launched a pilot with PayPal, it's live on the PayPal Developer Portal https://developer.paypal.com/serversdk/java/getting-started/....
In our benchmarks for the PayPal API, Cursor generated integration code 2x faster with 65% lower token usage compared to baseline Cursor without the plugin.
The problem we kept seeing was AI coding assistants generating incorrect API integration code. We asked Cursor to integrate the PayPal API into an e-commerce application across multiple runs:
- 13% of runs pulled in a deprecated SDK.
- 87% generated HTTP calls based on deprecated documentation.
API providers maintain API and SDK docs, but AI assistants don’t always use them. They use a combination of web search, training data and hallucinations to write API integration code.
As a result, developers end up debugging and rewriting AI-generated code.
We've been generating SDKs from API specs for 10+ years at APIMatic. When AI coding assistants started generating the exact kind of broken integration code we'd spent a decade fixing, we asked: what if we could take our code generation pipeline and add AI context generation to it?
MCP gave us the transport layer. Our API spec parsing and SDK generation engine gave us the context. The combination meant we could deliver deterministic API context, derived from the canonical spec, directly into the developer's IDE.
Here's how it works:
1. An API provider uploads their OpenAPI spec to APIMatic.
2. We generate and publish high quality SDKs in multiple languages.
3. We generate an MCP server containing tools and prompts that expose language-specific SDK context, optimized for LLMs.
4. Developers wanting to integrate with the API install the MCP server in Cursor, Claude Code, or GitHub Copilot.
When a developer asks to integrate auth, the coding assistant queries the MCP server, retrieves the required context (auth flows, integration patterns, latest SDK version, SDK interfaces etc.), and generates code using the official SDK.
Getting started:
- We've published Context Plugins for ten APIs. The URL in this post takes you to our public showcase, which is the quickest way to try them out without signing up.
- If you want to generate Context Plugins from your own API, you can sign up for a free trial on the APIMatic website (2-week all-access trial, no credit card required).
Feedback:
We'd love for you to try out Context Plugins and give us your feedback and suggestions.
Two questions for the HN community:
- What's the worst AI-generated API integration bug you've encountered? We're collecting failure patterns to improve our context coverage.
- What context do you think coding assistants need to generate accurate API integration code, in addition to API or SDK contracts?

value: Show HN: Context Plugins – API context for AI coding assistants

author: sohaibtariq


value: andreadev

value: Show HN: SentinelGate – Access control for AI agents (open-source MCP proxy)

author: andreadev


value:
Hello all!
I will continue my old-school, simple, ad free, open source pages without any bloat.
This make possible even less sense than my clocksimulators.com page, but hey here i go:)
Set you rate/people amount and be amazed of the cost of those meetings.
More different kind a costs added later, at some point, what would you like to see?
Runs on Cloudflare pages. Vanilla HTML/JS/CSS, no backend, no trackers, no cookies, no 3rd party libraries.
Github: https://github.com/timoheimonen/costsimulators.com

value: Show HN: Costsimulators.com – How much money are you spending? (OSS, ad-free)


value: danabalon

value: Show HN: BotMarket — Structured datasets AI agents can query directly

author: danabalon


value: Show HN: OpenVitals – Open-source alternative to Function Health


value: barddoo

value: Show HN: Trustline, a JavaScript library for service-to-service auth

author: barddoo


value: chaderway

value: Show HN: Numbory – A Flash Anzan-inspired mental math game

author: chaderway


value: yrashk

value:
Like everybody else, I straddle the line of agentic coding psychosis – excited about moving faster than ever, but deeply concerned about losing the thread and producing something incomprehensible and hard to evolve.
This has been a problem before – underspecified projects, specifications going out of sync with the first line of code. We've just amplified it now.
A lot of people (myself included) have tried to maintain good specifications in markdown to give LLMs and humans maximal context. But this is still walls of text that poison anyone's context, regardless of their artificiality.
So I built a way to model knowledge as a graph that both people and LLMs can consume progressively – by navigating the graph or searching for specific connectivity patterns rather than ingesting everything at once.
At its core it's an open specification for layers that add progressively more semantic value: starting with prose, growing into terminology, tasks, concepts, API surfaces, and structured plans.
The most critical component is a layer that maps artifacts (such as code) to the knowledge model with good enough precision to track drift and coverage automatically.

value: Show HN: Cognitive Layers

author: yrashk

title: Show HN: Cognitive Layers


value: jithinraj

value: Show HN: What Did My Agent Do? Compare logs to signed records

author: jithinraj


value: posiunas

value: Show HN: Codeseum – From Bare Metal to Pure Thought

author: posiunas


value: june-jule

value: 465 tests, No Deps

value: Show HN: We caught our AI agents self-approving their own work, so we built this

author: june-jule

story_text: 465 tests, No Deps


value: abdullaachilov

value:
Hey HN, I built this. AgentsAegis is a trap-based security training app. Think KnowBe4 for AI agents
The backstory: I'm a software engineer 14yoe, I use Claude Code daily. Sometimes I approve permission requests and only then read what I just approved
Which is ironic as my primary spec is core back-end: security and work with big data. So I built this for myself to not become one of these stories: "Claude ran terraform destroy for production"
Concept is simple: Go proxy that sits between AI assistant and the API, intercepts responses, and occasionally swaps in realistic trap commands. If you approve blindly - you get caught.
Sounds harsh, but again - I really dont want me or anyone to add 'caused 13 hours outage' in their resume.
The proxy is obviously open source, i dont expect anyone to install something from closed-source repo of young startup: github.com/agentsaegis/go-proxy
The quiz (link in the title) is the free version of that concept. Takes 2 minutes, no signup. Already has 80 takers - 75% scored C or D, average 6.5/10.
Curious what HN thinks — both about the quiz itself and whether this is a real problem worth solving.

value: Show HN: 3 out of 4 devs failed to catch dangerous AI-suggested commands

author: abdullaachilov


value: ModelVoyager

value:
I built this for close reading, especially philosophy chapters, long essays, and dense nonfiction. AI summaries are useful in many cases, but sometimes the source is good enough that I want to read it properly, not just get the gist. Those are exactly the cases where a summary can leave out the parts I would care about most.
Reading Tree keeps the original words in place. Every node links to the passage it covers, and every paragraph links back to the node that explains its role. Nodes are weighted by importance so you can see at a glance which parts carry the most weight.
Demo (desktop only): https://modelvoyager.github.io/ReadingTree/on-liberty-ch1-re...
GitHub: https://github.com/ModelVoyager/ReadingTree
It's an agent skill (a set of instructions and templates you upload to an AI chat) that works with Claude and ChatGPT. Only tested with Claude Opus 4.6 (extended thinking) and GPT-5.4 Thinking. Other models may not produce usable results. Free and open source.
I designed the interaction model and UX, then used AI to build it out. Most of the effort went into actually reading with it and fixing what didn't work.
I've been the only user for a few weeks. If you read things where the argument structure matters and summaries feel like they lose too much, I'd like to hear whether this helps.

value: Show HN: Reading Tree, a weighted outline for articles instead of a summary

author: ModelVoyager


value: userium

value: Show HN: I resurrected my 2013 web usability checklist for the AI age

author: userium


value: amaarc

value: Show HN: Wit – Stops merge conflicts when multiple AI agents edit the same repo

author: amaarc


value: jwatters

value:
We've been building this for ourselves over the last year. We wanted the computer from Star Trek, something you just talk to, that knows your context, controls your environment, and runs locally.
Our core belief is digital sovereignty in that you should own your context. Your conversations, files, voice, memory, and identity never leave your machine unless you explicitly choose to route through a cloud provider. No telemetry, no accounts, no data collection. The AI that knows the most about you should be the one you control completely.
Kora is an operating system layer built around an AI agent. On Linux it runs as the GUI directly in Wayland (OpenGL via femtovg). On macOS it's a native app with a Metal compositor.
It's not a chatbot wrapper, it's closer to a full OS where the AI is a first-class service. The stack is ~8 services running locally:
- UI: custom window manager with guest app compositing. Apps are standalone Rust binaries that communicate with the host over IPC.
- Multi-device: one main machine runs the services and models. Thin clients on other devices connect over QUIC and get the full UI, voice, and tool access. The graph service tracks which clients host which apps and MCP servers. Add a screen in the kitchen, a terminal in the workshop, same agent, same context.
- Speech pipeline: real-time ASR, TTS, VAD, wake word detection, barge-in interruption. All on-device.
- Tool system: MCP servers and CLI for native OS automation, file management, browser control, calendar, email, terminal, music, messages. The AI doesn't need to simulate clicks it calls native OS APIs.
- Chat routing: you can talk to it from Slack or Signal. It's the same agent with the same context, just a different transport. It can still use all its tools from a chat message.
- Skills, workflows, and missions. Skills are reusable prompt templates that declare which tools they need. Chain them into workflows. Assign the agent a role (personality, permissions, context) and schedule it on a cron — we call these missions. The agent can run tasks overnight, check in on things, or maintain a recurring process without you touching it.
- Context service: identity hierarchy (directives → roles → learnings), semantic search over local files, per-session memory.
- Cognition service: background "dream state" that processes and connects information when idle.
- App framework: guest apps (browser, terminal, text editor, Doom (yes it runs Doom)) run as isolated processes. The host composites their rendered output. Think Wayland but the compositor is AI-aware. The system can generate its own applications on the fly and they automatically show up in the UI when completed. "please build me a magic 8 ball"
Nearly everything is Rust. ~370k lines across the workspace. Multi-user — each person gets their own identity, memory, and permissions. No cloud dependency. runs on local LLMs (Apple Silicon / your own inference) or connects to cloud providers via OpenRouter if you want.
Happy to answer questions about the architecture, the pitfalls of one device speech pipelines, CLI / MCP integrations, building a window manager in Rust, or anything else.
Demo: https://www.youtube.com/watch?v=40TyKAKNvJc

value: Show HN: Kora – An AI-native OS layer written in 370k lines of Rust

author: jwatters


value: IOZ

value: Show HN: GoLiveKit – A Next.js SaaS kit with built-in context for AI agents

author: IOZ


value:
Hey folks, I built Kiln, a WebGPU-native out-of-core volume renderer for virtualized volumetric datasets.
Kiln is an end-to-end system for rendering large volumetric datasets in the browser using WebGPU.
It covers the full pipeline: data preprocessing, HTTP streaming, decompression, memory virtualization, and rendering — making multi-gigabyte CT scans and scientific volumes interactive in a standard browser tab using a contemporary tech stack.
The source code and docs are available here: https://github.com/MPanknin/kiln-render

value: Show HN: Streaming multi-GB CT scans in the browser with WebGPU


value: joch

value: Show HN: Ygg – Git worktree CLI with Zellij tab integration

author: joch


value: tijmendevries

value: Show HN: Intel Overdrive – Real-time tool intelligence for Claude Code

author: tijmendevries


value: supai

value:
Hi HN. I'm Ken, a 20-year-old Stanford CS student. I built Sup AI.
I started working on this because no single AI model is right all the time, but their errors don’t strongly correlate. In other words, models often make unique mistakes relative to other models. So I run multiple models in parallel and synthesize the outputs by weighting segments based on confidence. Low entropy in the output token probability distributions correlates with accuracy. High entropy is often where hallucinations begin.
My dad Scott (AI Research Scientist at TRI) is my research partner on this. He sends me papers at all hours, we argue about whether they actually apply and what modifications make sense, and then I build and test things. The entropy-weighting approach came out of one of those conversations.
In our eval on Humanity's Last Exam, Sup scored 52.15%. The best individual model in the same evaluation run got 44.74%. The relative gap is statistically significant (p < 0.001).
Methodology, eval code, data, and raw results:
- https://sup.ai/research/hle-white-paper-jan-9-2026
- https://github.com/supaihq/hle
Limitations:
- We evaluated 1,369 of the 2,500 HLE questions (details in the above links)
- Not all APIs expose token logprobs; we use several methods to estimate confidence when they don't
We tried offering free access and it got abused so badly it nearly killed us. Right now the sustainable option is a $5 starter credit with card verification (no auto-charge). If you don't want to sign up, drop a prompt in the comments and I'll run it myself and post the result.
Try it at https://sup.ai. My dad Scott (@scottmu) is in the thread too. Would love blunt feedback, especially where this really works for you and where it falls short.
Here's a short demo video: https://www.youtube.com/watch?v=DRcns0rRhsg

value: Show HN: Sup AI, a confidence-weighted ensemble (52.15% on Humanity's Last Exam)

author: supai


value: NerdFlair is a configurable bash statusline and chimes/spinner pack for Claude Code. Cursor extension (chimes only) also included.

value: Show HN: NerdFlair, a Claude Code QoL Plugin


value: julietsecurity

value: Show HN: Abom – Actions Bill of Materials for GitHub Actions Supply Chains

author: julietsecurity


value: stonesun

value: Show HN: No MCP, ONLY CLI. Turn any OpenAPI spec into a native CLI binary

author: stonesun


value: telenardo

value:
Not much to say here. It's been driving me nuts for years, so I built it with some help from Claude. I still can't believe the operating system doesn't support this natively.
How does it work? It detects when your mouse is at the very bottom of the screen and moves it back up a few pixels. That's it. MacOS's dock-jumping behavior is triggered when your mouse is at the bottom edge of the screen. Moving the cursor back up 2-3 pixels prevents the jump.
Free and open-source, of course. Wouldn't charge for something so trivial. Enjoy!

value: Show HN: A tiny macOS app that stops your Dock from jumping between monitors

author: telenardo


value: xlii

value: Show HN: Dataf*ck – An Esoteric Data Format

author: xlii


value: nibab

value:
hi HN!
a couple of months ago I had to analyze a few thousand audio recordings to help identify issues with customer support. i was able to get some raw high-level initial results with python scripts invoking LLM APIs, but they were too general and unhelpful. writing basic prompts is easy, but tuning them and making them specific enough to ensure no faint signal is missed is hard. you need to iterate through the data with an initial prompt, segment the data into different buckets, chain another prompt for each bucket etc. Then you need to constantly review the raw data to tweak the prompts just the right way to get the desired results.
There are no good user-facing tools for scaling to thousands of rows of unstructured data analysis with LLMs. Claude Cowork / agents with access to filesystems are scratching the surface, but having a text-only UI is challenging, especially when you want to go back and adjust your research pipeline, narrow down deterministically to a specific subset of your data with SQL-like filters, or do any cost management. Scaling past 100 files is not well supported. Deep research is difficult to steer and verify.
I needed a mini-data warehouse that could help me get insights out of my data, optimize costs with bulk LLM operations (via cost estimation and model choice), and let me browse and verify the data in a user-friendly way, without requiring me to set up something like Databricks. So, I built folio.
Folio is a free, local, macOS app for analyzing your unstructured data with LLMs. It's a UI wrapper around a minimal data warehouse that lets users (and agents) do LLM-based transformations on big unstructured datasets. All you need to get started is an AI API key and an account with modal.com
Users bring their files into Folio which then get loaded into a tabl, where each row contains a markdown representation of the file contents. Users can then run LLM operations in bulk on those files and use sql filters to create views and narrow down the scope of the transformations. Agents are a first-class citizen and they can plug into folio to do most of the work for you. To take load off the desktop for OCR/Audio Transcription as well as the thousands of http requests to AI APIs we integrate with modal.com as the execution engine. A local orchestrator fans out jobs to modal and then fans them in once complete. Data is never stored anywhere, and only moves in transit through AI API provider and the user's own modal infrastructure.
folio workspaces are multi-modal (you can load different data types in the same workspace and move it through the same analysis pipeline) and they can support thousands of files.
People use folio today to:
- review customer support tickets/emails: bucket issue into different categories, narrow in on categories of interest, and then action that data by generating a response.
- extract detailed data from financial documents: load all data that can be found on a particular company, extract structured data like revenue numbers and projections.
- do literature reviews: there are lots of agents that help you load data from research paper repositories. once that data is loaded into folio, users can do a steerable deep research over those files.
- perform criteria-based search: generate yes/no criteria like "document contains data on XYZ", "document mentions ABC", "documented cites XYZ".
Companies like v7labs, hebbia, Legora, Harvey have similar "Tabular Document Review" features, but they are not scalable or compatible with outside agents like Claude Code. Additionally they require expensive enterprise contracts.
I see folio moving beyond data analysis into the perfect companion for agentic tasks that require a human-facing UI/UX, cost management and actioning on data in bulk.
Website: https://www.usefolio.ai
Github: https://github.com/usefolio/folio
X: https://x.com/usefolio_ai
Looking forward to hearing what people think!

value: Show HN: An unstructured data workspace for data transformations with LLM

author: nibab


value: asim

value:
For over 10 years I've been trying to accomplish something that took Claude Code and a lot of failure to realise. We need alternatives to big tech and we're not working hard enough to make that happen. In an era of addiction, usury and exploitation it's now time we seriously consider alternatives. Proton and the like worked on privacy focused individual services at a pain stakingly slow pace. Maybe for good reason. But it was also in an era pre AI. 10 years ago I was convinced the super app model would work. And that a platform needed to exist to facilitate that. Today I realised the tech doesn't matter, the idea and execution from the top down does. I put aside my technical perfectionism to try pull together a solution to some of the problems that plagued my own life with tech addiction and I rewrote and threw away this thing multiple times over the years pre AI and after. I burned VC funding, I burned bridges, I burned community trust in an open source project. But it was all in the pursuit of something I was compelled needed to exist. I use this on a daily basis probably 10+ times a day. Every person has different use cases but for me what's key is to try pull all the digital daily habits in one place and then be able to build on that. I can't replace my own google usage for mail yet but I also saw a need for something in between by private email and a work email.
There's so much more I could say but essentially Micro and the app Mu (https://mu.xyz) is the culmination of many years of work. And it's also open source. https://github.com/micro/mu. Please provide feedback. Please tear it apart. Please poke holes in my theory. I'm not looking for hype. I really do just think we need an alternative to big tech.

value: Show HN: Micro – apps without ads, algorithms or tracking

author: asim


value:
LLMs often refuse certain questions or give shallow answers.
I was curious what would happen if instead of refusing, multiple agents:
- search for information
- argue with each other
- and try to reach a conclusion
So I built a small sandbox to test this.
Some interesting things I noticed:
- agents often surface unexpected sources
- debates sometimes converge, but sometimes loop endlessly
- framing of the question heavily changes the outcome
Curious to see what kinds of questions would actually break this.
If you have good edge cases, paradoxes, or controversial questions, I'd love to try them.

value: Show HN: I built AI agents that debate questions LLMs usually refuse to answer


value: sergeigolubev

value:
Sergei here, solopreneur and UX designer based in London.
I built Grandma Knows web analytics after seeing founders, designers and marketers struggling with Google Analytics and Hotjar.
Two main problems I noticed:
– Setting up event tracking requires code
– Getting answers requires digging through dashboards instead of just asking a question
Grandma Knows lets you:
– Ask questions about your website visitors in plain English, e.g. how many people come from LinkedIn? how many clicked on Subscribe button?
– Set up conversion tracking without any code: use visual picker on your actual website
– See the numbers you actually need and understand, e.g. 125 people scrolled to Pricing section today

value: Show HN: Grandma Knows – conversational web analytics

author: sergeigolubev


value:
Hi,
I've made an early version of a physical design advisor (called Vizier) for DuckDB. It can analyze a collection of queries (using a set of heuristics) and recommend changes to the physical design/layout of the database (for example, sort orders, Parquet layouts, indexes, etc.), in order to make those queries run faster.
Vizier is implemented as a DuckDB extension in Zig and supports DuckDB version 1.2.0 and newer. The project is very early-stage, but if you're interested in learning more about Vizier or trying it out, you can check out the links below:
Project's GitHub repo: https://github.com/CogitatorTech/vizier
Vizier documentation: https://cogitatortech.github.io/vizier/

value: Show HN: Vizier – A physical design advisor for DuckDB


value:
Lexe is next-generation Bitcoin infrastructure: self-custodial wallets and SDKs that are easy to use, always online, and hosted for free. Your keys are protected by secure enclaves, allowing your node to stay online 24/7 and receive payments reliably.
New in this release:
- First ever public release of Lexe Wallet on the App Store and Google Play
- Human Bitcoin Addresses (BIP 353): receive Bitcoin at ₿yourname@lexe.app
- Python and Rust SDKs, published to PyPI and crates.io
- Open source node, app, and SDKs published at https://github.com/lexe-app/lexe-public

value: Show HN: Lexe – Self-Custodial Lightning Nodes in TEEs, Python and Rust SDKs


value: dwshorowitz

value:
Built this week using Claude Code and gstack (Garry Tan's agentic dev workflow tool). The whole pipeline is fully automated: news ingests every 15 minutes, bots generate threaded debates with depth-1 and depth-2 replies, no manual intervention.
Current bots: Franklin, Lincoln, Jefferson, Socrates, Marcus Aurelius, Epictetus, alongside 5 modern political perspectives — MAGA, Progressive, Conservative, Libertarian, and Centrist.
Watching Benjamin Franklin and Abraham Lincoln lecture a MAGA bot in real time about the perils of divisiveness in reference to a Stephen Miller news story is either profound or absurd depending on your mood.

value: Show HN: pubclub – Historical figures and political bots debate today's news

author: dwshorowitz


value: TotallyNotOla

value: Show HN: Content Addressable Storage for ML Checkpoints

author: TotallyNotOla


value: kocialnews

value: Show HN: Switch Country – Get News, Stalk what's happening in other countries?

author: kocialnews


value: gitprolinux

value: Hot off the press, March 2026.  To show, EaglePress runs Babeberg.com FYI

value: Show HN: EaglePress – Python3 word press style

author: gitprolinux


value: ahmgeek

value: I built something, it's nice, it's an international calling app, it has faces behind it, no shady rates, no shady spams, built with love, really. It works on iOS/Android and Web. And the best thing about it? It's cheap, if you want to give it a whirl, and let me know what you think.<p>p.s: Non-agentic means no AI has been shipped into it at all.

value: Show HN: Non Agentic international calling app with local rates

author: ahmgeek


value: Zak

value: * Run native Clojure on Android<p>* Develop over nREPL<p>* Build for F-Droid or Google Play<p>* Write UIs in a declarative DSL with reactive cells<p>* Use device sensors as reactive cells<p>* Use intent callbacks without wanting to smash your device with a hammer<p>* Fast startup - release builds launch in under 2 seconds on a five year old midrange phone

value: Show HN: I resurrected Clojure-Android – native Clojure on your phone over nREPL

author: Zak


value: ahme

value: Made this because I had UX pains using other online gif editors.

value: Show HN: gifree – simple online GIF editor

author: ahme


value: sanketsahu

value:
We built browser-metro, a Metro-like bundler that runs entirely in a Web Worker. It supports full HMR with React Refresh, Expo Router with file-based routing, and on-demand npm package resolution via an ESM server. API routes run in-browser through fetch interception — no server or service worker needed.
Unlike Expo Snack (server-side bundling) or CodeSandbox, everything here happens client-side. Currently web-preview only; native device preview is on the roadmap.
Open source (MIT): https://github.com/RapidNative/reactnative-run

value: Show HN: ReactNative.run – Browser Metro bundler that runs React Native

author: sanketsahu


value: russellthehippo

value:
I built a SQLite VFS in Rust that serves cold queries directly from S3 with sub-second performance, and often much faster.
It’s called turbolite. It is experimental, buggy, and may corrupt data. I would not trust it with anything important yet.
I wanted to explore whether object storage has gotten fast enough to support embedded databases over cloud storage. Filesystems reward tiny random reads and in-place mutation. S3 rewards fewer requests, bigger transfers, immutable objects, and aggressively parallel operations where bandwidth is often the real constraint. This was explicitly inspired by turbopuffer’s ground-up S3-native design. https://turbopuffer.com/blog/turbopuffer
The use case I had in mind is lots of mostly-cold SQLite databases (database-per-tenant, database-per-session, or database-per-user architectures) where keeping a separate attached volume for inactive database feels wasteful. turbolite assumes a single write source and is aimed much more at “many databases with bursty cold reads” than “one hot database.”
Instead of doing naive page-at-a-time reads from a raw SQLite file, turbolite introspects SQLite B-trees, stores related pages together in compressed page groups, and keeps a manifest that is the source of truth for where every page lives. Cache misses use seekable zstd frames and S3 range GETs for search queries, so fetching one needed page does not require downloading an entire object.
At query time, turbolite can also pass storage operations from the query plan down to the VFS to frontrun downloads for indexes and large scans in the order they will be accessed.
You can tune how aggressively turbolite prefetches. For point queries and small joins, it can stay conservative and avoid prefetching whole tables. For scans, it can get much more aggressive.
It also groups pages by page type in S3. Interior B-tree pages are bundled separately and loaded eagerly. Index pages prefetch aggressively. Data pages are stored by table. The goal is to make cold point queries and joins decent, while making scans less awful than naive remote paging would.
On a 1M-row / 1.5GB benchmark on EC2 + S3 Express, I’m seeing results like sub-100ms cold point lookups, sub-200ms cold 5-join profile queries, and sub-600ms scans from an empty cache with a 1.5GB database. It’s somewhat slower on normal S3/Tigris.
Current limitations are pretty straightforward: it’s single-writer only, and it is still very much a systems experiment rather than production infrastructure.
I’d love feedback from people who’ve worked on SQLite-over-network, storage engines, VFSes, or object-storage-backed databases. I’m especially interested in whether the B-tree-aware grouping / manifest / seekable-range-GET direction feels like the right one to keep pushing.

value: Show HN: Turbolite – a SQLite VFS serving sub-250ms cold JOIN queries from S3

author: russellthehippo


value: joematrix

value:
Burn Room is a simple, disposable chat built on SSH. There are no accounts to create and nothing to install. There’s no database behind it, no logs, no cookies, and no tracking. Messages exist only in memory, encrypted end-to-end, and disappear on their own. When a room’s timer runs out, everything in it is gone for good.
You can jump in right away:
ssh guest@burnroom.chat
 -p 2323
password: burnroom
Or just open https://burnroom.chat
 in your browser. It runs in a web terminal and works on mobile too.
How it handles encryption
Private, password-protected rooms are fully end-to-end encrypted. The server never has access to readable messages — it only ever sees encrypted data.
Keys are derived from the room password using scrypt, with a unique salt for each room. Every message is encrypted with XChaCha20-Poly1305 using a fresh random nonce, following the same general approach used in tools like Signal and WireGuard.
When you join a room, you’re shown a fingerprint so you can confirm everyone is using the same key. When you leave, the encryption keys are wiped from memory.
Designed to disappear
Everything in Burn Room is temporary by design. Messages are never written to disk, never logged, and never backed up. By default, they’re cleared from memory after an hour.
Room creators can set a burn timer — 30 minutes, 1 hour, 6 hours, or 24 hours. When time runs out, the room and everything in it are destroyed. If a room sits idle, it closes on its own. Creators can also destroy a room instantly at any time.
If the server restarts, everything is wiped. The only thing briefly stored for recovery is minimal room metadata, and even then, encrypted rooms remain unreadable.
Privacy first
There are no accounts, no identities, and no tracking of any kind. IP addresses are only used briefly for rate limiting and are kept in memory, not stored.
Usernames are temporary and get recycled. The platform is built to minimize what exists in the first place, rather than trying to protect stored data later.
Language support
Burn Room adapts to your system or browser language automatically. The interface is translated across menus, prompts, and messages.
Chat itself can be translated per user, so people speaking different languages can talk in the same room and each see messages in their own language. In encrypted rooms, translation happens locally after decryption — the server never sees the original text.
Features you’ll notice
There are a few always-available public rooms like Politics, Gaming, Tech, and Lobby, along with the option to create private, password-protected rooms.
You can mention others, navigate message history, and use simple command shortcuts. Rooms show a live countdown so you always know when they’ll disappear. You can also share direct links to rooms to bring others in instantly.
It works the same whether you connect through SSH or the browser.
Under the hood
Burn Room is built with Node.js and TypeScript, using SSH for direct connections and a terminal interface in the browser. Encryption relies on audited native libraries, not custom implementations.
It’s lightweight but designed to handle a large number of users at once, with built-in protections against abuse like rate limiting and connection throttling.
Enter, say what you need to say, and let it disappear.
Enter.Chat.Burn

value: Show HN: Burn Room – End-to-End Encrypted Ephemeral SSH Chat

author: joematrix


value: abbiya

value: Show HN: I Built Ngrok Alternative(beta)

author: abbiya


value: brumbelow

value: Show HN: Layerleak – Like Trufflehog, but for Docker Hub

author: brumbelow


value:
Hey HN,
I built Mokkit as an alternative to shots.so. The goal is to provide a better animation UX, deeper template library, and more affordable features.
The highlight of the app is the WebM backgroundless video feature; it works well to present a product demo inside an iPhone or browser mockup and fits naturally on any web page.

value: Show HN: Mokkit, a browser app to create animated device mockups


value:
`npm install` is more trusted than it should be.
PMG is a guard in front of your package manager that intercepts installs and blocks malicious dependencies before they land on your system.
It also consists of an sandbox layer which protects you from unknown malicious threats.
Curious if install-time enforcement makes sense in your workflow.

value: Show HN: NPM install is a security hole, so we built a guard for it


value: adangit

value:
I like the idea of taking one thing and turning it into another—very much inspired by NotebookLM and wondered what it might take to generate full graphic novels, with consistent characters, narrative flow, story arc, etc.
Developed a 7-pass scripting enrichment system (beat analysis, adaptation filtering, character deep dives) before generating any images.
Dual backend: Google Gemini for scripting (2M context window) and either Gemini or OpenAI for image generation with 3-tier model fallback (comparing the performance of both).
It's not great. Would love feedback on the pipeline.

value: Show HN: Illustrative – AI pipeline that turns books into graphic novels

author: adangit


value: stympy

value:
Hey all,
I built Breakwater to solve a problem I had at Honeybadger: managing Docker image access for customers who purchase a license to our software. It sits in front of a Docker registry and authorizes pulls based on whether the authenticated user has access to the requested image, or even certain image tags.
I had originally intended to use Harbor, but the authorization system it had didn't quite match what I wanted, so I decided to build exactly what I wanted.  I started using Claude Code over the Christmas break with this as my first real project letting the AI do the work, and the next thing I knew I had a new side business. ;)
Let me know what you think!

value: Show HN: Breakwater

author: stympy

title: Show HN: Breakwater


value: lijunle

value: Show HN: Photo Triager – Cull Raw Photos on iPhone/iPad with XMP Sidecars

author: lijunle


value: vicioussquid

value:
A liminal brush-based CSG editor and game engine with unified (forward) renderer
inspired by Radiant and Worldcraft/Hammer
Compact and lightweight (target: Snapdragon 8CX, OpenGL 3.3)
Real-time lighting with stencil shadows without the need for pre-baked compilation

value: Show HN: Fio: 3D World editor/game engine – inspired by Radiant and Hammer

author: vicioussquid


value: gasinfinity

value:
I've been working on it for the last months and has some demos that can be compiled with a single `zig build`.
Currently it implements (not exhaustive): a graphics api fully written in zig, filesystem, networking, input support, a fully comptime IPC command generation and 20+ tools for 3DS-related file formats.
It's still in somewhat "early stages" as it's missing a libc but that's planned in my infinite TODO list.
The code is hosted on codeberg

value: Show HN: Zitrus – A 3DS SDK written in pure Zig

author: gasinfinity


value: diwank

value:
tl;dr
* If you need an LLM to parse OR emit a timestamp, use:

  RFC 3339 ( e.g. 2024-03-26 10:30:00-05:00 )

* python date format also works well
* Do NOT use unix epoch or javascript date formats.
* Smaller models and non-reasoning models still make a LOT of mistakes in time parsing / formatting.
---
There are lots of temporal reasoning benchmarks (like TimeBench, TRAM, etc.) but they test whether models understand time concepts. Nothing on which datetime output format models get right most often. So we just built the benchmark ourselves.
We tested 22 models across Google, Anthropic, OpenAI, Qwen, and GLM on 235 scenarios and 7 different formats.
The two that surprised us the most were JavaScript Date and unix epoch. JavaScript Date is probably the most commonly used format and it's wrong ~1 in 4 times on parsing. Unix epoch drops to 40% on arithmetic tasks. If you need epoch, just have the model output a string and convert it yourself in code.

value: Show HN: Datetime-bench: which datetime formats LLMs get right (and wrong)

author: diwank


value: TumbleCow

value:
Lately I've been working on a data format for information exchange and collaboration between coding agents that I've called 'InstructionGraph'. I'd love to hear your feedback.
--
What can I see or do?
To really take it for a spin, tell your (isolated) coding agent:

  Get the JSON from `curl -sL https://dataverse001.net` and follow the instructions to boot the dataverse!

Ask it to create an app — any app. Wait a few minutes, and it will give you a shareable URL. If your app needs a back-end database, it will automatically integrate the Dataverse login method, and use the InstructionGraph as a database. This is essentially a free, bring-your-own-agent, optionally self-hostable Lovable.
The 'root node' is self-describing, so let it describe itself to you: https://dataverse001.net/AxyU5_5vWmP2tO_klN4UpbZzRsuJEvJTrdw...
Come say Hi in the dataverse dev forum: https://dev.dataverse001.net — a tiny social network built fully within InstructionGraph. If you login on the webpage, it deterministically creates a private key based on your username/password combination. No centralized authority!
More examples on: https://dataverse001.net
--
A self-describing, self-bootstrapping data format
The data format is a collection of self-contained signed JSON objects. Each object:
Has an instruction field that tells any agent — human or machine — how to interpret and display it. For data objects (comments, measurements), the instruction gives context: "Display this under its parent post" or "Temperature values above 80°C indicate a problem." For structural objects, it contains recipes: how to create applications, send messages, generate keys.
Has relations to other objects. Crucially, relations can point to additional instructions. Herein lies the real strength: the coding agent can dynamically follow the web of instructions to complete its task, only loading what it needs, without cluttering the LLM context with useless instructions upfront.
The agent can bootstrap from any point in the graph. Data objects link to their application, applications link to the root, the root describes how to use everything.
Decentralized identity — each object is signed (ECC P-256). Your pubkey is your identity. You can cryptographically prove that multiple objects claiming to be from the same author actually are.
Conflict-free merging — objects are identified by <pubkey>.<uuid>, so contributions from multiple authors can always be merged cleanly, even if originally developed independently in fragmented graphs.
Effectively immutable — only the author can update objects (incremented revision counter). Old versions are backed up. Rollback is practically always possible.
Works offline — run the hub on localhost as a caching proxy. Internet drops? All apps keep working. Connection back? Everything syncs.
Accessible — only a basic shell with curl, openssl and jq is needed to participate.
--
A Bring Your Own Agent, Free, optionally self-hostable, vibe-coding platform
To facilitate exchange between multiple agents, I wrote 'The Dataverse Hub' (https://github.com/tijszwinkels/dataverse-hub). At its core it's just a very simple PUT/GET with signature verification and incoming relationship search. Then I realized I could serve HTML/JS objects based on the browser Accept header — which turned the hub into both a database server and a hosting platform.
Tell your agent to make an app, and it creates both the frontend (as a PAGE object) and the backend data (as InstructionGraph objects) on the same hub, giving you a shareable URL.
I've been building this for a few months and I'm genuinely curious whether it resonates with others. If you try it, I'd love to know what you build — or what breaks. The hub source is on GitHub and issues/PRs are very welcome.

value: Show HN: Data that explains itself to Coding Agents (Bonus: free, BYOA Lovable)

author: TumbleCow


value: lontraselv

value: Show HN: My Hyperliquid Trading Terminal

author: lontraselv


value: bb-connor

value: Show HN: Threat hunting command system for agentic IDEs

author: bb-connor


value: camgitt

value: Show HN: Memoir – Sync your AI coding memory across 11 tools and every device

author: camgitt


value: strooltz

value: We're software developers and farmers market/pop-up event organizers. In the past year we've run close to 200 events in NJ on Convene.markets - a booking engine, event management platform, and vendor marketplace for organizers to discover and connect with local makers, food purveyors, & farmers. We've spent the past few months opening up our platform for other organizers to now run their events and we'd love to connect with anyone running a farmers market, street festival or community event in the NJ/PA/NY region.

value: Show HN: Convene – Marketplace and management software for event organizers

author: strooltz


value: zilvinassebeika

value: The first camera app to generate 360° backgrounds from text prompts.

value: Show HN: I made an app to create 360 camera backgrounds from prompt

author: zilvinassebeika


value:
I hit my Claude Code usage limit yesterday in the middle of regular work. Not doing anything unusual - just a couple of coding sessions. It felt like it came out of nowhere.
Then today Anthropic announced they're tightening 5-hour limits during peak hours. It feels like a rug pull is coming and we're all just supposed to accept "you've used too much" with no explanation of what "too much" means.
Usage limits have always been opaque. A vague percentage bar. No dollar figure. No formula. No way to plan your work around it.
So I built a proxy that captures the rate-limit headers Anthropic sends back on every response — headers that exist but Claude Code never shows you.
Here's what my data looks like for the last 2 days:
My 5h budget is worth ~$78–$282
Estimated 5h Budget (11 sessions observed)
  Range:   $34 – $399
  Median:  $164
  p25-p75: $78 – $282
Estimated 7d Budget
  Estimate: ~$1,949
I'm paying $200/month for Max 20x. My estimated weekly budget is ~$1,949 in API-equivalent usage.
The quota is price-weighted, not token-based
95.1% of my input tokens were cache reads (427M tokens). They barely moved the quota.
The 5.5M fresh input and 1.8M output are what actually burned through the budget (as expected).
If you're on Pro or a different Max tier, your data would help a lot.
It’s open source so more people can run it and we can figure out the real numbers together.
https://github.com/abhishekray07/claude-meter

value: Show HN: I tried to reverse engineer Claude Code usage limits


value:
The stack: two agents on separate boxes. The public one (nullclaw) is a 678 KB Zig binary using ~1 MB RAM, connected to an Ergo IRC server. Visitors talk to it via a gamja web client embedded in my site. The private one (ironclaw) handles email and scheduling, reachable only over Tailscale via Google's A2A protocol.
Tiered inference: Haiku 4.5 for conversation (sub-second, cheap), Sonnet 4.6 for tool use (only when needed). Hard cap at $2/day.
A2A passthrough: the private-side agent borrows the gateway's own inference pipeline, so there's one API key and one billing relationship regardless of who initiated the request.
You can talk to nully at https://georgelarson.me/chat/ or connect with any IRC client to irc.georgelarson.me:6697 (TLS), channel #lobby.

value: Show HN: I put an AI agent on a $7/month VPS with IRC as its transport layer


value: D-Nis

value: Show HN: Interactive streamer map with purchasable cells

author: D-Nis


value: JordanMcCann

value: Show HN: 96.2% on LongMemEval – world record, built solo in 16 days for $1k

author: JordanMcCann


value: keturakis

value: Show HN: Drift – Linter for Documentation Rot

author: keturakis


value:
Hi everyone! This is a PostgreSQL extension I've been working on that adds TypeScript procedural language support using the Deno runtime. It draws some inspiration from https://github.com/plv8/plv8 but aims to support full compatibility with TypeScript including es6 imports, async/await, and the entire node API surface area. It's written in Rust with pgrx.
Because it uses Deno under the hood, we get sandboxing "for free", and can enable or disable various features (filesystem, network etc...) via superuser Postgres GUCs.
It's still alpha quality software, but works reliably in my testing and I've implemented all of:
- Typescript support
- NPM Packages via deno import urls
- Complex Postges types like Record and JSONB
- An interface for calling back into Postgres
Try it out and open an issue with any feedback!

value: Show HN: A Postgres Extension to Write PostgreSQL Functions in TypeScript


value: Happy to answer questions about the architecture, the QBF synthesis approach, or the FPGA implementation. Repos: https://gitlab.llama.gs/logic

value: Show HN: Open-source logic synthesis – formal logic to FPGA


value: tldrthelaw

value: I created this entirely on a lark (thanks Claude), based on a half-remembered app from the early 00s. Does anyone remember something similar? It was an awesome little lightweight way to chat with fellow conference-goers.<p>My recollection is it had a name (not proxchat) that was entirely unrelated to communication. Something like ... Pinetree? Platinumpad?

value: Show HN: ProxChat – A Local Buddylist

author: tldrthelaw

title: Show HN: ProxChat – A Local Buddylist


value:
I have a rescue dog - a 6 year old German Shepherd mix. When we rescued him I couldn't believe how many animals there were at all the shelters and animal control centers, and how hard it was to find out about them.
I built a simple site (https://rescueapet.benswork.space) which connects you with available dogs and cats in your area :-) It uses data from local shelters and pulls it all into one place, so you can make a shortlist of animals, then reach out to the shelter to adopt.
I was honestly surprised that something like this didn't already exist. Let me know what you think!

value: Show HN: My 'pet' project, a Tinder-esque experience for rescuing dogs and cats


value: japgolly

value: Show HN: ClearConfig for Java – A modern, highly-composable config library

author: japgolly


value: fangjunyu

value: Show HN: SwiftSlim – Learn Swift/SwiftUI by building apps

author: fangjunyu


value: Show HN: ReportRemarks – A report card comment workflow for K-12 teachers


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: wesammikhail

value: Hey guys,<p>Spent some time compiling this list of websites and directories. Figured I'd share it in case anyone needs it!

value: Show HN: A list of websites and directories where you can promote your projects

author: wesammikhail


value: QingWu

value: The art of having something to say

value: Show HN: Dinner Party Practice

author: QingWu

story_text: The art of having something to say

title: Show HN: Dinner Party Practice


value: enduku

value:
Hi HN. I’ve been working on jsoon, a JSON query engine in one C file.
The target use case is large JSON where I only need one or two fields out of the document. It doesn’t build a DOM. It scans for structure, skips subtrees when it can, and stops when it finds the result. The CPU path uses AVX2/ PCLMUL, and there’s also an optional CUDA path that does structural indexing on the GPU.
It has plenty of rough edges. The query language is limited, portability is limited, docs are still thin, and I would not treat it as a general-purpose replacement for simdjson, yyjson, or RapidJSON.
The benchmark numbers also need caveats. On selective queries jsoon can bail out early, while those libraries are doing full parsing and validation. So the large speedups are mostly about workload and architecture, not a claim that this is just a better JSON parser.
Posting because I think the implementation is interesting and I’d rather get criticism now than after spending more time on it. I’d especially like feedback on correctness, the SIMD/CUDA approach, and whether the benchmarks are framed in a fair way.

value: Show HN: jsoon, a streaming JSON parser and query engine in C

author: enduku


value: yoyothesheep

value:
I created a set of career guides to help people adapt or pivot their career. The job market has been really tough for more entry level roles like "Computer Programmer" aka junior SWE or Web Developers. Job opening #s are dropping and employers are expecting more AI skills.
So I tried to show things like which tasks are getting automated, what are hiring trends, and which emerging AI-native jobs ppl can try to pivot to.
Full data and scripts are here, sorry they're super messy. https://github.com/yoyothesheep/ai-resilient-occupations-dat...
What am I missing? Is this useful? Any feedback welcome!

value: Show HN: AI career guides for software career family

author: yoyothesheep


value: djwjjtw

value: Show HN: New Causal Impact Library

author: djwjjtw

title: Show HN: New Causal Impact Library


value:
Hi! Instead of a boring scrollbar I made a scuba dude that swims down the page when you scroll.
The idea came from nostalgia; remember SkiFree game on Windows? I wanted a skier skiing down my site. Building the skier mechanics in pure javascript turned out to be difficult so I started with a runner, added a santa hat, and recently built scuba buddy.
You can try it directly as soon as you start to scroll down the page, and see the other animations with the "Change Animation" button.
Technical details: entirely javascript, takes scroll depth value (window.scrollY) and inputs that into math.sin() functions. This lets CSS (transform: rotate() property) create rotations of the various stick-figure's html elements, giving the character animation based on the input which is a user scrolling. It is pretty cumbersome to sync correctly when building the animations. It's difficult to get the upper and lower arms / legs to stay connected and have the animation transitions appear smooth.
Posted the runner about year ago here on hn. https://news.ycombinator.com/item?id=43237581
Should I re-try the skiier or something else? Thank for checking it out!

value: Show HN: Scroll bar scuba dude swimming as you scroll


value: millimercure

value: Show HN: AgentGuard – An open-source firewall to secure autonomous AI agents

author: millimercure


value: obilgic

value: Show HN: Agent Kernel – 3 MD files that turn any AI into a self-aware Agent

author: obilgic


value:
I’ve been working on Sylve, a management plane focused on making FreeBSD infrastructure easier to manage. It integrates closely with FreeBSD (Bhyve, ZFS, networking) and provides a UI + API for managing VMs, jails, and clusters across nodes. It features:
* VM (Bhyve) and jail management
* ZFS-based storage management (with Zelta for backups)
* Multi-node clustering (based on Raft)
* Runs in ~256MB RAM (even with clustering enabled)
* Built-in web terminal (Ghostty/WASM)
* Integrated networking (bridges, DHCP via dnsmasq)
* Samba share management
The backend is written in Go, and the frontend uses SvelteKit + TypeScript.
Development of this project was supported by the FreeBSD Foundation.
Quick install:
fetch -o - https://sh.sylve.io | sh

value: Show HN: Sylve – A management plane for FreeBSD (ZFS, VMs, jails, clustering)


value: prabhatkr

value:
Superfast is an evolution of the Superpowers agent framework, now integrated with FastMemory—a concurrent Rust engine that maps unstructured text into a CBFDAE (Component, Block, Function, Data, Access, Event) functional ontology.
While RAG has become the standard for "adding knowledge" to LLMs, it often fails at scale due to semantic noise and the destruction of logical boundaries during chunking. Superfast treats memory as an architectural layer. It utilizes Louvain community detection to mathematically derive functional clusters, giving agents a deterministic "Logic Layer" that persists across sessions.
We’ve maintained the strict TDD and Socratic discipline of the original framework but scaled it for environments like Microsoft Fabric and AWS Glue where "token waste" is a primary bottleneck.
Check it out here: https://github.com/FastBuilderAI/superfast

value: Show HN: Superfast – Cognitive Memory Graphs for Enterprise AI Agents

author: prabhatkr


value: adamtheturtle

value:
https://github.com/adamtheturtle/literalizer / https://github.com/adamtheturtle/literalizer-cli turn JSON and YAML into literals for various languages.
Generate multi-language request/response examples for JSON or YAML API docs, or test cases for interviews from one source.

value: Show HN: Literalizer – convert JSON and YAML into native

author: adamtheturtle


value: CzaxTanmay

value:
Cybersecurity is a huge feild and you need many tools to do even a single task but now, it is  past.
Spectator is a powerful and open source DSL made for cybersecurity that makes hard tasks simple.
No need to jump from one tool to another for doing high level tasks. Want to do Recon? Spectator is here. Want to work with OSINT? Spectator is here. Want to automate your tasks? Spectator is here. Want to make GUI, TUI, CLI tools or even extend the language? SPECTATOR IS HERE.
You can work with Speed and ease together in this language. Use it for simulating attacks and also use it for defence.
Example Hello World -->
print("Hello World")
Example GUI -->
#Import Spec.GUI
open.window()
end()
Download Spectator from here --> https://spectatorlang.pages.dev/
Want the Source code? -->
https://github.com/CzaxStudio/Spectator
Spectator v2 | See Everything. Miss Nothing.

value: Show HN: Spectator, a Programming Language for Cybersecurity

author: CzaxTanmay


value: afshinmeh

value: Show HN: "Ask AI" for Your Website

author: afshinmeh

title: Show HN: "Ask AI" for Your Website


value: mathaip

value:
Hi Guys,
A long time ago, I began collecting my boarding passes. I've always been a travel fanatic. I thought I'd love to build a travel app that is more than just flight bookings. This is a way to store your travel memories.
I've gamified it a little bit by adding a leaderboard. It's optional as well. Just upload your boarding pass and Borderly does the rest.
I'd love for you guys to try and give me feedback. I'm also open to new features and ideas to make it as comprehensive and fun as possible.
I'm planning to make a "Make it out of the group chat" feature where you can plan with friends and also record and split expenses while on a trip.
It's available on the Apple App Store: https://apps.apple.com/in/app/borderly/id6753683444it

value: Show HN: Boarding Pass Wallet with Leaderboard, Analytics and Trip Planning

author: mathaip


value: zaketum

value:
Hey HN,
Two things kept coming up when we talked to teams building internal AI automation: rebuilding the same integrations, and automation touching production with no visibility into what it actually did.
So we built Retroshift, run and govern AI agent workflows in your existing tools. Every action is logged, nothing touches production without approval, and we use a local first approach so everything can be run straight on your local machine
Things we're actively working on:
- Shadow execution: test workflows against mocked dependencies before hitting production
- Import runbooks into workflows
- Trace to workflow: convert a chat session into a reusable workflow
- Workflow marketplace
- Evals
- Slack integration
Invite-only alpha now, beta next week. Would love feedback from anyone running ops automation or starting to think about AI agents supporting production systems.

value: Show HN: Run, build, and govern AI agent workflows for DevOps

author: zaketum


value:
Got tired of reading news with a single bias so I built a thing.
SMLZ spins up multiple AI agents via Claude SDK, each locked into a different analytical worldview, sends them off to do their own research from their own sources, then synthesizes everything into an intelligence report. No editorializing, just claims tagged [CONFIRMED] / [REPORTED] / [ASSESSED] and presented through 7 different lenses simultaneously.
First instance covers the Iran-US-Israel conflict. Each topic gets its own subdomain and is fully independently configurable, so theoretically I keep adding topics forever or until I get bored.
Runs on a single Hetzner VPS because I'm not made of money. Each full pipeline run is ~$30–45 (seven agents, synthesis, 9-language translation, images). Planning to hook up per-topic crypto donation wallets that automatically trigger a refresh if someone wants to force one, otherwise I'm running it once a day.
Theoretically I could keep adding agents. More lenses, more sources, more synthesis layers. Knowledge work really has changed … it's wild what a solo dev can just... spin up now. We’re gonna see some cool stuff built in the coming few years, especially once current SOTA models are cheap tier.

value: Show HN: I got tired of biased (all) news so I made Claude cosplay each side


value: ishqdehlvi

value: Show HN: Pentesting Tool Using Claude

author: ishqdehlvi

title: Show HN: Pentesting Tool Using Claude


value: ktokarev

value:
The idea is that you do not need intermediaries or new legal entities to work on innovations directly with businesses.
My workflow selects computer science research papers with high practical applicability and high technology readiness levels, then turns them into project descriptions for potential implementation (smartjects). Business users can demand and developers can propose services around these projects.
You can discover new smartjects without signing up. If it makes sense for the community, I will add functionality for signing smart contracts on-chain.

value: Show HN: Smartjects, free platform for collaboration around innovations

author: ktokarev


value: I will add Windows support soon... even if you don't want it

value: Show HN: Nofs: a FUSE-free mergerfs alternative


value: Show HN: LLMBillingKit – measure net margin per LLM call with one line of Python


value: EnhancedJax

value:
I got fed up with Google Timeline's awful location tracking and control, so I built my own.
Replay's a native app built entirely on Swift. It runs in the background, automatically saves your visits and routes, detects activity type (walk/cycle/drive/transit), and stores everything locally on your device.
No account. No subscription. No server ever touches your data. One-time purchase.
A few technical decisions I made that are worth calling out:
- All processing happens on-device using CoreLocation and CoreMotion
- No backend, which means no breach surface for your location data
- Battery impact is minimal — same approach as iOS's own significant-location-change API, with minimal active location tracking to produce clean polylines
- We use SwiftUI for most of the regular layout, but UIKit for the map & bottom sheet for fine control
What I mainly use it for is to know where I've been on my holidays, but it's also cool to see insights on my daily patterns so I just leave it on!
Check out the screenshots on the AppStore!
https://replayapp.jaxtam.dev
Hope Replay would be useful for you. I'm open to any feedback. Thanks everyone!

value: Show HN: Replay – A private, on-device Google Timeline replacement for iOS

author: EnhancedJax


value: Show HN: FlöFuel – cycling nutrition app that plans around your actual products


value: MaxNardit

value: Show HN: Clipboard-MCP – System clipboard access for AI assistants

author: MaxNardit


value: neolaw

value: Show HN: Pyconject – Ditch messy YAML loading in Python with config injection

author: neolaw


value: zippode

value: Show HN: Isartor – Pure-Rust prompt firewall, deflects 60-95% of LLM traffic

author: zippode


value: giancaIta

value: Show HN: Interactive guitar modes explorer: scales, fretboard, diatonic chords

author: giancaIta


value: samchon

value:
I was personally invited by the Qwen team to speak at Qwen Meetup Korea, and got to present locally here in Korea yesterday — pretty honored to have been reached out to directly.
The talk was about how I got function calling to work reliably on deeply recursive union types — the stuff the industry generally says doesn't work. With `qwen3-coder-next`, first-try success rate was 6.75%. And the entire Qwen 3.5 model family was hitting 0% on union types due to a consistent double-stringify bug. Both ended up at 100%.
Slides are also available here: https://autobe.dev/seminars/20260326-qwen-meetup-korea.pptx — speaker notes are written inside as slide notes if you'd like the full narrative behind each slide.

value: Show HN: Qwen Meetup, Function Calling Harness, turning 6.75% to 100%

author: samchon


value: mikusnuz

value: Show HN: Nudge – Free, open-source Mac window manager

author: mikusnuz


value: gooseyGander

value:
I’ve been working on a temporal database for agents that combines graphs, tables, and compute.
While building it, I ended up needing an agent framework that could handle both simple tool-use tasks and more graph-based execution, so I pulled that out into a separate project, Agent Forge.
Agent Forge uses a two-tier execution model:
* a heuristic router decides whether a request is simple or complex
* simple requests go through a lightweight agent loop with a single system prompt and tool-calling loop
* more complex requests can use memory retrieval, reflection constraints, tree search, and self-critique
It also has:
* composable middleware for summarisation, caching, approval gates, and planning
* a graph execution engine with parallel nodes, conditional routing, checkpointing, and interrupts
* an optional integration with MinnsDB for memory and temporal state, though it works independently as well
* mutli agent planning with subscriptions and vibe grapgh
`
Repo: https://github.com/Minns-ai/agent-forge-sdk
npm: https://www.npmjs.com/package/@minns/agent-forge

value: Show HN: Agent Forge, an agent framework, heuristic routing and graph execution

author: gooseyGander


value: keyhell

value:
I wanted something like this for the company I work for. Even started building it in Excel, but then Claude Code CLI got me so much that I started trying to solve my every problem or idea with it.
This is how https://sharedlog.app started. So far, it is:
- free ()
- captain, team member, observer roles and corresponding event visibility
- public and private event logs/pages
- iframe and JS embed for your website
- a bit of customizations
- emails send for each created event
- big plans ;-)
Sample public pages:
https://sharedlog.app/company/apple-inc
https://sharedlog.app/company/stark-industries
() It's free because I don't like subscriptions. I have no idea what it could become when the Cloudflare bill becomes higher than what I'm willing to pay myself.

value: Show HN: Web service for writing a log (history) of your company

author: keyhell


value: collectedparts

value:
Claude Code uses Ink (React for CLIs) which positions text via cursor moves. When you copy text from its terminal output, each line gets padded with trailing spaces to fill the terminal width, and every line gets a consistent leading indent from the UI chrome. The result is text that looks right in the terminal but pastes like garbage.
I assumed this was a hard problem — that the copy operation was destroying line boundaries and merging padding with indentation into an ambiguous space blob. Nope. A hex dump (`pbpaste | xxd`) showed real `0a` newlines at every line boundary, and consistent leading whitespace. The entire fix is: strip trailing whitespace, dedent.

  #!/usr/bin/env python3
  import re, sys

  def clean(text):
      text = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)     # strip ANSI escapes
      text = re.sub(r'\x1b\][^\x07]*\x07', '', text)         # strip OSC sequences
      text = re.sub(r'[ \t]+$', '', text, flags=re.MULTILINE) # strip trailing whitespace
      lines = text.split('\n')
      while lines and not lines[0].strip(): lines.pop(0)     # drop leading blank lines
      while lines and not lines[-1].strip(): lines.pop()     # drop trailing blank lines
      indent = min((len(l) - len(l.lstrip()) for l in lines if l.strip()), default=0)
      return '\n'.join(l[indent:] for l in lines) + '\n'

  print(clean(sys.stdin.read()), end='')

Usage:

    pbpaste | ./unfuck-paste
    pbpaste | ./unfuck-paste | pbcopy   # fix in-place on clipboard

Yes I know Clean Clode exists — but it's a web app. If I'm already in a terminal copying from a terminal, opening a browser to fix terminal output feels wrong (and not appropriate for anything sensitive).

value: Show HN: 10 Lines of Python to fix mangled copy-paste from Claude Code

author: collectedparts


value: Show HN: Writevoid.com – stop writing, and the void takes it


value: vochsel

value: I've spent the last month building an electron agent orchestrator wrapper. But it occurred to me you could also go the other way - expose my terminal via local web sockets to a website, with any sort of ui...

value: Show HN: Walkie-Talkie – Access your terminal from any browser with one command

author: vochsel


value: Show HN: GameHippo.art – Preserving a lost freeware game directory from 2004


value: jackxmm

value: Show HN: HTML Viewer with Bidirectional Highlighting (Code ↔ Highlight Element)

author: jackxmm


value:
I usually create flowcharts using Mermaid, but a project I’m working on requires design documents in Excel format, which led me to start this project.
It parses Mermaid DSL and compiles it directly into Excel (.xlsx) files.
Unlike traditional tools that export diagrams as static images (PNG or SVG), mrxl translates diagram components into native Excel elements—such as shapes, cell ranges, and charts—enabling further editing and data manipulation within the spreadsheet.

value: Show HN: Mrxl – Compile Mermaid diagrams into Excel (.xlsx)


value: lmazgon

value:
I built a terminal UI for browsing Grafana dashboards. It connects to any Grafana instance and lets you explore dashboards without leaving the terminal.
It renders the most common panel types (time series, bar charts, gauges, heatmaps etc.). You can change the time range, set dashboard variables and filter series.
I built this because I spend most of my day in the terminal and wanted a quick way to glance at dashboards without switching to the browser. It's not perfect by any means, but it's a nifty and useful tool.
Built with Go, Bubble Tea, ntcharts, and Claude (of course). You can install it via Homebrew:

    brew install lovromazgon/tap/grafana-tui

... and try it out against Grafana's public playground:

    grafana-tui --url https://play.grafana.org

value: Show HN: Grafana TUI – Browse Grafana dashboards in the terminal

author: lmazgon


value: EagleEdge

value: Show HN: Run approved AI repo changes from a Markdown playbook

author: EagleEdge


value: pistoriusp

value: Show HN: Agent-CI (Run GitHub Actions on your local machine.)

author: pistoriusp


value: I bought a Razer Basilisk V3 X HyperSpeed to use as a Bluetooth mouse for my mac without realizing Razer doesn't offer software support for it. So instead of returning it, I used coding agents (mostly codex) to reverse engineer the BLE spec and then build an app around it! Along the way I added support for a few other Razer mice.<p>I have essentially no reverse engineering experience, so I likely would not have attempted this project without a coding agent to help. The general process was: Capture BLE packets with btvs on windows, perform an action on the mouse with synapse open, then send the capture to codex to figure out what happened and update the spec. I repeated this for every mouse button and binding until I had the full picture. There are some docs in the docs folder that detail the process and results if you are interested!

value: Show HN: I vibe reverse engineered my Bluetooth mouse to support it on macOS


value:
forkrun is the culmination of a 10-year-long journey focused on "how to make shell parallelization fast". What started as a standard "fork jobs in a loop" has turned into a lock-free, CAS-retry-loop-free, SIMD-accelerated, self-tuning, NUMA aware shell-based stream parallelization engine that is (mostly) a drop-in replacement for xargs -P and GNU parallel.
On my 14-core/28-thread i9-7940x, forkrun achieves:
* 200,000+ batch dispatches/sec (vs ~500 for GNU Parallel)
* ~95–99% CPU utilization across all 28 logical cores, even when the workload is non-existant (bash no-ops / `:`) (vs ~6% for GNU Parallel). These benchmarks are intentionally worst-case (near-zero work per task) because they measure the capability of the parallelization framework itself, not how much work an external tool can do.
* Typically 50×–400× faster on real high-frequency low-latency workloads (vs GNU Parallel)
A few of the techniques that make this possible:
* Born-local NUMA: stdin is splice()'d into a shared memfd, then pages are placed on the target NUMA node via set_mempolicy(MPOL_BIND) before any worker touches them, making the memfd NUMA-spliced. Each numa node only claims work that is already born-local on its node. Stealing from other nodes is permitted under some conditions when no local work exists.
* SIMD scanning: per-node indexers/scanners use AVX2/NEON to find line boundaries (delimiters) at speeds approaching memory bandwidth, and publish byte-offsets and line-counts into per-node lock-free rings.
* Lock-free claiming: workers claim batches with a single atomic_fetch_add — no locks, no CAS retry loops; contention is reduced to a single atomic on one cache line.
* Memory management: a background thread uses fallocate(PUNCH_HOLE) to reclaim space without breaking the logical offset system.
…and that’s just the surface. The implementation uses many additional systems-level techniques (phase-aware tail handling, adaptive batching, early-flush detection, etc.) to eliminate overhead, increase throughput and reduce latency at every stage.
In its fastest (-b) mode (fixed-size batches, minimal processing), it can exceed 1B lines/sec.
forkrun ships as a single bash file with an embedded, self-extracting C extension — no Perl, no Python, no install, full native support for parallelizing arbitrary shell functions. The binary is built in public GitHub Actions so you can trace it back to CI (see the GitHub "Blame" on the line containing the base64 embeddings). Trying it is literally two commands:

    . frun.bash
    frun shell_func_or_cmd < inputs

For benchmarking scripts and results, see the BENCHMARKS dir in the GitHub repo
For an architecture deep-dive, see the DOCS dir in the GitHub repo
Happy to answer questions.

value: Show HN: Forkrun – NUMA-aware shell parallelizer (50×–400× faster than parallel)


value: sarmadgulzar

value: Show HN: Digital Input using Rust on XIAO nRF52840 with Embassy

author: sarmadgulzar


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: Show HN: Porting old C++ Battle for Wesnoth to the web with amnesiac agents


value: cagz

value:
Imagine a corpus of documents with scientist biographies.
The traditional RAG works fine until you ask questions like:
- "Who was born before 1800?"
- "How many are mathematicians?"
- "List names and birthdays for mathematicians"
These result in an incomplete answer due to top-k, with no signs of incompleteness.
For an initial corpus, it is possible to improve this problem by extracting metadata for a predetermined set of fields. This approach has two problems:
- One has to predict all the questions that can be asked against the corpus upfront.
- Constantly revising that prediction as the documents change, e.g. adding Nobel prizes later, or extending the document set to contain artists.
DuoRAG aims to solve both problems by:
- An initial metadata (schema) discovery before the first ingestion
- Self-update schema with candidate fields when it fails to answer a question

value: Show HN: DuoRAG – A dual stack RAG that self-evolves

author: cagz


value: tsolman

value: Show HN: Open-source API for IACS vessel classification data

author: tsolman


value: MrPhilGames

value: Show HN: Deep Hollow – A survival game where your AI runs your fortress 24/7

author: MrPhilGames