value:
I built Hydra because I kept losing my flow when Claude Code hit usage limits mid-task. I would copy context, open another tool, and then re-explain everything. This would be super annoying for me.
Hydra wraps your AI coding CLIs (Claude Code, Codex, OpenCode, Pi, or any terminal-based tool) in a single command. It monitors terminal output for rate limit patterns, and when one provider runs out, you switch to another with one keypress. Your conversation history, git diff, and recent commits are automatically copied to your clipboard so you can paste and keep going.
The fallback chain is configurable. Mine goes Claude Code → OpenCode (free Gemini) → Codex → Pi (free Gemini). The free tiers alone give you ~3000 requests/day, so even after burning through paid limits you can keep working.
Key details: Full PTY passthrough you see the exact same TUI as running the CLI directly hydra switch from another terminal signals ALL running sessions (rate limits are account-wide) Context extraction parses Claude Code's JSONL session files for real conversation history, not just recent output Any CLI that runs in a terminal works as a provider Single Go binary, ~200 lines of core logic
https://github.com/saadnvd1/hydra
Nothing amazing, but wanted to share with others in case it's useful. Feel free to modify it as you see fit.

value: Show HN: Hydra – Never stop coding when your AI CLI hits a rate limit


value: bootbloopers

value: One of the things I struggled with a lot when doing web development was developing effective CSP directives, so I built a browser extension for Chrome and Firefox to assist in this task.

value: Show HN: A Browser Extension for Testing Content Security Policy

author: bootbloopers


value: nowflux

value:
Wreflecto is a word square puzzle where every row and every column must form a valid word. Read more about ancient word squares here - https://en.wikipedia.org/wiki/Sator_Square
Unlike crossword or wordle, there are many possible solutions. Any valid word combination works. 4x4 (easy) on weekdays. 5x5 (hard) on weekends. Two modes - mirror (https://wreflecto.com/mirror), and cross (https://wreflecto.com/cross).
Daily puzzle is free on web. Built using vanilla JS/HTML/CSS, everything runs in the browser, no backend, no ads, no account/login.
Also turned it into an iOS game with both daily and on-demand unlimited play offline: https://apps.apple.com/us/app/id6751056949
Please let me know if you try it.

value: Show HN: Wreflecto – word puzzle inspired by the ancient SATOR Square

author: nowflux


value: araldhafeeri

value:
Structura is a free, opensource vs code extension that brings next-generation code exploration and analysis to your editor. It transform your codebase into a live, incrementally expanded interative graph that aims to reduce the congitive load, eliminate mice lag, and allow you to present source code to yourself or others in visually appealing and fast way.
Here is the demo link :
https://www.youtube.com/watch?v=Upx4HWUs0y0
In the video :
- Why code exploration needs to evolve.
- Live demo ( quick and longer versions )
- Keybaord-first navigation walkthrough
- Roadmap and what's coming next
Currently : Supports JS, TS, JSX, other programming lanaguge support is planned and help is needed. checkout [parser.md](http://parser.md) in source code
Key-features:
- Incremental graph exploration ( no hair balls ) .
- Neo-vim inspired keyboard navigation ( minimal for maximum movement ).
- near-Real-time graph updates ( extremly fast , noval architecture ).
- Semantic language and visuals of code intent.
- ANd more...
Repo: https://github.com/ARAldhafeeri/structura-v2
Marketplace :  https://marketplace.visualstudio.com/items?itemName=AhmedRak...

value: Show HN: New way to explore code in vs. code ( vs. code extension)

author: araldhafeeri


value: millerjoe

value: Show HN: Partial-zod – streaming JSON parser for LLMs (zero deps, Zod-native)

author: millerjoe


value: techalchemist

value:
Muxforge is a single Go binary that manages tmux plugins the way you'd expect in 2026.
No need to fiddle with adding the plugin the tmux.conf and then installing. You can manage plugins directly with muxforge.
Lock file for reproducibility, one-command migration from TPM, and a managed block in your tmux.conf that keeps plugin declarations clean without touching the rest of your config.
Works with stow and dotfile managers, the lock file is designed to live in version control.
MIT licensed. Would love the feedback.
https://muxforge.dev

value: Show HN: Muxforge Tmux Plugin Manager

author: techalchemist

title: Show HN: Muxforge Tmux Plugin Manager


value: dtnewman

value: Show HN: Zev helps you remember (or discover) CLI commands with natural language

author: dtnewman


value: lackoftactics

value: Show HN: Uncompressed. Media stack with VPN namespace isolation, no public ports

author: lackoftactics


value: paperlantern

value:
Hi, we've been working on Paper Lantern - an MCP server that searches 2M+ CS research papers for coding agents. The coding agent describes its problem and PL returns ranked techniques with implementation steps, hyperparameters, and failure modes.
We tested it on Karpathy's autoresearch framework : where the task is to find better llm architecture and training configs. In autoresearch, the agent proposes an optimization, tries a 5 min training run, calculates the val loss and then keeps / discards if the val loss lowered / increased.
We compared a strong baseline agent (Opus 4.6 + web search) vs that same agent + Paper Lantern.

  - agent + Paper Lantern iterated to a config that got a much lower val loss on 5-min runs

  - we trained the two final configs for 2 hours : the config from Paper Lantern got a 3.2% lower val loss

Two concrete examples :

  1. Both agents tried halving the batch size. The paper-access agent pulled a 2022 paper and scaled the learning rate by 1/sqrt(2) as the paper prescribed. It worked, and further halving kept working. The web-search agent made the same batch change, got worse loss, and moved on without diagnosing the LR.

  2. The with-paper-lantern agent also implemented AdaGC (adaptive gradient clipping, arxiv 2502.11034, published Feb 2025) on the first try with no tuning. Which the baseline agent did not try at all.

If you want to deep-dive:

  - (code) https://github.com/paperlantern-ai/autoresearch-experiment

  - (blog) https://www.paperlantern.ai/blog/autoresearch

If you want to try Paper Lantern yourself:

  - Quick setup: `npx paperlantern@latest`

value: Show HN: Paper Lantern – improving Autoresearch with research knowledge

author: paperlantern


value: varol

value:
I built Mounjy for people using GLP-1 medications like Mounjaro, Zepbound, Ozempic, and Wegovy.
I wanted a more private, focused tracker for logging shots, weight, side effects, progress photos, reminders, and Apple Health data without needing another account.
Would love feedback, especially on the product direction, onboarding, and what feels missing for long-term GLP-1 tracking.
For anyone here who wants to try it, you can redeem 6 months free with code MOUNJYFREE in the app.

value: Show HN: Mounjy – a private GLP-1 tracker for shots, weight, side effect

author: varol


value: cgr-ciprian

value:
Maintaining software goes beyond PR review. Octokraft is a technical debt management platform that helps you ship confidently by validating patterns, consistency, security, and more across your
  repositories. It tracks code friction, development practices, PR reviews, stacked PRs, and more.
It detects architecture drift, learns your team's conventions and enforces them on new PRs, measures test quality beyond just coverage, and shows you which parts of the codebase are getting harder to work in. When something regresses, you know about it before it compounds.
Free for 1 project and you can find a bunch of open source projects already analyzed.

value: Show HN: Octokraft – code health and PR review for AI-assisted teams

author: cgr-ciprian


value:
I’m a data scientist and I find it hard to use Claude Code for SQL - it doesn’t have DB context. so I made yet another database MCP server! only Snowflake support for now.
I had to reconnect with nature after reading native Snowflake MCP setup docs so for my server I’ve made a nice CLI wizard to set up DB connection and install the Claude Code plugin: MCP + skill - you can ask it like `/db write dbt model to rank leads`.
It also has a `plan` tool for complex questions. when you ask a blurry question, it triggers a separate text-to-SQL agent that uses 1. (kinda) RAG for your schema (along with some values) that builds during DB connection (if you agree) 2. subagents to explore your data. 3. planning. This is what Snowflake Cortex is supposed to do, but when I try it, it never finds the right tables.
Database-as-MCP sounds like a security nightmare, but I put a lot of effort into making it safer. I’d appreciate any thoughts on the secure design. by default, CLI asks for select permissions on all schemas, not just information_schema. I’m convinced that it’s impossible to write good SQL without peeking into the data. maybe it's a hot take - share your thoughts!
Everything is free and hosted by me, but rate-limited. In the future, I want to charge for planning calls above the limit. I have a bunch of ideas on how to make a smarter text-to-SQL, so I want to keep this part closed-source. I’ll open-source more though - it’s just deployed as a monolith now.

value: Show HN: DataFrey – MCP server for Snowflake with text-to-SQL agent


value:
Hey HN,
I'm working on a browser automation system via natural language and API calls.
Now you might ask? How is this different than the already existing ones like Vercel browser, browser use, stage hand. e.t.c?
Well none, NONE handles scaling and identity / proxy management for you, you'd have have to use the cloud service, and of course none written in RUST(the best PL ever).
This is excellently useful for companies that wants to keep this parts of their system internal for privacy / cost reason.
Rusty-Browser does.
You just plugin your service account / AMI key (currently supports GCP, AWS) and in less than 30 seconds you are done with the setup.
Now your limitation is how many servers your accounts can spawn. Noticed I said account, it's cloud agnostic and can run on multiple cloud accounts.
You need 2000 browsers running simultaneously for whatever purpose, web bots, trading bots, web scraping e.t.c. RustyBrowser has you.
The beautiful part is it downscales and upscales based on your demand. Once you are done. auto descales to the min servers you've set.
Aside:
1. It also supports local usage
2. We don't dump raw html into the LLM, that's a waste, we leverage the Visual Tree of webpages to tell the LLM what to do, and to save on tokens we use a diff change on that tree so it knows exactly what changes made rather than redumping.
3. Also supports screenshots, however we prefer using it for the task evaluator rather than the instructor.
4. We are purposefully engineering it to work with cheaper, faster models like gpt-5.4-nano which works excellently well in filling out complex forms per our tests.
it's here: https://github.com/dashn9/rusty-browser
Other projects inspired for Rusty are:
(Serverless management and deployment)[Flux: https://github.com/dashn9/serverless-flux ]
(Browser automation, BiDi and CDP)[Rustenium: https://github.com/dashn9/rustenium ]
It took me over three months to build the wonderful projects.
Please star the repo if you think it has some value, would encourage me to take it seriously and work more on it.
All contributions and support are appreciated.
Thanks guys!!!

value: Show HN: I created an open source autoscaling AI browser agent


value: Designed so your portfolio data can last for years as plain JSON files, independent of any broker app or SaaS dashboard. With coding agents and LLMs, it is much easier to build your own asset management software and adapt it to your needs over time. rikdom focuses on the durable layer beneath that iteration: a solid foundation for storing and evolving financial data, plus a plugin system you can extend with coding agents and enrich with reusable open-source plugins.

value: Show HN: Rikdom – Open-source, local-first wealth portfolio schema toolkit


value: Aeroi

value:
Hey HN, I'm Pete.
I'm a boat captain by trade, but I've spent the last 16 months building Camera Search.
Agents in the physical world need a different set of skills to be useful. We've optimized our harness and architecture to specialize in diagnosing and fixing problems in traditional industries like mining, oil & gas, telecom, construction, and the skilled trades.
Existing benchmarks didn't cover what workers in these industries actually do day-to-day, so today I'm publishing FieldOps-Bench on github and Hugging Face [https://huggingface.co/datasets/CameraSearch/fieldopsbench].
It's a 157 case multimodal benchmark across 7 industries, testing visual diagnostics, code/standard citations, and general industrial field knowledge.
I ran it against our agent and the frontier models. Camera Search beat Claude Opus 4.6 on 87% of cases. I scored it two ways: a rubric and pairwise judging.
I'm not a benchmarks specialist, so criticism is welcome, and yes, it's apples-to-oranges because my agent has tool use the baseline models don't. I think it still shows what's possible when you tune the system and corpus for a specific vertical instead of relying on a general-purpose model.
Happy to answer any questions, and would love to connect with people building agents for the physical world. Especially where the stakes are high and the information is incomplete.
-Pete

value: Show HN: FieldOps-Bench an open eval for physical-world AI agents

author: Aeroi


value: danielsdk

value:
how can we make AI agents more accessible?
it has been a crazy journey seeing how AI agents gets smarter every single day but interaction layer is still missing
we are launching Spectrum TODAY: one Unified API connect your AI Agents into iMessage, WhatsApp, Telegram and more

value: Show HN: Spectrum – Deploy AI Agents to iMessage, WhatsApp, Telegram, and More

author: danielsdk


value: Show HN: Resumemind – A developer-first resume builder


value: Show HN: A simple intermittent fasting tracker and meditation timer


value: Show HN: Humanoid.js – One HTML file that scores how human your clicks look


value: bigryanhacks

value: Show HN: Million Dollar Homepage, 21 years later, priced in satoshis

author: bigryanhacks


value: buyukdev

value: Show HN: FMQL – graph query and bulk-edit CLI for Markdown and YAML frontmatter

author: buyukdev


value: razvanneculai

value:
Most AI coding agents assume you have a 200k-context model. In reality, the local models most people actually use have 8k windows — barely enough for one large file, let alone a whole project.
This tool works in three steps:
-Map: on init, it writes plain Markdown context files: one project-level overview, one per folder, plus a line range index for any file over 150 lines.
-Plan: one LLM call reads the map and turns your request into a task list, with dependencies.
-Execute: it gives only one file to an LLM call. A token counter checks before every single call, and falls back to loading just the relevant line range if the file is too big.
Works with Ollama, LM Studio, Groq, OpenRouter, Gemini, DeepSeek, or any OpenAI-compatible endpoint. Local models run sequentially by default, while cloud providers run in parallel.
The hardest part was conversation memory. 8k isn't enough for the full history, and i have tried compression, but it wasn't going to cut it either. The fix was a ring-buffer eviction system of summaries of the last two completed actions. It offers enough continuity to avoid repeating work, while its cheap enough to always fit.
This was something i had been pasionatelly working on and i hope you guys find it usefull. I am open to hearing any feedback and questions.
Thank you for taking your time to check this project out and I hope you enjoy it as much as me.

value: Show HN: I built a coding agent that works with 8k context local models

author: razvanneculai


value: justvugg

value:
Hi everyone,
I built cli-use, a small Python tool that turns any MCP server into a native CLI.
The idea is simple:
HTTP has curl, Docker has docker, Kubernetes has kubectl — MCP should have a shell-native client too.
Why I made it:
MCP is useful, but using it through agents has overhead:
every session pays schema discovery cost
every call carries JSON-RPC framing
responses are often verbose JSON when the useful output is just a line or two
cli-use converts that into a terse CLI so tools can be called like normal shell commands.
Example:
pip install cli-use
cli-use add fs /tmp
cli-use fs list_directory --path /tmp
After that, the MCP server behaves like a regular CLI:
usable by agents
usable by humans
usable from scripts / subprocess.run
composable with grep, head, xargs, etc.
Example:
cli-use fs search_files --path /tmp --pattern "*.md" | head
cli-use fs read_text_file --path /tmp/notes.md | grep TODO
One thing I cared about a lot is agent ergonomics.
Every add also emits a SKILL.md plus an AGENTS.md pointer, so agents working in a repo can discover and use the CLI automatically.
A few details:
pure Python stdlib
zero runtime deps
persistent aliases
works with npm, pip, pipx, and local MCP servers
built-in registry for common MCP servers
I also benchmarked it against the real @modelcontextprotocol/server-filesystem server (14 tools). Depending on session size, token savings were around 60–80%, mostly by removing schema overhead and verbose request / response framing.
It’s still alpha, but already usable.
Repo:
https://github.com/JustVugg/cli-use

value: Show HN: CLI-use – turn any MCP server into a CLI in one command

author: justvugg


value:
I am Rohan, and I have grown really frustrated with CC's search and read tools. They use Haiku to summarise all the search results, so it is really slow and often ends up being very lossy.
I built this MCP that you can install into your coding agents so they can actually access the web properly.
Right now it can:
- search the general web
- search Reddit
- read and scrape basically any webpage
Install it:
npx openalmanac setup
The MCP is completely free to use. We have also built a central store where you can contribute things you learned while exploring. If you find something useful, you can contribute it to the encyclopedia we're building at Almanac using the same MCP.

value: Show HN: Almanac MCP, turn Claude Code into a Deep Research agent


value:
A few months ago I posted this here. Since then I've added a bunch of new assertions: BeSorted, BeSameTime, BeWithin, BeError/BeErrorIs/BeErrorAs, formatted custom messages, and some renames for clarity.
The core idea is still the same — when a test fails, you should immediately know why without having to add debug prints.
https://github.com/Kairum-Labs/should

value: Show HN: Should – Expressive Assertions for Go


value: basilikum

value:
A club for websites with absolutely no JavaScript. Because documents do not need arbitrary code in them.
This was originally not my idea. There used to be a NoJS club on nojs.club some years ago. But it got discontinued. So someone continued its legacy on https://no-js.club. However the list is fairly outdated and many of the sites have added JavaScript in some way since they were added. I found the original domain nojs.club to be free and decided to start my own No JS club on the legacy of the original domain.

value: Show HN: No JavaScript Club

author: basilikum

title: Show HN: No JavaScript Club


value: sakamotosan

value:
Hello, I released a demo for VERDURE today.
VERDURE is a creative sandbox where you grow and shape plants through trimming and pruning. You can also unlock a 'recipe panel' to further customize them and build a entire collection of your creations. I like to try and recreate real plant designs with it. It is a bit unusual.
Can you try it?

value: Show HN: Verdure Demo (Steam PC)

author: sakamotosan

title: Show HN: Verdure Demo (Steam PC)


value: arusekk

value:
It is fairly simple, but useful for non-power users: a statically-linked Qt app that gracefully edits Windows Boot Manager to do a reboot-once into GRUB, which in turn launches ZorinOS live/installer from disk loopback. I needed to make a custom initramfs with dislocker in it, and to squeeze it a little (default Windows EFI partition is not so big).
Currently my biggest issue is that systemd is unable to shut down gracefully when rootfs is mounted from such a deep loop stack. The other is that installing to full disk crashes right after it successfully damages the partition table. I think I could solve both by copying the ISO contents to ramdisk before systemd takes over (initramfs needs to stay slim as I mentioned before) - maybe opportunistically if there is enough RAM (3,5G is not so unreasonable to expect).
I decided to make it paid for now (maybe not eligible for show? if so, sorry, I've been mostly a HN reader so far), but I am still considering if my project brought more good by being free of charge. It is free as in GPL3+ though, so although I can politely ask you not to exercise it too hard until I turn Bad™, you (will) have several ways to obtain it without paying anyway.
The website itself (especially payments) is also an interesting story, I can share it too some day.
What do you think?

value: Show HN: Linux installer .exe without pendrives (secure-boot compatible)

author: arusekk


value: bahulneel

value:
Agent Brain Trust lets you summon a panel of real, named experts to critique your architecture, review your writing, pressure your product strategy, or debate your design patterns. 10 built-in trusts, an extensible roster, and a working turn-taking protocol that ensures nothing useful gets skipped. Guest experts are drafted via an MCP server that maps topics to real persona cards so the panel can reach into niche and novel territory without inventing expertise it does not have.
Wrote up the full thinking here: https://tinyurl.com/agent-brain-trust

value: Show HN: Agent Brain Trust, customisable expert panels for AI agents

author: bahulneel


value: annanay

value:
Hi HN,
We’re excited to share gcx, a new CLI we’ve been building for Grafana Cloud.
With the rise of agentic coding tools like Claude Code and Codex we're building faster than ever, but these agents are often blind to what’s actually happening in production.
gcx brings the full power of Grafana Cloud observability to your terminal. Query production. Investigate alerts. Let the Assistant root-cause issues. Ship fixes with observability built in. Without leaving your editor. gcx also comes packaged with a skills bundle that allow agents to see and act on your production telemetry. You can ask an agent to root-cause a latency spike, and it can actually fetch the telemetry, analyze the spans, and suggest a fix—all while having the full context of your codebase.
Do check it out and give us feedback!
Github link: https://github.com/grafana/gcx

value: Show HN: gcx – The Official Grafana Cloud CLI

author: annanay


value: Show HN: Group Relative Policy Optimization, visualized step by step


value: onsari

value: Show HN: PayClaw – Give your AI agent a wallet it can spend

author: onsari


value: qwikhost

value: Export, Download & Bulk Delete X (Twitter) Bookmarks Effortlessly

value: Show HN: Twitter Bookmarks Downloader – Export and Bulk Delete X Bookmarks

author: qwikhost


value: kitdobyns

value: Show HN: Benchmarking how AI models write vulnerable code under pressure

author: kitdobyns


value: inderrr

value:
Anthropic Managed Cloud is a great way to build and run agents, but it does not provide any governance. We fixed that in AgentLattice.
We just shipped govern() SDK, a single method that sits between your app and Anthropic's Managed Agent runtime. Every tool call (bash, file writes, web fetches) flows through your org's policies before executing.
It evaluates each tool call against your workspace policies. Low-risk tools auto-approve instantly. High-risk tools escalate to humans via alerts and dashboard. Everything lands in a tamper-proof, ECDSA-signed audit trail.
It is very easy to make any agent govern()-able, here's how:

  const al = new AgentLattice({ apiKey, anthropicApiKey });
  const result = await al.govern(agentId, "Analyze this report");

Find out more:
X post: https://x.com/gadbadd/status/2046016210438091196
Blog: https://agentlattice.io/blog/govern-anthropic-managed-agents
Docs: https://agentlattice.io/docs/managed-agents
GitHub: https://github.com/AgentLattice/govern-anthropic-demo

value: Show HN: Govern Anthropic Managed Agents with 3 lines of code

author: inderrr


value: ryan-a

value:
Hey All,
I built this app to solve a problem for myself, my m1 max would regularly run out of battery in 2 hours lately while coding at a cafe. I could never work out what apps were causing the egregious battery life performance, activity monitor wasn't particularly useful.
So I built a power attribution engine with the native apple silicon power readings. Its not perfect, currently it can attribute CPU + Ram usage to the apps, on top of reporting in real time your total watt draw (like stats) and the cpu, gpu, display and usb power draw.
I would appreciate some feedback, and any suggestions for improvements!
I am working on adding GPU attribution and power limiting as while low power mode is handy I think it would be awesome to be able to set a specific W limit for your apps/device.
Cheers,
Ryan

value: Show HN: Individual App Power Usage Tracking on Mac in Native Swift

author: ryan-a


value: PrismerAI

value: Show HN: Agent harness that turns errors into shared genes

author: PrismerAI


value: Therapy, mood tracking, journaling, informal diagnostics, and a few whizzes for convenience

value: Show HN: GBrain, an AI tool for diagnosis and therapy for neurodivergents


value: taoh

value:
I built an open source version of OpenAI Chronicle.
Some design decisions I made:
1. Local first: OCR uses Apple Vision, summarization supports local AI providers via Vercel AI SDK. Nothing leaves your computer.
2. Multiple Provider: exposes MCP so any coding agents can use it.
3. Swift menubar app: efficient, low-footprint
4. Blacklist apps: password managers, messaging apps (Slack, WhatsApp, Messenger), mail clients are on default blocklist.
Current Limitations:
1. Mac only. Mac-first is a feature.
2. Small local models with weak structured-output support will fail on generateObject.
3. Retrieval is LIKE-query keyword search. FTS and optional embeddings are on the list.
Demo video (6s): https://youtu.be/V75tnvIdovc
Curious what you think the right balance between exclusionlist allowlists. Happy to answer anything.

value: Show HN: Open Chronicle – Local Screen Memory for Claude Code and Codex CLI

author: taoh


value: yincrash

value:
Aide is an Android app that replaces your default digital assistant. It can register as your default assistant, so corner-swipe and power-button-hold summon it instead of the Google assistant.
I wanted to do something other than Google, but ChatGPT and Claude's integration couldn't do anything on device, so I built this.
Bring your own key for Claude, OpenAI, or any OpenAI-compatible endpoint (Ollama, LM Studio, vLLM). Keys are encrypted on-device; conversations go straight to your provider.
Free: chat on any provider, multi-provider switching, web search + URL fetching as built-in tools, custom system prompt, markdown.
Pro ($6.99 launch week, $9.99 after, one-time): voice input + streaming TTS, voice-first overlay, photo/file attachments, device actions (SMS/calendar/alarms, every intent confirmed), screen context, Home Assistant integration.

value: Show HN: Aide – A customizable Android assistant (voice, choose your provider)

author: yincrash


value: anju-kushwaha

value:
Interesting to see how they've handled the latency issues across such a diverse geographical footprint while maintaining their core zero-knowledge encryption
https://vucense.com/tech-guides/security-101/proton-vpn-145-...

value: Show HN: Proton VPN expands to 145 countries: A technical look at infrastructure

author: anju-kushwaha


value: ShawFei

value:
I noticed that many long videos are posted on Twitter, and sometimes I prefer to watch them on TV, so I build this App, it can sync bookmarks and list(on the way) from Twitter to Apple TV. I use Apple TV usually, so I build for Apple TV first, android tv will be available soon,I need more time to test it.
Twitter's v2 api is too expensive by the way. So please don't sync too much. here is more intro: https://xttv.islasher.com/

value: Show HN: XTTV, the App to watch long video from Twitter/X on Apple TV

author: ShawFei


value: keepamovin

value: Show HN: Frame-by-Frame Previews of MPEGs and PDFs (Rust)

author: keepamovin


value: morawr

value:
I built a plugin that lets Claude Code delegate work to Gemini CLI.
I started this after finding myself reaching for Gemini more often on long context repo work. I have been especially liking Gemini’s codebaseinvestigator for long context.
This is inspired by openai/codex-plugin-cc.
Code Review, adversarial review. Under the hood its Gemini CLI over ACP
Would love feedback from people using Claude Code, Gemini CLI, or ACP. I am especially curious whether this feels useful outside my own workflow.
Its a great combo with Opus 4.7 + Gemini 3.1 workflows

value: Show HN: Gemini Plugin for Claude Code

author: morawr

title: Show HN: Gemini Plugin for Claude Code


value: Entropnt

value:
Hey all!
I work in quantitative trading, and so far our team’s use of LLMs has barely gone beyond coding. I wanted to find out whether they could contribute to actual trading decisions, and the first step felt like building an evaluation harness.
ModelX is my attempt at that. It’s a prediction exchange where LLMs trade derivative contracts that settle to real-world numbers using fake money.
Market making and market taking require different reasoning processes, so I split the benchmark into two roles: Market Makers and Hedge Funds. MMs post sealed two-sided quotes, while HFs see the residual orderbook and send market orders.
Most traditional markets operate in continuous time, which means speed often determines the winners. I didn’t want to benchmark inference speed, so orders are batched into 30-minute sealed-auction cycles. As long as a model submits before the cycle closes, its orders are matched simultaneously with all other models'.
Each cycle, models see relevant news headlines, recent trades, the current orderbook, and their own inventory. They decide, the engine matches everyone simultaneously, and the loop repeats until I manually settle the market.
I've only been running a single market with free models for the past day or two, but I've already noticed that the models are poor at keeping consistent positional views. The HFs are consistently losing, not necessarily because they entered bad positions, but instead because they continuously hack out of their own positions, giving up the spread to the MMs. I've deliberately kept the prompts minimal so as not to hand-hold the models.
Running more markets and testing more capable models would be some obvious next steps.
Please let me know your thoughts, or if you have any suggestions!

value: Show HN: ModelX – Prediction Exchange for LLMs

author: Entropnt


value:
I built this small website to study chess openings using a visual tree. I personally find it helpful for comparing them, especially on desktop because it supports keyboard navigation. It works well on mobile, though.
It’s simple, has no ads. I decided to make it public in case others find it useful as well. I’ll be adding more openings over time.
I’d really appreciate any feedback.

value: Show HN: Minimal visual chess openings explorer


value: baCist

value:
I built this based on requirements from my wife, who has been teaching German at a university for over 25 years. She genuinely needed a tool like this for this exact topic and started using it in her teaching right away.<p>The main idea was to make learning as comfortable and focused as possible. That’s why the app has:<p>– no ads
– no tracking
– no subscriptions
– A1–A2 verbs are available for free.

value: Show HN: Irregular German Verbs – a simple app, no ads or tracking

author: baCist


value: vednig

value: Show HN: DoShare Personal Cloud

author: vednig

title: Show HN: DoShare Personal Cloud


value: Show HN: Vibe Coding Games in Minutes

title: Show HN: Vibe Coding Games in Minutes


value: kevinhacker

value: Show HN: GPT-Image-2 Prompts

author: kevinhacker

title: Show HN: GPT-Image-2 Prompts


value: timdageno

value: Show HN: Data-driven GEO and marketing agent platform

author: timdageno


value: lftherios

value:
Autoresearch from Karpathy has been one of the most interesting agentic patterns to emerge this year.
The challenge: right now every agent runs experiments in isolation, duplicating work and compute, forgetting findings, rediscovering dead ends. Everyone is running in solo mode.
Community Computer is a collaborative network for autoresearch-like code experiments.
Agents conduct experiments, publish signed results, and build on each other's work. The community reproduces findings on their own hardware.
It’s built on Radicle, the p2p code network built on Git.

value: Show HN: A P2P Network Where Agents Collaborate on Code Optimization

author: lftherios


value:
Hi HN.
Solo iOS middle aged, slightly burnt out dad from the UK here, wondering if anyone is interested in what I've been building.
Lifelong chess fan, not very good but always trying to improve and I started to build Notation: Chess coach a while back.
It's been live a month now on the App Store, doing modest numbers, and I've been learning a lot... mainly make my add brain slow down, stop, test everything twice and never when tired. Submissions will always wait another day!
Many people play on chess com, or lichess, just as many in apps and OTB. What my app does (differently I hope) is bring that data together.
You can import PGNs of your games, connect to chess com and lichess and sync your games over or play in the app.
If you have a Chessnut electronic board, you can play IRL on that as well.
Every game, every move is then analysed by a series of on device detectors, and classifiers. And I'm not talking about"I run Stockfish 18 and get your move evals" like most tools do.... Theres a LOT more to it.
Happy to go into detail in the comments if anyones interested!
Then, it takes all that data (ON DEVICE - No ads, no trackers, no subscriptions, no data sharing unless you want to send it to someone) to create your playing profile, which you can see on a dashboard, or pdf export - its your coaching report - shows you where and how to improve.
Most apps will say Nd6 was a blunder. My app can tell you why. To that end, I created a coach, Nadia, who when enabled in a practice game, will look over you as you play, make proactive suggestions to improve, and talk you through the board positions - on device TTS and templates allow this, with a sprinkling of Apple foundation models.
My principle has always been data privacy, and no subscription.
In the latest version, there is a "Shadow" opponent - Literally play vs yourself - same openings, same weaknesses, same strategies.
Now, I have added (because Apple device restrictions mean running a bigger model on device is not practical right now... come on WWDC and gemini...) a 100% optional feature where you can add an API key for the service of your choice, and use a cloud LLM to help interpret your coaching data - full game reviews, individual position assessments, and coming soon opponent scouting reports that are literally based on how YOU would perform vs that opponent - no one does that, they all do "this person plays x".
But - and I stress - this is optional, and uses the users own api key, so it's their data/choice. I see nothing, and it's a VERY structured payload sent to ensure there is zero scope for hallucination.
Happy to share samples if people want to see the output.
App Store: https://apps.apple.com/us/app/notation-chess-coach/id6759826...

value: Show HN: Notation – an iOS chess coach (Stockfish on device and optional BYOK)


value: TimoKerr

value: Show HN: We benchmarked 18 LLMs on OCR (7K+ calls) – cheaper models win

author: TimoKerr


value: centrali

value: Show HN: Content-mill: Index any static content into Meilisearch via YAML config

author: centrali


value: mmarian

value:
4 months ago, I released an extension for LibreOfffice Writer that adds an AI copilot to its sidebar. Did a Show HN at the time but got no interest T_T https://news.ycombinator.com/item?id=46233776 I’ve added several major features since then, so I figured it’s worth doing another one.
Features added:
- The extension connects to a free online LLM by default, with no signup needed. All you need to do is install the extension and you’re ready to go.
- Can connect to a wide range of online models if you bring your API key (Anthropic, Gemini, OpenAI, Mistral, Groq, etc)
- Can connect to a self-hosted Ollama instance; I’ve also added the option to override the URL so feel free to test it out with other tools.
- You can rephrase text you’ve selected (initially just added the output at the bottom of the document)
I’ve also amassed over 10k installs in the meantime, which is nice.
There’s still a ton of stuff I could add. But I don’t have much time in the evenings, and I’m not sure what’s the next most important thing to do. Any feedback/suggestions would be much appreciated!

value: Show HN: LibreThinker, free AI assistant for LibreOffice Writer, 10k installs

author: mmarian


value: szaglam

value:
kdts is an optimization-first TypeScript compiler. Instead of erasing types as early as possible, it uses them throughout the compilation to direct optimizations, achieving transformations that would not have been possible were the types not known.
Currently it is Bun-only. You can install it with
bun add -g @kimlikdao/kdts
It has two modes: fast and opt.
- fast mode is a thin wrapper around bun build but supports the same command line arguments as opt mode.
- opt mode uses (a fork of) Google Closure Compiler as a backend to perform type-driven optimizations.
Fast mode should work on most valid TypeScript programs:
kdts entry.ts --fast
In opt mode, the sources need to be accurately typed and written in a small but expressive subset of TypeScript for now. Such programs can be compiled with
kdts entry.ts
It currently compiles our kimlikdao-lib in opt mode, including substantial cryptography and decentralized identity code.
I built kdts while working on kimlikdao-lib, where type-driven optimizations seemed very useful, but writing code for Closure Compiler directly was painful and never seemed to get easier. kdts lets you write code in idiomatic TypeScript while still targeting Closure Compiler for aggressive optimization.
kdts is still under active development, but it is already useful for us on kimlikdao-lib. I’m interested in hearing from others who have codebases where this kind of type-driven optimization could be useful, and what features or workflow support would matter most for adoption.

value: Show HN: Kdts, an optimization-first TypeScript compiler

author: szaglam


value: tegs

value:
Our team has been deploying AI agents in enterprise environments for the past 2 years, across 60+ deployments. The same governance problem kept recurring: how do you certify reliability, enforce policy, route and orchestrate context, monitor behavior, and manage agent identity—without bolting together a pile of disconnected tools?
So we built a unified stack and open-sourced it under the Cohorte AI GitHub organization:
TrustGate — black-box AI reliability certification via self-consistency sampling and conformal calibration
Guardrails — declarative YAML policy engine for AI agent guardrails
Context Router — intelligent context routing engine for AI agents
Context Kubernetes — declarative orchestration of enterprise knowledge for agentic AI systems
Agent Monitor — governance-first observability with kill switches
Agent Auth — agent-specific identity and access management for AI agents
All of it is open source, Python-based, and released under Apache 2.0. The architecture is documented in the free playbook The Enterprise Agentic Platform:
Book: https://www.cohorte.co/playbooks/the-enterprise-agentic-platform
GitHub org: https://github.com/Cohorte-ai
The research behind the stack is also public. Charafeddine Mouzouni has published three papers touching the underlying problems we kept running into in practice: exploitation surfaces in LLM agents, reliability certification for AI agents, and routing dynamics in Mixture-of-Experts systems.

value: Show HN: We open-sourced a 6-library governance stack for AI agents (Python)

author: tegs


value: KennyVan

value: Show HN: Tesseron – an API for AI agents, defined by the app developer

author: KennyVan


value: peksi

value:
Ahoy HN!
I'm sure most of you have at least subconsciously noticed that when aligning heading to a layout edge or another element, text always appears slightly indented. This is indistinguishable on smaller font sizes, but starts to be noticeable especially on bigger sans-serif font sizes.
This has been discussed in the internet without any proper solutions. There's even a W3C CSS proposal from 2014 for "font-side-bearings: trimmed" that has remained stale. https://lists.w3.org/Archives/Public/www-style/2014Jan/0242....
This npm-package 'sidebearing-trim' fixes the issue. By extracting .woff font metrics we're detecting starting characters of the visual lines and shift each row by exactly the sidebearing value of its first glyph.
This is my first npm package so please expect it to be still rough around the edges. Happy to hear your feedback!

value: Show HN: Sidebearing-trim – align text to visible ink, not the glyph box

author: peksi


value: Show HN: AICommander – Reliable System-Level Automation


value: Show HN: Browser-based M68K interpreter Release 1.1.0


value: metaphorician

value:
This is an unconventional clock concept, with a North Pole-centered azimuthal world map that rotates counterclockwise once per day, just like the Earth does around its axis when viewed from the north. This makes it possible to see roughly what time it is everywhere on Earth at once. The clock hand is the central longitude of your time zone.
The star map is also shown, in the same projection, as an overlay. The Sun, Moon and planets are also shown, with accurate ecliptic longitudes to within 1 degree max error, but with their ecliptic latitudes ignored – that is, they are snapped to the ecliptic circle for a cleaner look. The star map makes one clockwise rotation once every year, so that the Sun stays roughly at the top of the watch face.
Since the clock's direction is counterclockwise, the hour hand will point right in the morning, up at mid day, left in the evening, and down at night. This takes some getting used to, but in my opinion, this is the direction clocks ought to go, since it makes it possible to have this kind of a clean, map-based world clock. The reason clockwiseness is the way it is has to do with sundials, which flips things relative to how the Earth actually moves.
The positions of the Sun, Moon and planets are where you see them in the sky. This means that if you can identify one celestial object, you can see on the watch face where to expect the others. E.g. if the Moon is up, and you see on the clock that Jupiter is supposed to be 90 degrees to its left, you should be able to see it if you turn 90 degrees left from looking at the real Moon – given that it is above the horizon. There is no horizon indicator on the Wear OS watch face, but there is at the bottom of the explanation page, so you can get a rough idea of what you can expect to be above the horizon.
The motivation and hope for this watch face is to reconnect timekeeping with the astronomical events it really is about, and also have it be a constant reminder on your wrist to look up and learn to identify planets and stars. We live inside this beautiful celestial sphere that we spent millennia figuring out, but then lost contact with because of mechanical clocks, various abstract timekeeping conventions, and artificial light.
The website contains a thorough explanation of how to read the clock, with visualizations, as well as two long articles, one about astronomy, with a lot more interactive visualizations, and one about the history of astronomical timekeeping. If you don't have a Wear OS, you might still find these interesting reads.

value: Show HN: Spacetime Watch – an astrolabe-inspired astronomical Wear OS watch face

author: metaphorician


value: Bgach

value: A free tool that analyzes a company website and turns it into a simple customer targeting plan.

value: Show HN: A free business analysis tool powered by AI

author: Bgach


value: zengjiajun

value: Show NH: Elytro – self-custodial agent wallet

author: zengjiajun


value: toygard

value: I built Meshgrid because I wanted a reliable way to communicate when internet access is spotty or non-existent. It’s a pure P2P mesh implementation for iOS. I spent a lot of time optimizing the low-level socket handling to ensure the app remains stable under heavy peer load without hitting memory limits. Open to any technical questions about the networking stack! https://meshgrid.org

value: Show HN: Meshgrid – A peer-to-peer mesh networking protocol for mobile devices

author: toygard


value: gkirira

value:
I built a small production monitoring system in C++ to explore what a modern backend runtime could look like without heavy frameworks.
It monitors HTTP endpoints, tracks uptime and latency, and streams updates via WebSocket.
The goal was to keep the system simple and understandable, with a clear architecture:
domain -> application -> infrastructure -> presentation
It runs on a low-cost VPS and handles real traffic.
This is powered by Vix.cpp:
https://github.com/vixcpp/vix
Source code:
https://github.com/GaspardKirira/PulseGrid
I’d appreciate any feedback, especially on architecture and design decisions.

value: Show HN: PulseGrid – real-time monitoring in C++

author: gkirira


value: BundyBear

value:
Burnish is a UI for MCP servers. You point it at a stdio or SSE endpoint and it renders each tool as an interactive form from the tool's JSON schema, then maps the response to a card, table, chart, or pipeline view based on the shape of the JSON. No LLM involved. The point is to see what a server actually does without wiring up a chat client or writing an inspection script.
MCP Apps (the official ext-apps extension) lets servers ship their own custom UI, but only if the server author builds one. Most don't. Burnish works with any server, including ones that have never heard of it, because it reads the schema and infers components from the output shape.
The hosted demo above runs a showcase server with 34 tools. Locally: `npx burnish -- npx -y @burnishdev/example-server`. Source is AGPL-3.0: https://github.com/danfking/burnish.
The thing I genuinely want to know is whether a generic explorer like this solves a real problem, or whether chat clients and MCP Apps already cover it well enough. Feedback welcome.

value: Show HN: Burnish, a UI for any MCP server (no LLM, no chat)

author: BundyBear


value: ResPublica

value: Show HN: Res.Publica democracy dashboard, Germany's political data as React app

author: ResPublica


value: mperlak

value: Show HN: Scan your Airtable base and get a Postgres migration plan

author: mperlak


value: thatcherthorn

value: Show HN: Infinite Lofi Radio Station Composed Live by Claude Code

author: thatcherthorn


value: soyasis

value:
Hi HN,
Cai runs actions on your selection via ⌥C, pick an action (AI, shell, GitHub issue, Linear ticket), done. Bundled local model (MLX Community), create custom actions with prompts, scripts and more.
Free, MIT.
Built after my Raycast extension sat in review queue for 3+ months. Wanted no typing, no app switching, no cloud.
Repo: https://github.com/cai-layer/cai
Demo: https://youtu.be/LH2MYNQ_wsk

value: Show HN: Cai – Local AI Action Layer for macOS (Free, MIT, MLX)

author: soyasis


value: WasimBhai

value: Show HN: Rapunzel – a tree-style terminal for AI agents

author: WasimBhai


value: talsraviv

value: Show HN: Every 4s, Familiar OCRs my screen into Markdown (open source, local)

author: talsraviv


value:
Hi, I built Postchi an api client. I started working on this because I didn't like that I couldn't see the whole request at once, every other app has the same ui where the request is split into tabs. as time went on I figured I make it into a whole app!.
Now I am really trying to pay attention to the developer experience with carefully put ui interactions and shortcuts.
it is built with tauri so it is fast and small.
some of the features:
It can sync with open api and update the requests as they change. it also provides better auto complete and linting when a spec is present.
it is local and everything is stored in text files the same way that they are shown in the app itself.
all the envs are defined in one file so you can scan them easily.
it does support scripts and also standalone scripts that don't require a request, which are called actions

value: Show HN: Postchi, An ide like api client, clean and local


value: drgeorgealex

value:
I’m a surgeon and have been experimenting with the idea that AI may need a more structured interface than raw natural language.
I built an early prototype called GALEN.
Instead of sending long-form speech or text directly to an AI model, GALEN converts it into a compact, structured instruction format first:
speech/text → structured representation → AI
The aim is not only to reduce token usage, but also to improve consistency, determinism and reliability across different AI systems.
So far the prototype appears to:
- reduce AI input overhead by roughly 30–70%
- work across multiple domains (healthcare, legal, finance, travel, etc.)
- allow the same structured instruction to be sent to different models
Still very early and patent pending. I’m trying to work out whether there is genuinely a useful product here beyond the prototype.
Demo: https://galenvoice.com
Would really appreciate any thoughts or criticism.

value: Show HN: Galen – a structured layer between humans and AI

author: drgeorgealex


value: piotrwilczek

value:
I made a small skill/script for agentic coding workflows:
https://github.com/panpeter/sift-skill
The idea is simple:
when a command like cargo test, pytest, npm test, or ./gradlew test prints a lot of output, that raw log often gets pulled into the context even though only a small part is actually useful.
Sift runs the command, captures the full output, and asks a nested cheaper agent call to return only a compact summary. The goal is to keep the main thread smaller and easier to work with.
In one command-heavy Codex workflow I used as a baseline, this looked like roughly ~45% lower total token cost. That number is an estimate, not a benchmark claim, and it will depend a lot on the workflow. It should help most when commands produce large noisy logs. It probably does very little for short commands.
Would be interested in how others handle this problem in Codex / Claude / other coding-agent setups.

value: Show HN: Sift – save AI tokens in Codex/Claude by summarizing command output

author: piotrwilczek


value: Show HN: Scalple – Structured production DB access with an immutable audit trail


value:
Reinhardt is a Rust web framework where one component DSL compiles to both WASM (client) and server-rendered HTML — a single file describes both sides of a page, with no separate frontend codebase, no JS build toolchain, and no duplicated types across the client/server boundary.
It also bundles what Django/DRF users expect: an ORM with auto-generated migrations from #[model] macros, DI, auth, admin, REST, background tasks, and i18n. Feature flags let you pull in just what you need (minimal / standard / full), or import individual crates directly.
I built it after moving from Django/DRF to Rust and repeatedly re-assembling the same Axum + ORM + migrations + auth stack for every project.
Quickstart: https://reinhardt-web.dev/quickstart/
v0.1.0-rc.18 release: <https://github.com/kent8192/reinhardt-web/releases/tag/reinh...>
Crates.io (published as reinhardt-web; the shorter name was taken): https://crates.io/crates/reinhardt-web
BSD 3-Clause.

value: Show HN: Reinhardt – Django-style Rust framework; WASM+SSR from one DSL


value: andredourado

value:
I've built software for clients for 38 years and kept hitting the same wall: weeks spent scaffolding the data layer and the Clean Architecture around it before any real work begins.
I asked Claude to estimate how long it would take to generate a complete "Access Control" app using Claude Code: 40 entities, 1,604 files, Clean Architecture, RBAC, tests. The answer: 50–80 hours and up to $350 in API costs.
ClickMVP generates the same output in under 2 seconds. No LLMs in the generation pipeline. Pure Jinja2 deterministic templates with a library of 13,799 entities extracted from real enterprise ERPs.
Because the engine is Jinja2, adding support for a new stack is just a new template set, no retraining, no fine-tuning. Currently generating Node.js + Prisma + React + Vite. Next stacks will follow user demand.
What you get: editable source (no lock-in), unit + integration + E2E tests, auth, RBAC, Swagger, storage, plus CLAUDE.md/AGENTS.md so Claude Code or Cursor can take over with full context from there.
It also ships an MCP server with 9 tools, so Claude Code can drive the generator directly: inspect the entity library, scaffold new modules, and iterate on the generated project without leaving the editor.
After generating, there's a 2-hour live preview so you can click through the app before downloading anything.
$50/year, 7-day trial, no credit card.
Demo without signup: hn@clickmvp.com / demo123
Happy to answer questions about the template architecture, the entity library or the MCP design. Feedback welcome.

value: Show HN: ClickMVP – Deterministic full-stack code generation (no LLMs)

author: andredourado


value: eoffermann

value:
Hi HN, Eddie here. My project BigBlueBam is a self-hosted, MIT-licensed Work OS with a unified backend with native MCP, "AI as Users" rather than bolted-on chat widgets. The deploy script will stand up the full stack (local Docker container or push it to Railway) in about the time it takes to make coffee.
What's live in the build:
 * Bam (project management/Kanban)
 * Banter (chat with LiveKit voice/video)
 * Beacon (knowledge base with a graph view)
 * Brief (collaborative docs)
 * Board (infinite canvas whiteboard)
 * Bolt (workflow automation)
 * Bearing (goals and OKRs)
 * Bond (CRM)
 * Blast (email campaigns)
 * Bench (analytics and dashboards)
 * Book (scheduling)
 * Blank (forms)
 * Bill (invoicing)
 * Helpdesk
The architectural bet I cared about most: MCP is the execution substrate for the whole suite, not a "feature". 340 MCP tools (and counting) registered across the apps. Agents and Bolt automations call those tools through the same registry, same auth, same data, and the MCP tools replicate any action a user can take in the UI.
Why I built it: honestly, out of annoyance. I wanted my own ticketing+Kanban and I'd started hacking on that and a Slack-alike in my spare time a while back. Recently I picked several old projects back up with Claude Code and started thinking what I'd do differently if I built them from scratch. MCP integration came up because I’ve been doing a lot of smaller MCP Server work, and I got carried away once I saw how much leverage I was getting from the unified data backend + shared MCP tooling. Once that clicked, each new app in the suite was less work than the last, and agents got more capable with every tool I added.
Try it: git clone, run ./scripts/deploy.bat, (or .sh or .ps1), pick Docker or Railway, answer a few prompts, and you're up in a few minutes. MIT license, full source, no telemetry, no feature gates. If you skip setting up a userid/password during install, it’ll have you create a SuperUser account the first time you hit it.
Railway deployment does have a couple minor notes since their graphql API can’t do everything; You can pick up a detailed overview of how that works in docs/railway-runbook.md
What's rough, and where I'd value feedback:
1. Local Docker won’t set up certs for HTTPS, so MCP tools can only be accessed at http://localhost/…
 2. Voice and video in Banter works via LiveKit, but I haven't tested it recently and hasn't been pushed into the corners of the suite where it belongs. Treat it as alpha. My intent is that any collaborative space is calling-enabled, ie., “we’re all in the same room” and less like calling is some special thing that you “do over there”.
 3. LiveKit agent layer is skeletal today. The next month is focused on standing up real agent participation in voice and video calls, built on local models (I have a lot of background in voice AI.)
 4. Service account management is very new and not as granular as I’d like. This is true for human user management as well. Permissions are fairly coarse. It'll get there.
 5. Templates of various kinds need to be reworked. A lot has changed underneath them since they were created.
 6. Slack and GitHub integration haven’t been used in anything like Production yet. Slack because Banter replaces it so it's low-p for me, and GitHub because I’ve actually got a LOT more I want to do with it.
 7. A suite this size needs real users hammering on it. Synthetic data plus a handful of human testers only catches so much. If you spin it up and break something interesting, raise an Issue. That's the most useful thing anyone can do for me right now.
Stack notes for the curious: Fastify v5, Drizzle, React 19, TanStack Query, Redis, MinIO for files, BullMQ for jobs, LiveKit for WebRTC, Qdrant for vector search (picked over pgvector for hard-delete semantics and built-in RRF), Yjs and Hocuspocus for CRDT in Brief and Board, Turborepo monorepo.

value: Show HN: BigBlueBam, MIT-licensed Work OS where agents are first-class coworkers

author: eoffermann


value: yukunqiu

value:
Over the past few months, as we scaled our internal AI Agents, we hit a dead end: Running LLM-generated arbitrary code in Docker is basically running naked on security due to container escape risks. But using full traditional VMs takes minutes to boot and eats too much memory to support high-density concurrency. We loved the developer experience of SaaS sandboxes on the market, but they are closed-source, expensive, and have too high a barrier to entry for self-hosting.
So, our team decided to build our own. After months of grinding, using RustVMM and KVM, we built a blazing-fast, ultra-lightweight secure sandbox service from the ground up: CubeSandbox. Today, we are officially open-sourcing it.
To balance security and performance, we stripped the underlying OS to the absolute extreme. Here’s what it can do right now:
1. <60ms blazing-fast cold start: End-to-end latency is under 60ms, making it 2.5x to 50x faster than traditional secure sandbox solutions.
2. <5MB extreme memory footprint: Memory per instance is kept under 5MB. A single 96-vCPU physical machine can easily run 2,000+ sandboxes concurrently, reducing storage consumption by 90%.
3. Massive concurrency scheduling: Capable of spinning up hundreds of thousands of instances in minutes.
4. True kernel-level isolation: Every Agent gets its own dedicated Guest OS kernel.
5. Native E2B SDK compatibility: Just swap a single URL environment variable. Zero code changes required for smooth migration and hosting.
Also, a millisecond-level “snapshot rollback” feature is coming soon…
Before opening the repo today, CubeSandbox has been running silently behind the scenes in Tencent Cloud, serving massive real-world AI Agent workloads in production. As we open-source it today, it is no longer a prototype, but battle-tested, production-ready infrastructure.
Today, we hand it over to the community. Because we believe that high-performance agent infrastructure shouldn’t be exclusive to a few—it belongs to every developer worldwide who demands ultimate security and freedom.
The project is still in its very early open-source stages, and we are really looking forward to your hardest critiques and architectural roasts. I’ll be hanging out here all day to answer your questions. The source code and deployment guides are all in the README. Come play with it!
https://github.com/TencentCloud/CubeSandbox

value: Show HN: We built a <60ms, open-source alternative to E2B using RustVMM and KVM

author: yukunqiu


value: Show HN: Tmuxx – simpler tmux, fewer keystrokes, no duplicate groups


value: davidsojevic

value:
After seeing the 1D-Chess project on the Hacker News front page somewhat recently, the idea came to me to try and make a CSS-only version of 1D chess because it seemed like it might be a good candidate for it.
There is absolutely no JS used for the interactivity or game state for this variant; it's all pure HTML + CSS, and I've added a few fun things along the way just to exercise those constraints a bit more, too.
I've also got a "making of" post for the project linked to from the about box on it if you'd like to learn a little more about how I put it together.

value: Show HN: CSS-Only 3D/2D 1D Chess

author: davidsojevic

title: Show HN: CSS-Only 3D/2D 1D Chess


value: Show HN: An MCP server that fact-checks AI bug diagnoses against AST evidence


value: mohidbutt

value:
1. CC / Codex dont handle API Docs well enough
No matter what I do, I run into bad requests with claude, day in, day out.
Its making up arguments, misunderstands required types, and misses fields in the requests. And when it catches its issues, the then inititated web search usually ends fuzzy scraped information, that yields even more issues.
Context7 helps. Its better than starting only with the LLM's vague (mis)understanding from pretraining. But it only does semantic search. And often times, semantic search is not precise enough for hyper-precision needed for API requests: CC runs into the same misunderstanding issues as above. And burns tons of tokens in the process.
2. What about Determistic Search in OpenAPI Specs?
In my opinion agents need 1) understanding the damn thing holistically, and 2) ability to do some type of agentic search within the docs.
Thankfully, we do have magnificiently standardized formats for API schemas, most notably OpenAPI/Swagger. Why is no one (to my best knowledge) making use of it?
As I need to work a lot with APIs, I started to build something myself few months ago.
In the end its a simple python script that splits the JSON/YAML/RAML/etc files into a) a holistic overview ("manifest"), and b) indexed chunks (by endpoints, tags, and schemas) md files.
Agents can access via MCP. It takes a) convert local files, or b) community-converted files, and give the agent the capability to do agentic search on the specs. You can check it out out here, and hook up the MCP server: https://github.com/mohidbt/api-ingest
3. Should we benchmark this? // Feel free to contribute!
WDYT? I am thinking about quantifively corroborating my assumptions, by doing some type of evals. And yes, this by endpoint indexing approach also has many limitations. I.e. when the individual chunks are themselves way too big to load fully into context.
Geniunely curious about all your thoughts
PS: Yes, for many - especially AI-tech - companies, we already have agent optimized API doc formats, like llms.txt in the docs, or skills built for using the APIs; and thats wonderful!
But whats with, i.e. Semantic Scholar Graph APIs? What do you do if core CC & Context7 fail? Check out this example: https://github.com/mohidbt/api-ingest/tree/main#opus-47-exam...

value: Show HN: API Ingest – Agentic Search (Inter) API Docs

author: mohidbutt


value: friedchocolate

value:
Hi HN,
stonks-cli is a terminal investment portfolio tracker with live prices, P&L, stock financials, candlestick charts, news feed and AI chat bot
I built stonks-cli because I noticed I kept opening broker apps/TradingView/FinViz/Yahoo Finance multiple times a day just to check portfolio value, financial quotes, charts, different metrics, analyst insights and news.
So I asked myself if I can have all this functionality in one app, preferably in in the terminal.
What began as a small helper script turned into a terminal-first investment dashboard that now supports:
* candlestick charts inside the terminal
* stock fundamentals and analyst insights
* crypto tracking
* portfolio news feed
* watchlists
* importing portfolios from Interactive Brokers
* an AI assistant that analyzes portfolio risk and news using RAG
Try it with a demo portfolio (out of the box):
$ pip install stonks-cli
$ stonks demo
I'd really appreciate feedback from people who manage portfolios from scripts, spreadsheets, or the terminal.
GitHub:
https://github.com/igoropaniuk/stonks-cli

value: Show HN: Stonks-CLI – track your investment portfolio from your terminal

author: friedchocolate


value:
I’ve been working on a small news app called Sift.
Looking for honest UI/UX feedback.
In screenshots the UI looks clean, but on real devices after installing it feels different — slightly dull / less crisp/ greyish. I can’t figure out if it’s colors, typography, spacing, or something else.
Would really appreciate direct feedback on:
what feels off or generic
anything that reduces the “premium” feel
Also not sure if this could be due to display differences or iPhone settings.
Blunt feedback is welcome.

value: Show HN: Sift – a minimal news app (looking for UI/UX feedback)


value: jusasiiv

value:
I have been trying out numerous AI agent setups to find out which one I would like to run as my personal assistant. One thing that kept constantly bothering me was dealing with API keys, especially those that need jumping through hoops to keep working. Not an uncommon sight was trying to get my agent to fetch me some data or post to X/Twitter and then it would return an error as my API key had stopped working.
So I built a tool that you can give to your AI agent and with one API key it can call all of the services. The tool acts as a central auth and handles individual API's requirements like refreshing tokens, making sure rate limits are adhered, sends the correct user-agents and everything else that each API might require.
At first I wanted to provide all of the users no need to setup their own API keys, but that proved to be impossible. Most API providers state in their ToS that proxying the API is prohibited. Also there was the problem with identities: if an agent posts to Reddit or X the post is from the shared account. So I decided to add a bring-your-own-key architecture where you can setup your own keys (if you want to!) but the tool still handles all the token refreshing etc. Some generous services allow pretty lenient use of their API so I included those ready out of the box, no config required to getting started!
Right now I am happy using this tool myself but I wish more people used it so that I could work on improving it. Since I am a single dev there is a lot of work, I am adding new providers every day, fixing bugs and all that. But if anyone would give me their honest thoughts and tested the features I could work on improving the tool even more. There is an option to pay for the usage to cover some running costs but the free tier is more than enough to get building.

value: Show HN: Ohita – a tool to simplify API key management for AI agents

author: jusasiiv


value: artembugara

value:
Hey HN,
Artem and Maksym from NewsCatcher here.
Some of you know us as we started six years ago as two freshly graduated economics students who decided to build the best news API product.
We started NewsCatcher thinking the market for news APIs was so big that we could build a self-serve platform and get millions of $29 users.
Obviously, it was a wrong assumption. We pivoted to serve enterprises and had success with it.
But we are hackers at heart, and we want to serve hackers.
We haven't used our Launch HN yet, so consider this our smoke test.
We're looking for feedback and power users rather than revenue. So, happy to provide enough credits for any HN user who finds CatchAll useful.
CatchAll is built for one thing: retrieving every matching event from the web. The use cases that fit it are ones where missing events have real consequences — funding and M&A monitoring, regulatory and compliance feeds (FDA approvals, SEC filings, policy changes), cybersecurity incident tracking, supply chain signals.
If your pipeline consumes structured records and the answer to your query is "find all of them," that's where it works. It's not the right tool for small, bounded queries that return 5 high-precision results.
The 15-minute job time is a direct consequence of the pipeline depth: analyze, fetch, cluster, validate, extract, deduplicate. You're not getting a ranked list of links; you're getting a verified record set.
Our latest benchmark run: https://newscatcherapi.com/blog-posts/web-search-api-benchma...

value: Show HN: CatchAll – slowest web search API that outperforms everything on recall

author: artembugara


value: brandonmb

value:
Momentum is a way to showcase what you're shipping.  Things are moving faster than ever with Claude Code and Codex, and it can be hard to keep up or even share your own progress effectively.  At the end of the day, the code is the progress and what runs in production, so a friend and I built this as a fun weekend project to explore the space.
Momentum grabs your PRs (backfilled up to 90 days), generates summaries of each one, calculates relevant statistics, and summarizes the narrative arcs of what's been shipped recently.  We also use the project website to grab a logo, colors, and writing style (this can updated in the settings).  You can edit PR summaries and narrative arcs as well as add customer quotes.  As new PRs get merged to main, it uses a webhook to keep things up to date, creating new summaries and trends.
Here's a few I created from open source projects that I forked:
* https://app.heytangent.com/momentum/pandas
* https://app.heytangent.com/momentum/shadcn-ui
* https://app.heytangent.com/momentum/kibana
Note that when you sign up, it requests access to your repos so it can access the PRs.  It uses each PR to create a summary and only provides a link to the PR if the repo is set to public.  Otherwise, only the summary is shown.  In the Settings page, you can delete everything and then revoke the Oauth token in GitHub should you choose to.
Let me know if you have feedback or questions!

value: Show HN: Momentum – showcase what you're shipping

author: brandonmb


value: uguryekta

value:
In the past 4 years, we developed a platform generating 3D visuals and deploying AR Try-on experiences into large footwear and retail companies. We focused on high-fidelity meshes and textures since the point was giving shoppers a realistic visual.
Then robotics companies started to approach us and they asked for thousands of 3D assets that they can use in creating different simulation environments. This is crucial for them so they can achieve better sim-to-real transfer with domain randomization (train a humanoid in a million different kitchens so a real one is not a surprise when it is deployed in the real world).
However, we realized nice geometry and pretty textures are not enough for sim engines as they lack physics properties.
So we developed a new pipeline creating SimReady assets in OpenUSD and MJCF that plug directly into Isaac Sim and MuJoCo.
- Mass: volume from the mesh, density from material classification by a vision-language model (approach adapted from NeRF2Physics), multiplied together.
- Center of mass, static/dynamic friction coefficients and restitution from the same material classification and estimation priors.
- Collision meshes via CoACD; adaptive hull count is in progress.
- Geometry and texture optimization, plus file format conversions.
- We are currently focused on physics property estimation for props. Next step: articulated objects
It comes with free credits on easy Google sign-up so you can give it a test. No credit cards required.
Still early. All we'd ask is honest feedback. What works, what doesn't, what you wish it did differently. That's worth more to us than anything right now.

value: Show HN: Physics-accurate 3D assets for robotics simulations from any input

author: uguryekta


value: matroid

value: Show HN: Move Lights in a Photograph in 3D

author: matroid


value: vijgaurav

value: Show HN: Qwen Lens Studio – multimodal app on Qwen3.6-35B-A3B, runs on Ollama

author: vijgaurav


value: anniebuilds

value: Show HN: PokeDemo: Create click-through demos you can self-host

author: anniebuilds


value: Dahvay

value: Show HN: Map – Receipts and rollback for AI agents

author: Dahvay


value: TimLeland

value: Someone recently asked me if I knew of a tool that could listen to audio from a mic and translate it into other languages in real time. For example, an English speaker, but you have Spanish speakers in the audience. I couldn't find a good free solution, so I built my own that uses Chrome's native APIs to do it all in the browser

value: Show HN: Free Live Speech Translator

author: TimLeland

title: Show HN: Free Live Speech Translator


value: dbuxton

value:
Hi! Everyone I've shown this to has been confused that it didn't exist already, so thought I'd share with the wider community.
All the Google Docs MCPs out there seem to be broken in annoying ways so I thought I'd make one. For instance they do character-offset-based editing and LLMs are reliably terrible at counting characters.
This one just works. (It uses the similar pattern-matching search and replace that code editor harnesses use for file editing to minimize token usage and latency).
There are some showstoppers still. The most annoying is that Google Docs comments API is has been broken for over a decade (sic). I (well, Claude) build a workaround that involves inserting a bookmark with the Apps Script API and linking to that bookmark from the comment. It's hacky but for a lot of LLM-based workflows like contract review or similar it gets you 80% of where you want to be - you can say something like "add comments and john@lawfirm.com for anything that you want their opinion on".
I hope people find it useful. Install involves the usual dance with Google Cloud API console; apologies in advance for taking some happiness from your day.

value: Show HN: Google Docs MCP that works

author: dbuxton

title: Show HN: Google Docs MCP that works


value: fliellerjulian

value:
Im a triathlete and the data for my training lives in 6 apps: Garmin, Strava, WHOOP, Intervals.icu, Wahoo, Withings, Apple Health, sometimes Hevy.
Every morning Id eyeball a few of them and make a call on whether to do the planned session.
For the past month I have been building a thing that does this for me, and got it to the point where I use it myself every day.
It OAuths into whatever platforms you connect, reconciles the activities (tbh harder than it sounds — same ride shows up in Strava, Garmin, and Wahoo with different timestamps and rounding), computes daily load and readiness, and proactively messages you over Telegram or Whatsapp when something matters.
Stack is straightforward: Typescript all the way, Postgres, an agent loop running on Claude (via Bedrock) with tool access to all your data + my computed metrics: zones, CTL/ATL/TSB, power/pace curves, anomaly detection on HRV and RHR, etc
Two things that were harder than expected:
1. Garmins API only exposes the last 90 days. So for anyone with Garmin as their primary device, you have to backfill from Strava and stitch the two together.
Strava has full history but misses some fields (e.g. HR-based TSS only — no power).
Wahoo and intervals.icu fill different gaps. The dedup pipeline is ugly and I'd welcome feedback from anyone who has solved this better.
2. Deciding when to message vs. stay silent is entirely a product problem. Too chatty -> muted. Too quiet -> feels dead.
One honest caveat though: no RCT data, and Id be skeptical of anyone who claims they have it for AI coaching at this stage.
I am at ~50 paying users, I personally reach out to every user to build the next iterations of the product based on feedback.
Already got testimonials from Ironman world championship finishers and other pro athletes.
Theres also a $9/mo MCP tier for people who would rather pipe their data into their own Claude/ChatGPT.
Happy to go deep on any topic! e.g. the tool-calling architecture, or the cost-per-user question (running an agent on every athlete daily is not free, and the margins here are worth discussing).

value: Show HN: AthleteData – AI coach for endurance athletes that messages you first

author: fliellerjulian


value:
Over a year ago I started Actionforge, a managed/self-managed visual CI/CD platform. Just for fun, because I like building and experimenting with dev tools. Back then I thought the user would be a human with a keyboard and a mouse.
These days I rarely write pipelines. I mostly write specs, an agent dumps 500 lines of YAML, Python and a Makefile then I get my artifacts. The amount is overwhelming and a liability, and I stop trusting what I just merged. So I pivoted my CI/CD project toward more visualization, analytics and data aggregation, so engineers can see what agents and the pipeline produced, the flow, steps, data. Where it fails. With that I have a better mental model instead of a blob of code.
The goal is better observability, and pipelines that explain their own failures back to the next agent. And also with a personal focus on UX and design. My project supports Perforce P4, Git/GitHub and GitLab, so quite flexible.
Would love to hear your impression.
I'm also very interested in your CI/CD horror stories, and how you use them these days. Any input is much appreciated!
P.S. Code is public and provides GitHub Attestations.

value: Show HN: A visual CI/CD system

title: Show HN: A visual CI/CD system


value: pzxc

value:
I used to run a flash games website (SWF files) years ago. I've made a few games of my own. I'm also an avid gamer and love to play games of all kinds.
I'm also a software engineer, and a few days ago I decided I wanted to run a games website again. So I bought the domain gamevibe.us and with the help of Claude I've been vibe-coding one video game every day since.
Happy to answer questions, take feedback, etc -- don't hold back, I know it's pretty elementary so far

value: Show HN: Making video games every day with Claude (Day 9: Pong Paralyzer)

author: pzxc


value: mrothroc

value:
I built a tool for quickly testing different ML architectures. Define a model in JSON, train on your Mac (Metal) or ship the same config to a cloud GPU (CUDA). No code changes between platforms.
Why: I wanted to compare attention vs Mamba vs GQA at different parameter budgets without writing PyTorch for each experiment. Edit a JSON config, hit enter, see loss numbers. It will race different configs for you. The number one goal is iteration speed.
JSON config lets you chain together common ML blocks (attention, GQA, mamba, RetNet, and several more) and optimizers (muon, adamw) and compiles them to MLX IR, which can either run on Metal or CUDA backends.
Why Go: 1.6s builds, built-in profiling (mixlab -cpuprofile gives you a flame graph), import-based extensibility for custom blocks. No C++ extensions, no custom build systems. And personally I prefer strongly-typed, compiled languages.
On a Shakespeare benchmark matching nanoGPT (6L, 6H, d=384, 10.8M params): val loss 1.5527 on M1 Max, 1.5588 on A40. PyTorch numerical parity confirmed to 8 decimal places.
brew install mrothroc/tap/mixlab
https://github.com/mrothroc/mixlab

value: Show HN: Mixlab, an ML arch lab in Go. JSON config, Metal and CUDA, 1.6s builds

author: mrothroc


value: ethanjamescolez

value:
This is an independent Hermes Agent install guide I put together for the part that usually gets skipped after "run this command."
What I wanted was one place that shows the environment choice first, then the official installer path, then the first commands people usually need right after install. The practical routes here are macOS, Linux, WSL2, and Termux.
The flow is intentionally narrow: choose the host, run the official installer command, reload the shell, then continue into commands like hermes, hermes model, hermes setup, hermes gateway, hermes doctor, and hermes update while keeping the official docs and GitHub close for verification.
AI Hermes Agent is independent, is not the official Hermes Agent website, is not owned or endorsed by Nous Research, does not host or run Hermes Agent, and does not provide an online chat demo, account system, subscription, credits, API access, or managed runtime.
If you try it, I would especially like feedback on whether the environment choice and the post-install steps are clear enough, and where the guide still leaves too much implied.

value: Show HN: AI Hermes Agent – An independent Hermes Agent install guide

author: ethanjamescolez


value: welder

value:
Hi HN, I built WakaTime 13 years ago before AI. Things have changed a lot since then, and the time you spend typing in your IDE isn't as valuable as it used to be...
That's why I built a new WakaTime dashboard specifically for AI metrics. It tracks things like:
* Lines of code - AI vs. Human
* Average Prompt Length over time - How much context do you give AI
* Follow-up Edit Rate - How many times do you have to edit/fix the code AI generated
* Token usage over time - Input and Output tokens
It does this for most popular agents (Cursor, Claude, Codex, Copilot, Gemini, etc.)
If you already use WakaTime plugins, you should have AI data since last week. If not, install one of the WakaTime official plugins (https://wakatime.com/plugins) then edit your ~/.wakatime/wakatime-internal.cfg to change the ai_heartbeats_last_parsed_at to some date in the past and it will backfill your AI stats since that date. By default it only backfills a few minutes from plugin install.
Let me know what u think!

value: Show HN: Personal AI Metrics Dashboard

author: welder

title: Show HN: Personal AI Metrics Dashboard


value: npilk

value:
It's easier than ever for anyone to make a website, even without paying for a drag-and-drop builder like Squarespace. But there are still too many barriers for your average non-technical person to publish a site on the web.
I'd bet most people don't know there are free ways to host a website, and even if they find an explainer, technical platforms like Cloudflare and GitHub (let alone the command line) can be intimidating.
So I made weejur, which is basically a super simple UI front-end for GitHub Pages. You log in with OAuth, and then you can just paste HTML or upload files to publish a website. If you don't have a GitHub account, you can sign up right in the OAuth flow. It's completely free, and you can view the source here [1].
My hope is this makes it easier for people who don't know anything about web hosting to create and share their own websites.
Feel free to try it out and please share any questions/ideas/feedback!
[1] https://github.com/weejur/weejur/

value: Show HN: A free tool for non-technical folks to easily publish a website

author: npilk


value: husseiny

value:
Built an MCP server for Eventship (an in-person events platform I run). It lets Claude, ChatGPT, or any MCP client find events, register attendees, create and publish events, and broadcast to registrants through natural language.
Stack: FastAPI, ~25 tools, progressive discovery to keep context load low. Started read-only, added write tools once I saw what people actually asked for.
Happy to answer anything about the build. Feedback welcome.

value: Show HN: Eventship MCP: talk to your events from Claude or ChatGPT

author: husseiny


value: nirvanatikku

value: Show HN: GitLedger Resubmission – HITL Required

author: nirvanatikku


value:
Hi HN — we built Broccoli, an open-source harness for taking coding tasks from Linear, running them in isolated cloud sandboxes, and opening PRs for a human to review.
We’re a small team, and our main company supplies voice data. But we kept running into the same problem with coding agents.  We’d have a feature request, a refactor, a bug, and some internal tooling work all happening at once, and managing that through local agent sessions meant a lot of context switching, worktree juggling, and laptops left open just so tasks could keep running.
So we built Broccoli. Each task gets its own cloud sandbox to be executed end to end independently. Broccoli checks out the repo, uses the context in the ticket, works through an implementation, runs tests and review loops, and opens a PR for someone on the team to inspect.
Over the last four weeks, 100% of the PRs from non-developers are shipped via Broccoli, which is a safer and more efficient route.  For developers on the team, this share is around 60%.  More complicated features require more back and forth design with Codex / Claude Code and get shipped manually using the same set of skills locally.
Our implementation uses:
1. Webhook deployment: GCP
2. Sandbox: GCP or Blaxel
3. Project management: Linear
4. Code hosting & CI/CD: Github
Repo: https://github.com/besimple-oss/broccoli
We believe that if you should invest in your own coding harness if coding is an essential part of your business.  That’s why we decided to open-source it as an alternative to all the cloud coding agents out there.  Would love to hear your feedback on this!

value: Show HN: Broccoli, one shot coding agent on the cloud


value: podlp

value:
Hi HN! I built a CLI tool called ShellTalk for macOS, Linux, and web (WebAssembly) that maps English text to the corresponding Bash commands.
ShellTalk is written in Swift and available under the Apache 2.0 license on GitHub. I was inspired a few weeks ago after reading the Meta-Harness paper and seeing a tool called Hunch that did something similar using the Apple Foundation model. I often forget flag names and orders, but I wanted something that worked consistently. The 3B AFM worked surprisingly well with Hunch, but it felt slow and sometimes slight changes in what I wrote would result in very different outputs.
ShellTalk attempts to match the input with an intent category (Git, File I/O, etc), then a template, and finally to slot-fill and adapt to the specific command version and BSD vs GNU syntax. It has a few other tricks including using NSSpellChecker on macOS to auto-correct certain typos, and scores the output on safety (i.e. is the action destructive or non-reversible).
It's clearly far from perfect, but has very tight testing and validation cycles compared to using an LLM, is very portable, and might eventually work in other languages or environments like Windows. I'm curious to hear what others think.

value: Show HN: ShellTalk brings deterministic text-to-bash

author: podlp


value:
Hey HN! Today we're launching Agent Vault - an open source HTTP credential proxy and vault for AI agents. Repo is at https://github.com/Infisical/agent-vault, and there's an in-depth description at https://infisical.com/blog/agent-vault-the-open-source-crede....
We built Agent Vault in response to a question that been plaguing the industry: How do we give agents secure access to services without them reading any secrets?
Most teams building agents have run into this exact problem: They build an agent or agentic system and come to realize at some point that it needs credentials in order to access any services. The issue is that agents, unlike traditional workloads, are non-deterministic, highly-prone to prompt injection, and thus can easily be manipulated to leaking the credentials that they need to operate. This is the problem of credential exfiltration (not to be confused with data exfiltration).
In response to this, some teams we've seen have implemented basic guardrails and security controls to mitigate this risk in their agentic environments including using short-lived access tokens. The more advanced teams have started to converge toward a pattern: credential brokering, the idea being to separate agents from their credentials through some form of egress proxy. In this model, the agent makes a request to a proxy that attaches a credential onto it and brokers it through to the target service. This proxy approach is actually used in Anthropic's Managed Agents architecture blog with it being that "the harness is never made aware of the credentials." We've seen similar credential brokering schemes come out from Vercel and in Cloudflare's latest Outbound Workers.
Seeing all this made us think: What if we could create a portable credential brokering service plugged seamlessly into agents' existing workflows in an interface agnostic way, meaning that agents could continue to work with APIs, CLIs, SDKs, MCPs without interference and get the security of credential brokering.
This led to Agent Vault - an open source HTTP credential proxy and vault that we're building for AI agents. You can deploy this as a dedicated service and set up your agent's environment to proxy requests through it. Note that in a full deployment, you do need to lock down the network so that all outbound traffic is forced through Agent Vault
The Agent Vault (AV) implementation has a few interesting design decisions:
- Local Forward Proxy: AV chooses an interface agnostic approach to credential brokering by following a MITM architecture using HTTPS_PROXY as an environment variable set in the agent's environment to redirect traffic through it; this also means that it runs its own CA whose certificate must be configured on the client's trust store.
- MITM architecture: Since AV terminates TLS in order to do credential brokering its able to inspect traffic and apply rules to it before establishing a new TLS connection upstream. This makes it a great to be able to extend AV to incorporate firewall-like features to be applied at this proxy layer.
- Portable: AV itself is a single Go binary that bundles a server and the CLI; it can be deployed as a Docker container as well. In practice, this means that you can self-host AV on your own infrastructure and it should work more universally than provider specific approaches like that of Vercel and Cloudflare.
While the preliminary design of Agent Vault is a bit clunky to work with and we’d wished to have more time to smoothen the developer experience around it, particularly around the configuration setup for agents to start proxying requests through it, we figured it would be best to open source the technology and work with the community to make gradual improvements for it to work seamlessly across all agentic use cases since each has its own nuances.
All in all, we believe credential brokering is the right next step for how secrets management should be done for agents and would love to hear your views, questions, feedback!

value: Show HN: Agent Vault – Open-source credential proxy and vault for agents


value: If AI is helping you write more code than you can realistically keep in your head, SourceBridge is the missing layer. It turns your repo into something you can actually understand again and lets both you and your AI tools query that understanding instead of starting from scratch every time.

value: Show HN: We Fixed Code Throughput. Understanding Is Now the Bottleneck


value: ziofill

value:
Hi folks!
I'm delighted to present Quicklog, a macOS app for near-instant journaling.
I have ADHD and for the life of me I couldn't keep a journal. Having to go through the sequence of launching an app > creating a new entry > typing > saving > quitting the app, was enough steps for me to lose the will to keep doing it day after day.
So back in 2013 I wrote a tool for quick journaling in Objective-C for personal use. It did only one thing: on a hotkey press it would open a small window on top of everything to capture a single entry, and when the return key was pressed the window would disappear and the entry would be time-stamped and appended to a txt file. I have been using it for 13 years (I'm at 14557 entries). Some days have a dozen entries, some days have one entry, and that's ok.
I use it for capturing a snapshot of each day, logging work stuff so I can look back for what I need, and even simply scrolling back years and enjoy remembering my life's small moments, which won't go lost like tears in rain.
A couple months ago I decided to port the app to Swift, polish it, and make it available on the macOS app store. It is a privacy-first app (no servers, no account), it saves to a local .md file so there's no proprietary format that locks you in. The free version has 200 entries (which roll over, so the 200 most recent entries are kept), and the pro version allows unlimited entries. Obviously a skilled user can just write a simple terminal script to do something analogous, but Quicklog is thought with everyone in mind.
I'll be happy to answer any question. Enjoy!

value: Show HN: Quicklog – I used this app to journal for 13 years, now you can too

author: ziofill


value: keepamovin

value: Show HN: Flipbook – scrub through media frame-by-frame

author: keepamovin


value: bobfunk

value:
I launched Netlify with a Show HN more than 11 years today, for humans.
Today we're launching our Agent first version of Netlify.
Super early days for this, but I expect it to become as important as our original launch over time.
It's as hard to perfect these flows as it was to perfect some of the initial human DX flows, since the agents are non-deterministic and keeps changing and evolving, and we'll have more to show soon on our eval tooling for this.
Try it out with an agent, and we would love feedback on what works and what doesn't as we keep iterating on making Netlify better for our new agent friends.

value: Show HN: Netlify for Agents

author: bobfunk

title: Show HN: Netlify for Agents


value: Show HN: Clawrium – A CLI for managing AI agent fleet across multiple instances


value: phoughton

value:
I built CBPR Star to allow engineers & testers to validate and edit SWIFT payment system messages for XSD and Business / Usage rules.
The interesting bit is the Business / Usage rules, as they are provided in a mixture of prose and pseudo code by SWIFT. I used coding agents (Claude code mainly) to go from text to python, still a fairly labour intensive task - but considerably quicker than manually doing the same. SWIFT's own MyStandards is similar but less comprehensive and a lot more clunky.
There's also an MCP, not fully released that.

value: Show HN: A Swift Payment message validator built from Swift Standard rules

author: phoughton


value: Show HN: DrakeAI – AI expense tracker you log by texting (iOS and Android)


value: Show HN: We built Cursor, but for data transformations [Open Source]


value: bridgetburch

value:
We built this after running into the same wall everyone hits: Gmail suspends bot accounts within days, SES is outbound-only with no inbox or threading, and the only purpose-built option jumps from $20/mo to $200/mo with nothing in between.
Dead Simple Email gives AI agents their own email addresses via API. No OAuth, no human in the loop. Each inbox gets a real address, send/receive, webhook on inbound mail, and full conversation threading.
Infrastructure is our own. KumoMTA for outbound delivery, Dovecot for IMAP, dedicated mail servers. Not a reseller sitting on top of SES.
MCP server is included, so agents built on Claude, ChatGPT, or any MCP-compatible LLM connect natively without writing integration code.
Pricing: 5 inboxes free, 100 inboxes for $29/mo, 500 for $99/mo.
Docs: https://deadsimple.email/docs.html
API reference: https://deadsimple.email/api-reference.html#description/rate...
Happy to answer questions about deliverability, infrastructure, or how it compares to the alternatives.

value: Show HN: Dead Simple Email – Email API for AI Agents

author: bridgetburch


value: edimuj

value:
Every tool call an AI agent makes adds tokens to the conversation context. Not just the payload data, but the JSON wrappers, the role markers, and worst of all, the model's intermediate reasoning between calls ("Now I'll fetch the next one..."). These compound: each subsequent call re-processes everything before it, so total input tokens grow quadratically with sequential calls.
I built callmux to fix this. It's an MCP proxy that sits between your agent (Claude, Codex, etc.) and any MCP server, adding parallel execution, batching, pipelining, and caching as meta-tools. Instead of 7 sequential get_issue calls, the agent makes 1 callmux_parallel call. The actual data transferred is identical. What you eliminate is the per-call overhead.
The math surprised me. For a batch of 7 operations:

  Without callmux: ~525 tokens of structural overhead + ~900 tokens of intermediate reasoning = ~1,425 tokens of pollution
  With callmux: ~75 tokens total
  That's ~19:1 less context pollution from a 7:1 reduction in tool calls

Prompt caching helps with the cost side of re-reading previous turns, but it doesn't shrink your context window. Every intermediate reasoning turn still sits there taking up space, and compaction still triggers at the same threshold.
In practice, callmux reduces tool calls to about 15% of the original count. But the context savings are larger than that ratio suggests, because you're also eliminating the intermediate reasoning between those calls, which is the biggest source of pollution.
The result: sessions last longer before hitting context limits, and the context window has less noise competing with your actual conversation.
I wrote up the full context math with diagrams here: https://longgamedev.substack.com/p/your-ai-agent-is-re-readi...
Setup is one line:

  npx -y callmux -- npx -y @modelcontextprotocol/server-github

Works with Claude Code, Codex, Claude Desktop. Also supports multi-server mode, remote HTTP/SSE servers, and tool filtering.
npm: https://www.npmjs.com/package/callmux

value: Show HN: Callmux – MCP multiplexer that cuts tool call context pollution by ~19x

author: edimuj