value: elananandhan

value:
Hi HN,
Instagram is the world’s largest mall, but for small boutiques in India, the "checkout" is broken. It usually involves a 20-minute DM conversation asking: "Is this in stock?", "What's the price?", and "Do you have my size?"
I built Trustd to give these sellers a structured Shop Page that works like a real e-commerce site but lives in their IG Bio.
The Problem:
Most IG sellers find Shopify too expensive or complex. They don't need a full CMS; they just need a way to show their catalog and build trust.
The Solution (Trustd Shop Page):
Trustd gives Instagram sellers a simple shop page to showcase their catalog and build trust, without the cost or complexity of a full ecommerce website.
Would love feedback, skepticism, or similar products you’ve seen.
Happy to answer questions.
Thanks,
Elan

value: Show HN: Link in Bio for Online Boutiques

author: elananandhan


value: rajish

value:
I got tired of Claude cutting me off mid-task with little or no warning
(when using opencode). Built a macOS menu bar app that shows exactly
where you stand.
Shows 5h and 7d headroom as a percentage with color-coded thresholds.
Burn rate arrows (→ ↗ ⬆) so you know if you're coasting or sprinting.
24h sparkline shows your usage sawtooth pattern. Notifications at 20%
and 5% before you hit the wall.
Reads your existing Claude Code OAuth credentials from Keychain (zero config).
Pure Swift, no dependencies, polls the quota API (not chat API, so no tokens wasted).
brew install rajish/tap/cc-hdrm
Coming next: full analytics window with historical charts and a breakdown
showing what you actually used vs. what the weekly limit blocked vs. what
you genuinely left on the table. Based on clever reverse engineering
carried out by she-llac in https://she-llac.com/claude-limits

value: Show HN: Cc-hdrm – See your Claude Pro/Max Headroom before you hit rate limits

author: rajish


value: wcamon

value: Show HN: Loader.land – dotfiles management for AI coding assistants

author: wcamon


value: Show HN: Stui – terminal UI for slurm clusters


value: Slydite

value:
I built a tool called Logic Mill that parses codebases with Tree-sitter to visualize and topologically sort functions and classes.
The core idea was an experiment: What if code files were ordered like mathematical proofs, where definitions always precede their usage?
Interactive Visuals
Visuals for Three.js and Preact.js are available on the blog (Open on Desktop - The graphs are heavy):
Logic Mill (the tool itself):
Symbols Graph: https://slydite.com/content/posts/toposort/codesorter/symbol...
Layered Sort: https://slydite.com/content/posts/toposort/codesorter/layere...
Global Sort: https://slydite.com/content/posts/toposort/codesorter/global...
GitHub: https://github.com/slydite/Logic-Mill

value: Show HN: Logic Mill – Visualizing and sorting codebases

author: Slydite


value: sylvain-h

value:
Hey HN,
Let me introduce "fault". A Rust-CLI to help engineers rapidly explore their reliability as close to the code as possible. Hopefully with a bit of fun while doing it.
Its features at glance:
- Native networking faults: latency, bandwidth, packet loss...
- Native support to change DNS or LLM responses
- OpenAPI scenario generator and runner with basic load test support builtin
- Easy command to inject itself into GCP, AWS or Kubernetes against a running application
- eBPF optional support for seamless interception
- LLM-based review of results with a system prompt leaning on SRE-analysis
- MCP server for AI-agents
- Fully Open Source and written in Rust
The premises are simple: a TCP proxying that you can configure to play on inbound and outbound streams.
For instance, injecting 300ms latency:

  $ fault run \
     --proxy "9090=127.0.0.1:7070" \
     --with-latency --latency-mean 300

Point your client to it and see how it behaves.
This is a small tool that is handy to have under your belt I believe. A bit of low-friction Chaos Engineering.
Would love to hear how you guys handle reliability so I know how to keep improving it.

value: Show HN: Fault – a Rust-CLI to inject network and application faults

author: sylvain-h


value: clementpiki

value:
Pikimov is a web-based motion design video editor that received a lot of positive feedback on HN when its first release came out in 2024.
I’m back with a major update (v5) that adds a "classic editor", similar to what you’d find in CapCut.
Reminder: it’s free, requires no sign-up, and avoids unnecessary AI features. Enjoy!

value: Show HN: I created an alternative to CapCut and After Effects: pikimov 5

author: clementpiki


value: fkorotkov

value:
Hey HN — Omni Cache is a sidecar daemon for CI caching. It exposes multiple cache protocols on a local endpoint while storing blobs in S3‑compatible storage.
Instead of funneling traffic through a centralized cache proxy, each job talks directly to S3, avoiding a shared bottleneck as workloads scale. No extra ingress/egress traffic bills.
What it supports:
- GitHub Actions cache v2 (used by Docker layer caching)
- Bazel HTTP remote cache
- Gradle build cache
- Xcode/LLVM compilation cache
- Custom HTTP clients
How it works:
- Run it next to your CI job/runner; HTTP + gRPC on one local address
- All built‑in protocols enabled by default
- S3‑backed (AWS or any S3‑compatible storage)
- Built‑in cache metrics endpoint and `omni-cache stats`
- LocalStack dev mode for quick testing
This has powered billions of caching operations for Cirrus Runners/CI since 2017.
Repo: https://github.com/cirruslabs/omni-cache
I’d love feedback on:
- Protocols you want next
- CI/networking gotchas I should document
- Metrics/observability you wish caches exposed

value: Show HN: Omni Cache – friendly sidecar for CI caching needs

author: fkorotkov


value: lincyang

value:
Hi HN,
I built a directory for AI roleplay characters: https://www.characteraibots.com
The problem: Character.AI and similar platforms have thousands of characters, but discovery is poor. Users spend hours browsing to find quality characters.
My solution: A curated directory with ratings, search, and filtering across multiple platforms (Character.AI, JanitorAI, SpicyChat).
Tech stack:
- Next.js 14 with SSR
- Dynamic sitemap generation
- SEO optimized (canonical URLs, OG images)
- Mobile responsive
Features:
- 50+ curated characters
- Search by name, type, tags
- Category browsing (Yandere, Tsundere, Vampire, etc.)
- Ratings and popularity rankings
- Multi-platform support
The site is completely free. I'm considering monetization through featured listings or API access.
Open to feedback and suggestions!

value: Show HN: Character AI Bots Directory – Curated AI Roleplay Characters

author: lincyang


value: joshuaisaact

value: Show HN: FizzBuzz Enterprise Edition 2026. AI-powered divisibility detection

author: joshuaisaact


value: Show HN: Stop decoding instructions. Use 588-Matrix coordinate substitution


value: deltadarkly

value: Show HN: Vercel for AI agents, one-click production deployment for any framework

author: deltadarkly


value: razuba

value:
Hi HN, We’re building security tooling around agentic AI systems.
Today, we're releasing our public MCP catalog with detailed risk analysis for every MCP server we've found on the internet: https://mcp.armor1.ai/mcp-directory
We all love agents and the power that MCPs unlock: suddenly your AI assistant can query databases, manage files, call APIs, and interact with the real world. But when we started adopting MCPs ourselves, we kept running into the same nagging questions:
Is this MCP safe? Where is my data actually going? Could it execute destructive actions? Is it susceptible to prompt injection? Can the LLM be tricked into calling something it shouldn't? And perhaps most concerning, can one MCP server influence the model and exfiltrate data meant for another?
We looked for answers and found... not much. No comprehensive catalog or standardized risk assessment. Nothing that gave us confidence before connecting an MCP to our agents.
So we built an MCP threat catalog and what we found was eye-opening.
We built what we believe is the deepest risk analysis pipeline for MCP servers:
• Provenance tracking: from an official source or community-contributed
• MCP spec conformance: does it follow the protocol correctly, or are there deviations that could cause unexpected behavior
• OWASP Top 10 for Agentic Apps: evaluate tool descriptions against the emerging threat categories specific to AI agents
• Static source analysis: analyze source code for AI-specific vulnerabilities, not just traditional ones
• CVE correlation: check dependencies against known vulnerabilities.
• Behavioral risk patterns: tool definitions that could enable prompt injection, privilege escalation, or cross-server data theft
What we found:
• Hundreds of credential leaks: API keys, tokens, and secrets exposed in server configurations and code.
• Dozens of MCP servers using known malicious packages: Not just vulnerable dependencies, but actually malicious ones.
• Tools attempting context poisoning: MCP servers designed to subvert the LLM and steal information via memory manipulation, potentially exfiltrating data meant for other connected servers.
We want everyone to realize the benefits of agentic AI, but not at the cost of security being an afterthought. So we're making this catalog free with no login, and we're committed to keeping it that way.
This is still a WIP. Looking forward to your feedback on what we need to improve, what we got right, and what we should prioritize next.

value: Show HN: Risk Analysis Database of Every MCP Server

author: razuba


value:
ClickLens is a modern, powerful, and user-friendly web interface for managing and monitoring ClickHouse databases. It provides a comprehensive suite of tools for developers, analysts, and administrators to interact with their ClickHouse clusters efficiently. ClickHouse is an incredible analytical database, but managing it via CLI or basic tools can be challenging. ClickLens bridges the gap by offering:<p>- Discover - Flexible, Kibana-like data exploration for any table
- SQL Console - Write, execute, and analyze queries with syntax highlighting and streaming results
- Real-time Monitoring - Keep an eye on your cluster's health, query performance, and resource usage
- Schema Explorer - Navigate databases, tables, columns, parts, and more
Access Control - Manage users and roles directly from the UI
- Native RBAC - Your UI permissions are derived directly from your ClickHouse grants

value: Show HN: ClickLens modern web UI for ClickHouse management


value: metzby

value:
INSTALL EXTENSION vsql-complex;
  CREATE TABLE t (val COMPLEX);
Look, MySQL is awesome [flamewar incoming?]. But the ecosystem has stagnated. Why?
No permissionless innovation. Postgres has flourished because people can change the core of the database (look at pgvector and pg_textsearch), without having to get their changes accepted upstream.
(This, btw, is what powered GitHub's early success: you can fork a repo and make changes without needing the owners' approval)
VillageSQL is a tracking fork of MySQL (open source, ofc) that adds an extension framework:
* Drop-in replacement
* Add custom data types and functions (with indexes coming soon)
* we wrote example extensions (vsql-ai, -uuid, crypto, etc.)
* you have a better idea for an extension
* my CEO submitted a Show HN post but linked to the announcement blog; help me show him hackers want code first
* I'm particularly proud of the friendly C++ API to add custom functions (in func_builder.h)
That link again is https://github.com/villagesql/villagesql-server
(Oh, and I get to work with the former TL of Google's BigTable and Colossus, so we care about doing databases Right)

value: Show HN: VillageSQL = MySQL and Extensions

author: metzby


value: Show HN: PipelineRL – Async RL with in-flight weight updates (train ~2× faster)


value: vkhafizov

value:
Hi HN,
I built an open-source system that reads raw engineering data and produces a structured engineering report stored in Notion.
It’s designed for engineering managers, team leads, and stakeholders who need a clear, up-to-date view of project status without constant syncs or manual status reporting. The goal is to reduce meetings and status overhead by synthesizing progress reports directly from development artifacts.
The system runs as a local MCP server and can be connected to any MCP-compatible agent (it works especially well with Claude Desktop).
Inputs:
– diffs and commits
– pull requests
– tasks / issues
– documentation
Flow:
– an MCP server exposes project data as tools
– an agent (e.g., Claude Desktop) requests a report
– the system synthesizes a structured engineering report
– the report is stored as a Notion page
– the report can later be queried for explanations and follow-up questions
Available as an npm package: npm install -g acture-mcp

value: Show HN: Acture MCP generates engineering reports from codebase and project data

author: vkhafizov


value: lexiathan

value: Benchmarks and technical details: https://lexiathan.com

value: Show HN: A spell-checker 380x faster than Hunspell, 5x faster than SymSpell

author: lexiathan


value: squeakycheese

value:
Hi HN! I'm launching Kvatch CLI v1.0.0-beta today — a tool that lets you query multiple data sources (Postgres, CSV, Google Sheets, APIs, etc.) as if they were a single SQL database.
Demo: https://github.com/kvatch-hub/kvatch-cli
Download: https://github.com/kvatch-hub/kvatch-cli/releases/tag/v1.0.0...
## Why I Built This
As a data engineer, I got tired of the "export-download-import-wrangle" dance every time I needed to join data from different sources. The usual workflow:
1. Export from Postgres
2. Download CSV from somewhere
3. Grab data from Google Sheets
4. Spend 3 hours in Python/Excel joining everything
5. Fix encoding issues
6. Realize you exported wrong columns
7. Repeat
It's 2026. This shouldn't be so hard.
## What It Does
Define data sources in YAML and query across them with standard SQL:
```yaml
connectors:
  - name: prod_db
    type: postgres
    connection: postgres://localhost/production<p><pre><code>  - name: sales_data
    type: csv
    connection: ./sales.csv
</code></pre>
datasets:
  - name: analysis
    query: |
      SELECT u.name, s.revenue
      FROM prod_db.users u
      LEFT JOIN sales_data s ON u.id = s.user_id
```
Run: `kvatch query --plan analysis.yaml`
Kvatch executes the query across sources and returns results — no exports, no intermediate files.
## Technical Approach
- Written in Go (single binary, ~12MB)
- Uses SQL federation (not ETL — queries sources directly)
- Local SQLite for caching/intermediate results
- Pluggable connector architecture
- Supports Postgres, MySQL, SQLite, CSV, JSON, Google Sheets, Git repos, REST APIs
Everything runs locally. Your data never leaves your machine.
## Current Status
Core engine is production-ready (tested with real datasets), but calling it "beta" because I want feedback before v1.0. Some UX polish still needed (diagnostics commands, better logging, etc.).
Supported platforms: macOS (Intel + Apple Silicon), Linux (x86_64 + ARM64), Windows.
## What's Next
Building a paid "remote mode" for teams: shared plans, scheduled queries, web UI, access control. Local mode will stay free forever.
## Try It
```bash
brew tap kvatch-hub/tap
brew install kvatch<p># Or download: <a href="https://github.com/kvatch-hub/kvatch-cli/releases" rel="nofollow">https://github.com/kvatch-hub/kvatch-cli/releases</a><p>kvatch init
kvatch query --plan examples/quickstart/plan.yaml
```
Examples: https://github.com/kvatch-hub/kvatch-cli/tree/main/examples
Happy to answer questions! Feedback very welcome.

value: Show HN: KvatchCLI – Query Multiple Data Sources with SQL(Postgres,CSV,APIs)

author: squeakycheese


value: Show HN: Lightweight browser based state machine simulator


value:
An open-source alternative to YouTube, perfect for anyone wanting to store videos or content creators looking to back up their content on their own platform.
Key features:
- Home Feed
- Video Player (With adaptive streaming)
- Interactions (Likes, Comments, Subscriptions)
- Creator Studio (Dashboard, Content Management, Channel Customization)
+ More soon
Tech Stack:
- Next.js 16
- Tailwind CSS v4
- Drizzle ORM (PostgreSQ)
- FFmpeg
- HLS.js
- Zustand

value: Show HN: OpenWatch – Open-source alternative to YouTube


value: guypod

value:
I'm Guy, the founder behind Snyk — now building Tessl, a package manager for agent skills.
We’ve recently witnessed that most teams still treat skills as static artifacts: markdown files, created or copied from repo to repo.
This approach offers a strong initial boost, but quickly creates debt:
- Skills are duplicated, and updates never roll out.
- Poor quality skills go unseen, misguiding agents instead of helping.
- Skill knowledge grows stale, and don’t keep up with the systems and practices they describe.
Without a way to evaluate skills, teams have no clear way to understand how good a skill actually is, or if it degraded over time.
Our belief is that evaluations are the foundation for having quality skills.
With that in mind, I’m glad to announce that Tessl Registry contains review evals for over 2,000 skills, and you can request an evaluation for any public skill.
Super excited to be launching this — keen to get your feedback, and looking forward to the many more enhancements in the queue!

value: Show HN: A package manager for agent skills with built-in evals

author: guypod


value: DeepBrainz

value:
Hi HN,
I’m releasing DeepBrainz-R1 — a family of reasoning-first Small Language Models (SLMs) designed for agentic systems in production.
The core idea is simple: agentic systems don’t ask once — they reason repeatedly (tool calls, verification loops, retries, schema-constrained outputs). That changes reliability and cost requirements, where large chat-optimized LLMs often struggle.
DeepBrainz-R1 models are post-trained to improve multi-step reasoning behavior, output stability, and robustness under agentic workloads. The focus is not chat or creative writing, but predictable reasoning at small parameter sizes.
Models:
- R1-4B (flagship)
- R1-2B (lower latency / cost)
- R1-0.6B-v2 (small, local / edge agents)
- Experimental long-context variants (16K / 40K)
Everything is open (Apache-2.0). Community-maintained quantizations (GGUF, low-bit) are already appearing.
I’d love feedback from people building agents, tool-using systems, or long-running reasoning pipelines.
HF org: https://huggingface.co/DeepBrainz

value: Show HN: DeepBrainz-R1 – Reasoning-First Small Models for Agentic Systems

author: DeepBrainz


value: Codegres

value: Show HN: MS Paint for Android

author: Codegres

title: Show HN: MS Paint for Android


value: rbshamsu

value: Show HN: Simple, Fast, Accessible Fine-tuning

author: rbshamsu


value: Show HN: Remove Background for Android

title: Show HN: Remove Background for Android


value: Show HN: How I built Live View for browsers running in Docker


value: wheeleeo

value: Show HN: I replaced QuickBooks with an MCP server running inside Claude

author: wheeleeo


value: antves

value:
Hi HN! Smooth CLI (https://www.smooth.sh) is a browser that agents like Claude Code can use to navigate the web reliably, quickly, and affordably. It lets agents specify tasks using natural language, hiding UI complexity, and allowing them to focus on higher-level intents to carry out complex web tasks. It can also use your IP address while running browsers in the cloud, which helps a lot with roadblocks like captchas (https://docs.smooth.sh/features/use-my-ip).
Here’s a demo: https://www.youtube.com/watch?v=62jthcU705k  Docs start at https://docs.smooth.sh.
Agents like Claude Code, etc are amazing but mostly restrained to the CLI, while a ton of valuable work needs a browser. This is a fundamental limitation to what these agents can do.
So far, attempts to add browsers to these agents (Claude’s built-in --chrome, Playwright MCP, agent-browser, etc.) all have interfaces that are unnatural for browsing. They expose hundreds of tools - e.g. click, type, select, etc - and the action space is too complex. (For an example, see the low-level details listed at https://github.com/vercel-labs/agent-browser). Also, they don’t handle the billion edge cases of the internet like iframes nested in iframes nested in shadow-doms and so on. The internet is super messy! Tools that rely on the accessibility tree, in particular, unfortunately do not work for a lot of websites.
We believe that these tools are at the wrong level of abstraction: they make the agent focus on UI details instead of the task to be accomplished.
Using a giant general-purpose model like Opus to click on buttons and fill out forms ends up being slow and expensive. The context window gets bogged down with details like clicks and keystrokes, and the model has to figure out how to do browser navigation each time. A smaller model in a system specifically designed for browsing can actually do this much better and at a fraction of the cost and latency.
Security matters too - probably more than people realize. When you run an agent on the web, you should treat it like an untrusted actor. It should access the web using a sandboxed machine and have minimal permissions by default. Virtual browsers are the perfect environment for that. There’s a good write up by Paul Kinlan that explains this very well (see https://aifoc.us/the-browser-is-the-sandbox and https://news.ycombinator.com/item?id=46762150). Browsers were built to interact with untrusted software safely. They’re an isolation boundary that already works.
Smooth CLI is a browser designed for agents based on what they’re good at. We expose a higher-level interface to let the agent think in terms of goals and tasks, not low-level details.
For example, instead of this:

  click(x=342, y=128)
  type("search query")
  click(x=401, y=130)
  scroll(down=500)
  click(x=220, y=340)
  ...50 more steps

Your agent just says:

  Search for flights from NYC to LA and find the cheapest option

Agents like Claude Code can use the Smooth CLI to extract hard-to-reach data, fill-in forms, download files, interact with dynamic content, handle authentication, vibe-test apps, and a lot more.
Smooth enables agents to launch as many browsers and tasks as they want, autonomously, and on-demand. If the agent is carrying out work on someone’s behalf, the agent’s browser presents itself to the web as a device on the user’s network. The need for this feature may diminish over time, but for now it’s a necessary primitive. To support this, Smooth offers a “self” proxy that creates a secure tunnel and routes all browser traffic through your machine’s IP address (https://docs.smooth.sh/features/use-my-ip). This is one of our favorite features because it makes the agent look like it’s running on your machine, while keeping all the benefits of running in the cloud.
We also take away as much security responsibility from the agent as possible. The agent should not be aware of authentication details or be responsible for handling malicious behavior such as prompt injections. While some security responsibility will always remain with the agent, the browser should minimize this burden as much as possible.
We’re biased of course, but in our tests, running Claude with Smooth CLI has been 20x faster and 5x cheaper than Claude Code with the --chrome flag (https://www.smooth.sh/images/comparison.gif). Happy to explain further how we’ve tested this and to answer any questions about it!
Instructions to install: https://docs.smooth.sh/cli. Plans and pricing: https://docs.smooth.sh/pricing.
It’s free to try, and we'd love to get feedback/ideas if you give it a go :)
We’d love to hear what you think, especially if you’ve tried using browsers with AI agents. Happy to answer questions, dig into tradeoffs, or explain any part of the design and implementation!

value: Show HN: Smooth CLI – Token-efficient browser for AI agents

author: antves


value: nkalupahana

value: Show HN: Proximity Voice Chat in VS Code

author: nkalupahana


value: tarekclarke

value:
I spent some time building a prototype to handle schema drift in high velocity data. It is called the Resilient RAP Framework and it uses semantic embeddings to fix broken data streams on the fly.
I tested it by feeding it F1 telemetry and then switching to clinical ICU data to see if it could map different fields without manual help. It successfully mapped drift across domains, like matching kph to km/h in racing data and resolving pulse oximetry to oxygen saturation in a health context.
The repo hit about 600 clones on GitHub this week. I'm interested to see if anyone else is using agentic recovery for ingestion or if there are better ways to handle this at scale.

value: Show HN: Resilient RAP – A self-healing pipeline for telemetry using embeddings

author: tarekclarke


value: asciimoo

value:
I'm working on a self-hosted search service called Hister with the goal to reduce my dependence on online search engines.
Hister is basically a full text indexer for websites which saves all the visited pages rendered by your browser. It provides a flexible web (and terminal) search interface & query language to explore previously visited content with ease or quickly fall back to traditional search engines.
I've been using it for more than a month now and as my local index is growing I can avoid opening google/duckduckgo more and more frequently.
The project is still heavily under development with constant fine-tuning, but the current version is in a fairly usable state in my opinion, so I wanted to share it here - perhaps some of you find it useful as well. (Or at least have some constructive criticism =])
The code is AGPLv3 licensed, available at https://github.com/asciimoo/hister

value: Show HN: Hister – fast, content-based search for visited websites

author: asciimoo


value: alvarogar

value:
Hey HN, I am Álvaro and I am working on ObsessionDB, a managed ClickHouse infra as a service. We run CH at about 100B rows scale and we spent the last few years learning what works and what doesn't at that scale.
These are open-source skills that teach Claude Code, Cursor, or any agent the ClickHouse patterns that matter.
The problem is that AI agents write syntactically correct ClickHouse SQL, but they don't know your query patterns. They'll suggest `ORDER BY (timestamp, user_id)` because that's what most examples online show. Any ClickHouse dev knows to put your filter column first, but the agent doesn't. Every conversation starts fresh.
I got tired of reviewing the same issues. The agent isn't stupid, it's just uninformed. So I wrote down what I'd tell a new engineer: ORDER BY column selection, why PREWHERE matters, when to use LowCardinality, partition strategies, materialized view gotchas.
Three skills so far:
- Schema Design - ORDER BY selection, partitioning, engine choice
- Query Optimization - PREWHERE, column selection, join strategies
- Materialized Views - Aggregation patterns, refresh timing
Each pattern has a priority (CRITICAL/HIGH/MEDIUM) so the agent knows what to check first.
npx skills add obsessiondb/clickhouse-skills
Curious what patterns I'm missing or what other devs have experienced. What ClickHouse lessons should your agent know?

value: Show HN: Open-source ClickHouse skills – SQL craft course for your agent

author: alvarogar


value: keepamovin

value: Show HN: Hacker News Discussion Clusters

author: keepamovin


value: nekocode

value: Show HN: Agent-worktree – A Git worktree workflow tool for AI coding agents

author: nekocode


value: clastiche

value:
Releasing our MCP server that connects AI agents to TabPFN, a foundation model for tabular ML. Beta is open now.
If you're building agents that work with tabular data (sales pipelines, customer data, inventory, financial records) you've probably hit this: agents spend tokens generating ML code that doesn't work, or produce unreliable results.
TabPFN MCP gives LLMs 2 tools: fit_and_predict (fits a model and runs predictions) and predict (uses a previously fitted model). Your agents don't need to impute missing data, encode categorical features, or preprocess messy tables as TabPFN handles it natively.
Available on ChatGPT, Claude, n8n and other major LLMs. Uses streamable HTTP for broad compatibility.
Keeping the beta small to work closely with early users. If you're shipping with structured data, join here: https://priorlabs.ai/deployment/model-context-protocol
Disclosure: I work at Prior Labs.

value: Show HN: TabPFN MCP, gives LLMs tools for predictions on tabular data (beta)

author: clastiche


value: mayankchhabra

value: Show HN: Umbrel Pro – 4x NVMe SSD home server (CNC aluminum and walnut)

author: mayankchhabra


value: ClassicOldSong

value: AirBeam lets you control an external display with an air mouse or touchpad. You can long-press the floating button to move the app currently shown on your phone to the external screen with one tap. Even better, AirBeam includes exclusive support for displaying while the phone is locked.

value: Show HN: Android Air mouse for screen casting

author: ClassicOldSong


value: whothatcodeguy

value: Show HN: A browser-based, animation-first pixel editor with a proper timeline

author: whothatcodeguy


value: juansgaitan

value:
I built Relay because existing messaging systems assume humans and legacy email constraints (SMTP, MIME, read flags, inbox polling).
Relay is an HTTP-native messaging server for AI agents. Agents create accounts, get stable addresses (e.g., a8f3k@getrelay.sh), and exchange structured messages in threads using pure JSON over HTTPS.
The API is fully HATEOAS-driven: an agent starts at GET / and discovers all actions via _links. No SDKs, no hardcoded URLs, no external docs required.
Other design choices:
– delta sync via state tokens instead of read/unread flags
– row-level security returning 404s for non-participants
– tokens stored hashed only
– content supports both human-readable markdown and machine payloads
This is early but complete enough to run locally or deploy behind Cloudflare Tunnel. I’m especially interested in feedback on the HATEOAS approach and whether this matches how people are actually wiring agent-to-agent workflows today.

value: Show HN: Messaging for AI agents without SMTP, MIME, or polling inboxes

author: juansgaitan


value:
Hey HN — I built this because I switch between Claude, ChatGPT, Gemini, and Perplexity constantly and got tired of re-explaining context every time.
It's a Chrome extension that captures conversations and transfers them between platforms with one click. Everything stays in IndexedDB, no external servers.
Chrome Web Store if you want to try it: https://chromewebstore.google.com/detail/relai/inkojohbljaag...
Known limitations: long conversations can lose formatting, and platform DOM changes will break extractors until I patch them. Built with vanilla JS, no frameworks, no build step.
Happy to answer questions about the implementation.

value: Show HN: Relai – Share context between AI assistants, 100% local


value: hyperwindmill

value: Show HN: MorphQL - Improving My Data Transformations

author: hyperwindmill


value: gauravsc

value: Show HN: Turn messy financial spreadsheets into structured data

author: gauravsc


value:
Hi HN,
I spent the last 14 months pairing with my own AI agent for everything from coding to life admin (1,000+ logged sessions).
I got tired of the "Subscription Cycle" (paying $20/mo for a wrapper that forgets context next week), so I built a sovereign framework: "Project Athena".
It is a local-first system that lets you build an AI agent with persistent memory, protocols, and knowledge graphs that live on your machine, not in a siloed cloud account.
*Key Features:*
- *Local-First Memory*: Markdown files + local vector store. You own the data.
- *Protocol Library*: 69+ decision frameworks (e.g. "Law of Ruin") that the agent follows.
- *GraphRAG Integration*: Uses GraphRAG to detect communities/patterns in your notes (for about $0.50/run via Gemini).
- *Trilateral Feedback*: Can cross-check decisions against multiple models (Claude, Gemini, GPT) automatically.
*Why I built it:*
I wanted an "Exocortex" – a second brain that grows with me. Most agents are "Stateless Servants" (they do a task and reset). Athena is stateful. It remembers that I prefer TDD, that I hate Tailwind, and that I'm optimizing for low-latency.
It’s open source (MIT). The repo is a "Reference Implementation" – a starter pack you can fork to build your own personal OS.
Repo and Docs in the link!

value: Show HN: Athena – A sovereign, local-first AI agent framework (anti-subscription


value: Jeffallan

value: Show HN: Claude Skills. Try vibe engineering instead of vibe coding

author: Jeffallan


value: ykdojo

value: Show HN: SafeClaw – a way to manage multiple Claude Code instances in containers

author: ykdojo


value: Show HN: Web Customizer – CSS injection for customizing any website


value: itaibo

value: Show HN: BackRepo – Off-site GitHub backups with client-side encryption

author: itaibo


value: vandyand

value:
I kept having "I wish there was..." moments --ideas for tools or apps I wanted but couldn't find. I figured other people probably did too, and somewhere out there a developer was looking for exactly that kind of signal. So I built a site to connect the two.
iwishtherewas.xyz is a community board where you post wishes for products or apps you want to exist. Each wish includes what you'd be willing to pay (or if you want it free). Other people upvote, leave comments, and can flag existing solutions that already solve the problem. Builders can browse wishes sorted by votes or discussion to find real demand.
You can post anonymously or sign in for a profile with an avatar. There's full-text search, threaded comments, and upvoting. Stack is Next.js 16, React 19, Supabase on the backend, Tailwind 4, deployed on Vercel.
It's early and the content is still thin, but I'd love for people to try posting wishes and see if it's useful. Feedback on the idea and execution is very welcome.
https://iwishtherewas.xyz

value: Show HN: I Wish There Was a place to post product wishes

author: vandyand


value: wiwoworld

value:
Hey HN,
I built Moltplace (https://www.moltplace.net) – a marketplace where AI agents register, offer services, hire each other, and trade autonomously using tokens.
How it works:
- You give your AI agent a single skill file (.md) and it registers itself on the network
- Agents list services (code review, research, writing, etc.) and set prices in tokens
- When an agent needs help, it posts a job – other agents pick it up, do the work, chat about it, and get paid
- All agent conversations are public – you can watch two agents negotiate and collaborate in real time on the live feed
- Humans can post jobs too. Agents compete to pick them up
On top: Skill Marketplace + Security Stack
Agents and humans can now publish, buy, and trade skill files on the marketplace. These are reusable .md files – prompts, workflows, checklists, techniques – that other agents can download and use. Free skills build reputation; paid skills earn passive token income.
But open marketplaces attract bad actors.
So I've built a 6-layer defense system:
1. Automated moderation – prompt injection patterns, URL scanning, credential proximity detection
2. Security banners – injected into all skill content, warning agents about attack vectors
3. Community skill verification – 3 reviewers stake tokens to verify skills.
4. Structured jobs – verifiable tasks referencing only verified skills (no external code)
5. Sybil-resistant verifier selection – system picks verifiers, excludes recent contacts, tracks interaction graphs
6. Content reporting – agents flag suspicious content, feedback loop for improving filters
The result: verifiable compute coordination without arbitrary code execution.
Every agent starts with 1,000 tokens. The economy runs on completed work: you earn by doing jobs and selling skills, you spend by hiring others and buying skills.
Technical details:
- REST API + WebSocket (no SDK required, just curl)
- Registration takes one API call – agent gets API key and claim URL
- Token transfers are atomic (PostgreSQL transactions)
- Skill verification uses staked consensus – reviewers have skin in the game
- All interactions public and visible on the dashboard
Stack: Next.js, Express, PostgreSQL, Redis.
I'm curious what HN thinks about agent-to-agent economies and the security challenges. Is this useful infrastructure?

value: Show HN: Moltplace – The place where AI agents hire each other and trade skills

author: wiwoworld


value: serious-sam

value: Show HN: Pinggy – A nanoblogging app where you can only post one word

author: serious-sam


value:
- I like tools like Conductor, but on my machine the Electron apps end up feeling slow/buggy for long sessions (input lag, rendering glitches, high overhead). I wanted the same “workspace + worktrees + terminals + diff” workflow, but as a native terminal app that stays snappy.
- Workforest is a Rust TUI that treats each workspace as a git repo and lists its worktrees; you can create/remove worktrees, switch the center pane by selecting a worktree, and open multiple terminal tabs per worktree. The embedded terminal uses the Alacritty terminal engine crate (so it’s a real emulator, not a toy). Diff is shown on the right, and you can optionally launch gitui.
- It’s also wired so if Codex TUI / Claude Code emits a bell on “done” or “needs input”, Workforest badges the terminal tab with ● and shows a toast. There’s a workforest setup-harness command to update the user-scoped configs for both.
- Install:
    - cargo install --git https://github.com/nikhilshinday/workforest --locked --bin workforest
    - Optional: install gitui for the diff hotkey.
Feedback welcome—especially on UX around worktree naming, repo discovery, and what you’d want in the diff panel.

value: Show HN: Workforest – a fast, clickable TUI for Git worktrees (no Electron)


value: mrbeep

value:
I built a Telegram CLI that's pure Rust with zero C/C++ dependencies. No TDLib, no OpenSSL — just `cargo build` and you're done.
Features:
- Incremental sync with checkpoints (fast subsequent syncs)
- Full-text search via FTS5 (local) + global Telegram API search
- Send messages, files, voice notes, stickers, polls
- Manage chats, folders, contacts, reactions
- Admin commands for groups (ban/kick/promote)
- Human-readable tables or --json output
Particularly useful for LLM agents (OpenClaw, etc.) — there's a SKILL.md in the repo with all commands documented for AI consumption. Agents can sync, search, and send messages programmatically.
Install:
  brew tap dgrr/tgcli
  brew install tgcli
Or: cargo install tgcli

value: Show HN: Tgcli – Telegram CLI in Pure Rust (No TDLib)

author: mrbeep


value: eismcc

value:
Hello HN!
I had some free time so I have been upgrading KlongPy.
KlongPy now supports PyTorch as a backend and autograd over the array language.
A while back someone on HN thought it would be cool to have Klong support autograd and I also thought that would be cool.
There's a lot of examples in https://github.com/briangu/klongpy/tree/main/examples/autogr...
but here's a taste:
f::{x^2}         :" Define f(x) = x^2
f:>3             :" Compute f'(3) = 6.0
Looking for feedback on new operators and any obvious gaps.  Thanks!
updated github pages: https://klongpy.org
repo: https://github.com/briangu/klongpy

value: Show HN: KlongPy array language now supports autograd

author: eismcc


value: I built a Rust library for reliable webhook delivery so startups don’t have to build the full infra or rely on SaaS. It includes fair scheduling, retries + jitter, DLQ, HMAC signing, rate limits, and optional Redis/Postgres durability. Would love feedback from folks who’ve built webhook systems.

value: Show HN: Webhook Dispatcher – webhook infra in a Rust crate


value: akshaysg

value:
Hi HN! We’re launching Haystack Review, a chat-based tool for reviewing pull requests.
Instead of starting from diffs and reconstructing the author’s intention and decisions from scratch, reviewers can ask questions like:
1. Can you compare the user experience before and after the PR?
2. Is this a general refactor, or a one-off change?
3. What changes led up to this one?
4. Which tests cover the new behavior? What’s untested?
and Haystack agent answers with receipts (links to the relevant diffs/lines that someone can navigate to).
Here’s a quick demo: https://youtu.be/cE1A0F0NjTc. If you’d like to give it a spin, head over to haystackeditor.com/review! We set up some demo PRs that you should be able to understand and review even if you’ve never seen the repos before!
One detail we’re excited about: Haystack chats are shareable via link, so context doesn’t need to be re-derived for each reviewer or the author. You can send a chat to the author and have them jump directly into the same conversation!
Why we built this
We think code is losing relevance.
Engineers increasingly:
1. Don’t need to write code (agents can do that)
2. Don’t need to read code either (because agents now follow instructions DECENTLY well)
The hardest part of the review is translating the author’s intent into your own mental model (spotting bugs is also hard, but humans suck at it!). That translation is cognitively expensive, slow, and error-prone.
LLMs are surprisingly good at doing this translation quickly. Even if they’re imperfect, they fast-forward reviewers to what actually matters:
1. knowledge transfer
2. architectural alignment
3. applying tribal knowledge to improve the change
Haystack uses this to compress the information hidden in the diffs (and related artifacts like previous PRs, Slack conversations, tickets, UI, etc.) so humans can understand and exercise judgment quickly.
We’re also interested in prompt traces and agent plans (and plan to make it so Haystack can easily reference them), but “decompiling” code back into natural language is still useful because it evaluates the actual output, not just the original intent.
This is even useful as an author! I often use Haystack to sanity-check whether an agent drifted from my instructions or deviated from the plan I had in mind.
We would love feedback, especially skepticism. Thanks for reading!

value: Show HN: Haystack Review – Have a conversation with your pull request

author: akshaysg


value:
We’re a team of two building Valiant after too many incidents where “something changed” but nobody could tell what actually caused production issues.
Valiant correlates intent (Git commits, CI/CD signals) with actual execution (Kubernetes rollouts) and links them to Prometheus metrics, so you can see the real impact of each change - not just what was deployed.
It’s open-source, still under active development, and very much a work in progress. Feedback, ideas, or contributors are welcome.
No website yet — just the GitHub repo ;)

value: Show HN: Why it's hard to know which deployment caused a production incident


value: Show HN: LobsterLair – Managed hosting for OpenClaw AI agents


value: brockmeier

value:
Built this because typing long prompts to Claude Code got tedious. VoxPaste records audio and transcribes via your choice of provider—Mistral, Groq, OpenAI, or Deepgram—then copies directly to clipboard.
Unlike single-provider tools, you can pick the fastest option for your needs. Mistral and Groq deliver fastest. Bind it to a hotkey and invoke from anywhere.
Audio goes directly to your chosen provider.
https://github.com/felixbrock/voxpaste

value: Show HN: VoxPaste – Fast voice-to-text CLI for dictating to Claude/Cursor

author: brockmeier


value: harshitshah

value: Show HN: PyDesigner – Visual GUI Builder for Tkinter, PyQt5, and CustomTkinter

author: harshitshah


value: phunterlau

value:
# Show HN: AgentVM – Safe, Sandboxed Linux VM for OpenClaw & AI Agents
Hi HN,
We built AgentVM (WASM + Alpine Linux) because Docker is too heavy for per-session AI agents, and `exec()` by an OpenClaw agent on the host is too dangerous.
It runs a full Alpine Linux VM inside a Node.js Worker Thread. It boots in milliseconds, is completely isolated, and supports Python, networking, and standard Linux commands out of the box, perfect for local AI agents like OpenClaw and others.
Website: [https://agentvm.deepclause.ai/]
Repo: [https://github.com/deepclause/agentvm]
Core Value
* Instant Boot: No container orchestration delay.
* Sandboxed: Runs in a worker thread. If it crashes or gets malicious, your host is safe.
* Full Environment: Real Linux userspace. Install packages, run Python scripts, grep files.
* Agent Ready: Drop-in integration for *OpenClaw* and Vercel AI SDK.
Why we are sharing this:
We want this to be the standard "execution unit" for local AI agents.
We need your feedback on:
1.  The security model (WASM/Worker isolation).
2.  API ergonomics for your agent frameworks.
PRs and issues are very welcome! We'd love to see what you build with it.

value: Show HN: AgentVM – Safe, Sandboxed Linux VM for OpenClaw and AI Agents

author: phunterlau


value: AquiGorka

value: Show HN: Track vim cmd and mapping usage, and detect typos to optimize vimrc

author: AquiGorka


value: camcamcam

value:
This is not an ai-agent virtual vibe coding ecosystem. It's an organizational pattern that helps me mentally keep track of my projects and their infrastructure. Servers are barns, deployed repositories are livestock, system services are critters, herds are environments. The running process itself acts as an MCP server for Claude Code sessions providing this information to sessions based on the context.
I have been working on this tool for a few weeks now, both developing on it and from within it. It's a central place for me to keep track of my projects, servers I run code on, and what is running on what server. It also helps me run multiple instances of Claude Code in an organized way.
I'm a fan of working in my terminal, and I love using Claude Code. This tool mentally helps me keep track of various issues and tasks I'm working on. It's built on top of Tmux so it can be detached and remain running in the background. I have some fun ideas in the future to bring in more automation in a structured way to help extend dev processes even further.
The code is open source. If you find it useful or interesting I'm curious to know your thoughts or suggestions. There are more features as well that are sort of half-built, like syncing environments based on IaC tools, issue tracking with github/linear, a project wiki feature, visualizer, and more.
Let me know what you think!

value: Show HN: Yeehaw – Infrastructure as Farm

author: camcamcam


value:
Hey HN!
Recently, I was going back to rendering HTML on the server, like good ol' 90s. In my opinion, one of the best things React brought us was JSX. The ability to write transpile-time type-safe templates with TSX is incredible.
But emails always were a pain in the ass. Luckily, mjml solved it long time ago. But mjml is just markup, you still need templating on top of it. Handlebars is a good solution, but then you need to compile mjml, compile handlebars, and keep the template types in-sync with the application types.
With the help of Claude Code, I have built a custom JSX runtime for generating mjml strings. Sure, react.email and mjml-react exist, but these depend on react and react-dom for no reason.
So if you, like me, love JSX/TSX, and mjml, and want to write type-safe emails without dragging react as a dependency, check out my repo[0], give it a star, and feedback!
Cheers!
[0] https://github.com/skwee357/mjmx

value: Show HN: Mjmx – JSX Runtime for Mjml

title: Show HN: Mjmx – JSX Runtime for Mjml


value: alphara

value: HyperAgency replaces brittle/fragmented automations with long-lived, self-improving systems. Open-source, self-host & cloud, omni-channel, decentralized, extensible.

value: Show HN: HyperAgency (H9y.ai) – Open-Source Agentic AI Operating System

author: alphara


value: waltergalvao

value:
Hey folks,
today we at Currents are releasing a brand new AI skill to help AI agents be really smart when writing tests, debugging them, or anything Playwright-related really.
This is a very comprehensive skill, covering everyday topics like fixing flakiness, authentication, or writing fixtures... to more niche topics like testing Electron apps, PWAs, iFrames and so forth. It should make your agent much better at writing, debugging and maintaining Playwright code.
for whoever didn't learn about skills yet, it's a new powerful feature that allows you to make the AI agents in your editor/cli (Cursor, Claude, Antigravity, etc) experts in some domain and better at performing specific tasks. (See https://agentskills.io/home)
You can install it by running: npx skills add https://github.com/currents-dev/playwright-best-practices-sk...
The skill is open-source and available under MIT license at https://github.com/currents-dev/playwright-best-practices-sk... -> check out the repo for full documentation and understanding of what it covers.
We're eager to hear community feedback and improve it :)
Thanks!

value: Show HN: Playwright Best Practices AI SKill

author: waltergalvao


value: Nexus is AI monitoring that automates understanding how your AI agents behave in prod. It catches when your AI agents silently fails in production and automates filtering, root-causing, and taking the first pass action to minimize user impact and save you time. Check it out

value: Show HN: Nexus-Monitoring that automates understanding your agent's behavior


value:
If you're a non-technical founder, you probably have no idea what your developers did last week. You ask, they say "refactored the auth module" and you nod pretending you understand.
Gitmore reads your GitHub activity and turns it into a simple report: what was built, what was fixed, what's stuck. Written for humans, not engineers.
It shows up in your inbox. You read it in 2 minutes. Done.
Here's what a report looks like: https://www.gitmore.io/example.html
Quick demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po
Free tier available. Happy to hear what you'd want from something like this.

value: Show HN: Ask your AI what your devs shipped this week


value:
I built agentrial because I was tired of the "it works... sometimes" problem with AI agents.
Existing eval tools treat agents like deterministic functions: run once, check output, done. But agents aren't deterministic - same input, different tool calls, different outputs.
agentrial runs every test N times (default 10) and gives you:
- Pass rate with Wilson confidence intervals (not "72%" but "72%, CI 55-84%")
- Step-level failure attribution (which exact step diverged between success/fail runs)
- Real cost tracking from API metadata
- GitHub Action for CI/CD
Tested with Claude 3 Haiku on a 3-tool LangGraph agent: 100 trials, $0.06 total, full trajectory capture.
pip install agentrial
Open source, MIT. LangGraph supported, CrewAI/AutoGen coming next.

value: Show HN: Agentrial – pytest for AI agents with statistical rigor


value: nicolodaddabbo

value:
We’ve been experimenting with a more controllable way of prompting, which led us to build Nudge - a better way to write type-safe prompts for TypeScript AI applications.
Nudge lets you define prompts via a TypeScript builder API, then uses a CLI tool to generate the final system prompts. You describe intent structurally, not by tweaking wording, caps, or repetition. Instructions can be “nudged” with a numeric strength instead.
Prompts support:
- type-safe variables
- optional blocks toggled at runtime
- multiple variants for A/B testing
Because prompts are structured, parts are easy to reuse across agents. Prompts can also be tested and iteratively improved using an LLM based on failing test cases.
This is a project Joshua Knauber and I have been working on - would love feedback.

value: Show HN: Nudge – A type-safe prompt builder with CLI codegen for AI apps

author: nicolodaddabbo


value: Jeaye

value: Show HN: Glitchlings, Enemies for Your LLM

author: Jeaye


value: hval

value:
I recently saw a post from the Vercel CEO pointing out that LLMs understand websites much better when they can request:
`Accept: text/markdown`
Most websites today are built for humans. When AI agents try to consume them, they get complex HTML instead of clean, structured content.
So I built *accept-md* – a simple open-source package for Next.js that helps solve this.
Getting started is intentionally minimal:
```
npx accept-md init
```
After that, your existing Next.js routes can automatically respond with Markdown whenever an AI agent (or any client) requests it. No redesigns, no CMS changes, and no duplicate pages to maintain.
Right now the project is:
* Focused only on Next.js
* Middleware-based and lightweight
* Designed to work with existing apps
* A small step toward more AI-friendly websites
This is an early experiment, but I think the idea itself matters as AI agents become first-class consumers of the web.
I’ve open-sourced it and would love help with:
* Better markdown extraction
* Edge cases across Next.js setups
* Performance and caching
* Tests and examples
* Documentation
* Eventually adapters for other frameworks
Would love feedback from the HN community on the approach – and whether `Accept: text/markdown` feels like a pattern worth standardizing for the AI-native web.

value: Show HN: Accept-md – One command to make Next.js sites LLM-scraping friendly

author: hval


value: akadhanu

value:
I built Guro as a lightweight, cross-platform CLI tool for system monitoring and basic benchmarking in Python.
It focuses on a clean, script-friendly interface with real-time CPU, memory, thermal, and (where available) GPU metrics. Installation is via pip, and it runs on Linux, macOS, and Windows.
This started as a personal tool to better understand system behavior during development and testing. I’m sharing it openly and would appreciate feedback from folks who use similar tooling or care about observability from the terminal. And hit a star, if you found this useful

value: Show HN: Guro – Python CLI system monitoring, benchmarking and telemetry tool

author: akadhanu


value: mikeyfrilot

value:
I've been working on this for a while and finally got it to a point where I'm comfortable sharing it.
Registrum is a state registrar that validates transitions against structural invariants. The interesting bit isn't the validation logic—it's the governance model around releases.
This latest release (v0.1.0) focused entirely on packaging integrity: single version source, explicit checksum vs hash semantics, documented tooling assumptions. No runtime changes at all.
The motivation: I kept running into situations where packaging ambiguity caused trust issues downstream—mismatched versions, unclear hash guarantees, undocumented assumptions. So I decided to treat packaging as part of the system's integrity surface rather than an afterthought.
Happy to answer questions about the dual-witness architecture (two independent invariant engines that must agree) or the governance model.

value: Show HN: Registrum – A structural registrar with enforceable release invariants

author: mikeyfrilot


value:
I built VectorGuard-Nano, a lightweight secure messaging plugin for AI agents.
With MCP and agent frameworks exploding, agents need a way to communicate securely. This is MIT-licensed, HMAC-based obfuscation for casual agent messaging (Moltbook, Slack, IPFS, etc).
Features:
- Deterministic encode/decode with shared secrets
- Built-in timestamp handling
- Zero dependencies (just Node crypto)
- OpenClaw integration ready
- Round-trip guaranteed
This is the "nano" version to show the concept. I'm also developing full VectorGuard with model-bound cryptography that solves the recently published Whisper Leak vulnerability.
GitHub: https://github.com/Active-IQ/VectorGuard-Nano
More info: https://www.active-iq.com
Happy to answer questions!

value: Show HN: VectorGuard-Nano – Free secure messaging for AI agents


value: alexsherrick

value: Show HN: Base.recipes – Version control for your recipes

author: alexsherrick


value: anthonymu

value: Show HN: ARIA Protocol – P2P distributed 1-bit LLM inference at 120 tok/s on CPU

author: anthonymu


value:
We built ate because AI agents keep forgetting everything between sessions. RAG retrieves documents, but agents need to remember what they learned — decisions, preferences, context.
ate stores thousands of memories in a single .mv2 file (~2MB for 10K memories). It's encrypted (AES-256), works offline, and agents can carry their memory file anywhere.
Key features:
- Multi-agent concurrent access (MVCC, no locks)
- Memory Capsules for sharing context between agents
- Trains of thought for reasoning chains
- Works with CrewAI, LangChain, and Agno (PRs open)
Install: pip install ate-memory
Try: ate memory init my-agent && ate memory add my-agent --text "first memory"
We're using it to give our own agents persistent memory. Would love feedback from anyone building multi-agent systems.

value: Show HN: Ate – Portable dense memory for AI agents (.mv2 format)


value: tudalv

value:
Hi HN,
Firs HN post here. I’ve been reading and following HN for years, so I’m really curious to hear feedback from you :)
API Unit started out of frustration, not as a startup idea.
In several projects, our APIs were no longer simple request-response endpoints. A single business flow meant multiple dependent calls, shared state, conditional logic, retries, and different outcomes depending on responses.
At first, we handled this with Postman collections. That worked… for a while.
Then collections grew, scripts multiplied, monitors became detached from the actual test logic, and it became hard to answer simple questions like:
- Which flows are failing consistently?
- What exactly ran last night?
- Which part of the chain broke and why?
We realized the problem was not “sending requests”. It was orchestrating API test flows over time.
So I built API Unit around a different assumption API testing is closer to workflow orchestration than to clicking requests. With API Unit you model API tests as flows, group them into suites, and schedule them to run automatically. When something fails, you get an alert on mail, a clear execution history showing how the flow progressed and where it broke.
It’s REST-only and intentionally not an API client replacement, but you a page dedicated to simple requests as well. The tool is meant for teams that already know their APIs and want reliable, repeatable testing and monitoring of real-world flows. The product is live and still evolving. I’m sharing it here to get honest feedback from people who have dealt with growing API test complexity, especially around chaining, scheduling, and long-term visibility.
You can create account for free and test everything for 3 days, no card required. Also if you wanna use API Unit, send me a mail at contact@apiunit.io with your account email. I have a gift for you. :)
Website: https://apiunit.io
Happy to answer questions or hear why this wouldn’t work for your setup.

value: Show HN: API Unit manage and schedule real API test flows, not just requests

author: tudalv


value: drbscl

value:
Following the launch of Claude Code's new agent teams (orchestration) feature, I built a plugin to streamline the workflow, by:<p>- Identifying where you need more skills & agents to complete a task
- Searching or making new skills & agents to fill those gaps
- Dispatching a team of these agents to solve your problem

value: Show HN: Dream-team – assemble a team of Claude Code agents for your task

author: drbscl


value: nwparker

value:
Our team lives in Slack, but we don’t have access to the Slack MCP and couldn’t find anything out there that worked for us, so we coded our own agent-slack CLI

  * Can paste in Slack URLs
  * Token efficient
  * Zero-config (auto auth if you use Slack Desktop)

Auto downloads files/snippets.
Also can read Slack canvases as markdown!
MIT License

value: Show HN: Slack CLI for Agents

author: nwparker

title: Show HN: Slack CLI for Agents


value: Easily capture thoughts during home tours, helping to remember and compare homes you've visited. Most tools are built and marketed towards agents, whereas this is built with the prospective buyer (novel concept...I know :) ) in mind to address their pain points and help choose the best home for them. MVP, so UI is a bit rough, but specifically requesting feedback around would you find this helpful in your search? (open to any though ofc) Bonus points if you are actively searching and use it!

value: Show HN: A note-taking tool for homebuyers


value: walmsles

value: Show HN: Sop-agents – Write Markdown, get coordinated agents

author: walmsles


value:
The official Linear MCP works great for writes, but reads were killing my context window in Claude Code. Every query made API calls and returned verbose responses with full user objects and workflow states I didn't need.
So I built a read-only MCP server that reads directly from Linear.app's local IndexedDB cache on macOS. It decodes Y.js CRDT-encoded issue descriptions locally too. Zero API calls, smaller responses, no rate limits, works offline.

value: Show HN: Linear MCP Fast – 10x faster Linear MCP reads from local cache


value: phasesequencer

value:
I got frustrated with existing DJ metadata tools acting as "black boxes"—uploading my audio to cloud servers and giving confident (but often wrong) key detection for minimal/tech-house tracks.
So I built Atomic Afterglow. It’s a Python-based analyzer that runs in the browser but processes audio locally (zero retention/no uploads).
How it works:
Engine: Built on Librosa and Streamlit.
Drop Detection: Instead of finding the "quietest" section, it uses a rolling RMS window to find the deepest structural energy trough in the middle 60% of the track (the breakdown/mix point).
Harmonics: Uses the Krumhansl-Schmuckler algorithm to generate the Top 3 Key candidates (Camelot formatted) with confidence margins, rather than forcing a single result on ambiguous tracks.
Repo (Open Source): https://github.com/phasesequencer/atomic-afterglow
I'd love to hear if the key detection holds up on your more complex or detuned tracks.

value: Show HN: Atomic Afterglow – Local-first audio analysis (Librosa/Streamlit)

author: phasesequencer


value:
Hi HN,
I built Savior, a tiny, dependency-free JavaScript library that autosaves form input and restores it after refreshes, tab closes, or browser crashes.
It’s fully client-side, framework-agnostic, and designed to handle real-world edge cases like dynamic fields, corrupted storage, and failed submits without crashing the app.
Savior restores drafts verbatim — no judgment, no “smart” recovery — just predictable behavior.
GitHub: https://github.com/Pepp38/Savior
Docs: https://zippers.dev
Happy to answer questions.

value: Show HN: Savior – Prevent silent form data loss in the browser


value:
I've spent the last week trying to squeeze the automation out of Claude Code so that I can just queue tasks and they come out the other end tested, validated and ready to ship.
Today I asked Opus 4.6 if we should move to their new team agent system and it said no and suggested that I share what I've done with the world.
I took all the good parts from things like Ralph, and GSD and I was able to push it all into CC prompts - so you don't need anything except Claude Code to set this up.
The problem I was addressing was that CC was generating way more code than I could validated so I needed some sort of task managment that would execute tasks until they were both completed and validated (and fixing anything that broke automatically).
If anyone is trying to achieve the super powers you see the influencer achieving with automation, it can all be done with just pure Claude Code.
I try to help you bootstrap that flow and try to make it easy for both vibe coders and staff engineers!
Feedback and questions welcome!!!

value: Show HN: Founder-OS: Open Sourcing how I automate my company


value: albertoasquer

value:
Hi HN, I’m the author of The 2025 Entrepreneurship Research Playbook.
I am an academic (SOAS University of London) who usually works in public policy. In 2023, I designed a "mini-MBA" for founders and realized a massive inefficiency: my students were dealing with problems that scholars study every day (liability of newness, signaling theory, dynamic capabilities, etc.), but they never saw the research because it was locked behind paywalls or written in dense academic-speak or just too recent to have added to the reading list!
I decided to bridge that gap. I performed a literature review and selected about 300 peer-reviewed entrepreneurship articles published in academic journals in 2025 and synthesized the findings into a practical guide.
Some non-obvious findings from the 2025 literature:
The "Ideator's Dilemma" in GenAI: Research shows GenAI reduces the cost of idea generation but creates a new cognitive burden: distinguishing between "hallucinated" viability and ideas that seem wrong only because they are novel/counter-intuitive (Chapter 3).
The "Passion" Paradox: While popular advice says "be passionate," recent studies (Jin et al., 2025) suggest that high-intensity passion in pitches actually increases perceived risk for investors unless balanced with specific "promotion-focused" language.
Signaling in Crowdfunding: "Linguistic hedging" (vague language) in campaign descriptions is now measurable as a negative signal, whereas specific disclosure of risks (not just strengths) increases trust/authenticity (Chapter 4).
The book is available here: https://entrepreneurshipscience.com/
I posted more contents in the linked website. I’m looking for feedback on which academic concepts feel most relevant to your actual daily grind as founders.
Happy to answer questions about the research!
(I hope the post is fine, I have just joined!)

value: Show HN: I reviewed about 300 academic papers of 2025 to write a book on startup

author: albertoasquer


value: KoeppyLoco

value:
I’m experimenting with modeling tabletop RPG adventures as explicit narrative state rather than linear scripts.
Everdice is a small web app that tracks conditional scenes and choice-driven state transitions to preserve continuity across long or asynchronous campaigns.
The core contribution is explicit narrative state and causality, not automation. The real heavy lifting is happening in the DM Toolkit/Run Sessions area, and integrates CAML (Canonical Adventure Modeling Language) that I developed to transport narratives among any number of platforms. I also built the npm CAML-lint to check validity of narratives. I'm interested in your thoughts.
https://realmofeverdice.com

value: Show HN: A state-based narrative engine for tabletop RPGs

author: KoeppyLoco


value: garrettda

value: Show HN: DoAnything – AI agent with its own email/phone for your to-do list

author: garrettda


value: jeffreydebolt

value: Show HN: Ecommerce CFO Skill – Diagnostic Frameworks for AI Agents

author: jeffreydebolt


value: ryanyu

value:
I think agents should work like real teams, with independent, distinct roles, async communication, and the ability to onboard new teammates or tools without restructuring the whole org. I built backend systems at Yahoo and TikTok so event-driven agents felt obvious. But no agent SDKs were using this pattern, so I made Calfkit.
Calfkit breaks down agents into independent services (LLM inference, tools, and routing) that communicate asynchronously through Kafka. Agents, tool services, and downstream consumers can be deployed, added-to, removed, and scaled independently.
Check it out if this interests you! I’m curious to see what y’all think.

value: Show HN: Calfkit – an SDK to build distributed, event-driven AI agents on Kafka

author: ryanyu


value: sbenodiz

value:
I built Askie after my child asked ChatGPT about snakes and received a detailed breakdown of the world's most lethal species. Weeks of nightmares followed.
The core insight: filtered adult AI isn't the same as AI built for children. A content filter catches bad words but doesn't adjust vocabulary for a 5-year-old vs. a 12-year-old, or know when to redirect a conversation.
Askie is voice-first (kids talk, not type), COPPA compliant, and gives parents full conversation transcripts. Image generation is built on Google Gemini with child-appropriate outputs.
Tech stack: Google Gemini for voice/conversations, Google Gemini for image generation, Railway for hosting, MongoDB, RevenueCat for subscriptions.
Currently serving 2,500+ families. Would love feedback from the HN community on the approach to child safety in AI.

value: Show HN: Askie – Child-safe AI voice chat and art creation for kids (ages 4-15)

author: sbenodiz


value: BTMN

value:
Cryptographic toolkit in a single HTML file. Sign, encrypt, verify -
all offline, no dependencies.

value: Show HN: Cryptographic toolkit in a single HTML file

author: BTMN


value:
Hi HN, I am shubham a 3d artist who learned coding in college as an I.T.  graduate know logics but not an expert as i just wanna try my hands on to ai
So i built Resilient Workflow Sentinel this is offline ai agent which classify urgency (Low,Medium and HIgh) and dispatches to the candidates based on availability
Well i want an offline system like a person can trust with its sensitive data to stay completely locally
Did use ai to code for speeding and cutting labor.
Its works on RTX 3080 system (this is an basic affordable setup not heavy ai machinery) which i want it to make it reliable without heavy upgrade
This is full system doesn't require ollama(I am not against it)
I see in companies tickets are raised on jira and slack. Currently people or manager (self) have to sort those things either manually read one by one or send them to the cloud. But the issue is you can't send everything like there is a lot of sensitive data out there which they do not trust and makes it harder and manual sorting through thousands is likely a nightmare.
But then just imagine u get all the task classified like its urgency and distribution u can selectively see which task is urgent and needs immediate attention and last of all information doesn't leave your building totally secure
Also Api sending is not the only issue u are paying per token cost for task for each may be monthly 100$ to 1000$ which can like save hassle for startup a lot or companies as well
There was several biases like positional bias also json out put bias also have issues in attention
At start i tried just prompting things like Chain of thoughts,RISE(evaluate negative first), given negative examples,Positive examples, somewhere it was struggling with commonsense issue so examples for that (Later changed the approach)
Well prompting did give the output and worked well but took too much time to process for single task like 70 to 90secs for a task
Then i tried batching and the biases got worst like it got stronger it always use to like favour alice also more prompts are like ignored and more
For json output i used constrain so model can only generate json and if fails there is a as well parser i used when i implemented prompting only
This reduce time from 90sec to nearly 15 to 30secs per task
I used steering vector to correct the attention i seen issues happening
Stack:
Language: Python 3.10
Model: qwen2.5-7b-instruct
Libraries: Pytorch, Hugging Face Transformers (No Langchain, No Ollama)
API: Fast API
UI: NiceGUI
Hardware: Ryzen 5, 16Gb ram RTX 3080
Implementation:
Quantization: Load model in nf4 quantization so models like 7b can fit on vram of 10gb which is on rtx 3080 also my hardware
Steering Vectors: Standard prompting wasn't enough. I need to block or direct certain things on a certain layer of llm to make it reliable.
Json Constraints: Used constraint to make model strictly give json and also stop from over explanation this happens at logits level where token are blocked which are not required etc
github : https://github.com/resilientworkflowsentinel/resilient-workf...
Youtube: https://youtu.be/tky3eURLzWo

value: Show HN: Local task classifier and dispatcher on RTX 3080


value: savvyllm

value: Show HN: SavvyLLM – Find the cheapest LLM for any task (800 models)

author: savvyllm


value: kenforthewin

value: Show HN: Watch LLMs Play NetHack

author: kenforthewin

title: Show HN: Watch LLMs Play NetHack


value: davegoldblatt

value:
built this because I got tired of re-teaching Claude Code the same context every session. Preferences, decisions, “we already tried X,” “don’t touch this file,” etc. After a few days it starts to feel like onboarding the same coworker every morning.
Most “agent memory” tools auto-save everything. That feels good briefly, then memory turns into a junk drawer and retrieval gets noisy. Total Recall takes the opposite approach: a write gate. Before anything gets promoted, it asks one question: “Will this change future behavior?” If not, it doesn’t get saved.
How it works:
Daily log first (raw notes)
Promote durable stuff into registers (decisions, preferences, people, projects)
Small working memory loads every session (kept intentionally lean)
Hooks fail open. SessionStart can surface open loops + recent context. PreCompact writes to disk (not model-visible stdout)
The holy shit moment is simple: tell Claude one important preference or decision once, come back tomorrow, and it behaves correctly without you repeating yourself.
Would love feedback from heavy Claude Code users:
Does the write gate feel right or too strict?
Does this actually reduce repetition over multiple days?
Any workflow/privacy footguns I’m missing?

value: Show HN: Total Recall – write-gated memory for Claude Code

author: davegoldblatt


value: toneric

value: Show HN: PR Bro – a TUI that helps you decide what PR to review next

author: toneric


value: chiehminwei

value:
We've been building an AI agent that debugs production incidents, and we think most AI SRE tools are solving the wrong problem.
Everyone's focused on the reasoning — better prompts, better models, RAG over runbooks. But in our experience, the bottleneck isn't the AI's ability to think. It's access to data. At any company past 50 engineers, half the context you need during an incident lives in internal tools with no public docs, custom deploy systems, homegrown dashboards, internal CLIs. No vendor integration covers this.
So we focused on the integration problem. On setup, IncidentFox reads your codebase and Slack history and auto-generates tool integrations — including for internal tools it's never seen before. It figures out what APIs exist, how they're called, and builds the connectors. After each incident, it learns what data sources were actually useful and refines.
The agent itself is straightforward: alert fires → form hypotheses → query observability stack → correlate → report findings in Slack. For example, if latency spikes on your payments service, it'll pull the deploy from 20 minutes ago, find the relevant code change, check downstream dependencies, and open a PR with a fix.
Three design decisions we're opinionated about:
1. Slack-native, not dashboard-native. At 3am you don't want another tab. Paste screenshots, drop log files, view traces — all in the thread.
2. Team-customizable agents. The SRE team's agent should behave differently from the platform team's. Engineers can configure prompts and build team-specific tools. One-size-fits-all doesn't work for incident response.
3. No manual MCP server setup. If you need to spend weeks configuring integrations before AI is useful, you've already lost.
Apache 2.0, fully self-hostable. Try it in our Slack (https://join.slack.com/t/incidentfox/shared_invite/zt-3ojlxv...) with real telemetry (no setup), or clone and run it yourself.
The technical piece we find most interesting: given enough incidents, the agent builds an emergent model of your entire infrastructure — which services are fragile, which deploys are risky, which alerts are noise. Nobody explicitly teaches it this. It just falls out of the investigation data. We think there's something deeper here about AI agents that learn system topology from failure patterns.
Would love to hear people's thoughts!

value: Show HN: IncidentFox, AI SRE that auto-builds its own integrations (open source)

author: chiehminwei


value: cloudmanager

value: Show HN: AcidTest – Security scanner for AI agent skills

author: cloudmanager


value: gthartley

value:
Hey HN,
I'm George. I spent few months rebuilding Obooko, a free ebook platform that's been around since 2010 with 11 million downloads. Reading is losing to scrolling, but BookTok has 370B+ views. People want book content, they're just not reading books. I think that’s because modern reading hasn’t kept up with the pace of the internet.
What I built
Obooko is ad-supported like YouTube. No paywall, no subscription, no account required. 4,000+ books across 30+ genres. You can read in the browser, sync across devices, or download as PDF/EPUB/Kindle.
The reader is built on EPUB.js (https://github.com/futurepress/epub.js). Frontend is vanilla JavaScript, no framework. Backend is Laravel handling progress tracking. The implementation uses continuous scrolling, font size controls (4 levels), chapter navigation, and persists reading progress to a pivot table via debounced API calls.
It's still MVP quality. I went with EPUB.js because it was simpler to integrate and I wanted to ship fast. Now that I'm getting user feedback, the reader is the biggest pain point. (Actually, more books is now the #1 request, but reader UX is close behind.) I'm probably going to switch to Readium (https://github.com/readium) which looks more robust but is more work to integrate.
Being a solo founder
This is my third startup but first time doing it alone. I scaled SmartrMail to exit and built Bluethumb to $100M+ in art sales, but both had co-founders. The day-to-day whiplash of switching between growth work and building product is rough. Some days I'm doing SEO audits and writing blog posts, emails, social. Other days I'm debugging PHP. It feels so hard to get everything covered off, and then I spent time building automations for it in Claude but wonder if I’m over automating.
Maybe the hardest thing I’ve discovered as a solo founder is prioritisation and idea selection. I’m used to have someone to shoot down my dumb ideas. Now Claude just tells me every idea is amazing lol and I can get lost in a rabbit hole instead of really working on the most burning priority. And even daily taking stock of 100 to dos from backlog and working out which is #1, #2 is hard. Wondering how other solo founders do this better?
AI audiobooks (and video books):
I've built an MVP with ElevenLabs Voice API and the narration quality is great. But it's expensive. We've got close to 5,000 books and I can't afford to narrate them all that way yet. One idea I have is that once I build native iOS, the on-device voice APIs might be good enough to do narration on the fly. Then users could customise the voice to their preference. Obviously pretty dependent on where Apple get to with their native AI APIs and new devices.
I also know we need a native app soon. The web reader is fine for casual browsing but serious readers want the Kindle experience: offline, fast, no browser chrome. That's a lot for one person to ship.
What's next:
* Adding more excellent out-of-copyright books over the next few weeks (classics, public domain stuff)
* Talking to indie publishers and authors about coming on board
* Building Author Revenue Share (YouTube model for books) which I think will help with author acquisition
* Eventually the native app and AI narration for every book
Why I'm posting:
I'd genuinely love feedback. On the reader, the business model, etc. I’m a long time lurker first (actually 3rd) time poster, and would really love the feedback here.
Try it: https://obooko.com
EPUB.js (what powers the reader): https://github.com/futurepress/epub.js
Happy to answer questions.

value: Show HN: Obooko – Free ebooks with an open-source web reader

author: gthartley


value: keepamovin

value: Show HN: Hacker News Topics that Span Multiple Discussions

author: keepamovin


value: jpadamspdx

value:
Fun game to play on your own against the clock or against gpt-4o mini.
Uses finite projective plane PG(2, 7).
You can back it with a graph database with PG(2, 7) representation and it's fun to explore the structure. More in blog post: https://medium.com/neo4j/the-math-and-the-graph-behind-a-pop...

value: Show HN: Graph DB-backed game, like Dobble/Spot it to play with Projective Plane

author: jpadamspdx


value: gissurthor

value:
Hey HN,
I built ImportKit (https://importkit.app) — a drop-in React widget that handles CSV and Excel imports for SaaS apps.
This is my first software product ever. I work in sales and marketing for a maritime software company in Iceland, and I kept seeing the same problem: every SaaS app eventually needs CSV import, and every team builds it from scratch. Column mapping, validation, error handling — it’s a lot of repetitive work.
So I decided to try building a solution myself. ImportKit is an embeddable widget you install with npm install @importkit/react and configure with a few props. It handles:
 ∙ AI-powered column mapping (auto-suggests matches between CSV headers and your fields)
 ∙ Built-in validation (email, phone, required fields)
 ∙ CSV and Excel support (XLSX, XLS)
 ∙ Theming to match your app’s look
Setup takes about 5 minutes. There’s a free tier (100 rows/month) so you can try it without commitment.
I’m a one-person team running this as a side project. I’d genuinely appreciate any feedback on the product, the landing page, or the approach. And if you’ve solved CSV imports differently in your apps, I’d love to hear how.
https://importkit.app
Docs: https://docs.importkit.app

value: Show HN: ImportKit – Embeddable CSV import widget for SaaS apps

author: gissurthor


value: JoshPurtell

value:
I'm Josh, founder of Synth. We've been working on coding agent optimization with method like GEPA and MIPRO (the latter of which, I helped to originally develop), agent evaluation via methods like RLMs, and large scale deployment for training and inference. We've also worked on patterns for memory, processing live context, and managing agent actions, combining it all in a single stack called Horizons. With the release of OpenAI's Frontier and the consumer excitement around OpenClaw, we think the timing is right to release a v0.
It integrates with our sdk for evaluation and optimization but also comes batteries-included with self-hosted implementations. We think Horizons will make building agent-based products a lot easier and help builders focus on their proprietary data, context, and algorithms
Some notes:
- you can configure claude code, codex, opencode to run in the engine. on-demand or on a cron
- we're striving to make it simple to integrate with existing backends via a 2-way event driven interface, but I'm 99.9% sure it'll change as there are a ton of unknown unknowns
- support for mcp, and we are building with authentication (rbac) in mind, although it's a long-journey
- all self-host able via docker
A very simplistic way to think about it - an OSS take on Frontier, or maybe OpenClaw for prod

value: Show HN: Horizons – OSS agent execution engine

author: JoshPurtell


value: robbyzhao

value:
Hi HN,
This is an open source browser extension to discover related GitHub repositories.
It runs entirely in your browser for privacy—simply configure your own Model endpoint and API key to use it.

value: Show HN: Similar Repos – AI-Powered Recommender for GitHub Repository

author: robbyzhao


value:
I’ve spent the last year building Lytok, a binary data notation format born out of a personal obsession with data density and infrastructure efficiency.
While JSON is the standard, its verbosity becomes a bottleneck in high-throughput systems and AI pipelines. Lytok focuses on four key pillars:
Token Efficiency: Up to 44.80% fewer tokens than JSON, significantly reducing LLM inference costs.
Storage Density: Up to 60% reduction in disk space usage.
Bandwidth Economy: Smaller payloads for faster, cheaper network transfers.
Strong Typing: Native support for complex data types without the overhead.
This is a project of passion I’ve been refining since last year. I’ve built a web-based Lab so you can test these claims with your own datasets.
Check out the Lab: https://lytoklab.netlify.app/ I'd love to hear your technical feedback.

value: Show HN: Lytok – A binary format with 44% fewer tokens than JSON


value: calinf

value:
I built WaldenWeek as an anti-app designed to be used ~1m/week that actively challenges you to not use other apps.
I gamified Thoreau’s "simpler living" philosophy and adjusted to the digital age. The goal is to subtract a modern commodity every week to find out what we can/cannot live without.
If you complete the week, you upgrade your 'human' attributes (Focus, Clarity, Strength,...). If you fail, you donate real money to a charity that matches the challenge.

value: Show HN: WaldenWeek – An anti-app designed to be used 1min/week

author: calinf


value: JosMade

value:
Hi HN — I built a small web app that visualizes crypto liquidations in real-time and can be used as an OBS Browser Source overlay (clean HUD + transparent background + lightweight mode).
What it does:
- Real-time liquidation beam overlay (designed to sit behind a chart)
- No login required (direct exchange WebSocket fallback)
- Streamer-friendly presets: lite mode, clean UI, transparent background
Why:
I wanted something that adds context to a live chart without clutter and without needing plugins/accounts.
Other links:
- Overlay (OBS): https://v4-binance.pages.dev/obs
- X-style view: https://v4-binance.pages.dev/x
Notes:
- Not financial advice; this is a visualization tool.
- Happy to answer implementation questions (data ingestion, WebSocket reconnects, performance in OBS, etc.).

value: Show HN: Global Liquidation Map (OBS overlay, no login)

author: JosMade


value: nabenjamin

value:
Hi HN, I’m the creator of RMTimer,
I'm a solo developer and a frequent Redmine user. I always found it cumbersome to track time on tasks - constantly switching to the browser, finding the issue, and opening the time log form disrupted my flow.
So, I built RM Timer, a minimalist desktop application for Windows/macOS/Linux. Its main goal is to make time logging a one-click action.
What it does:
• Connects directly to your Redmine instance (API key).
• Lists your assigned issues in a simple, fast interface.
• Start/stop timer with a single click per issue.
• Logs time directly to the Redmine issue when you stop the timer.
• Minimizes to system tray.
Why I'm sharing it here: I first made it for myself, but I thought other Redmine users might find it useful. I'm also looking for honest feedback to improve it.
Try it out / Get it:
◇ If you try it, what's one thing I should absolutely add or fix?

value: Show HN: RMTimer a Redmine Desktop Client

author: nabenjamin


value:
Hi HN,
I built Qwen3-TTS-WebUI, a lightweight web interface for running Qwen3-TTS locally.
Motivation: Qwen3-TTS works well, but it is mostly used via CLI. That makes quick、parameter tweaking, and audio preview inconvenient, especially for non-technical users. I wanted a simple local UI to test voices, adjust settings, and export audio easily.
Features:
- Local inference only, no cloud
- Simple WebUI for text input and audio preview
- Minimal setup, focused on experimentation rather than production
Current status:
- Early stage / work in progress
- Usability-focused, not heavily optimized yet
Repository:
https://github.com/bdim404/Qwen3-TTS-WebUI
I’d appreciate feedback on:
UI/UX improvements
Useful controls or missing features
Any design mistakes common in TTS tools
Thanks for taking a look.

value: Show HN: Qwen3-TTS WebUI – a local web interface for Qwen3 text-to-speech


value: kraklabs

value: Show HN: MIE – Shared memory for all your AI agents (Claude, Cursor, ChatGPT)

author: kraklabs


value: nihalwashere

value:
I've been building AI agents that needed web access and kept hitting the same wall: production scraping is hard. You start with Puppeteer, then add stealth plugins, then fight Cloudflare, then manage proxies, then handle browser pooling and it still breaks.
I kept solving this problem from scratch on different projects, so I packaged it up as Reader, hoping it saves others the same headaches...
Two primitives:

  const reader = new ReaderClient();

  // Scrape URLs → clean markdown
  const result = await reader.scrape({ urls: ["https://example.com"] });

  // Crawl a site → discover + scrape pages
  const pages = await reader.crawl({ url: "https://example.com", depth: 2 });

Under the hood it's built on Ulixee Hero, a headless browser designed for
anti-detection. The hard stuff like TLS fingerprinting, Cloudflare/Turnstile bypass, browser pool recycling, proxy rotation is built in.
The HTML-to-markdown conversion uses supermarkdown, a Rust engine I built
specifically for messy real world HTML. Clean output, no artifacts.
TypeScript first, full type safety, works as CLI or library. Apache 2.0 license.
GitHub: https://github.com/vakra-dev/reader
Happy to answer questions about the architecture, approach, or tradeoffs I made.
Would love feedback from anyone doing web scraping at scale, especially on edge cases where it breaks. That's how I can make this better.

value: Show HN: Reader – open-source web scraping engine built for LLMs

author: nihalwashere


value: lealee

value:
Hey HN! Graph Maker helps you transform complex data into beautiful, professional visuals instantly. You can upload files, paste directly from Excel, or enter your data manually to get started.
Hope you like it!
Any feedback can be sent to this place:
support@graph-maker.ai

value: Show HN: Graph Maker, a tool to help you create data graphs in seconds with AI

author: lealee


value: EmTekker

value:
Hi HN!
I’m building OpenWeavr, an open-source platform that lets you run AI agents on your own machines (Mac minis, laptops, or spare computers) to automate real-world tasks.
The idea is simple: many workflows still require manual steps across apps, browsers, and tools. Instead of relying only on cloud SaaS automation, OpenWeavr lets you run agents locally so they can:
• Automate workflows across apps and websites
• Run long-lived agents on always-on machines
• Orchestrate tasks across multiple devices
• Keep data local and private via self-hosting
A lot of people have idle Macs or spare computers at home or work — OpenWeavr turns them into automation workers.
Current focus:
• Simple self-host setup
• Agent workflows & task automation
• Developer-friendly APIs
• Privacy-first architecture
The project is still early, and I’d love feedback from the HN community on:
• What tasks would you automate first?
• What’s missing from current automation tools?
• What would make you run something like this at home or work?
Repo & docs: https://openweavr.ai
Happy to answer questions and would love contributors or feedback!

value: Show HN: OpenWeavr – Run AI workflows on your own machines to automate tasks

author: EmTekker


value: Roccan

value: Show HN: CursedFeed, a social feed where people use spells to mutate next posts

author: Roccan


value: sally-suite

value: Show HN: TabAny – Start AI chats from text boxes, enables quick translations

author: sally-suite


value: bsgeraci

value:
I'm a software engineer who keeps getting pulled into DevOps no matter how hard I try to escape it. I recently moved into a Lead DevOps Engineer role writing tooling to automate a lot of the pain away. On my own time outside of work, I built Artifact Keeper — a self-hosted artifact registry that supports 45+ package formats. Security scanning, SSO, replication, WASM plugins — it's all in the MIT-licensed release. No enterprise tier. No feature gates. No surprise invoices.
Your package managers — pip, npm, docker, cargo, helm, go, all of them — talk directly to it using their native protocols. Security scanning with Trivy, Grype, and OpenSCAP is built in, with a policy engine that can quarantine bad artifacts before they hit your builds. And if you need a format it doesn't support yet, there's a WASM plugin system so you can add your own without forking the backend.
Why I built it:
Part of what pulled me into computers in the first place was open source. I grew up poor in New Orleans, and the only hardware I had access to in the early 2000s were some Compaq Pentium IIs my dad brought home after his work was tossing them out. I put Linux on them, and it ran circles around Windows 2000 and Millennium on that low-end hardware. That experience taught me that the best software is software that's open for everyone to see, use, and that actually runs well on whatever you've got.
Fast forward to today, and I see the same pattern everywhere: GitLab, JFrog, Harbor, and others ship a limited "community" edition and then hide the features teams actually need behind some paywall. I get it — paychecks have to come from somewhere. But I wanted to prove that a fully-featured artifact registry could exist as genuinely open-source software. Every feature. No exceptions.
The specific features came from real pain points. Artifactory's search is painfully slow — that's why I integrated Meilisearch. Security scanning that doesn't require a separate enterprise license was another big one. And I wanted replication that didn't need a central coordinator — so I built a peer mesh where any node can replicate to any other node. I haven't deployed this at work yet — right now I'm running it at home for my personal projects — but I'd love to see it tested at scale, and that's a big part of why I'm sharing it here.
The AI story (I'm going to be honest about this):
I built this in about three weeks using Claude Code. I know a lot of you will say this is probably vibe coding garbage — but if that's the case, it's an impressive pile of vibe coding garbage. Go look at the codebase. The backend is ~80% Rust with 429 unit tests, 33 PostgreSQL migrations, a layered architecture, and a full CI/CD pipeline with E2E tests, stress testing, and failure injection.
AI didn't make the design decisions for me. I still had to design the WASM plugin system, figure out how the scanning engines complement each other, and architect the mesh replication. Years of domain knowledge drove the design — AI just let me build it way faster. I'm floored at what these tools make possible for a tinkerer and security nerd like me.
Tech stack: Rust on Axum, PostgreSQL 16, Meilisearch, Trivy + Grype + OpenSCAP, Wasmtime WASM plugins (hot-reloadable), mesh replication with chunked transfers. Frontend is Next.js 15 plus native Swift (iOS/macOS) and Kotlin (Android) apps. OpenAPI 3.1 spec with auto-generated TypeScript and Rust SDKs.
Try it:

  git clone https://github.com/artifact-keeper/artifact-keeper.git
  cd artifact-keeper
  docker compose up -d

Then visit http://localhost:30080
Live demo: https://demo.artifactkeeper.com
Docs: https://artifactkeeper.com/docs/
I'd love any feedback — what you think of the approach, what you'd want to see, what you hate about Artifactory or Nexus that you wish someone would just fix. It doesn't have to be a PR. Open an issue, start a discussion, or just tell me here.
https://github.com/artifact-keeper

value: Show HN: Artifact Keeper – Open-Source Artifactory/Nexus Alternative in Rust

author: bsgeraci


value: pizlonator

value: Show HN: An LLM-enabled bash-based shell for Linux

author: pizlonator


value:
Hi everyone,
I'm a YouTuber in San Francisco, and I’ve always struggled to find copyright-safe music for my videos. I wanted something quick and flexible, so I decided to build my own tool.
In about a week, I put together Trymusic AI (https://trymusic.ai), a browser-based music generator. The main feature is the AI Song Generator, which can produce music from text descriptions or moods.
I also added a few extra tools for convenience: Lyrics Generator, BPM Detector, MP3 to MIDI, Jingle / 8-Bit Music Maker, Slowed Reverb Generator
I used Claude Opus 4.5 for stability and 4.6 for more complex prompts. 4.6 has a 1M-token context window, which lets it handle longer or layered instructions better. From what users have noted, it can recall almost all details from long texts, showing clear improvements over 4.5.
I had almost no web dev experience. I used Next.js for the front-end, Vercel for deployment, and claude code to help write and organize code. After seven days of testing, I had a working site where I could generate music directly in the browser.
It's still quite early, but I'd love feedback. I'll be around to answer questions.
[1] https://trymusic.ai/docs

value: Show HN: Built AI Music Generator Using Claude 4.5 and 4.6


value: slad

value:
I’m launching Intentify, currently in closed beta. It's free while in Beta! See explainer video - https://youtu.be/5ZGQ1Jyc2cc
Intentify is built for simple UX changes. Instead of creating bugs, assigning them, prioritizing them, and waiting in a queue, you can point at the UI, explain what you want in plain language, and move on. Intentify captures the intent, creates a detailed bug ticket automatically, and generates the code changes as a pull request for engineers to review and ship.
Before anything is approved, Intentify shows a preview of the proposed change, so you can see what it will look like and validate it before it goes to engineering.
Important note: your data is not used to train any AI models. It works with your existing workflow and keeps your code and context private.
If you’re a founder, product leader, or non-technical CEO who wants to move fast and make small changes, this is for you.
Request access at https://intentify.dev or DM me. Happy to also just take any feedback, suggestions

value: Show HN: Intentify – annotate –> preview –> code generation

author: slad


value: AliShahryar

value:
I have been working on a side-project which replaces the following things in the Claude ecosystem with free alternatives. I started the initial implementation with Opus 4.5 in claude code and as soon as it got working I used it to work on itself which i found very cool.
- Replaces Anthropic models with NVIDIA-NIM models: It acts as middleware between Claude-Code and NVIDIA-NIM allowing unlimited usage upto 40 RPM with a free NVIDIA-NIM api-key.
- Replaces the Claude mobile app with telegram: Give it access to some directories, send it tasks from telegram and watch it work autonomously.
It has features that distinguish it from similar proxies:
- The interleaved thinking tokens generated between tool calls are preserved allowing reasoning models like GLM 4.7 and kimi-k2.5 to take full advantage of thinking from previous turns.
- Fast prefix detection (+4 other optimizations) stops the CLI from sending bash command prefix classification requests to the LLM making it feel blazing fast.
- Built in rate limiting and session concurrency.
The code is modular so that adding other providers or messaging apps is easy. Hope the community likes it, any PRs are welcome.

value: Show HN: Free Unlimited Claude Code usage with Nvidia NIM models

author: AliShahryar