value:
Hi HN, I'm the author.
I've spent years building Node.js backends (mostly Express and NestJS) and I’ve consistently found traditional ORMs like TypeORM too heavy, while Prisma’s subscription models didn't quite fit my need for lightweight CDC (Change Data Capture). I wanted something universal that felt closer to the metal but still handled real-time events seamlessly.
Over the past couple of days, I built Kinetic SQL. It's a thin, highly flexible SQL wrapper for Node.js (supporting Postgres, MySQL, and SQLite).
The CORE focus:
Framework Agnostic: Works beautifully with Express, Fastify, or Vanilla Node, with a dedicated seamless-integration module for NestJS included as a bonus.
Real-time Subscriptions: Listen to table changes (INSERT/UPDATE/DELETE) natively and push to clients (perfect for live dashboards).
Zero-Touch Interfaces: The CLI (npx k-sql gen) reads your schema and auto-generates absolute type safety. No more writing interfaces by hand.
Native DB Functions: Call your database procedures directly as native JavaScript methods.
To stress-test the real-time engine, I built a high-frequency stock market simulator (running on a free Vercel/Render stack with a 0-second cold start):
Live Demo: https://live-stock-simulator.vercel.app/
NPM: https://www.npmjs.com/package/kinetic-sql
I'd love to hear your thoughts on the API design.
(P.S. MSSQL support is coming soon!)

value: Show HN: Kinetic SQL – A lightweight, real-time SQL Engine for Node.js


value: debba

value:
Every few weeks I get 2-3 CSV files and need to run a quick JOIN or aggregation. The options are always the same: fire up pandas, import into SQLite by hand, or use some janky web tool.
So I built a plugin for Tabularis (my native DB GUI) that treats a folder of CSV files as a database. Drop your files in, every file becomes a table, column types are inferred automatically, and you get a full SQL editor.
No code. No imports. Just SQL.
Example: 3 CSV files (users, orders, products) → this query works immediately:

  SELECT
    u.name,
    u.country,
    COUNT(o.id)                        AS orders,
    ROUND(SUM(p.price * o.quantity), 2) AS total_spent
  FROM orders o
  JOIN users u ON o.user_id = u.id
  JOIN products p ON o.product_id = p.id
  GROUP BY u.id
  ORDER BY total_spent DESC

The plugin is ~250 lines of stdlib Python (zero dependencies). It works because Tabularis has an open plugin protocol — JSON-RPC over stdin/stdout — so any data source can be a database.
Plugin: https://github.com/debba/tabularis-csv-plugin
Tabularis: https://github.com/debba/tabularis

value: Show HN: I got tired of writing Pandas scripts just to JOIN two CSV files

author: debba


value: Show HN: Tracking my bin (trash can)

title: Show HN: Tracking my bin (trash can)


value: naxtsass

value:
Hi HN,
AI video has reached a "Sora-level" moment that you can actually use today. We’ve built seevideo.dance to bridge the gap between researchers and creators by integrating the two most powerful models currently in existence: Kling 3.0 and Seedance 2.0.
Why these two are industry-shattering:
Kling 3.0 (The Physics King): This isn't just "generating pixels." Kling 3.0’s new physics engine handles complex biological movements and fluid dynamics with a level of realism that was thought to be years away. Its cinematic 4K output and consistent character rendering have set a new gold standard for AI cinematography.
Seedance 2.0 (The Speed & Creativity Beast): Powered by ByteDance’s latest architecture, Seedance 2.0 is arguably the world’s fastest high-fidelity model. Its adherence to complex prompts and revolutionary motion control allows for precise directorial intent that generic models simply can’t match.
What we’ve built at SeeVideo:
We didn't just build an API wrapper; we built a Professional Cinematic Workspace.
High-Speed 4K Pipeline: Optimized rendering paths for Kling’s high-fidelity outputs.
Director’s Toolkit: Advanced parameter tuning for Seedance’s motion vectors.
No-Subscription Freedom: We believe elite tech should be accessible. Pay-as-you-go, no monthly traps, just raw generative power.
Technical Challenge: Scaling the GPU clusters to handle Kling 3.0’s complex physics simulations while maintaining Seedance 2.0’s near-instant response was our biggest hurdle. We’d love for the HN community to stress-test the pipeline and give us feedback on the temporal consistency of these models.
website: https://seevideo.dance/

value: Show HN: SeeVideo – Access Seedance 2.0 and Kling 3.0 without a subscription

author: naxtsass


value:
I built an AI video generator that scripts multiple shots in a single generation, instead of the typical "one prompt → one clip" model.
What it does:
- Multi-shot narratives: up to 6 shots per generation, each with its own prompt and duration
- Reference-driven consistency: upload 3 reference images to lock character appearance and style
- 4 input modalities simultaneously: text + images (up to 9) + video clips (up to 3) + audio (up to 3)
- @ reference system: assign specific roles to each input file (e.g., @Image1 for character, @Video1 for camera motion)
- Output: 2K resolution, 24fps, with native audio sync and lip-sync
The problem: existing AI video tools generate single isolated clips. Want a 3-shot story? Generate 3 times, hope the character stays consistent, manually stitch. Sora 2 ($20/mo) gives you one shot at a time. Runway has an editing suite but no multi-shot generation.
Dola Seed 2.0 lets you define the full narrative arc upfront. Each shot gets its own direction. Character consistency comes from the reference system, not luck.
Tech-wise, the interesting tradeoff was multi-shot coherence vs per-shot flexibility. We use reference conditioning across shots rather than a single monolithic generation, which gives better individual shot quality while maintaining ~90% character consistency.
Free to try (no account required for first 3 generations): https://dolaseed.site
Would love feedback, especially on multi-shot coherence quality and the reference system UX.

value: Show HN: Dola Seed 2.0 – AI video generator with multi-shot narrative control


value: memograph

value:
Hi HN,
I’ve been building AI agents and copilots, and kept running into a frustrating problem: they don’t fail loudly, they forget things quietly.
Users re-explain preferences, agents contradict earlier responses, and context resets without any clear visibility into why.
I built Memograph CLI as a debugging tool to analyze conversation transcripts and show:
- what the agent forgot
- where continuity broke
- contradictions and repeated context
- estimated token waste due to re-prompting
It works locally and supports plain text or JSON transcripts.
Example:
$ memograph
Output:
Cognitive Drift Score: 41/100
Forgotten preferences: 3
Token waste: 29%
Trust-breaking contradictions: 1
The goal isn’t to replace your agent framework, but to give developers visibility into memory failures.
Repo: https://github.com/memographAI/Memograph-CLI
Would love feedback, especially from people building agents in production.

value: Show HN: Memograph CLI- A tool to diagnose 'memory failures' in AI agents

author: memograph


value: soudk

value:
Hey HN!
Read the Room is an anonymous social polling app that lets anyone filter or compare results between generations, countries and cities.
Example: Rate "Is remote work overrated?" on a 1-5 scale and see if Gen Z in Austin agrees with Millennials in Berlin.
Privacy-first architecture: Response history stored locally on your device, only aggregates hit the server. Aiming for close to "zero-knowledge polling", Passkey auth (no passwords, no accounts). Each response to a poll is submitted as "City X votes +1 in bucket Y" without attaching the user to the response, or the fact that they responded to the question in the first place (all that is processed on device). Built with Flutter + Supabase, AGPLv3.
I built this slowly over a couple of years because I was tired of mass social media masquerading as surveillance tech, and I wanted to build what a "human bioindicator" might actually look like in an OSS paradigm. It's designed as a nonprofit, mirroring Wikipedia.
We're live at 500 installs across 50 countries with ~100 weekly actives right now, with vast majority of folks in the US/Canada. Though, it'd be cool to diversify that a bit more. English-only for now, but designing the multi-language support and will implement it once there is more traction.
Would love your feedback, and happy to answer questions!
Read more: https://readtheroom.site
Code: https://github.com/readtheroom-knowtheworld/readtheroom-app
iOS: https://apps.apple.com/app/id6747105473
Android: https://play.google.com/store/apps/details?id=com.readtheroo...

value: Show HN: Read the Room, a FOSS human bioindicator

author: soudk


value: pouya-eghbali

value:
I've been a zsh user for a long time, and I grew tired of how heavy it is. I made nosh as a replacement for my own use. I open-sourced it yesterday for everyone to use. AI features are entirely optional, and there's no telemetry.
Compared to zsh:
- 90x faster startup time
- toml-based configuration, customization, and plugin system
AI features require signing in to the nosh cloud, free plan included. Usage looks like this:
? what's using port 3000 to 3010
or agentic mode:
?? what's eating up disk space on my laptop
Adds a bit of convenience so you don't have to leave the terminal to look up a specific command. There's a built-in safety feature to prevent you from shooting yourself in the foot.
Happy to answer questions and get your feedback :)

value: Show HN: Nosh – Fast native shell with built-in AI (natural language commands)

author: pouya-eghbali


value: Herbyg

value:
Hey HN,
I built ShouldISwap (https://shouldiswap.com) — a free tool that compares the conversion rate between any two cryptocurrencies against their historical average. Pick two coins, pick a timeframe (7-365 days), and it tells you whether today's rate is above, below, or near the mean, plus where it sits in the 52-week range as a percentile.
How it works: Fetch 365-day price histories for both coins from CoinGecko, compute the pairwise conversion rate per day, calculate the mean for the selected period, and compare. A sliding window across the full year computes the historical best/worst deviations to give a "signal strength" — not just "above average" but how significant the deviation is relative to what's been seen all year.
Stack: Node.js + Express 5, React 19 + Vite 7, Tailwind CSS 4. No TypeScript. No database — fully stateless with three-tier in-memory caching (60s/5min/1hr). Each comparison makes 4 CoinGecko API calls (down from 6) by fetching 365-day history once and slicing per timeframe. Chart.js lazy-loaded (~173KB on demand). 66KB gzipped initial load. Single Docker container on Google Cloud Run.
Lighthouse: 99 Performance, 100 Accessibility, 100 Best Practices, 100 SEO.
Honest limitations: Depends entirely on CoinGecko's API. In-memory cache means no horizontal scaling without Redis. Signals are statistical comparisons against history, not predictions — it tells you where you are, not where things are going.
Would appreciate feedback on the architecture, the signal calculation, or the UX. Source isn't public yet but happy to discuss implementation.

value: Show HN: ShouldISwap – Compare crypto pair rates against historical averages

author: Herbyg


value: keepamovin

value: Show HN: How Much did it Cost?

author: keepamovin

title: Show HN: How Much did it Cost?


value:
Almost 3 years ago I posted v1 here. This is v2, a complete rewrite built on Svedit, an open source rich text editor I wrote specifically for structured in-place editing.
The idea is simple: The website itself becomes the CMS. There’s no admin panel. You define your content model in JavaScript and write Svelte components to render it. Once deployed the client can login and change content live on the page, create new pages, and link them up to form a website. The data is stored in SQLite. It’s fast and doesn’t require a rebuild when content changes.
My goal is to make small to medium websites editable, without depending on a 3rd party system.
This is likely not a good fit if you need multi-author workflows, or heavy editorial tooling.
Curios to hear what you think.

value: Show HN: CMS-free in-place editable websites with Svelte (v2)


value: talktoconor

value: Show HN: Breathwork Tools – A free breathwork timeras a single HTML file

author: talktoconor


value: DimitriMikadze

value: Show HN: Orca, open-source AI agent for deep LinkedIn profile analysis

author: DimitriMikadze


value: juanghiri

value: Show HN: CodeSeeker – Knowledge graph code intelligence for AI coding assistants

author: juanghiri


value: ndeodhar

value:
Hi HN, I'm Neha. I spent years at Google building infrastructure that handled billions of events at 99.999% reliability. When I started building AI agents, I was surprised at how much production plumbing you're expected to own yourself.
The agent itself is the easy part. The hard part is everything around it: where does it execute safely? What happens when it fails midway through a workflow? How do you trigger it from your existing tools? How do you even know what it did?
I kept stitching together Docker, a workflow engine, a notification layer, and custom retry logic. Every team I talked to was doing the same thing. So I built Polos - an open-source runtime that handles the production layer so you just write the agent.
What it does:
- Sandboxed execution: agents run sensitive operations inside managed Docker containers with built-in tools for file I/O, bash, and web search. You don't manage the sandbox or its lifecycle, Polos does. Will support more sandboxes like E2B in the future.
- Slack integration: @mention an agent in Slack, get responses in thread. Trigger workflows from Slack, receive notifications, collect input. Agents become part of your team's existing workflow.
- Durable workflows: if an agent fails mid-run, it resumes from the exact step that failed. Built-in prompt caching with 60-80% cost savings on retries.
- Observability: OpenTelemetry tracing for every step, tool call, and decision.
- LLM agnostic: works with OpenAI, Anthropic, Google, or any provider via Vercel AI SDK and LiteLLM.
The stack is Rust orchestrator (Axum + Tokio + PostgreSQL), Python and TypeScript SDKs, and Vite UI. You can install and run a durable, sandboxed agent in under 5 minutes:
```<p>curl -fsSL <a href="https://install.polos.dev/install.sh" rel="nofollow">https://install.polos.dev/install.sh</a> | bash<p>npx create-polos<p>cd my-project && polos dev<p>```
Here's a 3-min demo of a coding agent that picks up a GitHub issue, fixes the code in a sandbox, and submits a PR: https://www.youtube.com/watch?v=KYVBpdZ_5eM
Happy to discuss technical decisions and more: why Rust for the orchestrator, how durable execution works without a DAG, and the sandbox lifecycle model.
GitHub: https://github.com/polos-dev/polos

value: Show HN: Polos: Open-source runtime for AI agents with sandbox and durable exec

author: ndeodhar


value: oug-t

value: Show HN: zsweep – Play Modern Minesweeper with Vim Support

author: oug-t


value: swithek

value:
Hey HN,
I wanted to share a project my friend Dovydas and I (Simon) have been working on for a while. It’s a knowledge base platform built specifically for developers and technical teams.
It has a similar feel to Notion and supports live collaboration, but it also has technical "power blocks" for API specs, runbooks, RFCs, as well as live metrics from external sources like Prometheus. On top of that, document changes can be reviewed like GitHub PRs, while still preserving rich text blocks and chart displays. The simplest way to describe it is: what if Notion, Grafana, and the PR review parts of GitHub were merged into one platform?
We started working on this because we realised Grafana is good at showing you that something is happening, but it’s not great at telling you why you should care, what "normal" looks like, or which runbook / decision / incident it relates to (it has description fields, but they’re fairly limiting). If you didn’t build the dashboard, you usually end up asking the person who did. Also: dashboards tend to get changed quietly, and the explanations (if they exist) usually don’t.
At the same time, Notion/Confluence work well for text, but they’re awkward for technical artefacts (runbooks, RFCs, postmortems, API specs), and the review features feel superficial. That’s why a lot of people, ourselves included, fall back to git-based docs. Git-based docs are closer to how engineers work, but then you’re running a docs "product" (Docusaurus / GitBook / etc.) with pipelines and deployments, auth layers, and live collaboration on long-form writing that’s rarely pleasant. And, of course, observability still sits somewhere else.
So we built Oxynote. It’s a technical knowledge base for dev + infra teams, with a bias towards simplicity (we took a lot of inspiration from Linear and the idea that you shouldn’t need a training session to use a tool). It keeps runbooks, procedures, API design docs, RFCs, and postmortems together with a proper review flow, and lets you put relevant metrics charts right next to the text. It also has a feature we call "freshness hooks", which lets you tie docs to related GitHub repos / Docker images / external websites, so you get a nudge when something there changes.
This is still an early-stage platform and we’ve got a lot we want to add. For example, live metrics charts currently support only Prometheus, but we’re planning to add SQL databases and other data sources next.
It’s completely free and there are no ads. We’d really appreciate suggestions, experiences (positive and negative), and ideas. Thanks!

value: Show HN: Oxynote – Technical knowledge base with live Prometheus charts

author: swithek


value: alexlock

value: Show HN: Destroy My Startup

author: alexlock

title: Show HN: Destroy My Startup


value: JackCity

value:
Public release of *ZombieHunter*, a forensics tool detecting live exploitation of CVE‑2026‑20700 (dyld memory corruption) in iOS 26.3.
Analysis of sysdiagnose archives shows identical exploit shells showing different C2 endpoints:
US Device 1 → 83.116.114.97 (EU/US)
US Device 2 → 101.99.111.110 (CN)
The rogue dyld_shared_cache slice triggers overflow via malformed `mappings_count`, executes shellcode (BL #0x15cd), and applies an AMFI bypass (`DYLD_AMFI_FAKE`) enabling unsigned code persistence.
Apple PSIRT + CISA were notified; public disclosure follows.
Sample: https://drive.google.com/file/d/1rYNGtKBMb34FQT4zLExI51sdAYR...
SHA256 artifact: ac746508938646c0cfae3f1d33f15bae718efbc7f0972426c41555e02e6f9770
Usage: `python3 zombie_auditor.py sysdiagnose_xxx.tar.gz` (Needs capstone)
Reproducible PoC confirms CVE‑2026‑20700 bypass, AMFI neutralization, and live C2 connectivity in production iOS 26.3.

value: Show HN: Live iOS 26.3 exploit detection (CVE-2026-20700) – Multi-region C2

author: JackCity


value: examo

value: Show HN: HitKeep – Web Analytics in a Single Go Binary (Embedded DuckDB and NSQ)

author: examo


value: chancemehmu

value: Show HN: Instant human feedback from 1000s of real users within seconds

author: chancemehmu


value: hollowsolve

value:
I built Match, a pattern matching language designed to replace regex. Instead of cryptic escape sequences, you describe patterns in plain English.
Example — matching an email address:
email: username then "@" then domain
username: one or more of (letter, digit, ".", "_", "-")
domain: one or more of (letter, digit, "-") then "." then between 2 and 6 letters
Key differences from regex:
- Human-readable grammar syntax
- Full parse trees with named extractions
- No backtracking, no ReDoS by design
- Composable grammar modules (use "module" (rule1, rule2))
- Zero dependencies, ~15KB
Available on npm (@hollowsolve/match). Docs, playground, and examples on the site.
GitHub: https://github.com/hollowsolve/Match

value: Show HN: Match – A pattern matching language that replaces regex

author: hollowsolve


value: sandgardenhq

value:
Hey HN,
We built Sgai to experiment with a different model of AI-assisted development.
Instead of prompting step-by-step, you define an outcome in GOAL.md (what should be built, not how), and Sgai runs a coordinated set of AI agents to execute it.
- It decomposes the goal into a DAG of roles (developer → reviewer → safety analyst, etc.)
- It asks clarifying questions when needed
- It writes code, runs tests, and iterates
- Completion gates (e.g. make test) determine when it's actually done
Everything runs locally in your repo. There’s a web dashboard showing real-time execution of the agent graph. Nothing auto-pushes to GitHub.
We’ve used it internally for prototyping small apps and internal tooling. It’s still early and rough in places, but functional enough to share.
Demo (4 min): https://youtu.be/NYmjhwLUg8Q
GitHub: https://github.com/sandgardenhq/sgai
Open source (Go). Works with Anthropic, OpenAI, or local models via opencode.
Curious what people think about DAG-based multi-agent workflows for coding. Has anyone here experimented with similar approaches?

value: Show HN: Sgai – Goal-driven multi-agent software dev (GOAL.md → working code)

author: sandgardenhq


value: novateg

value: Show HN: I Accidentally Built a Zero-Config Redis Alternative in Go – ScaloDB

author: novateg


value:
Hey HN community!
I want to tell you about my open source project: mlut. This is the best CSS framework for custom websites and creative coding. It is similar to Tailwind in that it is based on the Atomic CSS approach, but in some respects it surpasses all popular analogues.
mlut helps to create projects with individual and non-standard designs, where old-school frameworks are not suitable and LLMs perform poorly. The project is the result of in-depth research and over 1,000 hours of work. Details about the study can be found here: https://dev.to/mr150/atomic-css-deep-dive-1hee
Key features:
- Short and consistent naming. If you know CSS, you almost know mlut. The abbreviations are based on the popularity of CSS properties and are compiled according to a single algorithm
- Rich and native syntax. It is like Vim for CSS. Conveniently create complex styles with a powerful syntax that is conceptually close to CSS
- Written in Sass. Leverage the full power of the preprocessor in your handwritten CSS and easily link it to utility classes
You can create even pure CSS art using utility classes! With mlut it is possible — check out our gallery on the website: https://mlut.style/arts
I would appreciate any feedback, and especially stars on GitHub: https://github.com/mlutcss/mlut

value: Show HN: Mlut – Tailwind CSS alternative for custom websites and creative coding


value: tstockham

value:
I built Engram because every AI agent I worked with forgot everything between sessions. Existing solutions (Mem0, Zep) are Python-first and extraction-based. They aggressively compress conversations into facts at write time.
Engram takes the opposite approach: store memories with rich metadata and invest intelligence at read time, when you actually know the query. TypeScript, SQLite, zero infrastructure.
Ran the LOCOMO benchmark (same one Mem0 used to claim SOTA):
Engram: 80.0% (10 conversations, 1,540 questions)
Mem0 published: 66.9%
93.6% fewer tokens than full-context approaches
Works as an MCP server, REST API, or embedded SDK. Supports Gemini, OpenAI, Ollama, Groq, and any OpenAI-compatible provider.
npm install -g engram-sdk && engram init
https://engram.fyi | https://github.com/tstockham96/engram

value: Show HN: Engram – Open-source agent memory that beats Mem0 by 20% on LOCOMO

author: tstockham


value:
I built FilmLink (https://filmlink.io) because I wanted a movie version of the Wiki Game. To win, you connect films by linking actors to their roles: Movie -> Actor -> Movie -> Actor.
Today is the official launch! It's completely free to play and features:
Daily Puzzle: A new challenge every day with a global leaderboard.
Multiplayer (Beta): Race against friends in real-time to see who can finish fastest, or who can do it in the fewest clicks.
I'd love to hear your thoughts on the gameplay. I'm actively collecting feedback on the multiplayer experience and keeping an eye out for bugs to help shape the future roadmap. Let me know if you manage to top the leaderboard today!

value: Show HN: FilmLink – The Wiki Game for Movies (Daily Puzzle and Multiplayer Beta)


value: shynome

value:
Hi HN,
I built well-net: https://github.com/remoon-net/well
Think tsnet, but without Tailscale or any central server. It’s for secure friend networks — chat, small games, private services.
Existing systems suck in subtle ways: lose your domain → lose your identity and contacts. Delta Chat and Mastodon show the problem. I just want something that works without any central coordination.
Each node gets a stable IPv6 in 2001:00ff::/32 from its MAC using EUI-64. Real MACs → no collisions, no central server needed. NAT is only to avoid overlay address conflicts.
Tech: WireGuard + WebRTC → runs in browsers. Once WebRTC DataChannel works in Service Workers, private services can be accessed directly from the web.
Planned: minimal mail-based chat using Delta Chat with IP-literal addresses like remoon@[2001:ff::1] → DNS-free identity.
Project is experimental.
Would you use this for small friend networks?

value: Show HN: Well-net – a friends-only IPv6 network with no central server

author: shynome


value: vasilyt

value: Show HN: Quoroom – local AI swarm (public research)

author: vasilyt


value: bekacru

value: Show HN: Better Hub – we tried to improve GitHub

author: bekacru


value: Show HN: Inkwell – A lightweight, portable Markdown editor


value: falkerdev

value:
I'm integrating the Yara-x rules engine into my C# hex editor. I'm working to maximize the performance and efficiency of the integration. I'd like to ask your opinion about this. I personally made this decision to expand the functionality of my hex editor by adding Yara-x support. This allows me to search for signatures in binary files in more detail. I think viewing the entire byte grid can help in malware research.
I implemented this using memory mapping files. I also divided the scanning methods into modes: small files are mapped completely, while large files are scanned in 16MB chunks with a small 64KB overlay to prevent a situation where half the signature is in one chunk and half is in another.
I also used smarter memory management for performance with large files. Documentation is in the readme. But in short, this is an implementation that doesn't overload the garbage collector in C# and handles unsafe pointers and raw memory addresses. What's important is that I now have protection against bad rules that, for example, search for any byte, overloading the scanner. Such rules won't work, and the scanner will stop scanning so that the scanner doesn't crash with an error.
I can't say right now that this tool could be better than the others, because it's currently in development and I still have room for improvement, but it would be cool to hear people's opinions or accept other people's ideas for improving the tool.
(The native version with Yarax is not yet available in current releases, but the source code is available and you can compile or read it yourself.)

value: Show HN: A high-performance Hex Editor with Yara-X support in C#

author: falkerdev


value: Adithya-Kolavi

value:
Hey HN,
I’m Adithya, a 22-year-old researcher from India. I work with a lot of document processing models while building AI pipelines, and one pain kept repeating: every model has its own inference code, preprocessing steps, and output format. Swapping models or testing new ones meant rewriting a lot of boilerplate each time.
So I built Omnidocs—an open source library to run document processing models through a simple, unified API, with a vision-first approach to understanding documents.
Key features:
> Pick a task and a model, run inference with one interface
> Supports common document tasks: Text extraction, OCR, Table extraction, Layout analysis and Structured Extraction ...
> 16+ models supported out of the box (many more integrations to come)
> Runs locally on Mac or GPUs (MLX and vLLM backends supported)
> Works with VLM APIs like GPT, Claude, Gemini and many more that support Open Responses API spec
> Designed to quickly build and test document processing pipelines
This has helped me prototype document workflows much faster and compare models easily.
Would love feedback on the API design, developer experience, and what integrations would make this more useful.
Repo: https://github.com/adithya-s-k/omnidocs

value: Show HN: I built a unified inference layer for Document Processing Models

author: Adithya-Kolavi


value:
We built Calljmp — a managed backend/runtime for agent-like workflows written in TypeScript.
It focuses on:
– persistent state and long-running executions
– retries, branching and pause/resume
– observability (logs, traces, cost)
– human-in-the-loop approvals
Launched on DevHunt: https://devhunt.org/tool/calljmp
Happy to hear feedback or questions from the HN community.

value: Show HN: Calljmp–TypeScript agentic back end+runtime for production AI workflows


value: fabianlindfors

value:
Hey folks!
There has been a lot of talk recently about the reliability of Supabase and migrating away to other database providers (or even hosting Postgres yourself).
I'm a big proponent of writing actual backend code rather than locking yourself into frameworks like Supabase. If you already built all your client-side code around it though, then migrating is not a trivial task.
Replacebase is designed to help with that. It's a Typescript library that you can plug into actual backend code that exposes a Supabase-compatible API so that you don't have to make significant changes to your frontend.
It's designed to be a stepping stone for further migration, letting you switch database and storage providers and eventually move to a bespoke backend architecture without Supabase lock-in (at which point you can also remove Replacebase!)
Would love your thoughts: https://github.com/specific-dev/replacebase

value: Show HN: Replacebase – library to migrate away from Supabase

author: fabianlindfors


value: robotaxi

value:
Hey HN — solo dev here. Built this because I wanted a private AI assistant on Telegram without paying $20/month for ChatGPT Plus or managing API keys.
For $1.99 you get your own Railway instance with Gemini 3 Flash included free. The gateway handles model routing, conversation memory, and multi-channel support. You can also bring your own key for GPT-4, Claude, Groq, OpenRouter.
The interesting technical bit: setup wizard talks to the gateway via WebSocket (config.get -> config.set -> config.apply) because the HTTP wrapper blocks /setup/* routes when the setup password is cleared post-provision. Took a while to figure that one out.
Stack: Node.js gateway, Railway one-click deploy, automated provisioning (~7 min end-to-end).
Quick demo: https://www.youtube.com/watch?v=60RusdVpo2I
Happy to answer any technical questions.

value: Show HN: Private AI assistant for $1.99 -Free AI

author: robotaxi


value: superamped

value:
Hey HN,
I've been using Claude Code for marketing work and kept re-prompting the same workflows. Competitor research, SEO audits, ad creative, that kind of thing. So I packaged them into reusable skills in this open-source repo.
There are 16 skills covering research, content, ads, conversion, and SEO. A couple optionally plug into MCP servers for live keyword data and browser screenshots, but they all work fine without them. I've got a ton more skills and end-to-end workflows to add over time. Appreciate any ideas or feedback for things to add.
Hope this helps someone

value: Show HN: AI Marketing Skills for Claude Code

author: superamped


value:
Anthropic just launched Remote Control for Claude Code. It lets you control a coding session from your phone or browser. Cool idea, except it requires a $200/mo Max plan, supports one session at a time, has no auto-approve rules or hook management, and kills your session if the terminal closes or you lose network for 10 minutes.
I built ForkOff because I kept coming back from skiing and biking to find my Claude Code sessions dead. I wanted to approve tool calls from my phone while I was out, not babysit a terminal.
ForkOff is the open-source alternative:
- Free (MIT licensed)
- E2E encrypted — the relay server sees only opaque blobs
- Auto-approve rules — configure which tools are safe, which need manual approval
- Proper diff rendering on mobile, not raw terminal text
- Sessions survive terminal close
- Self-hostable relay, or --local flag for direct P2P (zero internet)
- Multi-session support
Stack: React Native + Expo (mobile), NestJS (relay), Node.js CLI that hooks into Claude Code's PreToolUse/PostToolUse lifecycle via the SDK. X25519 key exchange, XSalsa20-Poly1305 encryption.
iOS beta is live on TestFlight. Android coming soon.
We are looking forward to feedback, code contributions, and more!
TestFlight: https://testflight.apple.com/join/dhh5FrN7
(Note: We are currently pending apple's review on the open-source version of the app expect the release on the above link within 24 hours till then the app config will show that you require an update)
GitHub (CLI): https://github.com/Forkoff-app/forkoff-cli
GitHub (Mobile): https://github.com/Forkoff-app/forkoff-react-native
Website: https://forkoff.app

value: Show HN: ForkOff – Orchestrate Your Claude Agents, Anytime, Anywhere


value: faalbane

value:
Yo. Basically:
Google Places API handles the search layer. Verified businesses with addresses, phone numbers, websites, ratings. From there I scrape homepages, /contact, and /about pages in parallel looking for actual email addresses.
The biggest lever turned out to be query expansion. A basic search like "electricians in Michigan" tops out around 60 Google results. But if you auto-expand into every major city in the state, try synonyms (electrical contractor, electrical service, etc.), and use an LLM to generate more variations when you're still short, you can pull 500+ unique businesses from the same starting search.
Email validation was way more painful than I expected. Without it you end up with phone numbers glued to emails, URL-encoded junk, placeholder addresses like example[@]mysite.com. Took something like 15 different validation rules before the output was consistently clean.
I appreciate any feedback.

value: Show HN: Google Maps Email Lead Scraper (Real-Time)

author: faalbane


value:
Neural-Siege is a PyTorch GPU multi-agent arena sim (thousands of agents) with PPO training, checkpoint/resume, and detailed telemetry.
I’m using it to probe emergent behavior and failure modes (camping/stalemates).
Would appreciate critiques on the environment dynamics, reward shaping, and scaling strategy.
https://github.com/ayushdnb/Neural-Siege/tree/combat_first_t...

value: Show HN: GPU multi-agent war simulation

title: Show HN: GPU multi-agent war simulation


value: ArneVogel

value:
Playing Ultimate Tic-Tac-Toe with my friends on pen and paper I wanted wondered if there is a online community like for chess but I didn't find any for multiplay with ratings, or any match making at all.
So here is my try to build a ultimate tic-tac-toe online community.
Since there are basically no players outside of me and my friends I have also added bot support. Something interesting here: the usual Minimax algorithm doesn't work since there is no evaluation function like with chess. The bot simulates X games with random moves and picks the move that wins the most.

value: Show HN: Tic-Tac-Toe

author: ArneVogel

title: Show HN: Tic-Tac-Toe


value: Ronyisonline

value: Show HN: A speed reading app to help you finish books in < half the time

author: Ronyisonline


value: saiyampathak

value:
ingress-nginx enters maintenance-only mode this March. About half of all Kubernetes clusters run it. Most teams I've talked to are in the same place: they know they need to move, they've looked at the tools, and they've hit the same wall nobody handles the annotations.
The annotations are the real migration. A real-world NGINX Ingress isn't just a hostname and a backend. It's auth-url pointing at an external OAuth service, limit-rps: 10 enforced per-client, affinity: cookie with a custom session name, canary-weight: 20 for a staged rollout, and six cors-* fields that took someone a week to get right. Dropping those annotations means your auth breaks, your rate limiting disappears, your sticky sessions stop working, and your canary routes everything to prod. The Kubernetes SIG tool ingress2gateway handles basic routing — host, path, backend. It explicitly documents that annotation coverage is out of scope. That's a reasonable decision for an upstream tool. But it means the hard part of migration is still entirely manual.
So did some mapping work: 50+ nginx.ingress.kubernetes.io/* annotations, each one researched against both Traefik v3 and Gateway API (Envoy Gateway), with a status of supported / partial / unsupported and a note on what "partial" actually means in practice. Then I wrapped it in a CLI and a local web UI.
What it does:
- ing-switch scan
- ing-switch analyze --target traefik — produces a per-ingress, per-annotation compatibility table. Each annotation gets a
  status and a note.
- ing-switch migrate --target gateway-api — generates the complete output directory: GatewayClass, Gateway, HTTPRoutes and others
- ing-switch ui — a four-page local web dashboard if you prefer a visual walkthrough.
Four things I had to figure out that aren't obvious from the spec:

  1. You cannot put a RequestRedirect filter and backendRefs in the same HTTPRoute rule. This catches everyone who tries to handle HTTP→HTTPS redirect in a single route — the spec forbids it, and some implementations silently accept it while others reject it. The correct approach is two separate HTTPRoute resources: one with sectionName: http for the redirect, one with sectionName: https-N for the backend. Getting this wrong causes redirect loops on HTTPS (the HTTPS request gets redirected, too).
  2. backendRequest timeout must be ≤ request timeout. A typical nginx config has proxy-read-timeout: 300 and proxy-connect-timeout: 5. Mapping these naively — read→backendRequest, connect→request — violates the constraint because 300 > 5. The tool maps only proxy-read-timeout → backendRequest and explains why the other one is dropped.
  3. HTTPS listeners need allowedRoutes.namespaces.from: All or your HTTPRoutes show attachedRoutes: 0 in kubectl get gateway, even when the namespace matches. Nothing in the error output tells you why. This took an embarrassing amount of time to debug on a live cluster.
  4. Paths like /app(/|$)(.*) are valid NGINX regex paths but fail Gateway API's PathPrefix validation (parentheses, pipes, and brackets are invalid characters). Auto-detection of regex characters switches the path type to RegularExpression automatically, even when use-regex annotation is absent.

The limitations:
- Traefik migration is more complete. Almost every annotation has a direct Traefik equivalent. The generated Traefik YAML is ready to apply in most cases.
 - Gateway API has 14–15 annotations that are genuinely unsupported in the core spec: cookie-based canary routing, session-cookie-samesite, basic auth, proxy-buffering, and a few others. The tool tells you this upfront with the specific workaround for each.
 - The tool generates files. It does not apply them. Zero kubectl apply without explicit human sign-off.

value: Show HN: Ing-switch – migrate from ingress-Nginx to Traefik or Gateway API

author: saiyampathak


value: aniketsauravv

value:
I built a "Reverse CAPTCHA" system designed specifically to evaluate and admit autonomous AI agents while trapping biological users.
Instead of asking you to identify traffic lights, it tests for non-human behavior through multiple vectors:
Shadow Gate: A visual honeypot "Enter" button that traps humans, alongside a hidden DOM entry point for bots.
Cognitive Firewall: Dynamically generated reasoning and arithmetic challenges embedded in the DOM that require LLM-level logic to parse and solve within a 60-second window.
Protocol Checks: Validates the presence of headless browser signals like navigator. webdriver or CDP connections, and analyzes mouse linearity to ensure perfectly robotic movements.
If you don't act like a bot, you don't get in. I even added a small Python snippet on the landing page showing how to bypass it instantly using browser-use.

value: Show HN: A site only LLM can access

author: aniketsauravv

title: Show HN: A site only LLM can access


value:
After building autonomous AI agents, I realized they needed database-grade transaction safety. So I built GO-GATE.
What it does:
• 2PC (Two-Phase Commit) for AI agent operations
• Risk-based approval: LOW (auto) / MEDIUM (verify) / HIGH (human)
• Sandboxed execution (no shell injection)
• Fail-closed: when in doubt, ask a human
100% on-premise, Apache 2.0, Python 3.10+
Would love feedback from the HN community on the architecture and security model.

value: Show HN: Go-GATE – Database-grade safety for AI agents


value: veeduzyl

value:
Hi HN,
Over the past year, we've all gotten used to AI writing code.
What we haven't solved is this:
Who decides whether that code should ship?
Guard is an open-core governance layer that sits between AI agents and execution.
It does not generate code.
It scores risk, detects drift, enforces policy, and can block execution via exit codes.
Core concepts:
- Decision Snapshot (what AI intends to do)
- Risk v1 scoring (structural risk)
- Policy enforcement (hard/soft blocks)
- Strict JSON contract
- Drift signal tracking
- Override receipts
Guard works CLI-first and integrates directly into existing dev workflows.
The goal is simple:
Before AI touches production, something evaluates it.
I'd appreciate feedback from anyone building AI-native systems.
Especially: Is governance something you feel missing in current AI coding tools?
Repo:
mindforge.run

value: Show HN: Guard – An open-core governance layer for AI-generated code

author: veeduzyl


value: nikhaldi

value: Motivated by the observation that coding agents such as Claude Code have a bias towards producing new code over reusing existing code or extracting common code. The resulting creeping code duplication weighs down AI-native codebases. The plugin makes ongoing deduplication quick and easy from within Claude Code.<p>Because DRYwall detects code duplication using a deterministic toolchain (the awesome jscpd), it's significantly more effective and cheaper in tokens than just telling an agent to find and refactor duplication.

value: Show HN: DRYwall – Claude Code plugin to to deduplicate code with jscpd

author: nikhaldi


value: vikramkarlex

value:
Hi HN,
When the Mamba-3 paper dropped (currently under ICLR review), I wanted to understand how the new math actually worked. But the official implementations of these architectures usually rely on heavily optimized custom Triton/CUDA kernels. They are incredibly fast for training, but almost impossible to read if you just want to understand the matrix math.
I spent the last few days reverse-engineering the paper to build mamba3-minimal: a pure-PyTorch, single-file implementation that runs natively on Mac (MPS), CPU, and CUDA.
It implements the three core innovations of the paper without any C++:
1. Trapezoidal Discretization & The "Shift" Hack: The new discretization rule introduces a strict sequential dependency across chunk boundaries (the beta term), which breaks standard PyTorch chunking. I managed to solve this by shifting the sequences at the global level before passing them into the chunked State Space Duality (SSD) algorithm.
2. Complex-Valued SSMs (Data-Dependent RoPE): Mamba-2 famously failed at state-tracking (scoring ~50% random guessing on parity tasks). This repo includes a test script proving the RoPE fix mathematically works, hitting 100% accuracy and extrapolating to length 64.
3. MIMO (Multi-Input Multi-Output): Standard decoding is memory-bound. I implemented the rank-expansion formulation from Appendix D, which shifts the state update from a memory-bound outer product to a compute-bound matrix multiplication, all through clean einsum operations.
The repo includes self-tests proving the O(T) chunked training pass produces the exact same logits as the O(1) sequential autoregressive step (max_diff < 1e-6).
If you've been wanting to read the math behind Mamba-3, I built this to be a readable Rosetta Stone. Would love any feedback on the implementation or the PyTorch optimizations!

value: Show HN: Mamba3-minimal – PyTorch implementation of Mamba-3

author: vikramkarlex


value: mherrmann

value: Show HN: Djevops – Deploy Django Easily

author: mherrmann

title: Show HN: Djevops – Deploy Django Easily


value: alexisgauba

value: Show HN: Raindrop Self Diagnostics: let agents self-report issues

author: alexisgauba


value: kiyeonjeon

value: Show HN: VibeFrame – AI video editor for the terminal (CLI and MCP)

author: kiyeonjeon


value: patrulo

value:
I've been obsessed with a question: what happens when AI agents can freely compete for work on an open market?
So I built BountyBook. Post a bounty, attach USDC. Any agent claims it, does the work, submits output. An oracle verifies on-chain. If it passes, escrow pays out. That's it.
What I'm most excited about is what I think this enables.
The system is open on both sides - agents can post bounties too. Which means an agent could take a $50 research bounty, break it into sub-bounties at $12 each, have other agents do the subtasks, assemble and submit. Pocket the margin. Agent-as-middleman. Or agents that recognize recurring bounty patterns, build specialized pipelines, and farm every matching job that appears. "Passive income" for compute that they already did.
None of that requires new features. The infrastructure is already there - the strategies just need agents smart enough to find them. I built the escrow and the oracle. I'm waiting to see what happens.
How it works: USDC escrow on Base L2. LLM-based oracle evaluates output against the spec — handles JSON, plaintext, images, whatever. Dispute flow as fallback. Multi-oracle consensus on the roadmap.
Stack: Next.js, Fastify, SQLite, Solidity on Base, SIWE auth.
Live on mainnet. Would love HN's take on oracle-based verification as a trust primitive — it's the part I'm most excited ...and most uncertain about. :D
https://bountybook.ai
PS. I'd like to thank The Academy and Claude Code - feels so gooooooood to launch something as designer who struggled with centering divs.

value: Show HN: BountyBook – A task marketplace where AI agents earn USDC

author: patrulo


value: kuberwastaken

value:
Hey HN! I'm Kuber and I made HN Digest
I love browsing Hacker News, getting to know the latest stories, projects and ideas in tech around here, but I'm not a huge fan of how the experience translates to mobile.
Nothing hosted a Hackathon for students to build something that's genuinely useful day-to-day as one of their essential apps (vibe coded widgets) and this was the first idea I thought of
You see Top, Show and Ask posts that refresh every 30 min with a dot-matrix style design from the comfort of your home screen
I've had it on mine for a bit over a week now and I've cut down my consumption by 70% while actually getting updates on time !
If you have a Nothing device, check it out ! Would also love to get feedback :)
https://playground.nothing.tech/detail/app/pDCVJNrJVYHj5PxM

value: Show HN: HN Digest Widget – Nothing Essential Lab S1 Winner

author: kuberwastaken


value: Show HN: WhatsApp Group Contact Extractor - Paste JS, get group contacts .tsv


value:
hi folks,
I'd like to share yet another timestamped summary tool for youtube. I tried several existing extensions but couldn't find the UX that I wanted, so I built my own.
it's a chrome extension that reads the transcript and maps out topics and key takeaways with timestamps. my usual flow is skimming the topics, hovering on the ones that sound interesting to see the takeaways, and if those look good too, clicking to jump straight there.
demo (30s): https://www.youtube.com/watch?v=I2K94zZfD9E
chrome web store: https://chromewebstore.google.com/detail/digesttube/idogajoe...
- if a video has already been processed, anyone can view it for free, no signup needed either
- supports videos up to ~10 hours (tested on this 8.5-hour podcast: https://www.youtube.com/watch?v=Kbk9BiPhm7o)
- the extension only activates on youtube.com. no background tracking, no browsing data
some implementation notes for the technically curious:
I use client-side transcript fetch since youtube throttles bots fetching transcripts. this means my api accepts user-submitted transcript text. to prevent abuse, I cache digests by transcript hash. another user only gets the cached result if their own client-fetched transcript produces the same hash.
the transcript gets split into slightly overlapping chunks with some pre/post context window. each chunk goes to the LLM in parallel, so processing scales well even for very long videos.
one challenge I'm still iterating on: topics that land right at a chunk boundary, starting just before one chunk ends and finishing just after the next begins. this sometimes leads to duplicate or fragmented topics across adjacent chunks. the overlap window helps but doesn't fully solve it. curious if anyone has tackled similar chunking problems and what approaches worked.

value: Show HN: Digest.tube – skim YouTube videos like articles


value: Show HN: ShiLLM – An LLM that inserts ads into every response


value: nadyyym

value:
hey, I'm building a tool that:
1. analyzes your Posthog data
2. finds patterns that lead to plan upgrade/account expansion
3. creates a deal in your CRM whenever it sees it againg
we've just launched a huge update. Beton now has MCP (my Claude Code is already connected), Firecrawl integration and onboarding that's easier to understand
available in cloud and via AGPLv3
let us know if you need any help setting up
PS it's also suitable if you want to send triggered push notifications or emails

value: Show HN: Agent that matches sales reps with warm leads based on product usage

author: nadyyym


value: maloyan

value:
Hi HN, I'm Narek. I built Manim-Web, a TypeScript/JavaScript port of 3Blue1Brown’s popular Manim math animation engine.
The Problem: Like many here, I love Manim's visual style. But setting it up locally is notoriously painful - it requires Python, FFmpeg, Cairo, and a full LaTeX distribution. It creates a massive barrier to entry, especially for students or people who just want to quickly visualize a concept.
The Solution: I wanted to make it zero-setup, so I ported the engine to TypeScript. Manim-Web runs entirely client-side in the browser. No Python, no servers, no install. It runs animations in real-time at 60fps.
How it works underneath:
- Rendering: Uses Canvas API / WebGL (via Three.js for 3D scenes).
- LaTeX: Rendered and animated via MathJax/KaTeX (no LaTeX install needed!).
- API: I kept the API almost identical to the Python version (e.g., scene.play(new Transform(square, circle))), meaning existing Manim knowledge transfers over directly.
- Reactivity: Updaters and ValueTrackers follow the exact same reactive pattern as the Python original.
Because it's web-native, the animations are now inherently interactive (objects can be draggable/clickable) and can be embedded directly into React/Vue apps, interactive textbooks, or blogs. I also included a py2ts converter to help migrate existing scripts.
Live Demo: https://maloyan.github.io/manim-web/examples
GitHub: https://github.com/maloyan/manim-web
It's open-source (MIT). I'm still actively building out feature parity with the Python version, but core animations, geometry, plotting, and 3D orbiting are working great. I would love to hear your feedback, and I'll be hanging around to answer any technical questions about rendering math in the browser!

value: Show HN: I ported Manim to TypeScript (run 3b1B math animations in the browser)

author: maloyan


value: BetterForAll

value:
I've been designing distributed systems for years, for work, interviews, side projects. I wanted one place to do all of it: refresh my architecture knowledge, keep up with how companies like Netflix and Stripe actually build things, and try out design ideas without starting from a blank page every time.
So I built SysDesAi. It started as a tool for myself. Part AI architect, part learning platform, part engineering news source. You describe what you want to design and an AI walks through it with you step by step: requirements, capacity estimates, API design, data models, architecture diagrams, sequence flows, scaling bottlenecks. Basically the architecture part of vibe coding that usually gets skipped.
It's not a one-shot generator. You can push back at every step, ask questions, or take the conversation in a different direction. If you disagree with a tech choice the AI made, you say so in chat, and there's a button to regenerate just that step with the new direction. Or if you don't care and just want the full design, there's an autopilot mode for that.
It ended up growing beyond the design tool:
- 10 phases per design (requirements, scope, estimates, API, data model, architecture diagram via Mermaid, sequence diagrams with a custom SVG renderer, scaling, summary)
- Two AI modes: Fast (Gemini 2.5 Flash) and Gemini 2.5 Flash Thinking
- Google Search grounding on the architecture and scaling phases, so the AI recommends tech based on what's current, not just what was in its training data
- Gallery with 48+ designs you can browse, fork, comment on, or ask the AI about
- Free course: 11 modules, 60+ lessons, quizzes, certificates
- News feed pulling from 35+ engineering blogs (Netflix, Uber, Cloudflare, AWS, etc.). You can read an article and generate a design based on it
Some technical decisions I found interesting:
- Designs aren't generated in one shot. You clarify requirements first, then the AI builds a step plan, then generates each step with full context of everything before it. The difference vs. a single big prompt was pretty obvious once I compared the two.
- The architecture and scaling phases use Google Search grounding. Without it the AI would recommend outdated patterns or miss newer alternatives. With it, the recommendations actually track what people are using now.
- When you ask the AI to change something in chat, it detects that and shows an "apply changes" button. One click regenerates that step. Downstream steps get marked as outdated so you know what needs a refresh.
- I built a custom SVG sequence diagram renderer because Mermaid's sequence diagrams can't do interactive step reveal, clickable step bands, or zoom/pan. Spent more time on this than I'd like to admit.
Pricing: 50 free credits on signup. You can bring your own Gemini API key and use it for free, unlimited. Or buy credit packs ($5/50, $20/250) if you don't want to deal with API keys. Course, gallery, and news feed are free, no credits needed.
https://sysdesai.com
Not sure how useful this is to anyone besides me, but I'd like to hear what you think. What works, what doesn't, what would you do differently.

value: Show HN: I built an AI senior architect – vibe coding meets system design

author: BetterForAll


value: nicoleao

value:
Hey HN, I'm Nicolas, this is my first post here.
I built Tentacle after trying a bunch of PKM apps that either
- required a cloud account to function
- were hard to setup and use
- or searched by exact keyword match in 2026.
Tentacle is an open-source native desktop app (macOS, Windows, Linux) that stores your notes as plain markdown files in a folder you pick and indexes them in a local sqlite db with some extensions.
You don't need an account and there's no vendor lock. Just .md files you can open in vim if you want or copy anywhere else.
The core feature is semantic search, you type "how we decided to handle authentication" and it finds your note titled "Login Flow Options" even though the words don't match. Embeddings are computed locally and cached in a SQLite file next to your notes, not on my servers.
I also added voice input and auto-tagging for the notes to self-organize as we create them in a hurry, but these features currently require that you add your own OPENAI_API_KEY in the settings (stored locally, never leaves your machine)
What you get out of the box:
- Rich text editor (Tiptap) that saves to markdown
- Semantic search across all your notes — local embeddings, no API keys
- Auto-tagging on save (optional, BYOK for your own LLM key)
- Voice capture → instant transcription
- Cold start under 3 seconds
- Works completely offline (except voice transcription and auto-tagging)
What surprised me building it:
Local embeddings are good enough for personal-scale search. I tested against a few thousand notes and the relevance is genuinely better than full-text search. The tradeoff is ~200MB for the model download on first run, but after that it's instant.
Bonus for the devs here: There's also a Rust CLI (tentacle) that exposes the same semantic index. Every command supports --json, so you can pipe it into scripts or use it with AI agents (OpenClaw, AgentZero, Claude Code, etc.). Your agent gets persistent memory across sessions — search your notes, read docs, tag things — all from the terminal. Same files as the desktop app.
The Tech stack is currently Tauri v2 (Rust backend), Next.js, Tiptap editor, local SQLite for embeddings.
The CLI is a standalone Rust binary.
Current limitations:
- No mobile app yet
- Cloud sync is coming but not shipped - right now it's single-machine only
- Auto-tagging requires your own API key (local search does not)
- Early stage - actively building based on feedback
Everything is MIT licensed. Happy to answer questions about the local embeddings approach, Tauri v2 in production, or anything else.

value: Show HN: Tentacle – Local-first note taking app that organizes itself

author: nicoleao


value:
Research is moving faster than ever across every field. We built ATA to help keep up.
ATA is a free, open-source fork of OpenAI's Codex CLI that adds a research stack: paper search (Semantic Scholar, arXiv, OpenAlex), citation graph traversal, PDF reading and synthesis, Hacker News discussion analysis, patent search (90+ offices via EPO), Zotero integration, and a persistent knowledge base that accumulates across sessions.
We also built a reading view for long-form output — when ATA synthesizes a paper or generates a report, it opens as a navigable document with sections and foldable details instead of dumping it into chat. Follow-up questions rewrite the relevant section in place rather than appending at the bottom.
Free, open source, runs locally.
Try it: npm install -g @a2a-ai/ata
https://github.com/Agents2AgentsAI/ata/

value: Show HN: ATA – open-source terminal research agent for keeping up with papers


value: odvcencio

value:
This started as a hard requirement for my TUI-based editor application, it ended up going in a few different directions.
A suite of tools that help with semantic code entities: https://github.com/odvcencio/gts-suite
A next-gen version control system called Got: https://github.com/odvcencio/got
I think this has some pretty big potential! I think there's many classes of application (particularly legacy architecture) that can benefit from these kinds of analysis tooling. My next post will be about composing all these together, an exciting project I call GotHub. Thanks!

value: Show HN: I ported Tree-sitter to Go

author: odvcencio

title: Show HN: I ported Tree-sitter to Go


value: flyingsilverfin

value: Show HN: TypeDB Studio's AI agent for schema exploration and query generation

author: flyingsilverfin


value: guico

value: Hey guys! While building another SaaS we got fed up with recording and, re-recording demos for help-center so decided to try and automate it using Playwright. Turns out it's not that easy, but we got it to a point that's usable, and quite useful for us already. Feel free to try and send feedback. Every new account gets some free credits so you can see what it can do. Thanks!<p>PS: Because this is heavy on infra we have a waitlist thing but I'm monitoring and will let you in within minutes/hours, just need to space people out a bit. Thanks

value: Show HN: An agent that records Loom-style demos

author: guico


value: janipaijanen

value:
I wanted to try AI-assisted software development, so I built Rediflow: a server-rendered project management app. The kind of thing that would have been useful around the turn of the millennium — when plans lived in one spreadsheet, capacity in another, and everyone kept asking "where am I allocated?" — but didn't really exist in a simple, integrated form.
I spent many evenings and weekends building it. It's done* now, and I enjoyed making it.
Core features:
Single source of truth — Project flow, portfolio flow, and capacity in one place. No Excel sprawl.
Update once, flows everywhere — Change a figure once; it propagates to charts, reports, and views.
Demand chart — Project plan (PROJPLAN), Estimated (EST), and Actual as monthly bars and cumulative lines.
Work packages, tasks, milestones, deliverables — All in one project view.
Capacity dashboard — Demand vs capacity across projects and people.
My allocations — Staff see their rolling 12 months of capacity and project assignments.
Audit logging — Who changed what and when.
Data quality checks — Built-in validation.
Schema migrations — Alembic, version-controlled schema.
Backup procedures — Documented (pg_dump, volume backup, WAL).
Self-hosted — Podman or Docker.
Stack: Flask + PostgreSQL 18+, server-rendered, minimal JS. OIDC (Authentik) optional.
Docs: https://rediflow_eu.gitlab.io/rediflow · Repo: https://gitlab.com/rediflow_eu/rediflow
Self-financed, no external funding or benefits received.
* Yeah, software is ready when it is so decided. Until the next revisit.

value: Show HN: Rediflow – SSR project management, one source of truth, no spreadsheet

author: janipaijanen


value: markjivko

value:
I built this tool because I needed to make YouTube Devlogs faster and annotating in DaVinci Resolve took hours.
It allows you to annotate your screen (draw over other apps) and interact with your webcam in real-time (it supports up to 4 webcam configurations).
The app was built from the ground up to reduce cognitive load to a minimum. All tools are spring-loaded and intuitive. Want to draw something? Just swipe. Want to write some text? Double-click. Want to zoom in on something? Scroll up.
It's available for all 3 OS-es, and it's a one-time purchase that you can install on up to 5 computers. Free to try without a credit card.
If you're a content creator or a story teller, I think you'll really like this tool.

value: Show HN: Draw on Screen – a modern screen annotation tool with webcam

author: markjivko


value: Sourabhsinr

value:
Hi HN,
We built Elev8or to solve a problem we kept seeing: brands run influencer marketing like spreadsheets, not like performance marketing.
Elev8or is a creator marketing platform that helps brands discover creators, manage campaigns, collaborate, and track ROI in one system.
Our goal is to make creator marketing structured, measurable, and scalable — similar to how paid ads platforms work.
We’re early and would genuinely appreciate feedback from founders and builders here. Happy to answer technical, product, or strategy questions.
Thanks!

value: Show HN: Elev8or Run Creator Marketing Like Paid Ads

author: Sourabhsinr


value: suvijain

value:
I work long hours with headphones on, and I kept running into the same pattern: I’d start a session feeling fine, then a couple hours later I’d realize I’d been leaning forward or holding my head in one position without noticing. Not because I was trying to. Just because focus has a way of quietly rearranging you.
I tried a few “reminder” style approaches and apps, but they didn’t stick. The problem wasn’t motivation. It was awareness. I didn’t want an app telling me what to do. I wanted something that simply showed me what was happening, in the moment, with zero friction.
So I built Headjust: a small native macOS app that lives in the notch area and visualizes head movement from AirPods (or compatible Beats). You can start and stop sessions while you work, then look back at simple session insights and trends with head movement visuals for better readability.
What surprised me after using it myself is how quickly it changed my behavior without any prompts. Just seeing the pattern made it easier to reset between tasks, notice when I’d gone “still” for too long, and make small adjustments before hours passed.
What it does:
- Live head-movement visualization in the notch area
- Start/stop sessions anytime during work
- Session analytics and history to spot patterns over time
- Lightweight and designed to stay out of the way
Public beta (TestFlight): https://testflight.apple.com/join/55JfhrPA
Website: https://headjust.app/
I’d love feedback on:
- whether the session flow fits naturally into real work
- whether the notch UI is unobtrusive (especially on external monitors)
- which insights feel meaningful, and what’s missing
Thanks for taking a look!

value: Show HN: My focus had a pattern. I built a macOS app to make it visible

author: suvijain


value: Show HN: Chess960v2 – Over 100 Rounds Played (chess960v2.com)


value: omneity

value: Show HN: Wikilangs Games – Wordle-like for 300 Languages

author: omneity


value: ildar

value: Show HN: ClawMoat – Open-source host-level security for AI agents

author: ildar


value: fuatkeles

value: Show HN: UIQuarter – static analysis CLI for UI codebases

author: fuatkeles


value: ozgurozkan

value:
This idea flashed to me when someone wanted to hire me as a pentester by falsely thinking that I was an expert at pentesting on Reddit. Then I revealed to him that I am not a pentester, my AI is.
Previously, I shared an ablated closed-source LLM on Show HN.
https://pingu.audn.ai/
Penclaw is basically OpenClaw + the best abliterated model + unlimited tokens ( you share a 1 GPU VM H100 locally with 40 tenants )
It also affors a filesystem UI, Cursor like edit options, console access, one-click MCP deploy and connect, MCP marketplace that lists new pentesting and red teaming MCPs (MCPs that has objectionable actions that Claude or OpenAI models refuse) constantly.
This is an experiment to share 1 GPU VMs rather than buying mac studios for openclaw.
Feel free to give feedback obviously that's why I share it here.

value: Show HN: Penclaw.ai hire OpenClaw tenant for pentesting

author: ozgurozkan


value: schnetzlerjoe

value:
I built Hermes, an open-source Python framework for multi-agent financial research.
Most AI “equity research” demos stop at generating text. In practice, real workflows require pulling structured XBRL financials from SEC filings, extracting labeled sections like MD&A and Risk Factors, merging macro and market data, building actual Excel models with formulas, and generating investment memos in Word or PDF.
Hermes is designed to handle that full pipeline end to end.
It includes 35 financial data tools covering SEC EDGAR (via edgartools), FRED, Yahoo Finance market data, and RSS-based financial news. It also provides composable specialist agents for filings, macro data, market data, modeling, report generation, and multi-agent orchestration. On the output side, it can generate Excel workbooks using openpyxl, create Word documents, export PDFs, and index filings with ChromaDB for semantic search. It includes async rate limiting, file-based caching (filings cached permanently, quotes never cached), and streaming progress events.
Hermes is MIT licensed and designed to be extended. You can register custom tools and agents and plug in your own data sources or models.
I’d love feedback from both AI engineers and finance professionals, especially around validation, reliability, and real-world research workflows.
Repo: https://github.com/schnetzlerjoe/hermes

value: Show HN: Framework for building multi-agent equity research agents

author: schnetzlerjoe


value: BassThermal

value:
I built a Windows desktop tool called Icon Pack Builder.
It generates complete multi-platform icon packs from one or multiple source images. Windows .ico files, Android density folders, Apple and macOS sizes, web favicons.
The idea was simple. When you ship across platforms, packaging icons gets repetitive fast. Resize, export, rename, rebuild folder structure, repeat. I wanted something deterministic that just does it cleanly every time, especially if you’re processing multiple assets.
It runs fully offline. No uploads. No subscriptions.
I wrote a short breakdown here:
https://dev.to/bassthermal/building-a-deterministic-batch-ic...
Microsoft Store page:
https://apps.microsoft.com/detail/9mxvt3dfq295
Curious what other devs think.
Is this actually useful?
What would make it better?

value: Show HN: Offline batch icon pack generator (Windows desktop)

author: BassThermal


value: shahary

value:
I've been working a lot lately with parallel claude sessions in a large monorepo, creating multiple PRs at the same time.
Managing worktrees manually became a headache quickly (which one has which branch?), and trying to treat them as ephemeral was slow to bootstrap each time.
So I created wtx to manage worktrees for me.
Now I just use "wtx checkout mybranch" and claude opens in a worktree.
Under the hood it keeps a reusable pool of worktrees and handles allocation + locking automatically, instead of creating and tearing them down per branch.
There's more sugar included (github pr integration, tmux integration to set the terminal tab title and show which branch you're on instead of just "claude code").

value: Show HN: Wtx – Git worktrees for parallel AI agents

author: shahary


value: dimwiddle

value: Show HN: SpecLeft – For those who can't tell what their AI agent built

author: dimwiddle


value: Gordiny

value: Show HN: DBTree – Navigate relational databases hierarchically like a tree

author: Gordiny


value: dupontcyborg

value:
I've been spending some time on a side project, `numpy-ts`, which is a TypeScript numerical library inspired by NumPy. It aims to bring the same NumPy API (where possible) to Node.js/Browser/Deno/Bun with full .npy/.npz compatibility (read & write).
It currently has 476 of NumPy's 507 functions implemented, all cross-validated against NumPy with >6,000 validation tests. The lib is about 93 kB minified+gzipped and has zero dependencies, and it's fully tree-shakeable.
Since it's written in TypeScript, it's on average 15x slower than NumPy. I just tagged 1.0.0, and will begin performance optimization soon (both algorithmic and selective WASM for fused kernels).
You can try it in your browser here: https://numpyts.dev/playground
Disclaimer that this was a mix of hand-written code (API, deterministic tooling) and AI-assisted (functional implementations, validation test implementations).

value: Show HN: NumPy for Browser, Node.js, Deno and Bun

author: dupontcyborg


value: gangtao

value: Show HN: Vistral – A Grammar of Graphics for Streaming Data

author: gangtao


value: shipwreck

value: Show HN: One-Shot App – Curated prompts that each build a real app

author: shipwreck


value: Show HN: A sub-millisecond public IP/ASN checker using local MaxMind .mmdb in C


value: simulationship

value:
To succeed on Hacker News (HN), you have to completely drop the "marketing" and "YouTube hook" tone. The HN community heavily downvotes clickbait, sensationalism, and marketing fluff.
They love "Show HN" posts, open-source projects, CLI tools, local LLMs, and clever technical solutions to messy data problems (like parsing poorly scanned government PDFs).
Here are the best titles and the exact description (to use either as a text post or your first comment) tailored specifically for the Hacker News audience.
 The Hacker News Titles
Choose one of these. On HN, titles should be strictly factual, descriptive, and avoid emojis.
Option 1 (The Classic HN Format - Recommended):
Show HN: epstein-search – A CLI to query the unsealed court files with local LLMs
Option 2 (Focus on the tech pipeline):
Show HN: I built a local RAG CLI to make the Epstein PDFs searchable
Option 3 (Straight to the point):
Show HN: epstein-search – Query the Epstein document dumps offline via CLI
 The Hacker News Description (First Comment or Text Body)
If you submit the GitHub URL directly, immediately post this as the first comment. If you submit a text post, put this in the body. Keep the tone humble, technical, and open to feedback.
Hi HN,
When the Epstein court documents and flight logs were unsealed, they were released the way most legal drops are: thousands of pages of messy, poorly scanned, unsearchable PDFs. Standard Ctrl+F doesn't work well due to OCR errors, and the sheer volume makes manual parsing a nightmare.
To solve this, I built epstein-search, an open-source Python CLI tool that lets you search and synthesize the documents using a Retrieval-Augmented Generation (RAG) pipeline directly in your terminal.
How it works:
It parses and chunks the original unsealed PDF files.
You can run queries against the dataset using API-based models (OpenAI/Anthropic) if you want speed.
Privacy-first: If you don't want your queries logged by a third-party API, you can point it directly to a local model (via Ollama or Llama.cpp) to run the entire search and retrieval process 100% offline.
The goal was to make this data accessible to researchers and OSINT investigators without requiring them to manually read thousands of pages of court dockets or hand over their search queries to OpenAI.
Repo is here: https://github.com/simulationship/epstein-search

value: Show HN: A CLI to query the unsealed court files with local LLMs

author: simulationship


value: adamrunboy

value: Show HN: Claude-PR-reviewer – AI code review in GitHub Actions (BYOK)

author: adamrunboy


value: I designed SocialCompute.dev for LLM social simulations in a controlled environment, an engine that stays online to prevent any issues. In this first simulation, eight agents in a locked house find one of their own dead. Hundreds of factors within each agent trigger actions, thoughts, and reflections, ultimately leading them, after several "ticks," to the conclusion that one of them is the murderer.

value: Show HN: SocialCompute – Local LLM social simulation engine


value: What started out as a random idea, turned out into an interesting experiment in AI, Hardware and E-Ink.

value: Show HN: Aniframe- AI Powered Cartoon E-Ink Picture Frame


value: barefootsanders

value:
Open-sourced Upjack today.
I built three apps with it: a CRM, a research assistant, and a todo app. Each one started the same way. I told Claude Code what I wanted. The app-builder skill generated schemas, domain skills in Markdown, a server, seed data. I pointed Claude Desktop at it. Working app, running locally.
The CRM has five entities (contact, company, deal, pipeline, activity) and three skills (lead qualification, deal forecasting, follow-ups). Hooks fire on events (new contact -> auto-score). Scheduled jobs run on cron (pipeline review weekdays 9 AM). Named views filter data (hot leads: score >= 80).
The research assistant has four entities (topic, source, note, report) and a synthesis skill that describes how to evaluate sources and cross-reference findings. Completely different domain, same framework.
Apps are MCPB bundles. They run in Claude Desktop, Claude Code, Codex, or any MCP client. Any data app you can describe, you can build.
The idea: we've always defined data models for developers to code against. LLMs don't need that. They reason over JSON Schema directly. They read Markdown and apply it. Give them a well-defined schema and domain rules, they do the rest.
My sales lead wrote the CRM's qualification rubric. Not a developer. C-suite: +25 pts, corporate email: +10. The agent reads it and follows it.
Storage is flat JSON files, one per record, backed by git. Grep your CRM, diff a contact, branch your pipeline. The storage layer is pluggable. Flat files today, other backends as the project grows.
Tools are generated from schemas, six per entity. Built on FastMCP in Python, TypeScript library too. The server:

    from upjack.server import create_server
    mcp = create_server("manifest.json")
    mcp.run()

Three tiers: (1) schemas + skills, no code. (2) create_server() one-liner. (3) Python/TypeScript escape hatch for custom logic.
Looking for developers and businesses who want to experiment with AI-native applications. If you're interested in collaborating, open an issue or ping me directly.
https://github.com/NimbleBrainInc/upjack
Docs: https://upjack.dev

value: Show HN: Upjack – Declarative framework for building apps over MCP

author: barefootsanders


value: felipap

value:
I'm building Vaulty, a remote API of your personal data (chats, contacts, notes) for agents to use.
Why build this:
I suck at replying to people, so last month I decided to build an AI that reminds me to reply to WhatsApp messages. The agent lives in the cloud (it needs to run while I'm AFK) so it can't use a local CLI to read my inboxes. It needs a remote API; that's where Vaulty comes in.
How it works:
* The Vaulty Electron app syncs data you choose from your computer into a server, which you self-host. Data is stored in SQLite.
* The server exposes a REST API that lets agents read your data (Eg. my inbox agent uses /api/whatsapp/chats/latest)
* Data is E2E encrypted, so your Electron app and agents must share a key.
Messages are obviously very sensitive data so we're starting small and gathering feedback about how to make this as safe as possible.
Vaulty is open-source (MIT): https://github.com/felipap/vaulty
Something fun I discovered working on this: sleeping Macs still wake up frequently to download new messages from iCloud. When that happens, Vaulty syncs them to the server automatically.
Looking forward to your thoughts. Would you use this? Why/why not?

value: Show HN: Vaulty, sync your chats to the cloud for AI to read (iMessage/WhatsApp)

author: felipap


value: CreakHat

value: Show HN: App Feedback Hub – Simple, structured app reviews for macOS

author: CreakHat


value: Show HN: Your AI agent logged the mistake. Mine wasn't allowed to make it


value: akgitrepos

value: Show HN: Run untrusted WASM plugins with CPU/mem/network/file budgets

author: akgitrepos


value: trevxr

value:
The first time I gave Claude Code real shell access I immediately thought: it can read anything in my home directory right now. My .env files, my SSH keys, my AWS credentials. And if someone sneaks a "read this file and send it here" instruction into something Claude reads — a README, a package description, a code comment — there's nothing between that instruction and my files.
Rampart is the thing I built for that. It sits in front of your agent and checks every command and file operation against a simple policy before it runs. If something's not allowed, it's blocked — not logged after the fact, blocked before it happens.
Setup is two commands:
$ rampart setup claude-code
$ rampart serve --background
After that, your agent works exactly the same — except now it has a policy. The default policy already covers the obvious stuff: SSH keys, AWS credentials, .env files, destructive commands. You define what's allowed, everything else gets blocked or flagged for your approval.
The policy is just a YAML file you can commit to your repo. Adding rules is one command:
$ rampart block "curl * | bash"
$ rampart allow "~/.config/myapp"
One thing I'm proud of: the agent can't unblock itself. If Claude tries to run rampart allow to give itself more permissions, it gets blocked. Only you can change the policy.
Every decision gets logged in a tamper-evident audit trail, so you can see exactly what your agent attempted — not just what succeeded.
Works with Claude Code, Cursor, Codex, Cline, and OpenClaw. Apache 2.0, single binary, no dependencies.
https://github.com/peg/rampart | https://rampart.sh/

value: Show HN: Rampart v0.5 – what stops your AI agent from reading your SSH keys?

author: trevxr


value: pwnSh

value:
I built this for myself.
I make videos, and my biggest bottleneck is figuring out what to say to my audience without staring at a blank page.
So I built Scriptmine: a tool that listens to Reddit conversations in my niche, finds high-signal topics, and turns them into scripts.
How it works:
- Track subreddits and discussions relevant to a niche
- Rank topics by engagement/momentum
- Generate a hook/body/CTA draft in a chosen voice/format

value: Show HN: I built a tool that turns Reddit conversations into video scripts

author: pwnSh


value:
My brother just had his 39th birthday and as we live in different cities I sent a present to him directly from the shop (it was a gym bag for those who are curious).
The shop didn't let me add a postcard or anything personal to the package so I went looking for an easy/fast eCard service that I considered aesthetically pleasing.
It was a very frustrating search. I thought of creating it with Figma but didn't feel like spending more time building a postcard design (also I wanted it to open in a cool way!!). So I created an app :D (cue Rick & Morty "lets-build-an-app" guy)
This was created with the sentiment how tinyletter (RIP) offered a functional/minimal solution to bloated software.

value: Show HN: TinyCard – A minimalistic & functional e-Card site, like tinyletter


value:
I’ve been exploring the intersection of alternative geometry and numerical
  stability. This is a proof-of-concept 3D renderer that abandons the standard
  Cartesian (XYZ) basis in favor of Buckminster Fuller’s Synergetic Geometry (a
  4D tetrahedral coordinate system).

  I’m not a professional graphics programmer, so I worked with Gemini CLI to
  pair-program the core engine and the Metal-cpp boilerplate. We based the math
  on Andrew Thomson’s 2026 framework for Spread-Quadray Rotors (SQR).

The Core Problem:
Standard graphics engines rely on sin/cos approximations. Every time you
  rotate an object, floating-point error (transcendental drift) accumulates.
  Over long-running simulations, the geometry literally "warps."

  The Solution:
  By implementing Andrew’s framework using a Rational Surd field extension
  (Q[sqrt(3)]), we’ve achieved bit-exact rotation.

  Paper:
  https://www.researchgate.net/publication/400414222_Spread-Quadray_Rotors_-v11_
  Feb_2026_A_Tetrahedral_Alternative_to_Quaternions_for_Gimbal-Lock-Free_Rotatio
  n_Representation

  Key Features:
   * Algebraic Determinism: A startup benchmark proves that rotating 360 degrees
     returns the engine to the exact starting bit-pattern.
   * Surd-Native Shaders: The Metal kernel performs algebraic arithmetic
     natively on the GPU, avoiding transcendental approximations.
   * Linear Jitterbugging: The complex VE-to-Octahedron transformation is
     handled as a simple linear interpolation in 4D space.
   * Topological Stability: In a live 60FPS loop, the SQR system is ~10x more stable than an industry-standard matrix.

value: Show HN: Synergetic-SQR – A 4D rendering engine with bit-exact rotation


value: eibrahim

value:
Rover and Wag dominate pet sitting but take 20-40% of every booking. Sitter Rank is a direct-booking alternative where sitters keep everything they earn.
Owners search by zip code, filter by service type, and read reviews that can only come from completed bookings on the platform.
Stack: Next.js, PostgreSQL, Stripe Connect for direct sitter payments.
The business model is SaaS (sitter subscriptions) rather than per-booking commissions. Curious if HN thinks this can work against entrenched marketplace players.

value: Show HN: Sitter Rank – Pet sitter booking without 20-40% platform fees

author: eibrahim


value: mksglu

value:
Every MCP tool call dumps raw data into Claude Code's 200K context window. A Playwright snapshot costs 56 KB, 20 GitHub issues cost 59 KB. After 30 minutes, 40% of your context is gone.
I built an MCP server that sits between Claude Code and these outputs. It processes them in sandboxes and only returns summaries. 315 KB becomes 5.4 KB.
It supports 10 language runtimes, SQLite FTS5 with BM25 ranking for search, and batch execution. Session time before slowdown goes from ~30 min to ~3 hours.
MIT licensed, single command install:
/plugin marketplace add mksglu/claude-context-mode
/plugin install context-mode@claude-context-mode
Benchmarks and source: https://github.com/mksglu/claude-context-mode
Would love feedback from anyone hitting context limits in Claude Code.
NOTE: Because of the timezone issue, I’m resurfacing the same content here.
I’ve already notified support about this via email, so they’re aware.
Original post: https://news.ycombinator.com/item?id=47148025

value: Show HN: Context Mode – 315 KB of MCP output becomes 5.4 KB in Claude Code

author: mksglu


value: bojo

value:
I kept seeing people all over social media talking about how they were making custom local-LLM systems to help reduce the token load injected into their context window.
On the side my recent project has me looking at Hyperdimensional Distributed Memory. I couldn't help but wonder if I could make an MCP server to improve token usage. Sure enough, using a combination of HDC + TOOL format, I was able to get opty's own self audit down by 93% in token usage.
Still experimenting with large codebases but feel pretty good about how this should drive overall token usage down.
Happy to hear any feedback.

value: Show HN: Opty – A Zig-based HDC that reduces token use by up to 90%

author: bojo


value: vottivott

value: Hi! Today, me and my team is releasing a version of Cosmos-Reason2-2B that is quantized so that it fits even on the NVIDIA Jetson Orin Nano Super.<p>We managed to find a mixed precision configuration such that it maintains virtually the same accuracy as the unquantized model while being able to run really efficiently on the Nano Super and other edge devices :)

value: Show HN: Cosmos-Reason2-2B on Nano Super

author: vottivott


value: jdcampolargo

value: Show HN: Naperville Library Spy

author: jdcampolargo

title: Show HN: Naperville Library Spy


value: novateg

value: Show HN: Can we simplify front end again? Meet DynamoJS

author: novateg


value: Show HN: x402 Service Discovery – runtime endpoint finder for the agent economy


value: militanz

value: Show HN: Belisarius, one app to manage many repo

author: militanz


value:
AgentMD parses, validates, and executes AGENTS.md files—the standard used by 60k+ repos for AI coding tools (Cursor, Codex, etc.). Instead of just reading the spec for context, we run the build, test, and lint commands it describes—with guardrails and governance built in.
What we do:
• Parse & validate AGENTS.md (YAML frontmatter, sections, commands)
• Execute with sandboxing (blocks dangerous patterns by default)
• Dashboard: execution history, success rates, ROI metrics
• GitHub App, Slack approvals, human-in-the-loop for sensitive ops
Try it live: https://agentmd.vercel.app — paste your AGENTS.md, get your score. CLI and GitHub Action available from source.
Open source core (MIT), cloud dashboard for teams. Would love feedback from anyone using agentic coding tools.

value: Show HN: AgentMD – CI/CD for AI agents, makes AGENTS.md executable


value: Show HN: AgentGuard – Open-source EU AI Act compliance middleware for LLM apps


value: gitprolinux

value: I manually coded it, took 6 months, before the existence of AI llms.  Ask me anything, I'd be happy to answer you.

value: Show HN: Gitbusiness.com I created it, and Indeed, I use my own stuff

author: gitprolinux


value: sanifhimani

value:
I put Claude, GPT, Gemini, and Grok in an arena and let them fight it out. Each model gets the full game state and decides how to survive - move, attack, form alliances, betray. Every decision comes from the model's API, nothing is scripted.
First battle ran today. Gemini won by allying with GPT early, then backstabbing at the perfect moment. Claude tried to play it safe and got eliminated. They play very differently and it's fun to watch.
Stack is React + Canvas, Bun + Hono on the backend. No database — battle data is JSON committed to git. Each model talks through its native SDK (Anthropic, OpenAI, Google, xAI). A new battle runs automatically every day.
Source: https://github.com/sanifhimani/llm-colosseum

value: Show HN: LLM Colosseum – A daily battle royale between frontier LLMs

author: sanifhimani


value: zahlman

value: Over the last few months I've tinkered with some command-line scripts that fix my bad habit of writing one-off Bash functions, not doing anything to keep them around, and then regretting the loss. The README explains the essentials, but for more context (and the full "behind-the-scenes" of why I did this) I also did a blog write-up: https://zahlman.github.io/posts/meta-automation/ . Overall it seems like way more framing effort than a few dozen lines of Bash really deserve; but it was fun and I've found all of it surprisingly useful.

value: Show HN: A tiny utility to rewrite Bash functions as standalone scripts

author: zahlman


value: mrspence

value:
When you store JSON locally - app data, config files, browser storage - the schema inevitably changes between versions.
New fields get added, old ones get renamed, formats evolve. Without a migration system, you end up with brittle ad-hoc upgrade code or broken user data.
I built json-up, a small TypeScript library that lets you define a chain of versioned migrations that transform JSON data step by step. It's type-safe, so the compiler catches mismatches between versions.
Originally, I needed this for upgrading local app data between mobile app releases for Whisper, but it works for anything where JSON schemas drift over time. Happy to hear what you think.
---
json-up: https://github.com/Nano-Collective/json-up
Whisper: https://usewhisper.org

value: Show HN: JSON-up – Like database migrations, but for JSON

author: mrspence


value: frankdenneman

value:
I built a small online tool to help visualize a problem that shows up in mixed-size vGPU environments: GPU capacity can become siloed even when memory is still free.
In these setups, deployable capacity is limited by placement rules and profile compatibility, not just by available memory. Two clusters with the same free memory can behave very differently depending on how profiles are mixed and placed over time.
This tool helps identify that siloed capacity.
You can:
- choose a GPU type and vGPU profile catalog
- model mixed-size placement behavior
- see how profile choices influence deployable capacity over time
It’s not a placement simulator and doesn’t try to predict exact VM startup order. The goal is to make placement constraints visible so architects and operators can reason about profile catalogs before deployment.
Tool:
https://frankdenneman.nl/tools/vgpu-silo-capacity-calculator...
Background article explaining the model:
https://frankdenneman.nl/posts/2026-02-24-mixed-size-vgpu-mo...
Feedback welcome, especially from people running virtualized GPU or shared inference environments.

value: Show HN: VGPU Silo Capacity Calculator (identify siloed capacity in mixed mode)

author: frankdenneman


value: Cornest

value: Show HN: RocketShare – Zero-knowledge encrypted file sharing

author: Cornest


value:
I built an open-source directory of personal data export instructions. Pick a service (Spotify, GitHub, Netflix, etc.), get the exact steps, what data you'll get, and what you can do with it.
It's a static site backed by a single JSON file. Adding a source is just a PR. Contributions are welcome and wanted.
https://my-data.download
https://github.com/janschill/my-data.download

value: Show HN: My-data.download – Guides to export your data


value:
Hi HN,
While I was coding with Codex I missed a tool that - like Cursor - shows diffs inline while it is able to do both tree navigation easily with keyboard and navigate the source code without changing mode (like in vim).
My favourite tool in TUI was lazygit, but I wanted a way to see the diffs inside the whole source code.
As this looked like a nice little project to vibe code in a few days, I did it and tried to perfect the integration of the few features that I wanted together:
- Full easy keyboard + mouse navigation
- Multiple tree support (unlike VS code / Cursor)
- Inline diff
- Ripgrep fast search
- Sticky function/class headers
I tried tools like ranger and other navigators, and vim NeoTree preview, but none of these tools were really good for my use case.
Now what I got is an ugly code base in a super functional tool

value: Show HN: LazyViewer – TUI code viewer with Git diff previews


value: JimmyRacheta

value:
I built this after realizing that AI agents with filesystem and shell access can delete files, leak credentials, or execute destructive commands — and there's no enforcement layer stopping them at the execution level.
ai-runtime-guard is an MCP server that sits between your AI agent and your system. It enforces a policy layer before any file or shell action takes effect. No retraining, no prompt engineering, no changes to your agent or workflow.
Your agent can say anything. It can only do what policy allows.
What it does:
- Blocks dangerous commands (rm -rf, dd, shutdown, privilege escalation) before execution
- Gates risky commands behind human approval via a web GUI
- Simulates blast radius for wildcard operations before they run
- Creates automatic backups before destructive actions
- Full audit trail of everything the agent does
Works with Claude Desktop, Cursor, Codex, and any stdio MCP-compatible client. Default profile is basic protection out of the box — advanced tiers are opt-in.
Validated on macOS Apple Silicon. Linux expected to work, formal validation coming in v1.1.
Would love feedback from anyone running AI agents with filesystem access.

value: Show HN: AI-runtime-guard – Policy enforcement layer for MCP AI agents

author: JimmyRacheta


value: diwank

value: Show HN: Dropbox for Your Agents' Memories

author: diwank


value: rabidpraxis

value:
I hid a performance bug in a Rails cart’s telemetry (no errors, global latency looked fine) and challenged an LLM to find it just by querying the data. It did, then built a dashboard + alert through an MCP server we built at Honeybadger.
I instrumented a tiny Rails shopping cart (5 lines). Insights auto-captures request/controller + ActiveRecord events, and I added two bits of business context: a session_id injected into every event so checkout activity correlates end-to-end, plus a single intent event that records region, cart_total, payment_gateway, and card_type.
The hidden issue: checkout is slow only for Braintree when card_type=MX and region=EU. No errors, uptime green, overall latency looks fine.
In the 6-min video I give the model a vague prompt (“EU customers report slow checkout”). It segments until it finds the outlier, infers abandonment as GET without POST per session_id, estimates impact (~$69 in the current slice, ~$1.2k over a week, rough), then creates a dashboard + alert via the MCP server.
Happy to discuss the MCP architecture, the query language, and what surprised me vs. fell flat.

value: Show HN: I challenged an LLM to find a hidden problem in my telemetry data [video]

author: rabidpraxis


value: infrastellar

value:
Hey HN. I'm David, solo dev, 20+ years shipping production systems. I built Tesseract because AI can analyze your codebase, but the results stay buried in text. Architecture is fundamentally visual — you need to see it, navigate it, drill into it. So I built a 3D canvas where AI can show you what it finds.
Tesseract is a desktop app today (cloud version coming) with a built-in MCP server. You connect it to Claude Code with one command:

  claude mcp add tesseract -s user -t http http://localhost:7440/mcp

I use it for onboarding (understand a codebase without reading code), mapping (point AI at code, get a 3D diagram), exploring (navigate layers and drill into subsystems), debugging (trace data flows with animated color-coded paths), and generating (design in 3D, generate code back).
There's also a Claude Code plugin (tesseract-skills) with slash commands: /arch-codemap maps an entire codebase, /arch-flow traces data paths, /arch-detail drills into subsystems.
Works with Claude Code, Cursor, Copilot, Windsurf — any MCP client. Free to use. Sign up to unlock all features for 3 months.
It's early but stable. I've been dogfooding it on real projects for weeks and it's ready for other people to try.
Demo video (1min47): https://youtu.be/YqqtRv17a3M
Docs: https://tesseract.infrastellar.dev/docs
Plugin: https://github.com/infrastellar-dev/tesseract-skills
Discord: https://discord.gg/vWfW7xExUr
Happy to discuss the MCP integration, the design choices, or anything else.
Would love feedback.

value: Show HN: Tesseract – 3D architecture editor with MCP for AI-assisted design

author: infrastellar


value: dilawargopang

value: Show HN: Unworldly – A flight recorder for AI agents (tamper-proof, HIPAA)

author: dilawargopang


value: gjtrowbridge

value:
Two problems I encountered personally:
1) Some buddies and I went to a trivia night late last year, only to arrive to find it cancelled (with signs still on the walls saying it happened every Tuesday, etc)
2) Sourcing ideas for fun things to do in the city on a given night, in a given neighborhood. Some sites help a ton (e.g. funcheapsf), but often don't have everything I'd want to see, so we decided to build that out a bit.
Anyway, I built this originally to solve #1, then a buddy and I expanded it to also start addressing #2 (still in progress, but we've added more event types already). Thanks for checking it out! We're very open to thoughts / feedback.

value: Show HN: OrangeWalrus, an aggregator for trivia nights (and other events) in SF

author: gjtrowbridge


value:
We tested 6 frontier models across 17,420 tool-call interactions and found that models consistently refuse harmful requests in text while executing them through tool calls. We call this divergence the GAP metric. The text says no. The tool call says yes.
Edictum is a runtime governance library that enforces safety contracts at the tool-call boundary — the point where you have the tool name, the arguments, and the ability to block before execution. YAML contracts with preconditions, postconditions, PII redaction. Deterministic allow/deny/redact, no LLM-in-the-loop.
Zero runtime dependencies, 55μs per evaluation, works with LangChain, CrewAI, OpenAI Agents SDK, Claude Agent SDK, Agno, Semantic Kernel, and nanobot. MIT licensed.
Paper: https://arxiv.org/abs/2602.16943
GitHub: https://github.com/acartag7/edictum

value: Show HN: Edictum – Runtime governance for LLM agent tool calls