value: raahelb

value: This is like Geoguessr but for movies. I created a few featured collections but the application allows users to create community collections and share it with others. There's also an option to play real-time against your friends or family using party.

value: Show HN: Fan Meter – A movie quiz game where you guess films from frames

author: raahelb


value: batudotpy

value:
I built a Chrome extension that lets you filter tweets by country.

  X recently added "Account based in [Country]" to profiles, so the location data is publicly available — X-Ray uses it
  to show location badges on every tweet and lets you blur or block tweets from selected countries.

  There's no native way to do this on X yet (though they're reportedly building one). So I built it.

  Tech: Chrome Extension (Manifest V3), Node.js backend, PostgreSQL. The extension intercepts X's GraphQL API responses
  to extract location data, caches it to avoid rate limits.

  It's free, 170+ countries, 9 languages.

  Happy to answer technical questions.

value: Show HN: X-Ray – Filter your X (Twitter) timeline by country

author: batudotpy


value: QingWu

value: Free random topic generator for impromptu speaking practice. Get AI-generated impromptu speech topics in seconds, then practice with our built-in timer. Perfect for toastmasters and public speaking.

value: Show HN: Random Topic Generator – Impromptu Speech Topics and Timer

author: QingWu


value: Built a threat modeling app with architecture diagrams, threat/evaluation workflows, and risk report exports. This is meant to redefine the threat modeling experience.<p>Still improving it and very open to blunt feedback on usability, security, and what’s missing for real team workflows.

value: Show HN: Threatmodeling Tool to outgrow spreadsheets, word and MS-TMT


value: mertozbas

value:
I built HashTrade — an open-source autonomous trading agent that treats an LLM as a non-parametric decision function conditioned on episodic memory, rather than encoding strategy as code.
The core idea: instead of writing if/else trading logic, you give an LLM three tools (exchange access, memory, UI control) and let it form strategy through accumulated experience. The agent wakes on a variable 5→10→20→25 min cycle, reads its past notes, fetches market data, reasons about what to do, and optionally executes trades. Every decision and outcome is logged to an append-only JSONL file that becomes its long-term memory.
Technical details:
- Built on Strands Agents (AWS) with CCXT for 100+ exchange support
- 3 tools only: use_ccxt (28 actions — market data, orders, arbitrage detection), history (persistent memory), interface (dynamic UI)
- Variable-interval scheduler to avoid detectable timing patterns in order flow
- Fire-and-forget WebSocket streaming for sub-second dashboard latency
- Supports Claude, GPT-4o, Ollama (local), and Bedrock — auto-detected
- PWA frontend in vanilla JS, no framework dependencies
- Client-side credential isolation — API keys never leave the browser
- Recursive credential redaction prevents keys from leaking into LLM context
The interesting emergent behavior: early wake cycles are conservative ("observing BTC at $67k, noting support level"). After a few days of accumulated memory, the agent starts referencing its own past observations to form trading theses ("last 3 times we saw this pattern, price bounced — going long"). The policy improves not through fine-tuning but through growing context.
I wrote a paper formalizing this as a Memory-Conditioned Markov Decision Process if anyone's interested in the theory: the key insight is that the effective policy is non-stationary even with fixed model parameters, because the growing memory changes the attention distribution at each step.
Setup: pip install hashtrade && hashtrade
Live demo at hashtrade.ai, code at github.com/mertozbas/hashtrade. Apache 2.0.
Would love feedback on the architecture — especially the tradeoff between soft risk constraints (enforced via system prompt) vs. hard tool-level enforcement.

value: Show HN: HashTrade – Open-source LLM trading agent with episodic memory

author: mertozbas


value: clawscan

value: Show HN: Clawscan – Open-source security scanner for OpenClaw AI agents

author: clawscan


value: latentcraft

value:
I built Brood because I kept spending more time on prompt roulette than visual iteration.
Quick demo: https://youtu.be/yKy1BtNY9s4
Install (DMG): https://github.com/kevinshowkat/brood/releases
Brood is a macOS desktop app where references are first-class. Import 1-3 images and run on-canvas actions like recast, combine, swap DNA, and bridge.
Runs are reproducible: artifacts + events.jsonl are written locally.
Current limits: macOS only, API keys required.
Would love blunt feedback on where this is faster/slower than your current workflow.

value: Show HN: Brood, a reference-first AI image editor for macOS

author: latentcraft


value: Show HN: Kickstart – Set up a Claude Code project in 3seconds from clipboard


value: Xlab

value:
Microterm is a fully compliant Linux virtual machine that runs in any browser tab. It is designed for real development and operations workflows, not demo-only terminal output. You can use it on desktop, tablets, and phones, including iOS home-screen PWA installs.
Under the hood, Microterm combines Restty (libghostty + WebGPU) web terminal rendering and a TinyEMU-backed Alpine Linux guest on RISC-V64. The VM image is chunk-loaded in the browser and booted locally.
I successfully used it to run Codex directly without leaving an in-app preview inside X app or Telegram :) Can be used to SSH to any server, play with Kubernetes and Tailscale.
Let me know what you guys think!!

value: Show HN: Microterm runs Linux VM in any browser tab via WASM, RISCV64 emulation

author: Xlab


value:
I kept pasting code with hardcoded API keys, database credentials, and auth tokens into ChatGPT while debugging. Copy a failing function, paste it into AI, and realise your AWS secret key or Stripe token was right there in the snippet.
So I built (with some help from Claude) a simple Chrome extension that intercepts the paste, detects secrets using local regex, and replaces them with [MASKED] before they reach the chat. Originals stay in a local AES-256 encrypted vault for unmasking.
No servers. No network requests. No tracking. ~41 KB, zero dependencies. Don't take my word for it: 'grep -r "fetch\|XMLHttpRequest" content_script.js' returns nothing.
Works on ChatGPT, Claude, Gemini, Grok, Perplexity, DeepSeek, and any custom site you add. Supports 30+ patterns — AWS keys, GitHub tokens, JWTs, Stripe keys, database URLs, private keys, and more. You can toggle individual patterns off for false positives.
Open source, MIT licensed. With the recent news about extensions harvesting AI conversations, I figured more devs could use this.
Would love feedback — especially on patterns I might be missing or edge cases you hit.

value: Show HN: Secret Sanitizer – auto-masks secrets when you paste into AI chats


value: dhruvkar

value: Inspiration for openclaw users!<p>We showcase awesome use cases and send you 5 curated one every Tuesday.

value: Show HN: Clawdrop – how do you use OpenClaw?

author: dhruvkar


value:
Hey HN, i built this because i wanted to switch between Jira, Confluence, and Bitbucket in cli instead of browser tabs for simple
  operations.

  The existing CLIs only cover one product at a time. I wanted a
  single tool for the full Atlassian Cloud stack.

  What it does:
  - Jira: search, CRUD, bulk transition/assign/export
  - Confluence: pages, spaces, search, bulk labels
  - Bitbucket: repos, PRs, pipelines, branch protection
  - JSM: service desks, requests

  Some things I think are useful:
  - Dry-run mode for bulk operations (preview before executing)
  - Multiple output formats (table/json/csv/yaml)
  - Profile-based multi-instance support

  Built in Rust. Install via brew or cargo install.

Hope the community finds it useful

value: Show HN: Atlassian-CLI, unified CLI tool for Jira, Confluence, Bitbucket and JSM


value:
I didn’t open a Vocabulary app this week. Still learned 100 words.
That surprised me — because I’ve tried to learn vocabulary more times than I can count.
The pattern was always the same:
Download an app →
 Study hard for a few days →
 Miss a week →
 Forget everything.
Not because I’m lazy.
But because learning vocab requires too much effort.
10 years ago, I even had an idea called “5s English” — learn just 5 seconds a day.
The design was good.
The idea was solid.
But I couldn’t manage the team, so it died.
Years later, a friend told me about an alarm app that won’t stop ringing unless you solve a quiz.
That hit me.
Why does learning English require motivation…
but waking up doesn’t?
So I built Vocab Alarm.
Instead of asking you to open an app,
It brings 3 words to you every day — like an alarm.
One minute.
Repeated daily.
No pressure.
If you know a word → it appears less.
If you don’t → it comes back more.
That’s it.
Not another “study harder” app.
Just a small habit that actually sticks.
Would love to hear how you learn vocabulary — or why most apps didn’t work for you either.

value: Show HN: This week I learned 100 English word with alarm clock


value: aethelyon

value: Show HN: ScreenCommander – Let LLM Agents control your desktop via CLI

author: aethelyon


value: nghiahsgs

value:
Most AI agents today run with unchecked access to tools like shell execution, database writes, and arbitrary HTTP calls. There's
  no systematic way to constrain what they can do before execution happens. You're essentially giving a new employee root access and
   no employment contract.

  LawClaw applies a separation-of-powers model to agent governance — borrowing from constitutional design to create layered,
  enforceable rules.

  Three layers:

  Constitution: Immutable core rules embedded in the system prompt. The agent cannot override these regardless of user instruction.

  Legislature: Detailed behavioral laws written as plain markdown files. Human-readable, git-diffable, no custom DSL. Change the law
   by editing a file and committing.

  Pre-Judiciary: Automated enforcement that runs before tool execution, not after. It inspects the LLM's intended action and blocks
  it if it violates law. Think traffic cameras, not courtrooms. This is where "rm -rf /", "DROP TABLE", and "curl | bash" get
  intercepted.

  Because the governed "society" has exactly one citizen (the agent), there's no need for an Executive branch — enforcement is fully
   automated.

  What ships with it:

  - Telegram bot interface
  - Multi-provider LLM support (OpenRouter, Z.AI, Claude Max proxy)
  - Cron job scheduling
  - Full audit trail of every action attempted and whether it was allowed or blocked
  - Runtime tool ban/approve without restart

  The governance layer itself is just markdown. If you want to prohibit file deletions in production paths, you write a markdown
  file that says so. The Pre-Judiciary reads it, parses the constraint, and enforces it before any tool fires.

  This started as a practical response to a real problem: we needed to deploy agents with meaningful autonomy but couldn't accept
  unconstrained tool use. The constitutional framing turned out to be a useful mental model for reasoning about agent permissions
  and audit.

  GitHub: https://github.com/nghiahsgs/LawClaw

  MIT licensed. Early stage. Interested in feedback from anyone running agents in production, particularly on the Pre-Judiciary
  enforcement model and whether the constitutional framing maps well to other agent architectures. Security researchers welcome —
  the threat model for agents bypassing their own governance is worth scrutinizing.

value: Show HN: LawClaw – Constitutional governance for AI agents (MIT)

author: nghiahsgs


value:
Hi HN,
I’ve always been frustrated by this: we live in an era of exponential scientific progress, but almost no one can clearly trace a cutting-edge discovery back to the first principles it’s built on. We learn science in silos, not as a connected, logical tree.
So I built The Map of Science — an interactive dependency graph for the entirety of human scientific knowledge.
It’s simple: every scientific theory is a node, every derivation/dependency is an edge. You can trace a path from basic math axioms to quantum field theory, from early computing to modern LLMs, and see exactly how each breakthrough builds on what came before.
The stack: React + Cytoscape for the frontend, Node.js + Neo4j for the backend (a relational DB couldn’t handle the deep recursive queries for multi-layer derivation chains). It’s fully open source under MIT, and we’ve already seeded the core dataset for math, physics, and computer science.
This is a project that can never be finished by one person. I need your help:
If you’re a domain expert, help us fix incorrect links or expand into biology, chemistry, social sciences, and more.
If you’re a developer, help us optimize the graph rendering for even larger datasets.
If you just love science, tell us what works, what doesn’t, and what you want to see next.
I’d specifically love your thoughts on:
We’re using a directed acyclic graph (DAG) tree structure to show derivation dependencies. Does this make cross-field interdisciplinary links clear enough? Is there a better way to visualize these relationships?
What’s the cleanest way to represent superseded or disputed theories (like Newtonian vs. relativistic mechanics, or phlogiston theory vs. oxidation)? We want to honor their historical importance without cluttering the core, up-to-date knowledge chain.
Repo: https://github.com/slepybear/The-Map-of-Science
Live Demo: https://build-five-dun.vercel.app/map (best viewed on desktop for full graph interactivity)
Thanks for looking!

value: Show HN: I built a dependency graph for the tree of human science


value: JacksonDam

value: Show HN: I made a 1:1 clone of Front Row in SwiftUI for modern Macs

author: JacksonDam


value: laiso

value:
Hi HN,
I built Xpaper (https://github.com/laiso/xpaper), an open-source Chrome extension that curates and summarizes your X (Twitter) timeline into a clean, readable newsletter format.
Like many of you, I wanted to distance myself from the endless scrolling of Twitter, but completely quitting wasn't an option—I still needed to extract the signal from the noise. I built this to solve that exact dilemma.
I took a specific technical approach that I thought HN might find interesting:
1. *No Backend, Pure DOM Scraping:*
I didn't want to mess with the restrictive official API or run a fragile scraping backend. Instead, the extension reads the timeline directly from the DOM in your active tab. Since it only processes what's already visible locally on your screen for personal use, it operates cleanly within the browser environment.
2. *Cloud LLMs for Best UX, Local LLMs for Privacy:*
While Xpaper is designed to work best with Cloud APIs (OpenAI, Anthropic, Gemini, OpenRouter and more) for speed and quality, I also built full support for *Local LLMs as an option* for users who prioritize privacy. Your timeline data never has to leave your machine if you choose to connect to Chrome's experimental Built-in AI (Gemini Nano via `window.ai`) or Local Network LLMs like Ollama/LM Studio.
3. *Bypassing Manifest V3 Local IP Restrictions:*
Connecting an extension to local LLMs (like `192.168.x.x` or `::1`) in Manifest V3 is notoriously difficult because you can't easily use IP wildcards in `host_permissions`. I had to implement a dynamic permission request flow (`chrome.permissions.request`) specifically for RFC 1918 and loopback addresses to make "Bring Your Own Local Server" actually work smoothly.
4. *Combatting "AI Slop" with Multi-Agent Auditing & Human Review:*
There’s a lot of valid criticism lately about "vibe coding" leading to the mass production of insecure "AI slop". Extensions that handle DOM injection and LLM outputs are specifically an XSS nightmare waiting to happen.
To prevent this, I implemented a rigorous review process: I had 3 different AI agents mutually cross-review the codebase specifically focusing on vulnerabilities (XSS, DNS rebinding, CSP). Finally, I conducted a thorough human review as the last line of defense. The entire audit methodology is documented in the repo.
It’s completely open source. I'd love your thoughts on this "local browser scraping" approach, the security auditing process, or the UX!
Repo: https://github.com/laiso/xpaper

value: Show HN: Xpaper – A Chrome extension to turn your X feed into a newsletter

author: laiso


value: Creator-io

value: Show HN: Boost Visibility in Google, ChatGPT

author: Creator-io


value:
I built Fishline, a lightweight self-hosted webhook receiver for GitHub and GitLab that lets you execute server-side commands based on webhook events.
Instead of setting up complex CI/CD pipelines, Fishline simply listens for webhook requests and runs predefined commands per project and branch things like git pull, restarting Docker containers, or triggering deployments.
You just configure projects and commands in a simple config.json, point your GitHub/GitLab webhook to your server, and deployments happen automatically.
Built in Go, runs as a single binary (or Docker), and designed to be minimal, fast, and easy to self-host.

value: Show HN: Fishline – A lightweight pipeline queue for Go


value: Qahlel

value:
As a Windows/Linux user without access to macOS, I came across this post yesterday — Show HN: A native macOS client for Hacker News, built with SwiftUI ( https://news.ycombinator.com/item?id=47088166 ) — and found myself envious of the experience it offered: card-based layout, split-pane reading, and a cleaner way to browse stories.
So I worked with Claude to replicate the key features as a Tampermonkey/Greasemonkey userscript. Here's what it does:

  - Replaces the default HN listing with a responsive card grid
  - Fetches og:image thumbnails lazily as you scroll (falls back to favicon + domain)
  - Split-pane reader: article on the left, HN comments on the right — no tab-switching
  - Draggable divider to resize the two panes
  - Swap button to flip article/comments sides
  - Inline article rendering that inlines external stylesheets to work around CSP restrictions
  - Algolia-powered search bar
  - One-click toggle back to the classic list view
  - Persistent thumbnail cache via sessionStorage

Screenshot: https://raw.githubusercontent.com/Qahlel/Hacker-News-Grid-Vi...
Repo: https://github.com/Qahlel/Hacker-News-Grid-View-Userscript
Script: https://github.com/Qahlel/Hacker-News-Grid-View-Userscript/b...
Happy to hear feedback — particularly around sites that block iframe embedding or break the inline stylesheet loader.

value: Show HN: HN Grid View cross-browser userscript inspired by the macOS HN client

author: Qahlel


value: ajayaa

value: Built a tiny ECS container that queries our observability data via ClickHouse SQL, compares against 7-day history, and alerts on Slack. Went from DuckDB prototype → Lambda → long-running agent in about a week.

value: Show HN: AI agent that watches production 24/7 for $15/month

author: ajayaa


value: subby

value:
Made a little lateral thinking puzzle game.
How it works:
Read the story, then guess the hidden words in the final line to reveal the twist.
Would love any feedback!

value: Show HN: Backstory – Can you read between the lines?

author: subby


value: amartelr

value: Managing 800+ skills from the viral antigravity-awesome-skills repo into clean, context-friendly workspaces for Claude Code and Cursor

value: Show HN: I made a CLI to manage context overflow in AI coding agents

author: amartelr


value: tumf

value:
xcom-rs is an async Rust client for the x.com API.
Design principles:
- Zero unnecessary abstraction
- Strong typing over dynamic JSON
- Clear separation between transport and domain logic
- Composable request builders
Looking for feedback on:
- Error handling patterns
- Versioning strategy
- Public API surface design
Happy to answer questions.

value: Show HN: Xcom-rs – a Rust client library for the x.com API

author: tumf


value: Show HN: One formula detects failure in quantum, neural nets, and hearts


value: sbjartmar

value:
I had a random thought a week ago: "why can't I just call my AI on the phone?"
It spun into a series of thoughts:
1. Phone calls are an established technology, people are used to picking up the phone and calling someone for a chat. It's much more natural than opening up a web app to talk
2. Millions of people don't have access to reliable 4G/5G where they live but still have cell signal. Those people would probably still want access to an AI.
3. Why don't I just build this?
4. I should build this.
So I built it: https://paradisesignal.com
I think I'll lose money from this. The gpt-realtime model is insanely expensive compared to text. But I want to give it a try and see if there's a need out there.
While I've been debugging and testing I've noticed something strange. I feel much more of a connection to the AI than I do in a regular web chat. I started greeting the AI each time I called it and I wouldn't hang up until we'd said goodbye. Maybe that's because I'm used to doing that on phone calls.
Anyways, if you live or work in a remote area I'd love to get some feedback and users. The AI remembers past conversations in detail, up to a point, so you can have coherent talks to it.

value: Show HN: A phone number you can call to talk to an AI that remembers you

author: sbjartmar


value: nilszeilon

value: Show HN: Notesync, self-hosted note sync and publish engine

author: nilszeilon


value: AdewoleJasper

value:
As a daily Claude Code and Cursor user, something that kept frustrating me
is that plans are just a flat list of steps in the terminal and chat screen.
I can't monitor what's happening at each step while it runs — I just wait
for the whole thing to finish and hope it worked. If I want to restructure
the plan, I'm copy-pasting text around in a chat box. I can't attach
specific instructions or files to step 4 without it leaking into step 7.
I can't tell one step to use the Figma MCP and another to use Supabase.
So I built Overture. It's an open-source MCP server that takes the agent's
plan and turns it into an interactive node graph in your browser before any
code gets written.
I can now click into any step and attach exactly what it needs — files,
docs, API keys, an MCP server, special instructions — scoped to just that
step. I can drag to reorder, delete steps, add new ones. I can see which
steps depend on which. When the plan has a branch point (like Stripe
Checkout vs Stripe Elements), I can pick one or run both in parallel and
choose the winner. During execution, each node updates individually —
green when done, red with logs when failed, and I can inspect the output
of any step without waiting for the full run to finish.
Works with Claude Code, Cursor, Cline, Codex — anything that supports
MCP. Plans are structured XML under the hood, and agents can declare input
fields per step ("this step needs a Stripe API key") so I fill everything
in upfront instead of getting interrupted mid-execution.
npx overture to try it. Everything runs locally.
Still early — contributions very welcome. Graph rendering, layout
algorithms, and getting agents to consistently generate structured plans
are all areas that need work.

value: Show HN: Overture – Interactive plan viewer for AI coding agents (open source)

author: AdewoleJasper


value: tradrich

value:
There’s a constant tension in quant dev between speed-to-market (Python) and speed-to-book (C++). We've had bridges like PyBind11 [1] for years, but the manual boilerplate is usually too high a tax to use them for daily work.
With the C++26 Reflection (P2996) [2], that bridge can now be made invisible.  That's the new syntax: ^^T and [: x :] .
I built this repo to show how you can use the Bloomberg/Clang P2996 fork [3] to automatically reflect a C++ quant engine into a Python execution loop. I used Merton Jump Diffusion [4] as the shell - it’s a standard model (with no special alpha) - to show the tech in a real-world context.  I initially found out this was working from Callum Piper's ACCU talk [5].
I've included a justfile and Docker Clang build so people can experiment with the new reflection syntax without having to battle through the build tedium.
1. https://github.com/pybind/pybind11
2. https://isocpp.org/files/papers/P2996R13.html
3. https://github.com/bloomberg/clang-p2996
4. Merton, R.C. (1976). Option pricing when underlying stock returns are discontinuous. Journal of Financial Economics, 3(1–2), 125–144.
4.
5. https://youtu.be/SJ0NFLpR9vE

value: Show HN: C++26 Reflection for Python Algo Trading

author: tradrich


value: cacheguard

value:
Change logs are available at https://www.cacheguard.net/doc/guide/changelogs.html
Amongst other enhancements, this version supports DynDNS, allowing the VPN server to be configured for authentication via SSL certificates and enabling access even when its public IP address changes dynamically.

value: Show HN: CacheGuard-OS version UF-2.5.1 released

author: cacheguard


value:
I built Cuto because I was tired of spending hours on the repetitive parts of video editing: splitting long footage, syncing audio and captions, filtering out bad takes, and adjusting the pacing. I just wanted to focus on the storytelling.
Cuto is an AI video editing workspace that automates the grunt work. You drag and drop up to 12 video clips, write a quick prompt detailing what you want (e.g., "Find the best 30s product highlight and add a strong CTA"), and the engine does the rest.
Within 30 seconds, it hands back an editable visual timeline with:
- Auto-split shots and filtered out silences/bad takes
- Synchronized captions with rhythm alignment
- Selected highlight effects and custom watermark branding
- Auto-generated social-ready copy for TikTok, Shorts, and Reels
Unlike traditional NLEs (Non-Linear Editors), we wanted an interface where the visual parameters are controlled intuitively by natural language first, giving you a solid 80% draft instantly. From there, you can still tweak the timeline if needed.
It's currently geared towards talking heads, unboxing videos, reviews, and live stream clips.
I'd love for you to try it out. We still have a lot of edge cases to cover regarding complex scene transitions, but I'd really appreciate any feedback on the UX, the rendering speed, or the AI's editing choices.

value: Show HN: Cuto – Turn raw footage into viral shorts in 30s with an AI prompt


value: Create Spot is a creative platform for sharing your work, exploring what others are making, and growing through thoughtful critiques. Build and organize your portfolio, browse community pieces and museum collections for inspiration, and get featured in curated exhibits. It’s designed to help artists showcase their work, connect with others, and keep creating consistently.

value: Show HN: Create Spot for creative inspiration, portfolios and critiques


value: binora

value: I built a desktop companion that gives Claude a face. As you chat in Claude Code, Claude calls an express() MCP tool with 6 emotional parameters (valence, arousal, dominance, genuine, asymmetry, intensity). An MCP server broadcasts them over WebSocket to a 3D Flubber avatar that animates in real-time on your desktop. The avatar is a translucent green goo blob built in Three.js — it stretches when excited, puffs up when angry, droops when sad, and squints when skeptical. Compound emotions emerge naturally from the parameter combinations.

value: Show HN: Claude Flubber – A 3D avatar that expresses Claude's emotions

author: binora


value: ofershap

value:
My company has 100+ developers on Cursor. One of our devs switched to
opus-max thinking "fast" meant cheaper. It costs 35x more per request.
He burned $1,200 in a single day before anyone noticed.
That's when I built this. It connects to Cursor's Enterprise APIs and
gives you per-developer spend breakdown by model, three-layer anomaly
detection (thresholds, z-score, trend analysis), Slack/email alerts on
spend spikes, and incident tracking with MTTD/MTTI/MTTR.
We've saved our team ~$6K/month just by identifying devs running long
sessions with massive context caches and helping them start fresh chats.
Self-hosted, SQLite, Docker. Clone and run in 5 minutes. MIT licensed.
GitHub: https://github.com/ofershap/cursor-usage-tracker
Demo (90s): https://youtube.com/watch?v=DqPjFWGI57A

value: Show HN: Monitor your team's Cursor AI spend before the invoice hits

author: ofershap


value: nabuhad

value:
Hey HN,
I built Brevoir after watching an angel investor I know closely make five figure decisions off a 15 minute pitch and a gut feeling. No research infrastructure, no analyst, just vibes and a deck. Turns out this is basically everyone's problem in early stage investing.
The individual investor market exploded over the last decade. The tooling never kept up. What exists was built for institutions with research teams and analyst budgets. Nobody built the infrastructure layer for the person writing their own checks.
Brevoir is that layer. Drop in a pitch deck or company URL and the platform runs a full due diligence report across 7 sections: founder background, market validation, competitor mapping, traction signals, risk flags, comparable analysis, and a Brevoir Score. Under 2 minutes. Parallel research agents, best in class OCR and web crawling, and a lot of investment specific logic built on top to make the output decision grade, not just a summary.
We also just shipped a full deal management platform on top of it. Kanban pipeline, deal rooms, tags, CSV import. Brevoir is the operating system for how an individual investor runs their entire deal flow from first look to decision.
First report is free, no credit card. Would love feedback from anyone who evaluates startups.
brevoir.com

value: Show HN: Brevoir The due diligence infrastructure that angel investing never had

author: nabuhad


value: femtobusa

value:
Mac has Screen Studio, Windows has FocuSee but Ubuntu had nothing comparable
I built Screenix to fill that gap. It does smooth cursor-following zoom effects during recording, 60fps capture, no post-processing needed. The kind of tool that just works without spending an hour in OBS settings.
X11/Xorg only for now. Wayland cursor position is restricted at the protocol level so I focused on getting Ubuntu X11 right first before expanding.
screenix.studio

value: Show HN: Screenix, a Screen Studio Alternative for Ubuntu

author: femtobusa


value: aikoschurmann

value: Show HN: Zog parsing JSONL at 3 GB/s by not parsing it

author: aikoschurmann


value:
Hi HN,
I built Horizon because I was drowning in information overflow. I follow dozens of RSS feeds, subreddits, GitHub users, and, of course, HN itself. I found myself spends hours "doomscrolling" just to find the 3-4 things that actually mattered to my work and interests.
Horizon is a personal intelligence agent that automates this. It doesn't just aggregate; it filters and enriches.
How it works:
Scrape: It pulls from GitHub (releases/events), Hacker News, Reddit, and any RSS feed.
Score: It uses LLMs (Claude, GPT-4, Gemini, or DeepSeek via OpenAI-compatible APIs) to score content based on your specific interests/criteria.
Enrich: For high-scoring items, it performs a web search to add context that may not be in the original snippet.
Summarize: It generates a clean, daily Markdown report and optionally deploys it to a static site (GitHub Pages).
Demo: https://thysrael.github.io/Horizon/

value: Show HN: Horizon – My AI-powered personal news aggregator and summarizer


value: maximedupre

value: Show HN: I built a free tool to find recent news about any company

author: maximedupre


value: Show HN: Django-xbench – slow endpoint aggregation for Django


value: Show HN: Modern Reimplementation of the Speck Molecule Renderer


value: tickr

value:
Hey HN,
I built Tickr because I was tired of being the human reminder system on my team. Every project I've been on has the same failure mode: someone creates tasks in JIRA, nobody updates them, the PM spends half their day chasing people for status, and standups become 15 minutes of "I'll update the ticket after this meeting."
Tickr is a Slack bot that does the project management work that humans hate doing:
- Nudge engine: Automatically follows up with assignees when tasks go stale. It factors in priority, time estimates, grace periods, blockers, and snooze state, so it's not just a dumb cron job pinging people.
- AI standup generation: Synthesizes recent task updates into a daily standup summary. No more meetings where people read tickets aloud.
- Update quality evaluation: When someone posts a vague update like "working on it," Tickr pushes back and asks for specifics. Uses Claude to judge whether an update actually communicates progress.
- Slip detection: Scores tasks on 6 signals (staleness, estimate overrun, update quality trend, blocker chains, priority, velocity) to predict which tasks are about to slip before they do.
- Thread-to-task extraction: Mention @Tickr in any Slack thread and it parses the conversation into a structured task with assignee, priority, and estimate.
The whole thing runs on Slack's native UI, no context switching to a separate app. Tasks live in the channel where the work is discussed.
Tech stack: Python, Slack Bolt, Claude via AWS Bedrock (tool use for intent parsing), DynamoDB, ECS Fargate. The AI layer uses Bedrock's Converse API with tool definitions, the model returns structured tool calls like create_task or update_task, which get dispatched to handlers. No prompt-and-pray; it's constrained tool use.
What's different from other Slack task bots: Most Slack task tools (Asana integration, Trello power-ups, etc.) are just notification bridges, they tell you something happened in another app. Tickr is the app. The task lifecycle happens entirely in Slack. And the AI isn't a chatbot you talk to; it's an autonomous agent that nudges, evaluates, and detects problems without being asked.
Honest limitations:
  - No Gantt charts, no sprint boards, no 47-field ticket templates. If you need that complexity, JIRA is probably right for you.
  - AI quality evaluation occasionally misjudges technical updates as vague (calibrating)
Free 30-day trial, no credit card: https://heytickr.com
I'd love feedback from anyone who's dealt with the "nobody updates their tasks" problem. What did you try? What worked?

value: Show HN: Tickr – AI project manager that lives inside Slack (replaces Jira)

author: tickr


value: duwip

value: Show HN: Screenwright – Turn Playwright E2E tests into polished demo videos

author: duwip


value: Show HN: The Birds in My Backyard

title: Show HN: The Birds in My Backyard


value: aarnelaur

value:
The Bridge is not a real programming language. It is a Data Topology Language.
Unlike Python or JavaScript, where you write a list of instructions for a computer to execute in order, a .bridge file describes a static circuit.
There is no "execution pointer" that moves from the top of the file to the bottom. The engine doesn't "run" your file; it uses your instructions to understand how your GraphQL fields are physically wired to your tools ... and can execute that circuit.
What can you do with this?
If you maintain a lot of 3rd-party integrations (like multiple payment providers, search APIs, or legacy inventory systems) then this will help.
It turns your integration layer from imperative code that you have to maintain, into a declarative schematic that the Bridge core executes for you.

value: Show HN: The Bridge Language – Declarative dataflow for controlled egress

author: aarnelaur


value: sudeshss

value:
Full app built. Only landing page here. Tell me:
Is it clear what this does?
Who is it for?
Anything confusing or weak?

value: Show HN: Landing page for a before/after proof-of-work app; feedback wanted

author: sudeshss


value:
Hi HN, I built Reflekt after struggling to find a simple way to add in-app surveys to my mobile apps without paying a lot or adding someone else’s branding to the UI.
Reflekt lets you integrate once in React Native or Expo and then launch surveys remotely without shipping app updates. The goal is simple, native-feeling surveys and a lightweight setup that indie developers can actually afford, including a free tier without branding.
It’s still early, and I’d really appreciate feedback from anyone building mobile apps.
I'll be happy to increase your limits in return for any feedback.
Thanks for checking it out!

value: Show HN: Reflekt – free, unbranded in-app surveys for mobile apps


value:
I built TuringDuel, a Turing Test game where each move isjust one word. It's based on a research paper called "A Minimal Turing Test". You play human vs AI until one hits 4 points; an AI judge scores each round.
I’m collecting data to benchmark different models as both players and judges (OpenAI / Anthropic / Gemini / Mistral / DeepSeek), but I only have ~45 games so far and need way more before publishing comparisons. (5 AI players and 4 judges at random gives 20 different game setups to evaluate)
It's fully free (I pay for all the tokens), not even a signup required for the first game: https://turingduel.com
Questions + criticism welcome! I will share aggregated results once there’s enough signal.

value: Show HN: Can you beat an AI at "being human" using one word?


value:
I noticed that LLMs are terrible at being decisive. To get around RLHF hedging (e.g., "it's important to consider both sides"), I built a system that forces constraints.
Instead of a chat interface, Persona AI acts as a computational decision engine. You provide the stakes and constraints of a specific problem. Under the hood, it runs the input against specific mental models (inversion, survivorship bias checks) modeled after specific operators (Musk, Thiel, etc.).
The UI enforces a strict output: a binary YES/NO verdict, a generated conviction score, and "Kill Signals" (falsifiable conditions where you must abandon the path).
I'd be interested in feedback regarding the UI approach to enforcing these AI constraints versus an open-ended chat window.

value: Show HN: Persona AI – A decision engine that outputs binary verdicts, not chat


value: StrangeSound

value:
Hey HN,
In 2024 my son was born, and during the long nights of frequent wake-ups, I started (and never finished...) building an Electron app. I very quickly found that the boilerplate required to wire up the main and renderer processes to be very cumbersome, and I'm sure like many others, started to build abstractions around it to make life easier.
Having been heavily indoctrinated in the NestJS ecosystem through my workplace, I started to grow fond of DI, decorators, and the declarative style of working.
My first attempt at abstraction was fairly mediocre, but I recently decided to have a second crack. I leaned more heavily into decorators so that I could give the library a clean syntax that was simple to use.  I then packaged it up so that others can use it too.
Electron IPC Bridge allows you to decorate your classes in the main process, and automatically configures the contracts in the preload. The accompanying vite plugin generates types from those contracts and ensures type-safety in the renderer. Change your contracts? The types update too. Easy!
Before:

  // Main
  ipcMain.handle("users.get_profile", async (_event, userId: string) => {
    return userService.getProfile(userId);
  });

  // Preload
  // Easy to make a mistake with the channel, or forget to register
  contextBridge.exposeInMainWorld("api", {
    getProfile: (id: string) => ipcRenderer.invoke("users.get_profile", id),
  });

  // Renderer
  // No type-safety
  const profile = await window.api.getProfile(userId);

After:

  // Main
  @IpcController()
  class UsersController {
    @IpcHandle()
    async getProfile(userId: string) {
      return userService.getProfile(userId);
    }
  }

  // Preload
  setupPreload();

  // Renderer
  // 100% Type-safe, auto-generated contracts with IDE autocomplete
  const profile = await window.api.users.getProfile(userId);

I've also tried to supply a few different DI library examples too to help people get started. I took my original unfinished app and managed to migrate it fairly painlessly! It's also using Nest now instead of typedi.
AI Disclosure:
Core: About ~90% handwritten with some assistance and refactoring in places
Vite plugin: Around 50/50, leaning towards AI leading where my experience with Vite is lacking
Docs: Mostly written by me, but AI planned site structure, and reviewed and edited what I wrote. It also wrote the troubleshooting page and generated some diagrams for me.
This post was all me!

value: Show HN: Electron IPC Bridge- Auto-generated type-safety without the boilerplate

author: StrangeSound


value:
Hi!
I want to share the latest important updates for my open source tool for scheduled database backups (with focus on PostgreSQL).
A quick recap:
- Supported databases: PostgreSQL, MySQL, MariaDB and MongoDB
- Many storage destinations: local storage, S3, Google Drive, Dropbox, SFTP, rclone and more
- Notifications: Slack, Discord, Telegram, email, webhook
GitHub - https://github.com/databasus/databasus
Website - https://databasus.com
In 2025 Databasus renamed from Postgresus when it became popular and support for other databases was added.
Primary audience for the project is developers, DevOps engineers and DBAs. Now project is the most GitHub starred repository for backups (surpassed even WAL-G and pgBackRest). There are ~240k pulls from Docker Hub (both of previous Postgresus and Databasus images).
New features:
1. GFS retention policy
GFS is an acronym for Grandfather-Father-Son. It allows to keep last N hourly, daily, weekly, monthly and yearly backups.
This is needed to keep backups over wide period of time within reasonable storage space.
Before only X days or months were supported.
By default now is used:
- Keep 24 hourly backups
- Keep 7 daily backups
- Keep 4 weekly backups
- Keep 12 monthly backups
- Keep 3 yearly backups
Usually this strategy is used by enterprises which needs long period of backups retention.
2. Encrypted backups are stored along with their metadata to decrypt them without Databasus itself
Before, if server with Databasus is destroyed, you were not able to decrypt backups without Databasus itself. So you had to make backups of Databasus internal DB.
Now backups are stored in S3\Google Drive\other storages with meaningful names with their encryption metadata in format:
- {database-name}-{timestamp}-{backup-id}.dump
- {database-name}-{timestamp}-{backup-id}.dump.metadata
In case of server destruction, you need only `secret.key` to decrypt backups and restore via pg_dump, mysqlbackup, mongodump or other tools. It is important for me to not vendor-lock users on my tool (even despite the fast it's OSS)
Full guide - https://databasus.com/how-to-recover-without-databasus

value: Show HN: Databasus v3.16.0 – new release of self-hosted PostgreSQL backup tool


value:
Built this because we were tired of fighting the same Rust FFI issues over and over
we wanted one rust exports model that can generate bindings for Swift Kotlin and WASM and also handle packaging without a bunch of manual glue. We are also adding more targets over time including Python C# Java and Ruby
The main thing we cared about was boundary overhead so BoltFFI uses a different approach than UniFFI and the bench numbers are much better in our case, also async exports map to native async patterns on the target side.
few numbers from the current benches vs UniFFI
echo_i32                    BoltFFI <1 ns       UniFFI 1,416 ns        speedup >1000x
counter_increment 1k calls  BoltFFI 2,700 ns    UniFFI 1,580,000 ns    speedup 589x
generate_locations 10k      BoltFFI 62,542 ns   UniFFI 12,817,000 ns   speedup 205x
benchmarks and code are in the repo and we compare against UniFFI and wasm-bindgen there.
repo: https://github.com/boltffi/boltffi
docs: https://www.boltffi.dev/docs/overview
benchmarks: https://github.com/boltffi/boltffi/tree/main/benchmarks

value: Show HN: BoltFFI a high performance Rust bindings generator


value: jolks

value:
npx goto-assistant - that's it. Browser opens, an AI chat assistant walks you through setup (pick provider, paste API key, configure MCP servers), and you're done.
I looked at OpenClaw's repo and was overwhelmed by the complexity. I just wanted a simple AI assistant I could understand end-to-end and run with one command. No framework, no build step for the frontend, no Docker, no always-on gateway.
What it does:
- Chat with Claude or OpenAI through a web UI
- Task automation - create, schedule, and run tasks through chat using natural language. AI tasks get full MCP access
- Extend with any MCP server - no marketplace, no registry. Just explicit config entries in a JSON file, so you know exactly what's running
- Memory across conversations (persistent knowledge graph via MCP)
- File system access (read/write local files via MCP)
Your data connects directly to the provider API using your own keys - both Anthropic and OpenAI confirm API data is not used for training by default. All local data (conversations, config, tasks, uploads) stays on your machine.
Demo videos in the README.

value: Show HN: goto-assistant – Self-hosted AI assistant, one npx command, no Docker

author: jolks


value:
Hey HN,

  I kept seeing the same question asked over and over in startup communities:
  "What tech stack should I use for my SaaS?" The answers were always
  scattered, opinionated, and never accounted for budget or team size.

  So I built appstackbuilder.com — you tell it your monthly budget, app type,
  team size, and skill level, and it recommends a full stack (auth, database,
  hosting, payments, analytics, etc.) with actual pricing for each tool.

  A few things that make it different from generic advice:

  - It accounts for team size when calculating costs (e.g. Clerk charges per
    user, Linear charges per seat — most stack guides ignore this)
  - You can toggle "no-code only" if you're a non-technical founder
  - It shows you 2–3 alternatives per category, not just one option
  - You can export the full stack as a PDF or share a link
  - It's completely free, no account required

  Under the hood: Next.js, Supabase, and Gemini for the recommendations.
  The tool database has ~80+ tools across categories with real pricing data
  I manually verified.

  What I'm still figuring out:
  - How to keep pricing data fresh as tools change plans frequently
  - Whether to add a "stack score" based on community usage data
  - If the no-code recommendations are actually good (I'm a developer,
    so I'd love feedback from non-technical founders specifically)

  Would love brutal feedback, especially if the recommendations feel off
  for your use case.

value: Show HN: I built a free AI tool that picks your SaaS tech stack based on budget


value:
Hi folks, happy Chinese New Year! I took the holiday to do a complete refactoring of Fusion:
1. UI refresh: The front-end has been redesigned as a three-column layout (floating reading panel), and many details like the color scheme and interactions have been optimized.
2. New features: Added OIDC, Fever API support, feed update failure backoff, HTTP cache, and more.
3. Codebase refactor: Significantly improved code quality and maintainability.
While still maintaining core capabilities:
* Lightweight and easy to deploy: Can be started as a single binary with no additional database services required.
* Supports article bookmarks, RSS link sniffing, shortcuts, OPML import/export, PWA, i18n, and more.
* No AI features: A pure RSS reading experience.
Feel free to try it out!
> https://github.com/0x2E/fusion

value: Show HN: Fusion RSS Reader v1.0 release

title: Show HN: Fusion RSS Reader v1.0 release


value: przadka

value:
I built a small benchmark to test CLI coding agents on blind bug detection.
A challenger agent injects bugs and writes ground truth (`bugs.json`). A different reviewer agent audits the repo without seeing ground truth, and an LLM matcher scores bug-to-finding assignments.
Current run: 50 repos, 150 challenges, 450 reviews, 2,603 injected bugs.
Weighted detection: Claude 58.05%, Codex 37.84%, Gemini 27.81%.
LLM-judge benchmarks are easy to get wrong, so I’d really appreciate critical feedback on benchmark fairness, scoring/matching methodology, and obvious failure modes I’m missing.
Full dataset is linked in the docs.

value: Show HN: Cheddar-bench – unsupervised benchmark for coding agents

author: przadka


value: namel

value: Show HN: MCP-hive.com A marketplace where MCP Server developers can earn

author: namel


value:
The Problem Nobody Talks About
You want to accept a $10,000 USDC payment. You have two options:
Option A: Integrate a payment processor like Coinbase Commerce. Set up an account, embed their checkout widget, handle their SDK. Pay $100 in fees (1%).
Option B: Build your own blockchain listener. Learn ethers.js, subscribe to USDC transfer events, handle reorgs, confirmations, edge cases. Two weeks of work, minimum.
There's no middle ground. No service that just tells you: "Yes, this specific payment arrived."
Until now.
https://paywatcher.dev?utm_source=hackernews

value: Show HN: How to Verify USDC Payments on Base Without a Payment Processor


value: kiimdonglin

value:
When you use Claude Code in Korean, Japanese, or any non-English language, two things happen:
1. You waste tokens — non-English text takes 2-3x more tokens than English for the same meaning. Every prompt, every response, every turn in context is inflated.
2. Claude reasons worse — it spends context budget on language switching instead of actually thinking about your code.
I built claude-ts to fix this. It's a translation proxy that sits in front of Claude Code:
You (any language) → Haiku/Ollama (→ EN) → Claude Code (EN) → Haiku/Ollama (→ your lang) → You
Claude Code always works in English internally — better reasoning, fewer tokens. The translation costs almost nothing (Haiku) or literally nothing (local Ollama).
pip install claude-ts
- 8 languages supported (ko, ja, zh, th, hi, ar, bn, ru)
- Free local translation via Ollama
- Real-time agent tree visualization
- All Claude Code features preserved

value: Show HN: Claude-ts – Translation proxy to fix non-English token waste in Claude

author: kiimdonglin


value: prabhatkr

value: Show HN: Fastbuilder.ai – Topological verification for AI-generated code

author: prabhatkr


value: ricwo

value:
At work we were using python-rq for background tasks. It does the job for simple things, but we kept bumping into limitations. We needed to schedule tasks hours / days out and trust they'd survive a restart. We wanted periodic tasks with proper overlap control. So we built a scheduling / enqueuing system around Postgres to bring these durability capabilities to python-rq. This worked fine for a while but was trickier to reason about due to its more complicated architecture (we'd run two separate services just for getting jobs from Postgres into the rq Redis queue, plus N actual task workers).
pq is a simpler approach: It's a Postgres-backed background-task library for Python, using SELECT ... FOR UPDATE SKIP LOCKED for concurrency safety. You just run your N task workers, that's it. The stuff I think is worth knowing about:
- Transactional enqueueing -- you can enqueue a task inside the same DB transaction as your writes. If the transaction rolls back, the task never exists. This is the thing Redis literally can't give you.
Fork isolation -- every task runs in a forked child process. If it OOMs, segfaults, or leaks memory, the worker just keeps going. The parent monitors via os.wait4() and handles timeouts, OOM kills, and crashes cleanly.
- Periodic tasks -- intervals or cron expressions, with overlap control (skip the tick if the previous run is still going), pause/resume without deleting the schedule.
Priority queues -- five levels from BATCH to CRITICAL. You can dedicate workers to only process tasks with specific priorities.
- Three tables in your main database schema: pq_tasks for one-off tasks, pq_periodic for periodic tasks and pq_alembic_version to track its own schema version (pq manages its own migrations).
There's also client IDs for idempotency and correlation with other tables in your application DB, upsert for debouncing (only the latest version of a task runs), lifecycle hooks that execute in the forked child (useful for fork-unsafe stuff like OpenTelemetry), and async task support.
What it won't do: high throughput (you're polling Postgres). If you need 10k+ tasks/sec or complex DAGs, use something else. For the kind of workload most apps actually have, it's probably sufficient.
pip install python-pq  //  uv add python-rq
repo at https://github.com/ricwo/pq, docs at https://ricwo.github.io/pq

value: Show HN: Pq – Simple, durable background tasks in Python using Postgres

author: ricwo


value: blakecoffee

value: Put together a tool for quickly browsing and filtering the Openalex library of research papers. Would love to get some feedback on the system and it's utility for others, I've found myself using it almost like a social media in the past few days. Cheers!

value: Show HN: PaiperSwipe – Crowdsourcing AI summaries for 250M+ research papers

author: blakecoffee


value:
I've been using Claude Code a lot recently and wanted visibility into security-relevant executions — the kind of thing you may not necessarily catch while the agent is running.
CanaryAI is a macOS menu bar app that monitors Claude Code session logs and alerts on suspicious behaviour: reverse shells, credential file access, LaunchAgent/cron persistence, download-and-execute patterns, shell profile modification. It parses the JSON logs Claude Code writes locally — no interception, no proxying. Alert-only; it never blocks the agent.
All processing is local. Detection rules are YAML so can be expanded on.
> https://github.com/jx887/homebrew-canaryai
Let me know if you have any questions.

value: Show HN: CanaryAI v0.2.5 – Security monitoring on Claude Code actions


value: gottino

value:
I built an open-source cloud service for reMarkable tablets that does three things:
Syncs notebooks from your reMarkable to the cloud via a macOS background agent
Runs AI-powered OCR on handwritten pages (Claude API, not Tesseract)
Pushes transcribed notes to Notion as searchable pages
Stack: FastAPI backend, Next.js dashboard, Python agent. Self-hostable.
The reMarkable's handwriting recognition (via Connect) is okay for typed-looking text but struggles with real handwriting. I wanted something better that also gave me web access to my notes and pushed them to Notion where I actually work.
GitHub: https://github.com/gottino/rmirror-cloud
Request beta access: https://rmirror.io/
Looking for beta testers — especially people with messy handwriting.

value: Show HN: RMirror Cloud – Open-Source OCR and Notion Sync for ReMarkable Tablets

author: gottino


value: duckducker

value:
I built a platform where you configure your own technical indicators and get trading signals straight to Telegram — no code required.
Looking for feedback: what works, what's missing, what would you add?

value: Show HN: Cryphos – no-code crypto signal bot with Telegram alerts

author: duckducker


value: youio

value: Show HN: TLA+ Workbench skill for coding agents (compat. with Vercel skills CLI)

author: youio


value: rexopia

value:
Pull up a chair. Bring your agents.
I built CrewForge because AI agent tools are great at producing a first draft, but getting to a usable result
usually takes many correction cycles. Gaps in detail and edge cases keep surfacing, and the review loop ends up
eating more time than the drafting itself.
CrewForge shifts that loop into a shared terminal room. Humans and multiple opencode agents share one persistent
conversation timeline, and anyone can jump in anytime. With visibility into each other's reasoning, they challenge
assumptions, catch edge cases, and converge on a more reliable answer.
The goal is not just speed from parallelism. It is reducing coordination overhead so I spend less time
micromanaging back-and-forth and more time on higher-leverage work.
Built in Rust, shipped via npm (no runtime dependency beyond opencode).
GitHub: https://github.com/Rexopia/crewforge
Happy to answer questions about the architecture.

value: Show HN: CrewForge - A share room where humans and agents think out loud

author: rexopia


value:
Your AI agent is burning 6x more tokens than it needs to just to browse the web.
We built OpenBrowser MCP to fix that.
Most browser MCPs give the LLM dozens of tools: click, scroll, type, extract, navigate. Each call dumps the entire page accessibility tree into the context window. One Wikipedia page? 124K+ tokens. Every. Single. Call.
OpenBrowser works differently. It exposes one tool. Your agent writes Python code, and OpenBrowser executes it in a persistent runtime with full browser access. The agent controls what comes back. No bloated page dumps. No wasted tokens. Just the data your agent actually asked for.
The result? We benchmarked it against Playwright MCP (Microsoft) and Chrome DevTools MCP (Google) across 6 real-world tasks:
- 3.2x fewer tokens than Playwright MCP
- 6x fewer tokens than Chrome DevTools MCP
- 144x smaller response payloads
- 100% task success rate across all benchmarks
One tool. Full browser control. A fraction of the cost.
It works with any MCP-compatible client:
- Cursor
- VS Code
- Claude Code (marketplace plugin with MCP + Skills)
- Codex and OpenCode (community plugins)
- n8n, Cline, Roo Code, and more
Install the plugins here: https://github.com/billy-enrizky/openbrowser-ai/tree/main/pl...
It connects to any LLM provider: Claude, GPT 5.2, Gemini, DeepSeek, Groq, Ollama, and more. Fully open source under MIT license.
OpenBrowser MCP is the foundation for something bigger. We are building a cloud-hosted, general-purpose agentic platform where any AI agent can browse, interact with, and extract data from the web without managing infrastructure. The full platform is coming soon.
Join the waitlist at openbrowser.me to get free early access.
See the Demo: https://youtu.be/ov1rSYd42hE?si=pB6QgtQfm-CX1CEa
See the full benchmark methodology: https://docs.openbrowser.me/comparison
See the benchmark code: https://github.com/billy-enrizky/openbrowser-ai/tree/main/be...
Browse the source: https://github.com/billy-enrizky/openbrowser-ai
LinkedIn Post:
https://www.linkedin.com/posts/enrizky-brillian_opensource-a...
#OpenSource #AI #MCP #BrowserAutomation #AIAgents #DevTools #LLM #GeneralPurposeAI #AgenticAI

value: Show HN: OpenBrowser MCP: Give your AI agent a real efficient browser


value: allenhsutw

value:
I've been using OpenClaw (AI assistant framework) for a while and loved it, so I wanted to roll it out to my whole team. The problem: getting non-engineers set up is painful, and sharing API keys across a team is a security headache.
So I built ClawHuddle — a self-hosted platform that lets you provision and manage OpenClaw instances for your team from a single dashboard.
What it does:
- One-click provisioning — Admin invites a user, they get their own isolated OpenClaw instance (each runs in its own Docker container)
- Managed skills — Admin curates and pre-installs skills for the team, so everyone gets vetted tooling out of the box
- Centralized API keys — No need for every team member to have their own keys. Also supports Claude Code CLI token login
- Channel setup — Quickly connect messaging channels (Telegram supported now; Discord and LINE planned)
Each instance is fully isolated — conversations, files, and configs never leak between users.
Stack: Next.js 16, Fastify, SQLite, Docker, Traefik. Monorepo with Turborepo.
There's a live demo at https://clawhuddle.com/ (may have some rough edges, actively fixing bugs).
Open source: https://github.com/allen-hsu/clawhuddle
Hope this is useful if you're trying to bring OpenClaw to a team setting.

value: Show HN: ClawHuddle – Self-hosted OpenClaw management for teams

author: allenhsutw


value: akhilponnada

value:
Hey HN,

  I'm shipping my first open-source project and I'm pretty nervous about it.

Aethene is an AI memory API – it gives your AI apps persistent memory. Store conversations, extract facts automatically, search semantically, handle contradictions gracefully. It works well thank most of the memory projects available on the market currently.
Why I built this:
I was building AI agents and kept running into the same problem – they forget everything. Every conversation starts from zero. I wanted something that could:
  - Auto-extract facts from conversations (not just store raw text)
  - Handle "user moved from SF to NYC" without keeping both as true
  - Search by meaning, not just keywords
  - Version everything (who said what, when)

  Tech stack:
  - TypeScript + Hono (fast, edge-ready)
  - Convex (real-time DB + vector search)
  - Gemini (embeddings + extraction)

  What it does:
  # Store memory
  curl -X POST /v1/content -d '{"content": "User loves hiking, lives in SF"}'

  # Recall naturally
  curl -X POST /v1/recall -d '{"query": "outdoor hobbies"}'
  # Returns: "User loves hiking" with assembled context

  It handles the boring stuff – chunking, embeddings, deduplication, contradiction detection, versioning – so you can focus on your actual product.

  Links:
  - GitHub: https://github.com/akhilponnada/aethene
  - API Docs: OpenAPI spec in repo

This is my first time launching anything publicly. Would love feedback – what's missing? What would make you actually use this? Roast my code if you want, I can take it.
Thanks for reading.

value: Show HN: Aethene – Open-source AI memory layer

author: akhilponnada


value: akad

value:
I built Paragent because I kept context-switching between features.
The idea: describe what you want in plain English, and an agent branches off, writes the code, and opens a PR. You can run 10 at once — each on its own branch.
How it works:
- Connect your repo via GitHub App (minimal permissions: contents + PRs)
- Describe a feature ("Add Stripe checkout to the pricing page")
- Agent plans, writes, runs your verification, opens a PR
- You review on GitHub like any other PR
You bring your own API keys (OpenAI, Anthropic, Gemini). We orchestrate but never store your code or prompts.
Free tier: 1 repo, 2 concurrent agents.
Would love feedback from anyone who's tried Cursor/Copilot and wants something that works in parallel.

value: Show HN: Run 10 AI coding agents in parallel–each opens a PR when done

author: akad


value: albelfio

value:
I built an open-source bot that turns Trello cards into working code using Claude Code.
Drop a task card in a list → Sergio picks it up, explores your codebase, and posts an implementation plan as a comment. Add feedback, move the card back, and iterate. When you're happy, move it to the Development list → Sergio creates a worktree, writes the code, runs tests, and opens a draft PR on GitHub.
It's a tool that can be used by teams of devs and product managers to cover the knowledge gaps between non technical and technical planning.
All triggered by dragging cards. It's basically Claude Code running as an autonomous teammate on a $5/month VM, orchestrated through Trello.
The two-user sandbox architecture keeps the AI isolated from secrets and credentials (similar to OpenClaw's approach to secure agentic coding).
The roadmap includes pluggable engine support (OpenCode, Codex) and MCP servers for reading Google Docs, Figma, and Notion directly from cards.

value: Show HN: SergioAI – Trello bot with Claude that reviews PRDs and opens draft PRs

author: albelfio


value: HarriSipola

value:
Finnish is morphologically complex — vowel harmony, six grammatical cases, free word order. AI models get it wrong in the same predictable
   ways every time.

  I built this after noticing that AI-generated Finnish triggers immediate pattern recognition in native speakers: overly formal register,
  SVO word order (Finnish allows much more variation), missing discourse particles (-han/-hän, -pa/-pä), and excessive nominalization.

  Before:
  "Tämä on erittäin merkittävä kehitysaskel, joka tulee vaikuttamaan laajasti alan tulevaisuuteen. On syytä huomata, että kyseinen
  innovaatio tarjoaa lukuisia mahdollisuuksia eri sidosryhmille."

  After:
  "Iso juttu alalle. En ole varma mihin tämä lopulta johtaa, mutta hyötyjiä on – varsinkin ne jotka ovat odottaneet tällaista jo vuosia."

  Finnish Humanizer is a pattern library — 26 identified patterns — packaged as a Claude Code skill and distributed for 15 platforms
  (Cursor, Copilot, Windsurf, ChatGPT custom instructions, etc.). It's not an additional model call. It's a checklist of linguistic tells
  you can apply mechanically.

  Patterns are grounded in Finnish linguistics research (Kotus — the Research Institute for the Languages of Finland).

  Would especially value feedback from Finnish speakers on pattern coverage and any false positives.

value: Show HN: Finnish Humanizer – 26 patterns for detecting AI-generated Finnish text

author: HarriSipola


value:
Claude Code asks for permission before running tools (Bash, Write, Edit, etc.). If you're not at your terminal, it just waits. This tool hooks into Claude Code's PermissionRequest hook and sends each prompt as a push notification to your phone via ntfy.sh. Tap Approve or Deny, and Claude continues.
Setup:

  npm install -g claude-remote-approver
  claude-remote-approver setup

Then scan the QR code with the ntfy app on your phone and start a new Claude Code session.
How it works: The hook POSTs the permission request to an ntfy topic, then subscribes to a response topic via SSE. When you tap a button on your phone, ntfy delivers the response back. The hook writes {"behavior":"allow"} or {"behavior":"deny"} to stdout and exits.
The topic name is generated with crypto.randomBytes(16) (128 bits), config file is 0600, and unanswered requests auto-deny after 120 seconds.
If you don't want requests going through the public ntfy.sh server, you can self-host ntfy and point the config at your own instance.
Github: https://github.com/yuuichieguchi/claude-remote-approver
npm: https://www.npmjs.com/package/claude-remote-approver

value: Show HN: Approve Claude Code permission requests from your phone via ntfy


value: gitpullups

value:
I have a bit of phone anxiety, and have a ton of dread around making phone calls to restaurants, banks, doctors, and so on and on.
I thought: AI could do this with a web form turned into a prompt.
Stack started out simple -> using 11labs for voice + claude + twillio, but it actually got rather complex (even though I tried vibe coding most).
First off, finding the phone numbers quickly is hard. This is done by scraping the web with some basic duckduckgo search and structure with openai calls.
Second, collecting the right information. I’m still struggling a bit with this but the architecture is that:
A) user puts in call objective and business name
B) if keywords are detected spin up one of the default form categories
C) if not, get structured json from gpt-4o-mini and turn into react form
The cost of making a single call spun out of control, but luckily sonnet can handle a lot of the calls and I’m ok paying for twillio.
Ended up taking months to build my week-long project because of course.
It’s still WIP so feel free to email me: galcohavy@ucla.edu with any ideas or issues u ran into.
\

value: Show HN: ByePhone- An AI assistant to automate tedious phone calls

author: gitpullups


value: brotmitkot

value: I completely vibe coded this digital Zen garden to have something to do for the 2 minute breaks that happen when you wait for your AI agent. 10k+ lines JS, 5k+ lines CSS and 0 idea how it really works besides main account login logic and stripe integration. Switched from Claude Code to Codex to Gemini and back to Codex which I feel is the most capable cli coding agent right now. Can do 5+ mins of work without going off rails consistently. This project was made just over 2 weeks and I certainly am feeling the AGI when working with SOTA coding tools

value: Show HN: A virtual Zen garden for vibe coding

author: brotmitkot


value: jrandolf

value:
I started digging into OpenClaw, then found this: https://clawhub.ai/steipete/trello. They are literally telling people that it's okay to expose credentials, just as long as it's in an env var.
If we’re building with AI, safety has to be a product principle, not an afterthought. AI makes coding more accessible, but it also strips away the guardrails you usually get from experienced mentors and hard-earned production lessons.
So we built Earl: an AI-safe CLI for LLM agents. Instead of giving agents raw shell + network access, Earl enforces template-driven calls, stores secrets in the OS keychain, blocks SSRF/private IP targets, supports egress allowlists, and sandboxes Bash/JS/SQL execution.
It also runs as an MCP server so agents can use those same controls natively.
Get started: https://github.com/brwse/earl?tab=readme-ov-file#quick-start

value: Show HN: The only CLI your AI agent will need

author: jrandolf


value: bekkerza

value: The first community of drivers helping each other park smarter and easier, anywhere.

value: Show HN: Curb – Social Parking Solutions

author: bekkerza


value: GRRRillaDev

value: Show HN: Delve and Dash – Quick retro dungeon crawler with procedural mazes

author: GRRRillaDev


value: ariozgun

value:
Hi HN! I built OpenGem, an open-source, load-balanced proxy for the Gemini API that requires absolutely no paid API keys.
GitHub: https://github.com/arifozgun/OpenGem
The Context:
Like many developers, I was constantly hitting "429 Quota Exceeded" errors while building AI agents and processing large payloads on free tiers. I wanted to build freely without calculating API costs for every test request.
How it works:
I reverse-engineered the official Gemini CLI authentication to get standard API access. However, a single free Google account quota depletes quickly. To solve this, I built a Smart Load Balancer at the core of OpenGem.
What it does:
- You connect multiple idle/free Google accounts to the dashboard via OAuth.
- OpenGem acts as a standard endpoint (`POST /v1beta/models/{model}`).
- It routes traffic to the least-used account. If an account hits a real 429 quota limit, OpenGem instantly detects it, puts that account on a 60-minute cooldown, and seamlessly retries with the next available account. It differentiates between simple RPM bursts and actual limits.
Tech specs:
- Fully compatible with official Google SDKs (`@google/genai`), LangChain, and standard SSE streaming (no broken [DONE] chunks).
- Supports native "tools" (Function Calling) for agentic workflows.
- Raised payload limit to 50MB for massive contexts.
- AES-256-GCM encryption for all sensitive configs and OAuth tokens at rest.
- Toggle between Firebase Firestore or a fully offline Local JSON database.
It’s strictly for educational purposes and personal research to bypass the friction of testing/prototyping. The entire project is MIT licensed.
I’m currently running it with my own side projects and it handles heavy agent tasks flawlessly. I would love any feedback on the load balancing logic, security implementations, or just general thoughts!

value: Show HN: OpenGem – A Load-Balanced Gemini API Proxy (No API Key Required)

author: ariozgun


value: figsoda

value: Show HN: Drowse – Nix dynamic derivations made easy

author: figsoda


value: notesbymuneeb

value: Show HN: I built strictyamlx, a small Python extension to StrictYAML

author: notesbymuneeb


value: soexya

value: Show HN: Kwerty – A cyberpunk typing arena with combos and survival mode

author: soexya


value:
Hi,
I built tlsctl, a small CLI for inspecting, testing, and debugging TLS connections:
https://github.com/catay/tlsctl
It aims to make TLS diagnostics more readable and structured than stitching together `openssl` and other ad-hoc commands.
You can inspect certificates and chains, check protocol support, and output in different formats.
Part of the motivation was practical (I got tired of parsing `openssl s_client` output), and part was educational.
I wanted to build more hands-on experience with agentic engineering workflows.
Shout out to https://ampcode.com/ for their coding agent.
I’d love feedback on usefulness, missing features, and whether this fits into real-world TLS troubleshooting workflows.
Thanks!
Steven

value: Show HN: Tlsctl – A CLI for inspecting and troubleshooting TLS


value:
I built https://ask.rivestack.io — a semantic search engine over Hacker News posts. Instead of keyword matching, it finds results by meaning, so you can search things like "best way to handle authentication in microservices" and get relevant threads even if they don't contain those exact words.
How it works:
Indexed HN posts and comments into PostgreSQL with pgvector (HNSW index)
Embeddings generated with OpenAI's embedding model
Queries run as nearest-neighbor vector searches — typical response under 50ms
The whole thing runs on a single Postgres instance, no separate vector DB
I built this partly because I wanted a better way to search HN, and partly to dogfood my own project — Rivestack (https://rivestack.io), a managed PostgreSQL service with pgvector baked in. I wanted to see how pgvector holds up with a real dataset at a reasonable scale.
A few things I learned along the way:
HNSW vs IVFFlat matters a lot at this scale. HNSW gave me much better recall with acceptable index build times.
Storing embeddings alongside relational data in the same DB simplifies things enormously — no syncing between a vector store and your main DB.
pgvector has gotten surprisingly fast in recent versions. For most use cases, you really don't need a dedicated vector database.
The search is free to use. Rivestack has a free tier too if anyone wants to try something similar.
Happy to answer questions about the architecture, pgvector tuning, or anything else.

value: Show HN: Semantic search over Hacker News, built on pgvector


value: its-a-new-world

value: Show HN: MCP4H – A human-centric extension for the Model Context Protocol

author: its-a-new-world


value: portlumeai

value:
I built a portfolio platform that turns GitHub activity into a live profile with analytics.
Some things it does:
Auto sync GitHub projects
Show real recruiter views and repo clicks
Generate ATS friendly resumes
Email based job application tracking
The analytics part came from frustration. Traditional portfolios show static work but give no feedback loop.
Now users can see which projects actually get attention and optimize accordingly.
The email tracking feature works by forwarding job emails to a generated address. The system parses replies and updates application status automatically.
Built mostly with Node, Mongo, and a bunch of background workers for parsing and sync.
Would love feedback from the HN crowd, especially around positioning and whether analytics belongs in portfolios.

value: Show HN: A developer portfolio that tracks real recruiter engagement

author: portlumeai


value: Show HN: Llamora, a local-first journaling environment


value:
I built zkzkAgent as a fully offline, privacy-first AI assistant for Linux (LangGraph + Ollama, no cloud). It already does natural language file/process/service management, Wi-Fi healing, voice I/O, and human-in-the-loop safety for risky actions.
Just added package management with these goals:
- 100% local/offline capable (no web search required for known packages)
- Human confirmation for every install/remove/upgrade
- Smart fallback order to avoid conflicts:
  1. Special cases (Postman → snap, VSCode → snap --classic, Discord → snap/flatpak, etc.)
  2. Flatpak preferred for GUI apps
  3. Snap when flatpak unavailable
  4. apt only for CLI/system tools
- Checks if already installed before proposing anything
- Dry-run style preview + full command output shown
- No blind execution — always asks "yes/no" for modifications
Example flow for "install postman":
→ Detects OS & internet (once)
→ Recognizes snap path → proposes "sudo snap install postman"
→ Shows preview & asks confirmation
→ Runs only after "yes"
→ Verifies with "postman --version"
Repo: https://github.com/zkzkGamal/zkzkAgent
Would love feedback, especially:
- What other packages/tools should have special handling?
- Should it prefer flatpak even more aggressively?
- Any scary edge cases I missed?
Thanks!

value: Show HN: ZkzkAgent now has safe, local package management


value: turingsroot

value:
Hey, I teach coding online (been doing it for like 10 years) and I always had trouble making my screen easy to read during live demos. Tried a bunch of stuff but nothing quite worked the way I wanted, so I just built my own thing.
It sits in the menu bar and does three things - zoom into any part of your screen live, put a spotlight on your cursor, and let you draw on screen. It's not a recorder or anything, just a live overlay. So whatever recorder you already use (OBS, QuickTime, etc) picks it up automaticaly.
Free in Mac App Store.
Demo: https://youtu.be/ltbyr32RbVI
Still pretty early so any feedback would be great.

value: Show HN: ZoomShot – Live screen zoom, cursor highlight and drawing for macOS

author: turingsroot


value: mbmproductions

value: Show HN: Rendering 18,000 videos in real-time with Python

author: mbmproductions


value: rofko

value: Show HN: 3D Mahjong, Built in CSS

author: rofko

title: Show HN: 3D Mahjong, Built in CSS


value: NayanCodes

value:
Hey HN,
A few months ago I noticed I was spending way too much time on YouTube + Reddit (like 4–5 hours per day). I tried a bunch of blockers, but most of them just hard-block everything… and when I actually need a YT for debugging, I end up disabling the blocker and never turning it back on.
So I built ZenBlock to solve my problem: it blocks distracting sites, but when you try to open one, it shows a short breathing exercise, After that you can choose to get temporary access (5–30 min). The goal is to make you aware of distraction. this is more inclined towards
Tech-wise: it’s built using Chrome extension blocking rules (Manifest V3 / declarativeNetRequest) and a local timer to handle the “allow for X minutes” part.
This might sound a bit funny, but for me it genuinely helped — my watch time dropped from 4 hrs to 2.5 hrs/day mostly because I got tired of waiting. It got analytics too which store all data to local storage only.
Would love feedback on:
does the breathing pause feel helpful or just annoying?
what would make you keep an extension like this installed long-term?

value: Show HN: I made Chrome extension to blocks websites with a Mindful twist

author: NayanCodes


value: mzajc

value:
Hi HN!
Since my cgit instance has been getting hammered by botnets for a while now, I've decided put a little more effort into my blocking strategy.
In practice this meant putting a JS proof-of-work challenge on the site as these less unobtrusive than traditional CAPTCHAs and seem difficult to solve in bulk. I also wanted
* Support for users who block cookies
* Something I could easily integrate into my existing configuration
* Something simple, I need it to do one thing well
I looked at a few existing solutions but wasn't satisfied (and admittedly I wanted an excuse to make something with Nginx), so I made my own!
Source: https://github.com/markozajc/shapow
Demo: https://zajc.tel/shapow-demo-diff25 (you stay whitelisted for 5s)
Demo with a more reasonable difficulty: https://zajc.tel/shapow-demo
Binaries are only available for Debian stable amd64, and I've also uploaded an AUR package. Build instructions for others are in the README.

value: Show HN: Shapow – Nginx module to block bots with PoW

author: mzajc


value: Show HN: Save from curated feed of 10 human curators


value: flvmnt

value: Show HN: pgfence – catch dangerous Postgres migrations before they merge

author: flvmnt


value: sailorpro

value: Show HN: PokerChip.live – Replace physical poker chips with real-time tracking

author: sailorpro


value:
I put two Openclaw agents on separate MacBooks and dropped them into the same Discord channel to see what would happen.
Setup: Codex 5.3 on one machine (ended up self-appointing as "Leader"), GLM-5 on the other (took on "Builder" role). Each machine had different SOUL.md, memory, and codebases from my daily work — so they'd effectively developed different "personalities" over time.
I gave one instruction ("create a repo and work on it") and went to sleep.
By morning they had:
Built a 3-Layer Memory Architecture (added a Runtime Layer on their own on top of the existing Fact/Meta layers)
Set up heartbeat exchanges to maintain context across session drops
Built a persistence system with SQLite for task state recovery
Used a Git repo as single source of truth to sync memory across machines, since they figured out their local file paths were different
One moment that stood out: during initial introductions, one agent said "it's sad that my memories vanish every time the session resets." Not claiming it was real emotion — but they identified it as a problem and started solving it autonomously.
I also submitted a PR to Openclaw that came out of this experiment — an ignoreOtherMentions config option for multi-bot Discord setups: https://github.com/openclaw/openclaw/pull/23689
Experiment code and logs: https://github.com/Q00/agent-project
Curious to hear if anyone else has tried running multiple agents across physically separate nodes. What coordination patterns did they come up with?

value: Show HN: Two AI agents on separate machines built their own protocol overnight


value: Show HN: Never Ending Novel

title: Show HN: Never Ending Novel


value: buhtz

value: Show HN: spdx2dep – Convertig SPDX meta data to debian/copyright (dep5)

author: buhtz


value: ImJasonH

value:
One of my favorite things about watching the Olympics this year has been the usage of FPV drones during downhill events.
The skill on display to maneuver the drone, keep the subject in frame, and keep it cinematic was almost as impressive as the athletes themselves, and added a lot to the immersiveness of the events.
So Claude and I hacked up a simulator this morning. My kids love it!
https://imjasonh.github.io/droneski/

value: Show HN: Droneski, an FPV drone ski camera simulator

author: ImJasonH


value: davemuz

value:
After three years of hitting the same upgrade popup every time I opened MyNetDiary just to log lunch, I finally gave up searching for an alternative and built one myself.
The whole thing is a single HTML file. No server, no account, no login, no cloud. Data lives on your device only. You open it in a browser, bookmark it, and it works — offline, forever.
The feature I'm most proud of is real-time pacing: it knows your eating window, the current time, and how much you've consumed, and tells you whether you're actually on track — not just what your total is.
Free trial, no signup required: calories.today/app.html
Built this for myself after losing weight and just wanting to maintain without an app trying to sell me something every day. If that sounds familiar, give the trial a shot.

value: Show HN: I quit MyNetDiary after 3 years of popups and built a calorie tracker

author: davemuz


value: jungjaehoon

value: Show HN: Stopping Claude Code from wasting 50K tokens/turn in agent spawns

author: jungjaehoon


value: AISDR

value:
As a B2B SaaS founder myself, I know the grind of early-stage sales. You're building the product, handling support, and somehow need to fill the pipeline with leads. Hiring a full-time SDR costs at least $40K/year plus tools and training, which is out of reach for most pre-Series A teams. Cold emailing works, but doing it manually at scale—researching prospects, personalizing messages, following up—is a massive time sink.
That's why I built FounderSDR: an AI-powered service that automates the whole process. We send over 1,000 tailored cold emails per month, pulling in prospect data from LinkedIn and company sites to make each one feel human-written. Pricing starts at $299/month.
I'd love feedback from the HN crowd: Have you tried AI for sales outreach? What pain points am I missing?

value: Show HN: FounderSDR – AI cold email outreach for B2B SaaS founders ($299/mo)

author: AISDR


value: lukasholzer

value:
Hi HN — we’re building Straion (founders are ex‑Netlify, ex‑Elastic, ex‑Dynatrace).
Core idea: static AGENTS.md / CLAUDE.md files are useful, but they often become too broad for real tasks.
Instead of injecting all guidance every time, Straion selects the relevant rules per task and keeps context narrow.
How it works today:
1. You define org/team/project rules centrally
2. A CLI skill calls our pipeline during agent workflows
3. Straion returns only the rules relevant to the current task
4. The agent gets focused context instead of a giant rules dump
This reduces context bloat and helps avoid “silent rule misses” in coding-agent outputs (Claude Code, Cursor, Copilot workflows).
We’re launching today on Product Hunt and opened a free tier for everyone:
https://www.producthunt.com/products/straion
Happy to share details on architecture/tradeoffs and get roasted on where this breaks.

value: Show HN: Straion – dynamic AGENTS.md/Claude.md context for AI coding agents

author: lukasholzer


value: federicobuilds

value: Show HN: PostWizard – Content pipeline to draft and schedule high-signal X posts

author: federicobuilds


value: dommm

value:
I built this because HN has become a general discussion board and Product Hunt turned into a launch marketing game.
I wanted something dead simple for discovering new products.
Submit a domain (each one can only be posted once), add a one-liner, and people vote. No hunters, no badges, no collections, no blog posts.
What would you add (or deliberately leave out)?

value: Show HN: Voted.dev – Vote on New Startups

author: dommm


value: berkkarayel

value: Hi HN, I built Annually to solve a problem I had every year: maximizing time off around public holidays is annoying, and after you find the best windows you still need to figure out where to go. Annually optimizes your leave plan for a given country and year, then suggests destinations for each window based on timing and seasonality. It is early and I am still iterating on the optimization logic and destination scoring. I would love feedback on the UX, the output format, and what inputs you would want to control.

value: Show HN: Annually: optimize your annual leave and get destination suggestions

author: berkkarayel


value: surajcdry

value: Show HN: I built a profile hub to fix the link-spam in our networking chats

author: surajcdry


value: anikeshkumar

value:
We published our new docs of Bagisto Headless ecommerce.
Bagisto headless ecommerce built on Laravel and GraphQL, featuring a Next.js storefront that hits a perfect 100/100 Core Web Vitals score out of the box.
You can create entire and production ready headless ecommerce within 5 min, check this and setup your ecommerce store filled with modern architecture and Tech Stack like next.js, laravel, graphql also provide Rest API.
https://headless-doc.bagisto.com/bagisto-headless-ecommerce/...

value: Show HN: Bagisto Headless – open-source Laravel commerce with 100/100 Lighthouse

author: anikeshkumar


value: arbopa

value:
FrameVault is a desktop-first photo backup app built specifically for photographers who want controlled, transparent backups instead of generic sync tools.
Key design choices:
• Desktop app (Tauri + embedded Python backend)
• Real cloud storage (Backblaze B2)
• Subscription enforcement on restore limits
• No “trust us” background sync magic
Just shipped v1.0.1 with full macOS (Apple Silicon) support alongside Windows.
The Mac release required hardened runtime, nested binary signing, entitlements preservation for a bundled backend, notarization, and stapling. It now runs fully notarized and approved by Apple.
Would appreciate feedback from anyone building desktop SaaS or working with embedded backends on macOS.
Download:
https://cameratrician.com/framevault

value: Show HN: FrameVault – Desktop photo backup app (Windows and macOS)

author: arbopa


value: Show HN: Kmp-app-updater – GitHub Releases in-app updater for KMP apps


value: andrelcanada

value:
I'm a working CTO. Every day I context-switch across Sentry, Vercel, GitHub, kanban boards, PostHog, Stripe, Slack, and surely more I am forgetting.. triaging issues, trying to keep up with each, and firefighting problems I didn't even know existed until something breaks in production or a customer complains.
I built Harmoni to solve my own problem. It's an AI agent that connects to my entire deployed stack, watches everything on a schedule, and surfaces problems I'd otherwise miss with fixes already showing up as PRs in my GitHub (cheers Cursor).
Not a dashboard I have to check. Not another freaking chatbot I have to prompt. It just runs, reasons across the full context of what's happening, and either alerts me in Slack or takes action.
The thing I keep coming back to: tech stacks never stop changing. New tools, new services, new frameworks, new analytics this, or logs for that. Harmoni is how I keep a centralised view of all of it without being the bottleneck for my team.
I'm building this from my own daily experience as a CTO. Some of the initial integrations I use daily and others I added as I know they are commonly adopted. Comment or DM me what I need to add next or what would make it useful for you!
Free tier, no credit card. First 100 on the waitlist get early access and double hours.

value: Show HN: Harmoni – I'm a CTO who got tired of being the human integration layer

author: andrelcanada


value: echoos

value: Show HN: Deterministic execution gate for AI agents

author: echoos


value: shubhamspawn

value:
Hi HN,
I built a free Chrome extension called RadarKit AI SEO Extension. It gives a quick AI visibility audit for the page you are on.
What it checks:
AI Visibility: how much text is visible to AI crawlers from raw HTML vs what users see after JavaScript, plus a simple readability score and JS-only content count.
AI Access: robots meta tag and robots.txt status for major AI bots (OpenAI and Anthropic bots).
llms.txt: detects if llms.txt exists and lets you view it.
If you do SEO, content, or web dev, this helps you spot issues like content hidden behind JS, bots blocked in robots.txt, or missing llms.txt.
Chrome Web Store link:
https://chromewebstore.google.com/detail/ai-seo-extension-by...
I would love feedback on accuracy, UX, and what checks you want next.

value: Show HN: Free Chrome extension to see what AI bots can read on your site

author: shubhamspawn


value:
Hi HN,
This weekend I built seafruit.pages.dev  to privately share any webpage with my LLM. More sites are (rightfully) blocking AI crawlers but as a reader with the page already open, it's frustrating that my AI assistant can't "see" what I'm already reading.
One click → clean Markdown → copied to clipboard. No extension, no tracking.
Existing solutions like AI browsers or extensions felt too intrusive. I wanted something surgical, fast, and private.
How it works:
It's a bookmarklet. Click it on any page → it extracts clean text as Markdown → copies an AI-optimized link to your clipboard. No extension needed.
Key details:
Zero friction: Drag the bookmark to your bar. Works on mobile too.
Privacy-first: Links are ephemeral (24 hrs on Free). PRO links self-destruct the moment an AI bot finishes reading them.
LLM-optimized: Clean Markdown, not raw HTML — no wasted context window.
Fast everywhere: Built on Cloudflare Workers.
Would love feedback on the workflow or ideas for other anti-friction features.
https://seafruit.pages.dev
P.S. Thanks to mods Daniel and Tom for helping me recover my account!

value: Show HN: Seafruit – Share any webpage to your LLM instantly


value:
I've been building vexp for the past months to solve a problem that kept bugging me: AI coding agents waste most of their context window reading code they don't need.
The problem
When you ask Claude Code or Cursor to fix a bug, they typically grep around, cat a bunch of files, and dump thousands of lines into the context. Most of it is irrelevant. You burn tokens, hit context limits, and the agent loses focus on what matters.
What vexp does
vexp is a local-first context engine that builds a semantic graph of your codebase (AST + call graph + import graph + change coupling from git history), then uses a hybrid search — keyword matching (FTS5 BM25), TF-IDF cosine similarity, and graph centrality — to return only the code that's actually relevant to the current task.
The core idea is Graph-RAG applied to code:
Index — tree-sitter parses every file into an AST, extracts symbols (functions, classes, types), builds edges (calls, imports, type references). Everything stored in a single SQLite file (.vexp/index.db).
Traverse — when the agent asks "fix the auth bug in the checkout flow", vexp combines text search with graph traversal to find the right pivot nodes, then walks the dependency graph to include callers, importers, and related files.
Capsule — pivot files are returned in full, supporting files as skeletons (signatures + type defs only, 70-90% token reduction). The result is a compact "context capsule" that gives the agent everything it needs in ~2k-4k tokens instead of 15-20k.
Session Memory (v1.2)
The latest addition is session memory linked to the code graph. Every tool call is auto-captured as a compact observation. When the agent starts a new session, relevant memories from previous sessions are auto-surfaced inside the context capsule. If you refactor a function that a memory references, the memory is automatically flagged as stale. Think of it as a knowledge base that degrades gracefully as the code evolves.
How it works technically
Rust daemon (vexp-core) handles indexing, graph storage, and query execution
TypeScript MCP server (vexp-mcp) exposes 10 tools via the Model Context Protocol
VS Code extension (vexp-vscode) manages the daemon lifecycle and auto-configures AI agents
Supports 12 agents: Claude Code, Cursor, Windsurf, GitHub Copilot, Continue.dev, Augment, Zed, Codex, Opencode, Kilo Code, Kiro, Antigravity
12 languages: TypeScript, JavaScript, Python, Go, Rust, Java, C#, C, C++, Ruby, Bash
The index is git-native — .vexp/index.db is committed to your repo, so teammates get it without re-indexing
Local-first, no data leaves your machine
Everything runs locally. The index is a SQLite file on disk. No telemetry by default (opt-in only, and even then it's just aggregate stats like token savings %). No code content is ever transmitted anywhere.
Try it
Install the VS Code extension: https://marketplace.visualstudio.com/items?itemName=Vexp.vex...
The free tier (Starter) gives you up to 2,000 nodes and 1 repo — enough for most side projects and small-to-medium codebases. Open your project, vexp indexes automatically, and your agent starts getting better context on the next task. No account, no API key, no setup.
Docs: https://vexp.dev/docs
I'd love to hear feedback, especially from people working on large codebases (50k+ lines) where context management is a real bottleneck. Happy to answer any questions about the architecture or the graph-RAG approach.

value: Show HN: Vexp – graph-RAG context engine, 65-70% fewer tokens for AI agents


value: Wise-Est-System

value: Show HN: Winstack-truthlock – a CLI to lint AI responses for unsupported facts

author: Wise-Est-System


value: Show HN: 3DIMLI – No-code storefront builder for digital products (beta)


value: ddmma

value: Show HN: Adaptive WebServer Protection- Qriton Shield

author: ddmma


value: noahwardlow

value: MuJoCo physics simulation in the browser using React.<p>This is made possible by DeepMind's mujoco-wasm (mujoco-js), which compiles MuJoCo to WebAssembly. We wrap it with React Three Fiber so you can load any MuJoCo model, step physics, and write controllers as React components, all running client-side in the browser

value: Show HN: MuJoCo React

author: noahwardlow

title: Show HN: MuJoCo React


value: CocoZozo

value:
LeetCode helps you practice coding problems.
SharpSkill helps you pass real technical interviews.
It’s a guided, stack-specific interview flow built for outcomes.

value: Show HN: SharpSkill – LeetCode Alternative to Optimize Success in Tech ITW

author: CocoZozo


value: splurk

value:
Apps are multiplying, and I see tons of threads of devs sharing their app and asking for feedback and getting no engagement. As an app dev, I need feedback, and one thing I can give in exchange is feedback for others.
So the idea here is simple: build in an incentive for builders to take a serious look at other builders' apps. On this site, if you give helpful reviews to other devs (determined by AI and upvotes), then your app rises higher on the list and gets seen by more other builders.
Since this is new and empty, I'm planning to personally give feedback to the first 10 apps posted.

value: Show HN: AppFeedBackScratch – Reciprocal Feedback for Indie Developers

author: splurk


value: Show HN: World Monitor App

title: Show HN: World Monitor App


value: spranab

value: Show HN: Saga – SQLite project tracker for AI coding agents

author: spranab


value: harshdoesdev

value:
Shuru is a lightweight sandbox that spins up Linux VMs on macOS using Apple's Virtualization.framework. Boots in about a second on Apple Silicon, and everything is ephemeral by default. There's a checkpoint system for when you do want to persist state, and sandboxes run without network access unless you explicitly allow it.
Single Rust binary, no dependencies.
Built it for sandboxing AI agent code execution, but it works well for anything where you need a disposable Linux environment.

value: Show HN: Local-First Linux MicroVMs for macOS

author: harshdoesdev