value: breakmyagent

value:
As a developer, I got tired of manually testing my AI agents and chatbots against the same prompt injections and jailbreaks every time I tweaked a system prompt. Our QA team was struggling with the exact same bottleneck, so I built BreakMyAgent.
It’s an open-source sandbox that runs an automated barrage of standard exploits against your target LLM to see if it leaks data or ignores core instructions.
How it works under the hood:
- The UI is built with Streamlit, backend is FastAPI, and dependency management is handled by `uv`.
- You paste your system prompt and hit run. It fires 12 baseline attack vectors (Direct leaks, XSS payloads, Context overflows, etc.) concurrently.
- The core mechanic is "LLM-as-a-Judge". It uses a hardcoded `gpt-4.1-mini` with strict alignment rules to systematically evaluate the target's responses.
- It supports OpenAI, Anthropic, and a solid list of open-weight models via OpenRouter (including DeepSeek V3/R1, Qwen 2.5, and Llama 3.3).
There is a hosted free version if you want to play with it immediately (I capped it at 15 requests/IP to survive the launch), but the entire tool is open-source and takes 30 seconds to spin up locally with Docker or `uv`.
Repo: https://github.com/BreakMyAgent/breakmyagent-os
Live demo: https://breakmyagent.dev
Next on the roadmap: I'm building a dedicated CLI/GitHub Action so teams can drop this into their own CI/CD pipelines to block prompt regressions. I'm also developing a PoC for multi-turn agentic fuzzing and expanding the payload database for complex tool-spoofing.
I’d love to hear your feedback! What other test configurations (besides temperature and response format) do you think are essential for a tool like this? Also open to any feedback on the architecture, the judge prompt, or specific zero-day vectors you'd like to see included in the public database.

value: Show HN: BreakMyAgent – Open-source red-teaming sandbox for LLM system prompts

author: breakmyagent


value: MaxNardit

value: Show HN: Agent Recall – Open-source, local memory for AI agents (SQLite/MCP)

author: MaxNardit


value: offbeatport

value:
Hi HN! I built MeshAway to connect Copilot SDK apps to ACP-compatible agents like Gemini, Codex, Opencode, etc.
There’s been some discussion around interoperability in this space (for example: https://github.com/github/copilot-sdk/issues/377). In practice, integrating across agent ecosystems still often means writing custom adapters or relying on different language-specific libraries in each project.
MeshAway is a plug-and-play bridge that lets Copilot SDK communicate with ACP agents beyond Copilot CLI. The goal is to keep this layer minimal so developers can use different CLI agents without rewriting their stack. It also includes an optional web interface (hub) for debugging sessions and trying prompts in a playground.
Curious if others are running into this fragmentation problem and how you’re approaching interoperability today.
GitHub: https://github.com/offbeatport/meshaway
Would love your thoughts!

value: Show HN: A bridge from Copilot SDK to ACP agents

author: offbeatport


value:
Poirot is a SwiftUI app that reads your local Claude Code sessions and gives you a proper UI for browsing conversations, code diffs, extended thinking, and configuration (commands, skills, MCP servers, etc.). Runs offline, no login, under 6 MB.
Built in a weekend using Claude Code. Open source (MIT).
Demo: https://youtu.be/JLvNSRZrxdo

value: Show HN: Poirot – A native macOS companion app for Claude Code


value: collenjk

value: Show HN: Riverse – persistent AI memory that grows with you, no RAG

author: collenjk


value: brankopetric

value: Show HN: OpenTweet – I built a way to stay active on X without opening X

author: brankopetric


value: meisnerd

value:
I've been delegating work to Claude Code for the past few months, and it's been genuinely transformative—but managing multiple agents doing different things became chaos. No tool existed for this workflow, so I built one.
The Problem
When you're working with AI agents (Claude Code, Cursor, Windsurf), you end up in a weird situation: - You have tasks scattered across your head, Slack, email, and the CLI - Agents need clear work items, context, and role-specific instructions - You have no visibility into what agents are actually doing - Failed tasks just... disappear. No retry, no notification - Each agent context-switches constantly because you're hand-feeding them work
I was manually shepherding agents, copying task descriptions, restarting failed sessions, and losing track of what needed done next. It felt like hiring expensive contractors but managing them like a disorganized chaos experiment.
The Solution
Mission Control is a task management app purpose-built for delegating work to AI agents. It's got the expected stuff (Eisenhower matrix, kanban board, goal hierarchy) but built from the assumption that your collaborators are Claude, not humans.
The killer feature is the autonomous daemon. It runs in the background, polls your task queue, spawns Claude Code sessions automatically, handles retries, manages concurrency, and respects your cron-scheduled work. One click: your entire work queue activates.
The Architecture
- Local-first: Everything lives in JSON files. No database, no cloud dependency, no vendor lock-in. - Token-optimized API: The task/decision payloads are ~50 tokens vs ~5,400 unfiltered. Matters when you're spawning agents repeatedly. - Rock-solid concurrency: Zod validation + async-mutex locking prevents corruption under concurrent writes. - 193 automated tests: This thing has to be reliable. It's doing unattended work.
The app is Next.js 15 with 5 built-in agent roles (researcher, developer, marketer, business-analyst, plus you). You define reusable skills as markdown that get injected into agent prompts. Agents report back through an inbox + decisions queue.
Why Release This?
A few people have asked for access, and I think it's genuinely useful for anyone delegating to AI. It's MIT licensed, open source, and actively maintained.
What's Next
- Human collaboration (sharing tasks with real team members) - Integrations with GitHub issues and email inboxes - Better observability dashboard for daemon execution - Custom agent templates (currently hardcoded roles)
If you're doing something similar—delegating serious work to AI—check it out and let me know what's broken.
GitHub: https://github.com/MeisnerDan/mission-control

value: Show HN: Mission Control – Open-source task management for AI agents

author: meisnerd


value: Show HN: I blocked YouTube on my kid's tablet and built an approval system


value: aaronziosec

value:
Hey everyone — I'm Aaron, co-founder of ZioSec. Wanted to introduce what we've been working on and get your feedback.
Quick background: we build adversarial testing software for AI agents — think automated red teaming. We've been building with design partnerships in the Mag 7, Big 4, and red team operators from around the world. We've been focused on enterprise AI security for the past year, testing agents for some of the biggest companies deploying them.
When the OpenClaw moment hit last month, everyone suddenly running powerful agents connected to their file systems, browsers, APIs, and messaging apps, we knew we had to open the platform up. The attack surface OpenClaw creates is genuinely unprecedented, and most people running it have no way to know what's actually vulnerable.
So we built a free tier: one agent, full attack library (250+ patterns), no credit card. It auto-discovers your OpenClaw gateway and tests for jailbreaks, prompt injection, privilege escalation, credential exfiltration, MCP exploitation, cron persistence, memory poisoning — basically everything we test for our enterprise customers.
We're actively developing new attacks specifically for OpenClaw and would love your help:
• Try it out and tell us what's useful (and what isn't): https://ziosec.com/openclaw
• If you've found a unique attack vector or developed your own adversarial techniques against OpenClaw, we'd love to hear about it. We're always trying to learn and make this more useful for everyone.
• Feedback on what to build next — what would make this actually valuable for how you use OpenClaw?
Happy to answer any questions about what we're finding, how the testing works, or AI agent security in general.

value: Show HN: We built free adversarial security testing for agents (OpenClaw too)

author: aaronziosec


value: codenomnom

value: vinext proved last week that Next.js complexity now becomes a choice, not a necessity. This is an open letter from developers who built Next.js' reputation and want it back. The GitHub repo is where we're compiling the actual pain points.

value: Show HN: Please, fix Next.js – an open letter

author: codenomnom


value: Show HN: Interactive Physics Simulations Hub built with AI


value: blakeheron

value:
Hey HN — Blake here. We built Novyx because every AI agent framework treats memory as an afterthought. Agents forget
  between sessions, can't search what they know, and when they make bad decisions there's no way to understand why.

  Novyx is a memory API for AI agents. Store observations, recall them with semantic search, and roll back when things go
  wrong.

  What it does:

  - Store + Recall — Semantic search over agent memories using sentence embeddings. Recency-weighted scoring, auto-linking
  related memories via knowledge graph.
  - Rollback — Point-in-time rollback with dry-run preview. Undo bad writes without redeploying.
  - Replay — Time-travel debugging. Reconstruct what your agent knew at any timestamp. Diff memory states between two points.
   Track individual memories from birth to death.
  - Cortex — Autonomous memory maintenance. Consolidates near-duplicate memories, reinforces frequently recalled ones, decays
   forgotten ones. Runs in the background.
  - Audit trail — Compliance-grade logging of every memory operation. Tamper-evident hash chains.

  Technical details:

  - Postgres + pgvector for storage and search. Redis for auth/rate limiting. CPU-only embeddings (all-MiniLM-L6-v2).
  - Multi-tenant with application-level isolation. ~82 REST endpoints.
  - Python SDK and JS/TS SDK. LangChain, CrewAI, and MCP integrations.
  - Free tier: 5K memories, 5K API calls/mo. Pro ($39/mo): unlimited memories + Replay + Cortex. Enterprise ($199/mo):
  counterfactual recall, drift analysis, insights.

  We're not competing with LangSmith or Langfuse — those are trace debuggers (what the LLM said). We're the layer underneath
  (what the agent knew).

  Live at https://novyxlabs.com. Docs at https://novyxlabs.com/docs.

  Happy to answer questions about the architecture.

value: Show HN: Novyx – Memory API for AI agents (rollback, replay, semantic search)

author: blakeheron


value: jacekschae

value: Show HN: I built a self-hosted course platform in Clojure

author: jacekschae


value: yelog

value:
I've been running multiple AI coding sessions in parallel and kept losing track of which one was thinking, which one was waiting for my input, and which one had quietly
  finished. Alt-tabbing through terminals every 30 seconds got old fast.

  VibeBar is a lightweight macOS menu bar app that solves this. It shows real-time session states (running / awaiting_input / idle / stopped) for Claude Code, Codex, and
  OpenCode without you leaving your current window.

  How it works

  Rather than relying on a single detection method, it uses three data channels and merges them:

  1. PTY wrapper (vibebar): wraps the CLI in a pseudo-terminal and monitors output patterns to infer interaction state with high fidelity.
  2. Plugin events (vibebar-agent): a local Unix socket server that receives lifecycle events from dedicated hooks in Claude Code and OpenCode.
  3. Process scanner: a fallback that runs ps to detect running tool processes when the stronger channels aren't available.

  State priority when channels conflict: running > awaiting_input > idle > stopped > unknown.

  Honest caveats

  - Without the plugin, awaiting-input detection uses regex heuristics on terminal output — it works but isn't perfect.
  - Codex has no plugin event channel yet, so it relies on the PTY wrapper or process scanner.
  - Automated test coverage is still thin.
  - macOS 13+ only.

  Built in Swift 6.2 with strict concurrency. The menu bar icon has four styles (Ring, Particles, Energy Bar, Ice Grid) and supports English, 中文, 日本語, 한국어.

  Source and releases: https://github.com/yelog/VibeBar

  Happy to answer questions about the PTY/plugin architecture or the Swift implementation.

value: Show HN: VibeBar – macOS Menu Bar Monitor for Claude Code, Codex and OpenCode

author: yelog


value:
This is a simple web application for personal use that some of you might find useful. It's essentially a serverless version of Calibre's "Fetch News" feature, designed to run on free/hobby server tiers.(Koyeb/Render etc).<p>It compiles the last 24 hours of your chosen RSS feed articles into a single ebook.
Users can download ebooks either via OPDS or send to ereader via email method.

value: Show HN: RSSPub – A self-hosted Rust app to turn RSS feeds into a daily ePub


value: codingstark

value:
Hi HN — I’m sharing @codingstark/x402-elysia, an ElysiaJS (Bun) plugin that implements the x402 Payment Protocol to protect HTTP routes behind crypto micropayments.
What it does:
Lets you configure paid routes like "GET /api/weather" and enforce payment requirements (price, chain/network, recipient address).
If a client hits a protected route without a valid payment header, it returns 402 Payment Required describing what to pay; after payment, the request is allowed through and the handler runs.
Why I built it:
I wanted “pay-per-request” APIs in the Bun/Elysia ecosystem (same idea as existing x402 middleware in other frameworks, but native to Elysia).
I’m planning to use it to power paid endpoints in my own product (slaab.ai), but this repo is intended to be generally useful for any paid API.
How to try it:
Install: bun add @codingstark/x402-elysia
The README has a complete “Quick Start” showing .use(paymentMiddlewareFromConfig(...)).
Demo:
I also recorded a short video showing the flow (request → 402 → pay → retry → success): https://x.com/twitter/status/2027014126648672438
Feedback I’m looking for:
Does the configuration shape feel idiomatic for Elysia apps?
Any missing use-cases (multiple chains, paywall UX, internal bypass hooks) you’d want for production paid APIs?

value: Show HN: One-line x402 pay-per-request protection for ElysiaJS APIs

author: codingstark


value: christalingx

value: Show HN: Compression API for LLM prompts (40-60% token savings, ~5ms overhead)

author: christalingx


value: I built jiken, a Python library for accessing real estate transaction data from Japan's Ministry of Land (MLIT).Japan's government publishes detailed real estate transaction records through a public API, but working with it directly can be cumbersome. Jiken wraps it in a clean, type-safe interface with zero external dependencies – just the Python standard library.Would love feedback on the API design and any feature requests.

value: Show HN: Jiken – A zero-dependency Python client for real estate transaction API


value: shaihazher

value: Show HN: Tappi Browser – Fastest AI browser, 3-10x fewer tokens, zero telemetry

author: shaihazher


value: Released @jtalk22/slack-mcp v2.0.0 today. Deterministic diagnostics, read-only --status checks, stable MCP tool contracts. Install proof in release notes.

value: Show HN: Slack MCP Server v2.0.0 (deterministic Slack MCP diagnostics)


value: mrdost

value:
I built a small tool for domain owners who just want a clean self-hosted-style “for sale” page and prefer handling transactions themselves (choosing an escrow themselves, negotiating etc.).
You add a domain, verify ownership via redirect, modify price (5 LLMs appraise your domain for free, you might set a discount) and contact details, and get a simple sale page, your unused domain now redirects to. Buyers contact you DIRECTLY. No signin walls. You keep 100% of your deal, a kind of self-hosted handle-everything-yourself fashion
Also you can share a link to your profile page with all your listed domains, like a portfolio showcase or a domain stall
The idea is minimal infrastructure for direct P2P domain sales.
I'm currently working on Whois/RDAP stuff to display expiration dates, could be very convenient in the future to get notified about expiration dates
Example page:
https://d.omain.co/d/startup.broker
Happy to answer questions and would appreciate feedback.

value: Show HN: Show your domains and get buyers message you directly

author: mrdost


value: justjoepeanut

value: Show HN: Orchagent – Cloud infrastructure for AI agents. On-demand and always-on

author: justjoepeanut


value: Show HN: ContextUI open sourced – Local first AI workflows for humans and agents


value: recuerdame

value:
I built a pixel canvas where you place tiles at real lat/lon coordinates on a world map – a 1.6M × 1.6M pixel grid (2.6 trillion addressable pixels). The technical challenge was making it feel smooth from zoom level 0 (whole world) to zoom level 18 (individual pixels).
What I tried and what worked:
- Canvas2D → WebGL: At wide zoom, Canvas2D couldn't keep up redrawing millions of pixels. Switched to a WebGL renderer with mipmap-style tile pyramids – pre-rendered lower-res textures for each zoom level, only loading full-res tiles when you're close enough.
- Viewport-scoped SSE: Instead of broadcasting all pixel updates to every client, the server only streams changes within your current viewport bounds. Cuts bandwidth by ~95% for a sparse map.
- Mercator pixel mapping: Each pixel maps to a real geographic coordinate. The tricky part was making pixel density feel uniform despite Mercator distortion at high latitudes.
- Seeded pixel art: Pre-placed recognizable characters in major cities so new users see something interesting immediately instead of a blank map.
Stack: Node.js, WebGL, SSE, S3 tile storage, Lambda for tile generation.
Free to use, no account required to browse. Still early – would love feedback on the rendering approach.

value: Show HN: WebGL mipmap renderer for a zoomable R/place on a real world map

author: recuerdame


value: HiTechK

value: Show HN: EZClaw – Deploy OpenClaw in Minutes

author: HiTechK


value: marcopinato

value:
Hi HN!
We built Sonde (https://github.com/compiuta-origin/sonde-analytics) after noticing - probably like everybody else - our website traffic was declining while prospects were telling us "I found you through ChatGPT".
We wanted to understand our visibility across LLM responses, as we did in the good old days of SEO and web analytics. Since existing tools were enterprise-tier expensive, we built Sonde as a simple internal project to:
- schedule prompts to run against multiple LLMs, with web search enabled
- track whether your brand is mentioned in responses, how it ranks vs. competitors and general sentiment
- monitor trends over time
Tech stack: Supabase, Next.js, OpenRouter as LLM wrapper.
Sonde is fully open-source and you can self-host it via Docker Compose. We're also offering a managed version for convenience, running with complete feature parity.
Sonde has fundamentally changed how we approach content strategy for our products: I'd love to get feedback on it, or hear how you're currently tracking LLM visibility!

value: Show HN: Sonde – Open-source LLM analytics (track brand mentions across LLMs)

author: marcopinato


value: dmpyatyi

value:
Telegram added gifts last year. Almost every gifts is shown on profile.
Anyone can map a graph by follow gift sender to recipient to their gifts and so on.
I used telethon and psql for this.
Scraping speed per one account - 8k/hour

value: Show HN: Bored, so I graphed 2M Telegram users by their gifts

author: dmpyatyi


value: rvalley

value:
Last year I was traveling as a digital nomad with a dog and spent too much time checking the requirements for each country. Every search result was a blog post, a YouTube explainer, or an old Reddit. I just wanted a list I could check off.
I had the idea of building a checklist library many years ago, but found myself with the barrier of generating the content. Now that's a solved issue.
I built tiqd.app. It's a library of checklists for the stuff life throws at you, like visas, moving, travel, job interviews, home buying. Not a task manager, just find a checklist and check things off. Statically generated from Postgres at build time (Next.js 14 SSG), so every page is just HTML. No logins, no backend for user state.
The share feature encodes all checked IDs as lz-string in a ?p= URL param. Felt like a nicer UX than forcing a signup just to compare notes with someone.
I optimized the architecture and development for programmatic SEO. Vibed coded most of it with clear instructions focused on distribution. A few days old and already seeing referral traffic from ChatGPT, which I wasn't expecting.
I'm also using Claude Code for the distribution side - branding, content calendar, social copy. Treating the whole launch as a learning exercise in programmatic SEO and distribution.
The content scales programmatically but most distribution advice out there is manual. If anyone has cracked programmatic distribution for a content site, I'd genuinely like to know what worked.

value: Show HN: Tiqd – a checklist library for life tasks

author: rvalley


value: ilkeraltin

value: Show HN: Soften Sleep – an iOS app for waking up at 3 AM with racing thoughts

author: ilkeraltin


value:
Hey HN,
I got tired of digging through cluttered OS network settings every time I wanted to change my DNS provider (Cloudflare, Google, Quad9, etc.). It always felt like too many clicks for such a basic task.
To fix this, I built cdns in Go. It’s a minimal, single-purpose CLI tool that strictly follows the KISS principle. You run one command, pick your provider, and your system's DNS is updated instantly right from the terminal.
https://github.com/junevm/cdns
I'd love to hear your thoughts, any feedback on the Go implementation, or if you run into any OS-specific edge cases!

value: Show HN: CDNs – A simple Go CLI to switch DNS servers in one second


value: Abhinayguptha

value:
Hey HN — I built openclawsetup.tech after seeing dozens of comments about people giving up on OpenClaw's setup process.
The traditional setup (VM, SSH, Node.js, API keys, messaging channels) takes 60+ minutes. This reduces it to 3 clicks: sign in, choose a model, deploy.
Managed hosting handles the infrastructure. Free tier available.
Would love feedback from this community.

value: Show HN: Deploy OpenClaw in 60 seconds – one-click setup, no DevOps needed

author: Abhinayguptha


value: lexokoh

value: Show HN: Verify any email address instantly

author: lexokoh


value:
One of the authors. Some things that surprised us while running these experiments:
The tasks are pulled from real merged PRs in vLLM and SGLang, so there's a known-good human solution for each one. Agents get the full codebase, the issue description, and a test harness. Pretty generous setup.
What we didn't expect: the agents are genuinely good at diagnosing the problem. They read the code, find the bottleneck, describe the right fix. But then the generated code has subtle bugs. Off-by-one in kernel indexing, wrong tensor shapes, missing synchronization barriers. The kind of stuff that passes a code review at first glance but segfaults under load.
The other weird result: agent rankings completely invert between codebases. Claude Code is the best performer on vLLM (46%) but the worst on SGLang (27%). TRAE with GPT-5 is the opposite pattern. Same underlying models, different agent scaffolding. It suggests the scaffolding around the model matters at least as much as the model itself.
We also tried three open-source models. None produced a single working optimization. One of them (MiniMax-M2.1) got stuck in a loop printing "I need to actually use the tools now" 2,412 times without ever making a tool call.
The benchmark, all agent transcripts, and evaluation code are open: https://ayushnangia.github.io/iso-bench-website/
Curious what others think about the scaffolding result in particular feels underexplored.

value: Show HN: Coding agents find the right GPU bottleneck 70% of the time, fix it 30%


value: keveenwong

value:
Hey HN,
We built Heimdall (heimdallspace.com) because the existing tools for space situational awareness are genuinely painful to use: clunky interfaces, fragmented data sources, slow rendering. The ones that aren't are locked behind enterprise solutions. We thought the foundation of this should be open and accessible.
The goal is a satellite observability platform: one place that gives operators complete, real-time insight into their assets and the orbital environment around them. Today's release is the foundation—aggregating and rendering the full public space catalog (30,000+ objects) in real time.
How it works technically:
- SGP4 propagation running across web workers, computing positions every few frames
- Go backend ingesting TLEs hourly from Space-Track.org with daily metadata enrichment from GCAT
- React + Three.js frontend rendering 30,000+ objects as GPU point sprites with custom GLSL shaders
- 8K Earth textures with accurate solar-positioned day/night cycle
- Self-hosted on a VPS
Any feedback is appreciated. We'd also love technical feedback on the propagation approach, data pipeline, or anything that looks wrong or could be done better. We're looking for professionals in the space industry who might be able to provide real-world insight into what they want from the platform. We're early and building in the open, so this is a real ask.

value: Show HN: Real-Time Satellite Tracking and Intelligence Dashboard

author: keveenwong


value: Show HN: Typed overlay over SQL now supports DuckDB


value: bwoud

value: Show HN: I built a 50ms SPF record and Shadow IT scanner

author: bwoud


value: ryanlitalien

value:
Hi HN,
Around summer/fall of 2025, I started using 'plan mode' quite a bit more. When I would cmd+click into a newly created markdown plan, macOS would open Xcode. This was slow, didn't have native rendered viewing, the list goes on. I started working on a markdown viewer to easily open, review plans before I sent Claude on their way. The Markdown Viewer was born! It came from inspiration from the great Preview Mac app.
For Christmas our family got a Bambu A1 3D printer (fantastic btw!) and I wanted to easily preview 3d files before opening/sending to the printer, etc. Well, I started up a 3d viewer. Yaml, CSV, Text viewers all followed.
As a responsible engineer, I started seeing patterns, so I DRY'd it up w/a core library, but was stuck with how to update each one, and to consistently get around the Apple notarizing/signing. So I created the Viewer Toolbox. The toolbox is an easy way to install and update my viewer apps. Now I can "write once, use everywhere" ;). I have a few Macs at home that I can now just click "Update" on the app and it's ready to go.
Originally, I opened up the Apple Mac Store to see if there were any quick viewers, but most were paid or had in-app purchases. I didn't think one app by itself was worth charging for, so my friend suggested I put the Toolbox up online for a price. Makes sense! So the individual apps are free, and if you want to get updates or new viewers, download the Toolbox! The individual apps will never have a paid version. This was to solve my own problem.
I was debating about writing this, but with Simon's recent blog post about his presentation app and how that Microsoft was adding markdown and AI support to Notepad, I had to launch this today.
Minor tech tangent: they're all native Swift/SwiftUI, universal binaries, no Electron, and each one is 1-2 MB. I share a small Swift package (ViewerCore) across all of them for common functionality like search, theming, and web view rendering. Simple, fast, free and portable are key here.
Hopefully this helps someone :).
Thank you!
Ryan
https://ryanlitalien.com/simple/
https://ryanlitalien.gumroad.com/l/viewer-toolbox (photos of the apps are on here)

value: Show HN: Simple Viewers – Tiny native macOS file viewers

author: ryanlitalien


value: elliotbnvl

value:
Hi all, author here.
This is a live, multiplayer "text-to-website" sandbox: people type requests in chat, and the site updates in real time. It’s powered by Sonnet 4.6.
I built it as a public demo of what current AI agents can actually do on real web code. It’s running on my own infra / API budget for now, so usage is rate-limited.
Under the hood it uses the same stack as the core product, including Bareclaw, a thin Claude Code CLI wrapper for custom clients. [1]
Inspiration came from Pieter Levels’ recent “chat with your website" tweet. [2]
[1] https://github.com/elliotbonneville/bareclaw
[2] https://x.com/levelsio/status/2023960543959101938

value: Show HN: Multiplayer realtime text-to-website demo (live edits via Sonnet 4.6)

author: elliotbnvl


value:
Prompt injection is primarily a control problem, not just a filtering problem.
Modern AI agents operate with authority — executing tools, accessing credentials, and interacting with external systems. Many defenses focus on detecting malicious inputs. MVAR instead enforces deterministic security boundaries at execution sinks, where privileged actions occur.
Core design principle: separate influence from authority.
Untrusted data may influence reasoning; privileged execution is governed by policy invariants.
MVAR implements three enforcement layers:
1. Provenance-based information flow control
All data carries integrity and confidentiality labels with conservative propagation. Policy decisions derive from data lineage rather than payload inspection.
2. Capability-based runtime constraints
No ambient authority. Tools execute within explicitly declared permissions. Targets are enforced individually (e.g., api.gmail.com ≠ arbitrary domains).
3. Deterministic sink policy evaluation
Privileged actions are evaluated against strict invariants:
UNTRUSTED + CRITICAL → BLOCK
Decisions are deterministic and produce evaluation traces.
When enabled, decisions may be cryptographically signed (QSEAL Ed25519) for tamper-evident auditability.
Validation
Evaluated against a reproducible 50 vector adversarial corpus spanning nine attack categories (command injection, encoding/obfuscation, multi-stage execution, credential theft, etc.).
Validation suite runs locally in ~2 minutes.
Scope, assumptions, and limitations are explicitly documented in THREAT_MODEL.md.
This release represents Phase 1, focused on deterministic enforcement rather than detection or behavioral scoring. Composition attacks and automatic sink discovery are future work.
Open source (Apache 2.0).
Repository: https://github.com/mvar-security/mvar
Site: https://mvar.io

value: Show HN: MVAR – Deterministic sink enforcement for AI agent


value: sirlojik

value: Show HN: Spana Time – An AI automotive ecosystem built on WhatsApp

author: sirlojik


value: nobbygoesbrr

value:
Hi HN,
Most AI agent workflows today rely on "vibes" and prompt engineering to stay on track. We’re essentially trying to cage a chaotic system with natural language, which often fails when 100% reliability is required.
After spending several thousand hours on the problem of deterministic layers for AI, I built LetsClarify.ai. It’s a dead-simple API designed to bring a human back into the loop without the overhead of building a custom frontend or notification system.
The core idea:
Instead of letting an agent guess when it hits an edge case, you trigger a clarification request. The human provides the missing intent via a minimalist interface, and the agent receives structured, type-safe JSON back.
Key features:
Zero Dashboard: You can generate your API key directly via curl.
Ephemeral: No long-term data storage; it’s just a bridge for intent.
Architecture-agnostic: It doesn’t matter if you use LangChain, AutoGPT, or a custom script.
I believe the path to 100% reliability isn't more brute-force compute, but a mathematically sound way to translate human intent into code.
I'm curious: How are you currently handling edge cases where your agents "hallucinate" a path forward instead of asking for help?
URL: https://letsclarify.ai/

value: Show HN: LetsClarify – A dead-simple API for Human-in-the-loop AI"

author: nobbygoesbrr


value: kxbnb

value:
I run OpenClaw agents for a bunch of different things. The agents are great, the infra around them is not.
So I built Claw42. You get a full browser, shell, and tools out of the box. Just run your agent. Managed Claw out of the box.
It's early and I haven't even set pricing yet. There's a short survey on the pricing page if you want to weigh in on what feels fair. I'd rather get it right with real users than guess.
If you're running agents today and tired of the plumbing, sign up and give it a go!

value: Show HN: Claw42 – Claw as a Service

author: kxbnb

title: Show HN: Claw42 – Claw as a Service


value: timstark

value:
I built a drop-in MCP server that sanitizes web content before it reaches your LLM — stripping prompt injection vectors deterministically, no LLM call needed. Along the way I found it also cuts token usage by ~90%.
Hidden HTML elements, zero-width characters, base64 payloads, fake LLM delimiters (<|im_start|>, [INST], <<SYS>>) — WebFetch passes all of it straight through. mcp-safe-fetch strips it in 8 stages on raw HTML and the resulting markdown.
Tested against PayloadsAllTheThings: caught 3 hidden elements and 4 LLM delimiter patterns WebFetch missed. Side effect I didn't expect — ~90% average token reduction across 4 test sites. Live test: same article, same task, 24,700 tokens vs 575.
Doesn't catch semantic injection (malicious instructions in visible text). That requires model judgment.
npx -y mcp-safe-fetch init — sets up Claude Code in one command. Works with any MCP client.

value: Show HN: I solved Claude Code's prompt injection problem, saved tokens doing it

author: timstark


value: Show HN:Covenant: Self hostable AI gateway with behavioral contracts


value: Show HN: I built a tutorial to help you learn Kuberenetes in most simplest way


value: MattijsMoens

value: Show HN: A closed source engine that stops hallucinations deterministically

author: MattijsMoens


value: xeloxa

value: Show HN: WP-Hunter, WP recon and SAST tool (building Agentic AI pipeline)

author: xeloxa


value: qagaryparker

value:
Hi HN,
I’m the creator of StageWright (and the open-source playwright-smart-reporter).
I’ve been frustrated by the "black box" nature of E2E test failures. Standard reporters tell you that a test failed, but they don't help you understand why it’s failing across 50 different runs or whether its execution time is trending toward a regression.
I built StageWright to treat test results as a performance and stability dataset.
Key Technical Features:
Historical Flakiness Detection: Unlike Playwright's default "retry" logic, we track failures across runs. A test only gets a high "Stability Grade" if it consistently passes over time.
Flamechart Step Timelines: We added a color-coded flamechart for test steps (v1.0.8). It categorizes steps into Navigation, Action, and API, making it easy to see if a 10s test is hanging on a locator or a slow backend response.
2-Sigma Anomaly Detection: The trends view uses moving averages and 2-sigma outlier detection to flag performance regressions that might otherwise go unnoticed.
AI-Powered Failure Clustering: We batch failures and use Claude/GPT-4 to cluster similar errors. Instead of 20 separate failures, you see "1 cluster: TimeoutError on payment-submit-btn."
Virtual Scroll Performance: We optimized the UI with virtual scrolling to handle suites with 500+ tests without the browser freezing—a common issue with the default HTML reporter.
Native Trace & Network Logs: Traces and network waterfalls are embedded directly in the report. No downloading .zip files from CI; they open instantly in an inline viewer.
The Architecture:
StageWright is built to be "Playwright-native." It hooks into the reporter API and can run locally (outputting a standalone HTML/JSON history) or via our new Starter/Pro cloud tiers. The Pro tier provides a centralized dashboard for teams, long-term history retention, and cross-project analytics.
I’m currently supporting both Node.js and Python (pytest-playwright) environments.
I’d love to hear what the community thinks—especially regarding how you handle "test debt" in large CI pipelines. I'm here for any questions!

value: Show HN: StageWright – A performance-focused Playwright reporter with AI

author: qagaryparker


value: dongekon

value: Show HN: Ccperm – Audit Claude Code permissions across projects

author: dongekon


value:
The current binary computing paradigm has hit a hard thermodynamic wall. We are watching the most advanced digital systems throttle their own logic because the energy cost of algorithmic emulation, forcing continuous reality through billions of discrete, microscopic gates, has become fundamentally unsustainable.
 For the past decade, I have been engineering the foundation of a new era: a non-algorithmic architecture that utilizes 3-phase AC power directly as the computational medium.
 Instead of binary voltage thresholds, the architecture computes using the continuous phase differential of macroscopic wave superposition. The foundational logic is driven by the physical integration of phase vectors:
V_net(t) = Σ [A_n * sin(ωt + Φ_n)]
By engineering the physical medium to capture specific interference patterns, we achieve true ternary logic states based on thermodynamic phase tension, natively undercutting the Landauer limit of binary bit-erasure:
L(ΔΦ) =[ 1 if ΔΦ > θ_th ]
        [ 0 if |ΔΦ| ≤ θ_th ]
        [ -1 if ΔΦ < -θ_th ]
Because there is zero algorithmic translation, the continuous wave translates instantaneously into discrete natural language tokens. It doesn't just calculate; it generates complex vector embeddings and fluid natural speech as a single physical event, completely bypassing the massive GPU arrays currently suffocating under LLM power demands.
 Applications:
 The implications extend far beyond the datacenters. In orbital space missions, where cosmic radiation regularly causes catastrophic binary bit-flips, this architecture is completely immune. You cannot bit-flip a continuous AC wave, providing unbreakable physical autonomy for rovers and satellites.

value: Show HN: The von Neumann era is over. Fabricating physical 3-phase AC ternary AI


value: saikatkumardey

value:
I built termstage because I was tired of screen-recording CLI demos and ending up with heavy GIFs that look bad in READMEs.
termstage lets you describe a terminal session in YAML and renders it as an animated SVG — lightweight, crisp at any size, embeds directly in GitHub READMEs.
Example:

  steps:
    - cmd: "notes list"
      output: "#1  Fix the login bug"
    - cmd: "notes done 1"
      output: "Marked #1 as done"

Run `termstage render demo.yaml --animated` and you get an SVG you can drop anywhere.
Install: pipx install termstage
GitHub: https://github.com/saikatkumardey/termstage
PyPI: https://pypi.org/project/termstage/

value: Show HN: Termstage – Animated terminal SVGs from YAML, no screen recording

author: saikatkumardey


value: supasidebar

value:
Hey HN! I was very early adopter of Arc. as a dev, I enjoyed useful shortcuts (like copy URL), vertical sidebar, command panel, and other cool features. when TheBrowserCompany left Arc, i also switched browsers but missed all those cool features. so I decided to make Arc’s features universal.
Meet SupaSidebar - Arc-like sidebar for all browsers
Here’s what the app can do:
  - Save links, files, and folders from any browser or Finder
  - Fuzzy search current open tabs, browser history, and saved links
  - Open saved links in any browser with just a click
  - Common browser history across browsers
  - iCloud sync
  - Link browser profiles to Spaces and quickly switch between them
  - Built-in sidebar feel with fullscreen, overlay protection, auto show/hide etc.
  - Global shortcuts, Air Traffic Control, AI tagging, and more
here's a demo video: [SupaSidebar Demo](https://youtu.be/OimIUO0PSAk)
Free to use for up to 3 Spaces. Native Swift/AppKit, no Electron.
Still in development and I’m making it better daily, so any feedback would be appreciated.

value: Show HN: SupaSidebar – I made Arc's sidebar universal for every browser

author: supasidebar


value: powerback

value:
Over the past few years I’ve been building POWERBACK, a web platform that experiments with applying conditional escrow mechanics to campaign finance.
Instead of donating directly to a campaign, users commit funds under a publicly defined condition. Funds are intended to be collected up front and released only if the condition is met. (If the condition is not met, funds are not refunded and instead support the platform.)
Conditions must be externally verifiable and rule-based.
The current v1 focuses on a single condition: whether H.J.Res.54 (a proposed constitutional amendment from Congresswoman Jayapal to overturn Citizens United) receives a floor vote in the House.
This demo does not collect funds, create accounts, or process payments. It is an interactive walkthrough of the mechanics and UI flow.
The intended full version includes authentication, payment via Stripe, and automated condition resolution.
Technical stack: MERN (MongoDB, Express, React, Node), VPS deployment with Nginx reverse proxy, JWT auth in the full build, and background watchers for legislative updates.
The hard problems have been structural rather than technical: defining objective conditions, avoiding discretionary fund control, ensuring neutrality, and designing something that does not resemble a quid pro quo.
I’m interested in feedback on the escrow model, incentive alignment, legal edge cases, and whether the mechanism is clear.
Demo: https://demo.powerback.us
Happy to answer questions.

value: Show HN: I built a conditional political donation system (demo)

author: powerback


value: santoshus

value:
Hey HN,
I built a free job application tracker. Kanban board, Chrome extension, AI suggestions.
The Chrome extension uses a tiered extraction approach — it tries structured API-level extraction first (LinkedIn, Greenhouse, Lever, Ashby), falls back to platform-specific DOM selectors, then generic parsing as a last resort. Most of the interesting engineering work went into making that pipeline reliable across different ATS platforms.
Other features: visual Kanban pipeline, a "Chances" system where you assign a confidence score per application (useful for prioritizing follow-ups), and AI-powered suggestions.
It's free — not freemium. I run it on a donation model. I'm a Head of Engineering and I've spent years on the hiring side. Watched the layoff wave hit hard this past year and got frustrated that every decent job tracker charges $15-50/month for features that aren't that complex.
My wife works in Talent Acquisition and we're building coaching features (CV review, interview prep) next.
Solo project, definitely rough edges. Would love technical feedback and honest criticism.
applyflowtracker.com

value: Show HN: ApplyFlow – Free Kanban job tracker with multi-tier Chrome capture

author: santoshus


value: waleedk

value: Show HN: CodevOS – Human-AI dev OS that shipped 106 PRs in 14 days on 80k LOC

author: waleedk


value: tomneijman

value:
I built an open format for self-contained knowledge cards.
Each card is a single directory:
- standalone HTML (no CDN, no external fonts)
- bundled CSS + assets
- print-ready PDF
- JSON-LD metadata
No account. No platform. No external dependencies.
The card itself is the product.
Goal: use LLMs to distill practical knowledge into small independent units — then make those units survive without the technology that created them.
"The best use of AI is not automation, but preservation — helping humans rebuild when machines are gone."
---
Identifier model:
Each card receives a 128-bit ULID.
The bits are mapped to A/C/G/T, producing a 64-character DNA-like sequence.
The first 9 characters map to three craft “codon” words from a fixed vocabulary (e.g. klei·vuur·rots).
Properties:
- Globally unique
- Chronologically sortable
- Bidirectionally decodable
- No central registry
The DNA appears in the URL, footer, and print version.
---
Integrity:
Each build generates a SHA-256 manifest of all cards, signed with Ed25519.
Verification happens client-side using the Web Crypto API (no server round-trip).
Verify here:
https://stoutenburger.com/verify/
---
Edition 1 is live (10 cards):
Water purification, fire, clay, basic metallurgy.
Five card types:
Knowledge (why), Instruction (how), Product (what), Maker (who), Network (connections).
Build pipeline:
Markdown + YAML → JSON Schema → Nunjucks → Puppeteer → signed manifest.
Cards are designed to roam: USB stick, any domain, or printed in a drawer.
The format is open.
https://stoutenburger.com

value: Show HN: Self-contained offline knowledge cards with ULID-DNA and IDsEd25519

author: tomneijman


value: billybat

value:
I kept building this for basically every project I built, so decided to make a standard version.
tl;dr:
- add actions to .kadai/actions in your repo
- run `bunx kadai`
- get a little CLI menu to run your actions
actions are also 'AI friendly', meaning there's an .mcp.json setup that points to kadai so AI's can discover any actions you add to kadai
basically you can share scripts/actions across your team and also expose them to AI at the same time

value: Show HN: Kadai –> AI friendly, discoverable project tools

author: billybat


value: ybsoft

value:
Temporal, Airflow, Step Functions are great — but sometimes you just need "run these steps, resume where it stopped if something crashes," without the infrastructure and learning curve that comes with a full platform, and whole mental model to internalize
So I built something simpler and maybe i over simplified things..
It sticks with philosophy of "workflows as code", so no dsl , no no-code, or visual designer. just a developer friendly lib..
Sayiir is a library you pip/npm/cargo install. Define steps as normal async functions, it checkpoints each output. On failure, completed steps are skipped, execution picks up where it left off.
No replay, no determinism rules, no separate server to deploy, no activities — just your good old existing async functions with durable execution underneath.
Rust core, Python/Node.js bindings. MIT licensed
Docs: https://docs.sayiir.dev
Playground: https://docs.sayiir.dev/playground/

value: Show HN: Sayiir – A simple durable workflow engine (Rust core, Python/Node.js)

author: ybsoft


value: tsump

value:
I built ArteSync, a CLI package manager for managing "agent skills"—prompt instruction files that extend AI coding assistants like Claude Code, Cursor, or Gemini CLI.
The problem: as I accumulated skills across projects, I found myself manually copying files between repos with no way to track versions or share updates reliably.
ArteSync treats any public GitHub path as an installable source and locks it to a commit hash, similar to how npm/Cargo handle dependencies:
arsync install myorg/myrepo/skills/my-skill#main
This fetches the files, writes a skills.arsync manifest, and generates a skills-lock.arsync lockfile (commit-pinned). Running arsync install with no arguments does a hard checkout to the exact hashes in the lockfile—so teams get reproducible skill environments. arsync update checks for upstream changes and rewrites the lock.
It's early and experimental (breaking changes possible), but it's usable:

  npm install -g artesync

Happy to answer questions.

value: Show HN: ArteSync – A package manager for AI coding agent skills

author: tsump


value: kfallah

value: Show HN: CLaaS – Update your local LLM's weights in real time from text feedback

author: kfallah


value: mnemoxai

value:
I built an MCP server that reality-checks project ideas against GitHub, Hacker News, npm, PyPI, and Product Hunt before you start coding.
v0.3 adds a 3-stage keyword extraction pipeline:
- Stage A: Stopword filtering (removes noise like "a tool that can")
- Stage B: Intent anchoring (maps vague terms to searchable keywords)
- Stage C: Synonym expansion + Chinese-to-English term mapping (150+ terms across 15 domains)
Before: Chinese input "寵物預約看診 app" → searched raw Chinese → garbage results
After: Same input → "pet appointment veterinary booking app" → relevant results
Other stats:
- 204 tests, 93% keyword extraction accuracy
- Quick mode (GitHub + HN) ~2s, Deep mode (5 sources parallel) ~3-4s
- Zero config: `uvx idea-reality-mcp`
- Works with Claude Desktop, Cursor, any MCP client
Built with Python + FastMCP + httpx async. MIT licensed.
GitHub: https://github.com/mnemox-ai/idea-reality-mcp

value: Show HN: MCP server that checks if your project idea exists

author: mnemoxai


value: gregolo

value: Show HN: HeyAgent – continue your Codex/Claude sessions from Telegram

author: gregolo


value:
I wanted to study large Python AI repos offline. Printing code helps focus but loses all context — no way to follow function calls without jumping back to the screen.
So I built pBinder. It converts Python repos into a Word document with a clickable TOC, symbol index, and call-site cross-references — every function call links to where that symbol is defined, including source line.
Portable Windows EXE. No Python, LaTeX, or Docker required. Batch export included.
Honest limitations: Windows only, PDF requires Microsoft Word, cross-references are .py files only.
pbinder.app — free trial available.

value: Show HN: PBinder – Python repo to DOCX/PDF with call-site cross-references


value: steppacodes

value:
After seeing 8,000+ MCP servers exposed this month and the OpenClaw/ClawHavoc campaign compromise 30,000+ instances, I built a proxy that keeps credentials in the OS keychain. The agent makes authenticated API calls but never sees the key values.
The core insight: AI agents are users, not applications. Applications need credential values to authenticate. Agents just need to make authenticated calls. Those are different things.
AgentSecrets sits between the agent and the upstream API. The agent says "use STRIPE_KEY". The proxy resolves the real value from the OS keychain, injects it into the request at the transport layer, and returns only the response. The key never enters agent memory.
Technical details:
-Local HTTP proxy on localhost:8765 with session token (blocks rogue processes on same machine)
-OS keychain backed — macOS Keychain, Linux Secret Service, Windows Credential Manager
-6 injection styles: bearer, basic, custom header, query param, JSON body, form field
-SSRF protection blocking private IPs and non-HTTPS targets
-Redirect stripping — auth headers not forwarded on redirects
-JSONL audit log — key names only, no value field in the struct, structurally impossible to log values
-MCP server for Claude Desktop and Cursor
-Native OpenClaw skill
-Global storage mode config — set keychain-only once during init, applies everywhere
Honest limitations: if a malicious skill has independent network access outside AgentSecrets it can still make its own calls. This removes credentials as an attack surface specifically, not every attack surface.
For the specific attack that just hit 30,000 OpenClaw users — a malicious skill exfiltrating plaintext credentials — it is structurally prevented. The keys were never on the filesystem.
MIT, open source.

value: Show HN: AgentSecrets – Zero-Knowledge Credential Proxy for AI Agents

author: steppacodes


value: funnycoding

value: Show HN: Nano banana 2 is coming to nanabanana2.run

author: funnycoding


value: kaliades

value:
If your Valkey or Redis instance runs in a private network  whether self-managed on EC2, in a Docker Compose stack, or on a managed service  getting monitoring data out is annoying. VPC peering, bastion hosts, or running your own Prometheus + redis_exporter + Grafana stack. None of it is hard, but none of it is fun either.
We just launched BetterDB Cloud with an agent that runs inside your network as a lightweight container. It connects outbound to our platform over WSS - no inbound ports, no VPC peering, no firewall changes. Drop it next to your database and it starts collecting.
What the agent captures that's different from existing tools:
Slowlog and COMMANDLOG persistence. Valkey's slowlog holds 128 entries by default. Once the buffer fills, old entries are gone. The agent captures every entry before it rotates and persists it. When your p99 spikes at 3am, the evidence is still there at 9am. COMMANDLOG (Valkey 8.1+) tracks large requests/replies - that 50MB MSET killing your network is now visible.
Client attribution. Not just "something was slow" but "app-server-03 sent 80% of the HGETALL user:* queries that caused the slowdown." Connects slow queries to specific clients.
Pattern analysis. Instead of scrolling raw slowlog, you see aggregated patterns: "HGETALL user:* accounts for 80% of slow queries, avg 12ms, mostly from 2 clients."
Per-slot metrics for clusters. If you're running clustered Valkey, per-slot key counts and memory distribution for spotting hot slots.
99 Prometheus metrics. If you already have Grafana, just point it at our /prometheus/metrics endpoint. Get Valkey-specific data that redis_exporter doesn't expose.
Important caveat on managed services: The agent works everywhere, but the value varies. On self-managed instances and standard ElastiCache, you get the full picture - slowlog, client lists, ACL logs, config monitoring. On fully managed services like ElastiCache Serverless that restrict admin commands (SLOWLOG, CLIENT LIST, ACL LOG), the agent is limited to what INFO provides. We surface core metrics (memory, CPU, connections, ops/sec, replication) but the historical persistence features that make BetterDB unique won't be available. The dashboard shows you exactly which features are available vs restricted for your instance.
Self-hosted: https://github.com/BetterDB-inc/monitor
Cloud: https://betterdb.com
Docs: https://docs.betterdb.com
Everything is free during beta - no credit card. Happy to answer architecture questions, take feature requests, or talk about the Valkey ecosystem.

value: Show HN: BetterDB Cloud – monitor Valkey/Redis in VPCs with a lightweight agent

author: kaliades


value: spicypoke

value:
Hi, I'm building a task orchestrator library with the ability to specify dependencies between task and with an ability to pass return value into the next task.
So something like following is possible:
1. Task1 executes its operation and returns 5
2. Task2 depends on Task1 and retrieve the value returned by Task1, that is 5.
3. Task2 executes its operation and uses the value from Task1.
The tasks also type safe, so there's no need for runtime type casting.
I'm looking for feedback and ideas, I was thinking to add branching and loop, but I would love to hear your thoughts.
You can find it here: https://github.com/spicyPoke/TaskWeave

value: Show HN: I'm building TaskWeave, a typesafe task orchestrator

author: spicypoke


value: Show HN: Gonzales – Self-hosted internet speed monitor with Home Assistant


value: taeshdas

value: Show HN: I built a minimal distributed tracer from scratch to understand better

author: taeshdas


value: aayush-mishraaa

value:
Hi HN,
I've been building Ryvos for the past few months — an open-source autonomous AI
assistant written in Rust. It's the thing I wished existed: always-on, multi-channel,
and actually secure.
The core idea: every tool call passes through a SecurityGate — 5 tiers of
classification, 9 dangerous pattern regexes (rm -rf, DROP TABLE, curl|bash, etc.),
Docker sandboxing, and human-in-the-loop approval for anything risky. Skills run in
Lua/Rhai sandboxes, not raw system code. We've all seen what happens when AI assistants
run community code without any vetting.
What it does:
- Talk to it on Telegram, Discord, Slack, web dashboard, or terminal
- 50 built-in tools (shell, file I/O, web search, grep, edit, browser...)
- 16 LLM providers (Anthropic, OpenAI, Ollama, Groq, Gemini, Azure, Cohere, Mistral...)
- MCP-native (stdio + SSE/Streamable HTTP)
- Drop-in skills in Lua/Rhai with sandboxed execution
- Ships as a single ~20MB static binary
- 15-30MB RAM idle
Quick install:
  curl -fsSL https://raw.githubusercontent.com/Ryvos/ryvos/main/install.s... | sh
I'm a solo founder, built the entire 10-crate Rust workspace myself. Would love
feedback — especially from people who've tried running personal AI assistants and
hit security or performance walls.
GitHub: https://github.com/Ryvos/ryvos
Website: https://ryvos.dev

value: Show HN: Ryvos – Autonomous AI assistant in Rust(15MB RAM,50 tools,16 providers)

author: aayush-mishraaa


value: mrxlimitless

value:
an open-source, community-vetted repository of real-world problems that AI could solve but nobody's building yet.
Each idea goes through a process:
Someone identifies a real inefficiency — something that could be 10x or 90% better with AI
The community researches market size, existing solutions, technical feasibility, and potential impact
Domain experts vote, critique, and refine
Ideas that survive get a viability score and a detailed blueprint — ready for someone to pick up and build
Everything is MIT licensed. The goal is simple: give builders a head start on problems that actually matter.
Looking for: domain experts who can vet ideas, engineers who want to pick one and build it, and anyone who's spotted a real-world problem that AI could solve but nobody's tackling.

value: Show HN: NotBuiltYet– Open-source library of civilisation problems worth solving

author: mrxlimitless


value: mikflex

value:
I built CIFER, a distributed encryption + access-control system designed so that no component ever holds a complete decryption key at rest.
Core idea: each “secret” (per user or per dataset) has its own independent post-quantum keypair. There is no master key.
Architecture summary:
Control plane: verifiable ownership, delegation, revocation, and append-only audit records (tamper-evident authorization history)
Custody plane: 5 custody nodes running in TEEs, each storing 1 key fragment
Orchestration: validates authorization then collects fragments to reconstruct keys only when needed
Key custody model:
Private key is generated in a TEE then immediately split via Shamir secret sharing into 5 fragments
Fragments are distributed to independent custody nodes
Original private key is destroyed
Threshold is 3-of-5 for reconstruction
Each custody node independently verifies authorization against the control plane before releasing its fragment
Clusters are disabled if membership changes (node exits disable the cluster)
Encryption scheme (hybrid PQ + symmetric):
Fetch ML-KEM-768 public key from content-addressed storage, verify integrity
ML-KEM-768 encapsulation per message/file/chunk to derive a fresh shared secret
Derive one-time AES key + IV via HKDF-SHA256
Encrypt payload with AES-256-GCM
Output includes a fixed-size envelope: ML-KEM ciphertext (1088 bytes) + GCM tag (16 bytes)
Decryption flow:
Requester signs a decryption request
Orchestrator checks owner/delegate status + freshness window (replay defense)
Orchestrator requests fragments in parallel, accepts the first 3 valid fragments
Reconstructs the private key and decrypts
Audit logs record the operation
Reconstructed keys may be cached in memory for 36 hours (availability vs exposure tradeoff)
Design goal: reduce blast radius from insider threats and single-node compromise, and address long-term confidentiality via post-quantum KEM.
I would love feedback on:
TEE trust assumptions and practical hardening for custody nodes
Whether 36h key caching is acceptable, and safer alternatives
Control plane failure modes (partition, reorg) and best practices for “deny by default” behavior
Metadata strategy for large-file workflows (I currently keep filename/size in plaintext metadata)
Better approaches for custody node independence and anti-collusion guarantees

value: Show HN: Cifer, zero-key custody using threshold cryptography

author: mikflex


value: alcazar

value:
Hey HN, We've decided to open-source our Portable Secret. It's a free tool that generates self-contained HTML files which decrypt locally in your browser.
Check it out at https://alcazarsec.github.io/portable-secret/.
Source code: https://github.com/alcazarsec/portable-secret
The project is inspired by an old post (https://news.ycombinator.com/item?id=34083366) by mprimi, who coined the term "Portable Secret." I really liked the idea and wanted to improve the security of the KDF and the UX. I hope he's honored that so many people have iterated on it over the years.
Let me know what you think. I love reading all feedback (good or bad). I'll be monitoring the thread to reply to comments.
Thank you!

value: Show HN: Portable Secret – Open-Source HTML files that self-decrypt offline

author: alcazar


value:
I built Axon, an open-source Kubernetes controller that turns AI coding agent runs into a declarative API. I can define my development workflow in YAML so that Axon handles the rest — isolation, credentials, git workspace, agent plugins, output capture.
I use it to develop Axon itself. I run a team of specialized agents on my cluster, each with a different job:
Workers — Watch for GitHub issues, pick them up, investigate, write code, open PRs, self-review, and iterate until CI passes. If an agent gets stuck, it pauses and asks for my feedback. I respond on the issue, and it picks back up.
Fake User — Runs daily. Pretends to be a new developer trying Axon for the first time. Reads the README, tries CLI commands, reviews error messages. When it finds rough edges, it files issues. This catches things I’d never notice as the author.
Strategist — Runs twice a day. Thinks about new use cases, integrations, and API improvements. Reads the codebase, checks recent activity, and proposes ideas as issues. Some of the best feature ideas in Axon’s backlog came from this agent.
Triage — Classifies new issues by type, checks if they’re already fixed, detects duplicates, and posts a triage report.
The whole setup is YAML files you can kubectl apply on your own cluster.
Repo:    https://github.com/axon-core/axon
Self-development pipeline:    https://github.com/axon-core/axon/tree/main/self-development
It’s not magic though. The workers produce mediocre PRs sometimes and I still do the final review before merging. The fake user occasionally files issues that make no sense. The strategist sometimes suggests things that already exist. But even with the noise, it improves itself pretty well.

value: Show HN: I run a team of AI agents on my Kubernetes cluster


value: aryaminus

value:
Hi HN, at (from @) is a weekend project seeding from Armin Ronacher’s post: https://lucumr.pocoo.org/2026/2/9/a-language-for-agents/
I feel we are hitting the limits of existing languages that heavily rely on IDE support for context, which makes it difficult for agents reason independently. at is an experiment toward that future:
- Explicit effects: needs/using to make dependencies visible and easily mockable by agents, , enabling built-in capability sandboxing.
- Zero hidden magic: No barrel files, explicit imports, and results over exceptions (encouraging minimal diffs).
- Fast: Sub-millisecond cold start and ships with WASM bindings.
MCP is dead? maybe? But not tool-use, so at comes with a working MCP server to expose tools directly to agents. I’d love your feedback, particularly on the skill/tool side of things: https://github.com/aryaminus/at/blob/main/skill.md
at definitely has its limitations, and maybe it’s because the ideator is an outsider who’s not built languages before. The plan is simple, humans remain at the idea/planning side, while agents handle the shipping.
Right now, I'm focusing on building out benchmarks and finding the constraints. KISS is the mantra!
Happy to answer any questions. Leaving you with: https://simonwillison.net/2026/Jan/19/nanolang/#atom-everyth...
Additional tags: Context without LSP, Minimal diffs, Local reasoning, No macros, Capability Sandboxing

value: Show HN: At – an agent-first explicit and greppable programming language

author: aryaminus


value: timothyjoh

value:
I kept doing the same thing manually: write a spec, have Claude implement it, review the code, fix issues, reflect, commit, repeat — resetting the context window by hand at each step. So I automated the loop.
cc-pipeline takes a BRIEF.md describing what you want built and orchestrates Claude Code through the whole SDLC: spec → research → plan → build → review → fix → reflect → commit. Phase by phase, overnight, while you sleep. Each step gets a fresh context window via the Claude Agent SDK (I tried tmux + send-keys first — do not recommend).
I've run it on a dozen projects: an Elixir port of an existing open-source gateway, a Trello-style kanban board twice (Astro and Rails), a statistical analysis in R (I've never written R), Tetris twice from the same brief, and a Kirby platformer attempt (that failed).
Full write-up of the experiments here: https://curiousagents.substack.com/p/experiments-in-building...
Quick start:
```
cd your-project
npx cc-pipeline@latest init
```
Then open Claude Code and ask it to help you write the BRIEF.md. Then `npx cc-pipeline run` and walk away.
The steps are defined in .pipeline/workflow.yaml — you can add, remove, or reorder them. The prompts are plain markdown. Easy to tune to your own SDLC.
Would love feedback on the approach, especially from anyone who's tried similar things.

value: Show HN: Cc-pipeline – Autonomous Claude Code pipeline that builds your project

author: timothyjoh


value: mikebiglan

value:
Mike, cofounder of DevSwarm here.
I’ve been using Claude Code heavily for the last few months (multiple Max plans). Running sessions in parallel across git branches or worktrees is fast, but it breaks down quickly in practice because of sprawl. Terminals everywhere, editor windows everywhere, and you lose track of basics like which agent is on which branch and what is ready for review.
DevSwarm is what we built to solve that.
The core abstraction is simple: workspace equals branch. Each workspace runs its agent session(s) and keeps the state visible. In 2.0 we added a full VS Code IDE embedded in each workspace, so editing, terminals, diffs, and git controls stay in one window while you jump between parallel branches.
I’d love blunt feedback from people doing parallel workflows:

  • What breaks first for you past 2 parallel sessions?

  • What would you need for this to be production-grade? Tests, debugging, extensions, PR flow?

Video: https://www.youtube.com/watch?v=MqRkSRee6HE
Download: https://devswarm.ai/download

value: Show HN: DevSwarm 2.0, fix parallel Claude Code sprawl

author: mikebiglan


value:
Use open-weight models on your own GPU or combine with proprietary to max out reasoning quality while staying compliant!
Three 8–20B open-weight models on a $7K machine have matched frontier model reasoning on AIME 2025. Here's the orchestrator that makes it work.
Today we're publishing the core orchestration engine behind our paper benchmark results. The NSED repository is live at github.com/peeramid-labs/nsed — source-available under BSL 1.1, free for organizations under $1M revenue, research, and education.
This post explains what NSED does, why it matters for teams that rely on AI for high-stakes reasoning, and how to run it today.

value: Show HN: NSED 0.3 Release. Steer Multi-Agent AI Swarm for Frontier Performance


value: lchoquel

value: Show HN: Mthds – Beyond skills: a typed DSL for executable AI methods

author: lchoquel


value: Show HN: Open Graph Tag Checker

title: Show HN: Open Graph Tag Checker


value: eigen-vector

value: Show HN: Talkatui – WWE style live commentary for your AI coding sessions

author: eigen-vector


value: congzhangzh

value:
I got tired of grepping YAML files to remember tag names and copy-pasting
hostnames into --limit every time I ran a playbook. AWX/Semaphore solve this
but require a database and a daemon. So I built a single-file TUI instead.
Demo：https://raw.githubusercontent.com/congzhangzh/ansible-tui/re...
It parses your inventory.yml and playbook.yml, gives you a split-pane
selector for hosts and tasks, builds the ansible-playbook command live as
you toggle checkboxes, then runs it with streaming output — all inside the
terminal.
The binary is ~100MB (Deno runtime embedded), but there's also a one-liner
for Deno users that needs nothing local:

  deno run --allow-read --allow-run --allow-write --allow-env \
    https://raw.githubusercontent.com/congzhangzh/ansible-tui/main/app.tsx

Single file (~650 lines of TSX), MIT licensed.
https://github.com/congzhangzh/ansible-tui

value: Show HN: Ansible TUI – a zero-dependency terminal UI for running playbooks

author: congzhangzh


value: ncruces

value:
I've spent the past couple of weeks building a Wasm-to-Go translator.
It supports a subset of Wasm useful enough to translate SQLite into 600k LoC (~20 MiB) of Go code. It already passes all of my Go SQLite driver's tests across the 20 platforms I support.
Performance compared to https://wazero.io/ is a bit of a mixed bag: code that frequently crosses the Go-Wasm boundary improves, but code that spends most of its time in "Wasm land" doesn't.
There's probably room for improvement (I'd love to hear your ideas), but this is also a testament to how good the wazero AOT compiler actually is.
You can get a feel for the generated code by looking into https://github.com/ncruces/wasm2go/tree/main/testdata
I should eventually spend some time ensuring the translator passes the spectest, though I suspect that'll be far less fun than building the translator itself was.

value: Show HN: A Wasm to Go Translator

author: ncruces

title: Show HN: A Wasm to Go Translator


value:
Hi HN,
In January 2026, 1,200 malicious skills infiltrated the OpenClaw agent marketplace
(ClawHavoc campaign). A month later, researchers catalogued 6,487 malicious agent
tools that VirusTotal cannot detect. The first agent-software RCE was assigned
CVE-2026-25253.
The response: a dozen heuristic scanning tools (pattern matching, LLM-as-judge,
YARA rules). They all carry the same caveat: "no findings does not mean no risk."
SkillFortify takes a different approach. Instead of checking for known bad patterns,
it formally verifies what a skill CAN do against what it CLAIMS to do. Five
mathematical theorems guarantee soundness -- if SkillFortify says a skill is safe,
it provably cannot exceed its declared capabilities.
What it does:
- skillfortify scan .          -- discover and analyze all skills in a project
- skillfortify verify skill.md -- formally verify against capability declaration
- skillfortify lock            -- generate skill-lock.json for reproducible configs
- skillfortify trust skill.md  -- compute trust score (provenance + behavior)
- skillfortify sbom            -- CycloneDX 1.6 Agent Skill Bill of Materials
Supports Claude Code skills, MCP servers, and OpenClaw manifests.
Evaluated on 540 skills (270 malicious, 270 benign): F1=96.95%, zero false positives.
Paper: [ZENODO_DOI_URL]
Install: pip install skillfortify
Code: https://github.com/varun369/skillfortify
Built as part of the AgentAssert research suite. Happy to answer
questions about the formal model, threat landscape, or benchmark methodology.

value: Show HN: SkillFortify, a formal verification for AI agent skills


value: serendip-ml

value: Show HN: SAIA – SCUMM for AI Agents

author: serendip-ml

title: Show HN: SAIA – SCUMM for AI Agents


value: antimaterial

value:
Built this because I had heard some horror stories about companies leaking PII from high compliance environments to ChatGPT. I wanted something that would auto-filter any dangerous traffic between my AI agent and the LLM API without requiring code changes in the agent itself.
The filtering list has expanded a bit to include PII, secret keys and I've started a prompt injection library thats being filtered on as well.
The problem: self-hosted agent platforms (OpenClaw, Agent Zero, CrewAI) have no runtime content layer. If your agent leaks an API key, gets prompt injected, or decides to forward someone's SSN to GPT-4, nothing stops it. The platforms don't try to stop it either.
OnGarde is a proxy. You change one line in your config (swap baseUrl) and every request gets scanned before it leaves. Catches credentials, PII, prompt injection, dangerous shell commands. If the scanner fails, it blocks it; never silently passes through.
npx @ongarde/openclaw init handles the OpenClaw setup automatically. Also on PyPI if you're doing something custom.
Dashboard is localhost-only with a SQLite audit log. Nothing phones home.
v1 just shipped: https://github.com/AntimatterEnterprises/ongarde/releases/ta...
I am looking for feedback on this project. Let me hear your thoughts.

value: Show HN: OnGarde – Runtime content security proxy for self-hosted AI agents

author: antimaterial


value: Show HN: Ask a graph database questions in plain English (runs in the browser)


value: dmitryv

value:
Hi HN,
We're the engineering team at Peakflo (B2B fintech). We built 20x internally because we kept copy-pasting Linear tickets into Claude, manually setting up branches, and babysitting agent output across terminals. Eventually we just built the infrastructure to connect task systems to agents directly — and decided to open source it.
20x is an open-source desktop app (macOS only — Linux and Windows on the roadmap) that orchestrates AI coding agents against your existing task systems.
In practice: a Linear ticket gets pulled in → the triage agent assigns Claude Code + relevant skills → a git worktree is created for branch isolation → the agent writes code with live-streamed output → it pauses for your approval before pushing → a PR is opened.
We started with engineering tasks because current agents perform best there.
The most interesting architectural piece: Self-improving Skills. Skills are reusable instruction templates attached to task types. After each task completes, the agent proposes updates based on what worked. Over time, skills accumulate institutional knowledge, like a runbook that writes itself. Each carries a confidence score that tracks reliability over time.
This is the main differentiator versus hosted tools like Devin or Factory. Unlike those tools, 20x is local-first, open-source, and agent-agnostic — it orchestrates your existing agents rather than replacing them.
A few architectural decisions:
- Local-first: SQLite, no accounts, no cloud sync, everything on-device
- Agent-agnostic: supports Claude Code, OpenCode, and Codex
- Integrations: Linear, HubSpot, Peakflo, and GitHub Issues (Peakflo is listed because we dogfood it internally —  it was our first integration and how we catch regressions.)
- Git worktrees per task for branch isolation
- Skill updates are written back after task completion
MIT licensed.
GitHub: https://github.com/peakflo/20x
Demo: https://youtu.be/3zKmMz6aFek
Happy to answer questions about the architecture, tradeoffs, or what didn't work.

value: Show HN: 20x – Open-source agent orchestrator for Linear/HubSpot tasks

author: dmitryv


value: Show HN: A minimal Claude Code clone written in Rust


value: danielkdewar

value:
Relay is an SMS API I built because integrating Twilio for a simple verification flow took me an unreasonable amount of time. The API is a single POST endpoint. You sign up, get an API key, and send a real SMS in under 2 minutes.
Tech stack: Express.js API, AWS End User Messaging for delivery, PostgreSQL (Supabase), Redis rate limiting. SDKs for JS/TS, Python, and Go.
Currently US/Canada only. Starting at $19/mo with 1,500 messages included. We handle 10DLC compliance and carrier registration.
One thing that might interest HN: AI agents can create accounts and start sending via POST /v1/accounts/autonomous. No human verification required. Trust levels auto-upgrade based on delivery quality.
Also released sms-dev as a free local dev tool (npm install -g @relay-works/sms-dev) for testing SMS flows without sending real messages.
Docs: docs.relay.works | Site: relay.works

value: Show HN: Relay – SMS API for developers (send your first text in 2 min)

author: danielkdewar


value:
Claude Code is becoming central to how teams write software, but session data is ephemeral and costs are opaque. So I built Confabulous — a
 self-hosted platform that captures, archives, and analyzes every session across your team.
Your sessions contain real code and architecture decisions — they never leave your network. Multiplayer with GitHub/Google/OIDC auth.
What you get (so far):
→   archive with full-text search
 →   per-session and aggregate, by model, with trend charts
 →   — tool usage, files modified, agent invocations, Claude utilization %
 → -  with actionable improvement suggestions
 →   with automatic secret redaction
 →   — sessions auto-link to PRs and commits
Example from Christmas time: https://lnkd.in/guVb5Nx2
Things are moving fast — new features rolling out regularly.
Open source: https://lnkd.in/gi5eqxh8
Or try it at https://confabulous.dev

  Generated with Claude Code

value: Show HN: I built an open-source analytics platform for Claude Code sessions


value: felixche

value:
I’ve spent the last few months thinking about why personal AI feels like a leash rather than a tool. Current "agents" are just thin wrappers over centralized LLMs that harvest your data to sell it back to you. You still have to do the work and make decisions whenever a tool proposes a solution. More pressure on you.
I’m building Ego-Kernel (EK-1). It’s an attempt to build a "Unitary Intelligence" - a single, local-first agent that manages your digital life, financial trades on Solana, and social reputation without your data ever leaving your enclave.
The Tech Stack:
The Brain (Go): A high-concurrency orchestrator running locally. It handles "Titan Handshakes" (P2P agent negotiations) and indexes your local life-data.
The Court (Rust/Anchor): An on-chain Reputation Ledger on Solana that makes "Social Honor" unforgeable and programmable.
The Shield (BUSL 1.1): I’m using the Business Source License to prevent the "Big Tech Vampirism" we saw in '24-'25. It’s free for individuals, but enterprises pay their share.
Why this is different:
Most AI projects are trying to be the next big chatbot. I’m trying to build a protocol for cognitive independence. The system uses a "Value-Weighting Matrix" that you tune locally. If your stress (biometrics) is high or your bank balance is low, your agent's aggression threshold shifts automatically.
The Manifesto explains the "Soul Drift" problem and how we're solving it through graduated autonomy.
GitHub: https://github.com/EgoKernel/The-Protocol
Manifesto: https://github.com/EgoKernel/The-Protocol/blob/main/Manifest...
Would love to hear your thoughts on the local-first approach and the staking-for-reputation model.

value: Show HN: EK-1 – A local-first, sovereign AI agent built in Go and Rust

author: felixche


value:
Hi HN,
I'm George Ciobanu (https://www.linkedin.com/in/georgeciobanunyc). I built pandō ('CAD for code') because I got tired of watching AI agents burn tokens, take forever, and still get it wrong.
Here's (one reason) why this happens: AI agents read and edit code as if it's just text. But code is more, much more: it has structure, syntax, relationships, and meaning.
Code is Data
We built pandō around this insight.
It indexes and persists your code's AST in a database, which gives AI agents instant search results, and enforces syntactically correct edits. Here's a full list of benefits that this different approach brings:
1. Correct Syntax - compiler-checked and gated edits (unless you force breakage)
2. Always Safe - auto snapshots after every change, so no matter what the agent does, 'Undo' is just a click away
3. 10-100x Faster - text-based tools must 1. read context around every match they find (match number scales with codebase size), 2. send that context to the LLM, 3. wait for inference, and finally 4. wait for the LLM to finish streaming the response. In contrast, pandō edits directly on your computer, in seconds.
4. Token Savings - >100× "token compression" for some operations (e.g. rename costs the same ~40 tokens whether the symbol has one or a thousand references).
5. Reduced Exposure - pandō operations send as much or less code to the LLM provider as text tools in order to achieve a goal; some operations send no code at all to the LLM — just the intent of the transform.
Every edit is atomic, hash-verified, compiler-checked, and backed up by a snapshot.
Download and install the Visual Studio Code extension (keep VSCode with the extension installed open) or download it from the marketplace(https://marketplace.visualstudio.com/items?itemName=humansof...), then connect from any MCP-compatible agent.
Supported: Typescript, Javascript, Python, C/C++, C#.
Coming soon: Java, Rust, Go, Clojure, R, Perl, Swift, Kotlin.
https://getpando.ai
feedback: george [at] human [dot] software

value: Show HN: Claude/Gemini/Codex 10-100x faster with pandō (CAD for code)


value: atefataya

value:
Hey HN,
If you use AI coding tools, you've hit this: you start a new chat, ask Claude or Cursor to refactor something, and it hallucinates an import. Or renames a function but misses 3 call sites. Or suggests moving a file with no idea what depends on it.
The problem is simple — AI tools have no map of your codebase. Every new chat starts from zero. They burn tokens scanning files they already saw, guess at dependencies, and give you confident answers based on incomplete context. Lost context = wasted tokens + broken code + time spent fixing what AI was supposed to fix.
I built Depwire to solve this. It parses your codebase with tree-sitter, builds a complete dependency graph, and serves it to AI tools via MCP (Model Context Protocol). The graph persists across sessions — your AI never forgets the architecture.
Now when I ask "what breaks if I rename Router?", I get the exact blast radius: 5 implementing classes, 2 core framework files, 14 downstream consumers, ~25 files total. Not a guess — a deterministic answer from the actual dependency graph.
What it does:
- Parses TypeScript, JavaScript, Python, and Go (tree-sitter, deterministic)
- 10 MCP tools: impact analysis, dependency tracing, architecture summaries, symbol search, and more
- Interactive arc diagram visualization in the browser
- File watcher keeps the graph current as you edit
- Zero config: npm install -g depwire-cli. No databases, no cloud, no Docker
- Everything local. No data leaves your machine.
- Full repository context, not just single file.
Tested on real projects — Hono (305 files, 5,636 symbols, 2.3s), Excalidraw (320 files), FastAPI, Express, Cobra. Zero parse errors.
Install: npm install -g depwire-cli
GitHub: https://github.com/depwire/depwire
Site: https://depwire.dev
Solo founder, scratching my own itch. BSL 1.1 (converts to Apache 2.0 in 2029). Happy to answer questions.

value: Show HN: Depwire – Dependency graph and MCP tools so AI stops refactoring blind

author: atefataya


value: DanyWin

value: Show HN: Duck Talk – Real-time voice interface to talk to your Claude Code

author: DanyWin


value: jackculpan

value: Show HN: I made a directory for Claude skills

author: jackculpan


value: sferadev

value:
PostgreSQL connections from distant regions are expensive. A new connection from Tokyo to a database in us-east-1 costs 400-800ms before the first query runs: TCP handshake, TLS (2 RTTs), PG startup and auth.
- PgBouncer pools connections but doesn't cache and runs in a single region.
- Hyperdrive does both but only works from Cloudflare Workers.
- Prisma Accelerate requires the Prisma ORM.
PgBeam is a PostgreSQL proxy that speaks the wire protocol natively. You only change one environment variable:
Before: postgresql://user:pass@prod.c7k2dfh4jk3l.us-east-1.rds.amazonaws.com:5432/postgres
After:  postgresql://user:pass@02ljaccjaffjy8xvsw1xq6fdra.gw.pgbeam.app:5432/postgres
Three things happen:
1. Routing: GeoDNS points to the nearest proxy (6 regions today)
2. Connection pooling: Warm upstream connections, no TLS/auth cost per query
3. Query caching: SELECTs cached at the edge with stale-while-revalidate. Writes, transactions, and volatile functions like NOW() or RANDOM() are never cached.
Live benchmark at https://pgbeam.com/benchmark with real TLS PostgreSQL connections from 20 global regions, comparing direct vs. PgBeam (cached and uncached). No synthetic data.
This is a technical preview meant for design partners and early customers via a private beta before scaling the infrastructure. Feedback is welcomed!

value: Show HN: PgBeam – A globally distributed PostgreSQL proxy

author: sferadev


value: novatrope

value: Learn AI for web development. Risk Free. Cost limited

value: Show HN: I built a managed Claude AI and hosting service

author: novatrope


value:
Hi HN,
I’m building browser-based WebGL terrain editor powered by a custom Three.js engine. It’s a real-time 3D scene, not a static render.
What’s new since the last iteration:
Authoring mode UI integrated into the left navigation (clean tool separation, no ad-hoc overlays)
Camera Mode vs Explore Mode (orbit/zoom author camera with a clear mode switch)
Visual modes for authoring (production parity vs simplified white “workspace” mode)
Live demo: https://playzafiro.com/isle-lab/
Short context: I’m doing this solo. The long-term goal is a lightweight world-building tool that can evolve into a broader editor/workflow.
I’d love feedback on:
- usability (does the navigation/tooling feel intuitive?)
- performance on your machine
- what feature would make this immediately useful for you (even as a prototype)
Thanks!

value: Show HN: Browser-based WebGL terrain editor with authoring mode and camera


value: suchanekj

value: I like to print, but I'm no artist. So I though of turning the full pipeline of my text -> concept images -> 3D mesh -> postprocess for the specific 3D printing workflow -> order it online into a nice UI. You can obv. also just download the STL and print it yourself!

value: Show HN: Conjure – 3D printed objects from text description only

author: suchanekj


value: I’ve tried agent teams, subagents, multi-terminal setups, and several open-source orchestration frameworks. This Claude Code skill (~500 lines of Markdown, no framework, no dependencies) has outperformed all of them for my team’s daily workflow.<p>It turns your session into a dispatcher that fans work out to background workers across any model (Claude, GPT, Gemini, Codex). Workers ask clarifying questions mid-task via filesystem IPC instead of silently failing. Meanwhile, your main session stays lean and focused on orchestration.

value: Show HN: The best agent orchestrator is a 500-line Markdown file


value: flamestro

value: deff is an interactive Rust TUI for reviewing git diffs side-by-side with syntax highlighting and added/deleted line tinting. It supports keyboard/mouse navigation, vim-style motions, in-diff search (/, n, N), per-file reviewed toggles, and both upstream-based and explicit --base/--head comparisons. It can also include uncommitted + untracked files (--include-uncommitted) so you can review your working tree before committing.<p>Would love to get some feedback

value: Show HN: Deff – Side-by-side Git diff review in your terminal

author: flamestro


value: cylinderthought

value: Show HN: Deadhand – trustless Bitcoin inheritance in 2 minutes

author: cylinderthought


value: vienneraphael

value:
batchling is a Python gateway to provider-native GenAI Batch APIs, so your existing calls can run at batch-priced rates instead of standard realtime pricing.
As an AI developer myself, I discovered Batch APIs when tingling with AI benchmarking: I wanted to save 50% because I was ok with a 24h-SLA.
What I discovered was a hard engineering reality:
- No standards: each batch API has a different flow and batch lifecycles are never the same.
- Framework shift: as a developer, switching from sync/async execution to deferred (submit, poll, download) feels off and requires to build custom code and store files.
That's when I noticed that no open-source project gave a solution to that problem, so I built it myself.
Batch APIs are nothing new, but they lack awareness and adoption.
The problem has never been the Batch API itself but its integration and developer experience.
batchling is bridging that gap, giving everyone a developer-first experience of Batch APIs and unlock scale and cost-savings for compatible requests.
batchling usage was designed to be as seamless as possible: just wrap existing async code into an async context manager (the only lib entrypoint) to automatically batch requests.
Users can even push that further and use the CLI to wrap a whole function, without adding a single line of code.
Under the hood, batchling:
- intercepts requests in the scope of the context manager
- repurposes them to batch format
- manages the whole batch lifecycle (submit, poll, download)
- hands back requests when they are processed such that the script can continue its execution seamlessly.
batchling v0.1.0a1 comes batteries-included with:
- Large batch providers support (Anthropic, Doubleword, Gemini, Groq, Mistral, OpenAI, Together, XAI)
- Extensive AI Frameworks integration (Instructor, Langchain LiteLLM, Pydantic AI, Pydantic Evals..)
- Request caching: avoid recomputing requests for which you already own a batch containing its response.
- Python SDK (2 lines of code to change) and Typer CLI (no code change required)
- Rich documentation stuffed with examples, get started and run your first batch in minutes.
I believe this is a game changer in terms of adoption and accessibility for any AI org, research lab or individual that burns tokens through API.
I'd love to get feedback from AI developers and new ideas by exchanging with the technical community.
The library is open to contributions, whether they be issues, docs fixes or PR.
Repo: https://github.com/vienneraphael/batchling
Docs: https://batchling.pages.dev

value: Show HN: Batchling – save 50% off any GenAI requests in two lines of code

author: vienneraphael


value: userware

value:
Hi HN, I'm Giovanni, founder of Userware. We built XAML.io, a free browser-based IDE for C# and XAML that compiles and runs .NET projects entirely client-side via WebAssembly. No server-side build step.
The link above opens a sample project using Newtonsoft.Json. Click Run to compile and execute it in your browser. You can edit the code, add NuGet packages, and share your project via a URL.
What's new in v0.6:
- NuGet package support (any library compatible with Blazor WebAssembly)
- Code sharing via URL with GitHub-like forking and attribution
- XAML autocompletion, AI error fixing, split editor views
The visual designer is the differentiator: 100+ drag-and-drop controls for building UIs. But the NuGet and sharing features work even if you ignore the designer entirely and just write C# code.
XAML.io is currently in tech preview. It's built on OpenSilver (https://opensilver.net), a from-scratch reimplementation of the WPF API (subset) using modern .NET, WebAssembly, and the browser DOM. It's open-source and has been in development for over 12 years (started as CSHTML5 in 2013, rebranded to OpenSilver in 2020).
Limitations: one project per solution, no C# IntelliSense yet (coming soon), no debugger yet, WPF compatibility improvements underway, desktop browsers recommended.
Full details and screenshots: https://blog.xaml.io/post/xaml-io-v0-6
Happy to answer questions about the architecture, WebAssembly compilation pipeline, or anything else.

value: Show HN: Browser-based .NET IDE with visual designer, NuGet packages, code share

author: userware


value:
A little while ago I built a tool to calculate how far you've traveled through space since the exact second you were born. The math was relatively simple (Earth's spin + Solar orbit + Galactic drift), but the feedback I got here inspired me to rewrite the visual engine and turn it into a proper deep-space dashboard.
Here is what’s new under the hood:
1. Vanilla JS 3D Engine: I built a custom Three.js simulation that renders your exact orbital alignment on your birth date and tracks it to the present.
2. Live Telemetry: It now actively tracks the real-time Keplerian orbital positions of Voyager 1, Voyager 2, and Pluto, plus the ISS orbiting the Earth at its true 51.6-degree inclination.
3. Cosmic Milestones: I added a "Party Predictor" to calculate the exact date you will cross 1 Light Year or 1 Trillion miles of total travel distance, plus a multiplayer tool to compare flight paths with friends.
4. 100% Local / Privacy First: All the date/time math and tracking is computed strictly client-side. Nothing is sent to a server.
I’m currently running this entirely on the client side to keep it lightning-fast. I’d love to hear your thoughts on the frontend performance, the Keplerian math, or any edge cases I might have missed in the 3D rendering.

value: Show HN: A Vanilla JavaScript 3D engine v2 to track lifetime space travel


value:
I've been struggling with my own to-do lists for years. Apps like Todoist or Habitica are great for reminders, but they never quite push me over the edge when motivation dips. So I built Focido: a social to-do app where you hire actual humans as motivators.
Here's how it works. You post a task – say, "Run 5km tomorrow" or "Finish that report by Friday" – and pick a motivator from the marketplace. They check in via chat, nudge you with encouragement (or gentle guilt), and you confirm completion for XP points. It's built on Flutter for iOS/Android, with Supabase backend for real-time chats.
You can see a 1 minute demo here: https://youtube.com/shorts/b7KidYEvsUg?si=9FyDz8NDfppfH1Fw
We've got clubs for niches like fitness or coding sprints, where groups keep each other accountable. Early users stick around longer because humans tap into reciprocity and social pressure better than AI bots – that's from some Gen Z studies I read.
Try it: https://focido.com/download/
(quick sign-up with Google/Apple, no barriers to post a test task).
Feedback welcome, especially on retention loops or marketplace balance.

value: Show HN: Focido – mobile app where real people motivate you to finish tasks


value: Pinkert

value:
Hi HN,
I'm building Librarian (https://uselibrarian.dev/), an open-source (MIT) context management tool that stops AI agents from burning tokens by blindly re-reading their entire conversation history on every turn.
The Problem:
If you're building agentic loops in frameworks like LangGraph or OpenClaw, you hit two walls fast:
Financial Cost: Token usage scales quadratically over long conversations. Passing the whole history every time gets incredibly expensive.
Context Rot: As the context window fills up, the LLM suffers from the "Lost in the Middle" effect. Response latency spikes, and reasoning accuracy drops.
The standard workaround is vector search (RAG) over past messages, but that completely loses temporal logic and conversational dependencies.
How Librarian Fixes This:
We replaced brute-force context windowing with a lightweight reasoning pipeline:
Index: After a message, a smaller model asynchronously creates a compressed summary (~100 tokens), building an index of the conversation.
Select: When a new prompt arrives, Librarian reads the summary index and reasons about which specific historical messages are actually relevant to the current turn.
Hydrate: It fetches only those selected messages and passes them to the responder.
The Results:
Instead of passing 2,000+ tokens of noise, you pass a highly curated context of ~800 tokens. In our 50-turn benchmarks, this reduces token costs by up to 85% while actually increasing answer accuracy (82% vs 78% for brute-force) because the distracting noise is removed. It currently works as a drop-in integration for LangGraph and OpenClaw.
I'd love for you to check out the benchmark suite, try the integrations, and tear the methodology apart. I'll be hanging out in the comments to answer questions, debug, or hear why this approach is terrible. Thanks!

value: Show HN: Librarian – Cut token costs by up to 85% for LangGraph and OpenClaw

author: Pinkert


value: ynnickw

value:
AppLaunchFlow uses AI to turn your app screenshots into fully editable App Store creatives.
You upload screenshots → it extracts text, UI structure, and layout → converts everything into modular blocks inside a Figma-style editor.
You can:
- Edit copy across all screenshots instantly
- Re-theme layouts in seconds
- Regenerate designs with AI
- Create promo videos from the same assets
- Export ready-to-upload App Store creatives
Built for indie devs and small teams shipping frequent updates.
Since launch (Jan 5):
- 700+ users
- 60+ paying customers
Looking for honest feedback:
- Is AI-based screenshot extraction actually useful?
- What would make this 10x better?
Happy to answer any technical questions.

value: Show HN: AppLaunchFlow: Create App Store screenshots in minutes

author: ynnickw


value:
Most security approaches I see in production environments focus on:
Scanning for CVEs
Hardening configurations
Aggregating logs
All useful — but they don’t actually stop exploitation once it starts.
In reality:
Not every CVE gets patched immediately
Legacy systems stick around
Zero-days happen
When exploitation succeeds, the real damage usually comes from runtime behavior:
A process spawning a shell
Unexpected outbound connections
Secret access
Container escape attempts
I’ve been experimenting with a lightweight runtime enforcement layer for Linux that focuses purely on detecting and stopping high-risk behavior in real time — regardless of whether the underlying CVE is known or patched.
Would love input from folks running Linux/Kubernetes at scale:
Is runtime prevention something you rely on?
Where do existing tools fall short?
What would make this genuinely useful vs just more noise?
Live Demo: https://sentrilite.com/Sentrilite_Active_Response_Demo.mp4
Github: https://github.com/sentrilite/sentrilite-agent

value: Show HN: Protection Against Zero-Day Cyber Attacks


value: SurceBeats

value: Show HN: I built a local AI-powered Ouija board with a fine-tuned 3B model

author: SurceBeats


value: kidustiliksew

value:
KARTA is a command center where hiring teams zoom into any city, filter by skills + timezone + 'actually available' and shortlist candidates who fit.
For hiring teams: Map-native search (like a tactical dashboard), high-signal filters that actually matter, request intros in one click.
For talent: Set-it-and-forget-it profiles, stealth mode, and Boost tiers to go Local, Regional, or Global.

value: Show HN: Karta – Google Search, for discovering talent

author: kidustiliksew