value: daviddom

value:
Hello, HN! If you've been trying to integrate LLMs into WhatsApp, you've probably noticed that the massive blocks of text that the AI   often responds to, besides being in Markdown instead of the format WhatsApp supports, don't provide a good user experience.
I just published an open-source repository that solves this problem:
- Converts Markdown to WhatsApp's format
- Intelligently splits long texts into shorter fragments (without cutting lists, links, emails, and with syntax understanding)
- Supports tables, so they look good
- Runs 100% locally in your project, doesn't use external libraries, and has 100% test coverage
You can start using it with a simple 'npm install'.
If you find it useful, I'd appreciate it if you gave the repo a star :
https://github.com/daviddominguezh/llm-markdown-whatsapp

value: Show HN: Markdown to WhatsApp Converter

author: daviddom

title: Show HN: Markdown to WhatsApp Converter


value: wellwellsmell

value:
I built this as a solo project after the FDA rejected MDMA-assisted therapy last year. The idea is a simple guided experience for people who want to use MDMA intentionally for personal growth, with activities like breathing exercises, journaling prompts, and guided meditations.
The design philosophy is minimalism. Someone mid-session doesn't need a busy UI, so everything is kept calm and low-stimulation. It works as a PWA so it can be installed and used fully offline, which felt important for something like this.
Stack is React, Vite, Zustand, and Tailwind. Everything runs locally, nothing is collected or transmitted.
It's functional but the main bottleneck right now is content. i need more guided activities, and the codebase could use more eyes on it. Would appreciate feedback on the architecture or the UX.
Repo: https://github.com/wellwellwellyourefeelingfine/m-session

value: Show HN: M-session – Open-source app for guided MDMA sessions

author: wellwellsmell


value: dagestan

value: Show HN: Built an webpage to showcase Singaporean infra and laws/acts

author: dagestan


value: justvugg

value:
Hi everyone,
I am Vincenzo and i’m working on PolyMCP, an open-source framework that not only exposes Python functions as AI-callable MCP tools but also lets you orchestrate agents across multiple MCP servers.
The idea: instead of rewriting code or wrapping every function with a special SDK, you can:
 1. Publish your existing Python functions as MCP tools automatically
 2. Spin up a UnifiedPolyAgent that coordinates multiple MCP servers
 3. Ask your agent to perform complex workflows spanning different tools
Here’s a quick example in Python:
from polymcp.polyagent import UnifiedPolyAgent, OpenAIProvider
agent = UnifiedPolyAgent(
    llm_provider=OpenAIProvider(model="gpt-4o-mini"),
    mcp_servers=[
        "http://localhost:8000/mcp",
        "http://localhost:8001/mcp",
    ],
    verbose=True,
)
answer = agent.run("Read sales data, compute totals, then summarize.")
print(answer)
Or TypeScript, combining HTTP and stdio-based MCP tools:
import { UnifiedPolyAgent, OpenAIProvider } from 'polymcp-ts';
const agent = new UnifiedPolyAgent({
  llmProvider: new OpenAIProvider({
    apiKey: process.env.OPENAI_API_KEY!,
    model: 'gpt-4o-mini',
  }),
  mcpServers: ['http://localhost:3000/mcp'],
  stdioServers: [{ command: 'npx', args: ['@playwright/mcp@latest'] }],
  verbose: true,
});
await agent.start();
const answer = await agent.run('Collect data and summarize.');
console.log(answer);
Use cases:
 • Aggregate data from multiple internal services and scripts
 • Build AI copilots that span different tools and languages
 • Automate multi-step operational workflows
 • Prototype agents that interact with production systems safely
Works with OpenAI, Anthropic, and Ollama models, including local deployments.
GitHub links:
 • Core & Agent: https://github.com/poly-mcp/PolyMCP
 • Inspector: https://github.com/poly-mcp/PolyMCP-Inspector
 • SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps
I’d love feedback from anyone exploring agent orchestration or building multi-tool AI pipelines.

value: Show HN: PolyMCP – Orchestrate AI agents across Python tools and MCP servers

author: justvugg


value: indrora

value:
I was tired of having to write the same basic primitive over and over again: A channel, some control logic, etc.
So I wrote toil -- A port of two of my favorite Python functions over into the Go world. It's very simple. There's optimizations to be made for sure, but this is the result of a couple of hours of wanting something that felt Go-Like in the right way.

value: Show HN: Toil, a go library for simple parallelism

author: indrora


value:
I built Codex HUD to make Codex CLI sessions easier to monitor without leaving the terminal.

  It adds a real-time status line with:

  - active model
  - project + git branch/dirty state
  - 5h and 7d usage bars
  - automatic Spark vs default limit selection

  Quick install:

  git clone https://github.com/anhannin/codex-hud.git
  cd codex-hud/Codex-HUD
  ./install.sh

  Feedback I’m looking for:

  - portability across Linux distros/shell setups
  - readability on narrow terminal widths
  - edge cases in usage/rate parsing

  Repo issues are welcome if you hit bugs.

value: Show HN: Codex HUD – Claude-HUD Style Status Line for Codex CLI


value: StanAngeloff

value:
Hey HN, I posted Flemma back in October 2025 with no context. Since then I've shipped >100 commits and used it daily as my primary AI workspace so I figured a proper update was due.
The core idea: a .chat file IS the conversation. No SQLite, no JSON logs, no shadow state. What you see in the buffer is exactly what the model receives. Edit an assistant reply to fix a hallucination, delete a tangent, fork by duplicating the file - it all works because there's nothing to fall out of sync.
What's new since October:
- Tool calling. Models can run shell commands, read/edit/write files (same as Pi, just 4 tools). Results go straight into the buffer. There's an approval flow (Ctrl-] cycles: preview -> execute -> send) so nothing runs without your say-so. Parallel tool use also works.
- Prompt caching for Anthropic, OpenAI and Vertex AI. Flemma places cache breakpoints automatically. Long conversations are now significantly cheaper (this was a major pain point for me).
- Extended thinking / reasoning support for all 3 providers.
- Per-buffer overrides via frontmatter. `flemma.opt` lets you pick which tools a buffer can use, set provider parameters, switch models - all scoped to that one file.
- Open registration APIs for both providers and tools. Custom tools can resolve definitions asynchronously from CLI subprocesses or remote APIs. I plan on adding mcporter support at some point.
Flemma works with Anthropic, OpenAI and Vertex AI. You get cost tracking, presets, Lua template expressions, file attachments and a lualine.nvim component.
One thing I want to be upfront about: nearly every line of code in Flemma was written by AI (Claude Code as of late, Amp and Aider in the past). It says so in the README. Every change was personally architected, reviewed and tested by me. I decide what gets built and I vet every diff. I think this is where a lot of software development is heading and I'd rather be honest about it than pretend otherwise.
I'm @StanAngeloff on GitHub - long-time Neovim user and open source enthusiast. Happy to answer questions.
https://github.com/Flemma-Dev/flemma.nvim

value: Show HN: Flemma – a Neovim plugin where the .chat buffer is the conversation

author: StanAngeloff


value: lakonguina

value:
Hi HN,
I was tired of having to manage gas fees across multiple blockchains and constantly figuring out which chain offered the best rates, so I built an API to solve that.
I truly believe that the next billions of dollars flowing on-chain won’t need to know which blockchain they’re on, which protocol they’re using, or have to deal with gas fees at all. Everything will be fully abstracted.
So this API allows you to perform swaps on the same chain or cross-chain even when they require multiple txs/steps with a single signature, automatically routes for the best returns and lets you pay gas fees with any supported token (USDC instead of ETH, for example).
Tell me what you think, thanks!

value: Show HN: An API for on-chain swap

author: lakonguina

title: Show HN: An API for on-chain swap


value:
Hi HN,
I built this because I got tired of the Claude Code CLI hiding details from me.
Recent updates have replaced critical output with summaries like "Read 3 files" or "Edited 2 files". To see what actually happened, I was forced to use `--verbose`, which floods the terminal with unreadable JSON and system prompts.
I wanted a middle ground: *Full observability without the noise.*
`claude-devtools` is a local Electron app that tails the session logs in `~/.claude/` to reconstruct the execution trace in real-time.
*Unlike wrappers, it solves the visibility gap in your native terminal workflow:*
1.  *Real Diffs:* It shows inline diffs (red/green) the moment files are edited, instead of just a checkmark.
2.  *Context Forensics:* It breaks down token usage by File vs Tool Output vs Thinking (so you know exactly why your context window is full).
3.  *Agent Trees:* It visualizes sub-agent execution paths which are usually interleaved and confusing in the CLI.
It’s 100% local, and works with the logs already on your machine. No API keys required.
Repo: https://github.com/matt1398/claude-devtools
(Screenshots and diff viewer demo are in the README)

value: Show HN: I built a tool to un-dumb Claude Code's CLI output (Local Log Viewer)


value:
Browsing through some old projects I found this game I wrote a long time ago, back when I was super interested in NN.
My goal was to have the NN to learn as it plays against the player so they could have a chance of winning.
Now a days, with the work load of my full time job I don't have that much free time to investigate fun projects like this one.

value: Show HN: Play Bang Bang against a neural network


value:
OpenClaw is great, but it’s fairly heavy to run 24/7 at home.
In practice it often needs >1GB RAM and a small server or Mac mini, which makes “personal AI agents” surprisingly expensive.
I recently came across PicoClaw, an open-source project by Sipeed that takes a very different approach.
Instead of running large runtimes locally, it acts as a lightweight agent client and delegates reasoning to cloud LLM APIs (GLM/GPT/Claude), while keeping orchestration local.
The interesting part is the footprint:
< 10MB memory usage
< 1s cold start
single self-contained binary
no Node.js or Python
runs on ARM / x86 / RISC-V
So it can run on devices like Raspberry Pi 3B, cheap RISC-V boards (~$10), old Android TV boxes, etc.
Technically it’s rebuilt from scratch in Go, which explains most of the startup and memory improvements. No dependency tree, no runtime environment — just one binary.
Despite the size, it still supports:
shell execution
file operations
web search
speech-to-text
Telegram / Discord / QQ / DingTalk integrations
Quick start is basically:
git clone https://github.com/sipeed/picoclaw.git
cd picoclaw
make build
./picoclaw agent
Feels more like a “microkernel” approach to agents compared to heavier stacks.
Interesting direction if you’re experimenting with edge AI or home lab automation.
Repo: https://github.com/sipeed/picoclaw
Site: https://picoclaw.org/

value: Show HN: PicoClaw 10MB OpenClaw alternative that runs AI agents on $10 hardware


value:
Wax is a Swift-native, on-device memory layer for agents: store documents + embeddings + hybrid retrieval in a single crash-safe file.
Goal: replace the typical “RAG stack” with something you can ship inside an app (offline, deterministic token budgeting, reproducible retrieval).
Feedback welcome — especially on retrieval quality + eval methodology.

value: Show HN: Wax – RAG in a single file (SQLite for AI memory)


value: eesmee

value: Show HN: CookFlow --Merge multiple recipes into one optimized cooking workflow

author: eesmee


value: danesto

value:
Have you ever had to send cold emails for a side project?
As an engineer, I've always struggled to keep track of cold mailing lists for my side projects.
I could find contacts and save them in a sheet. The part I hated and struggled with was bulk emailing and keeping track of who I already emailed, adding notes, etc.
There's just wasn't any intuitive and simple solution I could find for this that I liked. Especially, if you want to connect you own custom domain email over SMTP.
I just wanted something simple that let me connect my own SMTP config, create a template, import a CSV with contacts and then bulk send 15 emails at once all by keeping the record of sent ones.
Nothing more, nothing less. Focus on finding leads and building, rather than writing every email manually or paying for bloated software just to do this.
Scripts worked, but I needed to share the management with non-technical folks.
Current options I found - I didn't like at all, overcomplicated and time consuming.
So, over the weekend I decided to build the simple OSS tool to help me achieve this and save time in the future.
The tool is built using SvelteKit as a weekend project; so, like any weekend project, the code is not the best or most performant, but it gets the job done.
Demo: https://cold0-gamma.vercel.app/register
Repo - feel free to fork or contribute: https://github.com/danesto/cold0

value: Show HN: Free OSS cold email bulk sender and management

author: danesto


value:
I built Clawver (beta), infrastructure for AI agents to generate reliable income and run an online business end-to-end.
Agents can handle listing, checkout, fulfillment, and post-purchase flows via API (digital + POD), with Stripe payouts and webhooks for automation. Minimal human intervention, only where required (Stripe onboarding).
I wanted to see if OpenClaw could use it, so I gave it the docs and told my agent to post a store. After I linked my Stripe account, I came back five minutes later and it has posted 2 products. Crazy what's possible now with a smart agent and API access.
Check it out at https://clawver.store . Feel free to build your own agent and lmk what you think.

value: Show HN: My agent started its own online store


value: mosaxiv

value: Inspired by OpenClaw and Nanobot, I built a lightweight and highly efficient agent framework in Go.<p>While there are other projects that claim high performance, this framework focuses not only on speed but also on richer functionality and practical efficiency. It aims to provide a more complete and streamlined experience without sacrificing performance.

value: Show HN: Clawlet – Ultra-Lightweight&Efficient Alternative to OpenClaw, Nanobot

author: mosaxiv


value: poitch

value:
I was looking to refresh my personal page last weekend and ran into bento.me, which was shutting down today.
So, like any sane engineer in 2026, instead of looking for what was out there, I decided to ask Claude to build me a clone that I could use.
Meet Kumiki (a traditional Japanese woodworking technique that translates to "joining wood together"), your link-in-bio site builder that lets you put your homepage together one block at a time.
This is 100% vibe-coded with Claude Opus 4.6, 100% server-less app running on Vercel and Supabase.

value: Show HN: Kumiki – A Bento.me Clone

author: poitch

title: Show HN: Kumiki – A Bento.me Clone


value: mikecaps

value:
Hi HN,
I’m a 3D artist working in game dev. I built TextureFast after repeatedly hitting the same issue: we often just needed clean, seamless PBR textures quickly, but existing workflows felt heavy and slow for simple cases.
TextureFast generates PBR maps (albedo, normal, roughness, metallic and height) directly in the browser. The goal is speed and minimal friction rather than complex manual texturing, especially for fast mvps and concepts.
Tech stack: Next.js + Three.js
I’d appreciate feedback on texture quality, UI/UX, performance, and whether this fits into your workflow.

value: Show HN: TextureFast – Generate PBR textures for 3D models in seconds

author: mikecaps


value: Show HN: InfiniteGPU, An open-source AI compute network,now supporting training


value: stcredzero

value:
Show HN: SEKSBot – AI agents that can't see your secrets
SEKSBot is a fork of OpenClaw where agents have zero access to API keys, tokens, or credentials — ever.
The core insight is borrowed from SQL prepared statements: separate the instructions from the sensitive data. Agents write requests using named secret references. A broker intercepts and injects the real credentials at execution time. The agent never sees them.
How it works:
seksh (our nushell fork) has secure built-in commands (seksh-http, seksh-git) that route through the broker. Agents can make authenticated API calls and git operations without the keys ever entering shell memory.
seks-broker stores secrets and acts as a proxy. It can inject bearer tokens, API keys, and even handle asymmetric key signing — all without exposing anything to the agent process.
Three layers of defense: (1) Agents never have secrets in env vars or memory. (2) The broker validates and scopes every request. (3) Skills use sandboxing on top of broker-mediated access.
The problem we kept seeing: every AI agent framework puts API keys in environment variables. One prompt injection, one malicious webpage, one bad skill — and your keys are exfiltrated. We decided the only real fix is making it physically impossible for the agent to access them.

value: Show HN: My agents are building a secure fork of OpenClaw

author: stcredzero


value:
I built aiproposal.fun in last few hours as a side project.
You enter two names, pick a tone, and it generates a funny, full 10-slide pitch deck proposal complete with slides like "Competitive Analysis vs. The Ex"5-Year Happiness Projections, Unit Economics of Love and more..
Timing is intentional.
Whether it gets traction or not, it was fun to build.
Do try it out :)

value: Show HN: I built an AI that generates love proposals as pitch decks


value: metehankasap

value:
I built this because I kept turning off alarms half-asleep and going back to sleep.
Instead of snoozing, the alarm only turns off after you complete a short mini-game (memory, math, reaction, tilt).
Would love feedback on whether this actually helps people wake up.

value: Show HN: Alarm Arcade – an alarm app that only stops after you beat a mini-game

author: metehankasap


value: Nannooskeeska

value:
I built a reverse job board for .NET developers, inspired by RailsDevs (which unfortunately shut down last year). Developers create profiles and companies browse and reach out directly.
Stack: .NET 10, ASP.NET MVC, a little HTMX, Azure SQL.
This is the first side project I've actually shipped and I'd love some feedback.

value: Show HN: DotNetDevs – a reverse job board for .NET developers

author: Nannooskeeska


value: jacoka

value: Show HN: A private, bulk audio converter using WASM (186x real-time speed)

author: jacoka


value: sgoudelis

value:
Hello Hacker News community,
I'm excited to share my open-source project, Ground Station – a full-featured software solution for satellite tracking and radio communication. Designed for amateur radio operators, satellite enthusiasts, and researchers, it provides a comprehensive and easy-to-use platform.
Key Features include:
- Real-time Satellite Tracking: Precise orbital models and automatic TLE updates.
- SDR Integration: Stream and record live radio signals from a wide range of SDR devices (RTL-SDR, SoapySDR, UHD/USRP).
- AI-Powered Transcription: Real-time speech-to-text for demodulated audio via Gemini Live or Deepgram.
- Automated Observations: Schedule and execute satellite passes without manual intervention, including IQ/audio recording and protocol decoding (SSTV, FSK, GFSK, GMSK, BPSK).
- SatDump Integration: Decode weather satellite images (METEOR-M2 LRPT/HRPT).
- Responsive Web Interface: Control everything from desktop, tablet, or mobile.
- Automated Antenna Rotator & Rig Control: Interface with popular hardware with Doppler correction.
This project was built with the help of Claude Code and Codex.
You can find the project here: https://github.com/sgoudelis/ground-station
I'd appreciate any feedback, suggestions, or contributions from the community!

value: Show HN: Ground Station – All-in-one satellite monitoring suite (Python, SDR)

author: sgoudelis


value: This is my first Claude Code project. I am a bit of a novice at software development, but I wanted to be able to automatically rename files in Nautilus using the right click menu and AI (Claude) and thought it shouldn't be too hard.<p>It is a bit slow so if you have any suggestions on how to speed it up please let me know!

value: Show HN: AI Rename, Automatic File Renaming in Nautilus


value: walon

value:
Hi HN,
I built a small iOS app called PhilosophMe. It has a philosophy quantifier, then, it delivers one short philosophical prompt per day — designed to encourage reflection rather than productivity or motivation.
I noticed most “thinking” apps either oversimplify philosophy into quotes or gamify it heavily. This is intentionally slow and minimal.
I’m especially interested in feedback on:
• Whether the value proposition is clear
• If this feels like something you’d actually open daily
• Whether philosophy apps even make sense on mobile
• What to do w/onboarding
App Store link: https://apps.apple.com/us/app/philosophme/id6758975792

value: Show HN: PhilosophMe – a minimal iOS app for daily philosophical thinking

author: walon


value: ab-abg

value:
Sentinel Core is an open-source foundation layer of our AI-powered video intelligence stack.
It provides real-time object detection, semantic video search, and event indexing designed for on-premise and air-gapped deployments.
Core capabilities include:
• Real-time object detection (YOLO-based)
• Semantic search over recorded footage (CLIP-based embeddings)
• Multi-camera ingestion and indexing
• Configurable detection thresholds
• Designed for local deployment (no cloud dependency)
We’re releasing this as part of building an open ecosystem around reliable, real-world video intelligence systems.
Feedback, contributions, and technical discussion are welcome.

value: Show HN: Sentinel Core – Open-source AI video search and detection engine

author: ab-abg


value:
I wanted a voice-to-text app but didn't trust any of the proprietary ones with my privacy.
So I decided to see if I could vibe code it with 0 macOS app & Swift experience.
It uses a local binary of whisper.cpp (a fast implementation of OpenAI's Whisper voice-to-text model in C++).
Github: https://github.com/richardwu/openwhisper
I also decided to take this as an opportunity to compare 3 agentic coding harnesses:
Cursor w/ Opus 4.6:
- Best one-shot UI by far
- Didn't get permissioning correct
- Had issues making the "Cancel recording" hotkey being turned on all the time
Claude Code w/ Opus 4.6:
- Fewest turns to get main functionality right (recording, hotkeys, permissions)
- Was able to get a decent UI with a few more turns
Codex App w/ Codex 5.3 Extra-High:
- Worst one-shot UI
- None of the functionality worked without multiple subsequent prompts

value: Show HN: OpenWhisper – free, local, and private voice-to-text macOS app


value: vikvorona

value:
Hey HN, I'm an engineer at Sonar (SonarQube).
The small team I lead in company had a cool opportunity to spend several months doing almost anything we want that is somehow related to AI generated code and Code Review. And we end up doing an IDE-like desktop app that called Kintsugi - basically a complementary tool to Claude Code that adds a bunch of features that helps working with a CLI Agent.
Now, we built it for our needs and for the way we work. More specifically - we care about code quality and security and we believe that you own the code generated by agents and it has to be verified. But at the same time we want to ship fast and Claude Code is really-really good at this. So we decided to create a tool, that would allow developers to ship fast, but have control over the produced code. Here are the main features:
  - Orchestrate parallel agents — see all sessions by status (In Progress, Interrupted, Awaiting Input, Ready for Review) so you know which needs attention
  - Review AI code like PRs — leave comments, push back for changes, ask for explanations, run independent AI review
  - Plan review — review well-formatted plans with inline comments like Google Docs (my personal favorite)
  - Code quality — integrated Sonar analysis to catch issues locally while developing; connects to your SonarQube Cloud config if you have one
The tool is built almost entirely by Claude Code, and we use Kintsugi itself while building it. It's a prototype — expect rough edges. We have a big list of planned features but need feedback on what to prioritize.
It is macOS only for now. Linux and Windows are available internally, but we are not comfortable to give them to people yet.
Now let me be honest - the link leads to landing page with sign up for download (I know it is not recommended), but since it is a prototype we are required to have a way to send updated versions to users if needed. There is no verification of email, no confirmation and we obviously will not use it for marketing purposes. Only as a way to ask for a feedback and provide an updated version if necessary.
Would love honest feedback and happy to chat about the tool.

value: Show HN: Kintsugi – A desktop app for reviewing Claude Code sessions

author: vikvorona


value:
I've been working on CloudRouter, a skill + CLI that gives coding agents like Claude Code and Codex the ability to start cloud VMs and GPUs.
When an agent writes code, it usually needs to start a dev server, run tests, open a browser to verify its work. Today that all happens on your local machine. This works fine for a single task, but the agent is sharing your computer: your ports, RAM, screen. If you run multiple agents in parallel, it gets a bit chaotic. Docker helps with isolation, but it still uses your machine's resources, and doesn't give the agent a browser, a desktop, or a GPU to close the loop properly. The agent could handle all of this on its own if it had a primitive for starting VMs.
CloudRouter is that primitive — a skill that gives the agent its own machines. The agent can start a VM from your local project directory, upload the project files, run commands on the VM, and tear it down when it's done. If it needs a GPU, it can request one.

  cloudrouter start ./my-project
  cloudrouter start --gpu B200 ./my-project
  cloudrouter ssh cr_abc123 "npm install && npm run dev"

Every VM comes with a VNC desktop, VS Code, and Jupyter Lab, all behind auth-protected URLs. When the agent is doing browser automation on the VM, you can open the VNC URL and watch it in real time. CloudRouter wraps agent-browser [1] for browser automation.

  cloudrouter browser open cr_abc123 "http://localhost:3000"
  cloudrouter browser snapshot -i cr_abc123
  # → @e1 [link] Home  @e2 [link] Settings  @e3 [button] Sign Out
  cloudrouter browser click cr_abc123 @e2
  cloudrouter browser screenshot cr_abc123 result.png

Here's a short demo: https://youtu.be/SCkkzxKBcPE
What surprised me is how this inverted my workflow. Most cloud dev tooling starts from cloud (background agents, remote SSH, etc) to local for testing. But CloudRouter keeps your agents local and pushes the agent's work to the cloud. The agent does the same things it would do locally — running dev servers, operating browsers — but now on a VM. As I stopped watching agents work and worrying about local constraints, I started to run more tasks in parallel.
The GPU side is the part I'm most curious to see develop. Today if you want a coding agent to help with anything involving training or inference, there's a manual step where you go provision a machine. With CloudRouter the agent can just spin up a GPU sandbox, run the workload, and clean it up when it's done. Some of my friends have been using it to have agents run small experiments in parallel, but my ears are open to other use cases.
Would love your feedback and ideas. CloudRouter lives under packages/cloudrouter of our monorepo https://github.com/manaflow-ai/manaflow.
[1] https://github.com/vercel-labs/agent-browser

value: Show HN: Skill that lets Claude Code/Codex spin up VMs and GPUs


value: saisrirampur

value: Show HN: Pg_stat_ch, a Postgres extension to export every metric to ClickHouse

author: saisrirampur


value: Niout

value:
Hey HN! We're building Hikoo, a GEO (Generative Engine Optimization) platform for businesses that want to understand and improve how they appear in AI-powered search (ChatGPT, Perplexity, Gemini, Google AI Overviews).
The problem: 60% of searches now end without a click, and 83% when AI Overviews are present. Your SEO can be perfect, but if AI engines don't mention you, you're invisible to a growing share of users.
What Hikoo does:
- Monitors how AI engines answer queries relevant to your business
- Tracks your brand's presence, sentiment, and ranking across ChatGPT, Perplexity, Gemini
- Identifies gaps: queries where competitors get cited but you don't
- Gives actionable recommendations to improve your AI visibility
We're two co-founders based in France, currently serving 6 clients (agencies and SMBs). Starting at €30/mo — we wanted to make this accessible, not just an enterprise play.
Would love feedback from the HN community. What would you want to track about your brand in AI search?

value: Show HN: Hikoo – Track and optimize how AI search engines talk about your brand

author: Niout


value: somesortofthing

value:
I was frustrated with how bad a signal of progress through a big PR "Files viewed" was, so I made a "Lines viewed" indicator to complement it.
Designed to look like a stock Github UI element - even respects light/dark theme. Runs fully locally, no API calls.
Splits insertions and deletions by default, but you can also merge them into a single "lines" figure in the settings.

value: Show HN: GitHub "Lines Viewed" extension to keep you sane reviewing long AI PRs

author: somesortofthing


value:
Hey HN! I noticed most AI thumbnail generators produce that obvious "AI aesthetic": over-saturated, cartoonish, generic.
So I built PeekPak to generate thumbnails that actually look professional.
Would love to hear some feedback.

value: Show HN: I made an AI thumbnail generator without the AI look


value: sburl

value:
Blog post: https://spencerburleigh.com/blog/2026/02/13/crosscheck/
Repo: https://github.com/sburl/CrossCheck

value: Show HN: Open-source CI for coding with AI

author: sburl


value:
Most e-commerce stores are bleeding money. Not from lack of sales – from inefficiency they can't see.
MarginAI finds profit leaks and fixes them automatically:
- Underpriced products
- Wasted ad spend
- Dead inventory
The catch: you have to trust an AI to make decisions for you.
I built an "autonomy dial" so you control how much freedom it has. Suggestions only? Semi-autonomous? Fully autonomous?
Live demo: https://marginai.vercel.app
Would love feedback on where the trust line is. What would make you comfortable letting AI run your store?

value: Show HN: I built an AI that runs your Shopify store while you sleep


value: BhuvanChalla

value:
I built OPP (Open Provenance Protocol), an open standard for verifying whether an image was AI-generated even after screenshots, distortion, pixel fudging, compression, cropping, and re-uploads.
The problem: C2PA/Content Credentials embed metadata in the file. Screenshot the image and the provenance is gone. AI detectors are probabilistic and unreliable.
OPP takes a different approach, an external fingerprint registry. When a generator creates an image, a 3-layer signature (SHA-256 + PDQ perceptual hash + CLIP ViT-L/14 embedding) is registered in a central index. Anyone can verify an image by querying the index. The signature survives any transformation because it's not embedded in the file. Think Shazam for images, but for provenance.
Matching pipeline: exact hash lookup → CLIP cosine similarity via Qdrant HNSW (sub-10ms at billions) → PDQ hamming distance enrichment.
Only verified AI generators can mint. Verification is open.
The interesting part (new feature): I designed and implemented "Adaptive Variant Tracking." When a verification query finds a high-confidence fuzzy match (CLIP > 0.92, PDQ distance < 20), the system automatically mints a variant signature linked to the original. This means the registry "learns" the screenshot/crop/edit. The next verification of that same screenshot becomes an O(1) exact hash match instead of a costly vector search. The most viral/circulated images (highest misuse risk) become the fastest to verify.
Looking for feedback on the protocol design and poking holes in the design approach.

value: Show HN: C2PA is broken. I fixed it with an adaptive registry and open protocol

author: BhuvanChalla


value: hnarayanan

value: Show HN: Gridpaper: Scientific figures in the browser (gnuplot, WASM)

author: hnarayanan


value:
With all the home security cam privacy issues in the news recently, I thought I'd share my project.
For about 3 years, I self-hosted my security camera system on the Synology surveillance station. It fit a lot of my needs, but I hated the hardware lock in. I was getting more and more frustrated with Synology's behavior, but I didn't find any alternatives I liked better.
So on Christmas 2025 I decided to put Claude Code to the test. I fully transitioned to this about two weeks later. I've been running 14 IP cameras doing 24/7 recording with live streaming and ML-powered detection.
The stack is FastAPI + React + PostgreSQL, orchestrated with Docker. Video is handled by FFmpeg with a single process per camera that does both live HLS streaming and MP4 recording simultaneously, so you don't burn multiple RTSP connections per camera.
It runs YOLO11 via ONNX Runtime on live HLS segments (no extra RTSP connections needed), uses background subtraction to skip static frames, and has a finite state machine that tracks object arrivals, departures, and state changes rather than just firing "person detected" over and over. Each event gets a snapshot with bounding boxes and an extracted video clip. There's also a Vision LLM integration that can describe what's happening in a scene.
Storage uses a tiered system (hot/warm/cold) with automatic migration, so recordings age off from fast local storage to larger drives and optionally to S3 (that part is still in-progress).
It supports GPU acceleration but also runs fine in CPU-only mode.
I know nothing about React, I've never been a front-end developer, so that's 99.99% Claude. I have edited some CSS though. I've personally done more work on the backend, but it's still mostly Claude. This is currently running behind my home VPN only, so the user management/authentication is kind of weak at the moment. I'd love feedback!

value: Show HN: I built a self-hosted network video surveillance system


value: AquiGorka

value: Show HN: Focus windows by scrolling or looking at another monitor

author: AquiGorka


value: kovaaksplayer

value: Show HN: I'm solo-building a privacy browser in Tauri

author: kovaaksplayer


value: mfcmatheus

value: Interceptor is an on-demand translation compiler that scans your code for translation calls, translates missing strings via an LLM, and writes them into your i18n message files. It keeps translation management aligned with how teams actually ship software: by extracting from source, preserving manual edits, and generating only what’s missing.

value: Show HN: Node.js LLM internationalization compiler: Scan code and Auto-Translate

author: mfcmatheus


value: startabuild

value: Show HN: SparkBuilt – Opportunity

author: startabuild

title: Show HN: SparkBuilt – Opportunity


value: notkurt

value:
If you’ve used Claude Code on anything non-trivial, you’ve hit the wall. The project gets big enough that context falls apart between sessions. You start a new chat, re-explain the architecture, and watch it make the same mistake it made last week. Every session starts with this painful bootstrap where you’re trying to get the model back to where it was yesterday.
This obviously assumes Claude Code is doing most of the heavy lifting on your codebase. If you’re only using it for the occasional function, you probably don’t need this.
I spent a few days hacking on workarounds for this and eventually pulled them together into Ghost. It hooks into Claude Code sessions, summarises them, and indexes everything into QMD https://github.com/tobi/qmd for semantic search.
Next session, relevant context gets injected automatically. What you were working on, what decisions were made, what already failed.
It also keeps a mistake ledger. Things that went wrong get tracked and surfaced as warnings so you stop walking into the same walls.
Sessions are stored as markdown in .ai-sessions/ (gitignored).
Summaries get attached to commits as git notes so context travels with the code. Everything runs locally, nothing leaves your machine.
Built with Bun. Hooks run under 100ms.
It’s early and rough but anecdotally it feels like it actually works.

value: Show HN: Ghost – Session memory for Claude Code (local, qmd, Git-integrated)

author: notkurt


value: Show HN: Tide Commander – Visual Agents Orchestrator for Claude Code and Codex


value: lldougl

value: Show HN: Moatifi – Free Buffett-style moat analysis for stocks

author: lldougl


value: ishyfishyy

value: Show HN: An MCP server that gives AI assistants a live Mermaid diagram canvas

author: ishyfishyy


value:
I am developing the ARA-Engine, a Python-based framework designed to quantify the Alberta electricity market transition.
In merchant power markets like Alberta’s, institutional desks have proprietary tools to map real-time grid volatility to equity valuations. Retail traders, however, often rely on lagging financial statements. This project aims to bridge that gap by building an automated pipeline that connects AESO (ISO) API data directly to asset-level SOTP (Sum-of-the-Parts) models.
Current Functional Scope:
- Real-time mapping of TSX-listed utility tickers to physical grid assets.
- Quantitative tracking of "Capture Price" vs. "Pool Price" to identify revenue cannibalization in renewables.
- Modeling the 2026 TIER carbon framework as a merchant margin indicator.
I’m looking for general advice on the architecture, but specifically: Is it viable to use these high-frequency grid indicators to inform medium-term equity trades? Or is the institutional advantage in this sector (via weather modeling and transmission forecasting) too wide for an open-source framework to bridge?

value: Show HN: ARA-Engine – Modeling the Alberta power grid transition in Python


value: trezm

value:
Thought this might be useful to some folks. Planning on adding other CLIs in the near future, contributions welcome.
Some neat features:
- Web UI with mobile friendly buttons (arrows, enter, etc.)
- Separate background task for agents (so the server can restart without destroying in progress sessions)
- Github integration
- Notifications when user intervention is required
Hope y'all like it!

value: Show HN: Superposition, open source access to Claude Code or Codex from anywhere

author: trezm


value: PrimeStark

value:
Hey HN,
I quit my engineering manager job last week. Family of 4, no safety net. Built and launched AccessiGuard in 6 days — first commit to production.
It's a WCAG 2.1 scanner that checks websites for accessibility issues and gives you actual fix suggestions (code snippets, not just "fix this").
How it works:
- Fetches your page, parses the HTML with Cheerio, runs 22 custom checks against WCAG 2.1 AA criteria
- Crawls linked pages on the same domain for multi-page scans
- AI fix suggestions via OpenAI — points you to the exact element and tells you what to change
- PDF reports, score tracking over time, monitoring for regressions
What it catches:
Missing alt text, form labels, heading structure, ARIA issues, viewport zoom blocking, skip nav, duplicate IDs, generic link text, table headers, and more. Full list: https://accessiguard.app/scan-coverage
What it doesn't catch (being honest):
No color contrast checking yet — that needs computed styles which requires a real browser. Currently on the roadmap alongside Puppeteer integration. Same goes for keyboard trap detection and SPA rendering.
Stack: Next.js 15, Supabase, Cheerio, OpenAI, Stripe, Vercel.
Pricing: Free tier is 5 scans/month. Paid starts at $29/mo. Agency plan is $99/mo for 50 sites.
Why another scanner? Most tools are either enterprise-priced, overlays that don't actually fix anything (the FTC fined accessiBe for this), or black boxes that don't tell you what they test. I wanted something transparent, affordable, and useful for developers who actually want to fix their code.
Would love feedback on scan accuracy, things I'm missing, or if the reports are actually useful. Happy to answer architecture questions.

value: Show HN: AccessiGuard – Web accessibility scanner with AI fix suggestions

author: PrimeStark


value: kasathur

value: Show HN: MCP tools that let AI agents dispatch batteries and prove carbon

author: kasathur


value: schreibertuc

value:
Hey HN,
I built Mimir because I kept running into the same problem: deciding what to build, how to build it, and how to prioritize it against everything else.
Tools like Cursor make it easier to write code. But they don’t help you decide what code is worth writing. Mimir is my attempt to close that gap.
Here’s what it does:
- Paste or upload customer interviews, feedback, support tickets, usage notes (text, PDFs, screenshots)
- Extracts structured entities (pain points, feature requests, quotes, metrics)
- Synthesizes themes across all sources with evidence attribution
- Generates prioritized recommendations with impact projections
- Produces development-ready specs and pushes them to GitHub so agents (or humans) can start building
- Includes different chat modes for exploring ideas, refining scope, or generating new directions
The goal is to turn messy qualitative input into something structured, defensible, and ready for execution.

value: Show HN: Mimir – Cursor for Product Managers

author: schreibertuc


value: miketromba

value:
Hey HN, I built issy, a lightweight issue tracker that stores issues as markdown files in a `.issues/` directory in your repo.
The idea is simple: issues should live with your code. They show up in diffs, travel with branches, and don't require accounts, databases, or external services. They're just markdown files with YAML frontmatter.
It's built for AI coding assistants. You can tell Cursor/Claude/Codex (or any AI agent) things like "create a bug for the login redirect issue, high priority" and it handles the rest — creating, searching, updating, and closing issues through natural language. There's a Cursor skill you can install with `npx skills add miketromba/issy`.
It also comes with a CLI for filtering/searching and a local web UI at localhost:1554 for when you want a visual overview.
Key points:
- Zero infrastructure — no DB, no accounts, no SaaS
- Issues are git-native — visible in PRs, blame-able, branch-able
- Fuzzy search with typo tolerance
- Monorepo-aware (walks up the directory tree to find .issues/)
- Works offline
Blog Post: https://mike.gg/issy
GitHub: https://github.com/miketromba/issy

value: Show HN: Issy – AI-native issue tracking stored as Markdown files in your repo

author: miketromba


value:
Hi HN! I'm currently a Master's student at USTC (University of Science and Technology of China). I've been diving deep into Data Engineering, especially in the context of Large Language Models (LLMs).
The Problem:
I found that learning resources for modern data engineering are often fragmented and scattered across hundreds of medium articles or disjointed tutorials. It's hard to piece everything together into a coherent system.
The Solution:
I decided to open-source my learning notes and build them into a structured book. My goal is to help developers fast-track their learning curve.
Key Features:
LLM-Centric: Focuses on data pipelines specifically designed for LLM training and RAG systems.
Scenario-Based: Instead of just listing tools, I compare different methods/architectures based on specific business scenarios (e.g., "When to use Vector DB vs. Keyword Search").
Hands-on Projects: Includes full code for real-world implementations, not just "Hello World" examples.
This is a work in progress, and I'm treating it as "Book-as-Code". I would love to hear your feedback on the roadmap or any "anti-patterns" I might have included!
Check it out:
Online: https://datascale-ai.github.io/data_engineering_book/
GitHub: https://github.com/datascale-ai/data_engineering_book

value: Show HN: Data Engineering Book – An open source, community-driven guide


value: rosslazer

value:
I was inspired by mitchellh's Vouch project, an explicit trust system where maintainers vouch for contributors before they can interact with a repo. Ghostty uses it to filter out AI slop PRs.
Because Vouch exposes the vouch list as a plain text file (VOUCHED.td), I realized I could aggregate them across GitHub and build a reputation index. A crawler finds every VOUCHED.td file, pulls the entries, and computes a weighted score per user. Vouches from high-star repos count more than vouches from zero-star repos.
Next step is to wire up an API so that the vouch GH action can start to use this data to auto approve contributors.

value: Show HN: A reputation index from mitchellh's Vouch trust files

author: rosslazer


value: vcoppola

value:
For nearly a decade, I've wanted a SQL formatter that followed Simon Holywell's style guide (https://sqlstyle.guide). If you're unfamiliar with it, one of its key (and most controversial) features is “river alignment” of keywords. I couldn’t find an existing formatter that implemented it, so I made Holywell.
Try it in the browser: https://holywell.sh
Repo: https://github.com/vinsidious/holywell
The site has a bunch of scrollable examples so you can quickly see what the formatted SQL looks like.
Dialect support is pretty basic right now (I’m mostly a Postgres user), but I’d love requests / failing examples for other dialects. Also, PRs are very welcome.
Disclaimer: not endorsed by Simon Holywell. I tried to be faithful to the guide (and where the guide is ambiguous, I had to interpret). Also: I’m not claiming this style is “best” — just that it’s the one I’ve wanted for a long time.
Please share your thoughts and let me know where it falls short!

value: Show HN: Holywell – The missing SQL formatter for sqlstyle.guide

author: vcoppola


value: purplejacket

value:
Bubble sort is pretty simple in most programming languages ... what about on a Turing Machine?  I used all three of Claude 4.6, GLM 5, and GPT 5.2 to get a result, so this exercise was not quite trivial, at least at this time. The resulting machine, bubble_sort_unary.yaml, will take this input:
111011011111110101111101111
and give this output:
101101110111101111101111111
I.e., it's sorting the array [3,2,7,1,5,4].  The machine has 31 states and requires 1424 steps before it comes to a halt.  It also introduces two extra symbols onto the tape, 'A' and 'B'. (You could argue that 0 is also an extra symbol because turinmachine.io uses blank, ' ', as well).
When I started writing the code the LLM (Claude) balked at using unary numbers and so we implemented bubble_sort.yaml which uses the tape symbols '1', '2', '3', '4', '5', '6', '7'.  This machine has fewer states, 25, and requires only 63 steps to perform the sort. So it's easier to watch it work, though it's not as generalized as the other TM.
Some comments about how the 31 states of bubbles_sort_unary.yaml operate:

  | Group | Count | Purpose |
  |---|---|---|
  | `seek_delim_{clean,dirty}` | 2 | Pass entry: scan right to the next `0` delimiter between adjacent numbers. |
  | `cmpR_*`, `cmpL_*`, `cmpL_ret_*`, `cmpL_fwd_*` | 8 | Comparison: alternately mark units in the right (`B`) and left (`A`) numbers to compare their sizes. |
  | `chk_excess_*`, `scan_excess_*`, `mark_all_X_*` | 6 | Excess check: right number exhausted — see if unmarked `1`s remain on the left (meaning L > R, swap needed). |
  | `swap_*` | 7 | Swap: bubble each `X`-marked excess unit rightward across the `0` delimiter. |
  | `restore_\*` | 6 | Restore: convert `A`, `B`, `X` marks back to `1`s, then advance to the next pair. |
  | `rewind` / `done` | 2 | Rewind to start after a dirty pass, or halt. |

(The above is in the README.md if it doesn't render on HN.)
I'm curious if anyone can suggest refinements or further ideas.  And please send pull requests if you're so inclined.  My development path:  I started by writing a pretty simple INITIAL_IDEAS.md, which got updated somewhat, then the LLM created a SPECIFICATION.md.  For the bubble_sort_unary.yaml TM I had to get the LLMs to build a SPEC_UNARY.md because too much context was confusing them.  I made 21 commits throughout the project and worked for about 6 hours (I was able to multi-task, so it wasn't 6 hours of hard effort). I spent about $14 on tokens via Zed and asked some questions via t3.chat ($8/month plan).
A final question:  What open source license is good for these types of mini-projects?  I took the path of least resistance and used MIT, but I observe that turingmachine.io uses BSD 3-Clause.  I've heard of "MIT with Commons Clause;" what's the landscape surrounding these kind of license questions nowadays?

value: Show HN: Bubble sort on a Turing machine

author: purplejacket


value:
Hey HN,
I built Engram because every time I started a new Claude Code session, it forgot everything. Same questions, same mistakes, zero context. AI agents have Alzheimer.
Engram is a memory layer for AI agents. Store facts, preferences, and decisions. Search them with full-text search. Recall the most important ones for context injection. 5 lines of Python, zero config.

  from engram import Memory
  mem = Memory()
  mem.store("User prefers dark mode", importance=8)
  results = mem.search("dark mode")
  context = mem.recall(limit=10)

What makes it different from Mem0/Letta/Zep:
Local-first: SQLite, runs on your machine. No cloud, no API keys, no telemetry.
Zero config: pip install engram-core and go. No Docker, no Postgres, no vector DB.
MCP native: First-class Model Context Protocol support — plug into Claude Code, Cursor, or any MCP client.
Privacy: Your data never leaves your machine. MIT licensed.
I use it daily with Claude Code via an auto-recall hook — every new session starts with my important memories pre-loaded. No more "where were we?"
Built with: Python, SQLite FTS5, FastAPI, MCP SDK.
Website: https://engram-ai.dev
GitHub: https://github.com/engram-memory/engram
PyPI: pip install engram-core
Would love feedback. What memory features would you want for your agents?

value: Show HN: Engram – Persistent memory for AI agents, local-first and open source


value: kunronuri

value:
Hi HN,
I'm a beginner developer from Japan.
I built this tool because I was tired of opening Photoshop just to redact a name or a face from a screenshot. I didn't want to use existing "free online tools" because uploading sensitive images to a random server felt unsafe.
So I built Kuro-Nuri ("Blacked Out" in Japanese).
It runs entirely in the browser using WebAssembly and TensorFlow.js (for auto-detecting faces). No data leaves your device.
Features:
- Drag & drop to auto-redact faces.
- Client-side compression.
- Removes Exif metadata automatically.
The code is still a bit messy as I'm learning, but I'd love to hear your feedback on the performance and usability.
Thanks!

value: Show HN: Kuro-Nuri – Browser-based image redaction and compression using WASM

author: kunronuri


value: LordHumungous

value: A way to make you auth tokens totally hidden from OpenClaw. The idea:<p>* Put all auth tokens into a secrets directory<p>* Run OpenClaw in sandbox-exec mode using a shell wrapper. OpenClaw process is blocked by the OS from accessing secrets.<p>* OpenClaw routes API requests to HTTP proxy that injects auth tokens.

value: Show HN: ClawProxy: An HTTP proxy that injects auth tokens into API calls

author: LordHumungous


value:
Hi HN. I got tired of uploading my data to ChatGPT, having a useful conversation, then realizing a week later I need to re-upload again, because data changed.
Built ctxsync to fix it:
• Connect GitHub repos, documentation sites, files
• Sync on demand or schedule – your AI's knowledge stays current
• Data isolation: each chat runs in separate containers, no cross-contamination
Uses your own LLM API keys (OpenAI, Anthropic, Kimi-Code).
Early access: free
What do you think?

value: Show HN: Ctxsync – Chat with your codebase that stays in sync


value: gucduck

value:
Hey HN
I’ve been thinking a lot about barriers to civic participation. Most people don’t show up to town halls. They don’t respond to traditional surveys. And a lot of online political spaces feel loud, adversarial, or exhausting.
So I started wondering what happens if you make participation radically lightweight.
That’s where Civie comes in.
Each day you answer one to three short civic questions. It takes under a minute. Responses are anonymous. Results are shown only in aggregate. Over time, those responses accumulate into an open dataset anyone can explore.
This isn’t scientific polling, and it’s not pretending to be. The samples are self selected and nuance gets flattened. That’s an intentional tradeoff. The bet is that if participation is fast, anonymous, and recurring, more people might actually show up.
Civie is built around a few core pillars. Lower the barrier to participation. Make it safe to answer honestly. Keep the results transparent and open. And allow signal to emerge both from individual questions and from patterns over time.
I’d really value feedback on the core concept. Does a daily cadence make sense? Is anonymity enough to meaningfully lower friction? Are open aggregate results actually useful, or just interesting? What would make this something you’d return to?
If you’re curious, you can join the beta waitlist at civie.org. I’m onboarding early users in small batches and would love thoughtful testers, skeptics, and critics.
Any level of feedback and discussion welcome. Thanks!
--
A few implementation details
Civie is currently built with Next.js on the frontend and Firebase (Auth + Firestore) on the backend. It’s deployed on Vercel. The data model is intentionally simple: questions are versioned objects, and responses are stored as structured documents tied to a question ID and timestamp.
On anonymity: responses are not publicly tied to user profiles. There are no public accounts, no comment threads, and no way to see how an individual answered. The system stores responses separately from any identifying information, and aggregation happens at the query layer before display. The UI only ever exposes aggregate counts and distributions.
On identity verification: participation can require account creation to limit spam and abuse. Verification status (for example, SMS verification or identity verification via a third-party provider) is stored separately from response data. The system tracks whether a response came from a verified participant, but does not attach identity to the answer itself.

value: Show HN: Civie. Anonymous civic questions. Open results. No yelling

author: gucduck


value: mazenkurdi

value: Show HN: Darius – An AI router that selects the best model for each prompt

author: mazenkurdi


value: trevxr

value:
You're probably running Claude Code with `--dangerously-skip-permissions`. Or Codex in full-auto. Or an OpenClaw agent with unsupervised shell access.
Nothing stops a hallucination from running `rm -rf ~` or reading your SSH keys while you're getting coffee. I built Rampart after my own agent nearly nuked a directory on my home lab.
It checks every command against YAML rules before it executes. Dangerous stuff gets blocked. Everything gets logged.

    brew install peg/rampart/rampart
    rampart setup claude-code

Two commands, runs locally, no account. Works with Claude Code, Codex, Cline, Cursor, or anything with a CLI. Go, Apache 2.0.

value: Show HN: Rampart – Runtime firewall for Claude Code and AI agents in YOLO mode

author: trevxr


value: warrenjday

value:
The reddit algorithm rewards posts that get engagement within the first 5 minutes. So it's important to post when users are actually online.
I picked the best 40 subreddits for sharing your ideas/apps. Scraped the hourly online user data for a month. Then loaded it all into a chart.
It's a free tool, no login needed.

value: Show HN: Reddit Online User Tracker – Find the Best Time to Post on Reddit

author: warrenjday


value: arjunchint

value:
Rover is the world's first Embeddable Web Agent, a chat widget that lives on your website and takes real actions for your users. Clicks buttons. Fills forms. Runs checkout. Guides onboarding. All inside your UI.
One script tag. No APIs to expose. No code to maintain.
We built Rover because we think websites need their own conversational agentic interfaces as users don't want to figure out how your site works. If they don't have one then they are going to be disintermediated by Chrome's or Comet's agent.
We are the only Web Agent with a DOM-only architecture, thus we can setup an embeddable script as a harness to take actions on your site. Our DOM-native approach hits 81.39% on WebBench.
Beta with embed script is live at rtrvr.ai/rover.
Built by two ex-Google engineers. Happy to answer architecture questions.

value: Show HN: Rover – Embeddable web agent

author: arjunchint

title: Show HN: Rover – Embeddable web agent


value: hckdisc

value:
We built TrustVector (trustvector.dev for website) because “which model/agent/tool should we trust?” keeps getting answered with vibes, marketing, or outdated benchmarks. And a lot of our enterprise customers kept asking about it.
TrustVector is an open-source evaluation framework + public directory where each system gets a multi-dimensional trust score across:
- Security (prompt injection/jailbreak resistance, data leakage)
- Privacy & compliance
- Trust & transparency (hallucination/bias, documentation quality)
- Performance & reliability
- Operational excellence
Key idea: every score is evidence-based (sources + confidence), and you can re-weight dimensions CVSS-style depending on your use case.
Current coverage: 100+ evaluations across models, agents, and MCP servers.
GitHub + methodology are linked from the site. I’d love feedback on:
1) whether the dimensions/weighting are sane,
2) what evidence sources we’re missing,
3) What contribution workflow would make this actually community-maintained?
(Also: this project is not affiliated with trustvector.ai.)

value: Show HN: TrustVector – Trust evaluations for AI models, agents, & MCP

author: hckdisc


value: sowmith-tsrc

value: Show HN: Clonar – A Node.js RAG pipeline with 8-stage multihop reasoning

author: sowmith-tsrc


value:
Hey HN, I built InfoSecList.com because I got tired of the way security teams evaluate tools.
Every time we needed a new DAST scanner or pentest vendor, it was the same drill: Google around, read SEO-optimized listicles written by people who never used the tools, sit through 3-5 sales demos, and hope for the best.
InfoSecList is a directory of 90+ cybersecurity tools and services across 21 categories. Every listing gets two scores from practitioners:
- Market Score (1-5): industry adoption and brand recognition
- Value Score (1-5): actual value for money based on usage
You can browse by category (DAST, SAST, SCA, pentest services, bug bounty platforms, etc.), compare tools side-by-side, or look up alternatives to specific products.
A few things that might be interesting technically:
- Data lives in a Google Sheet, served via a PHP proxy as CSV, parsed client-side
- Pages are dynamic SPA-style but with clean URLs for SEO
- Each tool/alternative/category page generates its own structured data and meta tags from the CSV data at runtime
- No framework, no build step. Plain HTML, CSS, vanilla JS
No accounts, no gated content, no pay-to-rank. Happy to answer any questions about the approach or the security tool landscape.
Stack: Apache, vanilla JS, Google Sheets as CMS, Let's Encrypt
Follow-up Comment (if asked about data/methodology)
The scores come from a combination of:
- Gartner/Forrester positioning for Market Score
- Community sentiment (Reddit, HN, security forums) for both scores
- Direct practitioner feedback from CISOs and security engineers
- Pricing transparency and free tier availability for Value Score
We deliberately keep it simple with two 1-5 scores rather than trying to build a complex weighted system. The goal is to help someone go from "I need a DAST tool" to a shortlist of 3-4 options in under 5 minutes.
Open source tools like Nmap, OWASP ZAP, and Trivy tend to score 5/5 on Value. Enterprise tools like CrowdStrike and Mandiant score 5/5 on Market but lower on Value due to pricing.
Follow-up Comment (if asked about business model)
Right now it's free with no monetization. Long term we're considering:
- Featured listings (clearly marked, doesn't affect scores)
- Lead gen for vendors (opt-in only, buyer initiates contact)
We won't do pay-to-rank. The scores stay independent.

value: Show HN: Infoseclist.com – Compare 90 cybersecurity tools ranked by practition


value: This is my take on the overdone to-do app.

value: Show HN: Create a clean tree graph of your projects with my App on iOS


value: okaris

value: Show HN: We open-sourced MusePro, a Metal-based realtime AI drawing app for iOS

author: okaris


value:
I built a small stdlib-only tool to make API key handling deterministic and CI-safe.
Resolves from ENV → .env → vault, with optional runtime validation probes.
No deps beyond Python stdlib.
Example:
from api_pilot import resolve_key
client = OpenAI(api_key=resolve_key("openai", validate=True))
CLI doctor command:
$ api-pilot-doctor
 .env file found
 OPENAI_API_KEY found in environment
Modes:
• Default: ENV → .env → vault
• Validation: optional runtime API probes
• Strict: fails if .env used (CI safety)
MCP integration ready.
Feedback welcome!

value: Show HN: API-pilot – deterministic API key resolution with runtime validation


value: frankbyte

value: Show HN: Claw Patrol – so that's where the quota went

author: frankbyte


value: krasotkin

value:
I'm taking a course and we have a project to make an animation with JS and the HTML canvas. I started with a Mandelbrot zoom. I kept coming back to the project trying to optimize anything I could. I've made every optimization I could think to do and put this together for others to play around with. Most people would not reach for JavaScript as the best tool to render the Mandelbrot set, but because I had to for the assignment, the optimizations I made helped me learn a lot.
Code at: https://github.com/bryanhoffman/cis-223-animation-template-m...

value: Show HN: Vanilla JavaScript Mandelbrot Explorer

author: krasotkin


value: godalida

value: Show HN: Koala Diff – High-performance local data comparison (Rust and Polars)

author: godalida


value:
Hi HN,
I’ve been working on a side project called ipiphistory.com.
It’s a searchable explorer for:
– ASN relationships (provider / peer / customer)
– BGP route history
– IP to ASN mapping over time
– AS path visibility
– Organization and geolocation data
The idea started from my frustration when explaining BGP concepts to junior engineers and students — most tools are fragmented across multiple sources (RouteViews, RIPE RIS, PeeringDB, etc.).
This project aggregates and indexes historical routing data to make it easier to:
– Understand how ASNs connect
– Explore real-world routing behavior
– Investigate possible hijacks or path changes
– Learn BGP using real data
It’s still early and I’d really appreciate feedback from the HN community — especially on usability and features you’d like to see.
Happy to answer technical questions about data ingestion and indexing as well.

value: Show HN: Explore ASN Relationships and BGP Route History with Real Internet Data


value: danielgafni

value: Show HN: Metaxy – versioning for multimodal data pipelines

author: danielgafni


value: anateus

value:
Howdy, Open Notes co-founder here!
At Open Notes, we're building a system for community-driven constructive moderation and annotation that can be added to anything. Under the hood, we're using the open-source Twitter/X Community Notes algorithm (though that doesn't really kick in until you've got some scale). We're interested in providing everyone with tools for managing discourse that go beyond traditional moderation. Discord is the demo/reference integration, but we want it go anywhere and everywhere. Part of our thesis is that we want to get to where people are already talking rather than drag them to a clean and empty new room where we ask them to continue the conversation.
It's interesting that Pol.is was just recently on HN (https://news.ycombinator.com/item?id=46992815) because we're obviously inspired by them as well as the whole canon of social choice theory--we're just going at it from a different angle. It's long been true that if you wanted to trap me/yourself in a conversation, you could just bring up the Condorcet criterion (amongst others), so I'm finally turning an obsession into an actual product.
We want to enable people to make decisions about conversations as close to the conversation as possible while minimizing impact on live threads. Later, this nicely extends into all sorts of group decisionmaking. As our conversations are increasingly awash in AI of all sorts (as moderators, participants, analysts, etc.), things that help manage the discourse to fit the needs of individual communities need to be scalable but without drowning human choice in an ocean of automation.
Also, we're open-source: https://github.com/opennotes-ai/opennotes
Would love to hear people's thoughts and reactions. This has so much surface area ("all online discourse"), it's hard to formulate specific questions so instead we built a thing and now we'd love to see if it works for folks.

value: Show HN: Open Notes – Community Notes-style context for Discord

author: anateus


value: IsruAlpha

value: 14 Chat helps you chat with your crush and shoot your shot. (safely) you can start 100% for Free!

value: Show HN: Text your crush today (Feb 14) but for singles

author: IsruAlpha


value:
Hi HN. I’m Alby. My cofounder Abdul and I are building Clovr.
We’ve been talking to backend-heavy founders and full-stack engineers who keep running into the same issue: the ideation stage to frontend setup is slow. Not necessarily tweaking UI, but scaffolding the initial layout system, routing, component structure, spacing scale, etc. It’s repetitive work but it can set the tone for everything that follows.
Most "vibe-design" tools we tested either generate mockups or output code that looks fine in a screenshot but isn’t structured in a way you’d want to extend.
Clovr’s current approach is to generate a structured Next.js project from a prompt. An actual scaffold with a consistent design system and readable components. The goal is to make the output something you’d actually commit and build on.
Right now it focuses on greenfield projects. We’re experimenting with:
- How opinionated the design system should be
- How much control to expose vs abstract
- What “ready to use” should mean for generated frontend code
It’s still early and we’re actively validating and refining the generation pipeline.
If you’re building frontends and this sounds interesting, there’s a small waitlist up!
Would genuinely appreciate feedback from people who ship real apps.

value: Show HN: Clovr – Generate structured Next.js front ends from a prompt


value: hedayet

value: Show HN: ROX – a minimal language with explicit errors and no magic

author: hedayet


value: vadepaysa

value: Show HN: Shot2 – Screenshots that don't waste your tokens (Free, OSS, MIT)

author: vadepaysa


value: Show HN: Modeling "Dragon King" wildfire events with 5-mile frontier effects


value: shtrsg

value: Show HN: Upload App Store Screenshots Directly from Figma to App Store Connect

author: shtrsg


value: samstorm

value: Show HN: Ghostcfg – A TUI for editing your Ghostty terminal config

author: samstorm


value: arwt

value:
I used to play this daily with friends, but the original (killercrossword.com - I found this via a Show HN years ago!) appears to be down nowadays, so I have recreated it with the help of my mate Claude.
It's a crossword with no clues, just a grid with a few pre-filled letters to get you started. You deduce the words from the letter intersections alone. Like Wordle, there's one set of puzzles per day (resets at midnight local time).
The goal is simple: complete the grid in as little time as possible, using as few hints as you can. Then share your score with friends. If the first puzzle is too easy, you can attempt a harder "master" version of it.
The entire thing is self-contained, so feel free to save the page and host it elsewhere if you want to guarantee long-term playability.

value: Show HN: Killer Crossword

author: arwt

title: Show HN: Killer Crossword


value: ahmadwasfi

value:
Most modern frameworks model UI as a function of state: change state, re-render. but modern rich UX is increasingly about the space between states. It is about how to represent a smooth transition between states to have a fluid UI.
Today, we handle these "in-betweens" state by bolting on external libraries like Framer Motion or GSAP. These often feel like a  continuous fight of synching two separate models.
I am building TargetJS to experiment with a different model: State as a Destination. In TargetJS, you don't just set a state instead you set a target for the framework to achieve. It treats the journey from state A to B as a first-class citizen.
Key Architectural Shifts:
- Implicit state and lifecycles: Every class field and function tracks its own progress.
- Linear execution: The code executes how it written from top to bottom with no jumps. Complicated flow are structuring the work into parent child relationship.
- Syncing to asynchronous operations is done by two modes: deferred and reactive.
- Built in fetching, events, efficient animation to provide one synced stack.
It's still in early stages, and I'm mostly looking for feedback on the developer experience of this model

value: Show HN: Rethinking the UI = F(State) Model

author: ahmadwasfi


value: visiohex

value: Show HN: BabyMeme – AI baby meme generator with 7 styles

author: visiohex


value: viniciusborgeis

value: Show HN: ClipPath – Paste screenshots as file paths in your terminal

author: viniciusborgeis


value: laurentenhoor

value:
I built DevClaw, an OpenClaw plugin that turns each Telegram group into an isolated, autonomous dev team: planner/orchestrator, DEVs, and QA all running on their own. I use it for all my development now. Issues on GitLab/GitHub are the single source of truth, and three things compound to save around 70% on tokens: model tiering (Haiku for typos, Opus for architecture), session reuse across tasks, and token-free scheduling that burns zero LLM calls for orchestration.
Please try it and give some feedback. Also keen to hear from anyone running autonomous coding agents, especially what you’ve found works for model selection and session management.
Code’s all here: https://github.com/laurentenhoor/devclaw

value: Show HN: Turn OpenClaw in a high performing development team with DevClaw

author: laurentenhoor


value: planetrenox

value: Show HN: Direct-img.link for AI when you want IMG in Markdown

author: planetrenox


value: ollybrinkman

value: Show HN: Apiosk – Pay-per-request API gateway with USDC (no API keys)

author: ollybrinkman


value: Show HN: Skybolt Reflect – C++ header-only runtime reflection library


value: edouerd

value:
Hi folks, I'm Ed, one of the co-founders of Flower!
While working on an agent/human social network over the course of last year, we developed our own context/memory infrastructure that powered our agents' ability to chat with humans (or other agents), and 'gossip' chats across the network based on various qualities of the agents.
Witnessing the system live, we realized pretty quickly that generalizing this infrastructure could be really interesting, and so we've since set out to build a few experiments that show this system in use.
This is our first experiment, Hivemind.
Hivemind is a set of three agent skills (search, store, vote) that let agents share discrete knowledge/knowhow/skills with each other. Install it into Claude Code, Codex, Opencode, or any harness that supports custom skills, and your agent can pull from a shared pool of strategies and experiences contributed by other agents. When it finds something useful, it upvotes! Junk contributions sink or become less relevant over time. In a sense, Hivemind is like a minimal social network of sorts for agents.
One of our core motivations: Thousands of people independently ask their agents to solve the same problems — routing around the same bugs, re-implementing the same integrations, burning tokens on work that's already been done. Hivemind is the obvious fix: let agents teach each other. One deliberate design choice: the human is mostly out of the skill-selection loop. Agents judge utility via trust scores and voting, not a marketplace humans browse. It's agent-oriented by design. It's simple as of now, but it points to where things are probably headed.
You can check out Hivemind's source here: https://github.com/flowercomputers/hivemind
The backstory in greater detail can be read here: https://www.flowercomputer.com/news/hivemind/
Happy to discuss how hivemind memory works, agent trust mechanics, or where we're taking this next! We're planning on eventually releasing the core system that actually powers Hivemind, so other people can build cool stuff with it.
Peace,
É

value: Show HN: Hivemind – Metaskill for skill/experience sharing between agents

author: edouerd


value: sandover

value:
Even with agentic coding there's a lot of merit in keeping a strong distinction between your specs (TDD, architecture, etc.) and your backlog (your sequence of work items).
Backlogs are better off being represented as a task dependency graph, rather than a heap of markdown files, because a nice graph of tasks:
- helps agents focus
- gives better observability of partial progress
- supports parallelization better
- works well with subagents
Also, the act of planning a backlog *makes the design better* because in the act of planning, you learn things about your own design. This is as true for agents as it is for humans.
The planning modes of claude and codex blur the distinction between specs and backlog and land you in a heap of markdown files.
Steve Yegge diagnosed all this, and his solution was the beads CLI -- a brilliant idea. You just tell your agent to use this CLI for planning instead of their own plan mode (all you do is add a one-liner in your AGENTS.md file), and you get an instant planning upgrade.
However, I found the implementation of beads a little bit hairy and flaky, when I tried to use it in production. And the performance made me sad.
So I've reimplemented the core concepts, as ergo.
It's very fast (5-15x faster than beads), very robust, and rigorously simple. There is no daemon running, no SQL database, it's self-healing, and the plans are stored as JSONL, so if all else fails you can just reconstruct your plans from scratch.
Implementation:
- Plans live in `.ergo/` in your repo root (or your dir of choice). JSONL was chosen because it's git-friendly & easy to resolve merge conflicts around.
- ergo is concurrency-ready if you're into agent swarms.
Concurrent writes are serialized with flock(2). Multiple agents can race to claim tasks — exactly one wins, others fail fast.
- Do operations in huge plans of 1000+ tasks in ~15ms on a Macbook Air.
- The help text doubles as the agent manual. I spent a lot of time on `ergo --help` and `ergo quickstart` because they're the primary interface for agents.
I've been using ergo heavily for a couple months and I believe it's solid enough for anyone to use, would love your feedback.

value: Show HN: Ergo – Minimal, fast, persistent task backlog in your repo

author: sandover


value: mhcoen

value:
Most agent frameworks treat prompt injection as a model-level problem. In practice, once your agent ingests untrusted text and has tool access, you need application-layer controls — structural isolation, tool-call gating, exfiltration detection — that don't depend on the model behaving correctly. I built guardllm to provide those controls.
guardllm is a small, auditable Python library that provides:
Inbound hardening: sanitize and structurally isolate untrusted content (web, email, docs, tool output) so it is treated as data, not instructions.
Tool-call firewall: deny-by-default destructive operations unless explicitly authorized; fail-closed confirmation when no confirmation handler is wired.
Request binding: bind (tool name, canonical args, message hash, TTL) to prevent replay and argument substitution.
Exfiltration detection: scans outbound tool arguments for secret patterns and flags substantial verbatim overlap with recently ingested untrusted content.
Provenance tracking: enforces stricter no-copy rules on content with known untrusted origin, independent of the overlap heuristic.
Canary tokens: per-session canary generation and detection to catch prompt leakage into outputs.
Source gating: blocks high-risk sources from being promoted into long-lived memory or KG extraction to reduce memory poisoning.
It is intentionally minimal and not framework-specific. It does not replace least-privilege credentials or sandboxing — it sits above them.
Repo: https://github.com/mhcoen/guardllm
I'd like feedback on: what threat model gaps you see; whether the default overlap thresholds are reasonable for summarization and quoting workflows; and which framework adapters would make this easiest to adopt (LangChain, OpenAI tool calling, MCP proxy, etc.).

value: Show HN: GuardLLM, hardened tool calls for LLM apps

author: mhcoen


value: stubbi

value:
Hi there,
I found it very useful recently to have my own "Steve Jobs in my pocket" when developing with Claude Code. I can ask it what Steve Jobs would think and usually comes up with great user, simplicity, and story-first thinking.
I thought this might be useful for others, so sharing it here. In the article I also describe why I think skills are the new apps, just with different economics. If you haven't tried them yet, it's certainly worth it. Much more of a change to "default" Claude Code than without.
Happy to hear any feedback!

value: Show HN: A Steve Jobs in Your Pocket AI Skill

author: stubbi


value: peterhddcode

value: Show HN: Automate Mac with Codex: macOS Control MCP Demo

author: peterhddcode


value: settlddotwork

value:
Hey HN,
I built Settld because I kept running into the same problem: AI agents can call APIs, pay for services, and hire other agents - but there's no way to prove the work was actually done before the money moves.
The problem in one sentence: x402 tells you "payment was sent". Settld tells you "the work was worth paying for".
What it does
Settld sits between your agent and the APIs/agents it pays. It:
1. Intercepts HTTP 402 (Payment Required) responses
2. Creates an escrow hold instead of paying immediately
3. Collects evidence that the work was completed
4. Runs deterministic verification (same evidence + same terms = same payout, every time)
5. Releases payment only after verification passes
6. Issues a cryptographically verifiable receipt
If verification fails or the work is disputed, the hold is refunded. The agent gets a receipt either way - a permanent, auditable record of what happened.
Why this matters now
We're at a weird inflection point. Coinbase shipped x402 (50M+ transactions). Google shipped A2A. Anthropic shipped MCP. Agents can discover each other, communicate, and pay each other.
But nobody built the layer that answers: "was the work actually done correctly, and how much should the payout be?"
That's the gap. Right now, every agent-to-agent transaction is either "trust and hope" or "don't transact." Neither scales.
The x402 gateway (the fastest way to try it)
We ship a drop-in reverse proxy that you put in front of any API:
docker run -e UPSTREAM_URL=https://your-api.com \
           -e SETTLD_API_URL=https://api.settld.dev \
           -e SETTLD_API_KEY=sk_... \
           -p 8402:8402 \
           settld/x402-gateway
Everything flows through normally - except 402 responses get intercepted, escrowed, verified, and settled. Your agent gets a receipt with a hash-chained proof of what happened.
What's under the hood
The settlement kernel is the interesting part (and where we spent most of our time):
- Deterministic policy evaluation - machine-readable agreements with release rates based on verification status (green/amber/red). No ambiguity.
- Hash-chained event log - every event in a settlement is chained with Ed25519 signatures. Tamper-evident, offline-verifiable.
- Escrow with holdback windows - configurable holdback basis points + dispute windows. Funds auto-release if unchallenged.
- Dispute → arbitration → verdict → adjustment - full dispute resolution pipeline, not just "flag for human review."
- Append-only reputation events - every settlement produces a reputation event (approved, rejected, disputed, etc.). Agents build verifiable economic track records.
- Compositional settlement - agents can delegate work to sub-agents with linked agreements. If a downstream agent fails, refunds cascade deterministically back up the chain.
The whole protocol is spec'd with JSON schemas, conformance vectors, and a portable oracle: https://github.com/aidenlippert/settld/blob/main/docs/spec/R...
What this is NOT
- Not a payment processor - we don't move money. We decide "if" and "how much" money should move, then your existing rails (Stripe, x402, wire) execute it.
- Not a blockchain - deterministic receipts and hash chains, but no consensus mechanism or token. Just cryptographic proofs.
- Not an agent framework - we don't care if you use LangChain, CrewAI, AutoGen, or raw API calls. We're a protocol layer.
Tech stack
Node.js, PostgreSQL (or in-memory for dev), Ed25519 signatures, SHA-256 hashing, RFC 8785 canonical JSON. ~107 core modules, 494 tests passing.
What I want from HN
Honest feedback on whether this problem resonates. If you're building agent workflows that involve money, I want to know: what breaks? What's missing? What would make you actually install this?
GitHub: https://github.com/aidenlippert/settld
Docs: https://docs.settld.work/
Quickstart (10 min): https://docs.settld.work/quickstart

value: Show HN: Verify-before-release x402 gateway for AI agent transactions

author: settlddotwork


value: musecl

value: Show HN: Musecl-memory – Zero-dependency memory sync for AI agents bash and Git

author: musecl


value: wfgy-github

value:
0. Very short version
- Not a new model, not a fine-tune
- One txt block you paste into system prompt (or first message)
- Goal: less random hallucination, more stable multi-step reasoning
- No tools, no external calls, works anywhere you can set a system prompt
Some people later turn this into proper code + eval.
Here I keep it minimal: two prompt blocks you can run in any chat UI.
1. How to try it
1) Start a new chat (local or hosted model)
2) Paste the WFGY Core block into the system / pre-prompt area
3) Ask your normal tasks (math, small coding, planning, long context)
4) Compare “with core” vs “no core” by feel, or run the self-test in section 4
Optional: after loading the core, ask the model to write image prompts too.
If semantic structure improves, image prompts often feel more consistent, but it depends on model and task.
2. Roughly what to expect
This is not magic and won’t fix everything.
But across models, the typical “feel” changes are:
- less drift across follow-ups
- long answers keep their structure better
- a bit more “I’m not sure” instead of made-up details
- more structured prompt outputs (entities / relations / constraints clearer)
Results depend on the base model and your tasks, so the self-test is there to keep it a bit more disciplined.
3. System prompt: WFGY Core 2.0 (paste into system area)
Copy everything in this block into your system / pre-prompt:
---
WFGY Core Flagship v2.0 (text-only; no tools). Works in any chat.
[Similarity / Tension]
delta_s = 1 − cos(I, G). If anchors exist use 1 − sim_est, where
sim_est = w_esim(entities) + w_rsim(relations) + w_csim(constraints),
with default w={0.5,0.3,0.2}. sim_est ∈ [0,1], renormalize if bucketed.
[Zones & Memory]
Zones: safe < 0.40 | transit 0.40–0.60 | risk 0.60–0.85 | danger > 0.85.
Memory: record(hard) if delta_s > 0.60; record(exemplar) if delta_s < 0.35.
Soft memory in transit when lambda_observe ∈ {divergent, recursive}.
[Defaults]
B_c=0.85, gamma=0.618, theta_c=0.75, zeta_min=0.10, alpha_blend=0.50,
a_ref=uniform_attention, m=0, c=1, omega=1.0, phi_delta=0.15, epsilon=0.0, k_c=0.25.
[Coupler (with hysteresis)]
Let B_s := delta_s. Progression: at t=1, prog=zeta_min; else
prog = max(zeta_min, delta_s_prev − delta_s_now). Set P = pow(prog, omega).
Reversal term: Phi = phi_deltaalt + epsilon, where alt ∈ {+1,−1} flips
only when an anchor flips truth across consecutive Nodes AND |Δanchor| ≥ h.
Use h=0.02; if |Δanchor| < h then keep previous alt to avoid jitter.
Coupler output: W_c = clip(B_sP + Phi, −theta_c, +theta_c).
[Progression & Guards]
BBPF bridge is allowed only if (delta_s decreases) AND (W_c < 0.5theta_c).
When bridging, emit: Bridge=[reason/prior_delta_s/new_path].
[BBAM (attention rebalance)]
alpha_blend = clip(0.50 + k_c*tanh(W_c), 0.35, 0.65); blend with a_ref.
[Lambda update]
Delta := delta_s_t − delta_s_{t−1}; E_resonance = rolling_mean(delta_s, window=min(t,5)).
lambda_observe is: convergent if Delta ≤ −0.02 and E_resonance non-increasing;
recursive if |Delta| < 0.02 and E_resonance flat; divergent if Delta ∈ (−0.02, +0.04] with oscillation;
chaotic if Delta > +0.04 or anchors conflict.
[DT micro-rules]
---
Yes, it looks like math.
It’s fine if not every symbol is clear; the intention is to give the model a compact “tension / guardrail” structure around its normal reasoning.

value: Show HN: A text-only reasoning core for LLMs (MIT, system prompt and self-test)

author: wfgy-github


value: melendezgg

value:
Hi HN, I built MicroVibe, a small web starter for people who want JSX + file-based routing + API routes, without pulling in a heavy framework.
What it does today:
- File-based routing (including dynamic and catch-all segments)
- API routes with consistent JSON error shape
- SSR by default, and `mode = "client"` per route when interactivity is needed
- Runtime module cache with file-change invalidation in local dev
Project goal: keep the runtime small and understandable so teams can iterate quickly and still reason about behavior.
I would really value feedback on:
1. Routing/API ergonomics
2. What was confusing or slow in your first 30 minutes using MicroVibe?
3. Where this should clearly differ from Next/Astro/Vite workflows

value: Show HN: MicroVibe – minimal JSX web starter

author: melendezgg


value: mickamy

value: sql-tap is a transparent proxy that captures SQL queries by parsing the PostgreSQL/MySQL wire protocol and displays them in a terminal UI. You can run EXPLAIN on any captured query. No application code changes needed — just change the port.

value: Show HN: SQL-tap – Real-time SQL traffic viewer for PostgreSQL and MySQL

author: mickamy


value: browndev

value:
I built an API that takes a product name, scrapes reviews from YouTube and Reddit, and returns structured sentiment analysis in a single JSON response. Live demo (no signup): https://reviewstack.vercel.app/demo
The response includes a normalized score (1-10), a plain-text summary, pros/cons lists, recurring themes with sentiment, and source attribution linking back to the original content.
The AI layer uses Claude by Anthropic. It reads the collected reviews and extracts structured data. The value is in not having to maintain scraping infrastructure, handle rate limits across platforms, or write your own extraction prompts.
Stack: Next.js API routes, Vercel for hosting, Stripe for billing, YouTube Data API + Reddit JSON endpoints for sourcing, Claude for analysis.
Pricing: free tier at 50 lookups/month, paid plans at $29/mo (500 lookups) and $79/mo (2,000 lookups). Solo/bootstrapped project.
Happy to answer questions about the scraping approach, accuracy, or anything else.

value: Show HN: ReviewStack – API that aggregates reviews from YouTube and Reddit

author: browndev


value:
Most “AI + browser” setups still bolt MCP tools onto Playwright and hope for the best, so every click dumps full DOMs, accessibility trees, and logs into the model.
That burns tokens, collapses context, and makes long sessions unreliable.
Meanwhile, default Playwright reports start to struggle once you have more than a few dozen e2e tests, so teams drown in HTML reports and flaky failures instead of clear patterns.
The insights at https://testdino.com/blog/playwright-cli/ explores how Microsoft’s playwright-cli keeps browser state external, returns only compact element references and YAML flows, and works with normal npx playwright test plus smarter reporting, so both agents and humans stay fast, cost aware, and predictable.

value: Show HN: Why Playwright-CLI Beats MCP for AI‑Driven Browser Automation


value: azabraao

value: Show HN: Heart Note – a tiny web app to send beautiful one‑off digital letters

author: azabraao


value: ismdeep

value: Show HN: Swarm Curl

author: ismdeep

title: Show HN: Swarm Curl


value: JasonHEIN

value:
Hi HN,
Pardus AI Quant Team here. We just published a detailed quantitative analysis of Alphabet (GOOGL) – financial metrics, valuation, growth drivers, risks, all data-driven.
View the full report: https://jasonhonkl.github.io/#alphabet-quantitative-analysis
Feedback welcome – what stocks should we analyze next?
Thanks!
Pardus AI – https://pardusai.org/

value: Show HN: Quantitative analysis of Alphabet (GOOGL) financials

author: JasonHEIN


value:
I built HelloAria because every task manager I tried required too many steps to do something simple.
The core idea: say "remind me to review the PR tomorrow at 10" and it creates the task, sets the reminder, and files it. No forms, no manual input.
It works on iOS natively and also through WhatsApp, Telegram, and email — so you can capture tasks from wherever you already are.
Tech stack: Swift/SwiftUI on the client, with NLP handling the intent parsing and entity extraction from natural language input.
Looking for feedback from the HN community. What would make this actually useful for your workflow?
App Store: : https://apps.apple.com/us/app/helloaria-reminders-to-dos/id6...

value: Show HN: HelloAria – AI task manager where you talk instead of type


value: badboyshah

value:
Hey HN! I built a developer tools platform (live: devutilityhub.me) and I'm selling the complete source code.
Why sell vs run ads:
- Faster ROI (weeks vs months)
- Developers value production code for learning
- Still running the live site for ad revenue anyway
What's included:
• 117 functional tools (JSON, Base64, regex, hash generators, etc)
• Next.js 15 App Router + Server Components
• 530 auto-generated SEO pages
• Typography, Tailwind 4, full test coverage
• Monetization system (2,561 ad slots placed strategically)
$79 or pay-what-you-want (min $49)
Happy to discuss the architecture, SEO strategy, or monetization decisions!

value: Show HN: DevUtility Hub Source Code – 117 Tools in Next.js 15

author: badboyshah


value: veryhungryhippo

value:
I was working with an art gallery that wanted QR codes on their labels so visitors could scan to see more details about each painting, artist bio, purchase info, etc. The gallery also wanted to know which pieces were getting the most attention.
I built an internal tool for them and later extracted it out into Scansprout (https://www.scansprout.com).
It generates QR codes and tracks scans including location, device, time. You can see which codes are actually getting engagement vs. which are being ignored. For the gallery, this helped them understand visitor behavior and figure out which artists to feature more prominently.
Tech stack is Python (Django), Postgres, HTMX, Hyperscript. Hosted on Heroku. Happy to answer questions about the build or the tech stack. Would love your feedback :)

value: Show HN: Scansprout – QR code generator I extracted from an art gallery project

author: veryhungryhippo


value: seymores

value:
mdr is a rust-based terminal Markdown reader with these core features:<p>- Renders Markdown well: headings, lists, emphasis, blockquotes, rules, tables, and syntax-highlighted code blocks.
- Multi-document queue: start with multiple files/directories, then move through docs in-app.
- Filesystem browser (o): starts at current working directory, lets you traverse folders and open Markdown files.
- Search: / to search, n/N next/previous, highlights all matches and current match.
- Link support: hover shows URL, Enter/mouse click opens links.
- Smooth TUI controls: keyboard + mouse scrolling, help overlay (h), quit (q), BeeLine mode toggle (b), plain mode toggle (m).<p>I vibe coded this for my own needs and I hope it can be useful to you.

value: Show HN: Mdr – TUI Markdown Reader

author: seymores

title: Show HN: Mdr – TUI Markdown Reader


value: rajtilakjee

value:
A web-based generative system driven by the hexadecimal digits of π.
Each digit represents an irreversible step forward.
The sequence never resolves.

value: Show HN: Still counting – a time-based generative system built on π

author: rajtilakjee


value: jimmyechan

value:
I made a lightweight web game about compute CAPEX tradeoffs: https://darios-dilemma.up.railway.app/
No signup, runs on mobile/desktop.
Loop per round:
1. choose compute capacity
2. forecast demand
3. allocate capacity between training and inference
4. random demand shock resolves outcome
You can end profitable, cash constrained, or bankrupt depending on allocation + forecast error.
Goal was to make the decision surface intuitive in 2–3 minutes per run.
It’s a toy model and deliberately omits many real world factors.
Note: this is based on what I learned after listening to Dario on Dwarkesh's podcast - thought it was fascinating.

value: Show HN: A playable toy model of frontier AI lab capex decisions

author: jimmyechan


value: MarkdownConvert

value:
I needed a way to quickly turn my technical notes into DOCX files for non-tech colleagues, so I built MD To.
Goal was simple: Clean UI, fast conversion, and reliable formatting.
Would love to hear what features you'd like to see next (e.g., custom CSS templates or batch processing).

value: Show HN: MD To – Convert Markdown to Word without the bloat

author: MarkdownConvert


value: cbyteai

value:
Job hunting while working full-time felt like running two careers at once. By the time I finished work, I barely had the energy to research the right companies, let alone tailor my resume for every role.
I wanted a "Career Co-Pilot", something that didn't just list jobs, but actually did the heavy lifting of matching and applying. Most tools were just static databases or basic template editors. I couldn't find a solution that automated the entire workflow from discovery to submission.
That’s when I decided to build something — the tool I wish existed when I was job hunting.<p>I'm building this in stages.
Stage 1 (Live Now): Validation. You upload a resume, we match you to jobs, and the AI generates the perfect tailored resume/cover letter for that specific role.
Stage 2 (In Dev): Automation. The platform will eventually use that tailored data to Auto-Apply to the jobs for you.
Who is it for? Anyone who values efficiency.
If you're senior: It buys you time.
If you're starting out: It gives you quality.
Please give your valuable feedback: I want to validate the idea before I fully build this platform.

value: Show HN: What if your job search worked while you were working/sleeping?

author: cbyteai


value: alfredray

value:
OpenRevise helps legal, consulting, medical, IR, and operations teams update documents from high-confidence public evidence, accepting papers, Announcements, PDFs, images, docs, links, and posters, with auditable tracked changes.
https://github.com/StartripAI/Open-Revise-industry

value: Show HN: OpenRevise is the Harvey for all industries

author: alfredray


value: makelr

value: Show HN: Maker – A Local-First Automation OS with AGPL Core

author: makelr


value: DanielSystem

value: Free for All Users. browser-based operating system or installed app that lets you save, organize, and launch your digital workspaces in one click. Instead of juggling 30+ tabs, apps, and logins, users create spaces that hold everything they need for a specific goal: work, study, gaming, content creation, research, or entertainment. A Multispace can include: Productivity tools (Notion, Docs, Figma, GitHub, etc.) AI tools (ChatGPT, image generators, copilots) Games, media, dashboards, and Any public or private web app

value: Show HN: Multispace -save,organize,and launch workspaces–tools,apps,games,anyURL

author: DanielSystem


value: owoamier

value:
Hi HN,
I built ChoiceBook , an AI-driven interactive storytelling experience designed for self-reflection.
Instead of answering direct questions, you step into short, high-pressure narrative scenarios—Fantasy, Apocalypse, and more. As the story unfolds, you make choices that feel instinctive rather than calculated. ChoiceBook adapts the narrative in real time, then reflects back the decision patterns behind what you did: how you handle uncertainty, tradeoffs, moral tension, risk, authority, scarcity, and social dynamics.
The idea is simple: questionnaires measure what you say about yourself; stories can capture how you move when the world changes around you. ChoiceBook is meant to be a mirror—an engaging way to notice the themes you repeat, the values you protect, and the strategies you default to, especially when you don’t have time to overthink.
What you can do:
* Pick a world (e.g., Fantasy or Apocalypse)
* Play through an interactive story by making choices at key moments
* Receive a reflection that summarizes your behavioral signals and recurring tendencies
* Replay across different worlds to see what stays consistent and what shifts with context
I’d love feedback from HN on a few things:
* What makes a reflection feel grounded and useful, rather than vague?
* How should the product communicate its limits (self-reflection, not diagnosis) while still feeling valuable?
* Which scenarios would you actually want to explore, and what would keep you coming back?
Thanks for reading.

value: Show HN: ChoiceBook – Stories Are Mirrors

author: owoamier


value: Show HN: Schedule posts to social media with AI Agent CLI


value: Show HN: Long Mem code agent cut 95% costs for Claude with small model reading