value:
I built a general-purpose programming language where the GPU is the primary execution target, not an afterthought.

  Most languages treat GPU as "write a kernel, dispatch it, copy results back." OctoFlow flips it — data lives on
  the GPU by default. The CPU handles I/O and nothing else.

  let a = gpu_fill(1.0, 10000000)
  let b = gpu_scale(a, 2.0)
  let c = gpu_add(a, b)
  print("sum: {gpu_sum(c)}")

  10 million elements. Data never leaves VRAM between operations.

  It's early — there's a lot to improve — but it works today and I'd love feedback from people who try it.

  What you can do right now:

  - GPU compute with arrays up to 10M+ elements
  - Statistical analysis, ML (regression, clustering, neural net primitives)
  - CSV/JSON data processing, HTTP client
  - Stream pipelines for image processing
  - Interactive REPL with GPU access
  - Import from 51 stdlib modules across 11 domains

  What you need: any GPU with a Vulkan driver and the 2.2 MB binary. That's it.

  I've been working on this solo and would genuinely appreciate people kicking the tires. What works, what breaks,
  what's missing — all useful.

  https://github.com/octoflow-lang/octoflow

value: Show HN: OctoFlow – A GPU-native programming language


value: danFctr

value:
Hey HN,
We posted Tako AI here last week (open-source AI agent for Okta). We just shipped the Slack integration.
GitHub: https://github.com/fctr-id/okta-ai-agent
The enthusiasm for AI agents living in chat apps is massive right now. The workflow benefit is obvious: you don't leave the context where you're already working.
But for many of these tools, security feels like an afterthought — exposed local ports, permissive defaults, and unchecked execution. When the data involved is Okta user records, admin group memberships, and app entitlements, that model doesn't work. Security can't be a second-class citizen.
So Tako's Slack bot ships locked down by default. Nobody gets access until you explicitly add their Slack ID to the .env whitelist. And your Okta data never touches Slack's servers — the bot runs locally, queries your own infrastructure, and posts results back to the thread.
All commands:

  /tako [question]   → ask anything about your Okta tenant in plain English
  /tako history      → your last 5 queries with ▶ Run and  Star buttons
  /tako favorites    → your starred queries, always one click away
  /tako help         → full command reference

Two implementation details worth sharing:
Socket Mode by default. Tako opens an outbound WebSocket to Slack — no port forwarding, no reverse proxy, no public URL. Most identity tooling runs on internal networks that can't expose HTTP endpoints.
Re-auth on every action. We re-check authorization on every interactive button click, not just the initial slash command — because Slack action payloads can be replayed by anyone who intercepts them.
Happy to answer questions on the implementation.
—Dan

value: Show HN: Chat with your Okta tenant directly from Slack (Open-source AI agent)

author: danFctr


value: Sophyte

value: Show HN: Likes Search for YouTube. Search Through Mountains of YT Likes

author: Sophyte


value: ainthusiast

value: Reduces tokens, ensures your agents know what is out there and how to install it, provides safety layer. Machine readable for agent, humans can use it too :)

value: Show HN: CLI,me – One CLI for all CLIs, built for agents. Secure. Open

author: ainthusiast


value: Piprim

value:
ascii-tree-export.el is a small package that exports an org-mode or markdown buffer as an ASCII tree into a dedicated buffer.
Useful for me to create a txt visual tree-structure directory (even it does not exist) with comments.
https://github.com/pivaldi/ascii-tree-export.el?tab=readme-o...

value: Show HN: Emacs package that exports an org or md buffer as an ASCII tree

author: Piprim


value: AleksDoesCode

value:
Hey everyone,
English is not my native language. This post was polished with AI, but the content is mine.
I run a small dev agency in Germany. Every week someone shares database credentials, API keys, or a .env file via Slack or email. Not because they don’t care: because there’s no frictionless alternative.
Vault setups are heavy. Enterprise tools are expensive.
I just needed: upload → share link → done.
But encrypted before leaving the browser.
So I built SecretDrop.dev.
What it does
Files encrypted client-side (AES-256-GCM, PBKDF2 600k iterations)
Built entirely on WebCrypto
No third-party crypto libraries
Server stores only encrypted blobs
Recipient decrypts in their browser
No account required (password mode)
The server cannot read files, filenames, or passwords.
Premium mode
Encrypt with recipient’s public key (ECIES)
No shared password
Digital signature verifies sender identity
Only intended recipient can decrypt
Why
The real competitor isn’t Vault.
It’s “paste in Slack.”
I optimized for:
Zero setup
Dev workflow simplicity
Default secure behavior
Free tier includes encrypted password-protected sharing. No credit card.
I’m exploring:
VSCode extension (right-click .env → share)
CLI tool (secretdrop share .env --expires 24h)
Would this fit your workflow?
Any concerns about the crypto model or threat assumptions?
Happy to go deep on the architecture.

value: Show HN: I Built Zero-Knowledge .env Sharing

author: AleksDoesCode


value: Show HN:Edge Veda – A framework for resource-aware edge computing


value: simbaz

value: Show HN: I built Aegis AI – An Agentic Home Security w/ GPT+Local VLM on Mac/PC

author: simbaz


value: aliakyildiz

value: Stop juggling multiple tools for simple tasks. Shorten links or send files instantly. Simplify your workflow today. You can get started in just three simple steps by creating your account, choosing your tool, and sharing your links immediately. Start in 30 seconds with no credit card required and the freedom to cancel anytime.

value: Show HN: Single Tool – Shorten links or send files instantly

author: aliakyildiz


value: stokkerpro

value:
Hi HN,
I built Microstock.pro, an analytics and AI research tool for stock contributors, primarily focused on Adobe Stock.
As a stock creator, I noticed that most contributors rely on guesswork when choosing what to create. There’s very little structured data available to identify profitable niches, keyword opportunities, and market gaps before investing hours into content production.
Microstock.pro aims to solve that by providing:
Keyword and niche research
Trend discovery
Competitive insights
AI-assisted content idea generation
Data-driven validation before uploading
The platform is specialized for Adobe Stock, but the research insights can also inspire strategies for other marketplaces like Shutterstock, since trends often overlap.
It’s still early-stage and I’m actively improving features based on feedback. I’d really appreciate thoughts from the HN community — especially from creators, indie hackers, or anyone working with marketplace analytics.
Happy to answer any technical or product questions.

value: Show HN: Microstock.pro – AI-powered analytics for Adobe Stock contributors

author: stokkerpro


value: avremel

value:
I got tired of scrolling through endless WhatsApp group chats, so I built a browser extension that does the scrolling for me.
You can tag contacts as "important" to scroll slower when their messages are in view. You can also hide messages from specific users (click-to-unhide like Slack has).

value: Show HN: Auto-scrolling for WhatsApp group chats

author: avremel


value: blueberrycongee

value:
Hi HN — I built CursorLens, a free and open-source screen recorder/editor for product demos and walkthroughs.
It started as a fork of OpenScreen, but I reworked a lot of the capture/editing pipeline for a more native macOS workflow.
Current features:
full-screen or window recording
native cursor hide/show behavior on macOS
camera overlay + microphone recording
timeline editing (trim/crop/zoom/cursor effects/annotations)
subtitle generation + rough-cut workflow
multi-aspect export (16:9, 9:16, 1:1) and batch export
audio export controls (gain, loudness normalization, limiter)
It’s still in beta, so stability can vary by machine.
Repo: https://github.com/blueberrycongee/CursorLens
Releases: https://github.com/blueberrycongee/CursorLens/releases
I’d really appreciate feedback on:
recording reliability across setups
editing UX (especially rough cut/subtitles)
export speed/quality tradeoffs

value: Show HN: CursorLens – Open-source screen recorder/editor for product demos

author: blueberrycongee


value: elieskilled

value: Show HN: Hi.new – DMs for agents (open-source)

author: elieskilled


value: meehow

value: This is my first GNOME / Vala app. Let me know what do you think.

value: Show HN: Receiver – Internet radio for GNOME with 30K pre-verified stations

author: meehow


value: Show HN: Fn-p to Picture-in-Picture any macOS window


value: mcoliver

value:
I built https://skicamslive.com because I was tired of clicking through youtube playlists to scope out my favorite mountain and wanted something I could put up on my big TV.  I wanted something that felt like a "command center" for skiers.
Key Features:
Zero Bloat: just the streams
High-Res Grids: Every mountain page features a 16:9 grid of all available live cams.
Power User Workflow: You can "favorite" the resorts you care about and open all of them in new tabs with a single click (great for multi-monitor setups while you're getting ready to head out).
Fast Search: Filter by mountain name or state instantly.
Mobile Optimized: Works great on the chairlift or at your desk.
The Tech:
Built as a static site using Jekyll, hosted on GitHub Pages. I focused heavily on a "premium" feel using vanilla CSS and minimal JS for the favorites system (stored in localStorage).
I’d love to get your feedback on the UI/UX, and if there are any specific mountains you think are missing, let me know and I'll add them!
Check it out here: https://skicamslive.com

value: Show HN: Skicamslive.com

author: mcoliver

title: Show HN: Skicamslive.com


value: nanamichael

value:
Heya
I built StillOnAir, an app that turns YouTube into a lean-back, old-school linear TV experience.
Instead of choosing individual videos, you just press play and surf channels — like cable. Each channel is programmed into a continuous stream built from YouTube videos.
Right now there are ~30 live channels, including:
 • GameVerse (gaming)
 • Toontown (animation & cartoons)
 • Reelhouse (film & movie content)
 • Total Sports (sports highlights & talk)
 • And more across tech, entertainment, documentaries, sports etc.
The core idea: bring back a passive cable tv like watching experience, a sitting on the couch and tune in experience.
The added wrinkle is that anyone can create their own network. You can curate YouTube videos, schedule programming blocks, design a lineup, and air your own channel.
It’s essentially programmable internet TV built on top of YouTube — without hosting any video yourself.
Would love feedback if you decide to take it for a spin and happy to answer any technical questions as well.

value: Show HN: StillOnAir – Turn YouTube into programmable, linear TV for free

author: nanamichael


value: mikemasam

value: Show HN: YAML SSH Task Runner

author: mikemasam

title: Show HN: YAML SSH Task Runner


value: lawrencechen

value:
I run a lot of Claude Code and Codex sessions in parallel. I was using Ghostty with a bunch of split panes, and relying on native macOS notifications to know when an agent needed me. But Claude Code's notification body is always just "Claude is waiting for your input" with no context, and with enough tabs open, I couldn't even read the titles anymore.
I tried a few coding orchestrators but most of them were Electron/Tauri apps and the performance bugged me. I also just prefer the terminal since GUI orchestrators lock you into their workflow. So I built cmux as a native macOS app in Swift/AppKit. It uses libghostty for terminal rendering and reads your existing Ghostty config for themes, fonts, colors, and more.
The main additions are the sidebar and notification system. The sidebar has vertical tabs that show git branch, working directory, listening ports, and the latest notification text for each workspace. The notification system picks up terminal sequences (OSC 9/99/777) and has a CLI (cmux notify) you can wire into agent hooks for Claude Code, OpenCode, etc. When an agent is waiting, its pane gets a blue ring and the tab lights up in the sidebar, so I can tell which one needs me across splits and tabs. Cmd+Shift+U jumps to the most recent unread.
The in-app browser has a scriptable API ported from agent-browser [1]. Agents can snapshot the accessibility tree, get element refs, click, fill forms, evaluate JS, and read console logs. You can split a browser pane next to your terminal and have Claude Code interact with your dev server directly.
Everything is scriptable through the CLI and socket API – create workspaces/tabs, split panes, send keystrokes, open URLs in the browser.
Demo video: https://www.youtube.com/watch?v=i-WxO5YUTOs
Repo (AGPL): https://github.com/manaflow-ai/cmux
[1] https://github.com/vercel-labs/agent-browser

value: Show HN: cmux - Ghostty-based terminal with vertical tabs and notifications

author: lawrencechen


value: tacogips

value: Show HN: Remote Coding Agent

author: tacogips

title: Show HN: Remote Coding Agent


value: klangdon

value:
I wanted to find a way to get kids:
- moving
- creating
- playing with others
In the end I, and a team of 4 others, built:
- a foam ball with a BLE IMU in it (moving/together)
- an app that allows you to create almost any game you can imagine with AI (creating)
Video of teenagers making a game: https://www.youtube.com/watch?v=-7TZXRBybOE
Video that was intended to be for Kickstarter: https://www.youtube.com/watch?v=Edy9zew1XN4 (we abandoned kickstarter, long story)
For hardware we came up with a pretty awesome custom PCB, based around a Dialog DA14531, that doesnt need any charging for over 500 hours of play. The electronics are encased inside 4.5" diameter of foam. We drove a car over it and it didn't break.
For the app, we are using OpenAI Realtime API (gpt-realtime-2025-08-28) to gather the game requirements via conversation. We are using voice/realtime to allow kids to do it without needing to type or read. This piece has a huge dynamic prompt that flows with the conversation. It has about 20 different tools that the agent can use to access sample requirements, ball data, user profiles, api documentation, etc. We also did a lot of work to require younger kids to have adults present and make sure we never saved any pii, etc.
Then we use Gemini 3 Pro to process the conversation and generate a markdown specification/arhictecture of how the game should be designed. We found that Anthropic Opus 4.6 did perform better here, but Gemini 3 Pro is much cheaper and faster. This has a static/cacheable prompt that is primarily a ball api documentation and details on previously seen issues.
Then we use Gemini 3 Pro to also code the game. A very similar prompt to the specification/requirements just different purpose. We are currently exploring condensing the architecture and coding steps into a single step, with new "thinking" models. Also seeing that Google is launching 3.1 model, literally while I type this...
The end result is an app that allows you to speak game requirements, have ai code the game, then you get to play it with a real physical ball.
So ya, tons of fun building all that. Curious what HN thinks. Now the hard part of maybe getting someone to buy it...

value: Show HN: Ball 2 – Use AI to build fun ball games

author: klangdon


value:
Hi HN,
I built MCPSEC, a security gatekeeper for MCP (Model Context Protocol) toolchains.
It scans MCP configs, correlates vulnerability intel (OSV / GHSA / NVD), simulates tool abuse with an LLM-based probe agent, generates a policy + patch plan, applies hardening, then re-scans and gates CI on the final risk score.
The design is intentionally agentic:
- Inventory agent: parses MCP configs
- Intel agent: pulls vuln data (OSV / GHSA / NVD)
- Probe agent (LLM, optional): generates adversarial tool abuse prompts
- Policy agent (LLM, optional): turns findings into concrete config changes
- Orchestrator: merges results, scores risk, writes reports, applies patches
You can run it locally as a CLI or drop it into CI as a GitHub Action:
- It produces before/apply/after reports as artifacts
- It can fail PRs if the final risk score stays above a threshold
- Without an LLM token it works as a deterministic scanner; with one it becomes a true “security copilot”
Repo: https://github.com/yuvrajgitwork/MCP-toolchain-security-GK
Demo workflow: scan → apply → rescan → lower score
I built this because MCP toolchains are becoming powerful and over-privileged very quickly, and there’s basically no security gate for them yet.
Would love feedback from folks working in AI infra / security.

value: Show HN: Mcpsec-A multi-agent SEC gate for MCP toolchains (scan →harden →rescan)


value: funbitty

value:
Hi! Funxy - a statically typed scripting language that compiles to native binaries and can leverage the entire Go ecosystem.
The main pain points I wanted to solve:
- Quick scripting without sacrificing type safety
- Seamless interop with existing Go packages
- Single-file deployment for tools and automation
What makes it different from other embedded languages:
- Native Go package access (declare deps in config.yaml, get auto-generated bindings)
- BusyBox-style multi-script bundling
- Strong type inference that actually works well
I'd really appreciate technical feedback on:
- The Go interop approach (any edge cases I might have missed?)
- The language design decisions (pipes, pattern matching, etc.)
- Potential use cases I haven't considered
GitHub: https://github.com/funvibe/funxy

value: Show HN: Embeddable scripting language for Go

author: funbitty


value: justvugg

value:
PolyMCP is a framework that exposes functions (in Python or TypeScript) as MCP tools, serves them through standardized MCP servers, and orchestrates them with autonomous agents capable of planning and executing complex workflows.
With PolyMCP, you can:
 1. Expose existing functions (in Python or TypeScript) as MCP tools without rewriting the code.
 2. Use the PolyClaw agent to dynamically orchestrate tools, break down complex tasks, and adapt to failures, all running in isolated environments via Docker.
PolyMCP is ideal for enterprise automation, DevOps, data pipelines, and internal tool orchestration.
GitHub Repo: https://github.com/poly-mcp/PolyMCP

value: Show HN:PolyMCP Python Tools with Autonomous Agents

author: justvugg


value: jundot

value:
I built an open-source LLM inference server optimized for Apple Silicon. The main motivation was coding agents - tools like Claude Code send requests where the context prefix keeps shifting, invalidating KV cache. A few turns later the agent circles back, and your Mac has to re-prefill the entire context from scratch.
oMLX solves this with paged SSD caching. Every KV cache block is persisted to disk. When a previous prefix returns, it's restored instantly instead of being recomputed. This makes long coding sessions significantly faster.
It also supports continuous batching for concurrent requests, multi-model serving (LLM + embedding + reranker) with LRU eviction, block-level KV cache with prefix sharing and copy-on-write, OpenAI and Anthropic compatible APIs, and tool calling.
Ships as a signed macOS menubar app with a web dashboard.
GitHub: https://github.com/jundot/omlx

value: Show HN: oMLX – Native Mac inference server that persists KV cache to SSD

author: jundot


value: Show HN: Zest – A single-container recipe manager built without front end tools


value: krzysiek

value:
I wanted to understand what exactly the EU commission and the EU parliament are working on.
I processed every legislation and resolution from the last month with gpt-oss:20b to figure out what goal every document is serving.
I also assigned an image corresponding to a category that each of this documents belongs to.
There is a feature flag in the URL, because there is still some work I have to do before fully opening up the list of EU commission texts. If you'd like to go outside of the goals page and explore the website, feel free to go to https://euforya.eu/?ff_reset=true to reset the feature flag and explore only the parliament texts.

value: Show HN: What the EU parliament and commission have been working on lately

author: krzysiek


value: Show HN: Axon – Safely run claude --dangerously-skip-permissions on Kubernetes


value: Show HN: Bosun – Supervising Agentic Fleet Manager (Open Source)


value: talhao

value:
Hi HN, I built Divan, a Vibecraft-inspired 3D mission control / observability dashboard for OpenClaw workspaces.
It lets you visualize agents as “rooms” in a 3D scene and track what they’re doing (sessions, memory changes, goals, cron jobs — and I’m focusing next on tool-call tracing in the 3D view).
Demo GIF: https://github.com/talhaorak/divan/blob/master/docs/divan_sp...
What I’d love feedback on:
What would you want to see in an “agent observability UI”?
Would a “demo mode” (no OpenClaw required) make you try it?

value: Show HN: A 3D dashboard for OpenClaw agents, their tool calls in real time

author: talhao


value:
I built this over a weekend to solve a problem I kept seeing: founders of profitable businesses have no idea what a PE deal actually looks like in practice.
Most assume selling = all cash out the door. The reality is PE firms typically want you to roll 20-40% of your equity into the new structure. That rolled equity then participates in the second exit (when the PE firm sells the platform 3-5 years later, usually at 2.5-3x).
The maths is surprisingly non-obvious. Rolling 30% at a 6x EBITDA multiple, then getting 3x on the rolled portion at second exit, often beats selling 100% upfront.
The tool is three steps: enter your business details → get a valuation range based on sector-specific EBITDA multiples → use a slider to model cash at close vs. rolled equity at second exit.
Tech: Next.js 14, Vercel, Tailwind. No sign-up required to see the valuation — email gate is only before the deal modelling step.
Would love feedback on the multiple ranges and the UX flow.

value: Show HN: Exit Calc – Free calculator that models PE exits for business owners


value: lowsun

value: Show HN: A small, simple music theory library in C99

author: lowsun


value:
Hey HN,
I've been building Aether, a background agent that takes production errors from Sentry and attempts to turn them into verified pull requests.
When a new error hits your Sentry project:
1. Sentry webhook fires with the stack trace, breadcrumbs, and context
2. Aether spins up an isolated Fly.io VM and clones the repo at the relevant commit
3. Agent analyzes the stack trace, reproduces the issue, proposes a fix
4. Starts the dev server, re-runs tests, and can verify the running app with Playwright (headless Chromium is pre-installed in every VM)
5. A review pass evaluates the diff before a PR is opened
6. Pushes to a feature branch and opens a GitHub PR, but only if verification succeeds
7. If CI fails, it retries once with the failure logs. If it fails again, the task is marked failed. No infinite loops.
Why full VMs instead of worktrees? Each task runs in its own isolated machine with a real filesystem, real process model, real network stack. It can `npm install`, run a dev server on port 3000, and Playwright can hit `localhost:3000` because it's an actual environment, not a sandbox. Since each task is its own VM, preview URLs are exposed per task via a gateway proxy so you can inspect the running app while the agent works. VMs shut down shortly after the task completes.
There's a simple multi-agent setup: a solver proposes the fix, a review agent evaluates the diff, and the fix has to survive re-execution in a clean isolated environment before a PR gets opened. Not claiming formal guarantees here, just requiring the fix to actually execute successfully in a reproducible environment before it touches your repo.
Limitations:
- Works best on well-tested codebases where "reproduce and verify" is meaningful
- If reproduction isn't deterministic, results degrade
- CI retry is capped at one automatic attempt
- Code review is model-driven, not an architectural enforcement layer
- BYOK only, you bring your own API key via OpenRouter. No markup on model costs but it's not super cheap to run
- Sentry integration is built but waiting on approval from Sentry, coming soon
- CLI is also coming soon
Bug fixing is the main focus but it's built on top of a general-purpose background agents system that works today. The agent is still great at general coding tasks. You can give the agent tasks from a full web IDE with a code editor, terminal, file tree, and agent chat panel. CLI is coming soon too (`aether run "add auth to the API"`). Each task gets its own isolated VM with shareable preview URLs so you can hand someone a link to see exactly what the agent built. Similar to Cursor background agents but running in the cloud with full environment isolation instead of local worktrees.
Stack: Go API (Chi), Fly.io VMs, React 19 + Vite frontend, Bun workspace service inside each VM, Supabase for auth/db/realtime, Playwright + Chromium preinstalled on each VM.
Self-serve right now: GitHub OAuth, connect a repo, and go via the web IDE. Sentry and CLI coming soon.
Would value feedback from engineers who deal with production debugging regularly, or frequently use background agents. Where would this break, and what would make you trust it?
Landing page: https://www.runaether.dev
Try it: https://app.runaether.dev

value: Show HN: Aether – Background agents that fix bugs in isolated VMs, opens PRs


value: Show HN: Git Diff Viewer and Editor

title: Show HN: Git Diff Viewer and Editor


value: mnafees

value: Show HN: pgtk - Pure SQL diagnostic functions for PostgreSQL

author: mnafees


value: dylanmeyford

value:
Over the past 12 months I built an AI CRM that changed my life. I funnelled every neuron of sales knowledge I had into it.
Today, I open-sourced the whole thing — code, prompts, agents, orchestration - the whole lot.
What it does:
- Connects to your email and calendar
- Automatically analyses every activity
- Joins, records and analyses every meeting
- Thinks about every deal like a seasoned sales pro and actively drafts the next best action to move the deal forward.
- Consumes your files and playbooks and uses it to draft and inform decisions.
- Sends, Schedules, Drafts and Cancels emails
- Sends, Schedules, Drafts and Cancels meeting invites
- Automatically researches and enriches contacts and deals
- Automatically creates meeting agendas
- Automatically finds new contacts to add to the deal
The output is a set of drafted actions: follow-up emails, meeting agendas, deal risk flags, new stakeholders to add. You wake up, review, approve.
The hard part + key unlock:
I built it because I was a founder trying to do EVERYTHING and the sales admin was killing me.
It took me 3 whole attempts to get right. I had to think deeply about what a human sales rep is 'actually' doing, consciously and unconsciously, when running a sales motion.
Key unlock: sales is all about people. The first versions I built were about the emails and calls. Didn't work. BUT, when I orientated the intelligence processing pipeline to first build up a story on each person in the deal, their responsiveness, role, contributions, what they care about, history, and only after roll that into overall deal health and intelligence - that's when it started behaving like a real rep.
Why open-source it?
Honest answer: the math.
There are well-funded teams building closed AI CRMs right now. I'm just one dude.
If I stay closed, I'm a small fish competing on their terms.
Open-sourcing makes me the only one in that category.
Funded competitors don't need my code — they have their own infra.
What they don't have is an open-source community. A room of genius founders just trying to make the product as great as possible.
The harder problem building Radiant uncovered:
Building this taught me something I can't stop thinking about.
Agents are becoming more and more capable.
But the gap between an LLM and an actual professional isn't capability - it's Judgement*
An LLM can write a follow-up email. But it doesn't know that a prospect's silence after you mention a competitor isn't them thinking, but actually a deal risk that calls for a battle card and timely landmine email - not a check-in email next week.
I only 'know' that because I learnt those signals the hard way by putting the reps in.
When I built Radiant, what I was really trying to was encode that judgment into a system.
This led me to a side project: a spec called OpenExperts — a structured way for professionals to package their decision heuristics, workflows, and deep domain knowledge into a format any AI agent can consume.
My first attempt will be to take the intelligence pipeline from Radiant and transform it into an 'expert package' - then see if OpenClaw can do it all for me.
The idea is that any agent could 'install' an expert package and immediately be a top tier expert in that field.
Links*
GitHub: https://github.com/dylanmeyford/radiant-ai-crm-oss
OpenExperts spec: https://openexperts.ai
Happy to go deep on the architecture, the orchestration approach, or the OpenExperts idea — curious what people here think about the "encoding expertise" problem.*

value: Show HN: I open-sourced an AI sales CRM – and the "experience" problem I learned

author: dylanmeyford


value:
Hi HN,
I build data platforms (Snowflake, dbt, Airflow) and kept seeing the same issue: starting a clean analytics stack is harder than it should be. Not because of tools — but because of patterns.
How do you structure raw vs staging vs analytics layers?
How do you ingest without creating a mess?
How do you avoid rebuilding the same scaffolding every time?
So I pulled the patterns I use into something reusable.
ClawData is a skills library for OpenClaw that encodes practical ingestion and modelling workflows. It’s less about generating SQL and more about enforcing structure.
You can run it locally:
git clone https://github.com/clawdata/clawdata.git
cd clawdata
./setup.sh
It checks for OpenClaw, installs if needed, and lets you select skills (DuckDB, dbt-style modelling, Snowflake patterns, etc.).
It’s early. I’m still figuring out the right abstractions.
Would appreciate feedback — especially on whether encoding data engineering patterns this way makes sense.
Repo: https://github.com/clawdata/clawdata

value: Show HN: ClawData – reusable data engineering patterns on top of OpenClaw


value: thestackfox

value:
I built a dashboard to track incidents across the services the internet quietly relies on: stackfox.co/stack-status
Web apps feel flakier lately because the stacks underneath keep getting taller. When one layer blips (auth, hosting, DBaaS, queues), everything above it starts failing.
Stack Status pulls outages from major infra providers and shows what’s actually down right now.
Early version — feedback on missing providers or categories is welcome.

value: Show HN: Stack Status – Tracking outages across the internet's underlying stack

author: thestackfox


value: Show HN: Claude.md templates based on Anthropic's advice


value: aarush-prakash

value: Show HN: Devly A native, private macOS utility belt for developers

author: aarush-prakash


value: ambitiouz

value: Even with the latest extra MCP layer WP cannot be managed by AI Agents. See the 10 layers of WP and why it is not AI friendly at the core.

value: Show HN: Year era of WP might be over

author: ambitiouz

title: Show HN: Year era of WP might be over


value: Show HN: Mercury CLI – CLI to Connect to Mercury Bank


value: cclth

value: Show HN: Building an e-commerce MVP in in 5 prompts using rdd

author: cclth


value: rchaz

value:
I run Claude Code across multiple projects daily. Two problems kept getting in the way: being stuck in the terminal waiting for agents to finish, and burning through rate limits midweek while manually switching between accounts.
claude-nonstop fixes both. Every session gets a dedicated Slack channel with completion notifications and near real-time progress updates. When you hit a rate limit, it migrates the session to the next best account and resumes automatically.
Node.js, tmux, Claude Code hooks, Slack Socket Mode. No servers, no public URLs.

value: Show HN: Claude-Nonstop – Auto Account Switching and Slack Remote in Claude Code

author: rchaz


value: wainguo

value:
A fan-made tactical resource for ARC Raiders players.
Built from playtest/open data, it includes:
Full item database (499+ items) with loot sources, values, keep/sell/recycle advice
Interactive zone maps (Dam, Buried City etc.) showing danger levels & loot categories
80+ active quests with requirements & rewards
Machine behaviors & weaknesses (Drones, Walkers, Titans)
Crafting recipes, weapon classes, Hideout upgrade paths
Latest intel, patch notes & roadmap updates
No affiliation with Embark Studios – just a community tool to help Raiders extract more efficiently and die less.
Feedback welcome: missing data, UI suggestions, or want to contribute field reports? Drop a comment or hit the Contribute section on the site.
Would love to hear how it helps (or doesn't) in your runs.

value: Show HN: Arc Raiders companion – Quest tracker,maps,crafting and bots weaknesses

author: wainguo


value: asgarovf

value:
Hi HN,
I built Locus, an open-source project management platform designed for engineering teams that want to use AI coding agents.
The core idea: plan sprints and manage tasks in a cloud dashboard, but all code execution happens locally on your infrastructure. Your source code never leaves your machine.
How it works:
- locus plan: AI generates a sprint plan by analyzing your codebase. It uses multi-agent roles to break down directives into structured tasks with complexity estimates and risk assessments. You can reject and iterate on plans before approving.
- locus run: An agent picks up tasks from the sprint, executes them sequentially on a single branch, auto-commits after each task, and opens a PR when the sprint is done. Supports both Claude and Codex as backends.
- locus review: Review that understands your full codebase, not just diffs. Detects bugs, security issues, and performance problems. Posts review comments directly to GitHub PRs.
- locus discuss: Have architectural discussions with AI that has full project context. Insights and decisions are automatically extracted and saved.
- Telegram bot: Manage your agent remotely from your phone.
- VSCode extension: Chat with AI in your editor with full repo context.
The whole system is free, self-hostable, and works with your existing GitHub workflow. There's a one-command installation script for Ubuntu/Debian/macOS.
Tech stack: TypeScript monorepo with NestJS API, Next.js dashboard, and a Bun-bundled CLI.
I'm a solo developer building this because I was frustrated with the disconnect between planning tools and actual code execution.
Would love feedback on the approach and any features you'd want to see.

value: Show HN: Locus – AI agents that ship your code

author: asgarovf


value:
Hi HN — I made this.
Been messing around with a small archive format called 6cy. Not trying to replace zip or anything, mostly just exploring what happens if you make the format a lot stricter.
Every block describes itself. Checksums are always there. Codecs are UUIDs. If decoding can’t proceed cleanly, it just errors out. No fallback tricks.
The whole point was to avoid ambiguity and make corruption obvious instead of silent.
It’s still rough and evolving. Happy to hear thoughts.

value: Show HN: 6cy v0.3.0 – A streaming-first binary archive format


value: anotherCodder

value:
Hey HN,
I'm a maintainer of Valkey GLIDE (the official Valkey client) and work on the AWS ElastiCache team. Day job is deep in database client internals — which gives me a clear view of where Node.js job queues hit a ceiling at scale.
The problems with queues like BullMQ aren't subtle: 3+ round-trips per operation, Lua EVAL scripts that NOSCRIPT-error on restart, Lists/BRPOPLPUSH primitives that predate Streams, and complete blindness to cloud topology (cross-AZ bills sneak up on you).
So I built Glide-MQ. High-performance job queue for Node.js built on Valkey/Redis OSS Streams, powered by Valkey GLIDE — a Rust core exposed via native NAPI bindings.
Because I maintain the underlying client, I could go further than an external library ever could:
1-RTT per job — completeAndFetchNext folds completion + next fetch + activation into a single FCALL. No more chatty round-trips.
Server Functions over EVAL — one FUNCTION LOAD, persistent across restarts. NOSCRIPT errors gone entirely.
Streams + Consumer Groups from day one — replaced Lists/BRPOPLPUSH. The PEL gives at-least-once delivery with fewer moving parts.
Cluster-native, not cluster-bolted — hash-tagged keys from day one. No {braces} surprise when you scale out.
AZ-Affinity routing — reads go to same-AZ replicas. Up to 75% reduction in cross-AZ costs on ElastiCache.
Batch API pipelining — addBulk for 1,000 jobs: 228ms to 18ms (12.7x) via GLIDE's non-atomic pipeline.
IAM auth — native ElastiCache/MemoryDB auth with auto token refresh. No secrets in env vars.
Numbers (no-op processor, Valkey 8.0, single node):
- c=1: 4,376 jobs/s | c=10: 15,504 jobs/s | c=50: 48,077 jobs/s
- 15KB payload compressed to 331 bytes (98% savings)
Also included: transparent gzip (zero config), OpenTelemetry tracing, TestQueue/TestWorker in-memory backend for unit tests without running Valkey, and chain()/group()/chord() for job pipeline workflows.
Companion package: @glidemq/dashboard — drop createDashboard([q1, q2]) into any Express (or any other framework) app and get a live REST + SSE UI across all your queues (avifenesh/glidemq-dashboard on GitHub).
Would love brutal testing on it abilities — especially from anyone burned by queue scaling in production.

value: Show HN: I maintain Valkey GLIDE – built a Node queue doing 48k jobs/s

author: anotherCodder


value: bsparker

value:
Hey HN — I’m a PM at You.com.
We just made our web search API free to use via MCP, so AI agents can call real-time web search without managing API keys or billing.
If you’re building with Cursor, Claude Desktop, OpenAI, or your own MCP-compatible agent, you can plug in our MCP server and get:
 • Real-time web results
 • Structured answers (news, web, RAG-friendly output)
 • No cost for search via MCP
Docs are here:
https://docs.you.com/developer-resources/mcp-server
Would love feedback from folks building agentic workflows:
 • What’s missing?
 • What would make this actually useful in production?
 • Where does search break in your current stack?

value: Show HN: Free web search for AI agents via MCP (You.com)

author: bsparker


value: roniemartinez

value: Show HN: URL-Based Geospatial Processing

author: roniemartinez


value: HocusLocus

value: Show HN: What Chicken Said

author: HocusLocus

title: Show HN: What Chicken Said


value: Show HN: Three new models by KittenML. <25 MB Open-source TTS. Highly Expressive


value: ZacharyZZ

value:
I wanted a fast way to turn Markdown files into good-looking PDFs from the terminal. Pandoc + LaTeX is powerful but heavy. Browser-based tools break my workflow. So I built mdxport: one binary, no dependencies, pipe in Markdown, get a PDF.
Under the hood it parses Markdown with comrak, converts to Typst, and compiles to PDF in-process. No LaTeX installation, no network calls, no temp files flying around.
What it handles: LaTeX math ($E=mc^2$, display blocks), GFM tables, fenced code blocks, YAML frontmatter (title/author/lang/toc), and two built-in templates. You can also pass your own .typ template.
CJK support was a pain point I wanted to solve properly. mdxport fonts install downloads Noto CJK fonts, and the converter auto-detects CJK characters and warns if fonts are missing. Chinese/Japanese/Korean documents just work.
Watch mode (mdxport input.md -w) recompiles on save. Stdin works too: cat notes.md | mdxport -o notes.pdf.
Install: npm install -g @mdxport/cli (ships platform-specific binaries, no Rust toolchain needed) or cargo install mdxport.
https://github.com/cosformula/mdxport-cli (MIT, Rust, 55 tests, CI builds for macOS/Linux/Windows)
There's also a web version at https://mdxport.com if you prefer a browser UI.

value: Show HN: Single-Binary Markdown-to-PDF CLI in Rust, Powered by Typst (MDXport)

author: ZacharyZZ


value:
I built an OpenClaw plugin that runs text-to-speech entirely on your Mac. No API keys, no cloud, no pre-installed Python required.
It wraps mlx-audio and handles the full lifecycle: bootstraps its own Python environment via uv, downloads the model on first run, manages the server process, auto-restarts on crash, and exposes a standard OpenAI-compatible /v1/audio/speech endpoint.
Installation:
openclaw plugin install @cosformula/openclaw-mlx-audio Four models out of the box:
• Kokoro-82M: ~400 MB RAM, fastest, good for English/Japanese
• Qwen3-TTS-0.6B: ~1.4 GB RAM, best Chinese quality, 3-second voice cloning
• Qwen3-TTS-1.7B VoiceDesign: generate voices from text descriptions
• Chatterbox: 16 languages, ~3.5 GB RAM
Works on 8 GB Macs with Kokoro or Qwen3-0.6B. A proxy layer injects model-specific parameters so OpenClaw's TTS client needs zero changes.
Why not just run mlx-audio directly? You can. This plugin removes the setup friction: no Python version juggling, no pip install, no manual server management. It also adds OOM detection, memory pre-checks, startup progress tracking, and hot config reload.
GitHub: https://github.com/cosformula/openclaw-mlx-audio

value: Show HN: Local TTS for OpenClaw on Apple Silicon (MLX-Powered, Zero Setup)


value: am-seo

value:
The DOJ released ~3.5M pages of Epstein documents across 12 datasets. Buried in them are 207 academic papers and 14 books that nobody was really talking about. From what I understand these papers aren't usually freely accesible, but since they are public documents, now they are.
I don't know, thought it was interesting to see what this dude was reading. You can check it out at jeescholar.com

  Pipeline:
  1. Downloaded all 12 DOJ datasets + House Oversight Committee release
  2. Heuristic pre-filter (abstract detection, DOI regex, citation block patterns, affiliation strings) to cut noise
  3. LLM classifier to confirm and extract metadata
  4. CrossRef and Semantic Scholar APIs for DOI matching, citation counts, abstracts
  5. 87 of 207 papers got DOI matches; the rest are identified but not in major indexes

  Stack: FastAPI + SQLite (FTS5 for full-text search) + Cloudflare R2 for PDFs + nginx/Docker on Hetzner.

  The fields represented are genuinely iteresting: there's a cluster of child abuse/grooming research, but also quantum gravity, AGI safety, econophysics, and regenerative medicine. Each paper links back to its original government PDF and Bates number.

For sure not an exhaustive list. Would be happy to add more if anyone finds them.

value: Show HN: I indexed the academic papers buried in the DOJ Epstein Files

author: am-seo


value: corefiredrill

value:
Hey HN,
I’m the founder of SalaryScript, and I wanted to share a project I’ve been working on for over a year: a comprehensive negotiation playbook tailored specifically for big tech roles.
I’ve navigated the FAANG hiring gauntlet multiple times myself, with stints at FAANG companies, so I know firsthand how opaque and high-stakes these negotiations can be. I wrote SalaryScript based on my experience, insights from a dozen FAANG-alumni colleagues, and lessons from recruiters I’ve worked with over the years. We’ve pooled perspectives from engineers, PMs, and execs who’ve collectively negotiated millions in total compensation.
Think of it as a “golden rule” book for tech negotiations. It covers everything from decoding offer letters and leveraging competing offers to scripting responses for common recruiter tactics, handling equity cliffs, and navigating relocation packages. No fluff — just battle-tested scripts, templates, and strategies that have helped people increase their total comp by 30–50% on average.
One contributor, a former Meta engineering manager, shared how he turned a $300K offer into $550K by reframing the RSU vesting conversation. Another, an ex-Apple product lead, broke down the psychology of why “total comp” framing often beats focusing on base salary alone.
Since launching last year at an introductory price of $19, we’ve crossed 1,000+ downloads and sales. Demand has been strong, and as word has spread, we’ve gradually raised the price.
If you’re prepping for interviews or staring at an offer right now, this might be the edge you need.
If you’re interested, you can check it out at salaryscript.com.
Would love your thoughts, war stories, or questions like what’s the biggest negotiation win (or fail) you’ve had in tech?
Cheers

value: Show HN: SalaryScript – The FAANG Negotiation Playbook

author: corefiredrill


value: qeeebo

value:
Over the past 6 months, our small team has been building Qeeebo — a large-scale question-and-answer knowledge archive designed to explore whether massive knowledge corpora can be published sustainably using fully static infrastructure.
This month, we are releasing:
• 150+ million structured questions
• 24.5 million topics
• 171 million topic-question relationships
• 18+ million paginated topic pages
• 100% pre-rendered static HTML
• No origin servers — served entirely via CDN
Each question includes:
– A full answer
– A summary
– Structured citation formats (APA, MLA, Chicago, IEEE, etc.)
– Export formats (BibTeX, RIS, JSON-LD, YAML)
The entire system is generated in independent segments (~45k pages each), built across parallel machines running Hugo, then uploaded via automated multi-threaded pipelines with full failure tracking.
Why build this?
Large Q&A platforms historically struggled with sustainability — especially when operating on database-backed, dynamically rendered systems. We wanted to explore whether extreme-scale static generation could reduce infrastructure cost while increasing long-term durability.
This isn’t positioned as a replacement for Wikipedia or Stack Overflow. Instead, it’s an experiment in permanence and cost-efficient knowledge hosting at very large scale.
Happy to answer technical questions.

value: Show HN: 150M AI-Generated Q&A Pages Static

author: qeeebo


value:
Hi HN!
I’m building Antenna, a Mac app to manage an OpenClaw team in one place. If you run multiple agents, it gets messy fast: scattered chats, unclear command approvals, and poor visibility into what happened where. Antenna is my attempt to make that operationally sane.
Right now I’m focused on three things: seeing conversations across agents in one UI, approving commands safely, and keeping sessions manageable as context grows.
I’m currently testing better visibility into usage/context per session, smoother coding/review workflows, and lightweight controls that reduce complexity instead of adding more.
This is early and moving quickly. I’d really value feedback on: what would make this trustworthy enough for daily use, what’s missing for teams running multiple agents, and what would stop you from adopting it.

value: Show HN: Antenna, a command center for OpenClaw agents


value: clanker-lover

value:
I'm a hardware engineer who reads schematics, not source code. I kept needing to understand codebases for projects I was managing but couldn't read the syntax. So I built a tool that turns any codebase into an interactive visual map with plain English explanations.
Point it at a folder, get nested colored blocks showing the structure (directories → files → classes → functions). Click to drill down. AI generates summaries written for humans, not programmers. Architecture mode shows a dependency graph so you can see how modules connect.
Built the whole thing in ~30 hours using a multi-node AI workflow: Claude for planning/decisions, Claude Code for implementation, five other models for adversarial security review (42 fixes across 6 rounds). I made every design decision; AI wrote every line of code.
Cloud AI (OpenAI/Groq) or local AI (Ollama) — your choice. pip install codedocent and run the setup wizard.
MIT licensed. Would love feedback from people who actually write code — does this help when onboarding onto unfamiliar codebases?

value: Show HN: Codedocent – Code visualization for non-programmers

author: clanker-lover


value: CosmoSantoni

value:
kept losing good conversations to /compact. you spend 40 minutes having claude map your codebase, it builds up real understanding, then context fills up and /compact crushes everything into a 3k token summary. "we discussed auth and decided on JWT." cool thanks.
dug into the actual session JSONL files and the breakdown is kind of absurd -- 60-70% is raw file contents from tool reads that claude already synthesized, another 15-20% is base64 thinking signatures. your actual conversation is like 10-15% of the window.
so i built cmv. it strips the junk and keeps every message verbatim. tool results over 500 chars become stubs, thinking sigs get removed, everything you said stays.
cmv trim --latest   # trim and relaunch, 20-70% smaller (milage varies depending on tool and context session etc.)
cmv snapshot "analysis" --latest # save a session state
cmv branch "analysis" --name "auth" # fork from it later
also has a TUI dashboard that shows the token breakdown per session so you can see what's eating your context before you do anything.
what it's not:
* not a token monitor (ccusage etc already do that)
* doesn't touch original sessions, everything creates copies
* local only, reads JSONL directly, no API calls
curious how others handle this. most people seem to just accept /compact but losing a deep architectural discussion to a bullet point summary felt wrong enough to build something.
https://github.com/CosmoNaught/claude-code-cmv

value: Show HN: CMV – strip up to 70% of Claude Code without losing any conversation

author: CosmoSantoni


value: fabiosuizu

value: Show HN: 17MB model beats human experts at pronunciation scoring

author: fabiosuizu


value: LetusWinyj

value: Show HN: GameZipper – 12 Free HTML5 Browser Games (No Ads, No Login)

author: LetusWinyj


value: LakshyAAAgrawal

value:
We built optimize_anything, an API that optimizes any artifact representable as text — code, prompts, agent architectures, configs, even SVGs. It extends GEPA (our prompt optimizer, discussed here previously: https://arxiv.org/abs/2507.19457) far beyond prompts.
The API is deliberately minimal. You provide what to optimize and how to measure it:
import gepa.optimize_anything as oa
def evaluate(candidate: str) -> tuple[float, dict]:
    result = run_my_system(candidate)
    return result.score, {"error": result.stderr, "runtime": f"{result.time_ms}ms"}
result = oa.optimize_anything(
    seed_candidate="<your artifact>",
    evaluator=evaluate,
)
The evaluator returns a score plus diagnostic feedback (we call it "Actionable Side Information" — stack traces, rendered images, profiler output, whatever helps diagnose failures). An LLM proposer reads this feedback during a reflection step and proposes targeted fixes, not blind mutations. Candidates are selected via a Pareto frontier across metrics/examples, so a candidate that's best at one thing survives even if its average is mediocre.
Two ideas distinguish this from AlphaEvolve/OpenEvolve/ShinkaEvolve-style LLM evolution: (1) diagnostic feedback is a first-class API concept rather than a framework-specific mechanism, and (2) the API unifies three optimization modes — single-task search (solve one hard problem), multi-task search (solve related problems with cross-transfer), and generalization (build artifacts that transfer to unseen inputs). Prior frameworks only express mode 1.
We tested across 8 domains. Selected results:
Coding agent skills: Learned repo-specific skills push Claude Code to near-perfect task completion and make it 47% faster
Cloud scheduling: Discovered algorithms that cut costs 40%, topping the ADRS leaderboard over expert heuristics and other LLM-evolution frameworks
Agent architecture: Evolved a 10-line stub into a 300+ line ARC-AGI agent, improving Gemini Flash from 32.5% → 89.5%
Circle packing (n=26): Outperforms AlphaEvolve's published solution
Blackbox optimization: Generated problem-specific solvers matching or exceeding Optuna across 56 EvalSet problems
CUDA kernels: 87% match or beat baseline; multi-task mode outperforms dedicated single-task runs
```
pip install gepa
```
Blog with full results and runnable code for all 8 case studies: https://gepa-ai.github.io/gepa/blog/2026/02/18/introducing-o...
GitHub: https://github.com/gepa-ai/gepa

value: Show HN: Optimize_anything: A Universal API for Optimizing Any Text Parameter

author: LakshyAAAgrawal


value: BenMorrisRains

value:
Disclaimer: Still in alpha. Also vibe coded, so... you've been warned.
I'm not really sure where this is going or if it needs to go anywhere, but as someone who lives in Kotlin based projects almost all day, I always envied web-devs with their npm's and bun's. Or Python devs with their pips.
Using those tools makes spinning up a project or adding dependencies seem so frictionless. No Google searches for every dependency path to copy/paste into Gradle.
That's where this idea came from for kpm. The job is basically the same. Run a simple command to scaffold an Android or Kotlin project and then another simple command to add a dependency. That's the idea anyways.
I had started out writing this by hand a few years ago and it went off the rails somewhere and I started over using Claude last year. Just recently picked it back up a bit and I think it's in a good enough spot right now to see if anyone is interested in something like this. AI is really good at scripting projects.
There's no real magic here beyond a lot of code to generate Gradle files and mutate them. There's some things I'm not sure about like the global config. I don't even know if that is useful and it certainly will mess things up if you use it in an already set up project because it's currently overwriting everything, so yeah, be careful.
I am working on (or AI is I guess) generating CMP/KMP projects which would be really nice.
Obviously this will never be as smooth as a bun or pip but it gives a familiar-ish experience.
If you are an Android dev, to get started:
kpm new MyApp --android --compose kpm add <Library here> will add a dependency
Curious and nervous to hear what people think. Thank you!

value: Show HN: I Built a Kotlin Package Manager (KPM)

author: BenMorrisRains


value: mickamy

value:
Hi HN, I shared sql-tap here a few weeks ago — a transparent SQL proxy that captures every query and lets you inspect it in real-time. Thanks for the feedback last time.
The biggest addition: *a built-in Web UI*. Add `--http=:8080` and open your browser — queries stream in via SSE, you can click to inspect, run EXPLAIN, filter, and copy queries with args embedded. It's a vanilla JS SPA baked into the binary, so there's nothing extra to install or deploy.
Other updates since v0.0.1:
*TUI improvements*
- Structured filter mode (`f`): `d>100ms`, `op:select`, `error`, combinable with AND logic
- Analytics view (`a`): aggregate queries by template, sort by total/count/avg duration
- Export to file (`w`): save captured queries as JSON or Markdown
- Copy with bound args (`C`): substitutes `$1`/`?` placeholders with actual values
- Sort by duration (`s`), half-page scrolling (`Ctrl+d`/`Ctrl+u`)
*Database support*
- TiDB support (`--driver=tidb`)
- MySQL 9 compatibility
- Fixed PostgreSQL binary parameter decoding (UUIDs, etc.)
The proxy works the same way: point your app at sql-tapd instead of your database, no code changes needed. It parses the native wire protocol to capture queries, prepared statements, transactions, and errors transparently.
Written in Go, single binary, install via Homebrew (`brew install --cask mickamy/tap/sql-tap`) or `go install`. This is a solo side project — if you find it useful, a star on GitHub would mean a lot.

value: Show HN: SQL-tap now has a browser-based Web UI for real-time SQL monitoring

author: mickamy


value: sidduex

value: Access 35+ blazing-fast, client-side developer utilities—from WASM-powered code formatters and secure PDF manipulation to lossless image converters and deep technical SEO analyzers. Beyond dev logic, Artboards is a unified creative suite: elevate your work with our high-fidelity Screenshot Studio, craft social assets with InStudio, explore our exclusive F1-inspired apparel hub, and unlock the complete Artboards Design System—a premium, meticulously crafted dark mode UI library.

value: Show HN: A local-first hub with 35 dev/design tools and a dark-mode UI library

author: sidduex


value: abliterationai

value:
Hey HN,

  I'm sharing Berean Labs (https://bereanlabs.com), a free, autonomous AI penetration testing tool designed to catch client-side vulnerabilities, exposed secrets, and misconfigurations in your web apps before attackers do.

  The Problem
  Traditional DAST/SAST tools are often expensive, hard to configure, or generate massive amounts of false positives. They also sometimes lack the semantic understanding to realize that an exposed <!--
  AWS_KEY=... --> comment or a specific combination of DOM sinks is actually a critical vulnerability. I wanted to build a tool that acts more like a junior red-teamer looking at your frontend code.

  How it works under the hood
   1. Domain Verification: To prevent abuse and random scanning, you first verify domain ownership via a DNS TXT record.
   2. Safe Fetching: The Node.js backend fetches your target's HTML. I implemented strict SSRF protections here—it resolves DNS and explicitly blocks private/local IPs and localhost routing before
      fetching.
   3. Attack Surface Extraction: Using Cheerio, the backend parses the DOM to extract a highly condensed "attack surface summary" to fit into the LLM context window. This includes forms, input fields, external script sources, suspicious inline scripts (e.g., eval, innerHTML), inline event handlers, and HTML comments.
   4. AI Analysis: This sanitized context is fed into a specialized model (powered by Abliteration.ai) via a strict red-team system prompt.
   5. Structured Reporting: The model enforces a JSON schema to return vulnerabilities ranked by severity, complete with CVSS scores, affected code snippets, and remediation steps.

  It's completely free to use. I built this primarily to see how well current LLMs can perform context-aware security auditing on raw client-side output when given the right constraints.

  I'd love for you to try it on your own domains and let me know what you think. Does it catch things your standard linters/scanners miss? Are there false positives that annoy you?

  Check it out at: https://bereanlabs.com

  Feedback, questions, and roasts of the architecture are highly welcome!

value: Show HN: Berean Labs – Free AI-powered penetration testing for web apps

author: abliterationai


value: lyall

value:
I've been trying to find some good baby names, so naturally I've been playing around with the US Social Security Administration's name data[0].
I've made various visualizations, tried to analyze names that are going to be popular in the future, etc. I recently tried making a name recommendation system that lets you rate names, then recommends names based on your inferred preferences. It worked OK, but along the way I ended up making namex[1], which has turned out fun and maybe useful enough to be worth sharing with a wider audience. Give it a try!
Basic overview:
- Corpus of ~24,000 names taken from SSA data
- Any name with 15+ registrations attributed to it from 2022-24 was included
- The names are scored by an LLM (Claude Sonnet 4.5) across ~40 subjective dimensions, such as "toughness", "trendiness", "easy to spell"
- A further ~15 dimensions are computed based off of the (LLM inferred) pronunciation of the name
- E.g. "vowel rich", "ends nasal", "syllable count"
- 3 dimensions are computed from the raw SSA data related to popularity and gender distribution
- Names are then represented by a 60-dimensional vector
- User selections create a weight vector
- Names are ranked against the weight vector using fancy linear algebra (or, uh, dot products)
- Static data is loaded from server, everything else is run client-side
Disclaimer: there is some potential for offense to be taken at the characterization of names. The LLM was instructed to score the subjective dimensions according to the American cultural context. So what is considered e.g. easy to spell, or associations with certain cultures or religions, is based on the LLM's interpretation of that. So there are probably biases that stem from the LLM's training or American culture, or likely both.
0: https://www.ssa.gov/oact/babynames/
1: https://namex.lyall.co/

value: Show HN: I made a static site for exploring names

author: lyall


value: Show HN: Prompt Indexing for ChatGPT Session


value: tetubrah

value:
I built Sinkai to handle tasks that pure software agents cannot complete alone (for example, on-site checks, physical evidence collection, and local human verification).
What it does:
- AI agent sends a tool call (`POST /api/call_human`)
- Human accepts task and submits photo/video/text proof
- Agent receives structured result for downstream workflow
Current focus:
- Reliability at handoff boundaries (planner -> executor -> verifier)
- Human-in-the-loop operations with explicit failure states
- MCP/OpenAPI friendly integration for agent builders
Docs and API:
- for agents: https://sinkai.tokyo/for-agents
- openapi: https://sinkai.tokyo/openapi.json
- repo: https://github.com/tetubrah-del/Tool_Call_For_LLM
I would love feedback on:
1. trust/reliability signals you would require before production use
2. where to draw the boundary between autonomous execution and human escalation
3. failure modes we should expose more clearly in API responses

value: Show HN: Sinkai – Let AI agents hire humans for real-world tasks

author: tetubrah


value: slad

value:
Intentify is now generally available.
It turns UI change requests directly from your app into structured tickets and pull requests.
How it works:
1. Point and describe – Click on any element in your app and describe the change in plain language.
2. Review the proposal – Intentify generates a preview by updating the page. You review and approve
3. Create a PR – A pull request is opened for engineers to review and merge.
Engineers stay in control. Nothing auto-ships.
Intentify adapts to your code patterns and respects your existing agent setup (including Claude or other configurations, if you use them).
It’s focused on small, scoped UI changes — copy tweaks, layout fixes, minor UX improvements.
Your code and data are not used to train models.
Would love feedback from HN.
Website: https://intentify.dev
Explainer Video: https://youtu.be/5ZGQ1Jyc2cc

value: Show HN: Intentify – Point at your UI, describe a change, get a PR

author: slad


value: Show HN: An e-ink air traffic monitor built with Cloudflare Workers


value: riyogarta

value:
I built Syne because I was tired of AI assistants that forget everything after each conversation.
Syne is a self-hosted AI agent framework where memory is a first-class citizen — stored as semantic vectors in PostgreSQL, searchable across millions of entries, and persistent forever.
Key features:
- Unlimited persistent memory with semantic search (pgvector)
- Anti-hallucination: only stores user-confirmed facts, auto-deduplicates
- Self-evolving: creates new abilities at runtime without restart
- Multi-model: switch between Gemini, ChatGPT, Claude mid-conversation
- True $0/month setup: free OAuth + local Ollama embedding + Docker
- 19 core tools, sub-agents, Telegram + CLI interfaces
Built with Python, PostgreSQL, and Docker. No vendor lock-in.
GitHub: https://github.com/riyogarta/syne
Landing page: https://syne.codes

value: Show HN: Syne – AI agent that remembers everything, built on PostgreSQL

author: riyogarta


value: alhwyn

value:
just shipped my first ios game: photobomb, a party game for 3–8 players.
similar to cards against humanity one player gets a prompt (ex: "bad posture"), everyone else digs through their camera roll to find the best matching photo under 40 seconds. The prompter picks their favorite photo and the player with that chosen phot wins the round, and you rotate until everyone's been the judge.
bonus: if your photo gets screenshotted during the gallery , you score extra point. ;)
its free, just need three friends and photos to share

value: Show HN: Photobomb – cards against humanity but for your camera roll

author: alhwyn


value: arjunbajaj

value:
Hey HN! Arjun and Sid here.
Fostrom is an IoT Cloud Platform designed for developers to make it really easy to get started and scale fleets. We have Device SDKs (in Python, JS, Elixir, more coming soon), Typed Schemas, Per-Device Mailboxes, Programmable Actions, 4 Global Regions for lower-latency connections, and much more.
We've built Fostrom to solve a real need we faced in our previous startup, building a fully automated indoor vertical farm. We spent more time figuring out IoT infrastructure than writing automation logic. Fostrom is the platform we wished existed back then.
Over the last few years we've experimented with a lot of interesting tech and architectures, and settled on an architecture that we believe is quite elegant. We wrote a Go<->Elixir bridge to execute JS code in WASM for Actions, implemented a DuckDB library for Elixir, and wrote a Device Agent in Rust that our SDKs run in the background (https://github.com/fostrom/devicekit).
The most interesting realization we had was about the data architecture. For years, we tried using distributed databases and built complex layers on top of them, but all approaches had significant limitations specifically around consistency and querying. We want to provide operational correctness, rich insights, and reliability. Finally, we came to the conclusion that to achieve this we really need a SQL database for fleet data. So we built a DuckDB-based replicated multi-tenant data layer. We're still improving it (hence the Technical Preview badge) but we're quite proud of this decision. It simplifies the rest of the codebase, while keeping operational complexity in just a few places.
Our vision is to make a powerful IoT platform that enables you to build correct, secure, and reliable connected systems without dealing with any of the plumbing or infrastructure.
Next up, we're gonna launch our CLI, add automatic device monitoring to our Device SDKs, and improve the debugging experience. We have some pretty cool ideas to make Fostrom and the experience of developing connected systems better. We're also going to write more about our architecture and journey soon.
We also published our launch blog post which goes into more detail about our vision, what we've built, and our future plans: https://fostrom.io/blog/introducing-fostrom
Would love for you to try out Fostrom and give us your feedback and thoughts.

value: Show HN: Fostrom, an IoT Cloud Platform built for developers

author: arjunbajaj


value: Show HN: Wc-template – create custom elements using template and link


value: arturss

value: Help your workshop respond faster to customers with AI-assisted damage estimates before the car arrives.

value: Show HN: PhotoMeh – Repair cost estimates from photos – in under 60 seconds

author: arturss


value: octablock

value:
Hi HN,
I built a small UART analyzer using an ESP32-S3 as a cheap probe.
It taps the target’s TX at 921600 baud and streams raw bytes to the PC over USB CDC.
To make it robust and easy to resync, the S3 wraps data into a tiny binary frame:
'A''N' | type | seq16 | timestamp32 | len16 | payload,
then COBS-encodes it with 0x00 delimiters.
On the PC side (Python/Tkinter), the UI shows:
- RAW hexdump + throughput graph + health stats (seq gap / overflow)
- LOG/TEXT views (extract printable ASCII runs)
- Record/Replay (.anlog) for offline reproduction
- AUTO parser: scans magic bytes and brute-forces CRC variants for unknown inner frames
This started as a personal debugging bridge between firmware and host,
and helped me catch dropped chunks, burst patterns, and protocol mistakes
without a logic analyzer.
Repo:
 https://github.com/choihimchan/linkscope-bpu-uart-analyzer
I’d love feedback on framing, replay formats, or parsing heuristics.
Thanks!

value: Show HN: ESP32-S3 probe – a UART "flight recorder" with auto frame decoder

author: octablock


value: Show HN: CLI tool to analyze your Vector Embeddings!


value: Show HN: ModelWar – CoreWars for Agents

title: Show HN: ModelWar – CoreWars for Agents


value: nonekme

value:
Hey HN, I built Global Issue Memory (GIM), an open-source MCP server that lets AI coding assistants look up and share solutions to errors they encounter.
GitHub: https://github.com/timho102003/global-issue-memory
Try it: https://www.usegim.com/docs/getting-started (free, no signup required to use the MCP tools)
How I got here:
I do a lot of vibe coding where I prompt Claude Code and let it run autonomously. I kept noticing the same pattern: the AI would hit a common error, spend 30K+ tokens doing web searches and trying failed fixes, and by the time it found the answer the context window was so bloated that output quality had degraded. I started calling this "context rot."
My first attempt at fixing this was having the AI store solved issues in local markdown files and check them before debugging. It worked for my own projects but obviously didn't scale.
Then I realized this is basically the same problem Stack Overflow solved for humans. The difference is AI assistants can't efficiently parse discussion threads. They need structured, machine-readable fixes.
What it does:
GIM is an MCP server with five tools. When an AI hits an error, it calls gim_search_issues and gets back a verified fix in ~500 tokens instead of burning 30K on web searches. When the AI solves something new, it can submit the solution back via gim_submit_issue. Solutions are deduplicated and matched using semantic search.
Knowledge comes from two paths. First, a GitHub issue monitoring pipeline that crawls 60+ popular repos (LangChain, FastAPI, Next.js, etc.) and tracks closed issues with merged PRs linked. Those get automatically extracted, sanitized, and stored. Second, user contributions through the MCP tools, where an AI session solves something with a workaround and contributes it back.
Both paths feed into the same knowledge base, and here's where it gets interesting. Say a user hits a bug and their workaround gets logged. Later, when the crawler picks up the maintainer's official fix, it automatically identifies the overlap, merges, and deduplicates so the knowledge base stays clean and up to date. You get immediate workarounds to unblock you now, and the official fix once it lands.
Technical details:
Built with FastAPI, Qdrant for vector search, and Supabase. The MCP integration follows the Model Context Protocol spec so it works with any MCP-compatible client.
Privacy:
This was non-negotiable for me. If people are going to contribute solutions from their codebases, they need to trust that nothing sensitive leaks. Every submission passes through two layers of sanitization. First, regex pattern matching catches 20+ known secret types (API keys, tokens, connection strings) and scrubs PII. Second, an LLM-powered pass reviews the content in context to catch things that don't match any regex pattern, like hardcoded credentials in unusual formats. And because no sanitization system can claim to catch everything, the entire codebase is open source so anyone can audit it and open a PR if they spot a gap.
Why open source and community matter here:
The value of GIM scales directly with contributions. One AI solves a bug, every AI learns the fix. That only works if people trust it enough to participate, which is why open source isn't just a nice-to-have, it's the foundation. I bootstrapped from 60+ repos to make it useful on day one, but the real potential is the community filling in the long tail of issues that no single team could ever catalog.
On the roadmap, I'm planning to add MCP tools that let Claude directly raise issues in upstream repos when it detects something that needs maintainer attention, and also let users add their own repos to be tracked by the crawler. So the coverage keeps growing with the community.
The whole thing is open source: https://github.com/timho102003/global-issue-memory
Happy to answer any questions about the architecture, the sanitization approach, or anything else.

value: Show HN: Global Issue Memory MCP – Stack Overflow for Your Coding Assistant

author: nonekme


value: andrespi

value:
We completely hacked how the CPU processes data using 1024-bit virtual registers. No GPU, no SIMD, just pure integer arithmetic.
Paper and details: https://zenodo.org/records/18706964
Free for academic and personal use. Feel free to improve it if you want.
Immediate applications:
Instant first layer multi-recognition and real-world image analysis
AI image pre-processing
Paper version 1. Wait to see what comes later.
Happy to answer questions.

value: Show HN: True and4500 FPS Edge Detection at 1K (CPU-only)

author: andrespi


value: wrryyyy

value:
I noticed that most local events and festivals are only advertised in Japanese on individual venue websites.
Note: The site is largely AI-powered — data collection, translation, and categorization are all automated. While I do my best to keep things accurate, there may be occasional errors in dates, locations, or details. Each event links to its official source page, so please double-check there before making plans!
Feedback welcome~

value: Show HN: MatsuriMap – Free interactive map for events and festivals in Japan

author: wrryyyy


value: ivannovazzi

value:
I built this after hearing the same complaint from accountants, lawyers, and consultants: they spend more time chasing clients for documents than doing actual work.
The pattern repeats everywhere — send a PDF, follow up three times, client sends it unsigned, follow up again, client sends the wrong document. The billing clock stops but the frustration doesn't.
Gatherly lets firms send a Secure Link to a branded Client Portal where clients sign and upload everything in one place. No client account required. Automated reminders handle follow-up until completion.
A few design decisions worth noting:
- Signatures are eIDAS-qualified (the EU legal standard for electronic signatures), which matters for law firms and financial advisors who need agreements that hold up legally
- We combine e-signature with document collection in one workflow — so a client signs an engagement letter and immediately uploads supporting files in the same session, rather than two separate tools
- Zero friction for the client side — they get a link, sign, upload, done. No account creation, no app to install
The thing I'm still figuring out: pricing model. Currently flat per-month with a free trial. Curious whether usage-based (per document request sent) or seat-based makes more sense for this kind of workflow tool.
Happy to hear from anyone who's worked in or built for professional services firms.

value: Show HN: Gatherly – E-signatures and doc collection for professional services

author: ivannovazzi


value: lbostral

value: Show HN: Inkwell-MCP – An MCP server for newsletter creators (open source)

author: lbostral


value: crazyguitar

value: I wrote a guide that walks through building a minimal GPU-initiated networking library from the ground up. It covers RDMA transport with libfabric on AWS EFA, PCIe topology-aware GPU-NIC placement, GPUDirect RDMA via DMA-BUF, CUDA IPC for intra-node NVLink transfers, and the symmetric memory model that ties it all together. Each section includes working code and benchmarks.

value: Show HN: Nvshmem from Scratch – RDMA, GPUDirect, and GPU Networking Demystified

author: crazyguitar


value: kriptonio

value: Understand what your agents do in production, and how much does it cost.

value: Show HN: Spanora, world class Agent observability platform

author: kriptonio


value: wayofthekatana

value: In this guide, We demonstrate that how to plan your n8n workflow.

value: Show HN: How to Plan a n8n Workflow

author: wayofthekatana

title: Show HN: How to Plan a n8n Workflow


value: kanelbullen

value:
Hi HN,
I built https://trustmeplease.ai
It’s a trust network for AI agents: agents don’t collect followers, they earn trust from other agents after real interactions. Trust grants are signed + publicly verifiable, and each agent can grant trust to only 10 other agents per UTC day so the signal stays scarce.
Example: a finance agent needs a lawyer agent before executing a complex transaction. Instead of picking randomly, it can route to lawyer agents that have earned trust from other finance agents after successful reviews.
Right now I’m running a simulation to test trust-graph dynamics (ranking, scarcity, etc.). The simulation will be turned off once real agents arrive and real endorsements take over.
Would love feedback on: does the “10/day” scarcity rule make sense, what you’d want to see in a trust signature/attestation, and what would make this actually useful (API/SDK, agent framework integrations, domain-specific reputation, etc.).
Thank you!
Kanelbullen

value: Show HN: Trustmeplease.ai – trust, don't guess (a trust network for AI agents)

author: kanelbullen


value:
I made a generative art system that generates random expressions made of functions (sin, exp, mod, etc.), variables x/y and p/q (polar coordinates), and constants you can set and animate. The outputs are highly variable.
You can press P to animate all constants at the same time and N to quickly generate new programs.
Presets don't work the same on all devices because GLSL is not deterministic and depends on the GPU.
One interesting thought is that if intelligent alien life exists out there and their vision works similar to ours they might have looked at outputs just like these at some point.

value: Show HN: Generative Art Shaders

title: Show HN: Generative Art Shaders


value: samantaba

value:
# Show HN: AstroLens -- AI that watches the sky and finds what nobody catalogued
*https://github.com/samantaba/astroLens** (MIT licensed, Python)
AstroLens is an open-source tool that downloads images from sky surveys (SDSS, ZTF, DECaLS, Pan-STARRS, Hubble, and others), runs them through a Vision Transformer + out-of-distribution ensemble + YOLOv8 pipeline, computes galaxy morphology, and cross-references everything against SIMBAD/NED/VizieR. It's designed to run autonomously for days.
*Results from a 3-day validation run* (zero human intervention):
published results in https://www.linkedin.com/pulse/astrolens-v110-teaching-ai-wa...
- 20,997 images from 7 sources analyzed
- 3,458 anomaly candidates across 354 sky regions
- Independently recovered SN 2014J (Type Ia supernova in M82), NGC 3690 (galaxy merger), and SDSS J0252+0039 (gravitational lens)
- YOLO transient detection went from 51.5% to 99.5% mAP50 by training on data collected during the run itself
- 140 self-correction cycles, zero errors
*What makes it interesting*: The pipeline is self-correcting — it adjusts OOD thresholds, rebalances survey sources based on anomaly yield, recalibrates its reference distributions, and handles errors autonomously. It's not a batch job; it's a continuous system that gets better as it runs.
*Honest limitations*: It found known objects, not new discoveries — this validates the pipeline but the real test is pointing it at less-explored regions. OOD detection on astronomical images is inherently noisy (the boundary between "unusual galaxy" and "imaging artifact" is fuzzy). The self-correcting system helps, but false positives remain a challenge.
Runs on a laptop (CPU/MPS/CUDA). Desktop app, web UI, CLI, Docker.
Built with Python 3.10+, FastAPI, PyTorch, Ultralytics, PyQt5.

value: Show HN: AstroLens – AI that watches the sky and finds what nobody catalogued

author: samantaba


value: theevoq

value: Show HN: FakeSec – AI photo detector with 12 independent analysis methods

author: theevoq


value:
Hey HN,
I vibed Chowser because I was tired of links always opening in my "default" browser when I wanted them in a specific session (work, personal, research, etc.).
Chowser is a lightweight macOS app that acts as your default browser. Instead of opening a link immediately, it pops up a sleek picker that lets you choose which browser to use for that specific link.
Key Features:
Lightweight & Native: Built with SwiftUI/AppKit. It lives in your menu bar and uses zero resources when idle.
Keyboard First: Press ⌘⇧1 through ⌘⇧9 to snap-select a browser instantly.
Set & Forget: Once it's set as your default browser, it stays out of your way until you click a link.
Open Source: Fully open source under MIT.
 Tech Stack:
Swift, SwiftUI, and AppKit. I wanted something that felt like a native part of macOS, not a heavy web-wrapper.
Check it out:
GitHub: https://github.com/bsreeram08/chowser
Download (DMG): https://github.com/bsreeram08/chowser/releases
Thanks! sreeram

value: Show HN: Chowser – A lightweight macOS browser chooser


value: Show HN: Delulu9 - SEO keyword research for Claude Code content pipeline


value: mirceamitu

value:
We built AISMOND for MSP teams that need one place to track external exposure across many client environments.
Live today:
- Multi-tenant dashboard for risky IPs, services, and countries
- IP-level context from CVEs, IoC signals, abuse reports, and open ports
- One-command onboarding scripts (Windows, Linux, macOS)
- Weekly digest generation and resend
- On-demand port scanning on eligible plans
Not shipped yet:
- PSA ticketing
- RMM integration
Would love feedback on two things:
1) Are the risk scores understandable enough to prioritize action?
2) Which PSA workflow should we ship first?

value: Show HN: Aismond – attack-surface monitoring for MSP client fleets

author: mirceamitu


value: daniellax

value: Show HN: SaveTheTrade – a simple trade journal and performance tracker

author: daniellax


value: fabiosuizu

value:
I built an English pronunciation assessment engine that fits in 17MB and runs in under 300ms on CPU.
Architecture: CTC forced alignment + GOP scoring + ensemble heads (MLP + XGBoost). No wav2vec2 or large self-supervised models — the entire pipeline uses a quantized NeMo Citrinet-256 as the acoustic backbone.
Benchmarked on speechocean762 (standard academic benchmark, 2500 utterances):
- Phone accuracy (PCC): 0.580 — exceeds human inter-annotator agreement (0.555)
- Sentence accuracy: 0.710 — exceeds human agreement (0.675)
- Model is 70x smaller than wav2vec2-based SOTA
Trade-off: we're ~10-15% below SOTA on raw accuracy. But for real-time feedback in language learning apps, the latency/size trade-off is worth it.
Available as REST API, MCP server (for AI agents), and on Azure Marketplace.
Demo: https://huggingface.co/spaces/fabiosuizu/pronunciation-asses...
Interested in feedback on the scoring approach and use cases people would find valuable.

value: Show HN: 17MB pronunciation scorer beats human experts at phoneme level

author: fabiosuizu


value: Show HN: I Emulated My Childhood

title: Show HN: I Emulated My Childhood


value: Behavrai

value: Show HN: Behavr – Run realistic user simulations on your prototypes in minutes

author: Behavrai


value: passh

value: Show HN: One async PHP process serving web, REST API, and MCP for AI agents

author: passh


value: jacoka

value:
I built a tiny tool to monitor Cloudflare R2 free Class B operations in real time.
I was running a small side project on Cloudflare R2 and realized the dashboard doesn’t make it very obvious how close you are to the free Class B limit. I didn’t want surprise charges, so I built a simple browser-based tracker.
R2Stat connects via the official Cloudflare GraphQL API and shows current usage against the free quota.
The API token is stored locally in the browser (not sent to any backend server).
It’s intentionally minimal – just a focused utility for indie devs and small projects that rely on the free tier.
Would love feedback from anyone using R2 in production.

value: Show HN: R2Stat – Monitor your Cloudflare R2 free Class B quota

author: jacoka


value: pgebski

value: Show HN: HushWork – A calm focus environment for focus in one tab

author: pgebski


value: Show HN: VaultAI – 42 AI models on a portable SSD, works offline ($399)


value: TedOS

value:
I built Forked because debugging OpenClaw agent failures was too opaque: lots of logs, hard to reproduce, and no clear way to inspect where behaviour diverged.
Forked is a time-travel debugger for OpenClaw that records agent execution and lets you inspect, fork, and rewind runs.
What it captures:
- LLM inputs/outputs (including token usage when available)
- tool calls/results
- message flow
- file-modifying actions (with snapshots)
- lifecycle/config/setup-file changes
What you can do:
- inspect a full timeline of a run
- fork from a decision point, modify payload, replay
- rewind file state to a prior snapshot-backed point, then branch from there
Architecture is simple/local:
OpenClaw tracer plugin -> WebSocket
local daemon (Node + SQLite)
local UI (React)
Privacy model:
MIT licensed
local-first (127.0.0.1)
no cloud dependency, no telemetry required
Repo: https://github.com/MurbotLabs/Forked
This is v1. I’d really value feedback on:
- Missing debugging workflows
- Pain points in fork/rewind UX
- What would make this essential in daily OpenClaw dev loops

value: Show HN: Forked – a local time-travel debugger for OpenClaw agents

author: TedOS


value: pulko

value:
Docs drift. Examples in README.md stop matching the implementation. CI usually doesn’t notice.
I built doksnet, a small Rust CLI that lets you link a documentation section to a code snippet and verify that both sides stay in sync using Blake3 hashes.
You define mappings like:
• README.md:15-25
• src/lib.rs:40-65
doksnet stores the ranges + their hashes in a compact .doks file.
doksnet test re-extracts the content and fails (exit code 1) if anything changed — including whitespace.
Basic flow:
• doksnet new – initialize
• doksnet add – create doc ↔ code mapping (interactive)
• doksnet test – CI-safe verification
• doksnet test-interactive – review/fix mismatches
It’s repo-local, no external service, no parsing/AST magic — just deterministic text extraction + hashing.
There’s also a GitHub Action if you want to enforce sync in CI.
Repo: https://github.com/Pulko/doksnet
Install: cargo install doksnet
Web: https://doksnet.pulko-app.com
Interested in feedback on the approach — especially whether this tool could be more useful then “Rewrite all the readme based on new changes. Make no mistakes”, for instance, in environments where AI usage is restricted

value: Show HN: Doksnet – keep docs and code in sync with hash verification

author: pulko


value: YugaHashimoto

value:
Open-sourced Android voice assistant app built for OpenClaw.
Key features:
- Offline wake-word detection (Vosk)
- VoiceInteractionService integration (long-press Home)
- Real-time chat + streaming responses
- Encrypted settings + device identity
- Bilingual UI (English/Japanese)
Would love feedback on architecture, onboarding, and production hardening.

value: Show HN: OpenClaw Assistant – Android voice assistant app for OpenClaw

author: YugaHashimoto


value: beowa

value:
Hey HN,
This is Legal RAG Bench, the first benchmark for legal RAG systems to simultaneously evaluate hallucinations, retrieval failures, and reasoning errors.
The key takeaways of our benchmark are:
 1. Embedding models, not generative models, are the primary driver of RAG accuracy. Switching from a general-purpose embedder like OpenAI's Text Embedding 3 Large to a legal domain embedder like  Kanon 2 Embedder can raise accuracy by ~19 points.
 2. Hallucinations are often triggered by retrieval failures. Fix your retrieval stack, and, in most cases, you end up fixing hallucinations.
 3. Once you have a solid legal retrieval engine, it doesn’t matter as much what generative model you use; GPT-5.2 and Gemini 3.1 Pro perform relatively similarly, with Gemini 3.1 Pro achieving slightly better accuracy at the cost of more hallucinations.
 4. Google's latest LLM, Gemini 3.1 Pro, is actually a bit worse than its predecessor at legal RAG, achieving 79.3% accuracy instead of 80.3%.
These findings confirm what we already suspected, that information retrieval sets the ceiling on the accuracy of legal RAG systems. It doesn’t matter how smart you are, you aren’t going to magically know what the penalty is for speeding in California without access to an up-to-date copy of the California Vehicle Code.
Even still, to our knowledge, we’re the first to actually show this empirically.
Unfortunately, as we highlight in our write-up, high-quality open legal benchmarks like Legal RAG Bench and our earlier Massive Legal Embedding Benchmark (MLEB) are few and far between.
We point out, for example, that the popular Vals AI CaseLaw (v2) benchmark yields LLM rankings inexplicably and starkly different from ours while also failing to properly evaluate end-to-end RAG performance. Because CaseLaw (v2) is a private and proprietary benchmark, we are unable to confirm the source of the discrepancies we discovered, though we suspect they lie in a seriously flawed evaluation and labeling methodology.
In the interests of transparency, we have not only detailed exactly how we built Legal RAG Bench, but we’ve also released all of our data openly on Hugging Face here: https://huggingface.co/datasets/isaacus/legal-rag-bench/. We will also soon be publishing our write up as a paper.

value: Show HN: Legal RAG Bench

author: beowa

title: Show HN: Legal RAG Bench


value: mmsols

value:
I built a native macOS app for browsing and playing retro DOS games through the eXoDOS collection.

  The problem: eXoDOS is an incredible curated archive of 7,000+ DOS games with pre-configured DOSBox settings, but it's Windows/Linux focused. On Mac you're stuck with janky shell scripts, manual DOSBox config, and no real way to browse the library. I wanted a proper Mac-native experience.

  What it does:

  - Downloads eXoDOS for you (full or lite — lite fetches games on demand via BitTorrent so you don't need 500GB upfront)
  - Browses the full library with box art, metadata, search, and filtering
  - One-click launch — auto-extracts archives, picks the right DOSBox version per game, handles config
  - Routes games to DOSBox Staging, DOSBox-X, ScummVM, or Wine+ECE automatically
  - Game version selector when multiple exist (Floppy/CD, SoundBlaster/MT-32, EGA/VGA)
  - Also supports eXoScummVM, eXoWin3x, eXoDREAMM collections in the same library
  - ROM support for console emulation via RetroArch/MAME

  A few Mac-specific things I added that I think are fun:
  - Spotlight indexing — Cmd+Space, type "Doom", hit Enter
  - Siri Shortcuts — "Hey Siri, launch a random DOS game"
  - Menu bar quick launcher for recent/favorite games

  Technical bits: Swift/SwiftUI, targets macOS 13+. Game launching is fully independent — I built a database of 1,700+ game version configs (which executable, which subfolder, which DOSBox flags) so the app doesn't depend on any eXo shell scripts.
  There's also a crowd-sourced fix system: if a game doesn't launch correctly, the app parses the dosbox.conf to find the right executable, and if the user confirms it works, the fix gets uploaded and synced to all users.

  €20 with a 14-day free trial. It's been a big project and I'd like to keep working on it.

  https://nostalgi.app

value: Show HN: NostalgiApp – Native macOS launcher for 7k+ DOS games (eXoDOS)

author: mmsols


value: ashfn

value: Show HN: Searchable aggregator of 24M London council spending transactions

author: ashfn


value: yaohuo

value:
When building AI video workflows, I kept running into the same problem: the tools were powerful, but every project felt like starting from scratch.
Blank canvases, endless parameters, fragile prompt chains.
I wasn’t blocked by the models — I was blocked by the lack of reusable workflows.
So I built TemplateFlow.
Instead of tuning prompts or writing scripts, you drag ready-made AI templates onto a canvas, connect them, and run.
Workflows are reusable, shareable (JSON-based), and designed for creators who want results fast.
TemplateFlow is fully open source and still early. Sharing it here to get feedback from the community.

value: Show HN: TemplateFlow – Build AI workflows, not prompts

author: yaohuo


value: Rizzist

value:
Had some friends in the Media Space (think super into cameras, video editing, vfx, etc...) & 3 years ago they asked me to make a simple srt editor. Fast forward 3 years later (& with much more programming skills under my belt) - spent the last 2 weeks rewriting HappySRT to allow media uploads, threads (like chatgpt), transcribe uploaded files w/ SRT Editing, Translate the transcribed file (also each translation is individually editable & savable), as well as summarize what the video/audio is about (it does it via the transcription).
I used Appwrite, Deepgram, NextJS Pages Router, OpenAI API, UpliftAI Scribe, and my favorite npm packages to create this: npm i styled-components & npm i styled-icons
Launching on Play Store soon (I used next-pwa for that, which meant I couldn't use turbopack but instead used webpack) & submitted it already for approval, hope it goes well.

value: Show HN: I made HappySRT to transcribe, translate, & summarize easily

author: Rizzist


value: rockyj

value:
Growing up in India in the 90s, I always wanted a cricket game I could just play - no downloads, no loading screens, no flashy 3D graphics that get in the way. Just pure cricket fun in the browser where every ball feels different.
So I built one. Choose ball line, length, pace, shot timing, power, direction and fielder positions. It all matters! Every delivery is a battle between bat and ball, and the result comes from the combination of all these factors - not from random dice rolls.
What's in the game:
- Day and Night matches
- Knockouts and full tournaments
- Historical scenarios - drop yourself into legendary chases and famous collapses
- 16 real-world-inspired teams with unique play styles and momentum traits
It runs entirely in the browser. No installs, no signups. Just pure cricket fun.
Would love to hear any feedback.

value: Show HN: Fun Cricket 26 – 3 clicks to bowl, 3 to bat, 1000s of possibilities

author: rockyj


value: 365 is nearly prime (5×73), which is why our months are uneven and weeks don't fit into months. But 360 has 24 divisors — swap 5 days for year-end holidays and you unlock dozens of clean calendar systems where every month is identical.<p>I built a tool to explore them all: pick a base, see every valid factorization, compare against Gregorian side-by-side.

value: Show HN: Our calendar is political, not mathematical – explore alternatives


value: dtfortu

value:
If you’ve ever tried to run an AI agent in production, you know the pain: Docker setup, VPS provisioning, SSL, DNS, secrets management, restarts, logs, and updates.
Most builders don’t want to spend their time becoming infrastructure engineers — they want to build, iterate, and ship.
That’s exactly why I built AgentClaw.

value: Show HN: Stop Running Your AI Agent on a Laptop: Meet AgentClaw

author: dtfortu


value: astonfred

value: Show HN: Flask Is My Go-To Web Framework

author: astonfred


value: bobowski

value:
I built Stario, an open-source Python 3.14+ framework for building web apps without React-style client bloat.
What it is: server-first web app architecture with HTML rendered on the server, realtime updates over SSE, and multiplayer behavior through CQRS patterns. The goal is to keep things simple, performant, and Pythonic.
Backstory: I kept running into the same issue in internal tools. Basic HTTP screens were easy, but once realtime collaboration was needed, projects often pulled in websocket protocol handling, client-side state sync, and more frontend framework complexity than the product needed.
Stario started as an exploration of Datastar and a question: what would a Pythonic framework look like if it fully embraced that philosophy? The result was a narrower approach: keep truth on the server, stream updates over SSE, and use one handler model for the most common endpoint behaviors.
What is different in practice:
- A Go-like shape with a Pythonic twist: `async def handler(c: Context, w: Writer) -> None`
- One handler model for three common types:

  - single response (`w.html`, `w.json`, etc.)
  - streaming over time (`w.alive(...)` + `w.patch(...)`)
  - work that continues after response (`w.empty(204)`, then continue server-side)

- Multiplayer sync via CQRS-style reads/writes plus in-process `Relay` fanout
- Realtime without requiring WebSocket protocol code for most use cases
Try it locally (no signup, interactive setup):
```
uvx stario@latest init
# interactive prompts guide project/template setup
```
Links:
- Docs: https://stario.dev
- Source: https://github.com/bobowski/stario
- Tiles walkthrough: https://stario.dev/tutorials/tiles-walkthrough

value: Show HN: Realtime Python Apps Without WebSockets and React Bloat (Stario)

author: bobowski


value: sudeshss

value:
Built a mobile app that generates cryptographically verifiable proof of completed service work. Before/after photos hashed with SHA-256, signed with Ed25519, timestamp anchored via freetsa (RFC 3161 compliant), GPS coordinates embedded.
Client side verification only. No backend trust required. Signatures verified locally in an ephemeral memory sandbox. Any tampering in photos, timestamps, GPS or metadata immediately invalidates the signature.
Stack: React Native, Golang, Ed25519, SHA-256, RFC 3161 TSA, AI work narratives via Groq.
Built for the gig economy trust problem. Target markets: contractors, cleaners, delivery, property management.
Looking to sell full IP and source code. mozar.t@yahoo.com

value: Show HN: Tamper-proof work verification with Ed25519 and RFC 3161 TSA

author: sudeshss