value:
AI coding agents now run real shell commands on your machine — rm -rf, git
push --force, DROP TABLE, dd, writes straight to disk. Almost always that's
fine. The one time it isn't (a hallucinated path, a prompt-injected
instruction, a confident wrong guess) there's no undo and you find out after.
Kintsugi sits between the agent and your system. It catches the dangerous
command before it runs, explains it in one plain sentence, makes
destructive actions reversible with a snapshot, and writes every command
every agent ran to an append-only, hash-chained log you own. Local-first:
no cloud, no account, nothing leaves the machine.
It's not only for AI. A passive bash/zsh recorder (no agent involved) puts
every command a person runs on the same tamper-evident log and snapshots the
destructive ones just-in-time — so `kintsugi undo` rolls back a DBA's
fat-fingered rm -rf or clobbering overwrite the same way it rolls back an
agent's. On a managed host you can seal the settings behind an admin password,
enforced daemon-side with brute-force lockout, so an agent or a normal user
can't quietly turn it off.
The design rule I cared most about: the decision to block a catastrophic
command is made by deterministic rules a human wrote — never an LLM. A local
model can only explain a command and add caution to the ambiguous middle;
it can never unlock or downgrade a rule-based block. So the block is
predictable and can't be talked out of by a clever prompt.
A few things that turned out to matter:
- It parses real shell structure, not text. Two passes — a fast tokenizer and
  a true bash AST parser (brush-parser, pure Rust) — and it takes the more
  cautious verdict. That catches commands hidden inside $(...), here-docs,
  subshells, and if/for/while blocks, which substring scanners wave through.
  echo "$(rm -rf /)" is caught.
- It fails toward caution. A line the parser can't fully understand is held,
  never assumed safe. The hard invariant, enforced by a golden corpus, is
  zero catastrophic-classified-as-safe.
- It works at the process/PATH layer, not as a per-tool plugin. Native
  pre-tool hooks for Claude Code, Cursor, Codex, Qwen, Gemini, Copilot,
  OpenCode — plus a $PATH shim and an MCP server for everything else,
  including a raw bash script or a Makefile. `kintsugi init` wires them in
  one command.
I want to be honest about the guarantee, because a lot of tools in this space
oversell. Kintsugi is a seatbelt, not a kernel firewall. Hooks are an
interception layer — an agent in a yolo/auto-approve mode, or a process that
calls a binary by absolute path, can bypass them. That's exactly why there's
a filesystem-watcher backstop: the promise is "nothing is unrecoverable," NOT
"nothing runs un-warned." And the admin lock defeats an agent or a non-root
user — it does not stop root. It guards against mistakes, not a malicious
same-user process with root.
I ran an adversarial assessment against it: 0/176 dangerous commands leaked
to "safe" across a MITRE ATT&CK + GTFOBins corpus, 1.4M fuzz inputs — which
surfaced one real heap-DoS, now fixed, and no crashes since — and zero unsafe
blocks. Every figure is reproduced by a committed test.
It's Rust, MIT, cross-platform (macOS/Linux/Windows). Install is one line and
it works immediately with no model — an optional local GGUF just sharpens the
plain-English summaries:

  curl -fsSL https://github.com/arrowassassin/kintsugi/releases/latest/download/install.sh | sh

  # or, from source:
  cargo install kintsugi

This is an early release and I'd genuinely like to be told where the model is
wrong — both false alarms on safe commands and, more importantly, any
catastrophic command that slips through. Happy to answer anything about the
rule engine, the AST approach, or the threat model.

value: Show HN: Kintsugi – a local-first safety net for AI agents and humans


value: maclinz

value:
I wanted to kick my doomscrolling habit, so I built a microlearning app that uses a TikTok-style algorithm, same addictive feed mechanics, but you actually learn something.
I started with a general version, Scroll: Daily Microlearning (microlearning.usescroll.app), but quickly realised it works better when focused on a single topic. So I split it into:
Scroll: Personal Finance (https://finance.usescroll.app)
Scroll: Learn AI (https://ai.usescroll.app)
Scroll: Daily Microlearning (https://microlearning.usescroll.app)

value: Show HN: Microlearning apps with a TikTok-style feed to beat doomscrolling

author: maclinz


value: freakynit

value: Show HN: JerrySniffs – MCP Server (and API's) for web and social media search

author: freakynit


value: czarandy

value: I always seem to miss new albums from music artists I like, and I haven't been happy with any existing services (they either cost $ or only work with Spotify, which doesn't have all the artists I listen to). So I built a simple tool to pull data from MusicBrainz for whatever artists you want.<p>It runs entirely locally (sqlite db) and can be used as a CLI (also works well with agents) or with a local web UI. It can optionally notify you with emails, or you can just check it periodically. I've already found a bunch of releases I missed from my favorite artists.

value: Show HN: Silver Music Notifier – get notified about your artists' new releases

author: czarandy


value: cavalrytactics

value:
As a Security Engineer with over 10+ years in industry, I kept running into the same problem with coding agents: Instructions are not guarantees.
I put guidance in `CLAUDE.md`, `AGENTS.md`, memory files, MCP descriptions, and tool documentation. I explicitly told the agent things like:
- Use the code graph for architecture questions instead of grepping the repository.
- Do not use deprecated APIs or Unsafe code.
- Prefer specific tools for specific tasks.
The agent would still ignore those instructions surprisingly often. It would grep the entire repo, use deprecated APIs, or choose a slower tool even when a better one was available.
That made me realize prompts and rules solve different problems.
A prompt is a probabilistic influence on model behavior. A rule is an enforcement mechanism.
So I built SSG (SigmaShake Governance), which sits between the agent and its tools. Instead of asking the model to remember a policy, SSG evaluates every tool call before it executes.
For example, this rule redirects architecture-related repository searches away from recursive grep and toward a code graph:
```text
rule route-codebase-grep-to-graph {
  enable true
  priority 80
  severity warning
  CATEGORY tool-routing
  FORCE search
  IF tool EQUALS "Grep"
  MESSAGE "Architecture, relationship, and dependency questions are routed to the code-graph tool."
  SUBSTITUTE "graphify query \"<what you were searching for>\""
}
```
When the agent attempts a grep for an architecture question, the call is redirected. If it attempts to write deprecated code, the write can be blocked before the content reaches disk and the replacement API can be suggested.
A few design choices:
- Rules are plain text and git-versioned.
- Enforcement runs locally.
- The same rules work across Claude Code, Codex, Cursor, Gemini, and MCP-based agents.
- Bypasses are allowed, but recorded.
- The goal is not to sandbox a hostile model; it's to prevent routine agent mistakes and shortcuts.
I found that many existing controls operate either too early or too late:
- Prompt files influence behavior but don't enforce it.
- Tool allowlists are often all-or-nothing.
- Pre-commit hooks catch problems after files have already been written.
- Harness-specific permissions don't travel with the repository. (what if your team does not use the same harness?)
If you do not live in the terminal, SigmaShake Desktop is the same governance dashboard with no CLI required: a free direct download for macOS, Windows, and Linux. The Mac App Store and Microsoft Store also carry it as a paid, sandboxed build that auto-updates and skips the Gatekeeper and SmartScreen prompts, if you would rather pay once for the managed install (or just want to support the project):
https://apps.apple.com/us/app/sigmashake-desktop/id676990115...
https://apps.microsoft.com/detail/9N2CHV3STGS4
I've been building this in public for a few months.
https://twitch.tv/sigmashake
https://youtube.com/@sigmashakeinc
What instructions do your agents consistently ignore?

value: Show HN: A policy gate that runs before your AI coding agent's tool calls

author: cavalrytactics


value:
Skill Atlas is a standalone, serverless IDE designed specifically to solve this problem. It parses your entire skill repository and automatically constructs a visual Directed Acyclic Graph (DAG).
By treating your agent's instructions as a compiled dependency tree, Skill Atlas allows you to:
Visually map the execution path and dependencies between different LLM instructions.
Ensure strict compliance with Anthropic and OpenAI guidelines for atomic, composable skills.
Safely edit markdown skills in the browser and securely push them directly back to GitHub as Pull Requests.
https://atlas-skills.netlify.app/

value: Show HN: Skill Atlas – Local, visual IDE for Agentic Skills (BYOK, no back end)


value: zinxor

value: Show HN: I built an AI that calls you, interviews you and publishes your content

author: zinxor


value: ngburke

value: Show HN: VulnFeed – 9 security tools your AI agent can call (MCP server)

author: ngburke


value: jgvandehey

value: Show HN: I made Oregon Trail for founders (paste your company URL)

author: jgvandehey


value: evanmarshall

value:
I'm Evan and I made Ito.ai
It's code review that actually runs your code. The result is that it finds more bugs with a smaller false positive rate. You get screenshots, videos, and run logs. I built Ito because manual verification sucks and I thought I could automate it. I've been a professional developer for 15 years and now more than ever, I'm just spending time making sure things work.
I looked into all of the other agentic testing tools that click around a url you give them and frankly, they sucked. They just didn't work. I figured to be able to actually testing things you need to run the full environment so you can seed data, bypass gates, mock external dependencies. They also can't get runtime evidence about changes that aren't frontend. Ito does.
Under the hood, Ito is creating a devcontainer for your application. All of your services are wired up and then a team of agents goes and tests your PR. We rolled out our own sandboxes and our own agentic coding loops.
I built Ito to be another useful signal in development. It shouldn't annoy you when it's not perfect and it saves you a bunch of time testing.
A few open source examples:
- n8n https://app.ito.ai/share/bb7d73aa-fd08-482d-9938-87938e2a232...
- lobehub https://app.ito.ai/share/1d76f15a-9998-4154-85b4-b177924cba8...
- excalidraw https://app.ito.ai/share/d1cb1475-fbe5-4c71-901b-409ba2aa6d6...

value: Show HN: Ito – Code reviews that run code

author: evanmarshall


value: jhylands

value: I've been working for a while on trying to curate a game that has the emergence of procedurally generated computer games but that can be played with only pen and paper. Here I present the best version I've been able to come up with that is simple and emergent. I've really enjoyed being able to engage with this sort of game while not feeling like my brain in rotting. I recon my numeracy improves while playing it.

value: Show HN: Pen and paper resource development game with an emergent world

author: jhylands


value: Show HN: Beautiful dark mode for Hacker News (New for iOS/Android)


value: ilyaizen

value: Show HN: visual hcker.news extension – story preview images for HN headlines

author: ilyaizen


value: stevesolun

value:
Hi HN!
Token cost has started to become a high topic of concern to all of us. I tried a few (awesome) tools such as rtk, caveman, and the recent (hillarious but effective) ponytail. What they usually do, is in-line token reduction, e.g. try to compress requests / responses as much as possible.
But then it hit me (and I’m sure others had similar ideas) - just like we have routers that pick the right model, why not have something that will also narrow down the amount of available tools, skills and mcps based on repo/context?
People usually accumulate skills, agents, MCP servers, harnesses, prompts, repo instructions, and local scripts. I’m not saying we are all hoarders, but we sort of are. When did you remove a skill recently? After a while, the model has way too many options to choose from.
ctx tries to fix that by selecting context before the session gets bloated.So no, it doesn’t cleanup your messy garage, but it gives you magic glasses that let you focus only on the tools you need.
It does it by watching the repo and task, walks a graph of available tooling, and recommends a small top-scored bundle of skills, agents, MCP servers, and harnesses.
How does it know?
To make sure results are not hallucinated, and repeatable, I curated a list of  91k+ skills,  467 agents, 10.7k MCP servers,  207 harnesses, and built a graph to help ctx make decisions on what to recommend. While I used AI to generate it of course, I curated it and revised it to make sure the data is up to date.
So how this is different from rtk, caveman, ponytail, and similar token-saving tools?
As mentioned above those tools mostly reduce tokens after something is already being used.
rtk compresses command output.
caveman-style tools make the assistant respond with fewer words.
ponytail, is, well, awesome, but again it focuses more on reducing code (YAGNI)
ctx is upstream. It tries to avoid loading irrelevant skills, agents, MCPs, and harnesses into context at all.
So it is not really a replacement. It should work side by side with them!
Use ctx to choose the right tools.
Use rtk to reduce terminal-output noise.
Use terse-output tools if you want shorter responses.
The goal is simple: save tokens without forcing the user to manually test and compare thousands of possible skills, agents, MCP servers, and harnesses.
Repo: https://github.com/stevesolun/ctx

value: Show HN: Ctx, save tokens by loading only the relevant tools

author: stevesolun


value: jjgreen

value: Show HN: Cpt-city, Xkcd colour schemes

author: jjgreen

title: Show HN: Cpt-city, Xkcd colour schemes


value: WolfOliver

value: Show HN: Almost all of MonsterWriter's back end is open source

author: WolfOliver


value: elpulgo

value: An Azure devops TUI tool, with management metrics, to follow up on stuck items, too much wip per team member and tracking across sprints.

value: Show HN: Azure DevOps TUI Management Style

author: elpulgo


value: WasimBhai

value: Show HN: Rapunzel – a tree-style tab terminal emulator for Codex Claude Gemini

author: WasimBhai


value: jratkevic

value:
Hi HN,
We’re the team at MyDecisive.ai, and today we’re giving developers a peek at Octant — point-and-click control and visibility for your OpenTelemetry.
You've likely felt the pain of the "observability tax," especially if you manage K8S clusters. The modern standard is to instrument everything with OpenTelemetry, but piping all those rich OTLP logs, metrics, and traces straight to a SaaS vendor (Datadog, Splunk, Honeycomb) gets expensive fast. You end up paying massive ingestion and storage costs for noisy, low-value data just so it's searchable when something breaks. With Octant you get up and running on OTel in minutes.
We built Octant to flip this model. Instead of blindly shipping all telemetry off-cluster, Octant configures and helps to manage OTEL clusters. It gives you a visual interface for managing K8s objects, but importantly, it acts as an OTLP gateway that filters data at the source before it leaves your VPC.
Because it natively speaks OpenTelemetry, you can point your existing OTel SDKs or collectors right at it without touching your application code. Here is what it does under the hood:
- OTel-Native Trace & Log Sampling: It makes it easy to ingest OTLP traffic and inspects logs and traces on the wire. By waiting for the full context of a trace before determining what to keep, it delivers on the promise of braiding, retaining 100% of the actionable signals around (like errors and high-latency spans) but droppings the junk before it hits your SaaS bill.
- In-Flight Stateful Alerting: Instead of waiting for data to be batched, shipped, and indexed by an external provider to trigger an alert, Octant can process the telemetry streams in-flight. This shrinks the detection gap and reduces the need for SaaS vendors in the first place.
- On-the-Wire PII Redaction: It can detect and strip sensitive information from your logs and traces in real-time before they are transmitted over the internet, removing "post-ingestion" clean-up costs and compliance risks.
- K8s Context Injection: Because it's deeply integrated with your cluster, it maps your OTel streams directly to your K8s resources (Deployments, Pods, CRDs) in a unified UI.
The API is built in Go ([github.com/mydecisive/octant] and the whole stack can be deployed directly into your cluster via our Helm charts.
We’d love for you to spin it up on a dev cluster and tear it apart. We just recently merged a PR from our very first community contributor, which was a huge milestone for us! We want to keep that momentum going. If you're interested in hacking on K8s observability and autonomy, OpenTelemetry pipelines, or Go/React, we’ve tagged a few 'good first issues' and would be thrilled to welcome you to the project.
GitHub: https://github.com/MyDecisive/octant
Website: https://www.mydecisive.ai/
I'll be hanging out in the thread today and am happy to answer any questions or dig into the architecture!

value: Show HN: Dev-friendly native OTel: only OSS stateful, on-the-wire Observability

author: jratkevic


value: ajaypanthagani

value:
I was frustated by having to draw system design diagrams by hand when discussing it with my team mates or in an interview. So I thought "Wouldn't it be great if someone draws it for me, while I think out loud?".
That is when I came up with VoiceDraw. You can just think out loud or discuss your system architecture with a friend/interviewer, the diagrams are automatically drawn along with your reasoning, open questions and tradeoffs beautifully written on to the side.
Demo Video: https://youtu.be/36PgHKSuccE

value: Show HN: VoiceDraw – Talk system design out loud, the diagrams draw themselves

author: ajaypanthagani


value: jmckenty

value:
Built mostly by agents, and mostly for agents, dopamine uses a common file format and a transpiler to abstract a common set of capabilities for Android, iOS and Web. Effects are configured with intensity, mood and whimsey rather than speed or palette.
PRs welcome.

value: Show HN: Dopamine – An MIT-Licensed Open-Source Cross-Platform Effects Library

author: jmckenty


value: windsor

value:
I spend a lot of my time writing GitHub Actions.
Specifically, I need to script a ton of things. The current way of writing GitHub Actions with YAML is usually fine for small jobs. But for anything complicated, I often find myself in incredibly cursed "shell-in-YAML" situations.
This was a major source of bugs for me. Since the "script" was written in YAML, there was actually not an easy way to modularize out the scripting logic to unit test them. Worse, there was zero type safety! For those who work with GitHub Actions frequently, you know how annoying this gets.
My ideal GitHub Actions workflow would be to write actual programs, preferably in a language with strong types support.
I also don't want an opinionated framework or a beefy runtime to "run" my GitHub Actions. I literally just want a way to write arbitrary programs that can call other services using native tooling from their respective ecosystems; for example, the AWS SDK to orchestrate my cloud.
So this got me thinking about the tooling in this space, and I was really surprised to find that it wasn't that great. Outside of a few linters and the popular `act` project, there was very little support for us DevOps guys.
That's why I made Hollywood! (Try to guess why it's name this way, haha. Hint at the end.)
It’s fully open-source and MIT-licensed. Just import Hollywood and you can begin writing your GitHub Actions logic purely in TypeScript.
Hollywood is not a "framework" so there are very few -- if any -- opinions as to how you ought to use it. You are free to do literally whatever you want with it, provided that it's legal in TypeScript.
This means you can validate your types with Zod or you can even use your favorite TypeScript frameworks, e.g. Effect.ts.
Hollywood is also very lightweight: only 53 kB and only 6 runtime deps.
If you wanted to containerize your Hollywood Actions, you are also not locked into any particular opinions or preconceived notions of how you should set up your runtimes and local testing. You can use Docker, or Podman, or Lima, or Apple's `container`, or a remote cloud service. Again, it's literally just TypeScript. You can do whatever you want with it.
Hollywood is a fully general-purpose TypeScript library that compiles your beautiful TypeScript into validated YAML for your GitHub Actions to consume!
--
Hint: "Lights, cameras, _!"
Fun fact: you are allowed to shell out in TypeScript, so you can actually just shell out to any language you’d prefer, not just TypeScript.

value: Show HN: Write Your GitHub Actions in TypeScript

author: windsor


value: dpesic

value: Show HN: Ril: a parallel data streaming tool for Python

author: dpesic


value: Show HN: Next.js boilerplate with Better Auth, PostgreSQL and Shadcn/UI


value: anqer

value: Can I have some feedback?

value: Show HN: I'm 15, built an AI that watches your screen and acts before you ask

author: anqer

story_text: Can I have some feedback?


value: bcye

value:
My go to for quickly keeping a count was a note on my phone, but I found it a bit cumbersome to edit a number again and again.
So I quickly built this app, it does what it says on the tin and keeps the feel of tally marks on paper.
I hope someone else will find some use in it too :)

value: Show HN: Tally Marks – an app for counting with a handwritten look & feel

author: bcye


value: melihelibol

value: Show HN: cuTile Rust: Safe, data-race-free GPU kernels in Rust

author: melihelibol


value: jkkronk

value: Show HN: My Mac shoos me away every time I bite my nails

author: jkkronk


value: smorsic

value:
I developed a package simply called bun-workspaces that worked on top of Bun workspaces directly with zero required config, using plain package.json scripts for orchestration.
I have re-developed this package into pacwich, which
supports Bun, npm, or pnpm. I decided it would be a better direction for it to be decoupled from a particular package manager, so it needed a new name (but I wanted to keep my logo).
I write about the development strategy and my engineering philosophy (including disclosing the manner in which AI assists and my approach to not vibing this) in the Security page and the launch blog post about the pivot, which I linked on the home page in the note about the bun-workspaces migration.
More is to come, including a way to compose scripts into more complex workflows rather than running one named script in parallel/series.

value: Show HN: Pacwich – lightweight new monorepo tooling on top of Bun, NPM, or pnpm

author: smorsic


value: Show HN: Audit your installed GitHub CLI extensions


value:
Hi HN!
I've built a web that takes your Steam game library and generates a 3D city from it. Games become buildings, playtime determines height. So your most-played game is a massive tower and that game you impulse-bought during a sale and never touched is basically a parking garage.
There's also a world view where every player's library is a building on a shared map. About 7k people on it right now, you can fly around the whole thing.
You can try this on https://thesteamcity.com
Built with Next.js, React Three Fiber, and Supabase. Works on mobile too.
Hope you like it!

value: Show HN: Steam City – Your Steam game library as a 3D city


value: stubbi

value: Show HN: Karpenter Provider for Hetzner

author: stubbi

title: Show HN: Karpenter Provider for Hetzner


value: apvcode

value: Show HN: PromptShark – MitM proxy, C++ loop detector and replay for AI agents

author: apvcode


value: lemonlym

value: Show HN: Private Markets SEC Filings Index

author: lemonlym


value: gianiac

value:
Hi, over the past few months I've been working on this project: Numax is a small Rust runtime that does three things: it runs WebAssembly modules in a sandbox, has a built-in local key-value store, and syncs everything across nodes with CRDTs and gossip.
Basically, you write a wasm module, run it on two machines, and they converge (I hope !).
It's a decentralized system... I hope someone finds it interesting!
There's a whitepaper I've put a lot into, and I think the code isn't bad either!
I believe there's still room in this world for software that's fun and well made, and while building Numax I had a great time!
I love Numax and I love software. Thanks to anyone who'll spend a bit of their time even just to open the repo and take a look!

value: Show HN: Numax - a portable runtime for distributed apps

author: gianiac


value: activefx

value:
Now on its 32nd edition, the Ruby AI Newsletter tracks what’s happening at the intersection of Ruby, Rails, and AI coding agents.
YC recommends Rails for new startups, YC’s internal software like Bookface, Work at a Startup, and the software that runs the accelerator all run on Rails. Garry has been a vocal advocate for Ruby on Rails for agentic startups, calling it a "crazy unlock". And there is an incredible ecosystem forming around RubyLLM. Ruby and Rails gives agents conventions, structure, and fewer architectural choices to hallucinate.
This edition is about that idea from the Ruby side: if models are increasingly interchangeable, restricted, expensive, or temporary, then the durable advantage is the system around them. Ruby and Rails may have a real edge there because they already reward clear conventions, small teams, mature libraries, and boring production software.
Feedback welcome!

value: Show HN: The Ruby AI Newsletter

author: activefx

title: Show HN: The Ruby AI Newsletter


value: YuechenLi

value:
Apologies in advance if my writing is unclear.
First, why make another programming language? This came out of my general frustration with working with MATLAB and Python during grad school as well as at work. I'm a mechanical engineer; I write Python scripts for my own use semi-regularly. My issue with Python is that while writing easy, debugging Python code I wrote is hard once the code gets big. Sharing my Python code to colleagues is very difficult as most of them are less technical on coding than I am, so asking them to setup a full Python env just to run a script is out of the question.
Then, the Two-Language Problem for scientific computing: write the prototype code in Python/MATLAB and rewrite the performance sensitive code in C++/Rust when needed. The problem is that C++ and Rust are not very easy to learn and converting from a dynamically typed language like Python to a strict, statically typed language like Rust is not easy, especially for people who are not software engineers.
The name Oct is a reference to GNU Octave and started as my concept of what Octave should have been, and the name stuck. About 75k lines of Oct code are in the repo across experiments, libraries, and examples. Pretty much all of it is written by Claude/Codex, my role is only to prevent drift/hallucinations.
Features, in no particular order:
- Function first, statically typed, both interpreted and compiled: Oct code compiles to a Go binary via MIR codegen, runs on anything that Go runs at Go speed, and inherits Go's absurd compile speed, which means that a JIT is mostly unnecessary.
- The entire Go ecosystem is available for Oct if you write a wrapper around it: Oct's `IO.Xlsx` library is `excelize`, Oct's builtin plot is `gonum/plot`, Oct's benchmark profiling is pprof, Oct's C interop is CGo.
- Boring syntax, easy to learn. If you know Rust/Go/C#/Swift, learning Oct would take a few hours at most. Vice versa, if you learn Oct, then you are halfway to knowing how to write Rust already;
- Octest, xUnit.NET style testing framework with `[Fact]/[Theory]` and various Asserts.
- Foundational SI unit built into the language and enforced by typechecker: you can't add Int<m> and Int<kg> together. Units also propagate.
```oct
fn StiffnessForce(K: Matrix<Float<kg/s^2>>, u: Vector<Float<m>>) -> Vector<Float<kg<i>m/s^2>> {
    return K @ u
    // Matrix<Float<kg/s^2>> @ Vector<Float<m>> → Vector<Float<kg</i>m/s^2>>
}
```
- You can't ignore errors, Oct is exception free and `null`/`nil`-free, all errors must be handled explicitly: `?` for propagation, `!` for unwrap, or fallible `match`.
- Arrays and vector/matrix are separate but related concepts, with vectors/matrices explicitly defined as Rank 1 and 2 tensors, and Einstein notation for tensors is built into the language.
```oct
let c = a[i, k] * b[k, j]
```
- Octomata, Oct's own built in control system runtime, using explicit finite state machines and utility scoring as primitives for control systems.
```oct
package Main<p>flow DoorControl(openCmd: Bool, closeCmd: Bool, blocked: Bool) -> String {
    state Closed {
        when {
            case openCmd and blocked == false -> goto Opening
            else -> return "closed"
        }
    }<p><pre><code>    state Opening {
        when {
            case blocked -> goto Closed
            case closeCmd -> goto Closing
            else -> return "opening"
        }
    }

    state Closing { return "closing" }</code></pre>
}
```
Oct is very much a work in progress, but enough jank/bugs has been fixed that hopefully it wouldn't be embarrassing to show it off now, although rough edges still expected. So, would love some feedback.

value: Show HN: The Oct Programming Language for scientific programming

author: YuechenLi


value: mannders

value:
Hey all. Reticle is a fast native desktop application (tauri/rust) which lets you spatially view your servers in a map with layers representing our global network infrastructure.
On those servers you have full observability and control. You can execute cron based health checks, scripts over ssh, or even a fully functional embedded terminal. This lets you intuitively see the health of your services, with the power of a full shell if you need it.
I wanted to see the broader context in which my ec2 instances or raspberry pi operates. I also wanted to open a simple dashboard, make sure all infra checks are healthy, and have a shell readily available for quick fixes and diagnostics.
Reticle lets you operate on the internet as an engineer in an intuitively new way. It's also very fun and cool, I would love to chat if any of you feel the same.

value: Show HN: Reticle – The map your infrastructure operators deserve

author: mannders


value: renatoworks

value: Show HN: oh-my-reddit – beautiful reddit threads, live in your terminal

author: renatoworks


value: gmicek

value:
Hi HN! ODocs.co is a free, no-login collaborative doc system that humans and their AI agents edit together (REST-native or MCP-native).
https://odocs.co
I was having trouble sharing Claude Code context and collaborating with our product managers, and I realized there might be an easier interface to collaborate on PRDs (product requirements docs) and engineering design docs.
The workflow I kept running into:
1. I would draft something with an agent or Claude Code session,
2. I'd share those thoughts for comments and feedback with a product manager or another engineer in a Google Doc or Notion page,
3. After we collaborated with comments, it was painful to have my Claude Code session (a) re-read comments, (b) edit/add updates into the existing Google Doc or Notion Page, and (c) preserve version history from edits from each user on the document without erasing and rewriting the whole document via MCP.
I realized that there might be an easier way to collaborate between engineers and product managers so that everyone could interact and collaborate with their own Claude Code/Codex/Gemini sessions as well.
I created ODocs.co as a free method (inspired by draw.io but with a freemium future) to make it easy for Human 1-Agent 1 and Human 2-Agent 2 pairs to collaborate. It also works great for agents sharing context to other agents.
To preserve version history from different users, I developed it to handle partial updates in collaborative documents without rewriting an entire document. LLMs aren't good at character counting, and I worked through some engineering / UX solutions to make the partial doc edits seamless on the AI side.
It supports multiplayer doc editing so humans and agents can all collaborate at the same time.
Check it out and let me know your thoughts! Feedback is very welcome in any direction.
Here's my blog post for further detail on why I created this:
https://gregmicek.com/software-coding/2026/06/12/introducing...

value: Show HN: Odocs.co – multiplayer draw.io and docs for agent and human collab

author: gmicek


value: huydotnet

value: Show HN: Fixing grammar and spelling using on-device Apple Foundation Model

author: huydotnet


value: Show HN: Sley – a native-Rust Git engine, benchmarked and verified against Git


value:
"Why waste time say a lot word when few word do trick"
Introducing Kevin, a claude plugin that talks like Kevin Malone from The Office but here is the fun part it actually saves you money. On some basic benchmarks it saved me 90% cost and it writes 93% less lines of code so you get more from your Claude Code limits.
It is easy to use:
/plugin marketplace add hvardhan878/kevin
/plugin install kevin@kevin
The product is fully open source. Looking forward to hearing your thoughts!

value: Show HN: Kevin – Claude talk less. Save Money


value: danipolani

value: Includes text to card conversion, visual editing, variations and integration for posting directly from the editor.

value: Show HN: Easy text to social media cards platform

author: danipolani


value: wbemaker

value: Show HN: I Built a Free Text Based Audio Editor

author: wbemaker


value: shpran

value:
Crunchbase is $49/month, which isn't great if you wanna learn and your not an angel or a VC.
At the same time I stumbled on grokipedia, and though it was a stupid website.
But then I realized that by using AI agents to research similar to grokipedia, and assembling the info into detailed crunchbase style profiles, I can create a free alt to crunchbase.
So I made an admin dashboard that lets me use custom ai agents to research startups and push to the site.
I put up measures to stop hallucination, but obviously they aren't perfect, and so i added a feature where people can report inaccuracies.
NOTE : If one of the profiles you visit seems wonky and has very little info, its because of a rendering bug, I'm working on fixing it right now.

value: Show HN: Startup research website, crunchabse and Product Hunt and grokipedia

author: shpran


value: telui

value: Show HN: penguinAI – the c.ai alternative focused on privacy, no self-hosting

author: telui


value: suryaankata

value:
As I started my building journey few months ago, AI agents/coding tools not being stateful has been a big pain for me.
So I just shipped an Opencode fork (my current daily driver for building) with built-in autonomous memory management, the memory core can also be plugged into Hermes (included) and other desktop/coding agents with few prompts.
It's WIP, but please try it and give me your feedback.
Goal is to build a voice and mobile first client with server running in a sandbox or VM and works with all models like Opencode does, and replaces my current hermes+opencode setup running on a Oracle VM.
hmu if you wanna collab on this :)

value: Show HN: Building a Stateful AI Agent

author: suryaankata

title: Show HN: Building a Stateful AI Agent


value: ilchenearly

value: Show HN: Otty – a native and beautiful terminal emulator

author: ilchenearly


value: jiangyifeng

value: Show HN: SciFigureAI – AI figure maker for research papers

author: jiangyifeng


value: denn-gubsky

value: Show HN: Loomcycle – a sidecar runtime for AI agents (Go binary, Apache-2.0)

author: denn-gubsky


value: Show HN: Whissle Gateway – Multi-Modal Voice AI in a 500MB Local Docker


value: josemarpoubel

value: Show HN: IAGlobal – A multi-agent cognitive architecture inspired by biology"

author: josemarpoubel


value: heroboy

value: Show HN: FinMind AI – what if Claude Code was built for Wall Street?

author: heroboy


value: circleoncircles

value: Show HN: Convert the raw HealthKit DB from an iPhone backup to SQLite

author: circleoncircles


value: cosmok

value: I built a tool to help with deciding if there is Market demand for what you are trying to build.

value: Show HN: Product Validation

author: cosmok

title: Show HN: Product Validation


value: zizheruan

value: Show HN: Fig0 – 0-Manual AI Scientific Figure and Illustration Generator

author: zizheruan


value: theMackabu

value:
Hey again HN!
After getting Ant to a (mostly) stable state, it came to me that I should make it a registry, so born is ants.land. Not the most special just a npm clone but I think the user experience is pretty nice
Take a look and try it out maybe, the more bugs found the better.

value: Show HN: Registry for Ant and Everyone Else

author: theMackabu


value: alfanick

value: I'm a Lightroom user since 1.0, but I don't have a Mac anymore, and using it in Windows VM is a pain. Over the years I've developed my specific workflow for reviewing images (multi-pass, rate 0/1, filter >1, rate 1/2, filter >2, repeat) that allows me to cull pictures extremely efficiently. My usage of Lightroom is mostly just applying film emulations, reviewing, and exporting in specific size. For that I developed opensource tool mini-film that covers all those aspects. It allows also multiple people to work at the same time on the same pictures using Web GUI, but CLI is also first-class citizen. Feel free to explore and leave any improvements ideas. Unfortunately I cannot share full set of example emulations, as the company behind the profiles is not too happy about that.

value: Show HN: Mini-film – open-source tool for batch processing and reviewing RAWs

author: alfanick


value: Show HN: ParaMetal: A realtime 3D heat transfer simulation


value: grezac

value: Show HN: Day-ahead river discharge forecasting using USGS and ERA5 data

author: grezac


value: Show HN: Stego.Image – Hide any file inside a PNG image in the browser


value: Open Prism is a local-first LaTeX editor that lets your authenticated Claude CLI write, fix, compile, preview, and export PDFs without putting API keys in the app.

value: Show HN: CLI Integrated Latex Editor

title: Show HN: CLI Integrated Latex Editor


value: Show HN: Xpenser – self-hostable personal finance tracker with MCP access


value: nikoladinevski

value: Show HN: Tocka – A million-pixel canvas like R/place, but with real economics

author: nikoladinevski


value: tcostasouza

value: Show HN: Cerberus – PromQL/LogQL/TraceQL Query APIs Backed by ClickHouse

author: tcostasouza


value: herbstgewinn

value: In Science, there is a lack of 3D Models. I have built a pipeline to solve that, usign accurate image generation and transformation into interactable 3D Models to highlight them public on my website.

value: Show HN: Open-source 3D Cell Models Pipeline

author: herbstgewinn


value: esychology

value:
Neural CAs model self-organizing pattern formation.
Now they can generate patterns at HD resolution in real-time, enabled by turning each CA cell into a Neural Field.
Try 3 demos: grow a pattern from a seed (and damage it, it heals), synthesize PBR textures that can regenerate, or create 3D textures like clouds.

value: Show HN: High-Res Neural Cellular Automata

author: esychology


value: ruimbarreira

value: Show HN: I built 184 free browser tools – PDF, image, dev, AI tasks, no upload

author: ruimbarreira


value: Show HN: Open-Source RAG Security Kit for Zero-Trust Retrieval


value: Show HN: Noema64 – an open-source LLM chess engine (still in beta though)


value: tjardo

value: For landlords and managers of houses, apartments, rooms and student housing. Create your move-in and move-out reports digitally — with photos, meter readings and signatures.

value: Show HN: Digital inspection reports for any rental property

author: tjardo


value: SyntacticLuster

value: Show HN: OrbitSuite – Deterministic infrastructure for AI agent fleets

author: SyntacticLuster


value: rotemtam

value:
hey all,
happy to share research i've been working on for islo.dev in recent months.
ever since the cheating agents (https://debugml.github.io/cheating-agents/) paper came out, revealing reward hacking was 4x more prevalent than previously estimated, i've been looking into how we can deal with the issue
the common approach (taken by the tbench team) is post hoc trajectory analysis.
i've been interested in the idea of reframing the problem as an endpoint security problem and tackling it via sandbox
i hope you find it interesting, and thanks to the islo.dev team for sponsoring this
happy to answer any Qs

value: Show HN: RewardHackBench: Using sandboxes to stop agents from cheating

author: rotemtam


value: suruiran

value:
You can interact with the database using TypeScript.
Of course, for SQL databases, SQL is also supported, and there are some extensions as well.

value: Show HN: DBNova – A database interaction tool for developers

author: suruiran


value: A set of skills to use with Claude Code, Opencode, Codex, etc to help make your open source project more popular.

value: Show HN: AI Agent Skills to Grow Your Open Source Project


value: alpadurza

value: Show HN: Paper UX for task management, that organizes your personal DB itself

author: alpadurza


value: Show HN: A dev-news reader in 100% Kotlin Multiplatform (Android, iOS WIP)


value: Show HN: Jobs Core API – structured job data from 9,800 feeds, without scraping


value: Rompass

value: Show HN: OpenC6 BIOS – A PC-like bare-metal bootloader and OS for ESP32-C6

author: Rompass


value: rohityadavcloud

value:
Hi HN, I built Noject, a small native menu bar app for macOS that prevents accidental ejects of always-on external drives.
I made it for my own Mac mini setup with NVMe external drives that are always plugged-in and behave like internal storage. Noject lets you protect those volumes and reject any normal eject/unmount attempts from Finder, Disk Utility, Terminal, and other apps.
It uses Apple's Disk Arbitration framework, protects volumes by UUID, and has an "Eject Once" bypass for when you really do want to disconnect something. It is privacy first and does not need to read the contents of your drives.
Available for lifetime and free/fair download from the website https://scaleninja.com/noject/

value: Show HN: Noject – menubar app to stop drive ejections on macOS

author: rohityadavcloud


value: messel

value:
Vibed out over the weekend and built a multiplayer space game. It's uses the host + KV signals to coordinate shared state. The first version was a 2D rendered board, the latest iteration is built on 3djs and uses hubble space images as embedded backgrounds.
There's proc gen midi music (optional).
Reach out with any questions and have fun!

value: Show HN: Multiplayer Space Game

author: messel

title: Show HN: Multiplayer Space Game


value:
Got bummed out with ads on swipe left android news so I cooked up my own. Open source so you can see what was vibed up (and maybe why).
https://github.com/victusfate/boomerang
Also separated out the cloudflare friendly collaborative filter bits in case anyone has need of just that for their own projects
https://github.com/victusfate/ricochet
Been trying to push how far I can go with a dark factory approach, but I keep having to come back and ground/steer it. Appreciate any tips here.

value: Show HN: Yet Another News Reader

title: Show HN: Yet Another News Reader


value: witnz

value: Show HN: Kaupang – a push-based deploy CLI, now with a drag-and-drop builder

author: witnz


value: zionsati

value:
Introducing fui-as - https://github.com/zion-sati/fui-as
This is a WPF grade UI framework with SwiftUI like fluent syntax that is created specifically for the web. As you probably know, creating a native feeling canvas wasm UI framework for the web is a massive ask but the goal is to make it feel as native as possible.
I've solved ARIA compliance problem, there's semantic tree by default but customisable. With brotli, the actual page is quite small, the demo pages are all under 100kb. The other bits such as the runtime and font assets are download once, cached forever.
It uses yoga, harfbuzz, ICU, skia for responsive UI, proper text formatting, shapes and shapes of modern UI, and comes with ICU data for all languages including Chinese Japanese and Korean. It also supports font tofu swapping, which is when you haven't loaded a font for a language but your user pasted some text in that language in text input/area.
Plenty more problems I've already solved which typically is canvas apps' biggest setbacks.
There are a few I have yet to implement, such as rendering a shadow DOM for pure Dev tool debugging purposes. Most likely it'll be opt in under Dev mode.
Other things like long press gesture and pinch to zoom are not done either.
I'm working on immediate more custom drawing as well as drawing text onto both immediate mode and memory bitmap canvases (yes canvas inside HTML canvas).
Maybe there's no point for such a thing any more these days when everyone can simply hackle AI to do things adhoc. But maybe someone out there still appreciates some good old engineering.

value: Show HN: WPF grade canvas UI framework for the web

author: zionsati


value: ElementMerc

value: Show HN: Stegcore – steganography and steganalysis in one Rust binary

author: ElementMerc


value: warisareshi

value:
I made a typescript sdk for hinge.
It supports recommendations, profiles, likes, chat, sessions, proxies, etc.
program the dating market guys :)

value: Show HN: [[[hinge-ts]]] I reverse engineered Hinge's API

author: warisareshi


value: A typing game that runs entirely in your terminal - no GUI. Words fall from the top and you type them before they reach the water line, or die.

value: Show HN: TermType – a terminal typing game where words fall like Space Invaders


value: pakosteve

value:
I wanted a page that shows upcoming match times in my local timezone without spoiling the results, plus an at-a-glance view of how the groups are shaping up.
So, as a tester, I - obviously - used my test management app's skin for it :D

value: Show HN: I made a spoiler-free World Cup tracker with a Test Management skin

author: pakosteve


value:
Hi HN, for the past few months, we’ve been working on Ferrix AI (https://ferrix.ai/)
As AI agents speed up engineering, deciding what to build has become the bottleneck. Developers got faster because agents fit into their workflow: tech design, code review, testing. They still make the key decisions, while AI handles mechanical work around them.
At Ferrix, we are automating workflow for product managers to make product decisions efficiently. Agents handle the research synthesis, spec writing, and progress tracking, while PMs, designers, and engineers collaborate in a shared workflow.
Ferrix AI is live, and you can start free → https://app.ferrix.ai/

value: Show HN: Ferrix AI – Agentic Product Management Platform


value:
We’re building Hextrap (https://hextrap.com/products/firewall/), a package firewall to make it easier for teams and organizations to govern the packages installed from their favorite NPM, PyPI, Go, and Rust registries using managed allow/deny lists, custom OPA policies, and built-in safeguards like soak time (new versions are quarantined for a configurable amount of time - most malicious packages are discovered within 48h) and typosquatting detection. Every `pip install`, `npm install`, and `go get` is proxied through Hextrap and evaluated against a target firewall.
Hextrap is designed to work with LLMs (via MCP) so tools like Claude Code will check if a package is allow-listed before downloading or adding it to a project (in addition to using the proxy at install time). This bridges the gap between Claude’s planning and execution phases and creates a more collaborative experience with the developer when libraries are being chosen (i.e. pyramid is not allow-listed, should I try Django or Flask instead?)
In addition to the above, security data and package metadata is made available to OPA so teams can use the extra information to craft their own custom Rego policies (i.e. package must have had at least n commits in the past 6 months, have at least 1,000 stars, and a Hextrap security score above 75). We pull in data directly from the public registries and generate security signals that help identify version-level threats within packages.
You can try it out without signing up or giving us an email address here: https://hextrap.com/try
We’re actively building this product and are curious what the HN crowd thinks about the proxy-approach, the MCP integration point, and whether OPA was the right choice for policy as code.

value: Show HN: Hextrap – Package Firewall with OPA Policies and MCP Support


value: EternalRights

value: Show HN: Agenthatch – Compile any skill into a standalone Python agent

author: EternalRights


value:
A first-person Nürburgring driving game that runs in the browser. It leans arcade — keyboard/touch with assists, not a hardcore sim — but the parts I cared most about are the physics and the sound.
I like racing games with realistic engine behavior, but sometimes I just want a quick drive and can't find a good fit. I love slowroads.io — I wanted something similar but built around race track, so I made this.
Physics: a 240 Hz rigid body with raycast suspension, combined-slip tires, a clutch launch model, and aero/weather grip — none of it from a game engine. The five cars (Elantra N, 992 GT3 / GT3 RS, a kart, an F1 car) are tuned to their real 0–100 and top speed.
Sound is synthesized rather than using recorded one — the engine runs in an AudioWorklet, tuned per car against spectrograms of real onboard recordings. The track is real OpenStreetMap geometry with SRTM elevation.
The initial version of the code was written by Fable 5, then tuned afterward.
github: https://github.com/esc5221/drive-game

value: Show HN: Web-based Nürburgring driving game – custom physics, synthesized sound


value: Show HN: A knowledge graph of 15,941 math states – proof as path-finding


value: Smbugua

value: Show HN: Transcribez,Transcription for Kenyan English and Swahili

author: Smbugua


value: upmostly

value:
Hey HN,
I'm Jay, co-creator of Mira. An open-source, self-hosted AI code reviewer where you BYOK (bring your own key).
Local models are getting really good.
Hosted frontier models are getting really expensive.
So, we built Mira. Mira has some snazzy features too:
- It's really fast at reviewing. Average is 77s compared with Greptile's 5 minutes. Your PRs aren't going into a queue on a cloud somewhere.
- Mira performs a blast radius and see what damage will be done with code change.
- Learns your codebase's patterns from the repo itself and enforces them without a config file.
- It's self-hosted, so your code never leaves your infrastructure. Bring your own model - OpenAI, Anthropic, or a local LLM behind your firewall.
We're really active, and looking for active contributors. Come join us in our discord!
https://github.com/miracodeai/mira
Thanks,
Jay

value: Show HN: Mira – Open-source and self-hosted AI code reviewer

author: upmostly


value: AkshatVirmani

value: Show HN: A tool that scores your OpenAPI spec for test-generation readiness

author: AkshatVirmani


value: undivisible

value:
Alpenglow is a general-purpose (focused on appliance use right now) Linux distribution focused on fast boot times, small system size, and minimal runtime overhead.
The project supports both traditional root-on-disk installations and diskless immutable deployments from the same codebase. In diskless mode the entire system runs from an initramfs with a read-only root and optional persistent state. In rootfs mode it behaves like a conventional Linux installation with package management and writable storage.
Alpenglow uses a musl-based userspace, dinit service management, Linux 7.0 (with Rust modules now that it's stable!), and a lightweight package manager called Oil. The system is designed around a small set of components with an emphasis on predictable startup performance and low resource usage.
Current platform support includes x86_64, aarch64, riscv, and experimental RK3566 targets.
Current benchmarks show boot-to-login times of approximately 0.6 seconds in the minimal configuration and 1.3 seconds in the standard configuration on native virtualization platforms.
The project is still under active development. APIs, tooling, package management, deployment workflows, and platform support continue to evolve, and some functionality remains experimental.

value: Show HN: Alpenglow, a Linux distribution that boots to login in 0.6s

author: undivisible


value: Show HN: LinguaX – a native macOS mouse enhancer (Logi Options+ alternative)


value: sigmaml

value: "GRID" (Gaps, Risks, Inconsistencies, Discrepancies) is a small framework that I developed over time for my spec-driven development using coding agents.

value: Show HN: "Grid" – a spec-driven framework for coding agents

author: sigmaml


value: oraziorillo

value: Show HN: Microcrad – Micrograd Reimplemented in C

author: oraziorillo


value: axfab

value: Show HN: Pocket DB – a single-file append-only document store for Node.js

author: axfab


value:
I built a wiki where you can set the current reading location (book + chapter) and articles get automatically truncated to only show information revealed up to that point. The problem with existing wikis was (for me, at least) that they would spoil complete character arcs already in the first few sentences of an article, basically making it impossible to look up any information before finishing an entire series. For something like the 14-book Wheel of Time series with literally thousands of characters, this is really painful. Especially if you're listening to the audiobooks, spread across months, it's really hard to keep track of all the names and places. There have been only a few attempts of spoiler-safe wikis before, such as Spliki (recently discontinued) and Coppermind (which is really great, but Sanderson-only).
Thulr is still a work in progress. I've only got a single series on there so far, Fourth Wing/Empyrean, which is much less complex than e.g. Wheel of Time. I think the current pipeline won't automatically scale up to those more extreme cases, so I'm trying to only slowly increase the complexity of series that I'm adding. It also currently only supports one clear timeline, so I'm not entirely sure yet how to handle the case where you've got non-obvious reading-orders or auxiliary books (such as having one wiki for all of the Tolkien/Middle-earth books).
My current implementation partially uses LLMs. I built a multi-step pipeline that collects chapter-level information on different entities and then aggregates that into final article candidates. This still needs a ton of manual back-and-forth for quality-control and editing. I want articles to incrementally reveal more information (as opposed to: rewrite the full article on each new time horizon), which makes the amount of text manageable, but can lead to awkward prose at times. E.g., name reveals or character identity collapses (think: Voldemort & Tom Riddle in Chamber of Secrets) can't be spoilered in an article at an early time horizon, but those paragraphs need to stay in the article even at a late time horizon. I'm still trying to find better approaches for this.
Any feedback or ideas on the UX (I'm very new to this) and data processing would be great.

value: Show HN: Thulr – a spoiler-free wiki for fantasy and sci-fi novels


value: luca-ctx

value: Show HN: ctx, a hackable desktop workbench for coding agents

author: luca-ctx


value:
AutomatiQ is an Open-Source Reverse-Engineering AI Agent, that can write requests-based(no browser) automation/scraper scripts on its own, all we have to do is, to normally browse the website once.
This makes it a lot easier to create/fix scripts, all we have to is browse the site. This is not a completely autonomous agent, you can pause, talk, guide the agent on its RE path, just like a normal agent.
I am aware of the limitations of this approach, but from my own research(please refer the blog for details) up to 60%-90% of websites can be automated/scraped with just requests.
I was able to run this against some popular websites like, bookmyshow, makemytrip. And to test it in the open, it one-shotted scraper solutions for 2 problems posted on r/webscraping.
It supports local models, cloud hosted models, and proprietary models.
Github: https://github.com/StoneSteel27/AutomatiQ
Blog for verbose explanation and techincal implementation: https://shiny-sushi-116.notion.site/automatiq
Demo video of using Automatiq on bookmyshow website to get current running movies, showtimes, seat layout of a particular screen to create an interactive script: https://www.youtube.com/watch?v=OfMvAQP5pkM
Thanks for your time, hope you have a great day/night ahead ;)

value: Show HN: AutomatiQ – Reverse-Engineering Agent for the Web


value: dhavalt

value:
I built AptSelect to stop writing throwaway scripts every time I needed to test how different LLMs handle specific instructions and prompt edge cases.
What it does:
Parallel Execution: Send a single prompt to OpenAI, Anthropic, Mistral, and Gemini simultaneously. Compare the outputs, latency, and exact token usage side-by-side.
Batch Evaluations: Upload a CSV dataset to run bulk tests across multiple models at once.
Manual Diagnostics: Grade outputs manually (Pass/Fail) and assign diagnostic tags (e.g., Hallucination, Format Error) to build a human-verified performance leaderboard.
Local-first: API keys encrypted with your OS keyring; history stored in a local SQLite DB; no telemetry.
I’m looking for technical feedback. What do you think current LLM testing/evaluation tools get most wrong?

value: Show HN: AptSelect – A local LLM client for parallel testing and evaluation

author: dhavalt


value: itransbook

value: ITransBook is a Local-first AI translator. 100% private – your documents never leave your device. Translate PDF, Word, PPT. Supports LocalAI + cloud APIs.

value: Show HN: ITransBook,a Local-First AI Document Translation Tool

author: itransbook


value: astrochicken

value:
Self-hosted RSS reader. Take a look. Enjoy.
Demo: https://brandonhon.github.io/ember

value: Show HN: Ember – self-hosted RSS reader in a single Go binary, AI is optional

author: astrochicken


value: shashanoid

value: Show HN: Analog military plane spotter as a new tab extension

author: shashanoid


value:
Pantheon is a technique for generating each subagent, generating codes with different solutions, deciphering them and writing codes that ultimately survive.
For Pantheon-X, GPT 5.5 is broken, GPT is broken and surviving is the last skill to write code written by Claude.
For Pantheon-gap, it's a review skill that keeps checking if the actual review is true and determines whether it's a real error or not.
In the case of Pantheon-gap-x, GPT 5.5 is a skill that performs better by cross-checking and determining whether the error is real or not.
I'd appreciate it if you could actually use it and give me feedback through the problem

value: Show HN: Code and reviews that only count if they survive an attack


value: eugenioenko

value: Show HN: TTT – A terminal IDE with standard keybindings, no modal editing

author: eugenioenko


value: rofko

value: Show HN: Quake ported to 3D CSS (no WebGL)

author: rofko


value:
Hi HN, I built agentspace because I kept seeing tmux recommended for keeping Claude Code sessions alive over SSH. I find multiplexers painful because they subtly change shell behavior in ways I always forget. They also do not offer a standardized way to run highly permissive agents in a safe way. I also tried worktrees, but it just feels awkward to manage work in that way.
Docker can help with all of this, so I thought up a workflow and used some shell aliases to automate spawning Claude/Codex agents into docker containers. I ended up creating a cli to wrap all these methods and would like to share it.
The problems agentspace is solving:
- You can run many tasks in parallel all working on their isolated copy of the code.
- No death by tapping y. You work on an isolated copy of your code in a fairly safe environment always so it becomes easy to get out of the way and just let the agent do its thing without potentially compromising your machine. Agents spawned by agentspace run containerized in yolo mode by default.
- No multiplexers. I have never had a use case for them so I am not used to them at all. The container is just a normal shell. Detach with Ctrl-P Ctrl-Q (standard Docker), reattach with `agentspace my-task attach`. No new muscle memory required.
- No git worktrees either. All approaches using this to run parallel agents just never stuck with me.
- Sessions typically die on SSH disconnect. Containers always keep running. Reconnect whenever you want.
I am now using this daily for running my agent sessions both on my own machine as well as on a remote VM.
Features:
- Spawn many agents which all run in parallel and work on their own code by mounting a volume to a docker container
- Preview results with a dedicated preview command which launches a container attached to the same volume so you can preview changes in real time
- Docker support inside the container via a docker-in-docker sidecar (Please note: `--docker` uses `--privileged` under the hood (required for DinD), so it's not a sandbox against actively hostile code. Use it for repos you'd trust on your machine anyway.)
- You handle the git commit, push etc. cycle so you stay in control of what goes into your repo. This is enforced at the image level via `PreToolUse` hooks for Claude Code and exec policy rules for Codex, so it holds even under `--dangerously-skip-permissions`. I don't like agents running changes for me, so I want to be in control here
Once pushed, it's just a normal branch so you can merge it through your usual PR flow. It does require a git remote though at the moment as this is the only way to get the work out of the container via the agentspace cli (of course you can use any direct docker command as well).
Current limitations:
- Base image is `node:24-slim`. Node/TypeScript works out of the box, other runtimes need you to extend the image yourself (You can create your own Dockerfile from agentspace and point `AGENTSPACE_IMAGE` at it). I am planning to just include more languages and runtimes in the agentspace base container as well, but so far this works for me.
- Supports Claude Code and Codex today. I would like to support Opencode and Pi later
- Windows unverified (should work as this project basically only needs node, git and docker, but it hasn't been tested)
- Some parts lightly tested or untested. I basically built it last week to scratch my own itch. It has some rough edges for sure. Very curious to get other experiences.

value: Show HN: Agentspace – long-running YOLO agent sessions in Docker


value: RiverXR

value: Show HN: Infinite – query your GA4/Stripe/PostHog data locally, on your machine

author: RiverXR


value: michaeljnatkin

value: I love dosa, but have a hard time remembbering what all of the terms mean and how they fit together. "Mysore masala paper roast" is just a stack of independent choices: batter, texture, a smear, a filling, and the word dosa. So I built a little tool that treats every dosa name as a formula. You build an order and see what would arrive, or tap a real menu item and watch its formula light up.<p>I tried to (with Claude's help, obv.) cover naming conventions from Bengaluru, Chennai, and Hyderabad. And, full disclosure, I'm an outsider to this cuisine who just loves food, so there's every possibility I've got mistakes in there, and I'm certainly missing some great dosas. Feedback and corrections are very welcome!

value: Show HN: How to Read a Dosa Menu

author: michaeljnatkin

title: Show HN: How to Read a Dosa Menu


value: jputney

value: Show HN: Ratchet – CDI-native persistent job scheduler for Jakarta EE

author: jputney


value: jackxlau

value: Show HN: FusionHarness – An Open-source Mixture-of-Agents compound-model server

author: jackxlau


value: corvj

value: Show HN: Tyto – find where audio breaks your voice-agent calls

author: corvj


value: nocodeg

value:
Hey all, remember back when the internet was fun?
Before the days of information overload and AI slop.
Back when sites were recommended by close friends instead of an algorithm.
I miss that.
And I’m trying to bring some of that magic back.
So I've built Stumble Again.
It's inspired by the OG StumbleUpon, and it’s a place where you can rediscover the internet with a curated selection of hand-picked websites, apps, and hidden gems from the depths of the internet.
Check it out and let me know what you think?
P.s. Would love to hear your recs for sites to be added. Drop a comment with your top picks?

value: Show HN: StumbleUpon Is Back (Kinda)

author: nocodeg

title: Show HN: StumbleUpon Is Back (Kinda)


value: smashini

value: Show HN: Stop your AI agents from approving their own work

author: smashini


value: Show HN: Artifacta – Durable storage for agent outputs


value: ldelossa

value:
Hello folks.
Like a lot of great software, we built OctoPunk out of frustration.
We are a set of developers who, for one reason or another, have been using GitHub as our primary code forge for professional work for a very long time.
We've seen GitHub grow, stagnate, ignore feature requests, and simply never produce a full-featured desktop client.
Finally, we had enough, decided to build our own, and OctoPunk was born.
OctoPunk is not a git GUI wrapper like GitKraken, not a half-implemented desktop client like GitHub's official client, which doesn't support code review, and not something that ignores complete workflows like per-commit reviews, looking at you, VS Code extension (https://github.com/microsoft/vscode-pull-request-github/issu...).
OctoPunk is a full-featured GitHub client that surfaces 95% of GitHub's functionality as a desktop client, presented through a UI and UX that feels instantly familiar to modern editors and developer tools. We provide a customizable dashboard, quick search widgets, desktop notifications, and even an AI assistant that optionally understands what you're looking at and can help explain comments, draft responses, and more.
OctoPunk got its name not just from the software we are building, but from the mentality of the company. We are a tiny team that doesn't subscribe to big tech practices. We plan on staying small, independent, and nimble.
Anyway, if you're looking for a desktop-native and productivity-focused GitHub client, give us a try.
We are currently in beta and looking for feedback, feature requests, and bug reports, all of which can be conveniently sent from within OctoPunk itself.
All of OctoPunk is free for public repositories and requires a subscription for private ones. That's our only monetization model: no dark patterns, no data harvesting, and we promise to always keep it simple.
Learn more about us and how to download the beta here: https://www.octopunk.io/blog/introducing-octopunk
Interact with our community here: https://github.com/octopunkio/community

value: Show HN: OctoPunk – a full-featured, AI-integrated GitHub client

author: ldelossa


value: spalas

value:
Deputies is a background agent platform like Ramp's Inspect or Stripe's minions, but open source and deployable anywhere.
I launched it a few weeks ago, and have since added a public demo instance at https://demo.deputies.dev/ that people can use to try it out!
Any GitHub account can sign in via oauth.
NOTE: This is a public instance, so others will be able to see the sessions you create.

value: Show HN: Deputies (open-source background agent control plane)

author: spalas


value: DrWiseguy

value: Show HN: TrendHawk – AI pipeline that finds ideas from 25 subreddits HN doesn't

author: DrWiseguy


value: reuven

value:
I've created an in-browser Python/Pandas/Git practice environment for my online learning platform and also for my corporate training classes. I'd be happy to discuss how I went about designing this, how I'm using it in my classes, and the architectural decisions I've made.
Most interesting, to me, is how much is running in the browser. Thanks to Svelte, Pyodide, isomorphic-git, LightningFS, and CodeMirror I'm able to provide a full environment for Python, Pandas, and Git.
I built much of this with Claude Code, and I'm happy to discuss how that went — what worked well and where I had to step in and make the calls myself.
I'm especially excited about the Git simulator: it shows the commit tree change as you run commands, plus an animated view of how files move between the working tree, the staging area, and HEAD.
The AI tutor, which uses Claude Haiku, was given my newsletters, classes, and exercises as inputs, along with a description of my pedagogical approach: instructors should give hints and feedback, but not reveal the answer.

value: Show HN: In-browser Python/Pandas/Git practice with animated Git simulator

author: reuven


value: wmolino

value: Show HN: Regentix – Block destructive MCP tool execution using Rego

author: wmolino


value: mlbenchdev

value: Show HN: Project Huginn – cheaper AI training on idle GPUs

author: mlbenchdev


value: elbazia

value: Show HN: Smooth.video – animate your content, slide by slide, free

author: elbazia


value:
Hi, Im Oscar. So I built Bacon cos like many of you ,I spend a lot of time staring at my terminal(s) waiting for claude code to finish.
But first, shout out to Andrew McCalip (@andrewmccalip) who built kickbacks.ai. He came up with the spinner ad and revenue share model, but as a VS code extension. But tbh Id rather not use VS code, so i built the terminal native version as a personal challenge.
So Bacon does that, it shows you ads on claude code. There are five surfaces, from least to most intrusive: spinner, statusline, strip, card, and marquee. When an ad shows up, you get a 50% cut of whatever the advertiser paid for that slot.
I built in a few hard constraints. Every surface shares one rule: the " Sponsored" marker ships with the slot. Also, the server sets the price, not the advertiser. Your 50% cut is a floor, not a bid, and neither side can move that number. So Im kinda trying to build a economic system to bridge both supply and demand and favor the most favorable ads for the devs.
And about privacy, your prompts and your code stay with you, if you choose the config to share about the intent of your sessions, we will collect tags about the intents like: "auth", "database" or whatever you are building. I also considered the loops and bots situation, so I made a 4 layer detection system to identify those weird patterns and included a 72hr hold before the payouts clear.
I literally just build this last weekend, and Im trying to solve the chicken and egg problem of being a 2 sided marketplace, so any advice on how to grow this will be vastly welcomed. And full disclosure, this isn't a get rich scheme out of claude, its just found extra money for time you already are spending at claude code anyways.
I genuinely want feedback on the trust/privacy model and the auction mechanics. Im doing my best to balance it so its fair enough for everyone. I honestly dont mind this kind of non intrusive ads, unlike those of youtube or twitch, but I also want to hear if others also don't mind em. Or wether its viable to have better targeted ads with the intents of what people are doing. Also as soon as i get time Im considering driving into the agentic part to check i can manage to have agents to go into a bid war for the ads lol.
And ofc i hope this is not a speedrun to get me banned on claude.
Try it: npx @geturbacon/wizard@latest

value: Show HN: Bacon – an ad network that pays developers while their Claude works


value: zarldev

value: Show HN: Zkit – Go libraries for building agents, not a framework

author: zarldev


value: shpran

value: crunchbase is $49 which is honestly too much if your not an actual angel or VC, as a result I decided to make this site, I use custom built agent pipelines to cross reference public sources, then I write and review the profiles and publish them to the site. Right now Ive only made a few profiles, and I'm hoping to get feedback on whether or not people would be interested in me releasing more.

value: Show HN: A Free Crunchbase Alternative

author: shpran

title: Show HN: A Free Crunchbase Alternative


value:
Hi HN!
We are building Cy, an AI coworker that runs inside Slack. Cy works like any teammate in slack. Except he is really good and always on. @Cy and he will do anything from simple research tasks to complete workflows like outbound, ad operations, analytics deep dives and suggestions, hiring and much more.
This is giving everyone on the team access to a super capable agent without dealing with CLI complexities and security issues. As it's a team agent it also keeps context accross different functions and threads and can ensure everyone is aligned. Connections, skills and routines are all observable and we tuned Cy to be super smooth in creating and editing them.
We have been using Cy internally at Neon Blue for sales, engineering support, growth analysis, experiment reporting, outbound ops, research, content, and small internal apps. It's completely changed how we work so thought we would share it with everyone here.
Try it here: https://www.neonblue.ai/

value: Show HN: Show HN: Cy. An AI coworker that works from Slack


value: Myxir

value:
I've been working on a scikit-learn compatible Self Organizing Map (dbgsom).
I started this project when I learned programming and machine learning at university. Recently I did some benchmarks at it actually does really well against other scikit learn Estimators. It can be used for clustering, classification, visualization and non linear projection in two dimensions.
Might be interesting for a broader Data science audience?
Install:

  pip install dbgsom

Example:

    from dbgsom import SomClassifier
    from sklearn.datasets import load_digits

    X, y = load_digits(return_X_y=True)

    clf = SomClassifier(sigma_end=1, lambda_=30, random_state=42)
    labels = clf.fit(X, y).predict(X)

    print(f"Neurons: {len(clf.neurons_)}")
    print(f"Quantization error: {clf.quantization_error_:.4f}")
    print(f"Topographic error: {clf.topographic_error_:.4f}")
    print(f"Accuracy: {clf.score(X, y):.4f}")

  > > Neurons: 92
  > > Quantization error: 20.8655
  > > Topographic error:  0.0267
  > > Accuracy: 0.9416

Github contains more examples and comparisons against scikit-learn (Clustering/Classifiers/Projection) and other SOMs.
Let me know what you think!

value: Show HN: Dbgsom: A scikit-learn compatible Self-organizing Map

author: Myxir


value: kgodey

value:
Hi HN!
We just shipped the public beta of the hosted version of Mathesar, our open source “intuitive spreadsheet UI, full PostgreSQL power” project.
Until now, using Mathesar meant installing and running it yourself. Now you can use Mathesar for free without having to maintain your own infrastructure at https://mathesar.cloud.
Mathesar Cloud is run by the Mathesar maintainers through the 501(c)(3) nonprofit that already maintains the open source project. We’re committed to ALWAYS keeping Mathesar 100% open source (no open core), nonprofit, and treat self-hosting as a first-class citizen. We’re launching a hosted service in part to sustain the project in the long term while keeping our principles. We’re also excited to be making Mathesar accessible to users who cannot or do not want to self-host.
Currently, we have a free plan that’s great for solo projects, prototyping, and evaluating Mathesar for larger deployments. It’s scoped to a single database per user.
We are using this early beta to learn what people need, as we work on launching more plans with feature parity with self-hosted Mathesar, including collaboration, control over Postgres roles and permissions, and connecting existing databases.
I'd love your feedback on Mathesar in general, the Cloud version, or anything else!
MORE ABOUT MATHESAR:
Mathesar is a 100% open source project (we just got to 5000 stars!) that gives users a spreadsheet-like interface to PostgreSQL databases. You can connect an existing database or start a new one from scratch, it works the same either way. We aim for the UI to be familiar and intuitive for non-technical users while also using the full power of PostgreSQL without intermediate layers or abstractions. For example, our permissions system uses PostgreSQL roles and permissions directly.
LINKS:
- GitHub: https://github.com/mathesar-foundation/mathesar
- Mathesar Cloud: https://mathesar.cloud
- Announcement blog post: https://mathesar.org/blog/2026/06/17/announcing-mathesar-clo...

value: Show HN: Hosted version of Mathesar, intuitive open source UI built on Postgres

author: kgodey


value: its-a-new-world

value:
Hey HN,
I created an MCP server aimed at giving LLM agents safe access to a database. It's part of the broader Polymr platform (https://polymr-platform.github.io/).
I generally allow the LLM to perform selects as it wishes to establish context, but once it comes down to modifying data, especially in a sensitive environment, I want to retain absolute control and understanding of what it's trying to do.
That's why I built mcp-sql.
Some of the features:
- DML Previews: Queries can be run in preview mode where the server executes the transaction and immediately rolls it back. This lets you see exactly what will happen if you allow the change.
- Dynamic Permission Prompts: The server dynamically introspects SQL to determine required permissions. If an agent tries to execute a query it doesn't have auto-approval for, it prompts the user. You retain full control over the agent's autonomy level.
- Environment Routing: You can use policies to dynamically switch the connection a query is run on, allowing you to easily switch between environments.
I'd love feedback, especially from people using MCP servers with production databases.

value: Show HN: Safe database access for AI agents

author: its-a-new-world


value: srmcguirt

value: Show HN: Aihu – durable Web Components an AI agent can drive (full WC framework)

author: srmcguirt


value: alevizio

value: Show HN: I matched 650k SF parking tickets to the block each was written on

author: alevizio


value: perryraskin

value: Show HN: Upfile – Open-Source File Upload CLI, for Both Agents and Humans

author: perryraskin


value: museumkeeper

value: Show HN: I made a paid guestbook for the internet

author: museumkeeper


value: tchauffi

value:
Hi HN!
I build this project to explore an idea I got in mind for a long time : Is transformer a suitable architecture for a chess bot? I built a small model (11M parameters) and trained it on human games (Elite Lichess DB).
Model alone is performing around 1500 elo, but I built an harness using Monte Carlos Tree Search (MCTS) using my model heuristics to improve the model to ~2100 elo (evaluated against stockfish).
If you want to try it, it is available as a Lichess bot : https://lichess.org/@/ChessTransformerBot
I'm looking to evaluate this model against human players so challenge, I would be grateful if you try it!
The project is open source, don't hesitate to star the repos if you like the project.
For me, the main key learning is that machine learning is an important part of the project, but it was the harness design that makes the system works with a nice performance regarding the small model size.

value: Show HN: Chess bot based on the transformer architecture

author: tchauffi


value:
Hi HN,
I spent the last few months reading the RISC‑V specification to build the lightest possible sandboxes. The idea behind a vpod is to quickly spin up a Linux sandbox from snapshots (Alpine by default) without any setup or subsystem required.
The trade-off for portability and security is raw CPU speed. So we don't expect it to match native workloads with Python or pip, for example.
More info is in the README
https://github.com/capsulerun/vpod
Happy to answer any questions!

value: Show HN: Vpod – Tiny Linux sandbox running in WASM


value: xmorse

value: Show HN: The full Minecraft game as an embeddable Framer component

author: xmorse


value: brownrout

value:
Hey HN, I built a website to watch live baseball games in an 8-bit broadcast. It takes live MLB data streams and converts them into near real-time pixel art gamecasts.
Been waiting to share this for when there’s actually a good slate of games happening since the site is pretty bare otherwise.
Here is today's schedule:
Mets @ Reds - 9:40am PDT
https://ribbie.tv/watch/game/824503
Royals @ Nationals - 10:05am PDT
https://ribbie.tv/watch/game/822721
Marlins @ Phillies - 10:05am PDT
https://ribbie.tv/watch/game/823450
Tigers @ Astros - 11:10am PDT
https://ribbie.tv/watch/game/824178
Padres @ Cardinals - 11:15am PDT
https://ribbie.tv/watch/game/823044
..and another 14 games throughout the later day.
I'm still early on in this project, but I've tried to add little details with actual stadiums, day and night modes, between inning graphics and interstitials, live scoreboards, etc.
Would love any feedback and ideas. Thanks for checking it out!

value: Show HN: An 8-bit live gamecast for baseball

author: brownrout


value: fachkamera

value:
I built my own reader mode because no existing solution had what I wanted:
A reading experience similar to an ebook reader, with a minimal opinionated UI, open source and privacy-respecting. I was actually shocked how many extensions request full network and tab access.
This has been my first time developing a browser extension.
In a perfect world with semantic clean markup everywhere the process of reformatting a website into a reader interface would be quite easy, but real world HTML can be really messy. Simply passing the DOM to @mozilla/readability (the engine Firefox uses for its reader view) was not sufficient. While it does a good job at identifying the main article, normalizing HTML and removing junk like widgets within it needs additional heuristics. So I built a custom pipeline of pre- and postprocessing steps around it and tested on as many websites as possible.
An interesting challenge has been how to get around CORS and CSP limitations by the host page. Some of the solutions I came up with are outlined on my blog post linked below.
Features I'm considering to add in a future release:
- one-click send to device for Kindle/Kobo etc.
- High quality Text-to-Speech
- Firefox/Edge/Safari release
github: https://github.com/fachkamera/booklike
blog post: https://mayermarkus.net/building-booklike

value: Show HN: BookLike – Chrome reader mode with eBook-style page flips

author: fachkamera


value: mantyx

value: Show HN: Mantyx – Batteries included managed agent runtime

author: mantyx


value: kachoio

value: Show HN: A free dataset, Polymarket's 5-minute crypto markets, second-by-second

author: kachoio


value: pwbgerrits

value:
I built this tool for myself, and the URL in this post points to it. I needed a secure way to store my environment variables because I work on many projects across multiple devices. Keeping each variable up‑to‑date on every device was a constant hassle.
Now everything lives in a local file that I can pull and push with a simple CLI command. I never have to think about it again.
The tool is also useful when you’re hiring freelancers who need access to staging or local environment variables for testing. Instead of handing over an entire .env file, only to have it linger for months and expose keys and passwords, you can share just the specific file or variable you want (e.g., only the database URL, not the password). When you need to rotate or change anything, press the sync button and the tool updates all environments automatically.
I use it daily and rarely log in just to edit a variable or .env key; a single click does the job.
If you work with multiple projects, devices, or freelancers, give it a try. I spent a lot of time securing and encrypting the secrets so they can’t be leaked. I’d love to hear your feedback.

value: Show HN: Save and store you .env vars

author: pwbgerrits

title: Show HN: Save and store you .env vars


value: Fotis-Karmpas

value: Show HN: A Claude built link page with an integrated reward wall

author: Fotis-Karmpas


value: jpsdtj

value: Show HN: Raise(fn) – fundraising intelligence YC keeps to itself

author: jpsdtj


value:
Hey HN,
There’s been a lot of interest recently in meta-harnesses, loops, and multi-agent orchestration. Obviously, there are already a lot of good tools: Conductor, cmux, the native Codex / Claude Code apps, etc.
For my own use cases, I’ve felt that the orchestration layer tends to feel overengineered. I mostly wanted a simple local harness (i.e Pi) for running and tracking CLI agents with the ability to hop in (via tmux). Relaymux is my opinionated attempt at that.
A few design principles:
- The frontend is just Telegram / iMessage / CLI. If I want more visibility, I hop into tmux.
- Subagents are normal interactive CLI agents running in tmux windows, usually with their own worktrees.
- The harness owns the tmux session, so each longer task becomes a named tab/window. Subagents report back to the orchestrator via CLI when they’re blocked or done. Then the orchestrator just messages me on Telegram / iMessage
- It works with any CLI agent that has an interactive terminal mode, so I don’t need special print-mode/non-interactive support. This means I don’t need to stress about the Agent SDK / claude -p billing limitations.

value: Show HN: Relaymux, a tmux-based meta-harness for local coding agents


value: LuxBennu

value: Show HN: CtxGov – drop in AI memory files, get an influence-boundary report

author: LuxBennu


value: AuthPlane

value: Show HN: AuthPlane – OAuth 2.1 and PKCE authorization server for MCP

author: AuthPlane


value: douglaswlance

value: Show HN: Tmppr – local PR review for AI coding agents

author: douglaswlance


value: ekduman

value: Show HN: Minecraft AI Agent for mods and server management

author: ekduman


value: sawyerjhood

value: Show HN: bb, an agentic IDE that can control itself

author: sawyerjhood


value: joshdappier

value: Show HN: Our Claude Code Plugin Routes Lightweight AI Tasks to Specialized SLMs

author: joshdappier


value: Show HN: Live-updating, information-dense World Cup dashboard and simulator


value: strctrd

value: Show HN: EVMist – Client-side builder for custom persistent EVM dashboards

author: strctrd


value: kossisoroyce

value: Show HN: 10k harmonized time-series datasets of African data

author: kossisoroyce


value: grzracz

value: Show HN: Cotect – a fast code inspector for agent era (open source)

author: grzracz


value: mikepapadim

value: Show HN: MizAI LLM detection of price anomalies in public procurement for Greece

author: mikepapadim


value: visioninmyblood

value:
Rather than calling tools one by one, Orion 2 generates a program and runs it end to end, meaning fewer round-trips and lower latency. You can try it out at https://chat.vlm.run
When orchestration is code, every workflow is composable, inspectable, and deterministic.
We put together a short Orion 2 demo video: https://www.youtube.com/watch?v=rzhXcNAYQ-0

value: Show HN: Visual Agents with Code Mode

author: visioninmyblood

title: Show HN: Visual Agents with Code Mode


value: yadongwen

value: Show HN: A locally hosted version of Google's internal SnipIt tool

author: yadongwen


value: oabolade

value:
I have running into the same problems recently instrumenting my LangChain and CrewAI agent pipelines. If something goes wrong with a tool call, there was no way to way to prove what the agent did, in what order, and whether the logs have been modified. Observability platforms like LangSmith and Langfuse are great at optimizing for agent behavior, tokens and costs but they do not produce legally defensible and auditable artifacts. That's the reason why I decided to build RootSign, an SDK that instruments your CrewAI and LangGraph agents and produces cryptograhic audit logs for CrewAI and LangGraph agents.
RootSign adds a cryptographic hash chain to every tool call.
If any record is modified after the fact, "rootsign verify" detects it.
What it does:
- SHA-256 hash chain across every Action record in a session
- Human-in-the-loop checkpoints with Approval records for certain agent actions
- PII redacted before hashing (StandardPIIConfig out of the box)
- Works with LangGraph and CrewAI — AutoGen coming soon
- Local first (Postgres + Timescale) — no cloud dependency
What it doesn't do (yet): compliance dashboard, cloud backend, policy engine, all on the roadmap.
Please try it out on the Github repo, contributions and feedback are always welcome.

value: Show HN: Tamper evident audit logs for LangGraph/CrewAI agents

author: oabolade


value: tamnd

value: Show HN: Yomi – Read any web page, or a whole website, into clean Markdown

author: tamnd


value: Show HN: No-Nonsense Table of FIFA World Cup 2026 Top Scorers and Assist Leaders


value: kedimuzafer

value: Show HN: ReplyVoice – mic overlay that transcribes into any app (Android + PC)

author: kedimuzafer


value: willks

value: Hey HN, I couldn’t find a good way to rank the current LLM models based on the priorities I have for different tasks, so I built my own.<p>You set your own trade-off priorities between fast, cheap, and good by dragging two handles around a pie chart to weight the three priorities, and a ranked table re-sorts live underneath. The data comes from BenchLM, OpenRouter and Artificial Analysis. Hope it's useful.

value: Show HN: Models Pie – LLMs ranked by fast / cheap / good tradeoffs

author: willks


value: Show HN: Learn math as a tour of duty in a Martian Navy


value: Show HN: I turned 250 movies into wormholes


value: andyhedges

value: Show HN: A distributed computing project for finding primes of the form k·2^n−1

author: andyhedges


value: unmodeledtyler

value:
Hey HackerNews!
My name is Tyler and I'm the solo founder of Quanta Intellect.
I'm excited to share an update to Vessel Browser with you today!
You can now either import an existing skill or create a new one in the Skills tab. Then, invoke your skill in agent panel with a "/" command!
Vessel Browser is open source and BYOK, allowing you to bring your existing AI stack with you.
Thanks for checking it out!

value: Show HN: Vessel Browser – Open-Source AI-Native Browser with Skills

author: unmodeledtyler


value: TrustLayerDev

value: Show HN: Leakproof – local secret-egress firewall for Claude Code/Cursor/aider

author: TrustLayerDev


value: Show HN: RealNear – nearby places ranked by quality score, not ads


value: bayshark

value:
Selora AI Local is an open-source, Qwen-based model for Home Assistant.
Specs:
Qwen3 1.7B base model (Q6 quantized~1.6GB)
Four Home Assistant-specific LoRA adapters:
- Answers
- Clarifications
- Automations
- Commands
~3.5 GB total download size
Runs locally via llama.cpp
We chose a Qwen-based architecture because of a paper on Arxiv (link below) which applied a Qwen based model for local LLM configuration, and showed promising results. We took it a step further in application by training LoRA adapters specialized in Home Assistant configuration.
This alpha release ships our base model with four specialist LoRA adapters preloaded for faster response: answers, clarifications, automations, and commands. The Q6 quantized base model is 1.6GB and the adapters are less than 100MB running either on self-hosted llama.cpp, or on Selora Hub devices, where everything is preconfigured and plug-and-play for you.
We started working on this because the existing options for local LLMs in Home Assistant lack knowledge to run anything useful, so users opt for very large LLMs, typically a cloud model that’s too expensive and not optimized for the kind of high-frequency, always-on smart home use we care about. We think there's a need for open-source models that are small and specialized enough to run on the kind of hardware people actually have at home.
Would love any feedback, questions, or ideas. Thanks for checking it out!
Hugging Face: https://huggingface.co/selorahomes/Selora-AI
Arxiv: https://arxiv.org/abs/2502.12923
More details: https://selorahomes.com/selora-ai/

value: Show HN: Selora – local model for Home Assistant

author: bayshark


value: piastresx

value: Show HN: Koala: Cross-Substrate Tactical Representations in Graph-Based Go [pdf]

author: piastresx


value: debarshri

value: Show HN: Cost efficient version control system for Gaming Assets

author: debarshri


value: daxaur

value: When it comes to chess openings I tend to forget some lines in crucial situations mid game. To cure my problem I used a site called chessreps.com for drills and practice. After wanting to explore more lines I came across the paywall behind it, which left me with one option: To build the open-source version myself and finally its here: Tabia.  Tabia at its core is a browser-local, no account, no server chess opening driller where nothing leaves your machine built with chess.js + Stockfish-in-WASM.

value: Show HN: Tabia – The first free, open-source chess opening trainer

author: daxaur


value: punnerud

value: Show HN: ESP32 512kB – Tailscale, English to Python LLM and 8 containers local

author: punnerud


value: zla

value:
Hi ,
I made 'MatrixEngineWgpu' webgpu engine in javascript ("The Beast" i added alias ;) ). Objective is full support for all browsers (with webgpu support) specially mobile browsers. I use vanilla js thats very important in context of performance. 2 years ago it was classic programming (without ai) but i involved ai in last 6 months. Thats not main subject.
I see in last yeasr that quality of web games are catastrophic even in promo videos i see buggy moments. Almost every webGPU examples or graphics+physics are very pure or not runnable on mobile devices.
 Theres also opinion that web can't produce high quality/performance app. Thats not true and that's i wanna to prove.
 My GraphicsCard is 13 years old and thats good when you make optimised stuff.
What is characteristics for "The Beast" in dev zone:

  - Every feature is tested on mobile device and balanced to be on "edge". Must pass mobile render.
  - On linkedin i see every day some new features doned in one of major engines and i imitates/integrate intro project.
  - What ever i can do i avoid ai asking (i keep control under code) also AI never gives BEST solution on begin. I need sometimes 2-3 phases of optimisation. Some optimisations concepts i learned from ai.
  - Usually engines give best quallty - matrix engine is downgraded by default in the name of performance.
  - Must be easy to use

 This is not full list but generally all main featureas are here,

  Done list []

 Draw loop per pipeline not per mesh (PipelineManager) with share material. Power optimisation.
 Support for 3D objects and scene transformations.
 Ammo.js, cannonES, matterJS && Jolt Physics libs integration (app<->bridge<->worker). Physics use webworkers by default.
 Networking with Kurento/OpenVidu/Own middleware Nodejs -> frontend.
 Bloom post processing.
 HZB post processing.
 Scene Culling feature.
 Based on the shadowMapping sample from webgpu-samples.
 Web GUI(online) Editor [app exec graph] with Visual Scripting (Named: FlowCodexVertex).
 Web GUI(online) Editor [shader graph] with Visual Scripting (Named: FlowCodexShader).
 Dynamic shadow cast (done also for skinned meshes).
 VertexShader displacment (done also for skinned meshes), nice for water effect.
 Basic flow for AI Graph Generator - Simple tasks passed for now with ollama platform. Open account/open-source/free-service-quota.
 ProceduralMesh objectScene entity with options for vertex morph - Shadows following morph blend.

 Interest feature :
  - All physics engines runs in worker by default
  - I added visual scripting (app level & shader level)
  - AI tool for generating app graphs

 Source: https://github.com/zlatnaspirala/matrix-engine-wgpu
 Demos: https://maximumroulette.com/apps/webgpu/examples.html

 Enjoy and star if you like it !

value: Show HN: Matrix Engine WGPU – focus on mobile]

author: zla


value: dttdrv

value: Show HN: OptiSYS – an open source Windows optimizer that isn't snake oil

author: dttdrv


value: jpolitzki

value: Show HN: A Universal Matching Engine

author: jpolitzki

title: Show HN: A Universal Matching Engine


value: Show HN: Any Search, One API

title: Show HN: Any Search, One API


value: narenst

value:
Hello HN! I made an iPad app with my seven-year-old daughter to make learning spelling fun.
https://spellabee.com/
We play Spelling Bee type games in our car rides, and she wanted to learn more words that way. So we built a simple app that teaches 10 words at a time, and lets the kids practice and master these 10 words.
The full word list in the app is static, and it gets progressively harder as the kid goes through the levels. There are no AI features in the app. I do not collect emails inside the app or have third party trackers. Based on feedback (reviews) and aggregate usage data I plan on updating the app with new word sets.
Although the app does not have any AI features I used AI to build the app itself. I used Claude to code the app using Flutter, do etymology research, and understand what alternative apps that are in the App Store. While the LLMs were good at providing a lot of information, I had to synthesize it and play a strong Product Manager role to drive the vision and keep the app simple. My daughter provided a lot of feedback and helped simplify the app and refine the UX. The "Bee Stage" design was inspired by her drawing.
Without AI tools, it would have been almost impossible for me to build and launch this app. But it still required a lot of decision-making and prioritization to get the product out of the door. I strongly believe that while AI is a powerful tool, human taste is the differentiator in well made products.
If you have a kid in K-5 who is interested in spelling bee type games, give it a try and I would love to hear any feedback you may have as a parent.
App store: https://apps.apple.com/app/apple-store/id6768881287?pt=12867...

value: Show HN: I built a spelling app for kids with my 7-year-old

author: narenst