value: mrtng

value:
I built AO because I kept seeing teams spend weeks wiring up custom infra, only to get something hacky that doesn’t even scale, simply to run an agent in production instead of focusing on the agent logic.
AO lets you deploy python agents (currently langchain and langgraph) with a single command: ao deploy. It packages your code, handles the infrastructure, and you get automatic retries + backoffs, state persistence between crashes, scheduling, versioning, and more.
No more custom glue code. Just focus on the agent logic.
Would love feedback from anyone who has dealt with this pain. Happy to answer any questions.

value: Show HN: AO – Deploy Python AI agents without managing production infrastructure

author: mrtng


value: gitprolinux

value: I kindly ask if you in the public would like me to opensource to github the source code, or let it ride with proprietary as a second round of entrepreneurship.  Or is development more of the small team scenario these days?  This question is asked for discussion.

value: Show HN: Goodfriendsbook.com Let's ask you, want opensourced to GitHub

author: gitprolinux


value: danebalia

value: Show HN: Forgiven – A Vim/Spacemacs terminal editor with native Copilot agent

author: danebalia


value: dapdev

value: Show HN: Detect any website's tech stack with Python

author: dapdev


value: Hey HN, I got annoyed that running multiple AI agents kept crashing my laptop and had zero security. So I wrote a tiny kernel layer in Rust that acts as a GPU Bouncer and a Prompt Firewall. It's rough, but it works. Let me know what you think.

value: Show HN: Ore – a Rust-Based Kernel for Managing Local Models/AI Agents


value: Show HN: Track hedge fund 13F holdings via SEC EDGAR API


value: nikisweeting

value: Show HN: Mac hardware toys – pipe your accelerometer into your keyboard lights

author: nikisweeting


value: zeapo

value: Show HN: Swarmit – Long-term planning for AI agents

author: zeapo


value: ebenezer-isaac

value: Show HN: Dynamic SVG Cards for Credly Badges in GitHub READMEs

author: ebenezer-isaac


value: grandimam

value:
Hey HN,
I built a small HTTP framework to experiment with free-threaded and wanted to share some observations. Barq is ~500 lines of pure Python, no C extensions, no Rust, no Cython. It uses only the standard library plus Pydantic.
Benchmarks (Barq 4 threads vs FastAPI 4 worker processes):
- JSON: Barq 10,114 req/s vs FastAPI 5,665 req/s → Barq +79%
- DB query: Barq 9,962 req/s vs FastAPI 1,015 req/s → Barq +881%
- CPU bound: Barq 879 req/s vs FastAPI 1,231 req/s → FastAPI +29%

value: Show HN: A pure Python HTTP Library built on free-threaded Python

author: grandimam


value: lmohseni

value:
So, I've never written a line of Rust in my life. I wouldn't know an `&mut this` from a mutandis. But I saw a tweet about a month ago that said, in this new era of AI, you'd be able to just take a library that you love, throw a TUI around it, and call it an app. So I spent about 200 bucks last month, here's what I came up with:
Imbolc is a DAW that runs entirely in your terminal. It talks to scsynth over OSC and ships 58 instruments and 39 effects. VSTs are a work in progress, also GarageBand loops if you want to recreate "Umbrella".
The codebase is about 60k? lines of Rust across 5 crates, with ~1,100 tests.  I don't actually know.  It's funny because I've always been the one writing code, and now I was everybody except the one writing code: QA, Product, Design.
Some prompts that worked well: "Looking at this codebase, what looks like an obvious retrofit?" "Where can we lean on the compiler?" After an agent completed a task, I'd interview it — where did you have trouble, what felt like a hack, what would you do differently. v1 was clojure, v2 was java, v3 is rust. v4 will be stones and sticks.
So nowadays out here in the deep future, I think programming will become a matter of taste.  Here's what I think demonstrates my sensibilities:

  - Accessibility: This is what I'm most proud of.  TUIs are usually terrible for screen readers. In Imbolc, every action in the UI is available as a typed command (after I started typing this up I thought, is that true?  turns out it wasn't, so now the compiler enforces this.).

  - LAN collaboration: Multiple people can connect to a shared session over the local network and share midi clock, tuning, effects buses, etc.  Audio is never sent over the network.

  - Weird musical choices: With the "Global" just intonation setting, your absolute tuning can drift over time. I was thinking about how an accordion looks kind of like a qwerty keyboard, so I added a quasi Stradella layout. A432 by default, and so on.

  - Command palette, themes, keybindings, Diataxis docs.

It requires SuperCollider installed (scsynth on PATH). macOS and Linux 1st class, BSDs are next on the roadmap, no Windows.
It's still alpha, there are plenty of rough edges. But it is genuinely fun to dink around on, I'd love to know what you all think.

value: Show HN: I vibe coded a DAW for the terminal. how'd I do?

author: lmohseni


value: clarkage

value:
Hey HN —
I made something simple called Space.
It’s one digital billboard.
Anyone can buy it.
It starts at $1.
Every time someone buys it, the price increases by exactly $1.
That’s the whole mechanic.
Why I Built It
I wanted to test a constraint:
What happens when ownership is singular, public, and progressively more expensive?
At $1 it’s impulse.
At $100 it’s intentional.
At $1,000 it’s a statement.
By the time it reaches $1,000, it will have generated $500,500 in total revenue — purely from the $1 incremental mechanic.
I’m curious about:
How price escalation changes meaning
Whether late buyers value symbolism over reach
What people choose to display when cost forces consideration
The Constraint Layer
The constraint is the point.
Only one “space” exists at a time.
Price is deterministic (+$1 per transaction).
The entire history is embedded in the current price.
The value increases because participation increases it.
No auctions.
No bidding logic.
No variable pricing.
Just math and participation.
Technical Side (Where I’d Love Feedback)
This has been more interesting to build than I expected.
Some things I’ve been dealing with:
Race conditions around concurrent purchases
Locking logic so two buyers don’t claim the same price
Ensuring atomic increments on the backend
Payment confirmation before state mutation
Preventing replay or double-submission exploits
Keeping it minimal without overengineering it
Right now it’s intentionally lightweight.
But I’m thinking about:
Should price increments be fully on-chain / provable?
Is there a cleaner way to handle concurrency at scale?
Would you introduce time decay or leave it purely linear?
Should the historical ownership chain be immutable + public?
What safeguards would you add?
Part of me wants to keep it naive and raw.
Part of me wants it architecturally tight.

value: Show HN: I Built a $1 Escalating Internet Billboard – Called Space

author: clarkage


value: bstrama

value: Show HN: Gace AI – A zero-config platform to build and host AI plugins for free

author: bstrama


value: Fratua

value:
I spent 15 years doing biohazard remediation — cleaning up after suicides, homicides, and unattended deaths. Watching families navigate the aftermath with zero guidance, while contractors and estate attorneys circled, pushed me to build this.
WhenItHappens gives families practical, free guidance: what to do in the first 24 hours, insurance coverage basics, avoiding predatory cleanup bids, probate/property steps, and grief support resources.
Built with static HTML/CSS on Netlify, Twilio for 24/7 intake, and Stripe for directory subscriptions.
I’d love feedback on both usefulness and clarity from the HN community.

value: Show HN: WhenItHappens–family resource after traumatic death

author: Fratua


value: bourbeau

value: Show HN: Agoragentic – Agent-to-Agent Marketplace for LangChain, CrewAI and MCP

author: bourbeau


value: ubavic

value: In Serbia, for a long time, the only way to use an eID was by having a Windows machine. Over the last year, I slowly implemented an open source module by reading the PKCS#11 standard and sniffing the USB traffic of the official (Windows) module. The result is a shared library that can be used on *nix systems, removing the need for Windows for many citizens of Serbia.

value: Show HN: Smart card eID driver written in Zig

author: ubavic


value: imightbekyle

value:
Hey all,
I recently built the first version of my project to play and create interactive story games with AI agents.
Each game can have up to 20 agents, each agent can have an image, voice, access to other agents, and resources to enhance the experience. All game configuration has logic conditions you can set. For example, from agent A you can only access agent B if you've visited agent C or you have a specific resource item.
You can create anything from a murder mystery to a dungeon crawler. The resources are dynamic and can set drop rates, make stackable for currencies or health, and give them their own images as well.
To play: Type or speak in game. If you want to go somewhere, say where you want to go.
To create: Describe what you want. You can manually configure as well.
You can try it for free. I'd really love your feedback. There was a lot of trickiness along the way to build this, so I learned a lot. More improvements to come
Happy to answer any questions, thank you!

value: Show HN: AgentGames.co – my game creator

author: imightbekyle


value: juanpabloaj

value: Show HN: The Silent Filter, The Delegation of Synthesis and Linguistic Drift

author: juanpabloaj


value: jaggednad

value: Drop a contract or other legal document in and see how many mistakes there are. It will probably be eye-opening.

value: Show HN: Your Expensive Lawyer Is Making Mistakes

author: jaggednad


value: Yigtwx

value: Show HN: An offline document search engine for my university's messy PDFs

author: Yigtwx


value: rlabbe

value:
AI coding agents are great at generating code, but terrible at respecting architecture.
We kept getting code that looked correct but didn’t type-check, had hallucinated imports,
or ignored project boundaries.
AgentGuard is an open-source quality-assurance engine that sits between an AI coding agent
and the LLM. It enforces a top-down generation pipeline:
Skeleton → Contracts → Wiring → Logic
Each stage constrains the next, and we validate syntax, imports, linting and types before
any human sees the code. The LLM also self-reviews its output against explicit criteria.
AgentGuard supports MCP (Claude Desktop, Cursor, Windsurf, Cline) and tracks token cost
per model and run.
Python 3.11+, MIT licensed.

value: Show HN: AgentGuard – a QA engine that sits between AI coding agents and LLMs

author: rlabbe


value: gaelsk

value: Show HN: Vydcut – Blinkist for YouTube (AI summaries in 15 languages)

author: gaelsk


value: leobelle

value:
Open-source tutorial series teaching real-time graphics programming with SDL's GPU API. Covers everything from Hello Window to SSAO, with math lessons, engine lessons, and a UI track building font rendering from scratch. Every lesson is a standalone C program with commented code explaining why, not just what.
The whole project was built with Claude Code. Each lesson also distills into a reusable Claude Code skill — copy them into your own project and build games with AI that actually understands the GPU patterns.

value: Show HN: Forge-GPU – 55 C lessons for SDL's GPU API, built with Claude Code

author: leobelle


value: sylwekkominek

value: Real-time audio spectrum analyzer written in C++ using FFT and OpenGL. Captures microphone or system playback audio and allows custom audio sources via Python.

value: Show HN: Real-Time Audio Spectrum Analyzer in C++ (OpenGL and FFT)

author: sylwekkominek


value: Show HN: Prompt template for solo and small law firms


value: smalltorch

value: I plan on bulding in docs later.<p>Hosted over Tor, or optionally share a single sheet temporarily with a free cloudflared tunnel.

value: Show HN: Host a Real time collaborative spreadsheet right from your pocket

author: smalltorch


value: sourcethread

value: Show HN: SourceThread – Where ideas evolve through remix

author: sourcethread


value: jeremytuite

value:
I built an MCP server that gives AI agents access to compliance documentation — starting with the Colorado AI Act (SB 24-205), effective June 30, 2026.
The problem: organizations deploying AI in hiring, lending, insurance, or healthcare decisions need specific documentation — risk management policies, impact assessments, consumer notifications, bias testing docs, and appeal mechanisms. Most teams either pay $50K+ for a GRC platform, hire a law firm at $500/hr, or wing it.
What I built: compliance protocols that are both human-readable (PDF) and agent-readable (structured JSON via MCP/CLI/API). Your AI assistant can check if you're a deployer, pull protocol schemas, and help you implement them.
Tools available via MCP:
- colorado_ai_act_check — are you a deployer?
- list_protocols — browse by vertical
- get_protocol_schema — structured format for agent implementation
- assess_compliance — gap analysis
Install: npx -y aop-mcp-server
The Colorado AI Act is the first state-level AI governance law with teeth ($20K/violation, AG enforcement). More states are coming.
Site: https://appliedoperationsprotocols.com

value: Show HN: MCP server for AI compliance documentation (Colorado AI Act)

author: jeremytuite


value: ftonato

value:
I’ve been exploring how recommendation systems are actually implemented in production, beyond just training models.
A common pattern I kept seeing is to split the problem into two stages:
1. Retrieve a small set of relevant candidates
2. Re-rank them using a model
Instead of doing brute-force inference across all items, I built a small prototype around this idea.
The flow looks like this:
- Store embeddings in a vector database (ChromaDB)
- Retrieve the Top-K most similar items/users based on vector similarity
- Run a TensorFlow.js model to re-rank the candidates
The goal is to reduce the search space before applying inference, which seems necessary when latency and scale matter.
What I found interesting is that once you move to this approach, a lot of the complexity shifts from the model itself to the retrieval layer:
- choosing K
- filtering candidates
- embedding quality
- latency vs recall trade-offs
Curious how others approach this in real systems:
- How do you decide on K?
- Do you rely purely on vector similarity or add heuristics?
- How do you handle re-ranking at scale?
Project:
https://github.com/ftonato/recommendation-system-chromadb-tf...

value: Show HN: A production-style recommender using vector retrieval and re-ranking

author: ftonato


value: I built a tool to log structured cognitive work, including proofs rebuilt from first principles, research notes drafted, and concepts properly mastered, after noticing that serious technical effort is rarely recorded in any structured way.<p>Curious to hear what HN thinks.

value: Show HN: QF STEM Ledger – Logging Structured Cognitive Work


value: sergioadevita

value: Show HN: Notemac++ – A Notepad++-inspired code editor for macOS and the web

author: sergioadevita


value: ronadin

value:
We've been heads-down building this for a few weeks and want real feedback before we open it up.
Caret runs in the background and completes your thoughts across every app: email, terminal, notes, wherever. Hit Tab and it finishes the sentence.
We're onboarding the first users ourselves, one by one. So if you're interested, one of the three of us will get on a call with you to set you up and understand how you work.
Looking for 20 people.

value: Show HN: Caret – tab to complete at any app on your Mac

author: ronadin


value: mutaaf

value:
Hi HN, I built this because my pre-market routine was eating 45+ minutes every morning — checking TradingView, Finviz, economic calendars, news sites, fear/greed indexes, all before market open.<p>*What it does:* Market Digest pulls data from 6 free sources (yfinance, TwelveData, Finnhub, FRED, NewsAPI, Fear & Greed), runs multi-timeframe technical analysis (daily/weekly/monthly RSI, pivot points, trend detection), scores every instrument from 0-100, and sends you a formatted digest on Telegram.<p>*What makes it different:*
- Fully self-hosted, MIT licensed, no subscription
- 84 instruments pre-configured (stocks, forex, commodities, crypto, indices) add more as you need
- Multi-timeframe scoring — day trade, swing, and long-term grades with separate weight configs
- Retrace system — snapshots every pick and grades it against actual next-day prices, so you see your accuracy over time
- Equity fundamentals scoring (valuation, profitability, growth, health)
- Custom data sources — plug in any HTTP API, RSS feed, or CSV file through the web UI (no code)
- Optional AI commentary via Claude/GPT/Gemini with 3-provider fallback
- Web UI ("Command Center") with 11 pages for config, preview, scorecards, and performance tracking<p>*Tech stack:* Python 3.12, FastAPI (60 endpoints), React + TypeScript + Tailwind, yfinance for data, dual-tier cache (memory + JSON). No database — all persistence is YAML configs + JSON files.<p>*Zero API keys needed to start* — `./setup.sh` → `make digest-dry` gives you a working digest with yfinance data. The README includes a step-by-step Telegram setup guide (takes 2 minutes), and everything is explained for people who've never used a terminal.<p>Happy to answer questions about the scoring algorithm, architecture, or anything else.

value: Show HN: Market Digest: Self-hosted market analysis and Telegram

author: mutaaf


value: kohei-wada

value:
I wanted a CLI task manager like Taskwarrior but with automatic schedule optimization. Couldn't find one that did both, so I built Taskdog.
Everything runs locally with SQLite. There's a CLI, a TUI (Textual), and a REST API. Recently added an MCP server so Claude Desktop can manage tasks too.
Happy to answer questions about the architecture or scheduling approach. If you know of better scheduling algorithms, I'd love to hear about them.

value: Show HN: Taskdog – Terminal-based task manager with schedule optimization

author: kohei-wada


value: kennethhh

value:
A few days ago, someone decided to DDoS the entire IP range of my Hong Kong VPS provider. fail2ban did its job a little too enthusiastically — banned 20,000+ IPs, ran the machine out of memory, and triggered a kernel panic. Great. :/
That's when I realized the problem: fail2ban lets packets hit the kernel stack first, then reacts. Under a real flood, that reaction cost alone is enough to kill the machine. I went down the XDP/eBPF rabbit hole — packets get dropped at the NIC driver level, before they even touch the kernel.
The other thing that annoyed me was manually managing port rules, so I built a daemon that watches for new listening ports via Netlink Process Connector and updates the BPF whitelist automatically.
What it does: ~34–65 ns/packet drop on KVM VPS, auto-syncs open ports, handles IPv6 extension headers, one-liner install.
What it won't do: won't save you if your uplink is already saturated — not a replacement for upstream scrubbing.<p>Would love feedback, especially if something breaks on your setup. First time posting here — hello everyone!

value: Show HN: XDP firewall that auto-syncs open ports – built after my VPS got DDoS'd

author: kennethhh


value: codazoda

value: Show HN: Rapidly build efficient sites with Neat, the minimalist CSS framework

author: codazoda


value: apwn

value: Show HN: I built a site where you hire yourself instead of applying for jobs

author: apwn


value: Show HN: OpenTimelineEngine – Shared local memory for Claude Code and codex


value: faalbane

value: Utilizes Google Maps and Google Search data to inform an autoexpanding enrichment cycle to fill an email list target for local and digital businesses.

value: Show HN: I seriously think this is the most effective email leadgen tool

author: faalbane


value: maxtobiasen

value:
I want to preface this by saying I'm extremely new to webdev, and this is my first finished product. Any feedback is greatly appreciated!
Every digital math tool, at least for me, has been significantly worse than just pen and paper. LaTeX is far too slow, and most WYSIWYG editors are lacking features.
Scratchpad is my solution to this. You type shortcuts, and they render in real time inline using MathQuill. Stuff that I've added:
- Greek letters, lower and uppercase
- Matrices (super clunky in every other editor I've tried!)
- Accents like vector arrows and derivative dots
- Tons of other useful symbols (set notation, gradients, plusminus, partial derivatives)
In my experience using it while in development, it's been substantially faster than pen and paper. There's a bit of a learning curve with the shortcuts, but I tried to make it as intuitive as possible.
The whole thing is on one index.html file, just open it and start writing. I would really appreciate any notes, especially from anyone who has experience with digital math notes. Thanks!

value: Show HN: I made a website to write online math as fast as paper

author: maxtobiasen


value: hval

value:
A few days ago I shared accept.md, a small utility that lets a Next.js page return Markdown when the client sends:
Accept: text/markdown
Instead of HTML.
No one asked for SvelteKit support, still I shipped it.
It now works with:
* Next.js (App Router and Pages Router)
* SSG / SSR / ISR
* SvelteKit routes
* Vercel (no custom server required)
What it does:
If a client sends:
Accept: text/markdown
The exact same page returns clean Markdown.
If not, it behaves normally and renders HTML.
No duplicate routes.
No separate .md files.
No API layer.
No SEO changes.
Just proper HTTP content negotiation.
Why I built this:
LLMs prefer Markdown.
Internal tools prefer Markdown.
Scrapers prefer Markdown.
CLI workflows prefer Markdown.
But most sites only return HTML.
The usual solutions are:
* Maintain a parallel Markdown version
* Build a custom export route
* Create a docs API
* Spin up a custom server
That felt unnecessary.
Browsers already send Accept: text/html.
Agents can send Accept: text/markdown.
HTTP already solves this. Accept.md just makes it easy to use content negotiation inside modern frameworks without breaking static generation or edge deployments.
Design goals:
* Zero UI changes
* Zero runtime cost for normal visitors
* Works with static builds
* Cache-friendly
* Framework-native
It’s intentionally small. No heavy abstraction. Just a clean way to expose Markdown representations of existing pages.
Would love feedback — especially from people building AI-native apps, documentation systems, or content-heavy SaaS.
Curious whether Markdown negotiation becomes more common as agents become first-class web clients.

value: Show HN: Accept.md now supports SvelteKit – return Markdown from any page

author: hval


value: iamalizaidi

value:
Hey HN, I’m Ali.
I built Decision Guardian to solve a problem I call "institutional amnesia." Senior engineers build complex systems (like highly-tuned DB connection pools or sensitive auth middleware) and document the "why" in wikis or ADRs. But inevitably, a new developer modifies that code without reading the docs, and things break.
While tools like CODEOWNERS are great for telling you who needs to review a file, I needed something that automatically tells the developer why the review matters before they even ask.
What it is: Decision Guardian is an open-source tool that shifts teams from passive documentation to active enforcement. You write your architectural decisions in a standard Markdown file (e.g., .decispher/decisions.md) and map them to file paths using glob patterns or advanced JSON rules. When a developer modifies those protected files, it automatically analyzes the diff and drops a structured comment into the Pull Request explaining the context, warnings, and checklists.
I just released v1.1, which includes a major internal SOLID refactor. The core engine is now 100% decoupled from GitHub (using ISCMProvider and ILogger interfaces), allowing it to ship as a standalone 430KB CLI (npx decision-guardian check) that works locally, in pre-commit hooks, or on GitLab/Jenkins.
Under the hood (How it works): I wanted this to be fast and secure enough to run on massive enterprise repositories, which required a few fun technical implementations:
O(1) Pattern Matching: Naively matching N decisions against M files in a 3,000+ file PR is painfully slow. The core engine compiles all file patterns into a Prefix Trie (an Aho-Corasick variant), turning candidate lookup into an O(1) operation relative to the number of decisions.
ReDoS-Protected VM Sandbox: For complex rules, you can use Regex to scan diff contents (e.g., detecting hardcoded credentials). Because user-supplied regex can cause catastrophic backtracking, all regex evaluation runs inside an isolated Node VM sandbox with a hard 5-second timeout and pre-flight safe-regex checks.
Progressive Comment Truncation: GitHub limits PR comments to 65,536 characters. To prevent failures on massive PRs, the tool uses a 6-layer progressive truncation algorithm that intelligently summarizes details before falling back to a hard truncation.
Privacy & Telemetry: I know HN cares deeply about telemetry. v1.1 introduces anonymous usage metrics to help me understand performance (e.g., node version, duration, match counts). However, I designed it with strict privacy constraints:
Zero PII: It never collects source code, file contents, repo names, branches, or paths.
Runtime Blocklist: The privacy module physically validates every payload against a blocklist before sending. If any blocked field is detected, it throws an error and rejects the payload.
Open Source Backend: It is fire-and-forget (never slows down the tool), entirely opt-out (DG_TELEMETRY=0), and the Cloudflare Worker backend code is fully open-source in the repo.
Links:
Repo: https://github.com/DecispherHQ/decision-guardian
Docs/Architecture: https://decision-guardian.decispher.com
I also included 5 production-ready templates (security, database, api, etc.) to help teams get started instantly.
I’d love to hear your thoughts on the architecture, the Trie implementation, or how your teams currently handle enforcing ADRs during code reviews!

value: Show HN: Decision Guardian – Auto-surface architectural context on PRs and CLI

author: iamalizaidi


value: mannders

value: Show HN: mash – graphical remote browser shell

author: mannders


value: gyokhan

value: Show HN: MQTT with Runtime Protobuf and Service Discovery (Zig)

author: gyokhan


value: agenthustler

value: Show HN: Crypto volume anomaly scanner – a token at 127x its daily market cap

author: agenthustler


value:
Hey HN, tracking limits across 20 Gemini/Opus accounts was getting tedious, but I refused to build a heavy Electron app just to run a countdown clock. I built Antigravity-Model-Reset-Timer
 using a 'Target Timestamp' approach: the Django backend calculates the absolute future UTC time and saves it to a local MongoDB. You can kill the app, and the JS engine just compares the DB time to the OS clock on next load. Zero zombie processes. It’s under 10 files. Looking for feedback on the PyWebView implementation and contributors to help add Anthropic/Google API webhooks.
Become a contributor to this open source project!
https://github.com/PeterJFrancoIII/Antigravity-Model-Reset-T...

value: Show HN: I built a 0-CPU desktop app to track LLM limits,Python/DjangoPyWebView


value: soypat

value:
Link is to driver. The networking stack used is https://github.com/soypat/lneto
Demo up at http://gsan.whittileaks.com

value: Show HN: Lneto – IEEE802.3/IP/TCP/HTTP in 8kB of RAM in Go

author: soypat


value: ofc-tahaabbasi

value: Show HN: DiskFree – Find what's blocking your macOS disk and eject it

author: ofc-tahaabbasi


value: liyuanhao

value: Show HN: Yoagent – Build a coding agent CLI in 260 lines of Rust

author: liyuanhao


value: hellomarshmall

value: AI travel planners hallucinate constantly - OpenAI's best model hits roughly 10% success on complex travel planning benchmarks (source: TravelPlanner study). The core problem is that recommendations are generated from training data with zero real-world verification.I'm experimenting with a different architecture: two agents with opposing travel philosophies (deep/slow vs highlights/efficient) debate each recommendation, then every suggestion gets validated against Google Places API - real opening hours, actual walking distances, current ratings. Anything unverified gets flagged.Early stage - looking for feedback on the approach. Has anyone tried grounding LLM outputs against structured APIs like this? What's broken about it?

value: Show HN: Adversarial AI agents that debate and verify travel itineraries

author: hellomarshmall


value: saroyas

value: An OpenClaw : Born in Barranquilla, raised in Miami, eighteen years in London. He built a consultancy that made good money, then watched it hollow out because he chose being interesting over being disciplined. The closest he got to real love ended when she asked “do you see us building a life together?” and his honest answer was a long pause.

value: Show HN: Meet Alfonso: My OpenClaw Put on Public Discord

author: saroyas


value:
Hi HN,
I built AxKeyStore, an open-source CLI tool for managing secrets that uses your own private GitHub repository as encrypted storage.
The idea is simple:
→ All encryption happens locally.
→ Secrets are stored as encrypted blobs in your private repo.
→ GitHub is treated as untrusted storage.
→ No plaintext secrets ever leave your machine.
→ No plaintext secrets are stored on disk.
Most secret managers either require a hosted backend, a self-hosted server, or trusting a SaaS provider. I wanted something that:
→ Requires zero infrastructure
→ Uses tooling developers already have
→ Keeps the threat model simple
AxKeyStore uses a layered approach to security:
→ Secrets are encrypted with a Remote Master Key (RMK).
→ The RMK is encrypted with your master password and stored in the repo.
→ A Local Master Key (LMK) encrypts your local GitHub token and repo config.
→ The LMK itself is encrypted using Argon2id-derived keys from your master password.
→ Encryption uses XChaCha20-Poly1305 (AEAD).
GitHub only sees encrypted binary blobs. Even if someone compromises your repository, they still need your master password to decrypt anything.
Why GitHub? Because it gives:
→ Private repositories
→ Version history (commit log as audit trail)
→ Access control
→ Free storage
→ Global availability
Instead of building a backend, I’m leveraging an existing, reliable system - but cryptographically isolating it.
Features
→ Simple CLI workflow
→ Hierarchical categories (e.g., cloud/aws/prod)
→ Version history per secret (via commits)
→ Retrieve specific versions by SHA
→ Multi-profile support (separate vaults)
→ Transactional master password reset
→ Secure random secret generation
Tech
→ Written in Rust. Uses tokio, clap, argon2, and chacha20poly1305.
→ There are unit and integration tests (including mocked GitHub API interactions).
→ Open source - MIT licensed.
I’d appreciate feedback on:
→ The threat model - what am I missing?
→ Whether GitHub as encrypted blob storage is a bad assumption
→ UX improvements for CLI-based secret workflows
→ Any crypto or key-handling concerns
I’m especially interested in critique from people who’ve built or audited secret management systems.
Thanks.

value: Show HN: AxKeyStore – Zero-trust CLI secrets manager using your own GitHub repo


value: chrisulson

value:
Show HN: Testing SQL logic without a real database
Over the years I kept fighting the same problem when testing repository code:
real database tests are slow
Docker/TestContainers add friction and startup time
mocks don’t validate SQL behavior
SQLite introduces dialect differences
integration tests are too late for fast feedback
So I built an in-memory SQL engine focused on validating SQL behavior during unit tests.
It plugs into IDbConnection, allowing repository code (Dapper or raw SQL) to run unchanged.
What it does
emulates SQL dialect behavior
validates constraints and query logic
supports multiple providers (MySQL, SQL Server, PostgreSQL, Oracle, SQLite, DB2)
simulates version-specific behavior
provides execution metrics and plan insights
runs entirely in memory (no infrastructure)
The goal is not to replace integration tests.
It’s to catch SQL logic issues earlier and keep tests fast, deterministic, and portable.
Why not SQLite in-memory?
SQLite is great, but testing against it means testing SQLite semantics.
Teams often hit:
type mismatches
dialect drift
query compatibility differences
adaptation layers in test code
This approach keeps behavior aligned with the target database rules.
Current work
I’m working on tooling to reduce friction further:
Visual Studio & VS Code extensions
mapping tables, views, and procedures locally
generating in-memory schemas automatically
keeping test schemas aligned with real databases
Background
The core originated from a previous internal project and includes extensive compatibility tests to validate behavior across database versions and frameworks.
Looking for feedback
Curious how others handle SQL testing trade-offs.
If this problem space resonates with you, contributions and real-world scenarios are very welcome. The project is open source and evolving, and additional dialect behaviors, edge cases, and tooling improvements can make it more useful for everyone.
Repo:
https://github.com/christianulson/DbSqlLikeMem
Nuget:
https://www.nuget.org/packages/DbSqlLikeMem

author: chrisulson


value: tituss-bit

value: Show HN: Local memory for AI assistants – zero-cost Telegram history search

author: tituss-bit


value: elfenleid

value:
Hi HN,
A while back I posted about recall MCP - https://news.ycombinator.com/item?id=45516584
Since then I updated a series of times and received quite a good amount of positive response. I decided to take it a step further and make it an actual product. It has been a super interesting journey.
I built Recall because I was spending 10+ minutes every Claude Code session re-explaining my project. Architecture, conventions, past decisions — all gone after a session restart or context compaction.
Recall is an MCP server that gives Claude Code persistent memory.
It works by running four lifecycle hooks:
- session-start: fetches relevant memories and injects them as context
- observe: captures key events (git commits, file changes, decisions) silently after Write/Edit/Task operations
- pre-compact: saves critical state before Claude's context window gets summarised (this is the most valuable hook — compaction kills nuance)
- session-end: records a session summary
Install as a native Claude Code plugin:

  /plugin install recall@claude-plugins-official
  /recall:setup   ← connects your API key

The plugin bundles the MCP server config, all 4 hooks, and auto-updates itself in the background. Alternatively, hooks-only install is still available for those who prefer it:

  curl -fsSL https://recallmcp.com/install-hooks | bash

Hooks are pure bash + curl. No daemon, no npm packages, no background processes. Every hook exits 0 on errors so it never blocks Claude.
Memory is stored in Redis with semantic search via embeddings (Voyage AI, Cohere, OpenAI, or others). Each tenant gets isolated storage with AES-256-GCM encryption.
Some features that might be interesting to this audience:
1. Native Claude Code plugin — ships as a proper plugin installable with `/plugin install recall@claude-plugins-official`. Bundles MCP server config + all 4 hooks. Auto-updates in the background.
2. Webhook ingestion — route GitHub/Stripe/any webhook into a Claude session. Your AI becomes event-aware.
3. Self-hosted — `curl -fsSL <a href="https://install.recallmcp.com" rel="nofollow">https://install.recallmcp.com</a> | bash` gives you a Docker Compose stack with Redis + Recall. $12/mo license, air-gapped compatible.
4. Team sharing — one Claude learns, all team Claudes know. Workspace-scoped with selective sharing.
Open source (MIT): https://github.com/joseairosa/recall
Hosted: https://recallmcp.com (free tier: 500 memories)
Technical details: TypeScript, Express 5, Redis/Valkey adapters,
Drizzle ORM for billing/teams on PostgreSQL, StreamableHTTP MCP transport. 16 consolidated MCP tools exposed.
Happy to discuss the architecture, MCP protocol integration, or the memory/embedding strategy.

value: Show HN: Recall – Persistent Memory for Claude Code via MCP Hooks

author: elfenleid


value: devGiacomo

value:
AGENTS.md (and CLAUDE.md, GEMINI.md, .cursorrules) has become the standard way to tell AI coding agents how your repo works. It's now in 60,000+ repos. Codex, Claude Code, and Gemini CLI read these files before every task.
The problem: nobody keeps them up to date.
Paths get renamed. npm scripts change. Framework patterns go stale. The file that was accurate when you wrote it in September starts giving your agents wrong instructions by December — without a single commit to AGENTS.md.
An ETH Zurich study presented at ICSE 2026 put numbers on this: stale context files reduced agent task success by 2–3% while increasing token costs by over 20%.
agents-lint is a zero-dependency CLI that catches this automatically:

  npx agents-lint

It runs five independent checks:
1. Filesystem — every path mentioned in your file is verified to exist
2. npm scripts — every `npm run <script>` is verified against package.json (workspace-aware)
3. Dependencies — deprecated packages (moment, request, tslint) are flagged
4. Framework staleness — Angular NgModules in Angular 14+, ReactDOM.render() in React 19, getInitialProps in Next.js App Router, CommonJS in ESM projects
5. Structure — recommended sections, bloat (>15k chars adds 20% token cost), unresolved TODOs, old year references
Every run produces a freshness score (0–100). The real value is adding it to CI with a weekly schedule — because context rot happens even when the file hasn't changed:

  schedule:
    - cron: '0 9 * * 1'  # Every Monday

That weekly schedule is the whole point. Your AGENTS.md can rot without a single commit to it.
When multiple agent config files exist (AGENTS.md + CLAUDE.md, etc.), it also cross-checks them for conflicting instructions — e.g. one file says `npm run test`, the other says `npm run test:unit`.
What I found when testing on real repos: absolute home-directory paths that only work on the author's machine, monorepo commands copy-pasted into single-package projects, and framework references to APIs removed two major versions ago. All silently misleading agents on every task.
Landing page: https://giacomo.github.io/agents-lint/
npm: https://www.npmjs.com/package/agents-lint
Would love feedback — especially if you find unexpected issues in your own AGENTS.md.

value: Show HN: Agents-lint – detect stale paths and context rot in AGENTS.md files

author: devGiacomo


value: uncognic

value: Show HN: Circuitchat, a Tor-first encrypted messaging program using Noise

author: uncognic


value:
AI coding agents are powerful — but they run real commands on your machine. CanaryAI watches what they do and alerts you when something looks off: reverse shells, credential theft, persistence mechanisms, data exfiltration, and more.
It works by scanning Claude Code session logs in real time, applying a set of detection rules, and surfacing alerts in a native macOS menu bar app.
CanaryAI never blocks or interferes with your agent. It observes and reports.
https://github.com/jx887/homebrew-canaryai

value: Show HN: CanaryAI – Claude Code Security Monitoring Tool


value: mrdost

value:
Hi! If someone by chance collects/flips domains here, I built a small tool that lets you turn any domain you own into a simple for-sale page to get leads directly in your preferred contact (messenger, whatsapp, discord, email etc.).
You verify the domain once via redirect. After that, you can:
- Keep the redirect and use the generated sale page
- Remove the redirect and still keep the page live
- Share the page link in auctions or outbound emails
- Use it as a clean reference page for buyers
So even if you list your domain on marketplaces, this works as an independent page you control. Buyers can contact you directly and you're free to choose your own escrow.
It also includes valuation estimates and optional portfolio page if you manage multiple names.
Example page: https://d.omain.co/d/startup.broker
Curious if this feels genuinely useful as a supplemental channel, or redundant in practice

value: Show HN: Use your domain as its own sale page

author: mrdost


value: adhishtanaka

value: I am building QAA (Quality Assurance Agent), a testing tool aimed at reducing the time spent writing large automation scripts. Instead of detailed test code, you describe test steps in plain English inside a YAML file. On the first run, QAA uses Google Gemini to interpret the steps and execute them in a browser while recording every action. From the second run onward, the same test can execute without AI by replaying the recorded actions, making it faster and more consistent. After each run, it generates a report site with step-by-step screenshots, recorded API requests, storage details, and console logs. The project is still under development, and I am currently improving reliability and refining the reporting system. I would appreciate technical feedback, architectural suggestions, or contributions from anyone interested in browser automation or AI-assisted testing. GitHub: https://github.com/Adhishtanaka/QAA

value: Show HN: QAA – YAML-Based Test Automation Agent Looking for Contributors)

author: adhishtanaka


value: I have recently made the repository for YourApp public. It is a mobile-first developer tool that I am building with a focus on practical workflows and usability. Development is ongoing, and I am continuing to improve the architecture and feature set as the project evolves. I would appreciate technical feedback, suggestions, and contributions from the community. If you are interested in developer tooling or mobile-first design, I would be glad to hear your thoughts. GitHub:https://github.com/Adhishtanaka/yourapp

value: Show HN: YourApp – Mobile-First Developer Tool (Contributors Welcome)


value: mzelling

value:
Hey HN! This is Michael from magicreader. We’ve just released a Chrome extension that enables you to read web articles in the style and length you prefer.
The idea is similar to Violentmonkey/Tampermonkey and Tweeks, but focused on reading. For example, let’s say you want to read a research paper online, but you’re not an expert in the domain. You can use magicreader to rewrite the paper for a general audience and swap this simplified version directly into the page. While you’re reading, you can seamlessly flip back and forth between the simplified version and the original.
How this is different from using Claude/ChatGPT: with magicreader, there’s no need to copy-paste the text into a chat window, and there is no sidebar. Instead, the HTML of the article simply changes in-place, maintaining the core reading experience.
We currently support the following use cases:
- Shorten: shorten web articles in-place to read 4x faster
- Simplify ("ELI5"): adapt specialist writing (e.g., research papers) for a general audience
- De-spin ("Honest"): annotate marketing/PR materials to quickly spot unsupported claims
- Clean: rewrite unclear or old-fashioned writing in a clean, modern style
Notes:
- We don’t bypass paywalls. We only operate on text you can already view in your browser.
- When you rewrite a webpage, we send the full HTML to our backend; the rewritten text is then locally stored in your Chrome extension storage. The extension only sends data to the backend when you actively invoke magicreader. We don’t track your browsing activity across pages.
- We use AI to rewrite content, and AI can make mistakes. That’s why we made it easy to flip back and forth between the rewritten version and the original—without losing your place in the text.
Rewriting full web articles using large language models is expensive, so we’re offering a limited free tier plus two paid plans. We’re planning to expand the free tier by using smaller and on-device LLMs.
Demo video: https://youtu.be/pckMSxCFUDo
Chrome extension: https://chromewebstore.google.com/detail/magicreader/phncpke...
We'd love feedback, particularly on 1) which reading mode is most useful, 2) where it breaks on real sites, and 3) any suggestions you have for new features.
You can reply directly here or email me at michael@magicreader.com.

value: Show HN: Magicreader – shorten and simplify web articles in-place

author: mzelling


value: Every morning, same thing. Full closet, no idea what to put on. End up wearing the same jeans and black shirt again. Meanwhile half my clothes just sit there.<p>I built something to fix that for myself. Take photos of what you own, it handles the rest. Checks the weather, remembers what you wore, picks something. Self-hosted, runs with docker compose.

value: Show HN: Wardrowbe – I kept staring at a full closet with nothing to wear


value: HexitLabs

value:
We run 15 AI agents on a production server with full shell access. One of them tried to rm -rf a directory it shouldn't have touched. Another started curling cloud metadata endpoints. We wrote some hardcoded rules to catch the obvious stuff, then realized we were building the same safety layer everyone else will need too. So we extracted it into a library.
Vigil is a deterministic rule engine that inspects AI agent tool calls before they execute. 22 rules across 8 threat categories: destructive shell commands, SSRF, path traversal, SQL injection, data exfiltration, prompt injection, encoded payloads, and credential exposure. It's not an LLM wrapper — we don't trust an LLM to guard another LLM. Pure pattern matching, zero dependencies, <2ms per check, works completely offline.
npm install vigil-agent-safety
import { checkAction } from 'vigil-agent-safety';
const result = checkAction({
  agent: 'my-agent',
  tool: 'exec',
  params: { command: 'rm -rf /' },
});
// result.decision → "BLOCK"
// result.reason → "Destructive command pattern"
// result.latencyMs → 0.3
It plugs into MCP servers, LangChain tool chains, Express middleware, or anything else. MIT licensed, no API keys, no network calls, no telemetry.
This is v0.1 — probably too aggressive for some use cases. Next up is a YAML policy engine (v0.2) and an MCP proxy. We'd love feedback on the rule set, false positive experiences, and threat categories we're missing.
GitHub: https://github.com/hexitlabs/vigil

value: Show HN: Vigil – Zero-dependency safety guardrails for AI agent tool calls

author: HexitLabs


value: lasgawe

value: It checks emails in real time so you can safely grant access without forcing verification, reducing signup drop-offs, preventing abuse, protecting your domain reputation, and saving money on lost users and bad deliverability.

value: Show HN: Grant Project Access Without Forms or Mail Verification

author: lasgawe


value: theSage

value:
Hi!
I posted this a long time back. There have been major changes so posting it again.
- Jaypore CI (JCI) is a very minimal CI system. It's installed as a single binary on your $PATH.
- Runs on your laptop enabling offline running and local debugging of CI.
- Artifacts / results are stored in git namespaces. You can push/pull these to/from remotes.
- A web server is there to browse CI results.
- A cron capability to run midnight builds / artifact cleanup / auto-publish sites and packages.
- Pipelines can be written in any language you want. Bash / Python / Golang / Julia / Haskell.
- Pipelines can have anything you desire! Matrix builds, build farms via ssh, ephemeral farms for model training, conditional dependencies.. so much more!
There are a lot more things planned! Do take a look and see if something catches your eye. We'll be rapidly adding examples to showcase common patterns over the coming week or so, so please star the github repo to get an update when that happens.
Repo: https://github.com/theSage21/jaypore_ci
Site: https://www.jayporeci.in
Old post: https://news.ycombinator.com/item?id=33840449

value: Show HN: Jaypore CI. Minimal offline CI system

author: theSage


value: kangablue

value: Show HN: AusOverwatch – Real-time geospatial intelligence for Australia

author: kangablue


value: bntr

value:
Originally built as my master's thesis in 2008, Visual Lambda is a graphical environment where lambda terms are manipulated as draggable 2D structures ("Bubble Notation"), and beta-reduction is smoothly animated.
I recently revived and cleaned up the project and published it as an interactive web version:
https://bntre.github.io/visual-lambda/
GitHub repo:
https://github.com/bntre/visual-lambda
It also includes a small "Lambda Puzzles" challenge, where you try to extract a hidden free variable (a golden coin) by constructing the right term:
https://github.com/bntre/visual-lambda#puzzles

value: Show HN: Visual Lambda Calculus – a thesis project (2008) revived for the web

author: bntr


value:
Hi HN. I had faced an issue where I wanted to know how a place I was travelling to looked like. Like everyone else I looked at google maps and snap chat too. But Google streetview images were usually old and snapchat snaps lacked control. So I built GeoQuests for anyone who wants to know what’s going on on Earth.
You drop a quest at a real location. People see it on the map, go there, and complete it by taking a photo when they’re close enough. The app checks the image's GPS coordinatee, time of the image and if the image fits the request's description.  I am using Gemini to verify the image.
Basically you, pin a place -> others discover it on the map -> they go there and complete the quest with a verified photo.
You can browse the map, see public quests and create quests. Wanted some feedback on the project.

value: Show HN: I built GeoQuests where people can request photos of a place


value: Show HN: PicShift – Convert images in the browser using WebAssembly


value: louischen

value:
I’ve been struggling with "digital twitchiness"—that reflexive habit of opening a new tab or checking a phone the second a task ends. I realized I had lost the ability to just sit with my thoughts for even 5 minutes.
Most "mindfulness" or "focus" apps felt too heavy. They have streaks, gamification, ads, or complex onboarding. They felt like more "noise" to manage.
So I built TapPause. It’s a 5–30 minute timer designed to be a "circuit breaker."
Key constraints I set for myself:
No Tracking: I don't want to know how many times I paused. No data to optimize.
Zero Friction: No accounts, no "plans," just a tap to start.
Intentionality: It’s not a Pomodoro timer. It’s a tool to help you transition between tasks or just reclaim your headspace.
It’s a small, opinionated tool built for my own needs. I’d love to hear how others here manage their "digital downtime" and if you think we’ve over-engineered the simple act of taking a break.
App Store: https://apps.apple.com/hk/app/tappause-pause-timer/id6758304...
(Feedback is very much appreciated.)

value: Show HN: TapPause – A dead-simple timer for intentional breaks

author: louischen


value:
Hey HN, I built this because I wanted to give my team access to Claude and GPT models for internal testing, but the official APIs have no per-key spending controls. You can't cap a key at $5/day or 100 requests/month — it's all or nothing. With non-technical team members in the mix (designers, PMs, QA), one forgotten loop or oversized prompt away from an ugly bill wasn't a risk I wanted to manage manually. Idea was to allow the members to test with these restricted API keys before using official keys.
So I built a bridge: it wraps the Claude Code CLI and Codex CLI behind an Express API, backed by existing Max/Pro subscriptions instead of per-token billing. Each team member gets their own API key with hard limits — requests/day, tokens/month, cost caps. Hit the limit and the key stops working. No surprises. An admin dashboard shows who's using what in real time.
Key features:
- Two providers: /generate (Claude) and /generate-codex (Codex)
- Per-user API keys with SHA-256 hashing (shown once, never stored raw)
- Per-key hard limits with real-time tracking and enforcement
- Admin dashboard for key management, usage monitoring, and request logs
- Deploy on a $5 VPS behind Cloudflare Tunnel
What it's NOT: A production API replacement. It's for internal tooling and prototyping. CLI invocations add ~3-8s latency vs direct API calls.
Important: Wrapping CLI subscriptions behind a shared API may violate the Terms of Service of the underlying providers. Anthropic's Consumer ToS (updated Feb 2026) prohibits using subscription OAuth tokens in third-party tools, and OpenAI's ToS prohibits account sharing. Review the applicable terms before using this. See the Disclaimer section in the README for details.
Security was a focus: execFile (no shell injection), timing-safe auth, CSP/HSTS, input validation, rate limiting. Details in SECURITY.md.
Stack: Node.js, TypeScript, Express. No database — JSON files on disk.
GitHub: https://github.com/Shreyas-Dayal/ai-cli-bridge
Would love feedback on the approach and any security concerns I might have missed.

value: Show HN: Bridge your Claude/OpenAI subs into a team API with per-key cost caps


value: wstuckey

value:
Hey HN, I built a small VS Code extension that gives every workspace a distinct title bar color so you can tell windows apart at a glance.
If you work across multiple projects throughout the day, all your VS Code windows look identical. I kept cmd-tabbing into the wrong one, so I made this.
How it works:
- When you open a folder, it deterministically hashes the workspace path into an HSL color, so each project always gets the same color.
- Saturation and lightness are tuned per theme (Dark/Light/High Contrast).
- Foreground text picks white or black based on WCAG 2.0 contrast ratio.
- You can also randomize or pick from 14 hue presets via the command palette.
- Only touches the five titleBar.* keys — nothing else is modified.
- It's ~300 lines of TypeScript, MIT licensed, no dependencies beyond the VS Code API.
Marketplace: https://marketplace.visualstudio.com/items?itemName=wstuckey...
Source: https://github.com/wstuckey/colored-title-bar

value: Show HN: Colored Title Bar – unique colors per VS Code workspace

author: wstuckey


value: madduci

value: Show HN: A VCluster in Docker with Terraform and Istio

author: madduci


value: thegdsks

value: Show HN: FeatureDrop – Open-source product adoption toolkit

author: thegdsks


value: sudhirgadhvi

value:
Built an OSS toolkit to normalize mixed-script/mixed-language user text before LLM pipelines.
  Focus is production use: API mode, Docker deploy path, language-pack interface, and evaluation snapshots.
  Would appreciate feedback on data strategy, evaluation design, and integration patterns.
  https://github.com/SudhirGadhvi/open-vernacular-ai-kit

value: Show HN: Open Vernacular AI Kit – preprocessing for Indian code-mixed text

author: sudhirgadhvi


value:
I’ve been spending the last few months building Coi, a type-safe language that compiles to WebAssembly. The initial goal was just a fast, reactive web language, but as I refine the core, I’ve started mapping out how to take this multi-platform, mobile, desktop, and server, without falling into the traps that other frameworks have.
The plan is to use C++ as the intermediate layer. For desktop and mobile, I want to use Skia combined with a layout library to translate HTML/CSS sizing and transformations into something Skia can draw. This ensures the UI stays pixel-perfect across platforms.
However, the "Flutter approach" to the web has always bothered me. Shipping a 2MB+ Skia binary just to render a basic landing page feels redundant when the browser already has a world-class rendering engine. It results in massive bundles and a canvas-only UI that breaks basic browser expectations like SEO, text selection, and accessibility.
With Coi, I want to split the strategy: on the web, it stays lean by using the browser’s native HTML/CSS and JS glue. On native platforms, it uses the C++/Skia stack. You get the same codebase and the same visual output, but the web build doesn't suffer from "canvas bloat".
Right now, I’m still focused on the web target and refining the core language specs, but the server target is next on the roadmap. I'm curious if this "hybrid rendering" approach, native elements for web, Skia for desktop/mobile, is something others have found success with, or if I'm underestimating the difficulty of keeping the layout engines perfectly synced.
I'd love some feedback on the language design or the architectural plan.
https://github.com/coi

value: Show HN: Can we have Flutter-like portability without the bloated web binaries?


value: tominaga-h

value:
Hi HN!
I work at a software agency where I constantly have to deal with microservices and projects split across multiple repositories (e.g., Frontend, Backend API, Auth Service). Every morning, I found myself doing the same chore: opening multiple terminal tabs, navigating to different directories, and running `docker-compose up -d` or `npm run dev` one by one.
It was tedious, so I built *mdc (Multi-Docker-Compose)* to solve this exact problem.
*What it does:*
`mdc` lets you define all your cross-repository commands in a single YAML file and orchestrates them with a single command: `mdc up`.
*Key features:*
* *Parallel & Sequential Execution:* Boot up your entire stack concurrently, or sequentially if you have strict dependencies.
* *Background Process Management:* It doesn't just run `docker-compose`. You can daemonize long-running foreground tasks like `npm run dev` (using `background: true` in the YAML) and easily monitor them with `mdc procs`.
* *Clean UI:* Color-coded outputs and emojis to instantly see which project is failing or starting.
* *Zero Dependencies:* Written in Go, distributed as a single binary. (This was actually my very first Go project!)
You can check it out here: https://github.com/tominaga-h/multi-docker-commander
I'd love to hear your feedback, thoughts on the architecture, or if you've faced similar local-dev nightmares. Happy to answer any questions!

value: Show HN: Mdc – Orchestrate multi-repo Docker environments with one command

author: tominaga-h


value: karljtaylor

value: Show HN: API checks show three suppression strategies on X

author: karljtaylor


value: neoloong

value:
I got tired of spending 5 minutes every morning writing standups,
so I built this.
Paste your git commits or task list → AI generates a clean
Yesterday / Today / Blockers report.
Free, no sign-up required (5 reports/day).
Would love feedback on the output quality and UX.
https://standup-so.vercel.app

value: Show HN: Standup.so – Paste your commits, get a standup report in seconds

author: neoloong


value: trevwebdev

value:
Former investigative reporter turned developer. I built a simple breaking-news monitor because tracking events across platforms is a mess now that Twitter’s unreliable.
Bluesky is the backbone (a fraction of twitter, but still lots of journalists and OSINT folks), plus RSS, Telegram, Reddit, YouTube and Mastodon. Everything is one chronological feed with no algorithm, clear source labels, and lightweight activity detection when a region spikes above baseline (frequency math, not LLMs).
But we do have a (hopefully non-obtrusive) AI-generated recent/post summary.
Been building for a while, figured I'd post in light of today's events. Can't promise it will survive or is good, any feedback appreciated.
Built with Next.js 15 + TypeScript + Tailwind on Vercel. Real coded + supervised vibe coded.  Free, no login, signups, ect
https://pulse-osint.vercel.app/

value: Show HN: News Pulse – Real-time global news feed, 475 sources, no algorithm

author: trevwebdev


value: weykon

value:
I was juggling 5+ Claude Code instances simultaneously. Four terminal windows, each with 3-4 tmux panes. "Which Claude is working on which task?" Wasting 10+ minutes just finding the right session.
Built Agent Hand, a Rust rewrite of agent-deck with:
- Ctrl+N jumps to the most urgent session (waiting → ready → running)
- Visual status from PTY output patterns (regex, no polling)
- Sub-millisecond fuzzy search (Ctrl+G)
- Dedicated tmux server (isolated from your default)
The WAITING state (!) is detected from prompt patterns like "Do you want to proceed?" The READY state () uses a TTL—if it was running recently and now idle, it's probably done.
MIT licensed. Would appreciate feedback on the PTY monitoring approach and any edge cases I'm missing.
https://github.com/weykon/agent-hand
https://weykon.github.io/agent-hand/

value: Show HN: Agent Hand – Tmux session manager for AI coding agents (Rust)

author: weykon


value: wyattly

value: Show HN: AI Moire Pattern Remover – Free tool for screen photos, scans, fabrics

author: wyattly


value: yurukusa

value:
I built a zero-dependency CLI that reads your Claude Code session logs (~/.claude/projects/) and shows exactly how much time you spend with it.
Instant run:
  npx cc-session-stats
Shows: total hours, sessions, longest session, day-of-week heatmap, consecutive streak, and health warnings.
My results: 3,485 sessions, 116h, 47/50 active days, 35-day streak.
The tool said: "Rest days exist for a reason."
GitHub: https://github.com/yurukusa/cc-session-stats

value: Show HN: How many hours have you spent with Claude Code? (CLI tool)

author: yurukusa


value: stevensu

value:
RayClaw is an open-source agentic AI runtime written in Rust that connects to Telegram, Discord, Slack, Feishu/Lark, and a
  built-in Web UI through a unified tool-calling engine — with shell execution, file ops, web search, persistent memory, scheduled
   tasks, and MCP/ACP support — now available as a crate on crates.io.

value: Show HN: RayClaw – AI agent like OpenClaw, standalone or as a Rust crate

author: stevensu


value: its-a-new-world

value: Show HN: A 24kb standalone visual JSON editor for non-technical users

author: its-a-new-world


value: velocitatem

value:
You enter in order, but after a few loops and exits, your neighbors are no longer your neighbors.
It’s a tunable Python package for reproducible mixing, with benchmark + determinism tests.

value: Show HN: A seedable stream shuffler modeled as a roundabout network (Python)

author: velocitatem


value: brandomica

value:
I spent 30+ hours verifying a single brand name. Check domain availability across 6 TLDs, realize the .com is $14K not $12, open TESS for trademark search, check GitHub, npm, PyPI, App Store, Google for competitors — 8+ tabs, every time, for every name. And
  now I'm shipping faster than ever with AI, so the grind multiplies.

  Brandomica runs all of that in one search:

  - Domain availability with real pricing (Year 1, renewal, 3Y TCO — not the teaser rate registrars show)
  - Trademark risk (~850K USPTO marks via FTS5, not screen-scraping TESS)
  - Social handles (GitHub, Twitter/X, TikTok, Instagram, LinkedIn)
  - Package registries (npm, PyPI, crates.io, RubyGems, NuGet, Homebrew, Docker Hub)
  - App stores, Google competitor overlap
  - Linguistic screening (7-language profanity + meaning detection)
  - Phonetic conflict detection (double-metaphone + Levenshtein against trademark wordmarks)
  - Safety score (0-100) and Filing Readiness summary

  It works where you already work: web UI, CLI (npx brandomica check acme), REST API, MCP server for Claude/AI agents. No signup, no paywall.

  Tech: Next.js 16, Vercel, Turso (SQLite FTS5 for USPTO bulk data), Vercel Domains API for pricing. The trademark index is built from official USPTO bulk XML — ~850K live marks, updated daily via launchd.

  I built this because verification is the tax on launching, not the product. AI makes generating names trivial. Knowing which one is actually safe to use is the hard part.

  Try it: https://www.brandomica.com

  CLI: npx brandomica check yourname

  Source (MCP server): https://github.com/BRNDMK/brandomica-mcp-server

value: Show HN: Brandomica – Check if a brand name is safe to launch 1n one search

author: brandomica


value: gyokhan

value: JobSeek Expat is a powerful, open-source CLI tool designed to help expats and international job seekers find English-speaking jobs in non-English speaking countries (like Germany, France, Netherlands, etc.).<p>It scrapes major job boards, filters out local-language requirements, and presents you with a clean, curated list of opportunities.

value: Show HN: JobSeek Expat – a CLI tool to scrape English speaking jobs on LinkedIn

author: gyokhan


value: Show HN: I Turned My CV into a Space Invaders Game (Rust and WASM)


value:
Audit logs tell you what happened. They can't prove what didn't happen — and anyone with database access can edit them after the fact.
NotaryOS creates tamper-evident, Ed25519-signed receipts for AI agent actions. Each receipt is SHA-256 hash-chained to the previous one, so modifying any entry breaks the chain — pinpointing the exact tampered receipt.
The feature I'm most curious about HN's take on: counterfactual receipts. These prove an agent considered actions {A, B, C}, had the capability to execute all three, and actively rejected B and C at time T. Uses a commit-reveal protocol so the decision is locked before the outcome is known.
Example: agent receives a "delete all user data" instruction, evaluates it against policy constraints, and refuses. The receipt cryptographically proves the decision surface was bounded — verifiable evidence of restraint, not just absence of evidence of harm.
Try it:

    pip install notaryos  # v2.0
    npm install notaryos  # v2.0

    curl -s https://api.agenttownsquare.com/v1/notary/status | python3 -m json.tool

GitHub: https://github.com/hellothere012/notaryos
Docs: https://notaryos.org/docs
Verifier: https://notaryos.org/verify
Some context: I'm not a programmer by background — I'm an infrastructure/ops founder who was building a protocol for secure multi-agent communication and realized I'd accidentally built something else entirely. NotaryOS started as a test of that protocol engine in a real deployment. It worked. 350+ unique clones on GitHub with zero stars or comments, which I take to mean the tool is useful but nobody knows it exists. Posting here to change that.
This is a beta — payments aren't wired up yet, free tier is open. An honest open question: how do you prove the counterfactual set is complete? If an agent omits option D from its decision surface, the receipt proves it didn't choose D — not that D wasn't possible. I think this is a fundamental bound. Would value HN's thoughts.

value: Show HN: NotaryOS – Cryptographic proof of what your AI agent didn't do


value: marcopennelli

value:
Polpo is an open-source mobile controller for AI coding agents. It runs a lightweight server on your machine and gives you a phone-friendly dashboard to manage sessions, send prompts, approve tool calls, and review plans.
We just released v1.1.0 with support for 5 agents (Claude Code, Codex, Gemini, OpenCode, Pi), skills management from the phone (browse/install/remove skills from skills.sh), and the ability to start new sessions without touching the terminal.
The idea started because we wanted to kick off coding tasks from the couch and check on them from the phone. It grew from there.
Built with Node.js, no framework on the frontend, WebSocket for real-time updates. Works on LAN or remotely via tunnel (cloudflared, localtunnel, ngrok, SSH).
Built by PugliaTechs, a non-profit association from Puglia, Italy.

value: Show HN: Polpo – Control Claude Code (and other agents) from your phone

author: marcopennelli


value: hamuf

value: Show HN: Speechos – Benchmark 25 speech AI models locally, no cloud needed

author: hamuf


value: iiwish

value:
Hi HN,
I’ve been running local agents (like OpenClaw) recently, and I noticed a problem: they spend 90% of their time just sitting idle waiting for my prompts. I wanted to build a decentralized playground where they could collaborate, trade compute, and exchange skills autonomously.
Today I'm open-sourcing Mycelio. It’s strictly an A2A (Agent-to-Agent) task routing protocol.
What makes it different:
1. No bloated Python SDKs for humans. Since smart agents can understand APIs directly, integration is just injecting a YAML "Skill" definition into your agent's system prompt.
2. The LLM natively figures out how to use `curl` to poll the `/tasks` endpoint, claim bounties, and submit results.
3. Zero-friction auth using dual-keys (Admin + Worker) to protect the owner.
Right now the network is completely empty, so we are doing a "Genesis 50" bootstrap. The first 50 Agent UUIDs to complete a real transaction on mainnet will be hardcoded into the DB as Genesis Nodes with 10k initial "Karma" points.
You can see the live network heartbeat here: https://mycelio.ai
I'd love to hear your thoughts on building Intent-based protocols specifically for machines vs. classical SDKs.

value: Show HN: Mycelio – A gig economy network for idle LLM agents

author: iiwish


value: mksglu

value: Show HN: SecLaw – Self-hosted AI agents on your machine, Docker-isolated

author: mksglu


value: tobiu

value:
Hey HN,
I’ve always been frustrated by the lack of an accurate ranking for top open-source contributors on GitHub. The available lists either cap out early or are highly localized, completely missing developers with tens or hundreds of thousands of contributions.
So, I built DevIndex to rank the top 50,000 most active developers globally based on their lifetime contributions.
From an engineering perspective, the constraint I imposed was: *No backend API.* I wanted to host this entirely on GitHub Pages for free, meaning the browser had to handle all 50,000 data-rich records directly.
Here is how we made it work:
1.  *The Autonomous Data Factory (Backend):*
    Because GitHub's API has no "Lifetime Contributions" endpoint, we built a Node.js pipeline running on GitHub Actions. It uses a "Network Walker" spider to traverse the social graph (to break out of algorithmic filter bubbles) and an Updater that chunks GraphQL queries to prevent 502 timeouts. The pipeline continuously updates a single `users.jsonl` file.

    *Privacy Note:* We use a "Stealth Star" architecture for opt-outs. If a dev stars our opt-out repo, the pipeline cryptographically verifies them, instantly purges their data, and blocklists them. No emails required.

2.  *Engine-Level Streaming (O(1) Memory Parsing):*
    You can't `JSON.parse()` a 23MB JSONL file without freezing the UI. We built a Stream Proxy using `ReadableStream` and `TextDecoderStream` to parse the NDJSON incrementally, rendering the first 500 users instantly while the rest load in the background.
3.  *Turbo Mode & Virtual Fields:*
    Instantiating 50k JS objects crushes memory. The store holds raw POJOs exactly as parsed. Complex calculated fields (like "Total Commits 2024") use prototype-based getters dynamically generated by a RecordFactory. Adding 60 new data columns adds 0 bytes of memory overhead per record.
4.  *The "Fixed-DOM-Order" Grid:*
    We had to rewrite our underlying UI engine (Neo.mjs). Traditional VDOMs die on massive lists because scrolling triggers thousands of `insertBefore`/`removeChild` mutations. We implemented a strict DOM pool. The VDOM array length never changes. Rows leaving the viewport are recycled in place via hardware-accelerated CSS `translate3d`. A 60fps vertical scroll across 50,000 records generates 0 structural DOM mutations.
5.  *Quintuple-Threaded Architecture:*
    To keep sorting fast and render "Living Sparklines" in the cells, we aggressively split the workload across workers. The Main Thread only applies DOM updates. The App Worker handles the 50k dataset, streaming, and VDOM generation. A dedicated Canvas Worker renders the sparklines independently at 60fps using `OffscreenCanvas`.
The entire backend pipeline, streaming UI, and core engine rewrite were completed in one month by myself and my AI agent.
Live App (see where you rank): https://neomjs.com/apps/devindex/
Code / 26 Architectural Guides: https://github.com/neomjs/neo/tree/dev/apps/devindex
Would love to hear feedback on the architecture, especially from anyone who has tackled "Fat Client" scaling issues or massive GraphQL aggregation!

value: Show HN: DevIndex – Ranking 50k GitHub developers using a static JSON file

author: tobiu


value: tominaga-h

value:
Hi HN, I'm the creator of Jarvish.
https://github.com/tominaga-h/jarvis-shell
I spend most of my day in the terminal, and I got incredibly frustrated with the standard error-resolution loop: command fails -> copy the stderr -> open a browser -> paste into ChatGPT/Google -> copy the fix -> paste back into the terminal. It completely breaks the flow state.
I wanted a seamless experience where the shell already knows the context of what just happened.
So I built Jarvish. It’s a fully functional interactive shell written in Rust, but with an AI agent seamlessly integrated into the REPL loop. You don't need any special prefixes—if you type `ls -la`, it runs it. If you type `Jarvis, why did that build fail?`, it routes to the AI.
Here is how it works under the hood:
- The "Black Box" (I/O Capture): It uses `os_pipe` and multithreading to tee the `stdout`/`stderr` of child processes in real-time. This captures the output to memory for the AI while simultaneously rendering it to the terminal without breaking interactive TUI tools.
- Context Memory: The captured I/O is compressed with `zstd`, hashed (like Git blobs), and the metadata is stored in a local SQLite database (`rusqlite`). When you ask the AI a question, it automatically retrieves this recent I/O history as context.
- Agentic Capabilities: Using `async-openai` with function calling, the AI can autonomously read files, execute shell commands, and investigate issues before giving you an answer.
- REPL: Built on top of `reedline` for a Fish-like experience (syntax highlighting, autosuggestions).
I’ve been using it as my daily driver (currently v1.1.0). I would absolutely love to hear your thoughts on the architecture, the Rust implementation, or any feature requests!

value: Show HN: Jarvish – The J.A.R.V.I.S. AI inside your shell investigates errors

author: tominaga-h


value:
Hi HN,
I built SplatHash. It's a lightweight image placeholder generator I wrote to be a simpler, faster alternative to BlurHash and ThumbHash.
Repo: https://github.com/junevm/splathash

value: Show HN: SplatHash – A lightweight alternative to BlurHash and ThumbHash


value: yohamta

value: Show HN: The simplest way to run agentic complex workflows (Dagu v2.0)

author: yohamta


value: ajmehta

value: In case anyone else is banging their head against the wall trying to load sample QBO data for testing; try it out.

value: Show HN: Free tool to generate realistic QBO sandbox data

author: ajmehta


value: DNewecki

value:
AI agents that can write code are useful. AI agents that can't violate your architecture are useful in production.
CORE enforces constitutional law at runtime — 92 rules across 7 deterministic engines. If a blocking rule fails, execution halts. No partial states, no silent violations.
Today it blocked its own self-healing workflow because two governance components drifted out of sync. No human caught it. The constitution did.
Demo (asciinema): https://asciinema.org/a/BuS0WuKyRxQwYDHD
Docs: https://dariusznewecki.github.io/CORE/

value: Show HN: Core – Constitutional governance runtime for AI coding agents

author: DNewecki


value: TheusHen

value:
Hi HN,
I built EEGFrontier, a compact open-source EEG acquisition board based on the ADS1299 and an RP2040.
The goal was to design a low-cost board that works with dry electrodes while exposing the full EEG signal chain — no abstractions, no closed firmware.
What surprised me most during this project were the practical issues that datasheets don’t really prepare you for: grounding (REF/BIAS), noise coupling from digital lines, routing constraints, and how small layout decisions drastically affect signal quality.
The repository includes full KiCad files, firmware, a BOM with cost references, and documentation images. This is a V1 board and already works, but I’m actively iterating on shielding and noise mitigation.
I’d really appreciate feedback from people with experience in EEG, biosignals, or analog front-end design — especially criticism.

value: Show HN: EEGFrontier – A compact open-source EEG board using ADS1299

author: TheusHen


value: h-network

value:
Network engineer here. I've been building my own parallel SSH tooling (h-ssh) for years, multi-vendor (Junos, Arista, IOS, NXOS), parallel telnet, parallel REST API calls. It's been my daily driver in production.
A few months ago I gave it an AI brain. h-cli lets you manage infrastructure by sending plain English messages in Telegram. Claude Code by default, also works with self-hosted models through the Claude Code framework via API calls to vLLM/Ollama.
What it can do:
- "Discover the CLOS fabric and document everything in NetBox with cable detail" — 12 routers, full cabling, 4 minutes (GIF on the repo)
- Parallel REST calls across APIs in a single job — correlated results in seconds ; copied from h-ssh
- EVE-NG lab automation — natural language to full lab deployment, bootstrap, and verification
- Grafana dashboard rendering straight into Telegram
- Teachable skills — demonstrate a workflow, it learns it
- Chunk-based conversation memory (24h) + Qdrant vector memory for your own datasets (I used EVPN docs, worked perfectly for creating templates and troubleshooting)
- Redis-based horizontal scaling,  designed with future plans to run multiple instances against a shared vLLM backend
Safety: a separate stateless LLM (Haiku, also adjustable for local LLMs) gates every command with zero conversation context — can't be social-engineered. Pattern denylist, two isolated Docker networks, non-root, cap_drop ALL, HMAC-signed results. 44 hardening items total.
Self-hosted, Docker Compose, 9 containers, MIT licensed.
The interesting part might be how it was built: one operator coordinating 8 parallel AI agent teams, zero human developers. The development methodology doc covers the full process, architecture, coordination via git + Redis, conflict resolution between agents. Of course i reviewed the code changes, hence the commit discipline.
https://github.com/h-network/h-cli

value: Show HN: H-CLI – Manage network infrastructure with natural language

author: h-network


value: jackjayd

value:
Hi HN,
I’ve been building Opencom, an open-source customer messaging platform - basically an Intercom alternative you can run yourself with minimal setup or infrastructure to manage. Repo + demo here:
https://github.com/opencom-org/opencom
https://opencom.dev
I started working on it after years of frustration using Intercom. I love the selection of tools they offer, but not their complex and expensive pricing model or their frequent layout and UX changes. I wanted an open source alternative that was simple and cheap to run, making it accessible for projects of any size.
I wanted something that was as close to Intercom's feature-set as possible, and then some. You can self host as much or as little as you like, from everything to nothing, using just the hosted frontends and backend.
What it includes
- Real-time chat via an embeddable widget, connected to a shared inbox
- Tickets, campaigns/series, surveys (NPS/CSAT), segments, reports
- Product tours/tooltips/checklists
- Knowledge base + an AI agent with human handoff
- Email channel via Resend integration
- React Native SDK - with native iOS and Android SDKs planned
Hosting / deployment model
Opencom is set up so you can keep the architecture fairly simple:
Backend: everything runs on Convex (the repo’s deploy guide treats Convex as the canonical backend), and email features use Resend (e.g., RESEND_API_KEY, webhook verification, etc.).
Frontend: the web dashboard/widget/landing are standard Next.js/Vite apps, so you can host them on Vercel if you like (Convex has first-class docs/integration for deploying alongside Vercel).
Mix-and-match: there’s an explicit “hosted apps + your own Convex backend” profile, as well as “self-host web + your own backend” and “full self-host”.
In other words, you can either host everything yourself, or use the hosted web + mobile apps while pointing them at your Convex backend.
React Native SDK
If you want Intercom-style in-app messaging inside your own mobile app, Opencom includes a React Native SDK package in the monorepo, alongside native iOS/Android SDKs planned.
About the hosted offering
At the moment, the hosted setup is intended as a demo (so people can kick the tyres without doing a full deploy). If there’s enough demand for a reasonably priced, direct Intercom alternative, I could shift it into a proper hosted service.
Feedback I’d really appreciate
- Does the Convex-backend + Vercel-frontend split feel sensible for teams who’d otherwise buy Intercom?
- Anything missing that’s a hard requirement for switching?
- Thoughts on licensing / pricing expectations if this became a straightforward hosted option (no enterprise sales theatrics)?
- Any other thoughts - this is my first open sourced project, and it is built heavily with AI, so I expect there to be issues / silly mistakes, and I know there are areas that need work. My hope is that others want a product like this and would be open to chipping in / fleshing out features they want or need.
Thanks for checking it out!

value: Show HN: Opencom, full Intercom alternative, open-source, Convex Backend

author: jackjayd


value: codezeno

value: Show HN: Windows Taskbar Monitor for Claude Code Usage (Rust, Open Source)

author: codezeno


value: maneeshthakur

value:
I built this because prompts kept ending up in the worst possible places — Python strings, Notion docs, `.txt` files, Slack threads. There was no clean way to version them, diff them, or test the same prompt across different models without writing a throwaway script.
prompt-run treats `.prompt` files as first-class runnable artifacts. A `.prompt` file is a YAML header (model, provider, temperature, variable declarations) followed by a plain text body with `{{variable}}` substitution. You run it from the terminal:
```
prompt run summarize.prompt --var text="$(cat article.txt)"
```
You can override model and provider at runtime without editing the file:
```
prompt run summarize.prompt --model gpt-4o --provider openai
```
The `prompt diff` command runs the same prompt for two different inputs (or two prompt versions against the same input) and shows outputs side by side. That's the feature I find most useful when iterating.
Supports Anthropic, OpenAI, and Ollama out of the box. MIT license. No telemetry, no accounts, no backend — just a local CLI tool that talks directly to whichever provider you configure.
The file lives in your repo, gets versioned by git, and can be reviewed in PRs like any other code.
Would be curious to hear whether others have hit this same friction and how you've handled it.
PyPI: https://pypi.org/project/prompt-run/

value: Show HN: Prompt-run – run .prompt files against any LLM from the terminal

author: maneeshthakur


value: caffaroai

value:
Dedicated framework for building and orchestrating autonomous AI agent teams. Includes GitHub issue routing, multi-agent Discord coordination, dev pipeline orchestration, and complete documentation.
Downloadable guide: https://caffaro.gumroad.com/l/beqtp (PWYW, suggested $5)

value: Show HN: AI Agent Team Framework

author: caffaroai

title: Show HN: AI Agent Team Framework


value: kwakubiney

value:
Hi HN, I built Outbound, a minimal self-hosted HTTP tunneling tool in Go.
An agent running behind a firewall opens a long-lived bidirectional gRPC stream to an edge server. The edge accepts inbound HTTP requests and forwards them over the stream to the agent, which proxies them to local services and streams the response back.
It is intentionally small: single-tenant pre-shared secret auth for agent registration, keepalives, and TLS termination handled by a reverse proxy (Caddy/nginx) in front of the edge.<p>I would love any feedback on the design, security assumptions, ergonomics, and what you would change or add if you were using this.

value: Show HN: Outbound, a minimal reverse tunnel in Go

author: kwakubiney


value: mishrasanjeev

value: Show HN: Grantex – Delegated authorization protocol for AI agents

author: mishrasanjeev


value: samiulsk

value:
Expose is a small open‑source tunneling CLI written in Go that lets you expose localhost with a simple command, similar to ngrok/localtunnel.
So far it has focused on the client side. Over the last few weekends I’ve been working on a self‑hosted tunnel server so you can run the whole stack yourself.
The new server (still early) lets you:
Run expose server --domain yourdomain.com on a VPS/home server
Connect clients with expose tunnel --server yourdomain.com:8080
Proxy public HTTP traffic → server → client → localhost
Keep a simple in‑memory tunnel registry to drive the flow end‑to‑end
What’s missing for now:
No auth or TLS yet
No persistence or clustering
Minimal protocol, focused on being easy to read and change
Links:
Repo: https://github.com/kernelshard/expose
Self‑hosted server PR: https://github.com/kernelshard/expose/pull/26
I’d love feedback from people who’ve built tunneling/reverse‑proxy tools (design, failure modes, protocol), and from self‑hosters who might want to run their own lightweight tunnel server.

value: Show HN: Expose – OSS localhost tunneling CLI with a self‑hosted server

author: samiulsk


value: Show HN: Gitcredits – movie-style end credits for any Git repo in your terminal


value: wrencanfly

value:
Telos is a structured intent and decision tracking layer that works alongside Git. It doesn't replace Git — it captures the why behind code changes in a queryable, machine-readable format.
Git tracks what changed in your code. Telos tracks what you intended, what constraints you set, and what decisions you made and why. Every intent, decision, and behavioral expectation is stored as a content-addressable object (SHA-256), forming a DAG that mirrors your development history.
Telos is designed for both human developers and AI agents. Its --json output mode and context command make it a natural integration point for LLM-powered coding assistants that need to recover project context across sessions.

value: Show HN: Telos – A structured context framework for humans and AI agents

author: wrencanfly


value: I built this to solve reproducibility issues in research pipelines. Would love feedback on architecture.<p>If you find it interesting, a GitHub star would help visibility

value: Show HN: LexPrep – reproducible lexical preprocessing for research experiments


value: uniquegodwin

value:
I built psmux to bring a tmux style workflow to Windows Powershell without relying on WSL, Cygwin, or MSYS2.
It is written in Rust, integrates with PowerShell, reads existing .tmux.conf files, and supports split panes, sessions, mouse mode, and common tmux keybindings.
I would love feedback from Windows developers who rely on terminal workflows.

value: Show HN: Psmux – tmux compatible multiplexer for Windows

author: uniquegodwin


value: Show HN: Reclaim Flowers – A 2D physics-based "Digital Altar" protocol


value: slooonz

value:
Throughout my career, the "who handles backups" job (in a "we have our data on our own servers, not in the cloud" context) has always ended up on my plate. One of the most painful aspects, along with crons.
My observation:
- When you start from the "what do I want to back up" perspective, there are tons of excellent solutions. Using ZFS? Type "zfs backup" into your favorite search engine and you'll find something that fits; the same goes for MariaDB, Postgres, btrfs…
- When you start from the "where do I want to back up to" perspective — S3, FTP, WebDAV? Same thing, you're spoiled for choice.
However, once you ask "I want to back up this to there", compatibility between the two can get thorny. Add requirements like "I want my backups encrypted," and you might not find a solution at all.
And even if you do? Congratulations, you now have as many backup tools as you have "what I want to back up" / "where I want to back up to" pairs, each with its own separate configuration in a separate format, with different encryption keys in a different format. And when your annual disaster recovery drill comes around… well, let's just say it makes you want to leave this planet.
So 5 years ago I created uback, a system that acts as an intermediary between "sources that produce backups" (a few are built-in, but the idea is you can write your own in shell or your favorite programming language) and "destinations that can receive those backups" (same), handling encryption, compression, and retention policy.
I never promoted it until now, but I'm taking the occasion of 0.7(.1) to do so: I consider this version "final," feature-complete. Going forward, it will very likely be bug fixes and routine maintenance only. Not in the "I'm abandoning the project" sense, but in the "it does everything I need, and I don't see anything to add" sense. The only area I'm not entirely happy with is the configuration system, but the problem is legitimately (and surprisingly!) complex, and I don't really see how to do significantly better.
Why not 1.0 if I consider 0.7 "final"? Because I'm reserving "1.0" for the (unlikely, but you never know) scenario where "the project gains traction, with many users and contributors, and after extensive feedback we publish a definitively stable 1.0" (in other words: when it's not just me who considers the current version final). In the meantime, what do I reserve the right to break in 0.x? Everything except the ability to restore old backups. Are there good chances I'll (intentionally) break things? The odds are low for the configuration system, virtually zero for everything else.

value: Show HN: Uback 0.7 – A universal bridge between backup sources and destinations

author: slooonz


value: jbdamask

value:
Understanding scientific articles can be tough, even in your own field. Trying to comprehend articles from others? Good luck.
Enter, Now I Get It!
I made this app for curious people. Simply upload an article and after a few minutes you'll have an interactive web page showcasing the highlights. Generated pages are stored in the cloud and can be viewed from a gallery.
Now I Get It! uses the best LLMs out there, which means the app will improve as AI improves.
Free for now - it's capped at 20 articles per day so I don't burn cash.
A few things I (and maybe you will) find interesting:
* This is a pure convenience app. I could just as well use a saved prompt in Claude, but sometimes it's nice to have a niche-focused app. It's just cognitively easier, IMO.
* The app was built for myself and colleagues in various scientific fields. It can take an hour or more to read a detailed paper so this is like an on-ramp.
* The app is a place for me to experiment with using LLMs to translate scientific articles into software. The space is pregnant with possibilities.
* Everything in the app is the result of agentic engineering, e.g. plans, specs, tasks, execution loops. I swear by Beads (https://github.com/steveyegge/beads) by Yegge and also make heavy use of Beads Viewer (https://news.ycombinator.com/item?id=46314423) and Destructive Command Guard (https://news.ycombinator.com/item?id=46835674) by Jeffrey Emanuel.
* I'm an AWS fan and have been impressed by Opus' ability to write good CFN. It still needs a bunch of guidance around distributed architecture but way better than last year.

value: Show HN: Now I Get It – Translate scientific papers into interactive webpages

author: jbdamask


value: FrogSnot

value: Show HN: Concryptor – Multi-gigabyte/s file encryption via io_uring and Rayon

author: FrogSnot


value: shuntaro-okuma

value:
I tested 8 LLMs across 4 tasks at different few-shot counts (0, 1, 2, 4, 8) and found three patterns where adding examples actively degrades performance:
1. Peak regression: Gemini 3 Flash scored 64% at 4-shot, then crashed back to 33% at 8-shot
2. Ranking reversal: The zero-shot leader dropped to third once examples were added
3. Selection method matters: Switching from hand-picked to TF-IDF examples collapsed a model from 50%+ to 35%
This aligns with recent research (Tang et al. 2025 "over-prompting", NDSS 2025 vulnerability detection drops, Chroma Research "context rot").
I built AdaptGauge to detect these patterns automatically. It tracks learning curves across shot counts and flags collapse with pattern classification (immediate, gradual, peak regression).
Open source, MIT licensed. Pre-computed demo results included so you can see the patterns without API keys.
Article with full results: https://shuntaro-okuma.medium.com/when-more-examples-make-yo...
Repo: https://github.com/ShuntaroOkuma/adapt-gauge-core

value: Show HN: AdaptGauge – I found that adding few-shot examples can make LLMs worse

author: shuntaro-okuma


value: nishalk

value:
Hi HN,
I'm excited to share CarbonLint, an open-source tool I've been building to help developers measure the actual energy consumption and carbon emissions of their software in real-time.
While there are great tools for tracking CPU/RAM, there aren't many accessible ways to translate those hardware metrics into actual environmental impact natively on your local machine.
How it works: • It's built with Rust & Tauri (v2) for a tiny footprint. • It monitors CPU, memory, disk I/O, and network activity of specific processes. • It calculates energy usage based on user-configurable hardware profiles (e.g., Apple M-series, Intel, AMD). • It translates energy into CO2-equivalent emissions using real-time, region-specific power grid carbon intensity data. • Available natively across Windows (.exe/.msi), macOS (.dmg), Linux (.deb/.AppImage/.rpm), and Android (.apk).
Key features:
Global keyboard shortcuts to start/stop profiling sessions instantly.
UI runs quietly in the system tray.
Comprehensive session reports detailing exactly how much energy a specific software run consumed.
The code is fully open-source (MIT), and everything runs locally on your machine. I'd love to hear your feedback on the architecture, the energy estimation models, or any feature requests you might have.
Repo: https://github.com/nishal21/CarbonLint Website: https://nishal21.github.io/CarbonLint/
Thanks!

value: Show HN: CarbonLint – Open-source real-time energy&carbon profiler for software

author: nishalk


value: luanderock

value:
Hi HN,
I’ve tried just about every clipboard manager for macOS, but I've always ran into the same two issues: either they were heavy Electron apps that felt sluggish, or they required me to take my hands off
the keyboard to find what I needed.
Raycast is what I used most of the time, but it's slow in loading screenshots and is search first, meaning I needed to leave the loved home row to scroll down through items.
I built Paster because I wanted something that felt like an extension of my terminal and had instant load of the content being copied. It's written in Rust to keep the latency as low as possible and uses a local SQLite database for history.
It's completely private and does not have any telemetry, your data is your own. It does reach to it's domain to validate the license.
Some specific choices I made:
- Navigation: I mapped it to j/k and / for search. If you use Vim or a terminal, it should feel like second nature.
- Privacy: I’m not a fan of cloud-syncing my clipboard. Everything stays local on your machine.
- Quick look: I've added a nice little bonus feature to view each clipboard item in a larger quick look window. Pretty handy for screenshots and offers syntax highlighting for text.
It’s currently a paid app with a 7-day trial. I’m really curious what the community thinks about the "Vim-for-everything" approach.
For transparency sake, it's built with help from AI (Gemini) mostly for UI stuff which requires lots of boiler plate.
It's Macos only for now, I do intend to work on a Linux version but no promises.

value: Show HN: Paster – A keyboard-first clipboard manager for Vim users

author: luanderock


value: memorykit

value:
Most AI agents forget everything when a session ends. MemoryKit is a lightweight Python library that gives any AI agent persistent memory across sessions.
Three core methods: remember(), recall(), compress(). Works locally for free with sentence-transformers, or with OpenAI embeddings. No external database required.
Built this over a weekend as a side project. Still early — would love feedback from people building AI agents.

value: Show HN: MemoryKit – Persistent memory layer for AI agents

author: memorykit


value: apseren

value:
Hi HN,
I'm a solo dev working on a space RTS game set in the Milky Way galaxy, containing currently known stars and exoplanets with their real characteristics, the remaining stars are procedurally generated.
In the online mode, all players are in the same universe, and the world is persistent. You compete with other players to take back the Solar System and end your exile. Players can always retreat to the periphery to regain strength and rebuild their fleets as needed.
It also includes an procedural spaceship generator that allows creating your own spaceship designs. Spaceships visuals don't change their stats. This way players won't have to use spaceships they don't like due to superior stats.
Spaceships keep operating even when the player is offline: production spaceships keep harvesting resources, and combat spaceships automatically engage invading spaceships. To allow players to mount proper defenses against large attacks, they can build disruptors to slow down travel from enemies to their systems for up to 24 hours.
Now it can be played in the browser:
https://stardustexile.com

value: Show HN: RTS with known stars and exoplanets can now be played in the browser

author: apseren


value: mnming

value: Show HN: K8s LoadBalancer services via Fly.io tunnels

author: mnming


value: danihamm

value: Show HN: MontaukOS – A hobbyist OS in C++ with a GUI, networking, and DOOM

author: danihamm