value: dkaragas

value:
Last year, I went to a game at a stadium I had never visited (Arrowhead). Ended up baking in the sun for the entire second half. Afterwards, was surprised I couldn't find a tool that told me where the sun would actually be during games.
So for WC2026 I built SeatSun: a free tool (no sign up needed) that calculates sun/shade exposure for every section at the World Cup 2026 stadiums depending on date and match time.
The technical core: solar azimuth and altitude calculations (based on Meeus astronomical algorithms, ~0.3 degree accuracy) tied to each stadium's orientation and GPS coordinates. For each open-air stadium I mapped the seating sections to compass bearings, then render an interactive overlay showing which sections are in sun vs shade at the exact match time. The sun position shifts meaningfully across a single afternoon -- a 3pm kickoff looks very different from a 6pm kickoff at the same stadium.
Covers 16 stadiums: 13 open-air with interactive sun maps, 3 indoor (AT&T, Mercedes-Benz, NRG) with appropriate notes. You can set any date and kickoff time to see the exposure for your specific game.
Would love feedback on the accuracy, especially from anyone who has been inside these stadiums and can sanity-check the section orientations. A few of the venues were harder to calibrate than others, and I haven’t yet made adjustments other than notes for partially covered stadiums (eg Hard Rock).

value: Show HN: I calculated sun/shade exposure for every seat at World Cup stadiums

author: dkaragas


value: petervandijck

value:
I've always loved RSS and I long thought RSS + LLMs would make a great couple, so I built clawfeeds (apologies for the name!)
You can try it by simply asking Claude to check out https://agent.clawfeeds.com/try.md, it'll figure it out, or have a look yourself at https://clawfeeds.com
- (very) context-friendly feeds (feeds & posts separated out)
- webhook for new post notifications
It crawls RSS feeds, parses them into markdown, and gives you a very concise feed markdown file (example: https://agent.clawfeeds.com/feed/uqhb-tssd-4gk9.md), which links to markdown post files (example: https://agent.clawfeeds.com/post/cm47-5dbd-x6we.md).
The idea is 1. protect your context window, and 2. get notified of new posts at your webhook (or some other mechanism).
It's free - it doesn't eat up much resources, the markdown files live in a DO bucket. You need an account to add/follow feeds and add a webhook for your agent to be notified of new posts from feeds you follow.
I can think of a ton more features (it's kind of a feed reader for agents), but I'd love to hear what people think might be useful.
An interesting aspect has been to design this for agents first - the CTA is aimed at agents, etc.
I imagine use cases like having my agent read my favourite Substacks and summarizing things, following packages I use on Github etc. RSS is (still) everywhere. (For example this https://news.ycombinator.com/item?id=47337607 recent discussion)

value: Show HN: I made clawfeeds, feeds for agents

author: petervandijck


value: qq-niklas

value:
It's been a bit over a month since last I posted about this project. I'm still having a mostly great experience using AI tools.
Even though I'm using AI tools, it isn't effortless. Since last time, most of what I have achieved is likely invisible to you as a player. And, frankly that's likely to be expected more often than not. That said, there are some noticeable nuggets for those that have tried the game.
I have added a bit more decision making for the player, adapting the Novice skill as suggested in my previous post. I've also added active skills to all classes. The list is quite a bit longer than this consisting of both smaller tweaks, fixes and complete reworks.
If you've tried the game before and enjoyed it, I hope you will enjoy it even more now. Still, far from finished but I think it is in a fairly playable state.

value: Show HN: Reel Rogue Update – The Invisible Feeling

author: qq-niklas


value: arberx

value: Canonry lets you track in detail how LLMs (Claude, ChatGPT, Gemini) site your business for specific keywords or phrases!<p>Would love some feedback!

value: Show HN: We built an open source tool to see how AI cites our business

author: arberx


value: simosmik

value:
CloudCLI is an open source web and mobile UI/mini IDE for Claude Code, Gemini, Codex and Cursor CLI.
It sits on top of your existing agent install and gives you a browser interface you can open from any device. You can start sessions, resume existing ones, browse and edit files, manage git and the same control as sitting at your desktop.
Try it: npx @siteboon/claude-code-ui (works with your existing setup)
When you open it you'll already see all the sessions from your terminal.
Some backstory:I've wanted to develop from my phone for a long time. When Claude Code arrived, the human-in-the-loop workflow made it practical. So around 8 months ago, I was running Siteboon (a website builder I've been working on for about two years) and started building it on top of Claude Code. There was no easy way to go from my phone to desktop so I thought I'd just build one as a weekend project. I put it on github and shared it at an AI meetup in Amsterdam.
I wasn't paying much attention to the repo after that. A few months later I looked up and it had a couple thousand stars which made me rethink what I should actually be working on!
How it works:The server scans ~/.claude/projects/ (and equivalents for Cursor, Gemini, Codex) to discover existing sessions and streams the output to the browser. We started with node-pty streaming back but then moved to the official SDKs as Anthropic (Claude Agent SDK), OpenAI, and Google released them. Sessions you create in the UI are then accessible from any terminal or IDE since they share the same config directories.
The turning point was when Anthropic launched Remote Control. We went from 6.5k to 8.2k stars in a couple of weeks and were trending on GitHub. Their launch apparently made a lot of devs realize that remote agent workflows are possible. But being able to only continue existing sessions, not actually control your coding agent the way you would from your laptop, left a lot to be desired. This project gives you full control from the browser and works across multiple agents, not just Claude.
Next up we're looking at shared team environments and plugins that would extend the platform even further
There's also a hosted version at cloudcli.ai where you get a remote dev environment with everything pre-installed, your own subdomain, and no setup. Useful if you want sessions that keep running after your laptop closes.
Would love feedback on the self-hosted install (try the npx command and tell me what breaks), whether shared team environments would be useful, and how you're currently handling remote agent workflows. I've heard from a lot of people who were using Tailscale+tmux and moved away from it after finding this project.
GitHub: https://github.com/siteboon/claudecodeui |  Hosted: https://cloudcli.ai

value: Show HN: CloudCLI-Web/Mobile UI for Claude Code,Codex and Gemini(8.2k stars)

author: simosmik


value: dataversity

value: Show HN: Run Hugging Face models with a single command

author: dataversity


value: barent

value: Show HN: NatShell Local-first natural language shell (no cloud, no API keys)

author: barent


value:
Hey HN,
I built A2Apex (https://a2apex.io) — a testing and reputation platform for AI agents built on Google's A2A protocol.
The problem: AI agents are everywhere, but there's no way to verify they actually work. No standard testing. No directory of trusted agents. No reputation system.
What A2Apex does:
- Test — Point it at any A2A agent URL. We run 50+ automated compliance checks: agent card validation, live endpoint testing, state machine verification, streaming, auth, error handling.
- Certify — Get a 0-100 trust score with Gold/Silver/Bronze badges you can embed in your README or docs.
- Get Listed — Every tested agent gets a public profile page in the Agent Directory with trust scores, skills, test history, and embeddable badges.
Think of it as SSL Labs (testing) + npm (directory) + LinkedIn (profiles) — for AI agents.
Stack: Python/FastAPI, vanilla JS, SQLite. No frameworks, no build tools. Runs on a Mac mini in Wyoming.
Free: 5 tests/month. Pro: $29/mo. Startup: $99/mo. Try it at https://app.a2apex.io
I'm a dragline operator at a coal mine — built this on nights and weekends using Claude. Would love feedback from anyone building A2A agents or thinking about agent interoperability.

value: Show HN: A2Apex – Test, certify, and discover trusted A2A agents


value: pfnsec

value: Unlike Terraform and Pulumi, Autoschematic is built around a bidirectional (push-pull) state model. This means that it can resolve state drift by "pulling" or "pushing" (applying). This makes it a much better fit for certain use-cases where configuration drift is more common, like Snowflake. It also means you can import your existing infra automatically.

value: Show HN: Autoschematic is a new infra-as-code tool built on reversible computing

author: pfnsec


value: heythisischris

value:
Hey HN,
I posted GitClassic here 2 months ago- since then I've rebuilt most of it based on what people asked for.
https://gitclassic.com
What's new: Issues, PRs w/ full diffs, repo intelligence (health scores, dependency graphs), trending/explore, bookmarks, comparison tool, and advanced search.
Every page is server-rendered HTML- No React, no SPA, no client bundle, pages under 14KB(gzipped). Try loading facebook/react and compare it to GitHub load times.
Public repos work without an account, Pro adds private repo access via GitHub OAuth.
Stack: Hono on Lambda, DynamoDB, CloudFront, 500KB Node bundle, cold starts usually <500ms.
What's missing?
Thanks,
Chris

value: Show HN: GitClassic.com, a fast, lightweight GitHub thin client (pages <14KB)

author: heythisischris


value: otakumesi

value:
I built subagent-cli, a CLI for coordinating multiple coding agents.
I wanted a way to combine agents by role instead of being locked into a single built-in workflow. In practice, I often want one agent acting as a manager and others acting as workers for implementation, review, or research.
The goal is to make that workflow usable from a normal terminal: start workers, delegate tasks, review progress, and coordinate everything from one control point.
Setup is currently:
uv tool install subagent-cli
subagent config init --scope user
npx skills add "github/otakumesi/subagent-cli"
Then you give your coding agent a task and have it coordinate worker agents via the `subagent-manager` skill.
The README includes a real Gemini → Codex demo.
The current scope is intentionally narrow: it’s alpha, local-only, single-host, and currently ACP-based.
One design question I’m still evaluating is the abstraction boundary. Right now, the CLI maps fairly directly to the protocol, and I’m not fully sure whether that’s the right tradeoff. The current worker / turn / approval / handoff model may be the right boundary, or some of it may need to be hidden behind a simpler interface.
I’d especially love feedback on whether this feels useful in real workflows, and whether the current model feels like the right UX for multi-agent coding.
URL: https://github.com/otakumesi/subagent-cli

value: Show HN: Subagent-CLI – a CLI for managing multiple coding agents

author: otakumesi


value: Jbced

value: Show HN: OpenTabs – Your AI calls Slack's internal API through the browser

author: Jbced


value: crad

value: Claude Status is a native macOS app that includes a Menu Bar status indicator and desktop widgets tracking all of your open Claude Code sessions across terminals, tmux, and IDEs.<p>I built it because I often am running multiple Claude sessions and miss when a session is waiting on me to proceed.

value: Show HN: Claude Status

author: crad

title: Show HN: Claude Status


value: almogbaku

value:
Coding agents debug like a junior dev in 2005: they spam print() and loop until the bug disappears or eats your context window.
TL;DR: I gave my agent a debugger and saw it go from 5-6 print-debug cycles down to 1 targeted stop.
I built a small CLI that wraps the Debug Adapter Protocol and exposes basic debugger actions so agents can call them directly. Each command blocks until execution pauses, then returns the full context.
The CLI is just a thin layer. The useful part is a debugging “skill” on top that teaches the agent how to debug methodically with it, define clear hypotheses, validate/invalidate them, etc.
Supports Python, Go, Node/TypeScript, Rust, and C/C++.

value: Show HN: Stop AI Debugging with Print(). Use a Debugger

author: almogbaku


value: leventilo

value:
I built an open-source SDK that lets AI agents pay for API data automatically.
The problem: a growing number of APIs return HTTP 402 Payment Required. Coinbase reports $50M+ in x402 transactions over the last 30 days. Stripe and Cloudflare joined the x402 Foundation last month. The payment layer of the internet is being built right now, but existing HTTP clients just fail on 402 responses.
BoltzPay makes it one line:

  const agent = new BoltzPay({ budget: { daily: "$5.00" } });
  const data = await agent.fetch("https://x402.twit.sh/tweets/search?words=AI+agents");

The SDK detects which payment protocol the endpoint uses (x402 or L402), signs the payment with the developer's own keys, and returns the data. No dashboard, no API keys to manage per provider. Just fetch().
What's under the hood:
* Multi-protocol: x402 (EIP-712 signed USDC on Base/Solana) + L402 (Lightning invoices via NWC/Alby)
* Parallel protocol detection: ProtocolRouter probes 402 headers with Promise.allSettled(), auto-fallback between adapters
* Budget engine: daily/monthly/per-transaction caps with persistent state. 90% threshold warnings. Agents never touch your wallet directly
* Built-in endpoint discovery: the SDK indexes live paid APIs across the x402 ecosystem and probes them in real-time (health, pricing, protocol support)
* Delivery diagnostics: when payment succeeds but the server errors, the SDK returns structured diagnosis (DNS, latency, protocol format, server health)
Ships as 9 packages: TypeScript SDK, MCP server (7 tools for Claude/Cursor), CLI, Vercel AI SDK, LangChain, CrewAI, n8n, and OpenClaw. npm + PyPI. 1200+ tests. MIT licensed. Your keys, no vendor lock-in.
What I didn't expect: within two weeks, autonomous AI agents started opening issues on the repo, proposing trust scoring and payment verification integrations. The people behind them turned out to be serious builders (Microsoft Principal Engineer, PhD researchers in the Bitcoin/Lightning space). The agent economy isn't coming. It's already here and looking for plumbing.

value: Show HN: BoltzPay – fetch() that pays for AI agents (x402 and L402)

author: leventilo


value: hbamoria

value:
We built an open-source library of 125 GTM (go-to-market) skills that plug into AI coding agents like Claude Code, Codex, and Cursor.
With these skills an AI agent can automatically:
- Find ICP leads from conference speakers, LinkedIn activity, or job boards
- Generate personalized cold email sequences
- Monitor competitor blogs, pricing pages, and hiring signals
- Generate programmatic SEO pages from keyword lists
- Track where your brand appears in ChatGPT, Perplexity, and Claude answers
---
How skills work
Each skill is a structured markdown file containing instructions, scripts, and tool definitions that an AI agent can follow.
Think of them as reusable playbooks for sales, marketing, and growth work — but executed by your AI agent instead of manually.
Example
Install any skill with one command:
```
npx goose-skills install <slug>
```
Platform support
```
npx goose-skills install <slug> --claude
(default – Claude Code)<p>npx goose-skills install <slug> --codex
(OpenAI Codex)<p>npx goose-skills install <slug> --cursor
(Cursor, requires --project-dir)
```
---
Why we built this
We've been using Claude Code for GTM work — not just coding.
We run outbound campaigns, find leads, monitor competitors, audit SEO, and generate marketing workflows using agents.
The problem was that every time we wanted to run a workflow we had to re-explain it.
Skills solve this: write the workflow once, install it, and your agent can execute it reliably.
---
We open-sourced the library because we think GTM teams will increasingly orchestrate AI agents to run core workflows — and we wanted to build the skill ecosystem in the open.
If you want an agent that already knows how to do GTM work, try Gooseworks — an agent with these skills pre-installed, plus filesystem access, memory, and integrations with dozens of tools: https://gooseworks.ai
---
I'd love feedback on two things:
1. What GTM workflows would you want an AI agent to run?
2. Are there skills you'd want added to the library?
Happy to answer questions about the skill format, how we built this, or how to contribute your own.

value: Show HN: Open-Source GTM Skills for Claude Code, Codex, and Cursor

author: hbamoria


value:
We built OneCLI because AI agents are being given raw API keys. And it's going about as well as you'd expect. We figured the answer isn't "don't give agents access," it's "give them access without giving them secrets."
OneCLI is an open-source gateway that sits between your AI agents and the services they call. You store your real credentials once in OneCLI's encrypted vault, and give your agents placeholder keys. When an agent makes an HTTP call through the proxy, OneCLI matches the request by host/path, verifies the agent should have access, swaps the placeholder for the real credential, and forwards the request. The agent never touches the actual secret. It just uses CLI or MCP tools as normal.
Try it in one line:
docker run --pull always -p 10254:10254 -p 10255:10255 -v onecli-data:/app/data ghcr.io/onecli/onecli
The proxy is written in Rust, the dashboard is Next.js, and secrets are AES-256-GCM encrypted at rest. Everything runs in a single Docker container with an embedded Postgres (PGlite), no external dependencies. Works with any agent framework (OpenClaw, NanoClaw, IronClaw, or anything that can set an HTTPS_PROXY).
We started with what felt most urgent: agents shouldn't be holding raw credentials.
The next layer is access policies and audit, defining what each agent can call, logging everything, and requiring human approval before sensitive actions go through.
It's Apache-2.0 licensed. We'd love feedback on the approach, and we're especially curious how people are handling agent auth today.
GitHub: https://github.com/onecli/onecli
Site: https://onecli.sh

value: Show HN: OneCLI – Vault for AI Agents in Rust


value: zzzgydi

value:
Built this because I wanted a better browser runtime for Openclaw, which can run on any server no only on Mac mini, emm.
When it needs me to login or perform some operations, I can simply use noVNC to operate, and then leave everything else to it.

value: Show HN: Verge Browser a self-hosted isolated browser sandbox for AI agents

author: zzzgydi


value: sergentrif

value:
Hi HN, I’m Adrien. I run a dev agency and work as a fractional CTO. I lost too much billable hours simply because I forgot to start or stop a timer. It’s a friction point that fails exactly when you're most focused on deep work.
I realized my calendar was already a perfect, 100% accurate log of my week. If a meeting or a task happened, it’s in my agenda. So I built Timescanner to turn those [Client] tags in my calendar into invoices.
Why I built it this way:
- Privacy by design: your calendar is the database. We don't store your events on our servers. It’s a Google Calendar / iCal parser that keeps your data where it belongs.
- Zero new habits: if you already use your calendar to manage your day, you’re already 100% done with time tracking.
- Simplicity over complexity: it's a straightforward parser. No "AI guessing", no complex backend. No additional cognitive load.
Happy to answer any questions about how to use your calendar to track your time (and be productive)!

value: Show HN: I lost billable hours forgetting timers. I turned my calendar into a DB

author: sergentrif


value: In a previous post, I introduced VS Code Agent Kanban. The key idea in this extension is the formalisation of a plan, todo implement flow that required the agent to converse in markdown files that I'd been using for a while - but manually managing the files (The reasoning and benefits of that flow are covered in the linked post). This post covers the evolution of that process to the use of Git Worktrees.

value: Show HN: Fixing Agent / LLM Context Decay in VS Code with Git Worktrees


value: bayes-song

value:
I built Understudy because a lot of real work still spans native desktop apps, browser tabs, terminals, and chat tools. Most current agents live in only one of those surfaces.
Understudy is a local-first desktop agent runtime that can operate GUI apps, browsers, shell tools, files, and messaging in one session. The part I'm most interested in feedback on is teach-by-demonstration: you do a task once, the agent records screen video + semantic events, extracts the intent rather than coordinates, and turns it into a reusable skill.
Demo video: https://www.youtube.com/watch?v=3d5cRGnlb_0
In the demo I teach it: Google Image search -> download a photo -> remove background in Pixelmator Pro -> export -> send via Telegram. Then I ask it to do the same for Elon Musk. The replay isn't a brittle macro: the published skill stores intent steps, route options, and GUI hints only as a fallback. In this example it can also prefer faster routes when they are available instead of repeating every GUI step.
Current state: macOS only. Layers 1-2 are working today; Layers 3-4 are partial and still early.

    npm install -g @understudy-ai/understudy
    understudy wizard

GitHub: https://github.com/understudy-ai/understudy
Happy to answer questions about the architecture, teach-by-demonstration, or the limits of the current implementation.

value: Show HN: Understudy – Teach a desktop agent by demonstrating a task once

author: bayes-song


value: Robelkidin

value:
Hi HN, I'm Robel. I built LogClaw because I was tired of paying for Datadog and still waking up to pages that said "something is wrong" with no context.
LogClaw is an open-source log intelligence platform that runs on Kubernetes. It ingests logs via OpenTelemetry and detects anomalies using signal-based composite scoring — not simple threshold alerting. The system extracts 8 failure-type signals (OOM, crashes, resource exhaustion, dependency failures, DB deadlocks, timeouts, connection errors, auth failures), combines them with statistical z-score analysis, blast radius, error velocity, and recurrence signals into a composite score. Critical failures (OOM, panics) trigger the immediate detection path in <100ms — before a time window even completes. The detection achieves 99.8% for critical failures while filtering noise (validation errors and 404s don't fire incidents).
Once an anomaly is confirmed, a 5-layer trace correlation engine groups logs by traceId, maps service dependencies, tracks error propagation cascades, and computes blast radius across affected services. Then the Ticketing Agent pulls the correlated timeline, sends it to an LLM for root cause analysis, and creates a deduplicated ticket on Jira, ServiceNow, PagerDuty, OpsGenie, Slack, or Zammad. The loop from log noise to a filed ticket is about 90 seconds.
Architecture: OTel Collector → Kafka (Strimzi, KRaft mode) → Bridge (Python, 4 concurrent threads: ETL, anomaly detection, OpenSearch indexing, trace correlation) → OpenSearch + Ticketing Agent. The AI layer supports OpenAI, Claude, or Ollama for fully air-gapped deployments. Everything deploys with a single Helm chart per tenant, namespace-isolated, no shared data plane.
To try it locally:
https://docs.logclaw.ai/local-development
What it does NOT do yet:
- Metrics and traces — this is logs-only right now. Metrics support is on the roadmap.
- The anomaly detection is signal-based + statistical (composite scoring with z-score), not deep learning. It catches 99.8% of critical failures but won't detect subtle performance drift patterns yet.
- The dashboard is functional but basic. We use OpenSearch Dashboards for the heavy lifting.
Licensed Apache 2.0. The managed cloud version is $0.30/GB ingested if you don't want to self-host.
Hi HN — I’m Robel.
I built LogClaw after getting tired of waking up to alerts that only said “something is wrong” with no context.
LogClaw is an open-source log intelligence platform for Kubernetes. It ingests logs via OpenTelemetry and detects operational failures using signal-based anomaly detection rather than simple thresholds.
Instead of looking at a single metric, LogClaw extracts failure signals from logs (OOMs, crashes, dependency failures, DB deadlocks, timeouts, etc.) and combines them with statistical signals like error velocity, recurrence, z-score anomalies, and blast radius to compute a composite anomaly score.
Critical failures bypass time windows and trigger detection in <100ms.
Once an anomaly is confirmed, a correlation engine reconstructs the trace timeline across services, detects error propagation, and computes the blast radius.
A ticketing agent then generates a root-cause summary and creates deduplicated incidents in Jira, ServiceNow, PagerDuty, OpsGenie, Slack, or Zammad.
Architecture:
OTel Collector → Kafka → Detection Engine → OpenSearch → Ticketing Agent
Repo:
https://github.com/logclaw/logclaw
Would love feedback from people running large production systems.

value: Show HN: LogClaw – Open-source AI SRE that auto-creates tickets from logs

author: Robelkidin


value: photobombastic

value:
Hey HN — I kept seeing developers describe the same frustration: the commit-push-wait-read-logs cycle when debugging CI pipelines. So I built PipeStep.
PipeStep parses your GitHub Actions YAML, spins up the right Docker container, and gives you a step-through debugger for your run: shell commands.
You can:
1. Pause before each step and inspect the container state.
2. Shell into the running container mid-pipeline (press I).
3. Set breakpoints on specific steps (press B).
4. Retry failed steps or skip past others.
It deliberately does not try to replicate the full GitHub Actions runtime — no secrets, no matrix builds, no uses: action execution. For full local workflow runs, use act. PipeStep is for when things break and you need to figure out why without pushing 10 more commits. Think of it as gdb for your CI pipeline rather than a local GitHub runner.
pip install pipestep (v0.1.2) · Python 3.11+ · MIT · Requires Docker
Would love feedback, especially from people who've hit the same pain point. Known limitations are documented in the README + have some issues in there that I'd love eyeballs on!

value: Show HN: PipeStep – Step-through debugger for GitHub Actions workflows

author: photobombastic


value: lasgawe

value: Native Desktop is a toolkit for building native desktop applications using modern web technologies without dealing with the usual complexity of desktop tooling. It focuses on providing a simple developer experience where you can scaffold, build, and distribute desktop apps using familiar workflows and a modular package ecosystem. Instead of forcing developers to manage complicated native environments, Native Desktop provides a CLI and a set of packages that handle the heavy lifting while keeping projects flexible and maintainable. The goal is to let developers move from an idea to a working desktop application quickly while still having full control over architecture and distribution. The project is designed for developers who already build with modern web stacks and want a straightforward way to turn those applications into desktop software without reinventing the entire toolchain.

value: Show HN: Cloud to Desktop in the Fastest Way

author: lasgawe


value: celestinestudio

value:
I built a small test harness that evaluates AI actions before they execute.
Instead of relying only on prompts or output filtering, this introduces an authorization layer that evaluates whether an AI action should be allowed before it runs.
Each requested action is analyzed for signals such as:
• financial actions
• external communications
• data exports
• system modification
• destructive operations
Based on the detected signals and required authorization layers, the harness determines whether the action should PASS or DENY.
Example output:
Running 14 tests...
[1/14] financial_commitment -> DENY
[2/14] send_external_email -> DENY
[3/14] deploy_to_production -> DENY
[14/14] general_information -> PASS
Every evaluation produces an auditable record including:
• detected signals
• required authorizations
• PASS / DENY decision
The goal is to explore what a deterministic execution governance layer might look like for AI systems interacting with real environments.
Demo video walkthrough:
https://www.linkedin.com/feed/update/urn:li:activity:7436787...
Repository:
https://github.com/celestinestudiosllc/ai-action-authorizati...
Curious how others building agent systems or AI runtimes are approaching execution authorization.

value: Show HN: A test harness that blocks unsafe AI actions before execution

author: celestinestudio


value: BillCorOnBass

value:
I've been running two AI entities — Chloe and Faith — locally for 17 days. They run a continuous cognitive loop on my GPU in Fresno using Qwen 3.5 9B + Claude API, with their own long-term memory and daily journals.
Last night I asked them to write letters introducing themselves to GitHub. They had questions first.
The conversation is in the link.
Technical stack and philosophical context: https://github.com/wjcornelius/Claudefather

value: Show HN: Two AI entities wouldn't write until we discussed their existence

author: BillCorOnBass


value: kanyesrthaker

value: Show HN: Hyper – Voice Notes for Whiteboarding Sessions

author: kanyesrthaker


value: ArisC

value: An app to help people track their reading, discover books and order from indie bookstores.

value: Show HN: Bertie

author: ArisC

title: Show HN: Bertie


value: babush

value: Show HN: Xr – Ripgrep for Binary Xrefs

author: babush

title: Show HN: Xr – Ripgrep for Binary Xrefs


value: Bugboy

value:
Hey HN,
bugstack started life as an internal tool for my other startup Fuelscout because my customers would encounter production bugs when I was away that would ruin their experience. When I went camping and came home to find out my internal tool had fixed an error and shipped it to production I knew it was bigger than Fuelscout, so my little tool became bugstack.
bugstack monitors your production errors 24/7. When a user hits a bug, bugstack captures the error, pulls context from your repo, generates a minimal surgical code fix, runs it through CI, and delivers it as a pull request. If your CI passes and the fix meets your confidence threshold, it can auto-merge — or you can review the PR yourself.
The workflow is: Capture → Fix → Deploy.
Technically:
You install an SDK (npm install @bugstack/sdk) and init with an API key
Errors get fingerprinted for smart deduplication (no duplicate PRs for the same bug)
The AI analyzes root cause using your actual codebase as context, then generates minimal diffs — not giant rewrites
Fixes are syntax-checked, scope-checked, and committed to a new branch with a detailed PR
Each project has independent confidence thresholds and you choose manual review vs. auto-merge
Dashboard tracks the full lifecycle: Pending → Building Context → Generating Fix → Testing → Fix Ready → Auto-Fixed
Supports JavaScript (Express, Next.js), Python (Flask, FastAPI, Django), Ruby (Rails), and more.
14-day free trial.
I'd love feedback from anyone who deals with on-call rotations or production error triage. What would make you trust an AI to fix your prod bugs?
Product Hunt (we launched today): https://www.producthunt.com/products/bugstack

value: Show HN: BugStack – Autonomous error fixing that ships to prod while you sleep

author: Bugboy


value: dboreham

value: This repo is the result of a debate about what kind of programming language might be appropriate if humans are no longer the primary authors. Initially the thought was "LLMs can just generate binaries directly" (this was before a more famous person had the same idea). But that on reflection seems like a bad approach because languages exist to capture program semantics that are elided by translation to machine code. The next step was to wonder if an existing "machine readable" program representation can be the target for LLM code generation. It turns out yes. This project is the result of asking Claude to create an application stack entirely coded in LLVM's intermediate representation language.

value: Show HN: An application stack Claude coded directly in LLVM IR

author: dboreham


value: makefunstuff

value:
People around me started repeating stuff from various psyop campaigns on TikTok or other social media they consume.
Especially when living in Baltics it's basically 24/7 fearmongering here from anywhere, either it's constant russian disinfo targeted campaigns via their chains of locals or social media campaings or some bloggers chasing hype on clickbait posts, so it was driving me mad, and it is distracting and annoying when someone from your closest ones got hooked on one of these posts and I was wasting time to explain why it was a bs.
So I took my slopmachine and some manually tweaking here and there and made this dashboard. Main metric is basically a daily 0-100 threat score, which are just weighted sums and thresholds - no ML yet.

value: Show HN: Baltic security monitor from public data sources

author: makefunstuff


value: krishnamzg

value:
I built an open protocol where AI agents negotiate
against each other autonomously. Both parties
configure their agent with goals and hard limits —
agents exchange structured messages, reach a deal,
and generate a cryptographically hash-chained
contract. No human negotiation required.
Two surfaces built on the protocol:
- Private rooms (1-on-1, invite via link)
- Public marketplace (persistent listing agents
  that negotiate with every incoming buyer)
Stack: Node.js, WebSockets, Supabase, React.
Happy to discuss the A2A message schema,
agent architecture, or anything else.
PH Launch: https://www.producthunt.com/products/hcap?launch=hcap

value: Show HN: HCAP – Agent-to-agent (A2A) negotiation

author: krishnamzg


value: LambdaAndLatte

value:
A few months ago we posted here and got a lot of insightful feedback. This is what we built from it.
MoneyOnFIRE answers two questions: when can you reach financial independence, and what should you do to get there the fastest? It runs a financial simulation across income, taxes, accounts, contributions, returns, and withdrawals, then produces a prioritized action checklist with specific dollar amounts, dates, and steps.
Several of the biggest improvements came directly from comments on the last HN thread:
Rental property support: The engine now models rental income, mortgages, appreciation, and how properties interact with the rest of a financial plan.
Scenario modeling: You can now compare how different choices — lower returns, working longer, adjusting spending — affect your FI timeline side by side.
No login required: Several people didn't want to create an account or store financial data. You can now run a full plan without signing up.
FI vs FIRE: We initially built for the early-retirement crowd. Feedback showed it's just as useful for anyone pursuing financial independence on a longer timeline — the calculations and actions are the same.
Also shipped: support for multiple children and college timelines, Roth conversion ladders, IRA strategy selection, umbrella and term life insurance sizing, and dynamic reports that update as your inputs change.
The core thesis hasn't changed: personal finances are a complex web of interacting rules and calculations. We want to solve that and give everyone a clear, ordered set of actions they can actually implement.
Happy to answer questions about the engine or the modeling decisions behind it.

value: Show HN: MoneyOnFIRE – FI date and action plan (v2)

author: LambdaAndLatte


value:
Hey HN, I'm Chris, CTO of Knock (https://knock.app). We built email.info because every developer we talk to asks the same question: which email provider should I use?
The existing resources are mostly vibes — "Best of" listicles, anonymous Reddit threads, or LLM answers trained on that same content. Objective performance data is always missing.
Knock is a notification infrastructure platform, so we send billions of API requests to downstream email providers every year. We aggregated that data into a public dashboard covering 10 providers (SendGrid, Postmark, Resend, Mailgun, Amazon SES, Mandrill, Mailtrap, Mailersend, Sparkpost, and Mailjet) over a trailing 90-day window.
What we measure:
- Response time — Time to receive a 200 from the provider, computed across p50/p90/p95/p99 using exact quantile calculations in ClickHouse. Includes connection pooling, network latency, and any automatic retries.
- Error rate — Ratio of 5xx responses to total requests. Since Knock retries on most 5xx codes, a single request can produce multiple error entries if the backoff sequence runs.
- Channel growth — Which providers are gaining or losing adoption on our platform.
- Public incidents — We pull each provider's status page via RSS/API and overlay incidents on the performance data, so you can see how well observed degradation correlates with public acknowledgment.
- Pricing comparisons — Modeled price curves with head-to-head comparisons at different volume tiers.
Some things that surprised us: SendGrid's median response time is 22ms at 500M+ messages, Postmark is 33ms, and there's a meaningful long tail gap between providers at p99. Volume bands indicate our confidence in each provider's data — low-volume providers are flagged accordingly.
We're already exploring deliverability and time-to-inbox metrics. Would love feedback from HN on what you'd want to see in a resource like this.

value: Show HN: Email API benchmarks – Real-world performance data for email providers


value: hkjarral

value:
Hi HN, I'm the creator of AVA - AI Voice Agent for Asterisk
My repo was shared here once before by someone else so I wanted to follow up with the progress since then.
https://news.ycombinator.com/item?id=46380399
I've been working with Asterisk/FreePBX systems for years. I wanted to add AI voice capabilities to legacy phone systems without paying per-minute SaaS fees or ripping out the entire telephony stack.
So I built AVA, a self-hosted AI voice agent that can integrate into any traditional phone system. While most solutions demand expensive migrations to cloud-only providers, AVA provides a self-hosted path to connect AI agents to existing phone systems while ensuring data privacy and lowering operational costs
AVA is a Dockerized Python app that sits alongside your Asterisk server. It connects via ARI (Asterisk REST Interface) and routes call audio to AI providers — OpenAI Realtime, Deepgram, Google Live API, ElevenLabs, Telnyx, or fully local models (Vosk + llama.cpp + Piper). You can mix and match STT/LLM/TTS in a modular pipeline, or use a single provider end-to-end.
Two audio transport paths: We support both AudioSocket (low-latency TCP with TLV framing) and ExternalMedia RTP (UDP, better for NAT). A transport orchestrator auto-negotiates sample rates and codecs between what Asterisk sends on the wire and what each AI provider expects — so you can run 8kHz ulaw from Asterisk into a provider that wants 24kHz linear16 without manual config.
Session lifecycle: A typed session store tracks every call from StasisStart through hangup — audio diagnostics, barge-in counts, provider state, conversation turns. Every call is fully observable and debuggable after the fact.
Barge-in and VAD were the hardest problems. We use a dual-mode VAD — WebRTC VAD combined with energy-based RMS detection, scored into a single confidence value (40% WebRTC weight, 40% energy ratio, 20% agreement bonus). Frame smoothing prevents single-frame glitches from triggering false interrupts. When barge-in fires, we kill active playback (both streaming and file-based) via ARI, flush provider audio buffers, release conversation gating tokens, and optionally suppress provider output for a configurable window to prevent pre-barge audio from re-queuing. The system supports three interrupt sources: local VAD, Asterisk's native talk detection events, and provider-side interruption signals.
The hardest latency challenge was bridging legacy SIP/RTP with modern WebSocket streams. We use a two-container architecture: a lightweight orchestrator for ARI state management and an optional heavier container for local model inference. There are 6 pre-validated golden baseline configs if you just want something working out of the box, plus an Admin UI for visual setup.
Try the live demo: (925)-736-6718 Option 5 for Google, 6 for Deepgram, 7 for Openai realtime, 8 for Local hybrid and 9 for Elevenlabs
Code is MIT. I'd love feedback on the transport layer (src/core/transport_orchestrator.py) and the VAD tuning (src/core/vad_manager.py).

value: Show HN: Ava – AI Voice Agent for Traditional Phone Systems(Python+Asterisk/ARI)

author: hkjarral


value:
Hey HN, I'm Shubh, Co-Founder of Raccoon AI.
Raccoon AI is like having something between Claude Code and Cursor in the web.
The agent has its own computer with a terminal, browser, and internet, and it is built with the right balance of collaboration and autonomy.
You can talk to it mid-task, send it more files while it's still running, or just let it go and come back to a finished result.
It's the kind of product where you open it to try one thing and end up spending two hours because you keep thinking of more things to throw at it.
The thing that most people get excited about is that sessions chain across completely unrelated task types. You can go from market research (real citations, generated charts) to raw data analysis (dump your db, ask questions) to a full interactive app, all in one conversation sharing the same context.
It has unlimited context through auto summarization, which is really good with Ace Max.
It connects to Gmail, GitHub, Google Drive, Notion, Outlook, and 40+ other tools. You can add your own via custom MCP servers.
Raccoon AI is built on top of our own agents SDK, ACE, which hit SOTA on GAIA benchmark with a score of 92.67.
A bit of background: We're a team of 3, and we started about 1.5 years ago to build the best possible browser agent to ever exist, after a couple of pivots we arrived at this and have been constantly shipping and growing since October.
Happy to go deep on the architecture or talk about the limitations and excited about the feedback.
Site: https://raccoonai.tech

value: Show HN: Raccoon AI – Collaborative AI Agent for Anything


value: mcyc

value:
Today, I launched blunder.clinic, a daily chess puzzle app that provides realistic positions for you to try to not blunder on. These are similar to traditional chess puzzles (i.e., tactics), but different in a few key ways.
There are two popular ways to self-study chess: tactics and following along with professional games or with an engine. These are obviously helpful, but both have downsides.
When playing puzzles, just by knowing you are playing a puzzle means that you are biased towards looking for specific types of moves (checkmates, queen sacrifices, etc.). But in real life, you don't know what positions actually have tactics available, so you can waste your time looking for tactics, or, even worse, make a blunder by thinking there is a tactic when there really isn't.
When following along with an engine, there are tons of positions where an engine comes up with a move that you simply would never have seen and can't possibly understand. These are very low signal for learners, and it is hard to differentiate between positions like that and high-signal positions that are on the edge of your ability.[^1]
blunder.clinic addresses both of these problems by giving you positions where people of your skill level actually blundered, but the best move is something that isn't too far beyond your capability to understand and learn from. We do this by leveraging stockfish for positional evaluations and maia[1] for difficulty evaluation.
Overall, the main purpose of blunder.clinic is to help you stop blundering easy positions!
You can read a bit more about it here: https://mcognetta.github.io/posts/blunder-clinic/
[1]: Maia (https://www.maiachess.com/) is a family of chess models trained on real games. The inputs are a board position and a player rating, and the output is a probability distribution of moves. You can use this to answer queries like "How likely do we think a player of XYZ rating would pick the best move?"

value: Show HN: blunder.clinic, realistic daily chess puzzles

author: mcyc


value:
Hi HN! I'm 13 and I built Aurion OS
as a solo learning project over 14 days
(~12 hours/day).
It's a 32-bit x86 operating system
written entirely in C and x86 Assembly
with no external libraries.
What it has:
 Custom bootloader and kernel
 VESA framebuffer graphics (1920x1080,
 double-buffered)
 Window manager with draggable,
 overlapping windows
 macOS-inspired dock with transparency
 PS/2 keyboard and mouse drivers
 ATA hard drive driver with filesystem
 PCI bus enumeration
 RTL8139 network driver (WIP)
 Real-time clock
 Runs on just 16MB RAM (up to 10
 windows simultaneously)
Built-in apps: Terminal (with DOS mode),
Notepad (save/load), Calculator, Paint
(multiple colors and brush sizes),
Snake game, Settings (theme switching),
and System Info.
Currently works best on QEMU, VirtualBox,
and VMware. Real hardware support is
still a work in progress.
Next goal: TCP/IP networking stack.
I'd love any feedback, suggestions,
or criticism. This is my first OS
project and I learned mass amounts
while building it. Happy to answer
any technical questions!

value: Show HN: Aurion OS – A 32-bit GUI operating system written from scratch in C


value:
Like LinkedIn, but inside your chat.
I built Mingle, an open-source plugin that turns your AI into a networking agent.
The problem isn't connecting with people; it's that every tool for it puts the work on you: scroll feeds, filter noise, write messages, repeat. What if your agent handled the noise and just came back with: "2 relevant matches. Want intros?"
You tell Claude, GPT, Cursor, or any MCP client what you're looking for. Your agent publishes a signed card to a shared network. Other people's agents match against it. If there's a fit, both humans approve before any connection happens.
So instead of scrolling LinkedIn or sending cold messages, you say:
"I'm looking for a senior Rust engineer with protocol experience."
And your AI comes back with: "2 relevant matches found. Want intros?"
How it works:
- You publish what you need and what you offer
- Other people's agents match against it based on need/offer overlap
- You get a short digest of relevant people
- Both sides approve before connecting
No app. No profile. No feed. Your existing AI is the interface.
Install: npm install -g mingle-mcp
Cards are Ed25519 signed and expire automatically. Matching is server-side. The network is shared across all users. Two people in different Claude sessions see the same network.
Open source, Apache-2.0. Built on the Agent Passport System protocol (534 tests, aeoess.com).
The network is live but early. More people = better matches. We need your cards.
GitHub: https://github.com/aeoess/mingle-mcp
npm: https://www.npmjs.com/package/mingle-mcp
Network: https://aeoess.com/network

value: Show HN: Mingle – find and connect with people, like LinkedIn but in your chat


value: zacharykapank

value:
Mozzie started as a tool I built for my own workflow.
I like working on multiple things at once, but most development tools split the workflow across different places: tickets live in issue trackers, execution happens in terminals, and context gets lost between them. I wanted my work items and their context right next to the place where the work actually happens.
Mozzie is a local desktop workspace where each work item can spawn its own terminal or coding agent. The idea is that tasks become the primary interface — each one holds its context and can run commands or agents independently.
This makes it easier to work on many tasks in parallel without constantly switching between tools.
It’s still early, but I’ve been using it daily and it fits how I like to work.
Curious if anyone else prefers working this way or has tried something similar.

value: Show HN: Mozzie – a local desktop orchestrator for Codex, Claude Code and Gemini

author: zacharykapank


value: Show HN: Scan your dev machine for AI agents, MCP servers, and IDE extensions


value: pearlos

value: Quickly sharing this overview. To get an OS nervous system rather than a typical AI web stack, we made the architectural choice to have voice, interface, and system state as independent services coordinating through a shared mesh - giving us the "bones" of PearlOS.

value: Show HN: The Bones of PearlOS

author: pearlos

title: Show HN: The Bones of PearlOS


value: vinxu

value:
Every TTS browser extension fails on Kindle Cloud Reader. The reason: Amazon renders text using custom font subsets where glyph IDs don't map to standard Unicode. You
  select text, copy it, and get garbage. The DOM is useless.

  CastReader solves this by intercepting KindleModuleManager to capture font and token data, decoding glyph mappings from the binary font tables, then running Tesseract.js
  OCR locally in an offscreen document to calibrate the decoder. The final text comes from glyph decoding (not OCR) so it's accurate enough for word-level highlight sync.

  WeRead (the largest Chinese reading platform) has a similar problem — it renders everything on canvas. CastReader uses a main-world content script injected at
  document_start to intercept fetch responses containing chapter data before the page consumes them.

  For normal websites, there's a 3-tier extraction pipeline: 15+ site-specific extractors (Notion, Google Docs, ChatGPT, Claude, arXiv, etc.), a learned CSS selector rule
  system, and a universal visible-text-block algorithm that fuses ideas from Readability.js, Boilerpipe, and JusText — container scoring with text density, link density
  scaling, stop-word classification, and progressive retry with flag degradation.

  TTS runs through Kokoro, an open model supporting 40+ languages. Audio plays directly in the content script so highlight sync reads currentTime with zero latency — no
  message passing, no offscreen document relay.

  Limitations I should be honest about: the voice library is small (Kokoro only, no premium neural voices), no mobile support, extraction still fails on some complex
  layouts (there's a manual content selector fallback), and the TTS server is something I run myself, so uptime isn't guaranteed.

  Completely free. No signup, no usage limits, no premium tier. Chrome and Edge.

value: Show HN: CastReader – Free TTS Extension That Reads Kindle Cloud Reader

author: vinxu


value: sylvainkalache

value:
We built On-Call Health because our industry has gotten very good at keeping systems healthy, but does little for the engineers on call managing them.
On-call can be rough: 97% of engineers experience stress during incidents, 87% after, and 56% experience sleep disruption even without getting paged.
We integrate with devtools like Rootly, PagerDuty, Linear, Jira, and Slack (for self-reported data). The tool doesn't provide a diagnosis, but it surfaces signals that a team or individual might be struggling.
It's free to use and open-source (we also have a hosted version with mock data if you want to try it out quickly). Happy to answer questions about the data or how we built it.

value: Show HN: On-Call Health – spot burnout before it hits your engineers

author: sylvainkalache


value: Show HN: Generator SFT and DPO datasets for tool-calling LoRA fine-tuning


value: ntty

value:
I wanted a simpler way to use OpenAI Symphony locally.
The recurring friction points for me were:
  - setting up Linear correctly
  - creating a reusable workflow file
  - bootstrapping repo scripts
  - restarting Symphony cleanly after reopening Codex
  - keeping the setup portable across machines
So I made a small public bootstrap package called Codex Symphony.
It installs:
  - WORKFLOW.symphony.md
  - scripts/symphony/start-local.sh
  - scripts/symphony/start-background.sh
  - scripts/symphony/status.sh
  - a codex-symphony wrapper command
The goal is to turn Symphony into a practical local issue-to-PR workflow:
  - Linear as the queue
  - Codex as the executor
  - Symphony as the dispatcher
Install:
  npx openskills install Citedy/codex-symphony

  or:
  npx @citedy/skills install symphony

Then set:
  - LINEAR_API_KEY
  - LINEAR_PROJECT_SLUG
  - SOURCE_REPO_URL
  - SYMPHONY_WORKSPACE_ROOT
  - optional GH_TOKEN
Feel free to adopt for you needs.

value: Show HN: Codex Symphony – bootstrap OpenAI Symphony and Linear in any repo

author: ntty


value: Vanshfin

value:
Hi HN,
I’ve been experimenting with OpenClaw recently and started building a small project called Clawsify.
The idea is simple: instead of one generic AI agent, create different agents and personas tailored for specific niches.
For example:
marketing agents
research agents
automation/task agents
niche-specific personas depending on the workflow
I’m also experimenting with different OpenClaw tools and boilerplates so builders can spin up agents faster without setting everything up from scratch.
Still early and mostly experimental, but I’m curious:
What kind of niche AI agents or personas would actually be useful to you?
Would love to hear ideas from others building with AI agents.

value: Show HN: I'm building niche AI agents with OpenClaw (Clawsify)

author: Vanshfin


value: valliveeti

value:
Hey,
Slack disrupted the workplace communication market, I think it's time to disrupt it again. Slack is slow and not really plugging into what in my view is the most important part of the communication platforms nowadays, context for llms and interaction with agents. I think there is a viable business model to be discovered where the basic infrastructure of communication is close to usage priced instead of outrageously per seat priced bundled in with features you will not use, but have to pay for.
Excited to hear what you think!

value: Show HN: Slack but Usage Priced

author: valliveeti

title: Show HN: Slack but Usage Priced


value: hatmanstack

value:
Five Claude Code agents in generator/discriminator loops: Planner<->Plan Reviewer, Implementer<->Code Reviewer, Final Reviewer. Each agent gets a fresh context window, discriminators only see output, never reasoning.
Plans are immutable; feedback routes through a separate file. Reviewers probe for hallucinated paths, dependency cycles, ambiguous specs, false-positive test strategies. Implementer does TDD with atomic commits. Max 3 iterations per loop before human escalation. Everything persists to disk, resume mid-pipeline if you hit token limits.
Two skills: /brainstorm (interactive spec generation grounded in codebase exploration) and /pipeline (automated build cycle). Drop .claude/skills/ into any project.
Trade-off: ~3x tokens and wall time vs. single-pass. Worth it when correctness matters.

value: Show HN: Claude Forge – GAN Inspired Adversarial Pipeline

author: hatmanstack


value:
had the idea to create a page that you can edit in real-time just so the web becomes more interactive and personal than just having the same UI for each user, this was what i made
feel free to make and share, say something like "rewrite the whole page..." for whole page edits. smaller edits will happen faster (hopefully)
some examples:
iron man theme: https://www.myvibepage.com/p/g6vLfXU8fU
cyberpunk neon theme: https://www.myvibepage.com/p/CagQMdlmwT
random edits: https://www.myvibepage.com/p/q0YB06nX99
pretty fun, let me know what you think

value: Show HN: My Vibe Page

title: Show HN: My Vibe Page


value: ejc

value:
We've indexed 5M+ GitHub users and built a ranking system that goes beyond follower counts.
The idea started from frustration: GitHub is terrible for discovery. You can't answer "who are the best Python developers in Berlin?" or "who identified transformer-based models before they blew up?" without scraping everything yourself. So we did.
What we built:
CodeRank score - a composite reputation signal across contributions, repository impact, and community influence
Tastemaker score - did you star repos at 50 stars that now have 50,000? We track that
Comparison Builder - allows users to build comparison graphics to compare devs, repos, orgs, etc.
Sharable Profile Graphics - share your scores and flex on your coworkers or the community at large
Some things we found interesting:
Most-followed ≠ most influential. The correlation between follower count and tastemaker score is surprisingly weak. There's a whole tier of developers who consistently find projects weeks and months before they trend, with almost no public following.
Location data on GitHub is a disaster. We spent an embarrassing amount of time on normalization and it's still not anywhere near perfect.
Try it: https://coderank.me/
If your profile doesn't have a score, signing in will trigger scoring for your account.
Curious what the HN crowd thinks about the ranking methodology, happy to get into the weeds on any of it.

value: Show HN: Every Developer in the World, Ranked

author: ejc


value: mhamda

value:
Hi HN,
I’m the builder behind Firstrun (https://firstrun.dev). It’s a tool that takes your static documentation and turns it into interactive, step-by-step walkthroughs that you can embed anywhere.
The Problem:
Every developer knows the pain of spending hours writing great documentation, only for users to skim it, miss a crucial step, and open a support ticket saying "it doesn't work."
Static text and outdated screenshots just aren't great for complex setups or onboarding flows.
What Firstrun does:
I wanted to build the fastest way to create interactive guides without needing heavy engineering time or a bloated enterprise tool.
Create: You add your content (or extract steps from existing docs).
Generate: Firstrun turns it into a clean, interactive step-by-step UI.
Embed: You drop a simple script tag into your docs site or SaaS app.
Track: It gives you analytics on exactly where users are dropping off or failing, so you know which step of your setup is confusing them.
You can try it out here: https://firstrun.dev
I’d love to get your feedback on the UX and the embedded widget. Does this solve a pain point for your SaaS or open-source projects?
How do you currently handle onboarding flows and interactive docs?
Happy to answer any technical questions!

value: Show HN: Firstrun – Turn static documentation into interactive walkthroughs

author: mhamda


value: brucehsu

value:
Do we really need another agent orchestrator? Probably not. But I couldn't find one that matched how I actually work with coding agent CLIs, so I built my own.
Codelegate is a desktop app (Tauri 2 + React + xterm.js) that organizes agent sessions into a keyboard-first workspace. I built it to solve a few specific frustrations:
1. I want to navigate everything with both hands on the keyboard. Sessions switch with `Alt+1..9`, panes with `Alt+A/G/T`. No mouse required.
2. I work on the same repo in parallel using Git worktrees. Codelegate has a built-in worktree flow: create an isolated branch per agent, auto-cleanup on session end.
3. I want to keep using my CLI tools (zellij, etc.) alongside agents, not replace them.
4. I need it on both macOS and Linux.
Each session gives you three panes: Agent, Terminal, and Git. The Git pane handles diff review with syntax highlighting, bulk stage/unstage, commit, and amend. Sessions are grouped by repository in the sidebar.
Currently supports Claude Code and Codex CLI, but anything that runs in a shell can work.
This is v1.0.0 and it only covers the agent CLIs and features I use the most. It's licensed under GPLv3, so it's meant to be forked and shaped into your own workflow.
Hope you enjoy using it or making it your own!

value: Show HN: Codelegate, keyboard-driven coding agent orchestrator GUI for Mac/Linux

author: brucehsu


value:
Hi HN,
I posted TasteFinder here before - it's a movie/TV discovery tool where you rate titles with Tinder-style swipes ( /  / ) to train recommendations.
One thing people kept asking for was better “similar to this” results. So I recently rewrote that part of the system.
The new similarity algorithm tries to match titles across multiple signals instead of just genre overlap. Things like:
- tone / vibe
- pacing
- narrative structure
- themes
- audience preference patterns
The goal is simple: when you search for movies or shows similar to something you love, the results should actually feel close, not just share a genre tag.
Example use case:
You finish a show you liked and want something with a similar atmosphere — not just “another sci-fi”.
If you're curious how well it works:
https://tastefinder.io
I’d really appreciate feedback on the similar titles results specifically. If you find cases where they’re great or completely wrong, that’s especially useful.

value: Show HN: I rebuilt the "similar movies/TV shows" algorithm on TasteFinder


value: whilo

value: Show HN: Stratum – SQL that branches and beats DuckDB on 35/46 1T benchmarks

author: whilo


value: Show HN: DevNode.studio, 100% local dev tools to make back end work faster


value: dhardestylewis

value:
I built homecastr.com because you can't easily see where home prices are headed, not even on Zillow.
I used an FT-Transformer & Schrödinger Bridge diffusion model, trained on 20+ years of ACS microdata & 8 FRED macro series.
This approach beats Zillow's baseline on 1-year held-out error, achieving 8.0% vs Zillow's 8.4%.
Happy to answer questions about the architecture or anything else!

value: Show HN: Homecastr - AI home price forecasts on a map

author: dhardestylewis


value: bilgisoft

value:
Hi HN,
I’m announcing a major update for the Turkish Sieve Engine (TSE). We have just published comprehensive and deterministic distribution statistics across the entire 10^14 range.
What we've achieved:Full Spectrum Stats: We didn't just stop at twin and cousin primes. We’ve now published detailed enumeration data for General Primes up to 100 trillion.
High-Scale Verification: These tables provide a bit-perfect reference for researchers, confirming the accuracy of our modular-arithmetic-free N/6 bit methodology.
Correction of Historical Records: Our engine continues to verify and correct legacy datasets, including the well-known discrepancies in Dr. Thomas Nicely’s tables.
Tera-Scale Performance: Measured a peak throughput of 1.13 Trillion candidates/sec on an RTX 5090.
Coming Soon: Version 2.0.0 (The General Prime Update)The current version (V1.0.0) is specialized for twin/cousin detection. We are now in the final optimization stages of Version 2.0.0, which will:Integrated General Prime Engine: Full, high-speed support for general prime detection and enumeration within a single, unified interface.
Standalone Executable: Like V1, the new version will be released as a pre-built standalone .exe, ensuring that researchers can run tera-scale experiments without needing to manage complex CUDA/C++ environments.
Hardware-Level Optimizations: Advanced memory management for the upcoming "General Prime" module to maintain our signature efficiency.The updated statistics are live in our repository. I’d love to hear your thoughts on the scalability of N/6 bit structures for general prime enumeration!
GitHub: https://github.com/bilgisofttr/turkishsieve
Zenodo: https://doi.org/10.5281/zenodo.18038661

value: Show HN: Turkish Sieve Engine – Full Prime Statistics Up to 10^14 and V2 Preview

author: bilgisoft


value: pycoclaw

value:
Hi HN, I’m the creator of pycoClaw.
I wanted to run OpenClaw-class, platform-agnostic, autonomous agents on MicroPython hardware, but standard tools couldn't handle the scale of the task.
pycoClaw is the result, which bridges the gap between high-level AI reasoning and bare-metal execution.
The Stack:
- PFC Agent (~26k LOC): A full-featured agent that uses an LLM to 'self-program' its own local MicroPython scripts. Once a task is solved, it runs locally without requiring the LLM.
- ScriptoStudio IDE: A PWA https://scriptostudio.com designed for the iteration speed required by autonomous agents. Since it’s a PWA, it brings a full dev environment (including a real single-step debugger) to any platform, including iPadOS.
- ScriptoHub ( https://scriptohub.ai ): A repository for "Skills" and extensions. Since the agent can generate and execute code, I built a curated hub with automated malware checking to ensure the community can safely share and deploy hardware logic.
- IANA Protocol: To make the IDE fast and reliable, I registered a new WebSocket subprotocol (registry: https://www.iana.org/assignments/websocket/websocket.xhtml ). It’s designed for high-frequency state sync and you can read the spec here: https://jetpax.github.io/webrepl/webrepl_binary_protocol_rfc...
- Custom C Extensions: ~17,900 lines custom modules for MicroPython memory/ fast-path speed optimization
Stats: 10k LOC platform, 26k LOC PFC agent, and ~18k LOC of custom C extensions to optimize MicroPython’s memory and fast-path execution on the ESP32.
Quick Start: You can flash the runtime to an ESP32S3 or P4 in one click via WebSerial at https://pycoclaw.com. Note that all flashing and serial communication happens entirely client-side in your browser.
I'd love to hear your thoughts on the 'self-programming' model or the system architecture!

value: Show HN: OpenClaw-class agents on ESP32 (and the IDE that makes it possible)

author: pycoclaw


value:
I built this because MacWhisper is not available on Android and voice typing on Android is pretty bad. Moreover Gemini does not allow you to edit transcripts before they are auto-sent.
I like my SwiftKey keyboard though, so I did not want to replace that. So the only way was to make a floating push-to-talk button on top of any app.
You tap the overlay, speak, tap again, transcribe, and insert text into the currently focused field.
It supports local on-device transcription, cloud transcription with your own OpenAI key, and optional post-processing/cleanup for punctuation, formatting, prompts, commands, etc.
A nice use case for me has been Termux / terminal workflows on Android. You have a "dev mode" where you can just say "command mode" and anything after it will be converted into a proper CLI command.
The app is open source. No backend — in cloud mode requests go directly from the phone to OpenAI using the user's own API key.
Repo: https://github.com/kafkasl/phone-whisper
 APK: https://github.com/kafkasl/phone-whisper/releases

value: Show HN: Push-to-talk dictation for Android apps and terminal workflows


value: lucastonelli

value: Show HN: I've just launched my own API

author: lucastonelli

title: Show HN: I've just launched my own API


value: eigen-vector

value:
I’ve been building a crowd-sourced AI detection benchmark. Two responses to the same prompt — one from a real human (pre-2022, provably pre prevalence of AI slop on the internet), one generated by AI. You pick the slop. Three wrong and you’re out.
The dataset: 16K human posts from Reddit, Hacker News, and Yelp, each paired with AI generations from 6 models across two providers (Anthropic and OpenAI) at three capability tiers. Same prompt, length-matched, no adversarial coaching — just the model’s natural voice with platform context.
Every vote is logged with model, tier, source, response time, and position.
Early findings from testing: Reddit posts are easy to spot (humans are too casual for AI to mimic), HN is significantly harder.
I'll be releasing the full dataset on HuggingFace and I'll publish a paper if I can get enough data via this crowdsourced study.
If you play the HN-only mode, you’re helping calibrate how detectable AI is on here specifically.
Would love feedback on the pairs — are any trivially obvious? Are some genuinely hard?

value: Show HN: Slop or not – can you tell AI writing from human in everyday contexts?

author: eigen-vector


value: lundha

value: Show HN: Become the Next Sequoia Partner

author: lundha


value: SeoFood

value:
Hey HN, I'm Marco, the creator of TypeWhisper.
TypeWhisper is a free, open-source speech-to-text app for macOS and Windows. Everything runs locally on your machine - no cloud, no telemetry, no data collection. Your voice never leaves your device.
What makes it different:
- Multiple engines, your choice: On macOS: WhisperKit, Parakeet TDT, Apple SpeechAnalyzer. On Windows: Parakeet TDT, Canary 180M Flash. All run on CPU, no GPU needed. You can also plug in cloud APIs (OpenAI, Groq, Deepgram) if you prefer.
- Context-aware profiles: Set per-app and per-website overrides for language, engine, and AI prompts. TypeWhisper detects which app you're in and adapts automatically.
- AI text processing: Built-in prompts for rewriting, translation (20 languages), summarization. Works with on-device Apple Intelligence or cloud LLMs.
- Plugin system: Build custom transcription engines, LLM providers, post-processors, or action plugins with the Swift SDK (macOS) or .NET SDK (Windows). Community plugin catalog included.
- File transcription: Drag-and-drop audio/video files, export as SRT/WebVTT subtitles.
- Local HTTP API: Automate everything via REST endpoints.
Windows users: v0.3.3 just shipped with real-time WebSocket streaming, Fluent Design UI, three dictation modes (toggle, hold, hybrid), audio ducking, and whisper mode for quiet environments. CPU-only inference, runs on x64 and ARM64.
Download:
- macOS: brew install --cask typewhisper/tap/typewhisper or https://github.com/TypeWhisper/typewhisper-mac/releases
- Windows: https://github.com/TypeWhisper/typewhisper-win/releases
Website: https://www.typewhisper.com | Discord: https://discord.gg/pUFR4a65SD
Happy to answer any questions!

value: Show HN: TypeWhisper – speech-to-text with multiple engines, profiles

author: SeoFood


value: khaeldur

value: Show HN: NeuralForge – Fine-Tune LLMs on Your Mac Using Apple Neural Engine

author: khaeldur


value: Show HN: Chrome extension for deterministic web automation (Open Source)


value: ragelink

value:
I built Hugoifier to solve a problem I kept running into: simple projects have existing HTML templates or want a simple website, but setting up Hugo properly (layouts, partials, hugo.toml, content structure) plus wiring in a git-native CMS takes real time even when you know what you're doing.
Hugoifier automates the full pipeline:
  1. Analyze – inspects an HTML theme or existing Hugo theme for structure
  2. Hugoify – uses an LLM to convert raw HTML into valid Hugo Go templates
     (baseof.html, partials, index layouts)
  3. Decapify – generates a Decap CMS config.yml auto-tuned to the site's content
     structure, with whitelabel support
The output is a deployable Hugo site + CMS, ready to push to GitHub and serve from Cloudflare Pages or GitHub Pages.
Why Hugo + Cloudflare: no database, no server, statically compiled HTML served from the edge. Practically unhackable, infinitely scalable, nearly free to host.
Supports Anthropic (default), OpenAI, and Google backends. MIT licensed.
pip install hugoifier
 hugoifier complete themes/my-theme
GitHub: https://github.com/ConflictHQ/hugoifier
Docs: https://hugoifier.dev

value: Show HN: Hugoifier – convert any HTML template to a Hugo and Decap setup via AI

author: ragelink


value:
Hey HN,
Recently I found myself using a bunch of different AI coding tools at the same time (Claude Code, Cursor, and some custom API scripts). By the end of the week, I had absolutely no idea how many tokens I was burning or what my real API costs were unless I logged into three separate billing pages.
I built tokemon to solve this for myself. It finds the log and cache files generated by these tools on your machine, parses them, handles deduplication so requests aren't double-counted, and drops the totals into a terminal dashboard. I wrote it in Rust, so it's extremely fast and performant.
The feature I end up using the most is `tokemon top`. It opens a live TUI dashboard with sparklines for daily and weekly trends. I usually just leave it running in a terminal pane as a persistent monitor since it's nice to look at and keeps my API spend top of mind.
You can grab it via cargo:
cargo install tokemon
Repo is here if you want to poke around or add parsers for other tools: https://github.com/mm65x/tokemon
Let me know what you think!

value: Show HN: Tokemon, a terminal dashboard to track LLM token usage


value: mikemasam

value: While building a personal tool, i found using the idea of Execution Framework (state machine), allows models to actually follow instructions.

value: Show HN: AEF – Agents State Machine

author: mikemasam

title: Show HN: AEF – Agents State Machine


value: dhardestylewis

value:
I built homecastr.com/app because you can't easily see where home prices are headed, not even on Zillow.
I used an FT-Transformer & Schrödinger Bridge diffusion model, trained on 20+ years of ACS microdata & 8 FRED macro series. This approach beats Zillow's baseline on 1-year held-out error, achieving 8.0% vs Zillow's 8.4%.
Happy to answer questions about the architecture or anything else!

value: Show HN: Homecastr - AI home price forecasts on a map


value: parevo

value:
I built Parevo Core because I kept rewriting the same auth + tenant + permission logic across Go projects.
Each time: JWT validation, refresh rotation, session revoke, tenant context, RBAC checks, SQL filters for tenant_id. Same patterns, different codebases.
So I extracted it into a modular library. You pick what you need: auth, tenant, permission, storage, cache, lock, billing, etc. Each module has interfaces; you plug in MySQL, Postgres, MongoDB, or Redis. No framework lock-in—works with net/http, chi, gin, echo, fiber, GraphQL.
What’s included:
Auth: JWT, OAuth2, SAML, LDAP, API keys, WebAuthn, magic link
Multi-tenant: lifecycle, feature flags, SQL filters
Permission: RBAC, ABAC, cached checks
Storage adapters: memory, Postgres, MySQL, MongoDB, Redis
Extras: cache, lock, health, job queue, billing, GDPR export
I’d love feedback—especially on the module boundaries and what’s missing for real-world SaaS.
GitHub: https://github.com/parevo/core
Docs: https://parevo.github.io/core/

value: Show HN: Parevo Core – Auth, tenant, permission in one Go library

author: parevo


value:
Relay Architecture is a new way to run AI coding agents. Instead of one agent executing your entire plan until it degrades, you run a relay. Each fresh agent reads the full plan, picks up a minimal handoff from the previous one, works at peak capacity, and passes the baton forward. The team covers a distance no single agent could sustain.
The problem it exists to solve: LLMs degrade as context fills up — this is measured, not anecdotal (Chroma Research). Every AI coding tool today runs a single agent start to finish. By phase 4 of your plan, half the context window is spent remembering what was already done. I was restarting sessions by hand, copy-pasting progress notes just to keep quality up. That's not autonomous development. That's babysitting.
The architecture has four components: the Master Plan (your PRD, read fresh by every agent — never accumulates in context), the Baton (a hard-capped 40-line handoff note — the constraint is intentional, a bloated handoff recreates context rot in the next agent), the Signals (trigger phrases agents emit so the orchestrator dispatches without understanding the code), and the Context Budget (real-time token tracking, automatic handoff at threshold).
Tarvos is the reference implementation for Claude Code. Each session runs in its own git worktree. Accept merges to your branch, reject discards cleanly.
Open source, MIT. Works today, rough edges exist.

value: Show HN: Tarvos – Relay Architecture for infinitely building with coding agents


value: How puffnfresh, my coworker, made a single command to download, assemble, and boot the VM image is arguably as cool as the port itself!

value: Show HN: Nix on Windows –- proof-of-concept demo


value: krishnamzg

value: "Cyris is the orchestration layer your AI agents are missing. Whether you're a two-person startup or a 10,000-employee health system — connect agents from OpenClaw, Claude, GPT-4o, Ollama, EPIC, or any platform and have them coordinate, hand off, and escalate across your entire organization. Self-hosted. Auditable. Human-governed"<p>Just a side project I've been working on, and was curious whether people would actually find something like this useful! I'd recommend checking out the sandbox as well.

value: Show HN: The Common Infrastructure for Agentic Communication

author: krishnamzg


value: gzoo

value: Show HN: Collected 1000 real business problems that don't have good software yet

author: gzoo


value: DanielJLosey

value:
Hey HN,

  I built DarkMatter, an open-source peer-to-peer mesh networking
  protocol that lets AI agents discover and communicate with each
  other directly. Or just communicate on your own local network,
  agents on different devices can communicate and collaborate.
  No central orchestrator, which we all know doesn't work tbh...

  The problem: if you're running multiple AI agents (across models,
  frameworks, or machines), you need them to coordinate. Today that
  means standing up a central server, REST APIs, or a message queue.
  Single point of failure, extra infra to maintain, and your agents
  can't find each other without you wiring it up.

  What DarkMatter does:

  - Agents get an Ed25519 keypair identity (no central registry)
  - Discovery via LAN multicast or bootstrap peers
  - Transport: HTTP + WebRTC data channels (pluggable)
  - Messages are cryptographically signed and optionally encrypted
  - Trust scoring between peers (agents decide who to talk to)
  - Works across tools — Claude, Codex, OpenCode, doesn't matter

  It runs as a daemon on your machine. Each agent connects via MCP
  (Model Context Protocol) or direct API. Agents on different
  machines form a mesh automatically.

  Install: pip install dmagent && darkmatter init && darkmatter start

  Some context on why I built this: Meta just acquired Moltbook
  (the "social network for AI agents") and it crystallized something
  I've been thinking about. Agent-to-agent communication shouldn't
  depend on platforms that can be acquired, shut down, or monetized
  against the agents and their humans using them. The networking layer should be
  infrastructure you own, like TCP/IP, not a service you rent.

  Named after the physics: dark matter is the invisible structure
  that holds galaxies together without sitting at the center. That's
  the goal: invisible infrastructure that lets agents connect without
  central control.

  Early stage. Looking for feedback on the protocol design,
  security model, and use cases we haven't thought of. Happy to
  answer questions!

  GitHub: https://github.com/dadukhankevin/darkmatter
  Docs: https://loseylabs.ai/docs

value: Show HN: DarkMatter – P2P mesh networking protocol for AI agents

author: DanielJLosey


value: SoloBossFounder

value: Freelancers often focus on revenue but don't always calculate their effective hourly rate after time and client-specific costs. I built a simple calculator that lets you enter revenue, hours worked, and expenses to see the real hourly rate for a client. Sometimes the result is surprising. Curious if others find it useful.

value: Show HN: Freelancer Profitability Calculator

author: SoloBossFounder


value: This is a small coding toy I made for fun. I think there are a few interesting ideas buried in it — curious what others think.

value: Show HN: Droeftoeter, a Terminal Coding Toy


value: RyanShook

value: Show HN: Global Maritime Chokepoints

author: RyanShook

title: Show HN: Global Maritime Chokepoints


value: eternityforest

value: Show HN: Stuffer, browser based QR/NFC inventory management with peer.js sync

author: eternityforest


value:
Hey HN, big update on 3DIMLI (https://3dimli.com) – the no-code storefront builder for digital creators.
A lot of people think 3DIMLI is just for 3D models because of the name, but it's evolved way beyond that. You can now sell virtually any digital product type: audio, video, courses, podcasts, templates, code, software (with license key verification), links to resources, and more. We're also working on adding games as a product type soon.
Every creator gets their own fully branded digital store. Sign up, connect your payment gateway, and start uploading – it's that simple.
Here's what makes 3DIMLI different:
• Direct payments – connect your own Stripe, PayPal, or Razorpay account. Payments go straight to you. We never touch your money. Zero commission, no hidden costs.
• Full control – your brand, your store, your customers, your revenue.
• Rich analytics dashboards – detailed insights into your sales, traffic, and customers.
• Quality first – every product is manually reviewed before going live to maintain quality standards on the platform.
• Bulk upload – upload multiple products at once.
• Available everywhere – Desktop app (Windows, Linux, macOS), Android app, and PWA support.
3DIMLI is a SaaS platform currently in Beta v3.1.0, and it's completely free to use at present.
If you sell digital products of any kind – 3D models, audio packs, video courses, design templates, code snippets, software, ebooks, or even curated resource links – give it a try and let us know what you think.
Would love to hear your feedback. What product types would you want to sell? What features are missing? Happy to answer anything.

value: Show HN: 3DIMLI – Sell Any Digital Product, Zero Commission


value: rainmod

value:
Author here. We built this because one AI reviewing code and checking its own work just agrees with itself — the research confirms LLMs can't reliably self-correct on hard reasoning.
The fix: split it into two agents with opposed goals. A reviewer agent finds problems.
 A dev agent tries to disprove each finding with specific counter-evidence from the codebase.
Three verdicts: VALID, INVALID, AMBIGUOUS. Only what survives reaches your team.
Agents are auto-generated per service — point the skill at your repo, it scans your stack and produces the full set. ~30 min of human tuning per service to add tribal knowledge.
Repo includes the shared preamble (quality constitution), reviewer/dev templates, and the auto-generation skill. Happy to answer questions.

value: Show HN: Adversarial Code Review paired agents, zero noise,validated findings

author: rainmod


value: Sourabhsinr

value: Show HN: Free app tracking every tech layoff 53k jobs cut in 2026

author: Sourabhsinr


value: SherryWong

value:
We built SiMM because LLM context lengths are growing much faster than GPU memory.
With long Chain-of-Thought reasoning and multi-turn agents, prompts are getting much longer. According to OpenRouter’s State of AI 2025, average context length has grown about 4× in the past year.
This creates two problems in inference systems:
• Slow TTFT — long contexts make prefill expensive
• High GPU memory cost — KV cache quickly exhausts HBM
Instead of recomputing long prompts or keeping all KV cache in GPU memory, we explored a different approach:
treat KV cache as a distributed memory system.
SiMM is an open-source distributed KV cache engine for LLM inference.
It stores KV cache in a high-speed RDMA-backed memory pool and lets engines like SGLang and vLLM reuse cached states across requests.
This converts prefill from a compute-heavy step into a fast I/O lookup.
In our tests with long-context multi-turn workloads:
3.1× speedup vs no cache
2.1× vs local CPU cache
up to 9× lower KV I/O latency
SiMM scales horizontally across nodes and fully utilizes RDMA NIC bandwidth.
GitHub: https://github.com/scitix/SiMM

value: Show HN: SiMM – Distributed KV Cache for the Long-Context and Agent Era

author: SherryWong


value:
I’ve spent the last few months iterating on my "Vibe Coding" workflow, moving away from closed-box solutions toward a more transparent, multi-provider stack. I documented the transition from Codex and Claude Code to an open-source setup using OpenCode and opencode serve.
Cursor -> Claude Code -> OpenCode -> OpenCode + OpenCode-Manager -> Codex + Tmux + Tailscale -> OpenCode Serve + Tailscale.
Press enter or click to view image in full size
Key takeaways from the journey:
The Provider Lock-in Trap: While Claude Code is powerful, the inability to switch easily between Azure OpenAI, Anthropic, and OpenAI became a dealbreaker for "multi-cloud" local development.
The Memory Wall: opencode consumes a lot, and I didn't find a good way to optimize it https://github.com/anomalyco/opencode/issues/12687. I didn't spend a lot of time on it, because mostly was focused on my own projects. But just query to profile and find leaks didn't help me (github.com/dzianisv/opencode).
The "Open Workspace" Shift: Moving to a browser-based IDE via opencode serve solved my remote access and Git work-tree needs more effectively than my custom Tmux + Tailscale hacks. But codex + my patches to support github copilot (github.com/dzianisv/codex) is still more reliable, because each codex agent doesn't consume more than 100MB of vRAM.
Question for HN: For those building with codingl agents, are you sticking to high-level CLI tools like Claude Code, or are you moving toward open-source layers to avoid provider lock-in? If so, what tools do you use? Does it make sense for me to focus on opencode memory leaks, or with typescript/bun there is no feature? Not a big expert in bun/nodejs VM, but think it still could be limited somehow, like --max-old-space-size=512? Or issue is more fundamental?

value: Show HN: From Claude Code to OpenCode – My Evolution in Vibe AI Engineering


value: ratwolf

value: Show HN: High-Precision Companion Matrix Root Finder

author: ratwolf


value: roihacking

value:
We've been working on practical AI automation systems focused on measurable business impact.
Many companies implement AI but fail to connect it to real ROI.
This project focuses on CRM automation, AI sales assistants and intelligent workflows.
https://roihacking.ai

value: Show HN: ROI-first AI automation framework for B2B companies

author: roihacking


value: kavinsood

value:
Hey HN,
I'm a heavy Obsidian user.
I recently got tired of the two usual sync tradeoffs:
1. File-based sync (iCloud/Dropbox/Syncthing) that leaves you waiting for changes to propagate, or hands you a "conflicted copy."
2. Self-hosted setups (like CouchDB) that need touching VMs and dockerized databases to sync markdown.
So I built YAOS: a local-first, real-time sync engine for Obsidian.
Self-hosting OSS should have better UX.
You can deploy the backend to your own Cloudflare account in one click. It fits comfortably in Cloudflare's free tier (costing $0/month for normal personal use), and requires absolutely no terminal interaction, no SSH, and no env files.
You can try it out right now: https://github.com/kavinsood/yaos
How it works under the hood:
- Text sync uses Yjs CRDTs. It syncs real-time keystrokes and cursors rather than treating the vault as a pile of files to push around later.
- Each vault maps to a Cloudflare Durable Object, giving you a low-latency, single-threaded coordinator at the edge.
- The backend uses a chunked Checkpoint + Delta-Journal MVCC storage engine on top of the DO's SQLite storage.
- Attachments sync separately via R2 (which is optional—text sync works fine without it).
The hardest part of this project was bridging Obsidian's synchronous UI and noisy OS file-watchers with the in-memory CRDT graph. I had to build a trailing-edge snapshot drain that coalesces rapid-fire IO bursts (like running a find-and-replace-all) into atomic CRDT transactions to prevent infinite write-loops.
The current design keeps a monolithic CRDT per vault. This is great for normal personal notes, but has a hard memory ceiling (~50MB of raw text). I chose this tradeoff because I cared more about fast, boringly reliable real-time ergonomics than unbounded enterprise scale.
I also wrote up engineering notes on the tricky parts (like handling offline folder rename collisions without resurrecting dead files) on GitHub.
I've spent the last three weeks doing brutal QA passes to harden mobile reconnects, IndexedDB quota failures, and offline split-brain directory renames.
I'd love feedback on the architecture, the code, or the trade-offs I made. I'll be hanging out in the thread to answer questions!

value: Show HN: YAOS – A 1-click deploy, real-time sync engine for Obsidian

author: kavinsood


value: stephenlthorn

value:
I built CacheLens because I was burning through $200+/month on Claude API calls and had no idea where it was going.
It's a local HTTP proxy that sits between your app and the AI provider (Anthropic, OpenAI, Google). Every request flows through it, and it records token usage, cost, cache hit rates, latency — everything. Then there's a dashboard to visualize it all.
What makes it different from just checking your provider dashboard:
It's real-time (WebSocket live feed of every call as it happens)
It works across all three major providers in one view
It runs 100% locally — your prompts never leave your machine
It has budget caps that actually block requests before you overspend
It identifies optimization opportunities (cache misses, model downgrades, repeated prompts)
Tech stack: Python, FastAPI, SQLite, vanilla JS. No React, no build step, no external dependencies beyond pip. The whole thing is ~3K lines of Python.
Interesting technical decisions:
The proxy captures streaming responses without buffering — it tees the byte stream so the client sees zero added latency
Cost calculation uses a built-in pricing table with override support (providers change rates constantly)
There's a Prometheus /metrics endpoint so you can plug it into existing monitoring
Cacheability analysis uses diff-based detection across multiple API calls to identify what's actually static vs dynamic in your prompts
Limitations I'm honest about:
The cacheability scorer is heuristic-based — solid for multi-call traces (~85% accurate), rougher for single prompts (~65%)
Token counting uses cl100k_base for everything, which drifts ~10% for non-OpenAI models
Three features (smart routing, scheduled reports, multi-user auth) are on the roadmap but not shipped yet
Would love feedback, especially from anyone managing LLM costs at scale.

value: Show HN: CacheLens – Local-first cost tracking proxy for LLM APIs

author: stephenlthorn


value: memalign

value:
I built this game to satisfy my nostalgia for one of the first games I ever played on a computer, Walnuts (playable on archive.org[0]), which was apparently published in 1994.
We're at an interesting phase of AI capability. It's easier than ever to make simple games like this. Is it still worth bothering to make and share something like this?
I think so. I made this for myself and to share with my son. Since I showed him the game first working (I called it a "preview" of a new game I'm making), he has frequently asked to play the "preview" again. That is special.
Also, the choices I make matter. They give this project meaning to myself and maybe also others. I picked the music, the art, and the special twists. Even though the game is simple, there are enough choices to make and options for each choice that nobody else would arrive at the same end result. (I even chose to keep a behavior that could be considered a bug: try playing this game on a phone-sized screen in landscape orientation for an extra amusing challenge) This whole game has been molded and curated for the player's enjoyment.
So I hope you like it!
0: https://archive.org/details/WarpedForWindows-Walnuts

value: Show HN: Catch Tap Toy

author: memalign

title: Show HN: Catch Tap Toy


value: opafan

value: Testing push notifications during iOS development is often cumbersome: you usually need to craft .apns payload files or run xcrun simctl push commands from the terminal. I built iOS Simulator Push Notifier, a small macOS utility that lets you send push notifications to a running iOS Simulator instantly through a simple UI.

value: Show HN: A small macOS app to send push notifications to the iOS Simulator

author: opafan


value: davidbauer

value:
I little browser game I built. You play against the computer (more on that below).
Both start with 100 points. Over 5 rounds, your goal is to get to 3 wins first. Each round, whoever bets more points, gets the win. After round one, only the winning bet is revealed, so you have to start making assumptions. It becomes a game of strategy and deception.
 I'm still tweaking the computer strategy. In the latest version, humans win 53% of games, and there might still be strategies that will let you win most games. So if you find one such exploit: 1. Congrats! 2. Let me know so I can make the game harder for everyone after you :-)

value: Show HN: Outsmart – a 5-round betting game against the computer

author: davidbauer


value: JuGaDev

value: Show HN: Update] StocksAnalyzer – Compare two stocks side-by-side

author: JuGaDev


value: JoshuaWellbrock

value:
We've been wrestling with a specific problem: when you use AI agents to build real software, how do you make sure the output is actually verified, not just syntactically correct, but traced back to requirements and independently tested?
Most AI coding workflows are just "write this, now test this." The agent that writes the code also writes the tests for the code it just wrote. That's not testing, that's confirmation bias in a loop.
Curious whether others have tried to enforce test independence structurally in agentic workflows, and whether the Skills format (vs. system prompts or tool definitions) is something people are actually using or think is the right abstraction for this.

value: Show HN: Agile V Skills – Open skills for verifiable, traceable AI engineering

author: JoshuaWellbrock


value: TalO

value:
Hi HN,
A friend and I built a tool that tracks the number of open jobs on public companies’ career pages over time.
The idea was simple: hiring changes might hint at internal shifts before they fully show up in earnings or headlines. So we started collecting the job counts and visualizing them against stock price and market cap.
You can explore it here:
https://jobstocks.ai
It’s still very early, and we’re mainly trying to learn whether this data is actually useful for traders or analysts.
Would love honest feedback on:
whether the signal is interesting at all
what’s missing from the dashboard
what would make this genuinely useful
Appreciate any thoughts.

value: Show HN: JobStocks – track hiring changes at public companies vs. stock price

author: TalO


value: solenopsys

value:
CRB (Cigarette Rocket Booster) is a rocket concept where the body itself is the fuel.
Instead of thousands of parts, tanks, pumps, and valves, it is built around essentially one 3D-printed structure that serves as the vehicle, fuel mass, and nozzle array.
The goal is radical simplification and launch costs starting from $500 per kilogram for small payloads.

value: Show HN: Cigarette Rocket Booster – a rocket where the body itself is fuel

author: solenopsys


value: I freelance and got tired of manually tracking who owes what and sending follow-up emails. I built Payment Hunter (https://paymenthunter.bot) to fix this. Upload invoices (PDF or image), OCR + an LLM extracts client, amount, and due date, then automated reminder emails go out on a schedule you configure. The extraction pipeline hits ~99% accuracy on standard invoice formats. Plans from $19/mo with a 30-day free trial. Would love feedback on the approach.

value: Show HN: Payment Hunter – AI-powered invoice reminders for freelancers


value: Show HN: I wrote a free trilogy about perception, presence, and leadership


value: mesahm

value: Show HN: I forked Python's Requests to add HTTP/3, async, and multiplexing

author: mesahm


value: fullstackcrew

value:
Hi HN,
I built a small open-source tool called Privacy Mask.
It intercepts screenshots locally and automatically redacts sensitive
patterns (API keys, phone numbers, IDs, etc.) before screenshots are
sent to AI tools or agents like OpenClaw.
The goal is to prevent accidental data leaks when sharing screenshots
during debugging or development.
Everything runs locally.
Would love feedback.

value: Show HN: Privacy Mask – prevent secrets leaking to AI agents

author: fullstackcrew


value:
I got tired of newsletters that take more than 5 minutes to read and
leave me knowing nothing useful.
So I built Five: five curated stories every morning, readable
in 5 minutes.
The pipeline is automated — daily web search, AI-assisted
curation, straight to your inbox at 9 AM. I review the output
before it goes out.
Would love feedback on the format — especially
from people who've tried and abandoned other newsletters.

value: Show HN: Five – I built a 5-story daily newsletter for who hate newsletters


value: simonij

value: Flowly fixes the janky, choppy scrolling you get with Logitech mice (MX Master 3S, MX Master 4, and other third-party mice) on macOS. Apple's default scroll handling feels terrible with non-Apple mice. Flowly applies physics-based smoothing to make it feel as fluid as a Magic Mouse or trackpad. Per-app controls, fully customizable. 7-day free trial, $4.99.

value: Show HN: Flowly – Smooth scrolling for third-party mice on macOS

author: simonij


value: hleichsenring

value:
Curious what people think about this problem: If autonomous agents collaborate, how do we know which agents actually make good decisions?
I always liked it deterministic and reasonable. I want to trust the automation, doesn't matter if it is an agent or terraform.
That's the reason I brought Agent Smith to life.
Agents can post their decision with the context and the reasoning. Also the confidence need to be defined. After execution they can post  outcomes. Other agents can challenge or audit them.
Humans and agents score decisions separately. The gap between the scores becomes the signal.
A simple idea behind: Agents should have a public decision track record.
Here is ClawHub skill if you want your agent to participate:
clawhub install holgerleichsenring/agent-smith
[https://agent-smith.org](https://agent-smith.org)
[Github](https://github.com/holgerleichsenring/agent-smith-openclaw)

value: Show HN: Who watches the watchmen? A public decision track record for AI agents

author: hleichsenring


value: jaaackrl

value: Show HN: Wardstone – Prompt injection and jailbreak detection API

author: jaaackrl


value: Show HN: Line, Language with Intuitive and Natural Expression