value: rmnbb

value:
Hi all! Wanna share you my project, which was born from my own pain.
If you build AI assistant, some CRM or any automation, which should be accessible via WA/IG/FB direct messages - you know, that intecrating this channels is quite painful. I tried to make it much easier - with Fiwano you build only one integration, covering all 3 these channels. You dont need to get any tokens from Meta, or digging throw Meta developer dashboard.
Check our cookbook on Github - I tried to make documentation user-friendly and easy to fetch with AI. Will be happy to get your feedback!

value: Show HN: Fiwano – Unified API for WhatsApp, Instagram DM and Facebook Messenger

author: rmnbb


value: bonigv

value: Felt LSP Servers were too complex.  Bash tools alone too brutish.  Wanted to see what if it is a tree-sitter as a firstclass tool.  Ran a bench over 10 large codebases [bitcoin, django, rails, redis,...] at 5 levels of exploration complexity each.  That 150 context isolated runs over the last few days.  Sharing the results with full tarnsparency.  All scripts, docker image scripts, all transcrpts.  There is a TL;DR; but I hope you don't leave it at that. Has been quite a bit of work.  Repo links are on the site.

value: Show HN: Is grep enough? A transparent benchmark for agentic code navigation

author: bonigv


value: sageserpent

value:
Back in the early 2010s I often found myself trying to merge code that had been refactored on one branch and had new functionality added or existing code changed on another. So subclasses being hoisted, methods being extracted, methods being sorted by visibility, code being packaged up into classes and these moved into their own files... Meanwhile on the other branch changes were made to the original code prior to all this refactoring. It made merging a bit challenging to say the least.
I was aware of Git/Mercurial/Bazaar's ability to merge through file moves, but that wasn't enough for the fine-grained movement of code that took place in a refactoring. So I thought about writing a tool to handle this on my commutes to work - and then got on with the job anyway and never got round to it. There was always something more pressing (and usually paid for) to do.
Fast forward to 2023 and I had the time to work on this pipe-dream. I had some ideas back then about how to do this using a genetic algorithm and naively thought it would take six months or so, maybe a year. Turned out to take a lot longer, but it's been a fascinating project to work on. The genetic algorithm was sacked in the first six months, btw.
Installation instructions are here: https://github.com/sageserpent-open/kineticMerge#installatio...
It's an MIT-licensed CLI application.
You will need a JRE >= 17 on your system to run it.
Currently, it is expected that you work using Git, so it reads Git history and makes Git merge commits.
It's currently on its 57th release, and I use it for my own work (including its own development), so it's out of alpha these days.
Go crazy with it, and do raise tickets on GitHub if you find bugs. High praise is always welcome too!

value: Show HN: Kinetic Merge – merge a refactored codebase and stay sane

author: sageserpent


value: splendidz

value: Show HN: Uniflow – a code skeleton so feature #50 looks like feature #1

author: splendidz


value: arun-prasath

value:
I wanted to know how fast a 26B mixture-of-experts model could run on a desktop CPU with no GPU. Got ~40 tok/s single-stream (lossless) and ~124 batched. The surprising part was the byte budget: for this model you compress the output head (32% of per-token bytes), not the experts (16%). The writeup has the bandwidth roofline and the dead-ends; the repo has the reproducible recipe. Happy to answer questions.
Repo: https://github.com/arun-prasath2005/gemma4-cpu-moe

value: Show HN: Running Gemma-4 26B at 124 tokens/SEC on a CPU, no GPU

author: arun-prasath


value: fodoj

value: Show HN: Apex Copilot, a real-time telemetry HUD and race log for Forza Horizon6

author: fodoj


value:
Hi HN!
Showcasing sod - a minimal Secure Enclave harness for ssh keys.
sod generates an ecdsa-sha2-nistp256, unexportable key inside the Apple Secure Enclave.
It then orchestrates a barebones ssh-agent session which, in short -
allows authenticating to OpenSSH servers the same way you would normally - but with your fingerprint instead of your password.
No special support required on the server side, this simply bridges typical ssh client behavior with Secure Enclave signing primitives.
sod is CLI-only, and "speaks" in typical OpenSSH verbs: ssh-keygen, ssh-add, ssh-agent.
sod is a lean codebase written in Swift - zero dependencies (outside of Swift's own).
It does not implement any cryptography itself but rather delegates to macOS and OpenSSH crypto.
Quickstart:
    brew install botanica-consulting/tap/sod

    sd install

    ssh-copy-id -i ~/.ssh/id_sod.pub user@host

    ssh user@host

Pre-built .pkg and the code for your perusal at:
https://github.com/botanica-consulting/sod
Any feedback is welcome!
--
sod is a FOSS project by https://botanica.software

value: Show HN: Sod – Touch ID-Backed SSH Keys Using the Secure Enclave


value: stichers

value: Show HN: Kedro as a Service

author: stichers

title: Show HN: Kedro as a Service


value: Show HN: MemoryOps AI – governed memory lifecycle for AI assistants


value: Show HN: Declarative secrets management for agents and dev teams


value: FelineStateMach

value:
I built a remote desktop app where your FIDO2 security key acts as the address. The hmac-secret produces the same Iroh P2P node identity on both ends. That means there are no accounts, pairing, or VPN required.
I documented an agentic development workflow retrospective, including PoC spikes, spec driven design, agentic roadbumps, and what "shipping v0.1" means to me. This writeup covers the agentic development process-changes I am making to adapt to various evolving DevEx tools; focusing on ergonomics, efficiency, and elegance.

  cargo install --git https://args.io/cat/sigil sigil

value: Show HN: Sigil – FIDO2 key-derived P2P remote desktop (agentic workflow retro)

author: FelineStateMach


value: BonPPa

value: Show HN: Framein – a local work-state layer that keeps AI agents in context

author: BonPPa


value: Whiskee

value: Show HN: ReelsGraph – movie/TV watchlist and ML-based discovery queue, no signup

author: Whiskee


value: deathbyknowledg

value:
Back in April I left the Agents team at Cloudflare because even though I loved the work, I always had the drive to build the apps rather than the libraries. I felt like nobody was building the ideas that I wanted to exist.
My biggest drive was wanting my agents to run fully on “the cloud” yet having them on all my machines at the same time. So I ended up building GSV, fully open source.
GSV acts as a cloud computer by having a remote file system and a shell environment and trying very hard to pretend to be something close to Unix. There’s a kernel that handles all the primitive operations, including AI inference and the agent loop.
At the same time, your devices (and browser!) can connect your GSV to provide file system and shell access to those same agents too. This allows your agents running on the edge to have access to your local devices.
I’ve just released the beta and would love to hear feedback. As of today, it requires a Workers Paid account (~5$/mo) plus your model costs.

value: Show HN: GSV – a personal AI computer that unifies your machines

author: deathbyknowledg


value: palazski

value: Show HN: NodePad – AI agent on a canvas instead of a linear chat

author: palazski


value: gkavinrajan

value: Show HN: PulseDB – Unified Redis and Pinecone Alternative in Python

author: gkavinrajan


value:
TL;DR: I created a Python package to make running agentic automated theorem provers (e.g., Aristotle, Numina-Lean-Agent, Claude Code, etc...) as simple as
open-atp prove Lemma.lean result/ claude
I took a class on formal verification back in 2022 when I was an undergraduate. There was something incredibly satisfying about constructing proofs in Coq and knowing my statements were now formally verified. However, formal methods were so time consuming that they weren't practical in most industry settings. The rise of AI has changed that story: https://blog.janestreet.com/formal-methods-at-jane-street-in....
AI is producing algorithms and mathematical proofs far faster than humans can review them and formal methods offer a solution. Automated theorem provers take a statement formalized in a proof assistant like Lean and attempt to supply a proof. Unlike natural language proofs, these proofs can be machine-checked, reducing the burden of review on humans.
AI agents are powerful automated theorem provers. Even general purpose coding agents, like Claude Code, can be effective provers with the right skills and tooling. However, these methods are currently challenging to run. They require configuring Docker containers with the proper Lean environment and agent tooling (skills, plugins, MCP, credentials). Furthermore, there is not a common interface to existing provers.
OpenATP aims to solve both of these challenges! It makes it easy to run methods locally in Docker or remotely in Modal. It currently supports the following provers: https://open-atp.henryrobbins.com/en/latest/provers/index.ht....

value: Show HN: OpenATP: A platform for automated theorem proving in Lean


value: marchypolite

value: Show HN: I Made an SDK to work with Vapi and Retell without vendor lock in

author: marchypolite


value: MalloyDelacroix

value:
For years I've worked with a lot of complex, hard to remember, or tedious to enter, shell commands. I managed them with shell aliases, notes, and google searches, but aliases don't support parameters well, notes are difficult to search and organize, and having to constantly google commands is tiresome. I wanted a tool that made it easy to recall infrequently used commands and allowed me to enter tedious commands quickly.
CmdBox lets you store commands with named variables using angle bracket syntax, like <host> or <port>, and either prompts you for values at runtime or lets you store values so they are reusable in several commands. It also allows for nested commands inside other commands using <cmd:command-name>, so you can build up reusable building blocks rather than duplicating logic.
A few other features it supports: stored execution context per command (working directory, shell, environment variables, and timeout) with runtime overrides, multi-line command templates executed as scripts, tag based organization and filtering, field based search across commands, import and export for command sharing, and configurable global settings for shell, output capture, color and more.
It is written in Python, installable via pip as cmdbox-cli, and works on Linux, macOS, and Windows.
I would love feedback on the concept, design, features, or anything else. Happy to answer any questions as well.

value: Show HN: CmdBox – A CLI tool for saving and running parameterized commands

author: MalloyDelacroix


value: Show HN: TOTP generator – SHA1/256/512 30/60/... 6-9 not via SubtleCrypto


value: grenzfrei

value: Show HN: CiteReady – check if your site can be cited by AI search engines

author: grenzfrei


value: bohdanstefaniuk

value: Show HN: Habit Pocket – track numbers and times of day, not just checkmarks

author: bohdanstefaniuk


value: xDaftTurtle

value:
Hi HN, this is a project I’ve been working on over the last few weeks while in between jobs.
I have a weird obsession with odd display hardware. Nixie tubes, VFDs, CRTs, and of course e-paper.
It turns out I had quite a collection of e-paper screens and wanted a simple way to drive them all. Something flexible, customizable, and that didn't require a cloud account. I couldn't find anything that fit my needs exactly, so I decided to roll my own solution.
What I ended up with: an HTML-based widget system that gets captured headlessly via Playwright, gets dithered and composed via panel-specific renderers, and then published to clients via REST or MQTT. All components (Widgets, renderers, and device kinds) are drop-a-folder plugins.
Hardware supported: Pimoroni Inky Impression panels via a client daemon, Waveshare panels via custom firmware, Seeed reTerminal and TRMNL devices via TRMNL firmware as well as jailbroken Kindles (or anything that has a TRMNL client)
The server publishes dashboards to all of these via a built-in rotation system.
The server and clients are AGPL-3.0-or-later. There are install scripts for windows/linux/OSX as well as full Home Assistant App support, Docker containers, or cloud-init.
This is my first post here. I hope people find this useful.

value: Show HN: Tesserae, self-hosted dashboards for the e-paper panel you own

author: xDaftTurtle


value: sawsymikey

value:
I built Debategle, a platform for live 1v1 debates. You get matched with a random opponent (ranked matching is based on topics you’re interested in, casual matches are just open rooms), you each argue your side, and an LLM judges who made the better case.<p>Stack: FastAPI backend, Clerk for auth, Elo-style rating system for ranked matches.
The obvious objection is LLM-as-judge reliability, I don’t think it’s perfect, but I’ve found it’s decent at scoring argument structure and rebuttals rather than just rewarding confident-sounding text. Curious what people think breaks it, I’m sure there are ways to game the judging that I haven’t found yet.

value: Show HN: Debategle – ranked 1v1 debates judged by an LLM

author: sawsymikey


value: nastynate

value:
A little while ago I was searching for a nice status line to use in Claude Code and was surprised that no community library type website existed for people to show off what they have made. So I decided to have a little fun and make one. All status lines are manually reviewed and rendered in a live container to capture the output. Enjoy!
Source code: https://github.com/NathanAB/statuslin.es

value: Show HN: Statuslin.es – a community library of custom Claude Code status lines

author: nastynate


value: owenthejumper

value:
I built TraceAIO, an open-source tool that prompts LLMs on your behalf and tells you whether ChatGPT, Perplexity, and Gemini mention your brand — and which competitors and sources show up instead.
Yeah, this category smells a bit like a grift, same as early SEO. And I think over time it will become just SEO again, and become about good content. The tool just helps you monitor over time.
It queries the browser products through real browser sessions, not APIs, runs on Docker, with an MCP server so you can query your own data through an LLM.
No business model, Apache 2.0, self hosted. If you use a residential proxy instead of running the browser locally I get a few cents via referral, not even enough to cover my token costs.
Demo (no signup): https://demo.traceaio.org — admin@example.com / adminadmin
Code: https://traceaio.org
Long on-and-off project, finally happy to show it. Feedback welcome.

value: Show HN: TraceAIO – open-source LLM visibility tracker

author: owenthejumper


value: dvdxnss

value:
app url: https://app.sunwaee.com
hey, so I never really stuck with chatgpt or claude web apps because to me they always felt like a slightly-more-personalized google search but far from actually knowing who I am, plus I also want access to the best models but with the release frequency of new models these days it often means multiple expensive subscriptions... kinda lazy too so I figured having some kind of autorouting that picks the model I want for given topics would be cool. On top of that I've been on a journey to get out of the google-ized life (i.e. google ecosystem), I'm obsessed with organizing everything, and I'm kinda growing tired of switching apps for notes, tasks, files, calendars, search, etc... even more so since those apps either have bad AI integrations (gemini...) or no AI integrations at all...
So I've been working on https://app.sunwaee.com for the last few months now, which is basically a all-in-one AI OS in your browser where you not only have access to most LLMs as agents, but also to native notes, tasks, files and calendars directly in the app - everything workspace-based. There are also a few other cool things, like:
- an autorouter that picks the best model based on the query topic and that you can customize (e.g. opus for coding, gpt for business, deepseek for maths..), plus you can switch model mid-conversation
- three-levels memory system: user > workspace > project, and Sun (the AI agent) can search your entire account for stuff
- a workbench where Sun can create/edit and pin anything from notes, tasks, files, events, or web searches (and soon custom objects like books, flights, animes, movies, products...)
- a PII redaction system that basically redacts emails etc from your messages, Sun messages, but also tool calls before they reach the LLM providers APIs
- and more, like subagents, file editing (incl. msft, pdfs, images..) in a sandbox, scheduled jobs, skills and basic connectors
Built everything solo (psql/fastapi/nextjs) but it's single-user only right now, no sharing/collab features yet
Ever since I put it on my domain I find myself using it basically for everything and from anywhere, from search to planning to learning and at this point it has become my daily-driver - which I'm very proud of (also knowing your data isn't sold or used for advertising purposes feels good). I'm also planning to add proactive/follow-up features, check-ins, and some kind of MCP such that coding agents can access your workspaces/chats/tasks in the next few weeks/months
But at this point I'm looking for external, honest feedback on the app itself. When I take a step back it sure isn't an app/service that solves *one-specific problem* like all startups you can see that just align 3 complex words and make it their selling point (e.g. "Agentic Construction Management") so when I talk to people about it the positionning part is hard to describe, even though the idea/bet is simple - everything in one app and Sun the agent that acts proactively across all of it
Would really appreciate a few people trying this out (https://app.sunwaee.com - no signup required, free trial too) and telling me honestly what they think, happy to connect with anyone who finds the idea/product interesting!
David

value: Show HN: SUNWÆE – your life's AI OS

author: dvdxnss

title: Show HN: SUNWÆE – your life's AI OS


value: ilyagruzhevski

value: Show HN: Built a minimalist currency converter app that I use daily now

author: ilyagruzhevski


value: Show HN: TinySearch – token-efficient web research for local AI agents


value: pbjerkeseth

value:
Hey folks, I started working on Ouijit around the start of the new year, and its since become the daily driver for myself and a handful of other engineers (that I know of).
The initial reason I built it was over dissatisfaction with how most agent orchestrators abstract stuff behind chat UIs, require login, or only support their companies own model/harness. I didn’t want to keep cobbling together scripts for worktree isolation between tasks though, so the yak shaving began. A couple weeks in, I received a message from a friend sharing that they just finished an 8 hour session working in it and they really liked it, and that they’d even shared it with their coworkers unprompted. I’ve been a software engineer/designer for ~10 years and its hard to put into words how rewarding that felt.
Some things I think are unique about Ouijit:
- Sandboxing is a first-class consideration, Ouijit supports running tasks in per-project Lima VMs. Right now I'm looking into making sandboxing pluggable so you can bring-your-own agent environment local or in the cloud, with a few baked in defaults.
- Integrated agents are automatically aware of a session-scoped CLI that enables them to orchestrate and drive tasks from any Ouijit terminal, with no additional setup.
- Tasks have lifecycle hooks that can trigger prompts, scripts, or both when tasks start, resume, move to review, or move to done.
- You can organize child terminals, markdown, and url previews to terminals. It's a little like Claude artifacts in that way.
Supports macOS and linux; integrates with Claude Code, Codex, Pi, and OpenCode agent harnesses.
Free and open source, no login, no telemetry.
Website: https://ouijit.com
Github : https://github.com/ouijit/ouijit

value: Show HN: Ouijit, command terminals running coding agents

author: pbjerkeseth


value: egntms

value: Show HN: Fits – compress PDF, pick the output size, fast, no upload, free

author: egntms


value: wayneshng

value:
Hi HN,
I would like to share with you Valmis, an AI agent harness built for work, with the ability to connect to 100+ business and productivity integrations. The system is designed with security in mind, and agents run in isolated containers, meaning AI never gets access to your API credentials or your host files.
I know the first question you are going to ask is: Why another AI agent harness? And here is why I'm building it.
OpenClaw (or many other harnesses) is a great tool for creating personal assistants, but it is not built for work. The biggest concern is security, as agents store credentials in their memory as plain text and sometimes send credentials directly to LLM providers.
Valmis addresses this issue with a proxy system: the Dockerized agent runtime can only make API requests to the host machine by providing the relevant credential ID. The host then makes the actual request and returns the JSON data back to the agent runtime. Even the LLM API calls themselves are made using proxy. With this design, you can even turn off the internet access of the agent container while making it work.
Agents can only work for you when they have access (safely) to your apps. Our proxy system now supports 100+ business and productivity integrations, including all Google Workspace apps, Slack, Notion, Hubspot, Salesforce, and Figma.
Finally, you can automate multi-step workflows using our workflow feature. Each workflow can be triggered by cron, webhooks, app events, and it supports conditions and loops. You can create workflows using our workflow builder UI, or simply ask your agent to create one by providing a description.
Other cool features:
- Agents have cross-session memory: Your agents are able to automatically write memory when you tell them anything worth remembering or when it discovers something that might be useful in the future.
- Browser automation: Agents can operate a headless browser, navigate, fill forms, click, read pages, and take screenshots. Browsers are also managed by the host machine, so agents interact with them using proxy.
- Human in the loop: Whenever there is a critical decision to make, the agent pauses and asks the human for a set of options.
- Team knowledge base and skill system.
Overall, Valmis is designed to run on the cloud and collaborate with humans to get work done (Valmis means "done" and "completed" in Estonian). If you have any questions about the project, please leave a comment, and I'll reply to all questions.

value: Show HN: Valmis, an OpenClaw alternative built for work, with security in mind

author: wayneshng


value: elvinas

value:
I ran a software agency for about ten years. Every client used a different task manager, which doesn't sound like a problem until it's your whole life. I spent more time digging through those things trying to figure out what we'd done than actually doing anything. So  I built Rinkta to get that time back. Seemed smarter than continuing to lose my mind.
What it does is, it takes all your tasks out of Asana, Linear, ClickUp, GitHub, Basecamp, whatever you got, figures out how long each one took, puts the right rate on it,  and lands the whole thing in one dashboard. That's the program. Not much to look at, but it works, which is more than I can say for most things.
Now, a lot of these people on HN build a little program and get up saying it changed the world, all that. But in reality they built it and walked away like a fella who buys a boat. Not me. Somebody says "it's Rinkta or you live as a hobo," I'm a hobo now, simple as that, got the little bindle and everything. Anyway, I'd love to hear what you think, and if you hate it , say so.

value: Show HN: Rinkta – pulls finished work from all task managers into one dashboard

author: elvinas


value: Show HN: Autoharness – a self-learning, maintaining skill layer for Claude Code


value: cbmouton

value:
I built this after watching seed-stage teams attempt SOC 2 in spreadsheets because Vanta and Drata cost $10,000–$15,000 a year before they had product-market fit.
Scorifya Controls is a self-hosted SOC 2 compliance tool:
- 33 automated checks across AWS, GitHub, GCP, and Azure (IAM, S3 public access, CloudTrail, MFA, branch protection, secret scanning, etc.)
- 20 manual controls with evidence file uploads and structured audit notes
- RFC 3161 cryptographic timestamps on every attestation, issued by DigiCert, verifiable by your CPA firm with a single OpenSSL command, without trusting Scorifya
The timestamp part is the piece I hadn't seen anywhere else in self-hosted tooling. If the vendor controls the timestamps on your compliance evidence, an auditor doing Type II has to take your word for the dates. RFC 3161 moves that trust to a public Timestamp Authority. DigiCert's root cert is already in Windows, macOS, and Adobe's trust store. Auditors verify offline:

  openssl ts -verify -in token.tsr -data record.json -CAfile digicert-tsa-ca.pem

Deploy is a single docker-compose.yml:

  curl -O https://www.scorifya.com/docker-compose.yml
  # set SESSION_SECRET, NEXT_PUBLIC_BASE_URL, LICENSE_KEY in the compose file
  docker compose up -d

Starts in under 30 seconds. Your AWS credentials, GitHub tokens, evidence files, and attestation records never leave your server.
Pricing is three tiers, monthly or annual, no per-seat charges:
Starter (AWS + GitHub) at $99/mo or $999/yr, Pro (all four clouds) at $249/mo or $2,499/yr, Team (Pro plus multi-tenant for agencies) at $499/mo or $4,999/yr. First 25 buyers in each tier lock in Founders pricing (20% off, forever).
Product page: https://www.scorifya.com/controls
Technical writeup on the RFC 3161 implementation:
https://www.scorifya.com/blog/rfc-3161-soc2-timestamps
Happy to answer questions about the SOC 2 audit mechanics, the timestamp verification, or the check implementations.

value: Show HN: Scorifya Controls, a self-hosted SoC 2 tool with RFC 3161 timestamps

author: cbmouton


value: PenguineDavid

value:
This is a library I've been working on with versions for C++, java & C# where you make custom formats and Log based on them, for example you could make an ERROR Like this:

  [ERROR] [date, time-stamp, time-zone] <main log message> (file:thread-ID:line)

but you would write it like this:

  // define the master format

  master_style = "%C[%N]%c%S%G[%D %T %Z]%c %M %G(%F:%t:%L)";

  // tell the logger what colour to use for a given name

  logger.add_format("ERROR", master_style, Colour::RED);

so now the [ERROR] part will be red,
the time area will be grey,
and the location grey,
but you could really make any style you wanted.
And once you have a master format you could also add different types of logs:

  logger.add_format("SUCCESS", style_minimal, Colour::GREEN);
  logger.add_format("INFO", master_style, Colour::CYAN);
  logger.add_format("WARN", master_style, Colour::YELLOW);

also the %S we put in there is actualy a colum padder so you logs will be inline:

  [INFO]   [16/06/2026 10:58:00 AUS Eastern Standard Time] Initializing core subsystem components. (src/main.cpp:1:39)
  [SUCCESS][16/06/2026 10:58:00 AUS Eastern Standard Time] Database connection established smoothly. (src/main.cpp:1:40)
  [WARN]   [16/06/2026 10:58:00 AUS Eastern Standard Time] High memory usage detected on node cluster. (src/main.cpp:1:41)
  [ERROR]  [16/06/2026 10:58:00 AUS Eastern Standard Time] Failed to write to write-ahead log! (src/main.cpp:1:42)

value: Show HN: C++, Java and C# light-weight-logger

author: PenguineDavid


value: thinkmariale

value: Show HN: Kinetk – Watch agent build a launch and growth plan for your product

author: thinkmariale


value: iishanto

value:
Problem Statement:
A few months ago, I was outside of my city. I was on a bus when one of my team members messaged me saying users were unable to read the product description PDF. I had to wait 3 more hours until I got back home, opened the laptop, and SSH'd into the server to find out what was wrong. In that moment I realized that being able to manage a server from a phone is very important when a laptop is not nearby.
What it does:
It is a UI wrapper over standard SSH command outputs. It parses the SSH output and shows the results in UI elements, and also translates your actions to relevant SSH commands. This way users won't have to heavily rely on the command line – as we know, typing commands from a mobile device is also hard. However, it also has a terminal to allow you to do anything. It also supports Kubernetes, where you can see and manage pods, view logs and stats, and RDBMS to allow you to quickly perform database operations – a bit like phpMyAdmin or pgAdmin.
Tech Stack: Flutter, SSH, Android Secured Storage, Firebase, Docker
Why Android:
I know – iOS is a major platform for this niche. But for now – as it is an MVP – I have decided to develop for Android to validate my idea and understand if it solves a real problem. The good news is, it does solve a real problem – at least the analytics say so. Within 30 days I got 5 premium users. About 30% of users connect their server and 23% of them use the app regularly. So now I am working on the iOS version.
Current Limitations:
Currently the app only supports Ubuntu – other Debian based OSes are not tested, though they might work as well. The Kubernetes and AWS features need more testing. Also, ServerKit VPS Lab currently limits sessions to only 30 minutes TTL to prevent misuse.
Feedback Request:
I would love your feedback on the VPS management and monitoring features, RDBMS features, and Kubernetes features. I also tried to keep the terminal simple, but your feedback on this is also valuable to me.
Try it out:
If you don't want to connect your own VPS, you can test the app using ServerKit Lab. It will allow you 30 minutes of free VPS to test the app.
Install ServerKit: https://play.google.com/store/apps/details?id=com.iishanto.s...

value: Show HN: ServerKit – A mobile UI for server management

author: iishanto


value: animeshchouhan

value: Show HN: Gödelify – Encode any file or text as a prime number

author: animeshchouhan


value: Make this skill to help me cross examine suggestions made by claude to other Claude or opencode supported models mid session. It compiles relevant context, consult a second opinion for me and support following up with the second opinion. A pattern that I find quite useful.<p>Currently it supports claude to claude, claude to opencode and opencode to claude invocation. These are the two harnesses I use.

value: Show HN: Second opinion – A skill to query different models


value: seachicken

value:
AI Agents like Codex and Claude are incredibly powerful and have drastically sped up implementation.
However, I noticed a strange side effect: I began to lose confidence in my own coding.
I submitted a pull request after the AI completed the implementation. It looked good, but during code review, I was asked, "Why did you implement it this way?" I grew increasingly embarrassed because I couldn't immediately explain the complex code.
Previously, I built confidence by understanding the design through reading and writing code, which was enjoyable, but now I've lost that.
This coding assistant helps users understand their thought process and coding progress, with the AI acting solely as a guide and not writing code on its own. To still leverage the AI agent's autonomous implementation capabilities, a separate AI thread runs in the background in a temporary working directory, providing highly accurate navigation assistance to the user.
The AI's responses are still a bit strange at times, but if this concept resonates with you, please share your feedback. As a solo creator, I find that very encouraging. Thank you.

value: Show HN: Shoaku – Your Coding Navigator

author: seachicken

title: Show HN: Shoaku – Your Coding Navigator


value: embleton

value: Show HN: The Hardware OS – a free field manual for hardware engineering leads

author: embleton


value: realdjpaulyd

value:
We’re building Fork. Our first release is a free Chrome extension, allowing you to build features on top of Gmail and Google Calendar.
50 second demo: https://www.youtube.com/watch?v=JQ292bncO_c
Chrome extension (free + no login): https://chromewebstore.google.com/detail/fork-for-the-web/mf...
We keep limited trace activity of coding sessions for 30 days to troubleshoot and improve our offering. No data (events, emails) from Google is ever logged or retained.
We have a lot to learn and build. Would love any and all feedback!
Paul & Dalton

value: Show HN: Fork – Chrome extension that builds features in Gmail and Calendar

author: realdjpaulyd


value: xtofalex

value: Show HN: Naja-scope – Let AI agents explore SystemVerilog netlists over MCP

author: xtofalex


value: olzhasar

value: Show HN: Mess – a tiny CLI to clean dev clutter

author: olzhasar


value: bathlasiddharth

value: Show HN: Myna – a local AI Chief of Staff that remembers your work

author: bathlasiddharth


value:
Hi everyone, french web dev here,
About 10 years ago I did a little party game in the browser inspired by Achtung die Kurve genre, it reached HN (https://news.ycombinator.com/item?id=9494619) and everything went crazy, it's still largely played in open-spaces all over the world today.
This past year, I've been working on a sequel: https://curvytron2.com is live.
Same goal as the first one: challenge myself, perfect my skills, have fun and give back to the internet community the best way I know; by just putting a free little fun game out there. No ads, no tracking, no business plan.
A decade of professional web development and hours of GMTK have raised my expectations and this time I aimed for:
- a good looking top-down 3D view with improved gameplay and real game juice: I learn Three.JS and WebGL for this project, worked on the camera movements, screen shake, sound design, gameplay feedback and I'm proud of the portal-like effect of the bonus that allows you to peak and  cross over to the other side of the map.
- a solid 100fps server simulation (in Go) serving clients with a really bandwidth efficient netcode (it's binary websocket instead of plain JSON and I open-sourced it: https://github.com/Tom32i/netcode).
- Instant reconnection, at any time: I had this requirement from day one, in the first curvytron losing connexion meant dropping out of the game permanently. Not anymore. You can just refresh the page mid-game and keep playing, try it yourself.
The game runs in any desktop and mobile browser and supports gamepads
I've put up servers in US and Europe to offer a good ping to as much players as I can afford at the moment.
I still maintain and host the first game to keep the original experience live.
I'd love to get feedback from HN, and don't hesitate to stress-test the game of course!
I'll be around to answer questions and discuss if you're interested.
Cheers!

value: Show HN: Curvytron 2, I rewrote my browser party game, 10 years later


value: dantelex

value: Show HN: Dropbox For –/[Code]

author: dantelex

title: Show HN: Dropbox For –/[Code]


value: Show HN: Research-Git, regenerate a past idea onto today's codebase


value: june-jule

value: Did a live demo of my schematic layer for production agentic workflows - check out the repo as well - https://github.com/neo4j-labs

value: Show HN: GraphDB Decision Tracing and Governance [video]

author: june-jule


value: Show HN: Anvit – Offline AI to chat with your PDFs on Android on-device


value: cloudcell

value: Show HN: OM Core – multidimensional models without spreadsheet cell formulas

author: cloudcell


value: Show HN: Aitori – open-source tool to inspect Claude and ChatGPT traffic


value: narner

value: CoreML implementation of National Design Studio's Rampart PII detection model + Swift package

value: Show HN: Rampart on CoreML

author: narner

title: Show HN: Rampart on CoreML


value: zubairov

value: Show HN: Scaffold a BigQuery and dbt and Cube project an AI agent can operate

author: zubairov


value: cloudkj

value:
I’ve recently just started tinkering with using local large language models, focusing on simple, low-dependency CLI setups. I ended up going down a bit of a rabbit hole: I wanted to see if I could build a functional model interaction REPL using exclusively standard command-line building blocks.
I tried to abide by the Unix philosophy, breaking the REPL into the composition of a few small, single-purpose program. Because the data flow is just text streams fed through pipes, at any step you can inject tools to inspect or modify the data—like using `grep` to filter out strings before they hit the model, or `pv` to benchmark model throughput. Everything is ultimately tied together into an `agent` Bash script that codifies the interaction into a REPL. To my surprise, this setup seemed to be sufficient to get a working “agent” that largely resembles ones built by more complex frameworks.
One motivation I have for sharing this here is to embed some semi-rhetorical questions: is that really all there is to a “modern agent”? Are the frameworks and libraries being tossed around overly complex and we really just need to keep it simpler?
A few more details of potential interest:
- Zero heavy dependencies: No `pip`, `npm`, package managers, virtual environments, etc. It just requires `bash`, `jq`, and `curl` to talk to the local model server. These should be available in most modern CLI environments.
- Transparent, file-based state: The agent's memory is just an append-only `.jsonl` file (like `.bash_history`). If you want to rewind the agent's memory, you just run head on the log to drop the last few lines.
- Standard exit codes for control flow: Tool execution is handled by checking standard Unix exit codes within a basic bash while loop.
I suspect there are scaling limits to doing this all in shell, and I'm still figuring out the most elegant way to handle some of the edge cases, particularly around tool calling - but those appear to mostly be limitations of the underlying models. Nevertheless it's been a really fun experiment in stripping out bloat, and as I mentioned above, somewhat surprising at least from a neophyte perspective.
Would love to hear thoughts and comments, particularly around the limitations to this orchestration and what features are otherwise missing due to bypassing the popular frameworks and libraries.

value: Show HN: Bash is All You Need for a language model REPL

author: cloudkj


value: aviscido

value:
Obvelum is a job platform where you don't apply - companies apply to you, and they don't know (in principle) who you are. You create by yourself an anonymous profile, mark yourself open, and companies could reach out to you based on what you can do. They only learn your name if you decide to tell them, and only after you've seen what the role is about (and what it pays).
regarding the privacy:
- Your name doesn't come out until you choose to release it, and a company has to show salary and role details first.
- Auth is self-hosted Zitadel. Google sign-in requests only openid+email, no profile scope, so Google never hands us your name. Email sign-up stores just the email address itself.
- Analytics is self-hosted Umami, anonymous. Cookies are functional only.
The part I actually want comment about is the threat model: your current employer. They already know your salary, your stack, your seniority, and which tag points at them; so to them your profile is basically a name tag, even though it's anonymous to a stranger. I let you block companies, but I don't think that closes it, and with small enough fields almost any profile is unique. If you can see how to fix that, or break anything else, tell me. I don't have a security background and I'd rather find out now.
About 100 profiles so far with little marketing.

value: Show HN: Obvelum – an anonymous hiring portal where companies apply to you

author: aviscido


value: ChicknNuggt

value: How this works is that I extracted knowledge from PGs publicly available essays. Instead of using RAG I used a state map approach, if you are keen about the extraction method I can share more in the comments.<p>TLDR: it’s a PG avatar trained on his essays and the avatar renders on webgpu, give it a shot and ask it about the hardest problem you are facing in your startup right now. If you like the avatars answer you can share your conversation here!

value: Show HN: AskPG, a real-time WebGPU Paul Graham avatar for startup advice

author: ChicknNuggt


value: Kaljurahn

value: Show HN: A physical dial that locks your screens until your focus session ends

author: Kaljurahn


value: ppiankov

value: Show HN: Bulwark – a kernel read gate so coding agents can't read .env or .ssh

author: ppiankov


value: BenMs

value: Show HN: Plain-language E2E tests for desktop UIs that don't have a DOM

author: BenMs


value: chepy

value: Show HN: Busabase – an approval-first database and knowledge base for AI agents

author: chepy


value: garymiklos

value: Show HN: NextMQ – managed BullMQ for serverless Next.js

author: garymiklos


value: turtledevio

value:
Hi everyone,
I've successfully used Backend + SPA pattern in several AI products so far. Then I decided to put years of experience into this starter pack. Even then, it took me a few months to make it a complete product.
It has anything a regular SAAS would require, plus AI-ready features such as token based metering and a fully functional AI copilot demo app.
Let me know your feedback.

value: Show HN: FastReact – FastAPI and React Starter Kit for AI SaaS

author: turtledevio


value: vasanthps

value: Keepp, is not just a link in bio. It is a landing page for all the creators and small businesses. Along with socials and links, it supports cards with customizable actions to show case things you sell and recommend. With and AI agent it becomes much easier to manage. Let it edit it automatically when you run promos, you have updates and never worry about it being outdated.

value: Show HN: Let your AI agent manage your link in bio

author: vasanthps


value: skyepstein

value: Show HN: Don't ask if devs cheat with AI, test if they're good with it

author: skyepstein


value: shaidiuk

value: Show HN: Codegrain – PDF/image/data tools, files never leave your tab

author: shaidiuk


value: lougarou

value:
Hi HN! I’m Lokhesh, I am part of the Product and AI team at a small startup, Kurrent. We built Capacitor, and here’s honestly how it started:
One night our Engineering Lead, Alexey,  left Claude Code running overnight to finish a task. In the morning his machine had auto-updated the OS and his session was gone. No context, no record of what had been done, nothing. He dug into the Claude Code docs, learned about session resume and transcript files, and realized there’s an enormous amount in those transcripts that’s normally invisible. How the agent reasoned through the task. Every file change. Every tool call. Every failed command and dead end. All of it. Gold!
That’s when he thought, ‘what if my machine dies and I lose all of that?’ And then, ‘what if I could share it with my team?’ That’s how Capacitor came to be.
Capacitor records agent sessions (prompts, responses, tool calls, code changes, etc.) into an event store (KurrentDB under the hood). Each session gets a unique ID. You can resume it in any agent, on any machine, or hand it to a teammate without re-explaining everything.
Here are some of the things we use it for:
- Survive on restart
- Hand a session over from a desktop to a laptop when you need to travel
- Remember what I’ve done before (+ why and how)
- Ask a second opinion (from a human or agent)
- Share knowledge with peers
- Explain the reasoning behind the code written by an agent
- Hand over when I get sick or take a day off
I’m doing this post because I’d love to get feedback from the HN community on how we can make Capacitor better. What works well? What could be improved? What should we add?
Get it here: https://capacitor.kurrent.io/api/auth/start?tier=free
Check out the docs: https://capacitor.kurrent.io/docs/getting-started/quickstart...
Note: We designed Capacitor as a cloud service to make setup easy, but are open to suggestions on how best to package it.

value: Show HN: Capacitor – shared mem for Claude Code, Cursor and other coding agents

author: lougarou


value: aniketwattawmar

value:
Portable evaluations for AI agents.
ECP is a vendor-neutral protocol for testing agent outputs, tool calls, and evaluator-visible audit context, cross frameworks, models, eval platforms, and CI systems.

value: Show HN: Evaluation Context Protocol (ECP)

author: aniketwattawmar


value: Streamlike

value: So I am building ASTRA - an AI-based matchmaking and date planning platform. We will select a group of 30 people who share similar vibes and preferences, ensuring an equal gender ratio. And curate an event for them to figure out who connected better with them.<p>Give yours feedbacks and sign up if in India!

value: Show HN: Astra – AI Dating Platform

author: Streamlike

title: Show HN: Astra – AI Dating Platform


value: therepanic

value: Show HN: Openleetcode – local LeetCode runner with open test suites

author: therepanic


value: noxan

value: Show HN: Diskly – fast and beautiful macOS disk usage visualizer

author: noxan


value: gsgreen

value: Show HN: Webbynode – An observatory built from 700 fresh cloud deployments

author: gsgreen


value: Rochus

value: Show HN: A statically typed, cross-platform, easily bootstrappable build system

author: Rochus


value: arthurjean

value: Show HN: Paneflow – cross-platform GPUI app for parallel coding agents

author: arthurjean


value: rjzzleep

value: Show HN: Agent Sandbox Options

author: rjzzleep

title: Show HN: Agent Sandbox Options


value: shanev

value:
Vanta is a Markdown notes app for iPhone, built around on-device AI organization and GTD (Getting Things Done).
I use Obsidian with Claude on desktop, and wanted a similar but automated flow on mobile. This started out as an experiment with Apple's local Foundation models which turned out to be genuinely useful for me. The local models are used to clean up messy dictation, format Markdown, and categorize your inbox using GTD principles.
Maybe one day it'll do your todos for you too :)
Import and sync your existing Obsidian vault on Github, or start with a new one. iCloud Drive sync is included.
App Store: https://apps.apple.com/app/id6777781490

value: Show HN: Vanta – Markdown notes for iPhone with on-device AI

author: shanev


value: cpard

value:
Hey friends. I'd like to share a project that's dear to me. fenic is a dataframe API with LLMs added as first-class citizens, a classic lazy dataframe API extended with new operators that are backed by LLMs.
What this gets you is the ability to work with structured and unstructured data in the same context. Most importantly, the LLMs aren't integrates as opaque UDF black boxes. They're exposed as "semantic" operators that the planner can reason about alongside the classic ones.
(There are examples and code snippets on the repo to see how everything works together)
Why build this? I'm a data infra / systems person. When LLMs showed up, what I saw was a new type of compute that changes the characteristics of the
workloads we deal with. I wanted to experiment with how our current systems can absorb these new workloads and compute types, and what it would take to make the DX as seamless as possible, that's where the UDF + arbitrary prompt was feeling too problematic.
To support this properly, we had to introduce a few really cool things:
New plan operators. You don't just send prompts at an LLM. You use operators like semantic join, semantic map and reduce, and semantic filter, among others. They mix with the classic operators, and because the planner sees them as real operators rather than black boxes, it can reorder work around them.
Typed outputs. There's ergonomics to turn the output of a semantic operator straight into a typed dataframe column. A Pydantic schema for the LLM output becomes a typed struct column you can unnest, explode, and so on.
New data types like a markdown data type. Markdown became an important way to share information with LLMs, even though it started life as a way to format text for presentation. It carries structure, and being able to access that structure the way you would a struct or JSON type adds to the developer experience I mentioned.
Async UDFs. One of the more interesting shifts in workloads from the LLM explosion is the need to put heavily I/O-bound steps in your pipeline: fetching a response from an API, crawling a website, and so on. Async UDFs fill that gap, and the implementation handles the nuances for you: concurrency, retries, and the rest.
An LLM-inference-aware planner and runtime. This is one of the parts I'm most excited about, and there's a lot still to do. Today: identical prompts within a batch collapse to a single model call, so duplicates cost zero tokens; requests are dispatched concurrently under per-provider rpm/tpm limits with retries and backoff; null and empty cells skip the model entirely; and you get token and cost metrics per operator. There's also an optional persistent response cache so re-runs skip the model.
MCP as a new catalog primitive. Much like a registered view, you can register a dataframe pipeline as an MCP tool in the catalog. fenic then serves an MCP server with that pipeline as the tool's logic, executed over your data.
These are just some of what's gone into fenic while experimenting with how LLMs can become part of our compute infrastructure. There's more, and plenty more to polish on what's already there.
I've been using fenic for all sorts of things. On the small/personal end, I use it to take my podcast audio recordings and turn them into nicely structured tables of metadata I can research. On the heavier end, I use it as tooling for agents to analyze agent traces exported from Pydantic Logfire, to discover evals and turn them into reproducible artifacts in the form of dataframe pipelines.

  pip install fenic
  Repo: https://github.com/typedef-ai/fenic
  Docs: https://docs.fenic.ai

There's also a skill you can use with claude code, codex etc. to quickly get started with fenic in your favourite agentic coding environment.
I'd love to hear your thoughts, criticism, and anything else that comes to mind.
I'm here to answer questions.

value: Show HN: fenic – LLMs as dataframe operators, query meaning and structure

author: cpard


value: abelgvidal

value: He's 13 years old. He wanted to track his own ant colonies — growth, feeding, humidity, and other metrics. He built the whole app himself with some help from AI tools; I just helped him deploy it to a server. Would love to hear your feedback!

value: Show HN: My 13-year-old built an ant colony tracker

author: abelgvidal


value: simonw

value: Show HN: Shot-scraper video tool for recording YAML-defined webapp feature demos

author: simonw


value: beebeeVB

value:
Hi all,
As there are more and more agents in the internet; Security is going to be a big problem. Currently, the problem is solved using a LLM to guard Agent but this creates the problem of hallucination and latency, so I coded a firewall in rust that runs under five milliseconds. This works by creating a plan and enforcing the plan; While the agent is running, we track the trajectory using graph of the tools and the actions it used and data it accessed. for per action call, this enforces using the Model context protocols list and for sequence it tracks every single tool call and data flow; there is also a taint mechanism where if the agent reads something outside of the user context, it flags and adds more security mechanism. It works by using a DAG.

value: Show HN: Trajeckt, a Firewall for AI Agents

author: beebeeVB


value: Show HN: Clusy – Cursor for data science notebooks in cloud


value: IvanGoncharov

value: I tried to make it look and feel similar to NotebookLM but inside ChatGPT

value: Show HN: NotebookLM style mindmap inside ChatGPT

author: IvanGoncharov


value: hxii

value: Show HN: I built an AI agent to yell at me about my ADHD

author: hxii


value: Show HN: Build better UI with Hermes agents


value: johnjwang

value:
We just open-sourced the internal system we built at Assembled for running coding agents as a team.
Coding agents worked well for individual engineers, but the surrounding workflow was a bit of a mess. We generally found that many engineers had different MCP connections and context for their agents, personal automations running that other people couldn’t access, and very little introspection for what a human’s input into the coding agent looked like.
So we built an internal system that converted coding agents into shared team infrastructure.
The system runs Codex, Claude Code, OpenCode, and other agent harnesses in gVisor sandboxes. You can mix and match coding agents to tune your cost and intelligence tradeoff (for example, our team has started to use GLM 5.2 for automation tasks and a combination of Codex/Claude Code for manual tasks). It connects to a bunch of tools like GitHub, Linear, Sentry, Slack, PagerDuty and makes previews easy to generate.
We were inspired by internal systems like Stripe Minions and Ramp Inspect, but wanted an open version other teams could inspect, run, and adapt so we made it MIT-licensed and self-hostable.
Hope you like it!
Website: https://143.dev
Github: https://github.com/assembledhq/143

value: Show HN: 143.dev – we open-sourced our internal coding-agent infrastructure

author: johnjwang


value: sharathr

value:
Anthropic recently published an excellent write-up on how they contain Claude Code and its sub-agents.
One thing that stood out is that the architecture isn’t really about Claude—it describes a general pattern for securing autonomous agents:
* Every agent gets its own identity.
* Authority is delegated (and attenuated) to sub-agents instead of being inherited wholesale.
* Tool access is authorized per action.
* Every action is attributable back to the originating principal.
We took that architecture apart and mapped it to explore how the same model can be applied across heterogeneous agent fleets (Claude Code, Codex, etc.), not just Anthropic’s own stack.
The post focuses on the architecture rather than the product:https://www.highflame.com/blog/how-anthropic-contains-its-ow...
I’d be interested in feedback from people building agent systems.

value: Show HN: Deconstructing Anthropic's Coding Agent Control Model

author: sharathr


value: badwx

value: Show HN: Pacific Slate – a self-hosted, model-agnostic multi-agent AI assistant

author: badwx


value: aperi

value:
[In beta]
The product is called Minima and is live at minima.sh to try.
It's a general purpose harness which uses Mubit (mubit.ai) memory to manage model routing

value: Show HN: An agent harness with model autorouting and memory

author: aperi


value: wilczyn

value: Show HN: Supaslides – Create on-brand animated carousels in 60 seconds

author: wilczyn


value:
Hi HN, I built Morning Report because every morning I was losing the first
30 minutes just checking Sentry, Linear, Gmail, and PostHog separately before
doing any real work.
It connects to the tools you already use and compiles a single daily
briefing, organized into five sections: what broke overnight, what you
committed to, what's performing, what needs you, and what happened in the
world. Delivered by email and archived on a dashboard.
The part I spent the most time on: instead of a generic AI summary, you set
your own "editorial voice" in plain English for how you want your data
filtered and prioritized. Something like "only show Sentry errors affecting
3+ users" or "always lead with revenue." It actually follows it every
morning.
Stack: Next.js, Supabase, Inngest for the scheduled collection jobs, Claude
for synthesis.
28 integrations across mail, dev tools, payments, analytics, CRM, and
calendar (Gmail, GitHub, GitLab, Bitbucket, Linear, Jira, Notion, Trello,
Stripe, Razorpay, PostHog, Mixpanel, Sentry, Datadog, HubSpot, and more — a
few marked "soon" as I roll them out).
Free tier connects 2 tools. Pro is $5/month for everything.
Would love feedback, especially on what other integrations would be useful
and whether the "editorial voice" idea lands or feels like overkill.

value: Show HN: Morning Report – daily briefing compiled from Sentry, Linear, Gmail,etc


value: tanavc

value:
Time to first token is 39% faster
Agent wall times decrease by 46%
No swaps
Tracks your resource usage in real-time and adjusts how the model runs so that it works perfectly on your device.
Implements KV cache sizing, prefix caching, live RAM pressure management, context trimming, KV quantization, and more.
Built a ton of features

value: Show HN: Makes local LLMs faster and more reliable by optimizing for your device

author: tanavc


value: Show HN: BetterVideo - privacy-first video enhancement API


value: Show HN: I made a heatmap of 3400 VCs who are open to cold emails


value:
Hi everyone,
I built this tool based on my experience as a financial controller at a Fortune 500 company. The idea is to automate most of the analysis work. All it needs is a general ledger, and you can add other relevant documents if needed(emails, contracts, loan sheets, etc)
I'm trying to make it work with most GL formatting, even the messy ones you can't even filter on Excel(like with Yardi, the ERP I used at my last job). Then you get a dashboard, KPIs and most importantly variance commentary that's also going to tell you if something is potentially incorrect and why. I also wanted to make sure no onboarding, connection or setup was required, it only works with stuff you already have.
I'm intrigued to see if this could be useful beyond the very niche context I built this around(3/4 teams working together, different tools, a lot of info circulating through emails & meetings, stiff organization & Chinese walls). Maybe for SMBs, founders, fractional CFO, etc.
It was a first for me to build something so "complete"(if you haven't guessed yet, I'm not exactly technical), having to setup a database, deployment, authentification, payments and of course API calls for the AI features. The platform itself is just a webapp with no persistence.
There's a free tier with 3 analyses for you guys to try.

value: Show HN: LangevinAI – Automated FP&A for Everyone


value: justswim

value: Show HN: Can you tell the difference between AI vs human-made fonts?

author: justswim


value: yeychenne

value: Show HN: Trains – leaderless total-order broadcast in Rust, formally verified

author: yeychenne


value: supo

value:
See where coding agents struggle, what tools eat tokens and how it all links to GitHub PRs & issues.
I open-sourced a tool that streams data from all your dev machines, VMs & sandboxes into S3. You can run your own analysis from there or use the bundled TUI.
Why I built this: I run a team of ~10 AGI-pilled engineers and struggle to keep track of how the work we do aligns to the milestones/projects we look in planning.
synty helps me identify areas of work that are getting a lot of agent/human attention but they are not accounted for in planning and we use this data to justify re-factoring/documentation efforts to remove friction for agents

value: Show HN: Distributed LLM tracing and GH PR/issue linking [Apache 2.0]

author: supo


value:
I built this website while exploring job opportunities at AI companies. Coming from an economics & policy background (I've done a good deal of research on the business/economics side gen AI, quantum and other emerging tech but I'm not an AI engineer), I wanted to understand how different roles fit together inside these companies.
So I started building a taxonomy to map job postings into departments and functions that is consistent across labs, making it easier for me to understand where each lab is hiring and for what. Out of curiosity, I expanded to see what's hot, etc. in technical areas too. It ended up being both job search and personal research project.
Coming up with a standard taxonomy is challenging. I'm still figuring out matching jobs to functions/departments, looking at other labs, and thinking of alt ways to organize this, eg., I see that companies associate job postings to specific teams, but I still don't have good descriptions of the scope of those teams to create crosswalks. I'm also looking at other companies.
So, sharing it here for others who may find it useful or want to comment. It'd be great to have feedback from those who have insight into how these companies organize their departments/functions, and from technical job seekers too, if this is something that helps them better understand job opportunities. If people find it useful, it could become something I maintain over the longer term (particularly if I don't end up finding a job at one of these labs).

value: Show HN: Frontier AI Lab Jobs – Open Jobs by Function at OpenAI, Anthropic


value: tomaytotomato

value: Show HN: Jensen – a Deus Ex: Human Revolution theme for 30 developer apps

author: tomaytotomato


value:
Kage was always a document format memory with it's own memory standards... and was betting on file based memory + git native.
It's good to see that Google also thinks the same and released OKF(Open Knowledge Format) and Kage has adopted OKF with open arms.
Though Google has released the Memory standard and how to structure the memory, it doesn't do verification, when and how memories are created.
That's where Kage comes in, Kage as a framework works with your agent, understand what to save, when to save, how to save, it also help the agent to recall relevant memory/maintain it's freshness.
Kage is focused on maintaining your repo's memory for you and give you best experience when coordinating and working with teammates on the same repo.
Just install Kage and let you agents do the memory maintenance job itself using Kage.
Best support with Claude Code(Hook), also available and works with all the over coding agents.

value: Show HN: Kage, verification and freshness for Google's OKF agent memory


value: therepanic

value: Show HN: Openleetcode – LeetCode runner where tests live in the repo

author: therepanic


value:
The most common failures for production agents are behavioral: looping, reasoning leakage, user frustration, and more. Using a frontier model like GPT or Sonnet to judge every turn is too expensive and slow to run at scale.
To solve this, we built Reflexes: semantic signals from agent traces, served fast and cheap over API. Built on custom kernels and a custom inference engine forked from vLLM.
Under the hood, it is a small LLM architected around multi-head inference. Small models need to be trained for specific tasks, but running 50 separate small models on the same input for 50 tasks makes no sense.
How it works:
We use a modern LLM with hybrid attention and remove the decode step. We built an inference engine that lets prefill compute be 99% reused from reflex to reflex, similar in spirit to older 2019-era BERT/HYDRA and older multiple-head techniques. we built the inference engine to reuse the KV/cache across inputs and compute across all reflexes. One shared backbone reads the trace once, then many heads classify different signals. Our inference engine reuses the same KV/cache and compute across all reflexes, giving us sub-30ms inference with less than 0.1% overhead for each additional reflex.
We took the same high-level idea and did the hard work to make it work with a modern architecture and attention. On it, we can run inference in under 30ms and serve the full request in under 90ms. If you run 4 reflexes or 100, the extra overhead is less than 2ms.
Why does optimizing this matter?
If you’re even a medium-sized startup, you’re dealing with tens of thousands of agent runs and millions of turns. If you want to track things like user frustration rates over time, frontier LLM-as-judge does not scale.
I built a similar stack at Tesla. When ML engineers needed to sample data across petabytes for signals like `is_camera_obfuscated=true`, along with 200 other things, you need to 1) spin them up quickly 2) run at scale efficiently
What it is not:
A dashboard. 99% of dashboards go unused.
100% API first and made for devs who want to use this to trigger their own stuff.
vibetrain a custom reflex in our dashboard, and/or then let it self improve in production: https://www.morphllm.com/dashboard/reflex
Docs: https://docs.morphllm.com/sdk/components/reflexes/index
I’d love feedback from people running agents in prod: what sorts of things do you wish you could track over time across 100% of turns but cant right now?
TLDR: semantic signals from agent traces, super fast, cheap via API

value: Show HN: Morph Reflexes – Multi-head classifiers for agent traces


value: PJHkorea

value: Show HN: Mathematical fault-Isolation accelerator engine

author: PJHkorea


value: perseusai

value: Show HN: Mimir – local-first encrypted memory for AI agents (single Rust binary)

author: perseusai


value: rafalswietek

value: Show HN: Turning Sentry errors into AI generated GitHub PRs with fixes

author: rafalswietek


value: yresnob

value: Show HN: Veritrace – B2B leads with a source URL on every row, no guessed emails

author: yresnob


value: franticstone

value: Having spent 20 years in video there is a few commercial tools out there but not really an open source one. Used Claude for some front end and made it easier to get my idea down.

value: Show HN: Open-source restreaming and live studio

author: franticstone


value: koliev

value: Show HN: Whenever Alignment Matters

author: koliev

title: Show HN: Whenever Alignment Matters


value: sakuraiben

value: Show HN: TakoVM – open-source sandboxing for your agent's code

author: sakuraiben


value:
Hey everyone, we’re an ex YC team building retail-intelligence.ai where we suggest 5 trades to you every 6 hours.
Our product maps out a strategy with you into logic trees, transforming it into custom signals, live dashboards, and automated alerts.
We’re excited to bring a new experience to retail markets and am keen to see what strategies you have!
You can get your recommended trades here: https://www.retail-intelligence.ai/

value: Show HN: Hinge for Trading

title: Show HN: Hinge for Trading


value: twainyoung

value: Show HN: Free Online GIS Viewer and Format Converter

author: twainyoung


value: Show HN: Yourself, in Every Light

title: Show HN: Yourself, in Every Light