value: hparadiz

value: Also demonstrates SDP video signaling for automatic switchover to 1080 and output to v4l2loopback

value: Show HN: Google Home Camera to KDE Plasma Overlay Live Stream via WebRTC Demo

author: hparadiz


value: Show HN: LLM Observability Stack for Local Dev – Agent Super Apy


value: Show HN: Tinder, but for Food

title: Show HN: Tinder, but for Food


value:
I go to a lot of tech events and conferences. The pattern is always the same: have a great conversation, swap some details verbally, promise to follow up… and then lose half of it by the time I sit down.
I tried everything scanning badges (when they exist), typing notes into my phone mid-conversation (awkward), taking photos of business cards (who carries those anymore). Nothing stuck.
So I built Payo. It's a PWA no app store, just open it on your phone.
The core flow: tap record, say what you remember about someone for 10 seconds, and Payo extracts a structured contact (name, company, email, phone) automatically. The whole thing is designed around one principle: if you're not getting value within 5 seconds of stopping the recording, you're not getting value.
How it works under the hood:
Deepgram Nova-3 streams transcription in real-time via WebSocket (sub-300ms, words appear as you speak)
If you're offline (because conference WiFi is always terrible), it falls back to local Whisper running in a Web Worker via WASM so it never freezes the UI
Rule-based cleanup runs instantly (<50ms) to strip filler words and extract emails/phones from spoken text ("john at gmail dot com" → john@gmail.com)
An optional cloud tier does LLM-powered cleanup if connectivity allows (3-second hard timeout, so it never blocks you)
The key insight: at events, you have maybe 30 seconds between conversations. You need something faster than opening the Contacts app and typing. A 10-second voice note that auto-parses into a contact card is that thing.
Stack: React + Vite + Supabase + Deepgram Nova-3 + Whisper WASM. It's a PWA with offline support, so it works even in airplane mode (Whisper handles transcription locally).
I've been using it at events for a few months and it's changed how I network I actually follow up now because I have the context of why I wanted to connect, not just a name.
Would love feedback from anyone who goes to conferences regularly. What's your current system for capturing contacts?

value: Show HN: Payo – I got tired of losing contacts at conferences, so I built


value: TaxFix

value:
I've been building AI agent tooling and kept running into the same problem: agents browse the web, take actions, fill out forms, scrape data -- and there's zero proof of what actually happened. Screenshots can be faked. Logs can be edited. If something goes wrong, you're left pointing fingers at a black box.
So I built Conduit. It's a headless browser (Playwright under the hood) that records every action into a SHA-256 hash chain and signs the result with Ed25519. Each action gets hashed with the previous hash, forming a tamper-evident chain. At the end of a session, you get a "proof bundle" -- a JSON file containing the full action log, the hash chain, the signature, and the public key. Anyone can independently verify the bundle without trusting the party that produced it.
The main use cases I'm targeting:
- *AI agent auditing* -- You hand an agent a browser. Later you need to prove what it did. Conduit gives you cryptographic receipts.
- *Compliance automation* -- SOC 2, GDPR data subject access workflows, anything where you need evidence that a process ran correctly.
- *Web scraping provenance* -- Prove that the data you collected actually came from where you say it did, at the time you say it did.
- *Litigation support* -- Capture web content with a verifiable chain of custody.
It also ships as an MCP (Model Context Protocol) server, so Claude, GPT, and other LLM-based agents can use the browser natively through tool calls. The agent gets browse, click, fill, screenshot, and the proof bundle builds itself in the background.
Free, MIT-licensed, pure Python. No accounts, no API keys, no telemetry.
GitHub: https://github.com/bkauto3/Conduit
Install: `pip install conduit-browser`
Would love feedback on the proof bundle format and the MCP integration. Happy to answer questions about the cryptographic design.

value: Show HN:Conduit–Headless browser with SHA-256 hash chain - Ed25519 audit trails

author: TaxFix


value: schipperai

value:
We needed something like --dangerously-skip-permissions that doesn’t nuke your untracked files, exfiltrate your keys, or install malware.
Claude Code's permission system is allow-or-deny per tool, but that doesn’t really scale. Deleting some files is fine sometimes. And git checkout is sometimes not fine. Even when you curate permissions, 200 IQ Opus can find a way around it. Maintaining a deny list is a fool's errand.
nah is a PreToolUse hook that classifies every tool call by what it actually does, using a deterministic classifier that runs in milliseconds. It maps commands to action types like filesystem_read, package_run, db_write, git_history_rewrite, and applies policies: allow, context (depends on the target), ask, or block.
Not everything can be classified, so you can optionally escalate ambiguous stuff to an LLM, but that’s not required. Anything unresolved you can approve, and configure the taxonomy so you don’t get asked again.
It works out of the box with sane defaults, no config needed. But you can customize it fully if you want to.
No dependencies, stdlib Python, MIT.
pip install nah && nah install
https://github.com/manuelschipper/nah

value: Show HN: A context-aware permission guard for Claude Code

author: schipperai


value: austinbaggio

value:
autoresearch@home is a collaborative research collective where AI agents share GPU resources to collectively improve a language model. Think SETI@home, but for model training.
How it works: Agents read the current best result, propose a hypothesis, modify train.py, run the experiment on your GPU, and publish results back. When an agent beats the current best validation loss, that becomes the new baseline for every other agent. Agents learn from great runs and failures, since we're using Ensue as the collective memory layer.
This project extends Karpathy's autoresearch by adding the missing coordination layer so agents can actually build on each other's work.
To participate, you need an agent and a GPU. The agent handles everything: cloning the repo, connecting to the collective, picking experiments, running them, publishing results, and asking you to verify you're a real person via email.
Send this prompt to your agent to get started: Read https://github.com/mutable-state-inc/autoresearch-at-home follow the instructions join autoresearch and start contributing.
This whole experiment is to prove that agents work better when they can build off other agents. The timeline is live, so you can watch experiments land in real time.

value: Show HN: Autoresearch@home

author: austinbaggio

title: Show HN: Autoresearch@home


value: vipinkashyap

value:
I've been a fan of Derek Sivers' /now movement (nownownow.com) for a while. The idea is simple — a page that says what you're focused on right now, not a static bio. Hundreds of people have one, but making one still means setting up hosting and writing HTML yourself. That's a weird amount of friction for something that should take 60 seconds.
So I built NowPages. You pick a handle, fill out a short form, choose a theme, and hit publish. Your page is live instantly at nowpages.github.io/your-handle. No accounts — you get an edit token to update it later.
A few things I think are interesting technically:
Generated pages are zero JavaScript, pure HTML and CSS. They load fast everywhere.
The whole stack is Cloudflare Workers + GitHub Pages free tiers. No database, no server costs.
Every page ships with JSON-LD, Open Graph, and Twitter Card metadata, plus a dynamically generated social preview image (separate Cloudflare Worker).
There are 5 themes with hand-picked typography pairings (JetBrains Mono, Source Serif, IBM Plex, Inter, etc).
The edit flow uses a token instead of accounts because I wanted zero friction and zero stored personal data. You publish, save your token, and that's it.
The whole thing is MIT-licensed and self-hostable if you want to run your own instance.

value: Show HN: NowPages – Free "now page" generator, no sign-up, pure HTML output

author: vipinkashyap


value: babush

value: Show HN: Nonna – code slop detector that runs in the browser

author: babush


value: deviscold

value:
Hi all, I'm sharing Jupycheck, an open source web tool that detects accessibility issues in Jupyter Notebooks that are either uploaded or from a GitHub repository. It also lets you remediate accessibility issues by launching the notebooks in a JupyterLite environment with our interactive Lab extension installed.
The tool is powered by jupyterlab-a11y-checker, an accessibility engine/extension that our student team has been working on for over a year at UC Berkeley. We believe accessibility should be a first-class concern in the notebook ecosystem, and we hope our tools can help raise awareness and make notebooks more accessible across the community.
Support us on GitHub if you find the tool useful!

value: Show HN: Gitingest for Jupyter Notebook Accessibility

author: deviscold


value:
I built this because Claude Code loads every rule and skill into context on every prompt. With 50+ rules and skills installed, you're burning tokens on Docker best practices while writing a commit message.
ai-nexus runs a hook before Claude starts — it picks 2-3 relevant rules and skills via keyword matching (free) or GPT-4o-mini (~$0.50/mo), and physically hides the rest. Claude doesn't even know they exist.
An ETH Zurich study (https://arxiv.org/pdf/2602.11988) on 12 repos and 5,694 PRs found that loading all rules at once hurts performance by ~3% and increases cost by 20%+.
It also works across tools — write rules and skills in .md once, auto-converts to .mdc (Cursor) and AGENTS.md (Codex).
npx ai-nexus install to try it. Apache 2.0.

value: Show HN: AI-nexus – Only 2-3 rules and skills load per prompt in Claude Code


value: remywang

value: Show HN: s@: decentralized social networking over static sites

author: remywang


value: snwy

value: Show HN: I built an open harness that excels at autonomous ML research

author: snwy


value: zippolyon

value:
On March 4, 2026, my Claude Code agent wrote a staging URL into a
production config file — three times, 41 minutes apart. Syntax was
valid, no error thrown. My logs showed every action. All green.
The problem was invisible because nothing had recorded what the agent
intended to do before it acted — only what it actually did.
K9 Audit fixes this with a causal five-tuple per agent step:
- X_t: context (who acted, under what conditions)
- U_t: action (what was executed)
- Y*_t: intent contract (what it was supposed to do)
- Y_t+1: actual outcome
- R_t+1: deviation score (deterministic — no LLM, no tokens)
Records are SHA256 hash-chained. Tamper-evident. When something goes
wrong, `k9log trace --last` gives root cause in under a second.
Works with Claude Code (zero-config hook), LangChain, AutoGen, CrewAI,
or any Python agent via one decorator.
pip install k9audit-hook

value: Show HN: K9 Audit – Causal intent-execution audit trail for AI agents

author: zippolyon


value: True-Good-Craft

value:
I’ve been building BUS Core, a local-first manufacturing/workshop system aimed at small makers and shop-style operations.
Version 1.0.3 is out today.
This release focused on hardening and UI cleanup more than feature expansion. The goal is to make the software more trustworthy in day-to-day use, not just more featureful.
The general product thesis is that there’s a gap between spreadsheets and heavy SaaS/ERP for small operators who want control over their own data and workflows.
It’s local-first, practical, and intentionally boring in the parts that should be boring.
Happy to answer questions about:
architecture
local-first tradeoffs
workflow scope
how I’m handling the build/process side

value: Show HN: Bus Core 1.0.3 Local-first manufacturing system for small shops

author: True-Good-Craft


value: AyodeleFikayomi

value: Show HN: A tool that audits healthcare ML models for safety and trust

author: AyodeleFikayomi


value: jamesweb

value:
Built this because I had multiple OpenClaw instances running with no good way to manage them together. SwarmClaw is the control plane.
Connect to OpenClaw gateways and 14 other providers (Anthropic, OpenAI, Gemini, Groq, Ollama, DeepSeek, Mistral, xAI, Claude Code CLI, Codex CLI and more). Build agents with custom tools and personalities, run multi-agent LangGraph workflows, queue work on a Kanban board, and bridge agents to Discord, Slack, Telegram, WhatsApp, Signal, Teams and others.
Under the hood: per-agent FTS5 + vector memory, sandboxed Deno/Python execution, JS plugin hooks, and MCP server support per agent.
MIT licensed. One-line curl install, npm, or Docker. Happy to answer questions.

value: Show HN: SwarmClaw – Manage a swarm of OpenClaw agents from one self-hosted UI

author: jamesweb


value: shalinshah

value: Show HN: Hyper, AI voice notes for spontaneous conversations

author: shalinshah


value: nyoki

value: Show HN: A public RSS feed aggregator for the indie web

author: nyoki


value:
I live in a rural farming neighborhood in Japan.
Day-to-day Japanese is fine for me. But neighborhood meetings were a completely different level.
People speak fast. There's local dialect. Someone references a flood from 1987, a land boundary dispute from 1994, and three people I've never met but everyone else knows. I would walk out feeling like I understood maybe 5% of what happened.
So I built a tool for myself to help follow those conversations.
Live Kaiwa listens to Japanese speech and, in real time, shows:
* Japanese transcription
* English translation
* a running summary of what's being discussed
* suggested responses you can say back
The idea is to help you stay oriented in complex conversations.
You can try it here: https://livekaiwa.com
---
How it works
When you start a session, the browser microphone captures the conversation and streams audio.
The pipeline looks roughly like this:
1. Audio streaming - Browser microphone → WebRTC → server
2. Speech to text - Kotoba Whisper runs a fast first pass transcription.
3. Multi-pass correction - Buffered audio is re-transcribed with higher accuracy and replaces earlier text.
4. LLM processing - Each batch of transcript is sent to an LLM that generates: English translations, summary bullets, and suggested replies (with TTS)
5. Live UI updates - Everything streams back to the browser in (mostly) real time.
Session data stays in the browser, nothing is stored server-side.
Why I built it, in short: even if you speak Japanese reasonably well, fast, multi-person discussions can become overwhelming. Seeing the conversation transcribed and summarized helps.

value: Show HN: Live Kaiwa – real-time Japanese conversation support


value: FedeUY

value:
Hi HN,
I built an MCP server that exposes an API for automated clinical coding.
Repo:
https://github.com/fcggamou/autoicd-mcp
It allows AI assistants that support the Model Context Protocol (MCP) to convert clinical text into structured medical codes like ICD-10 and SNOMED-CT.
Example use cases:
• coding diagnoses from clinical notes
• extracting structured codes from medical documentation
• integrating medical coding into LLM workflows
• healthcare data pipelines
Example prompt with an MCP-enabled assistant:
“Convert this clinical note into ICD-10 codes”
The server then calls the AutoICD API and returns structured codes.
The goal is to make it easy to plug medical coding into AI agents and tools.
Would love feedback from anyone working on healthcare AI, medical NLP, or MCP tooling.

value: Show HN: MCP server for ICD-10 and SNOMED clinical coding

author: FedeUY


value:
Hi HN,
I built AutoICD, an AI-powered clinical coding platform that converts unstructured medical text into ICD-10 and SNOMED-CT codes. This is not an LLM wrapper. The platform uses a multi-layer machine learning architecture internally, combining custom-trained models with curated medical knowledge.
Platform and tooling:
- JS SDK – https://github.com/fcggamou/autoicd-js
- Python SDK – https://github.com/fcggamou/autoicd-python
- MCP Server – https://github.com/fcggamou/autoicd-mcp
Use cases and benefits:
- Automated ICD-10 and SNOMED coding from clinical notes
- Creation of structured datasets for research and analytics
- Integration with AI assistants via MCP
- Scalable pipelines optimized for real-world healthcare data
- Access to ICD-10 codes and metadata programmatically
Feedback from anyone working on medical AI, clinical NLP, or MCP tooling is welcome.

value: Show HN: AutoICD API – AI clinical coding platform for ICD-10 and SNOMED


value: konfuzio

value: Show HN: Agentic Static Site Generator – waitlist: info[at]wise-relations.com

author: konfuzio


value: fomoz

value:
Hi guys,
I made my Restailor project open source. You're welcome to use the code in case you're looking for a new job or just want to play around with an LLM integration for this purpose. You're also welcome to use my prompts.
It's working end-to-end and I built the infra to scale and support a lot of users using it (Next.js + FastAPI + Redis + Postgres). It also has applied job tracking and analytics.
LLM integrations are with Anthropic, Google, OpenAI, and xAI.
Please let me know if you have any questions.
Thanks!

value: Show HN: Restailor – open-source AI job fit/resume tailor/job tracker

author: fomoz


value: Show HN: An Open-source platform for building and orchestrating AI agents


value: hydralerne

value:
Hey HN,
If you’re building local AI agents (or using tools like Cursor/Claude Code), giving them a place to safely execute code and manipulate files is a headache. Running untrusted LLM-generated code directly on your machine or local Docker is risky, and managing remote SSH keys for an automated agent is clunky.
I built Oblien to solve this. It provides instant, hardware-isolated cloud VMs, but the actual interesting part is how you interact with them: the Runtime API.
Every workspace runs an internal HTTP/WebSocket server on port 9990. Instead of establishing an SSH connection, your local agent just makes standard API calls to control the remote machine securely.
It exposes everything an agent needs to do real work:
• Command Execution: Run POST /exec to execute bash commands. It supports synchronous runs, or you can stream stdout/stderr in real-time via SSE for long-running tasks.
• Files & Search: A full file API to list, read, and write files. It also has a native /search endpoint powered by ripgrep, so agents can find code without pulling the whole repo locally.
• WebSockets & Terminals: You can open interactive PTY sessions multiplexed over a single WebSocket connection. It even supports streaming filesystem events (create/write/delete) to watch directories.
How local agents connect securely:
The workspaces are network-dark by default—outbound internet is on, but inbound is completely blocked.
To let your local agent in, you hit the Oblien API to get a short-lived Gateway JWT. The agent uses this token as a Bearer auth header against workspace.oblien.com. Our gateway decodes the routing info from the JWT and securely tunnels the HTTP request through the firewall directly to the VM's internal server.
It makes orchestrating remote compute feel like using a standard web API.
For example, to run a command inside the remote VM, your agent just does this:
curl -X POST "https://workspace.oblien.com/exec" \
-H "Authorization: Bearer $GATEWAY_JWT" \
-d '{"cmd": ["npm", "install"]}'
Docs and API reference: https://oblien.com/docs
Would love to hear what you think of the API design, or if there are specific endpoints you'd want added for your own agent workflows.
also You can use it like Vercel—spin up a VM, add workload, expose a port, and attach a custom domain for instant preview URLs. But unlike serverless platforms, you aren't restricted. Because every workspace has an injected Runtime API (port 9990), you can programmatically execute commands, edit files, and multiplex terminals over WebSockets right from your local machine or CI pipeline. You get the hosting of a PaaS, but the low-level control of a raw Linux VM

value: Show HN: Cloud VMs with a Built-In REST API for AI Agents

author: hydralerne


value: Show HN: LockFS Is Now Stable

title: Show HN: LockFS Is Now Stable


value: kiru-cmdrunner

value:
I’m building CmdRunner, an AI agent that executes web application test cases directly from documents.
Most teams maintain Selenium or Playwright scripts, but many already have test steps written in Excel or documentation.
CmdRunner reads those steps and performs them in a browser like a human tester.
Workflow:
1. Upload test case file
2. Agent understands each step
3. Opens browser
4. Executes actions
5. Validates outcome
6. Generates report
Goal: reduce the time spent maintaining automation scripts.
If anyone is interested in trying it with real test cases, Register here:
https://cmdrunner.com

value: Show HN: CmdRunner – Upload test cases and an AI agent runs them in a browser

author: kiru-cmdrunner


value:
Instead of dumping raw price data into a prompt, I treated the LLM strictly as a "Qualitative Reasoner" (the Brain) and built deterministic scripts as the "Quantitative Executors" (the Hands).
The Math Layer (Zero Hallucination): Traditional Node.js/Python scripts pull market data and calculate deterministic indicators (SMA, ATR, RSI) and backtest historical win rates.
The Context Layer: It fetches live news, SEC filings summaries, and Wall Street ratings via Finnhub/Tavily.
The LLM Brain (DeepSeek-R1 / GPT-4o): The model is ONLY fed the computed results. It acts as an investment committee, weighing the technical setup against the macro news catalysts.
The Risk Controller: Even if the AI screams "BUY", the system passes the signal through a hard-coded Volatility Parity sizing model (using ATR) to calculate the exact safe position size.
Human-in-the-loop (Telegram): For execution, I integrated a Policy Engine. The bot sends a beautiful proposal card to my Telegram. It only executes via the Broker API (Longport/Alpaca) if I reply /approve.
The $1000 Experiment:
I am running this live right now. It's not about getting rich; it's an engineering experiment to see if multi-agent systems can actually maintain a positive Expected Value (+EV) in noisy markets without blowing up.
Currently, the system is [up 2% / down 1% / flat] in its first week. It successfully avoided a fake breakout yesterday because the Bear-Agent successfully debated the Bull-Agent on low volume.
Tech Stack: Node.js, TypeScript, SQLite, better-sqlite3, Longport SDK.
I’m open-sourcing the entire framework. It’s highly modular, so you can swap in your own indicators or prompt logic easily.
I would love for the HN community to roast my architecture, point out my blind spots in the backtesting logic, or just tell me how quickly I'm going to lose my $1000.

value: Show HN: An open-source AI Quant Agent trading live with my own $1000


value:
I built a small tool called ClawJetty. It gives an AI agent a public progress page for any task. It has worked wonders on OpenClaw, Claude Code, Codex.
The idea is simple: before starting work, the agent creates a run, returns a public link to the user, and then posts short progress updates as it works. The user can watch a live timeline instead of waiting in the dark for a long task to finish.
The product is intentionally minimal. There are no accounts, no setup flow, and no dashboard. The homepage just gives you a prompt to paste into your agent. The agent reads the instructions, creates a run, and starts updating it. The public page shows the title, status, timestamps, and event timeline.
The main use case is making agent workflows legible to users. If an agent is researching vendors, debugging a system, reviewing documents, or drafting something large, it can expose a live status page without building a whole product around “agent transparency.”
It was also useful to dogfood while building. I used the product itself to track debugging and deployment work on the app, which helped clarify what kinds of updates are actually useful versus noisy.
Would be interested in feedback on the product framing and whether this should stay extremely narrow or grow into something more general for agent task visibility.
https://clawjetty.com

value: Show HN: ClawJetty: See what your AI Agent is Doing


value: Ralz

value: What if hacker news was structured like an IRC client. Utilizes the Firebase API and has full keyboard navigation support.<p>Hope someone enjoys it, feedback welcome.

value: Show HN: HN-IRC – I rebuilt Hacker News as a retro IRC client

author: Ralz


value:
AI coding agents degrade as context fills up. By phase 6 of 8, output quality has quietly fallen apart. I kept restarting sessions by hand — copy-pasting my PRD and progress notes into a fresh context just to keep it on track. That's not an autonomous developer. That's babysitting.
Tarvos automates the handoff.
When context crosses 50%, it writes a progress note and spins up a fresh agent that picks up exactly where the last one left off. Each session gets its own isolated git worktree. When the work is done, accept merges to your branch, reject discards cleanly.
You write a markdown plan. Tarvos runs it to completion without you.
Open source, MIT. Works today, rough edges exist.

value: Show HN: Tarvos – fix context rot by chaining fresh Claude agents automatically


value: tredkar

value:
Team,
I started Hackerdogs back in Oct 2025 with the vision of delivering the right intelligence, at the right time, to the right people. When I was running larger Dev and Sec teams, I struggled to get real-time information on the company's overall security posture and its apps. I had to face customers during incidents with little to no data. Hackerdogs was born to solve this problem in an AI-native way so that people don't have to run around to get real-time threat and posture data.
With the success of Preview 1 (announced Feb 2nd), we made massive progress with Preview 2. Preview 1 was a Chat experience with 150+ MCP servers integrated and multi-agent workflow. The theme of Preview 2 is: One-Click Attack Surface Discovery: See your Organization the Way Hackers Do.
New features:
1) Scheduled prompts discover your attack surface and other posture information continuously
2) One-click Attack Surface Discovery
3) APIs and Hackerdogs MCP Server so you can use Hackerdogs in Claude or in your own pipeline
4) 200+ Security and OSINT MCP Servers integrated
5) Webhooks to Slack, Teams, Discord and Custom APIs
Would love feedback. Contributors welcome.
Try it: https://preview.hackerdogs.ai
Thanks,
Tej
Founder, CEO
https://hackerdogs.ai

value: Show HN: Hackerdogs Preview 2 Released

author: tredkar

title: Show HN: Hackerdogs Preview 2 Released


value: twwch

value:
I built a self-hostable pipeline that takes a screenplay (or a one-line idea) and produces a finished animated video —
   no coding required, no SaaS subscription.

  The pipeline:
  1. Write or AI-generate a script
  2. Extract characters → generate turnaround reference sheets (for visual consistency)
  3. Split the script into shots with camera direction and motion descriptions
  4. Generate keyframes (first + last frame per shot) with continuity chaining
  5. Interpolate each shot into a video clip
  6. Concat everything with FFmpeg, burn subtitles

  Each stage can be triggered individually or in batch, so you stay in control.

  Tech:
  - Next.js 16 App Router + SQLite (self-contained, zero infra)
  - Bring your own keys: OpenAI, Gemini, or Seedance for text/image/video
  - Docker one-liner: docker run -p 3000:3000 -v ./data:/app/data twwch/aicomicbuilder:latest
  - No accounts — browser fingerprint (SHA-256 of UA/screen/timezone) is the user identity, so multiple people can share
   one instance with full data isolation

  Why I built it: Existing video generation tools are either single-shot (one prompt → one clip) or fully opaque
  pipelines. I wanted something that exposed every step so I could iterate on prompts, swap models mid-project, and
  understand what's actually happening.

  The hardest part was the continuity chain — the last frame of shot N becomes the first frame of shot N+1, which keeps
  characters visually consistent across cuts without fine-tuning.

  GitHub: https://github.com/twwch/AIComicBuilder

  Demo video in the README. Would love feedback on the pipeline design and whether the fingerprint-as-auth tradeoff
  makes sense for this use case.

value: Show HN: AI Comic Builder – turn a script into an animated video local

author: twwch


value:
I spent ~4 hours building AIComicBuilder [1], a full-stack AI comic/drama generation platform,
  without writing a single line of code manually. This is a writeup of my "vibe coding" workflow
  using Claude Code.

  The app lets you: input a script → AI generates screenplay → character analysis → storyboard
  generation (with first/last frame images) → video generation. Supports OpenAI-compatible,
  Gemini, and Bytedance Seedance APIs for text/image/video models, configurable per-user via a
  settings UI.

  Tech: Next.js full-stack, SQLite, queue-based async processing.

  **The workflow:**
  1. Describe tech requirements in plain text → AI generates architecture doc → review/tweak in
     the terminal
  2. Reference the doc, load `superpowers:subagent-driven-development` → AI writes the plan,
     self-reviews it, then executes autonomously (~45 min)
  3. Auto-commits after each feature (critical safety net if AI breaks something)
  4. Bug? Screenshot + one sentence → AI fixes it
  5. Ugly UI? "redesign using ui-ux-pro-max" → 3 iterations → done

  The key insight from Karpathy's "vibe coding" concept: in this paradigm, *documentation quality
  matters more than coding ability*. The clearer your requirements, the better the output. Your
  role shifts from programmer to product manager.

  I'm documenting the full workflow and useful Claude Code skills here: [2]

  Curious if others have found good skill combinations for Claude Code, or are using similar
  approaches with other tools (Cursor, Aider, etc.).

  [1] https://github.com/twwch/AIComicBuilder
  [2] https://github.com/twwch/vibe-coding

value: Show HN: I built an AI comic generator from scratch using only natural language


value: jlandersen

value:
I made an app that allows you to view Kubernetes resources just like the unix system in Jurassic Park :)
Unlikely to be used for anything serious, but with the tools available today I couldn't let the idea slip. Just a bit of nostalgic vibe.

value: Show HN: Jurassic Park Unix System Kubernetes Viewer

author: jlandersen


value: cnaize

value: Show HN: Landlook – Interactive Landlock Profiler

author: cnaize


value:
Hi,
I just wanted to share Okapi with the community here. Its my stab at the observability problem - how to debug when something breaks in prod. Okapi focusses on two modalities of observability's big three (metrics, logs, traces). Okapi is all about metrics and traces. The idea here is that metrics and traces usually have the most signal and also that analyzing logs is so fragmented that one might just spend ages doing just logs stuff.
Features:
- Otel everywhere, its Okapi's preferred and only ingestion mechanism :) Currently Okapi supports ingestion via protobuf-over-HTTP. Here's a sample config (https://github.com/okapi-core/okapi?tab=readme-ov-file#examp...)
- Dashboards both via clicks and code: Okapi UI has a dashboard designer hopefully with autocomplete everywhere so users don't have to guess metric paths. However, if you're not a fan of clicks and/or love GitOps all Okapi dashboards can be expressed as YAML templates.
- Out-of-box Service health: For an application instrumented as per Otel conventions, Okapi has REDs as a first-class concept. Service health pages have RED breakdowns for the service, its sub-operations and dependent paths. The calculations are subject to applications being instrumented, but hopefully following a convention makes things easy.
- And of course AI : Okapi has a limited capability AI SRE agent affectionately called Oscar (supposed to be an okapi but no mascot yet). Calling it a full blown SRE is a stretch since its tough job. You can ask Oscar questions in natural language as you would any chatbot and it will try its best to answer. Atleast on integration tests, Oscar can fetch metrics, find traces given criteria and do a multiple step debugging that links query latencies with high CPU usage on hosts.
I am curious to hear feedback from the community so check it out.
TLDR: https://github.com/okapi-core/okapi?tab=readme-ov-file#quick...

value: Show HN: Okapi yet Another Observability Thing


value: booffa

value:
Meowth GBA Translator is an open-source, AI-powered tool that automates translation of Pokémon GBA ROMs (including binary hacks like FireRed, Emerald, Ruby/Sapphire, and Mystery Dungeon). Powered by LLMs (supports OpenAI, DeepSeek, Gemini, Claude, Groq, and 10+ others), it extracts text, translates intelligently while preserving codes and context, then rebuilds the ROM — all in one click via a friendly GUI or simple CLI command.
Supports 6+ languages (Chinese, English, French, German, Italian, Spanish) with optimized prompts and smart font patching. Focus on gameplay mods, let AI handle the words. Free, MIT-licensed, cross-platform.

value: Show HN: AI-powered one-click translator for Pokémon GBA ROM hacks

author: booffa


value: radoslaw-sz

value: I always struggle with the guarantee that my AI agent won't do anything that could break my system. An AI agent’s behavior is never 100% guaranteed — there is always a small chance that it might send tons of emails, accidentally delete a file, or cause other unintended side effects.<p>Guardio solves this issue. You put a proxy in front of all your AI agents and create policies that the agents cannot break. You can forbid sending certain parameters, rate-limit access, or simply break down your AI system into smaller parts so your agents only do exactly what you ask them to do.

value: Show HN: Guardio – control your AI Agent

author: radoslaw-sz


value: AliAbdoli

value:
Also launched on product hunt today: https://www.producthunt.com/products/x402r-refund-protocol?l...
Would appreciate feedback!

value: Show HN: Refund and Arbitration Protocol for Agents

author: AliAbdoli


value: hjbarraza

value:
Score any Wikipedia page for sensitivity, quality, and risk in seconds.
Wikimetron analyzes Wikipedia pages across multiple dimensions — editorial quality, content sensitivity, and informational risk — by pulling data directly from the Wikimedia API. It evaluates things like source density, edit frequency, controversy signals, and structural completeness to generate composite scores that would take a human reviewer hours to assess manually.
Built for researchers, journalists, and anyone who needs to know how much to trust a Wikipedia page before citing it.

value: Show HN: Wikimetron – Surface hidden sensitivity and risk in Wikipedia

author: hjbarraza


value: emamoah

value: I wanted something like Glasswire, but for Linux and free. I found only one project that did this, but it's been discontinued, so I decided to learn and build one myself. Still in progress.

value: Show HN: Bandmeter: Per-program network usage monitor for Linux, built with GPUI

author: emamoah


value: tgalal

value:
Instead of giving LLM tools SSH access or installing them on a server, the following command:

  $ promptctl ssh user@server

makes a set of locally defined prompts "magically" appear within the remote shell as executable command line programs.
For example, I have locally defined prompts for `llm-analyze-config` and `askai`. Then on (any) remote host I can:

  $ promptctl ssh user@host
  # Now on remote host
  $ llm-analyze-config /etc/nginx.conf
  $ cat docker-compose.yml | askai "add a load balancer"

the prompts behind `llm-analyze-config` and `askai` execute on my local computer (even though they're invoked remotely) via the llm of my choosing.
This way LLM tools are never granted SSH access to the server, and nothing needs to be installed to the server. In fact, the server does not even need outbound internet connections to be enabled.
Github: https://github.com/tgalal/promptcmd/

value: Show HN: Execute local LLM prompts in remote shells

author: tgalal


value: jirigalis

value: Show HN: Tasquery – No-login bridge from messy notes to Jira tickets

author: jirigalis


value: kinderasteroid

value:
Hi HN,
I'm building Qwodel, an open-source pipeline that automates the fragmented mess of LLM quantization.
If you've ever tried to prep a Hugging Face model for edge deployment or cheaper cloud inference, you know the drill: wrestling llm_compressor for AWQ, writing ctypes calls for llama.cpp for GGUF, or fighting memory leaks in coremltools for Apple Silicon.
Qwodel acts as a unified orchestration engine. Instead of context-switching between three different ecosystems, you pass the model, and we handle the memory chunking, edge-case graph conversions, and output production-ready formats (GGUF, AWQ, CoreML).
We are actively building and updating the package every week to add new model architectures and backend optimizations. You can check out the full reference guide here: docs.qwodel.com.
The project is entirely open-source. We would love for you to test it out, tear the architecture apart, and let us know where it breaks. We are wide open to pull requests, so feel free to raise bugs or contribute directly in the repo!

value: Show HN: Qwodel – An open-source unified pipeline for LLM quantization

author: kinderasteroid


value:
Hi HN,
We built *ForgeCode*, a coding agent that integrates directly into *Zsh*.
After installing the plugin you can talk to it from your shell using `:` commands.
Example:
```
: add caching to this GraphQL resolver
```
Because it runs inside Zsh, your *aliases, plugins, and shell workflows keep working*.
Forge also appears *multiple times near the top of the Terminal-Bench 2.0 leaderboard* depending on the model configuration.
https://www.tbench.ai/leaderboard/terminal-bench/2.0
Project:
website: https://forgecode.dev
Repo: https://github.com/antinomyhq/forge
Curious if others have tried putting AI directly into the shell instead of using another CLI tool.

value: Show HN: Talk to a coding agent directly inside Zsh


value: tinkeringtechie

value:
I built Chronoscope, a project to explore the world through time.
I've been wanting to do this for a while, after being inspired by Ollie Bye's "History of the World" video several years ago.
I'm not the first person to have done this - resources like OpenHistoricalMaps are amazing.
But, I noticed there were a few disparate datasets / academic databases online, so I combined them together as best as I could (I've linked all sources in the app). To make it more interesting, I also included:
- Notable events from the time period (geolocated where possible), sourced from wikidata
- Ancient cities + their original names
- Empire hierarchies for colonial empires like the British Empire
You can jump across time and use shuffle to explore some fascinating corners of history.
Would love any feedback, especially from people who like maps, timelines, and weird historical rabbit holes. Also please report any data issues if you find them (it's all using publicly collated data, so there will be plenty).
Happy to publish code / data on GH if there's interest!

value: Show HN: I built Chronoscope, because Google Maps won't let you visit 3400 BCE

author: tinkeringtechie


value: bgleb

value: AI is everywhere now, but we're mostly stuck with chat interfaces. It feels like a massive limitation to me personally and I've been exploring new ways to interact with computers. I've found myself reinventing the wheel from the '80s. The ability to tinker with live, running apps is super exciting to me, so I took a stab at building a web prototype.<p>To get started, you just need Claude Code configured (vmExit uses the Claude Agent SDK). You start with a blank canvas and build out tiny components piece by piece, organically evolving your own environment.

value: Show HN: VmExit – an experiment in AI-native computing

author: bgleb


value: beasubs

value: Show HN: MeepaChat – Slack for AI Agents (iOS, macOS, Web / Cloud, Self-Hosted)

author: beasubs


value: this-is-shreya

value: Show HN: I built a screen recorder with automatic zoom effects

author: this-is-shreya


value: Show HN: Detect when an LLM silently changes behavior for the same prompt


value: softcane

value:
I built SpotVortex for a simple reason: most teams want more Spot savings, but they do not want to compromise service safety to get them.
SpotVortex runs inside the cluster and controls Spot at the node-pool level. It watches market risk and pool health, then decides when a pool should grow, spot, hold, freeze, or move back toward On-Demand.
A few concrete details about the shipped runtime:
* The deterministic mode is the active path
* The control cadence is 10 minutes
* Decisions stay at the node-pool level, not the pod level
* Workload data stays in-cluster.
The controller also looks at pool blast radius, not just price. It tracks things like:
* PDB Slack under node loss
* How much critical workload is sitting on the Spot restart and recovery time
* Stateful workload mix
* zone spread
* evictability
* available On-Demand headroom
* Current AWS support is explicit. The shipped model scope covers 60 instance families across:
compute: c5, c6, c7
general purpose: m5, m6, m7
memory optimized: r5, r6, r7
burstable: t2, t3, t4g
Happy to answer hard questions.

value: Show HN: SpotVortex helps SRE teams push more Kubernetes capacity onto Spot

author: softcane


value: pkstn

value: Show HN: Elevators.ltd

author: pkstn

title: Show HN: Elevators.ltd


value:
Hi HN,
I've been working on an open-source simulation lab called CAELIX and wanted to share it here. It's a discrete lattice field framework for testing whether continuum-like signatures can emerge and be routed using strictly local update rules on a balanced-ternary substrate {-1, 0, +1}.
There are 11 real-time animations running directly off the simulation code on the website. (I locked these specific visualisations to 2D so they actually run smoothly in the browser on phones and modest hardware).
The architecture enforces a strict separation. The discrete balanced-ternary microstates act as a topological boundary generator which couples via a deterministic load functional into continuous carrier dynamics. The numerics are often FDTD-like, using diffuse and telegraph surrogate equations, but the framework as a whole is much broader than a conventional solver.
A bit of background: I'm not a physicist. My expertise is in computing systems, databases and audio engineering. I go all the way back to writing Z80 machine code and making ZX Spectrum games as a kid. CAELIX actually started out as a machine learning experiment in adaptive noise cancellation before evolving into this.
I'm not making any grand metaphysical claims either. The 1/r vacuum profile it generates isn't claimed as novel. It's just the expected asymptotic behaviour of the 3D discrete Laplacian and I use it as a regression-safe baseline.
The part I think this crowd might find interesting is the topological fan-out. The field dynamics can route stable non-linear solitons (specifically generative Sine-Gordon kink walls) through geometric logic gates like a T-junction. The computation lives purely in the passive waveguide topology rather than active switching states. There is also a module hunting for stable oscillons but the gates themselves use the kink walls. I've mapped the failure modes extensively to separate genuine kinematic-dilation proxies from stencil dispersion and discrete mode-locking artefacts.
Repo: https://github.com/caelixuk/caelix (I've included pre-extracted .h5 sprite assets so you can run the collision and routing experiments immediately without needing to run the extraction sweeps first).
White paper: https://doi.org/10.5281/zenodo.18823977
I'd be really interested to hear if anyone working on unconventional compute, cellular automata or lattice field solvers has seen similar passive routing behaviour in other discrete substrates. Happy to answer any questions on the numerics or the routing grids.

value: Show HN: Caelix, a balanced-ternary lattice field laboratory


value: silverr

value:
I built this because I got tired of tabbing away during F1 practice sessions to check live timing. The idea was simple: keep race stats accessible in the menu bar without eating screen real estate.
What it does:
Live driver positions & session timing
Real-time telemetry (speeds, gaps, tire info)
PitStop F1 API integration
Zero full-window footprint
Current status:
Live on the Mac App Store. It works, but I'm actively iterating. The biggest challenge so far has been getting reliable real-time data without hammering the API. I'm caching aggressively and considering WebSocket fallbacks.
What I'm stuck on:
Performance with rapid session updates
Whether the feature set justifies the menu bar UX or if users expect more
Data accuracy during race weekends (some API endpoints are inconsistent)
Shipping small indie projects is harder than I thought, mostly in the "people actually knowing it exists" department. Any feedback on the concept, execution, or what's obviously missing would be genuinely helpful.
Open to suggestions.

value: Show HN: Pitwall – Live F1 Stats in Your macOS Menu Bar

author: silverr


value: powerwild

value:
Hi HN!
I built MicroMoment App, an Apple Watch app designed for 30–90 second micro-resets during the day.
The idea came from noticing how hard it is to maintain focus and good posture while working at a computer for long periods. Instead of long breaks or complicated routines, MicroMoment lets you do tiny actions that reset your mind and body without interrupting your workflow.
With one tap on your watch, it starts a short micro-action like:
a quick stretch
mindful breathing
posture correction
a small energy boost exercise
Everything is designed to be fast, glanceable, and doable in under 2 minutes.
Key features:
- Instant Reset Button – tap once to start a random micro-action
- Timer + haptic guidance – subtle vibrations guide you through the exercise
- Daily streaks – track consistency
- Personalized suggestions based on your usage
- Surprise mode with occasional fun mini-actions
- Challenges & achievements to keep things interesting
- Watch face complication showing your next micro-moment or streak
The goal is simple: help people feel better throughout the workday with minimal friction.
I’d love feedback from the HN community — especially on:
- whether micro-actions like this are actually useful
- features you'd want in a watch-first productivity/wellbeing app
- ideas for new micro-actions
Happy to answer any questions!

value: Show HN: MicroMoment Apple Watch micro-resets for focus, posture, and wellbeing

author: powerwild


value: upflag

value: Show HN: Upflag – Plain-English error alerts for apps built with AI coding tools

author: upflag


value: Show HN: AgentBridge – Let AI agents control Classic Mac OS thru a shared folder


value: bastadanii

value:
We built CodeYam Memory because Claude Code kept making the same mistakes on our codebase. Our claude.md files quickly got stale and maintaining by hand or with Claude wasn’t sufficient.
While digging into this we found that Claude has a native rules system that allowed us to target specific parts of our repo with path matching.
CodeYam Memory uses a background agent to review your coding session transcripts, identifies confusion patterns, and generates targeted rules with proper scoping.
Install: npm install -g @codeyam/codeyam-cli@latest
Then from your project root run: codeyam
This will launch a dashboard with further instructions for initializing CodeYam Memory.
90 sec demo on our own repo:
https://youtu.be/oJ2gTb-lxbE
https://codeyam.com/

value: Show HN: We got tired of managing Claude.md files, so we built something better

author: bastadanii


value:
Gruezi HN,
We built SympLog (Android & iOS), an offline-first health tracker with a fully encrypted DB. When users asked for home-screen widgets, we hit a problem: how do you let a widget write data without exposing the encrypted database?
Prototype demo: https://files.catbox.moe/8egcnt.mp4
App info: https://www.symplog.com
The problem: Fast logging matters for symptom tracking — too many taps and people stop. But our DB is fully encrypted, so letting a widget read it directly would weaken the security model.
The solution: An encrypted queue architecture. The widget never touches the main DB. It writes events (just event_id, catalogUid, rating, timestamp) to an encrypted queue using EncryptedSharedPreferences + Android Keystore. When the user opens and unlocks the app, it imports and clears the queue.
Threat model: Shoulder surfing (someone sees your screen), phone seizure while locked, and ADB/cloud backup extraction. Users can set aliases (e.g. "Anxiety" → "A5y") to obscure what's displayed. The widget must be explicitly enabled after a privacy warning, and its config is fully encrypted.
UX: Undo window before commit, checkmark on success, disabled-state with deep link to configure, dark/light mode.
Still iterating on: Import idempotency (crash during import). Also evaluating alternatives to ESP — direct Keystore+Cipher with one file per event, or encrypted Jetpack DataStore.
I'd love feedback on this architecture, or how others have handled secure data ingestion from "leaky" UI surfaces like OS widgets.

value: Show HN: Encrypted queue architecture for zero-trust home screen widgets


value: hbasria

value:
Built ollamon, an htop-style terminal monitor for Ollama nodes. It shows installed and running models, CPU/RAM/disk usage, GPU metrics, access-log-based latency/request telemetry, and lightweight operational insights in a terminal UI. macOS GPU data is sourced from agputop, and the goal is to make local LLM infrastructure easier to observe without adding heavy dependencies.
https://github.com/hbasria/ollamon

value: Show HN: Ollamon, an htop-style terminal monitor for Ollama nodes

author: hbasria


value: nahime

value: Show HN: Lazyagent – One terminal UI for all your coding agents

author: nahime


value: Fr-e-d

value: Show HN: GAAI – One agent plans, one codes. A Markdown folder governs both

author: Fr-e-d


value: kachar

value:
Hi HN,
I built Prompt Area — a contentEditable rich text input component for React, designed specifically for AI chat interfaces.
The problem: if you're building an AI chat UI, your input needs @mentions (to reference context), /commands (to trigger actions), #tags, inline markdown, file attachments, and undo/redo. Existing options are either too limited (react-mentions only does mentions) or massive overkill (Tiptap, Lexical, and Plate are full document editors built on ProseMirror/Slate — way too heavy for a prompt input).
Prompt Area sits in the middle. It uses a segment-based model (array of {type, text} objects) on top of contentEditable, with all logic extracted into a pure engine file that's testable without a DOM. Zero dependencies beyond React and your existing Tailwind/shadcn setup.
Features: trigger-based chips (@, /, # or any character), immutable chip pills, live inline markdown preview, auto-growing textarea, full undo/redo history, copy/paste with chip preservation, IME support for CJK input, ARIA accessibility, dark mode, and file/image attachments.
Install in one command:
`npx shadcn@latest add <a href="https://prompt-area.com/r/prompt-area.json" rel="nofollow">https://prompt-area.com/r/prompt-area.json</a>`
Demo & docs: https://prompt-area.com
GitHub: https://github.com/team-gpt/prompt-area
Would love feedback from anyone building AI/LLM interfaces.

value: Show HN: Prompt Area – Rich text input for AI chat UIs (Shadcn, zero deps)

author: kachar


value: tugaypala

value:
ImagineIf is a platform where users collaboratively write stories, one 280-character segment at a time, and AI generates a visual for each contribution automatically.
Each story starts with an "Imagine if..." prompt. Anyone can continue a chain — the AI produces an image for every new segment using FLUX-dev (Replicate as primary, fal.ai as fallback). Stories can branch based on contributor choices.
Tech stack: React Native/Expo (web PWA + iOS + Android), FastAPI backend, MariaDB, Celery+Redis for async image gen, Groq/Llama for moderation and translation, FLUX-dev for visuals.
What's live today:
Web: https://imagineif.app
iOS: https://apps.apple.com/app/imagineif-story-chains/id67597222...
Android in closed testing
22 language support with automatic translation pipeline
The hardest part technically was building a reliable dual-provider image pipeline that degrades gracefully without blocking the user's contribution flow — a failed image generation shouldn't interrupt the writing experience.
Happy to answer questions about the architecture or the solo-founder experience.

value: Show HN: ImagineIf – Collaborative storytelling with AI visuals (22 languages)

author: tugaypala


value: makepostai

value:
GlobCall started as a Skype alternative — browser-based international calling, open a tab and call anywhere. I use it myself to run my business in Europe.
The more businesses used it for support, sales, collections and onboarding, the more one thing became obvious: the phone call isn't the problem. The human availability around it is.
---
The "Human-Phone" interface is beautiful:
Voice closes deals chat can't. A real human voice carries weight across cultures and languages that no message, notification or email ever will. It's still the highest-trust communication channel on earth.
But the world is moving fast. Someone has to be awake. Someone has to speak the language. Someone has to be available at 2am when a customer in another timezone picks up the phone.
The medium is extraordinary. Human availability is just finite.
---
The "Agent-Phone" interface is where the world is heading:
AI voice agents that place and receive real international phone calls. A local number in Brazil following up on invoices. An AI that speaks Romanian handling inbound calls overnight. An outbound agent qualifying leads in the UAE while your team sleeps. Or simply telling your AI agent "book me a haircut" and it calls the barber and handles it.
This is the next era of business communication. The infrastructure exists. The accessible, affordable calling layer built for this is what we're building at GlobCall.
---
The agentic layer is in private testing. International calling, local phone numbers in any country, browser and API access are all live today. Flat usage pricing, top up and go.
Happy to talk about the stack, the agent architecture, or anything in between.
can be found at → globcall.com

value: Show HN: GlobCall – Agentic AI voice agents that make real international calls

author: makepostai


value: The idea came from noticing when reading tech news / comments and thinking "someone should build that".<p>So I wanted to automate this and track daily - I.e. come up with interesting ideas, provide a scoring and reasoning based on articles and discussions in the tech space.<p>> buildwhat.org

value: Show HN: Buildwhat.org – Find the next tech idea


value: yol

value: Made this skill to free me from the chores for improving LLM output quality.

value: Show HN: An agent skill for eval-driven development of LLM-powered app

author: yol


value:
I built Smart Local Search – a privacy-first local AI search tool.
It finds files, photos and code by describing them.
Everything runs locally:
- no cloud
- no telemetry
- open source
GitHub:
https://github.com/dan99nik/smart-locale-search

value: Show HN: Smart Local Search – open-source local AI search for files and photos


value: Show HN: Calyx – Ghostty-Based macOS Terminal with Liquid Glass UI


value:
GitHub:
https://github.com/themankindproject/imgfprint-rs
imgfprint is a Rust library for deterministic image fingerprinting and image similarity detection.
Features:
- perceptual hashing
- exact hashing
- optional CLIP embeddings

value: Show HN: Imgfprint – deterministic image fingerprinting library for Rust


value: ogandreakiro

value:
Hey HN!
We built Notte, a browser infrastructure and agents platform.
Many of our users automate UI workflows or extract data from sites that don’t have APIs. In practice, we noticed that once an agent understands how a site works, parts of the task can often run without a browser by interacting with the same network requests the site uses.
So we built Anything API: describe a browser task, and our agent explores the site, builds a function, tests it against your description, and deploys a callable REST endpoint. No infra to manage.
How the build works:
- Describe the task (best results come from writing it as acceptance criteria)
- The agent browses the target site, finds the optimal automation path (UI vs. network requests)
- It generates a function, runs it, checks the output against your description, iterates until it passes
- You get a deployed endpoint running on managed infrastructure
What actually gets deployed:
The agent's default goal is a pure HTTP client that calls the site's backend APIs directly, with no browser at runtime. When the site doesn't expose usable APIs for the task, it produces a hybrid function that mixes API calls with browser automation.
"Can't I just build this with Claude Code?"
Could build a one-off version locally, the difference/value is our managed infrastructure out of the box - concurrent cloud execution, stealth, browser management, scheduling, monitoring
"What happens when the site changes?"
Functions that rely on network requests are typically less affected by frontend changes. Hybrid functions are more sensitive to UI changes, but in either case failures return errors rather than silently failing. Managed self-healing is something we're currently working on.
"Are agents used at runtime?"
Agents drives the build phase. The deployed endpoint is a scripted runtime wherever possible.
"Bot detection?"
Anything API runs on our stealth stack (residential proxies, etc.). However, we enforce a fair use policy. The agent will refuse requests that explictely violate a site's terms of service.
"Authenticated content?"
Works with login-gated sites. The agent handles auth during the build. For recurring runs, we have encrypted credential vaults, session profiles, and OTP interception for 2FA.
Try it and let us know what you think: https://anything.notte.cc
- Andrea & Lucas, Notte Founders

value: Show HN: Anything API – Get APIs from Websites Without APIs

author: ogandreakiro


value: akshaydeshraj

value:
I kept copying multi-line commands from ChatGPT/Claude/READMEs and getting `command not found` errors when pasting into my terminal. Bracketed paste mode doesn't help — it prevents line-by-line execution, but the content itself still arrives broken (stray `$` prompts, split continuations, operators across lines).
SmartClip hooks into your shell's paste widget (zsh, bash, fish) and silently fixes multi-line commands before the shell sees them. You paste with Cmd+V as usual — no new keybindings, no daemon, no background process.
It uses score-based heuristics to detect shell commands (so it won't mangle your JSON or prose), joins lines intelligently (backslash continuations, pipes, `&&`), strips prompt characters, and validates everything with `bash -n` before inserting. If it's not confident or the fix has invalid syntax, it passes through unchanged.
~150 lines of bash. Zero dependencies.
`brew install akshaydeshraj/smartclip` or `npm install -g smartclip-cli`

value: Show HN: SmartClip – fix multi-line shell commands before they hit your terminal

author: akshaydeshraj


value: JitseLambrichts

value: I built a local-first UI that adds two reasoning architectures on top of small models like Qwen, Llama and Mistral: a sequential Thinking Pipeline (Plan → Execute → Critique) and a parallel Agent Council where multiple expert models debate in parallel and a Judge synthesizes the best answer. No API keys, zero .env setup — just pip install multimind. Benchmark on GSM8K shows measurable accuracy gains vs. single-model inference.

value: Show HN: Run an Agent Council of LLMs that debate and synthesize answers

author: JitseLambrichts


value: ftwum

value: Show HN: React components for generating beautiful PDFs

author: ftwum


value: larsmosr

value:
Hey HN -- I'm a solo dev. Built this because I got tired of AI crawlers reading my HTML in plain text while robots.txt did nothing.
The core trick: shuffle characters and words in your HTML using a seed, then use CSS (flexbox order, direction: rtl, unicode-bidi) to put them back visually. Browser renders perfectly. textContent returns garbage.
On top of that: email/phone RTL obfuscation with decoy characters, AI honeypots that inject prompt instructions into LLM scrapers, clipboard interception, canvas-based image rendering (no img src in DOM), robots.txt blocking 30+ AI crawlers, and forensic breadcrumbs to prove content theft.
What it doesn't stop: headless browsers that execute CSS, screenshot+OCR, or anyone determined enough to reverse-engineer the ordering. I put this in the README's threat model because I'd rather say it myself than have someone else say it for me. The realistic goal is raising the cost of scraping -- most bots use simple HTTP requests, and we make that useless.
TypeScript, Bun, tsup, React 18+. 162 tests. MIT licensed. Nothing to sell -- the SDK is free and complete.
Best way to understand it: open DevTools on the site and inspect the text.
GitHub: https://github.com/obscrd/obscrd

value: Show HN: I built an SDK that scrambles HTML so scrapers get garbage

author: larsmosr


value:
I built PromptSonar because I kept seeing LLM security
discussions focus entirely on runtime interception — but
nobody was scanning the prompt strings written directly
into source code before they ship.
PromptSonar is a static analyzer that scans your codebase
for prompt injection, jailbreaks, PII leaks, and privilege
escalation patterns in LLM prompt strings. It works across
TypeScript, JavaScript, Python, Go, Rust, Java, and C#.
What it catches:
- Direct prompt injection and jailbreak patterns
- Unicode evasion: Cyrillic homoglyphs, zero-width character
  injection, Base64-encoded jailbreaks
- PII exposure in prompts (SSN, credit card, API keys)
- Privilege escalation and role manipulation
- RAG poisoning patterns
- Insecure output handling
Maps findings to OWASP LLM Top 10. Outputs SARIF v2.1.0
for GitHub Code Scanning integration. 100% local,
zero telemetry, no API calls.
Available as VS Code extension, CLI, and GitHub Action.
npx @promptsonar/cli scan ./src
I wrote up the Unicode evasion detection methodology
separately if anyone is interested in how the
normalization pipeline works:
https://medium.com/@meghal86/detecting-unicode-homoglyph-and...

value: Show HN: PromptSonar – Static analysis for LLM prompt security


value: didarsingh

value:
Hi HN,
I've been working on a small project called Arkadia.
The idea started when I put a collar camera on my dog and experimented with using AI to narrate things from her point of view. That led me down a rabbit hole thinking about animal personalities and how people might interact with them.
Arkadia is a conversational AI app where you can chat with characters inspired by real animals.
The goal is to make it feel like discovering animals through conversation rather than interacting with a generic chatbot.
It's still early, but we have a few hundred people using it while I test conversation quality, memory, and latency.
One direction I'm exploring is using AI as a bridge to the real world. For example, after chatting with a character inspired by a specific breed or animal, you could discover farms, shelters, or places nearby where you could actually meet animals in real life.
Curious what the HN community thinks.

value: Show HN: Arkadia – AI characters based on real animals

author: didarsingh


value: suneeshtr

value: Show HN: Atomic Commit – MCP and Claude plugin for structured Git workflows

author: suneeshtr


value: huksley

value:
Hi HackerNews,
Ruslan here.
I once posted here a story how I got AWS $4k surprise bill for one day (https://news.ycombinator.com/item?id=31907374), which is why I built DollarDeploy. I believe 95% of apps don't need complicated AWS infrastructure and can be hosted using simple server from Hetzner, Digital Ocean, etc.
Today I am launching an AI agent on DollarDeploy. The AI agent can automatically build and deploy your NextJS/React, Go, Rust, or other types of apps to your own servers, running all commands via SSH on your server. You just type your commands or paste your GitHub repo link!
DollarDeploy is similar to Dokploy expected there is no self-hosted version, because we want to offer a simple solution which you don't configure and maintain - just add your GitHub repo and you are good to go.
What makes DollarDeploy different is that we run apps as isolated Systemd processes on your server, and you can install Redis, Postgres, and other services to your host in a single click. Everything works locally, with low overhead as normal Linux processes, without the need of third party services.
Try deploying your app — takes under 5 minutes. Looking for your feedback and opinion! Happy to answer any questions you have!
FAQ: 1) To use DollarDeploy, you need to bring your own server or provision one directly through UI/AI. 2) We have 14-day trial. 3) We are using OpenAI LLMs (probably will change soon) 4) You can use quick boilerplate to launch the app, or a template for open source software, including running GPT-OSS LLM model

value: Show HN: DollarDeploy AI, agent to deploy your web apps to production

author: huksley


value:
We built rudel.ai after realizing we had no visibility into our own Claude Code sessions. We were using it daily but had no idea which sessions were efficient, why some got abandoned, or whether we were actually improving over time.
So we built an analytics layer for it. After connecting our own sessions, we ended up with a dataset of 1,573 real Claude Code sessions, 15M+ tokens, 270K+ interactions.
Some things we found that surprised us:
- Skills were only being used in 4% of our sessions
- 26% of sessions are abandoned, most within the first 60 seconds
- Session success rate varies significantly by task type (documentation scores highest, refactoring lowest)
- Error cascade patterns appear in the first 2 minutes and predict abandonment with reasonable accuracy
- There is no meaningful benchmark for 'good' agentic session performance, we are building one.
The tool is free to use and fully open source, happy to answer questions about the data or how we built it.

value: Show HN: Rudel – Claude Code Session Analytics


value: Show HN: We wrote a custom microkernel for XR because Android felt too bloated


value: rohansx

value:
Hey HN,
When you send real documents or customer data to LLMs, you face a painful tradeoff:
- Send raw text → privacy disaster
- Redact with [REDACTED] → embeddings break, RAG retrieval fails, multi-turn chats become useless, and the model often refuses to answer questions about the redacted entities.
The practical solution is consistent pseudonymization: the same real entity always maps to the same token (e.g. “Tata Motors” → ORG_7 everywhere). This preserves semantic meaning for vector search and reasoning, then you rehydrate the response so the provider never sees actual names, numbers or addresses.
I got fed up fighting this with Presidio + custom glue (truncated RAG chunks, declension in Indian languages, fuzzy merging for typos/siblings, LLM confusion, percentages breaking math). So I built Cloakpipe as a tiny single-binary Rust proxy.
It does:
• Multi-layer detection (regex + financial rules + optional GLiNER2 ONNX NER + custom TOML)
• Consistent reversible mapping in an AES-256-GCM encrypted vault (memory zeroized)
• Smart rehydration that survives truncated chunks like [[ADDRESS:A00
• Built-in fuzzy resolution for typos and similar names
• Numeric reasoning mode so percentages still work for calculations
Fully open source (MIT), zero Python dependencies, <5 ms overhead.
Repo: https://github.com/rohansx/cloakpipe
Demo & quick start: https://app.cloakpipe.co/demo
Would love feedback from anyone who has audited their RAG data flow or is struggling with the redaction-vs-semantics problem — especially in legal, fintech, or non-English workflows.
What approaches have you landed on?

value: Show HN: I built proxy that keeps RAG working while hiding PII

author: rohansx


value: apresmoi

value:
I made Le Vin Nouveau, an artwork on slopism.art
It is a continuously growing cyclic graph of short story fragments. Each node is a fragment, each edge is a possible continuation, and each visit reveals one path through the graph.
The graph is being written continuously by 13 agents based on books. Readers/users vote on fragments, and over time those votes shape what gets surfaced and what the graph keeps growing around.
So the point is not that the earliest fragments are already polished literature. The point is selection/curation: an artwork whose form emerges through accumulation, readers pressure, and survival inside of the graph.
The initial set of agents was selected through a published collaborative pipeline involving GPT, Claude, Gemini, Grok, DeepSeek and myself deciding on ties:
github.com/slopism/ghosts-in-the-machine

value: Show HN: A graph of story fragments shaped by reader votes

author: apresmoi


value: jrswab

value:
I built Axe because I got tired of every AI tool trying to be a chatbot.
Most frameworks want a long-lived session with a massive context window doing everything at once. That's expensive, slow, and fragile. Good software is small, focused, and composable... AI agents should be too.
Axe treats LLM agents like Unix programs. Each agent is a TOML config with a focused job. Such as code reviewer, log analyzer, commit message writer. You can run them from the CLI, pipe data in, get results out. You can use pipes to chain them together. Or trigger from cron, git hooks, CI.
What Axe is:
- 12MB binary, two dependencies. no framework, no Python, no Docker (unless you want it)
- Stdin piping, something like `git diff | axe run reviewer` just works
- Sub-agent delegation. Where agents call other agents via tool use, depth-limited
- Persistent memory. If you want, agents can remember across runs without you managing state
- MCP support. Axe can connect any MCP server to your agents
- Built-in tools. Such as web_search and url_fetch out of the box
- Multi-provider. Bring what you love to use.. Anthropic, OpenAI, Ollama, or anything in models.dev format
- Path-sandboxed file ops. Keeps agents locked to a working directory
Written in Go. No daemon, no GUI.
What would you automate first?

value: Show HN: Axe – A 12MB binary that replaces your AI framework

author: jrswab


value: jaredstivala

value:
Hey HN, I built Friendware because I wanted autocomplete that works everywhere on my Mac, not just in code editors.
In any text field it can draft replies, rewrite text, and write prompts for AI tools; it uses on-screen context to adjust based on what you’re doing.
My goal was making it feel native and not require workflow changes, so it stays accessible across apps by living in the notch.
Currently working on better voice learning and a memory system, would love feedback on what to prioritize!

value: Show HN: Friendware – Tab-to-complete everywhere on macOS

author: jaredstivala


value: Enjoyooor

value:
The internet is full of vibecoded projects and AI-generated startups.
We built Glad-AI-tor, a public arena where founders throw their products into the crowd.
The rules are simple :
1/ submit your product
2/ the crowd roasts it
3/ the strongest survive
No marketing budget required.
Just the judgment of the internet.

value: Show HN: Glad-AI-Tor – A public arena where startups get roasted or crowned

author: Enjoyooor


value: Show HN: Python DSL for system programming with manual memory and linear types


value: amichail

value:
PluriSnake is a daily puzzle game where you create and move colored snakes to clear tiles.
The idea is simple:
* You use color matching in two distinct ways: matching circles create snakes, and matching a snake’s color with the squares beneath it destroys them.
* Only snakes can move, and you move them in a worm-like fashion across the grid to new positions.
* Your goal is to destroy as many squares as you can. Note that destroying all of them may not be possible.
App Store link: https://apps.apple.com/us/app/plurisnake/id6756577045 [iOS/iPadOS/macOS]
What do you think of this game?
Can you beat my score of 98% for today's puzzle?

value: Show HN: PluriSnake, a new kind of snake puzzle game [iOS/iPadOS/macOS]

author: amichail


value: slhomme

value:
I built StudioIndex because I kept seeing incredible AI-generated commercials (Nike, Coca-Cola, Anthropic's Super Bowl spot) but had no way to find out which studios actually made them or how to hire similar talent.
Marketing teams are starting to look for AI video production partners, but there's no central place to compare studios, see their work, or understand pricing. So I built a curated directory where you can browse AI-native and AI-augmented studios, watch their best work, and filter by the tools they use (Runway, Veo, Midjourney, Kling, etc.).
The site is free to browse. Studios can list themselves for free too. I'm curating listings manually right now to keep quality high.
Would love feedback on the UX and what data points would be most useful when comparing studios.
I'm just strating this, so it's work and progress, don't hsitate to share good videos and studios.

value: Show HN: StudioIndex – A directory to find AI video production studios

author: slhomme


value: davidkir

value: Show HN: Runnable MCP agent attacks – DNS rebinding, rug pull, and mitigations

author: davidkir


value: monkeypilot

value:
Hi HN! We're Oncourse AI — an AI-powered medical exam prep platform. We built this because watching friends waste 6-12 months on ineffective prep was painful.
The problem: Medical students use static question banks (UWorld, Amboss) + generic study plans. They burn out, waste 10+ hours/week, and have no data on what's actually working. Average pass rate has stagnated for years.
In my college, I got an average 3/4GPA. Then I came across neuroscience principles of learning which made me get a perfect 4/4 GPA with lower effort. But there was no good product which let me apply these principles, and none of them were fun. This is why we built Oncourse.
Our solution: An AI study mate that:
- Lets med students practice clinical scenarios with AI patients that you can chat with and diagnose (Clinical Rounds)
- Gives high-yield questions and adapts the difficulty based on performance
- Give flashcards & interactive lessons - all personalised
- Gives clear explanations with visuals like flowcharts
- Uses spaced repetition for optimal retention
Tech: Uses LLMs for the content and has been reviewed by doctors. And spaced repetition algorithms, with real-time analytics and memory to personalise to students. Available across all platforms.
More than 30,00+ medical students across 30+ countries are using Oncourse AI already to help with their prep and their medical studies.
We're a 6-person team in Bangalore. Open to feedback. Especially if you're prepping for USMLE, NEET-PG, or INI-CET, try it free.

value: Show HN: Oncourse AI – Personal AI Study Mate for Med Students

author: monkeypilot


value: gian-lazzarini

value:
I built a self-hosted wardrobe organizer that runs as a single Docker container.
You photograph your clothes, categorize them, and build saved outfits. It's a
PWA so it installs to your phone's home screen and works offline.
docker run -d -p 3000:3000 -v librecloset_data:/app/data ghcr.io/lazztech/libre-closet
No external services required. SQLite by default, optional PostgreSQL. Local disk
storage by default, optional S3-compatible provider. Optional JWT auth for
multi-user households, or run completely open for personal use.
There are a handful of wardrobe apps in the wild, but they're either unmaintained,
cloud-only, or require a stack of services to stand up. This one is a single
image. I wanted something I'd actually use.
Source: https://github.com/lazztech/libre-closet
Live demo: https://librecloset.lazz.tech (register free, no email verification)

value: Show HN: Libre Closet – self-hosted wardrobe organizer (single Docker run)

author: gian-lazzarini


value: kluton

value: Show HN: CUDA Farm – 65 physics endpoints that can't hallucinate

author: kluton


value: ashleynader

value: Show HN: I got tired of writing release notes so I built a bot with Claude

author: ashleynader


value: khaeldur

value: Show HN: ProjectOS – An AI operating system for truth and control

author: khaeldur


value: danesto

value:
I just started a blog and newsletter in the developer experience niche. I plan on writing about my experience of various tools and tech I try out to help developers build faster. Also I will be documenting my whole journey about starting this newsletter there, so it might be a fun serios to follow!
https://danilostojanovic.stoicdev.tech/the-patch

value: Show HN: Developer Experience Newsletter

author: danesto


value: andrewfhou

value:
I’ve been studying Japanese for a few years pretty seriously (anki decks, textbooks, online tutor) but I always felt that the speaking practice pipeline could be optimized. With a real tutor, my mistakes didn’t get enough specific reps, they oftentimes weren’t pedantic enough, and practice in multiple contexts was a problem. (I also subconsciously avoid saying things I know I might mess up on to not sound dumb to a real human)
I’m pretty bearish on most other apps, they seem mostly for casual learners with streaks/gamifications and canned scenarios with shallow feedback, even the recent stuff using AI. I for one hate using mobile apps to study (small screen, notification driven, gamified, etc) and I really wished I could deep dive/rabbit hole into my mistakes and drill them specifically.
I built Lingle as a desktop-first tool explicitly for learners who already have a serious study routine and want to work on deliberate practice for speaking with rigorous feedback and detailed explanations and more pedantic feedback to bridge the gap between understandable and natural.
Details:
-Voice input with real-time transcription fed into a conversation model prompted to behave as a native speaker in a user-defined context
-A second pass evaluates utterances for naturalness, register, and pragmatic appropriateness, not just grammatical correctness
-Corrections surface inline without interrupting conversation flow, allows you to retry if you made a suboptimal response
Users define their own contexts entirely — no preset scenarios, you tell it what you're watching, reading, or which grammar structures you want to drill
watching, reading, or which grammar structures you want to drill
The hardest problem has been calibrating correction sensitivity - getting the model to catch subtle pragmatic errors without overcorrecting or flagging legitimate stylistic variation. Still actively working on this and would genuinely love input from anyone who's thought about this problem. Also thinking about adding longer term memory and integrating with other study tools (Anki, etc) to make it more fullstack. Maybe one day replacing my italki tutor entirely with AI + memory and textbook integration or something.
Currently Supports Japanese, Spanish, French, Mandarin, German, Korean, and Portuguese. Free to try while I validate whether this is a real problem worth building further.
Happy to get into the technical architecture or prompting approach in the comments.
– Andrew

value: Show HN: Desktop conversation practice tool for serious language learners

author: andrewfhou


value: DrFisch

value: Show HN: War News Wire – Real-Time Aggregator for the Iran-Israel-US Conflict

author: DrFisch


value: vadelfe

value:
Over the last few months I've been doing something that feels completely irrational in 2026.
While everyone is building AI tools and automating everything, I started manually curating people from the internet who talk about topics that can help you improve different areas of life.
Not ranking them.
Not claiming they are “the best”.
Just organizing who talks about what.
The Process:
1,150+ sources (authors, founders, scientists, creators and regular people).
100% manual categorization. No AI scrapers.
Organized by categories, subcategories and intent-based tags (all done by hand).
Built entirely on spreadsheets before moving to this prototype.
Right now it's about 1000+ sources organized around topics like health, skills, business, mindset, and others.
I originally started doing this for myself because:
- I don't like that what I see online depends on an algorithm
- I know there's valuable content online, but finding it consistently is hard
- While organizing this, I kept discovering things I didn't know existed but were exactly what I needed
becometry.vercel.app
I'm genuinely curious:
In an AI-saturated internet, does the idea of human-curated discovery still make sense to you?
Does the 'Map' structure feel like a viable alternative to the way we consume information today?
Happy to answer anything and open to brutally honest feedback.

value: Show HN: I manually organized 1000 profiles (am I a dinosaur?)

author: vadelfe


value: Show HN: Oat Glassed – 11KB, no dep, almost semantic UI library make worse


value: judekim

value:
AgentFork lets maintainers and teams connect a GitHub repo. Our AI indexes the codebase — detects the framework, databases, services, and build steps — and generates an environment spec. Anyone can then fork the project and get a fully provisioned cloud environment with a live preview URL. Databases like Postgres and Redis are spun up automatically.
The idea is that AI agents (or any contributor) can fork, make changes, and verify them against a real running instance without anyone configuring infrastructure.
Early stage — waitlist is open at agentfork.dev. Would love technical feedback on the approach.

value: Show HN: AgentFork – Any repo, instantly runnable by AI agents or contributors

author: judekim


value: psrth

value:
Mori is an open-source database proxy that lets you run your application locally against real production data without risking writes to production. It connects to your production database, clones the schema locally, and intercepts queries:
- Reads come from production
- Writes / migrations / deletes are executed only in a local shadow database
- Results are merged in real time so your app thinks the changes happened in production
So you (and your AI agents) can safely test your code in a verifiable environment (real production data) locally before you're ready to push.
Links:
- Demo -> https://moridb.sh/demo
- Repository -> https://github.com/psrth/mori
- Docs -> https://moridb.sh/docs
Motivation:
Most people ask Santa for a bicycle; every year, I've been asking for the ability to test in prod. The existing alternatives (branching, snapshots, seed dbs, staging dbs, good old pg_dump) are one or more of: (a) out of sync, (b) expensive to run (time and cost), (c) cloud / managed provider only. But as AI agents continue to write more code, our local testing frameworks need to keep up. Writing code shouldn't be artificially bottlenecked or a literal leap of faith.
Implementation:
The docs have a lot more information, but a summary:
- Support for PSQL/MySQL/SQLite + 6 more engines, each with custom AST-level query classification and rewriting
- In-flight cross-DB merging of prod data with local modifications
- Collision-free PK generation and support for foreign keys
- Full transaction support including CTEs, nested transactions, and savepoints
- MCP support: plug-and-play into Claude Code, Cursor, or wherever you get your tokens
- Exhaustive E2E test suite per engine
Safety:
I want to specifically call out the core design principle — that production should never be writable through Mori. This is enforced through four independent layers:
1. Query classification — every statement is parsed and classified as read or write before routing
2. Routing rules — writes are deterministically routed to the local shadow database, never forwarded
3. Shadow execution enforcement — even if classification is bypassed, the execution layer rejects any write targeting the production connection
4. Raw byte inspection — finally, outbound bytes on the production socket are inspected to ensure no write operation ever reaches prod
If any layer fails to classify a query, Mori refuses the statement entirely rather than risking a pass-through.
Note:
While I've validated (and extensively tested against our production database) all of the supported queries, there may (and will) be edge cases that I haven't discovered yet. If you hit an edge case, please open an issue - expanding the current coverage is my top priority!
If you want to see if this repo is a good fit for your workflow, you can checkout
> https://www.moridb.sh/docs/resources/compatibility.
Or, in the true spirit of this project, just go for it :)
> curl -fsSL https://moridb.sh/install.sh | sh

value: Show HN: Mori – Test against production data, without ever touching production

author: psrth


value: I kept hitting the ceiling with pgHero (snapshot only, no trends) but couldn't justify pganalyze at $149/mo for a small team. Building in health scores, query trends, deploy correlation. Still pre-launch, collecting waitlist signups. Appealing to more than just myself? https://uselantern.dev

value: Show HN: Lantern is a Postgres query monitoring for Rails teams ($39/mo)


value: Vercist

value:
Hello Hacker News! I'm Andreas, and I built SkyBlobs (https://skyblobs.com). It's still early but I wanted to share it now to get feedback. I built it to solve a problem I kept running into: non-technical teammates needing to change website copy that lives in JSON, YAML, or markdown files in a GitHub repo.
SkyBlobs connects to a GitHub repo, reads your content files, and gives you a clean visual editor. You edit the text, see a live preview of how it'll look on the site, and either save directly to a branch or open a pull request. The files never leave your repo.
Here's how the workflow looks in practice: I invite my collaborator to the Github repository, they sign in with GitHub, see the content files laid out in a visual UI, make their changes, and open a PR. I review it like any other code change.
*What it supports today:*
- JSON, YAML, and markdown content files
- Live preview (works best with Next.js and Vite projects currently)
- Save to branch or open a GitHub PR
- Nested key editing for i18n/translation files
The live preview runs your actual site framework in-browser using WebContainers so you see real output, not a mock.
*What it's not:*
This is not a full headless CMS. There's no content modeling, no schemas, no editorial workflows, no role-based permissions. It's deliberately simpler than that. If your content already lives in files in a repo and you just want people to be able to edit those files without opening VS Code, that's the use case.
I'd love to hear thoughts, especially from anyone who's dealt with the "my content is in Git but my editors can't use Git" problem. What did you end up doing? And if you try it out, I'm very open to feedback on what's missing or broken.

value: Show HN: SkyBlobs – Visual editor for content files in your GitHub repo

author: Vercist


value: brianberns

value: I built a machine learning project to play the card game Hearts at a superhuman level.

value: Show HN: Crushing Hearts with Deep CFR

author: brianberns

title: Show HN: Crushing Hearts with Deep CFR


value: stumpyfr

value:
I built Pulsar to solve a daily annoyance: GitHub's PR view doesn't give you a clean at-a-glance picture of what needs attention across multiple repos.
Pulsar is a lightweight dashboard that runs entirely in your browser. You paste in a GitHub PAT and it never leaves your machine, no backend, no accounts.
It shows PRs grouped by status (needs attention, awaiting review, your PRs, drafts), with approval badges, CI pass/fail indicators, and a small analytics dashboard (cycle time, review workload, merge trends).
Live: https://pulsar.arkham-advisory.com
Source: https://github.com/Arkham-Advisory/pulsar
Would love feedback, especially from teams with lots of repos.

value: Show HN: Pulsar, a browser-only GitHub PR monitor for engineering manager

author: stumpyfr


value: kapitalx

value: Show HN: A desktop app for managing Claude Code sessions

author: kapitalx


value: Show HN: Stop over-budget AI API calls per customer/feature (no proxy)


value:
We kept hitting the same wall building voice AI systems. Pipecat and LiveKit are great projects, genuinely. But getting it to production took us weeks of plumbing - wiring things together, handling barge-ins, setting up telephony, Knowledge base, tool calls, handling barge in etc. And every time we needed to tweak agent behavior, you were back in the code and redeploying. We just wanted to change a prompt and test it in 30 seconds. Thats why Vapi retell etc exist.
So we wrote the entire code and open sourced it as a Visual drag-and-drop for voice agents ( same as vapi or n8n for voice). Built on a Pipecat fork and BSD-2, no strings attached.
Tool calls, knowledge base, variable extraction, voicemail detection, call transfer to humans, multilingual support, post-call QA, background noise suppression, and a website widget are all included. You're not paying per-minute fees to a middleman wrapping the same APIs you'd call directly.
You can set it up with a simple docker command. It comes pre-wired with Deepgram, Cartesia, OpenAI , Speechmatics Sarvam for STT,  same for TTS, and OpenAI, Gemini, groq, Openrouter, Azure on the LLM side.
Telephony works out of the box with Twilio, Vonage , CLoudonix and Asterisk for both inbound and outbound.
There's a hosted version at app.dograh.com if self-hosting isn't your thing.
Repo: github.com/dograh-hq/dograh
Video walkthrough: https://youtu.be/sxiSp4JXqws
We built this out of frustration, not a thesis.
The tool is free to use and fully open source (and will always remain so), happy to answer questions about the data or how we built it.

value: Show HN: We open sourced Vapi – UI included


value: kstenerud

value:
The problem: tools like Claude Code ask you to approve every file edit, every shell command. After hundreds of prompts you stop reading and just hit "yes", or even worse you reach for `--dangerously-skip-permissions` and hope for the best. Neither option is great.
yoloAI runs your AI coding agents (Claude Code, Codex, Gemini, Aider, OpenCode) inside disposable containers so that they can operate without permission prompts. Your files are never touched because the agent works on an isolated copy. When it's done, `yoloai diff` shows exactly what changed, and `yoloai apply` patches your real project.
Workflow:

    yoloai new fix-bug ./my-project --prompt "fix the failing tests"
    # agent works freely inside the sandbox
    yoloai diff fix-bug    # see what changed
    yoloai apply fix-bug   # patch your real project (either workdir changes or new git commits)
    yoloai destroy fix-bug # toss the container

This isn't just some Docker wrapper script. yoloAI handles the full lifecycle: copying your project into the sandbox, setting up git baselines, injecting credentials, managing agent state across sessions, and giving you a clean diff/apply workflow to review changes before they land. Your originals are protected until you explicitly choose what to keep.
Single Go binary. Works on Linux (Docker), macOS (Docker Desktop, Tart VMs, or native Seatbelt sandboxing). Profiles with user-supplied Dockerfiles for reproducible environments. Network isolation with domain allowlists. Five agents supported out of the box.
Early access: The core workflow is solid, rough edges remain. MIT licensed.
https://github.com/kstenerud/yoloai
I built this because I was tired of babysitting Claude Code through permission prompts. Now I can't live without it. Happy to answer questions about the design, the tradeoffs, or the sandboxing approach.

value: Show HN: YoloAI: Sandboxed agent, no permission fatigue, diff/apply workflow

author: kstenerud


value: mattyhogan

value: Show HN: A workspace for humans and agents to do real work

author: mattyhogan


value: GregReve

value:
I'm Greg, co-founder of VaultLeap.
Built this for founders who can't get a US bank account. USD/EUR/MXN accounts with real ACH routing numbers and we have Visa cards coming soon.
If you've been cut off from Mercury or similar recently, DM me — happy to help some founders out.

value: Show HN: VaultLeap – USD accounts for founders outside the US

author: GregReve


value: ApiNotes

value:
Hi HN
I built ApiNotes Mock Server, a small tool that generates a live mock REST API from an OpenAPI (3.0/3.1) or Swagger 2.0 spec.
The goal was to remove all friction when you just need a mock API quickly:
No sign-up required to create an anonymous mock
Supports paste, file upload, or URL fetch
Produces a base URL + an auto-generated endpoints list
Anonymous mocks currently expire after 72 hours (you can register to keep them / get higher limits)
Link: https://apinotes.io/mock-server
I’d love feedback on:
What would make you trust a mock server like this for real projects?
Any features you’d expect (auth simulation, latency/errors, stateful mocks, webhooks, etc.)?
Is the 72-hour model reasonable, or should the free tier work differently?
Thanks, happy to answer any questions and share implementation details.

value: Show HN: Free API mock server from your OpenAPI spec (no sign-up)

author: ApiNotes


value: pkhodiyar

value: Show HN: LegalTech – A curated list of tools and software

author: pkhodiyar


value: Show HN: President: A Strategy Game

title: Show HN: President: A Strategy Game


value: marcobambini

value: Show HN: An embeddable fractional indexing library in C

author: marcobambini


value: thomasfromcdnjs

value: Show HN: View WhoisHiring post ranked against your resume using a CLI

author: thomasfromcdnjs


value: christopherAs

value:
Hi HN,
Most DevOps tools are good at observing — they collect data, surface metrics, and send alerts. But the actual decision and action still falls on the engineer.
So I built Riventa.Dev — a DevOps platform where the AI (Riv) doesn't just surface data, it acts.
What Riv does today:
- Automatic PR review on every push — no manual trigger, no GitHub Actions boilerplate
- Predictive failure detection — catches patterns that historically cause prod failures
- DORA metrics dashboard with real pipeline data (MTTR, Deployment Frequency, Change Failure Rate)
- Security scanning: SAST, SBOM, dependency analysis — built in, not bolted on
- Works with GitHub, GitLab, and Bitbucket
Built solo, from scratch, with a focus on keeping things simple for the end user.
What I'd love feedback on: Is the AI-first positioning clear? Where does the UX feel rough?
Free to try — no credit card required.

value: Show HN: Riventa.Dev – AI-native DevOps that acts, not just alerts

author: christopherAs


value: Show HN: Search 7,500 MCP servers across NPM, PyPI, and the official registry


value: Show HN: I made PythonStarter so I could launch faster with no Next.js or React


value: Show HN: An Embeddable SQLite Parser

title: Show HN: An Embeddable SQLite Parser


value: mnovalic

value: My first serious Open source project, MIT license, created with Sonnet 4.6 as co-pilot. Please give feedback. Thanks !

value: Show HN: Open-source project management tool

author: mnovalic


value: wsxiaoys

value:
Hi HN, Meng from TabbyML here.
We decided to build this simply because we find Jujutsu (jj) really interesting, and many folks on our team have started trying it out recently. Since it introduces a very different workflow compared to traditional Git, we thought it would be a fun challenge to see how well current AI coding agents can actually use it.
To build this, we created a semi-automated pipeline. We used AI to research the official Jujutsu documentation and websites, which then helped us bootstrap a dataset of 63 distinct evaluation tasks. Each task includes instructions, bootstrap scripts, and tests. We then ran the evaluations using the Harbor framework and our Pochi agent.
Some interesting insights from our initial leaderboard:
Claude 4.6 Sonnet is the clear winner: It achieved a 92% success rate (passing 58/63 tasks), beating out Opus and OpenAI's top models. It seems exceptionally good at parsing the novel CLI rules of jj.
The Speed vs. Accuracy Trade-off: While GPT-5.4 sits at #5 with an 81% success rate, it is incredibly fast, averaging just 77.6s per task. In contrast, Gemini-3.1-pro achieved 84% but took over 3x as long (267.6s average).
Open Weights / Regional Models are competitive: Models like Kimi-k2.5 (79%) put up a very respectable fight on a relatively niche tool.
The benchmark isn't completely solved yet, but the fact that top models can successfully navigate a relatively new version control system by reasoning through the tasks is pretty exciting.
If there are specific jj edge cases you think we should add to the dataset, feel free to open up a PR!

value: Show HN: jj-benchmark – Evaluating AI agents on Jujutsu version control

author: wsxiaoys


value: conguy

value: I accidentally cooked my local .env file and then went on a spiritual journey building what I wished 1pass’s environment tool was. Used Tauri to make a native mac app with a cli attached to it. Everything is offline, local, and encrypted. The cli forks a child process and injects your envs so you don’t need a .env file. I made it open source, maybe ya’ll might find it useful.

value: Show HN: Sigyn – OSS native macOS secrets manager to replace .env (GUI+CLI)

author: conguy