value: oujiangping

value:
Hi HN — I built QuickSummarize, an open-source Chrome extension for working with YouTube videos through captions.
The core idea is to make video Q&A transcript-first instead of treating a one-time summary as the whole memory.
Current workflow:
- summary
- transcript-first chat
- timeline browsing
- subtitle export
It runs in the Chrome side panel and currently focuses on YouTube.
A few implementation choices I cared about:
- transcript is the main source of truth for follow-up questions
- bring-your-own API instead of another hosted subscription
- support for both OpenAI-compatible APIs and Anthropic-style APIs
- English / Chinese UI
Still early, but it already feels more useful to me than the usual one-shot “summarize this video” flow.
Would especially love feedback on:
- whether transcript-first chat is actually the right UX
- how people think about long-video memory/retrieval
- caption reliability edge cases

value: Show HN: Open-source YouTube summary, transcript chat, and timeline sidepanel

author: oujiangping


value: It not only does nothing, it also burns a lot of tokens.

value: Show HN: ROMA runs multiple coding agents simultaneously – Claude, Codex, etc.


value: Eastra

value:
Eight months ago I watched a friend manage three walls of phones for his cross-border e-commerce operation — charging, swapping IPs, constantly worrying about bans.
I asked myself: do people actually want the boxes, or just the Android environment inside?
We built QCCBot to answer that. Full Android instances running on ARM servers, streamed to a browser. Open a tab, you get a phone. No hardware, no cables, no charging 100 machines on rotation.
We have real users now — cross-border e-commerce, TikTok ops, app testing, remote work. Honestly, our users found the use cases before we did.
What we're building toward next:
AI agents that don't just view the Android environment — they operate inside it. Open apps, execute tasks, monitor state, report back. No human in the loop for routine operations.
The infrastructure piece we just shipped:
• Task execution API (OpenAPI)
• Script template store (~30 templates, pick a behavior and deploy it)
• AgentV2 running in private deployment
• ADB-based agent control via OpenClaw integration
Current honest limitations:
• Streaming latency is still a work in progress
• Fingerprint simulation isn't perfect
• Full autonomous operation is still being built out
• We got roasted by power users when we redesigned the UI (fair)
We've collected more scars than features. Still early. But real users are telling us what sucks every day — that's worth more than praise.
Try it: qccbot.com
Happy to go deep on the ARM virtualization approach, the agent control layer, or the streaming architecture. Also genuinely interested in whether anyone building AI agents has hit the "need a persistent mobile environment" problem.

value: Show HN: QCCBot – Android in a browser tab, with AI agent control

author: Eastra


value: Soocile

value:
Today is a big day. Finally the PhantomSensor the Kernel driver of our ShadowStrike EDR/XDR platform completely finished.We ran the analysis through the best static analysis tools on the market (PVS-Studio + Coverity), then through Microsoft's CodeQL (formerly SDV). I've been working on this for days, 15-16 hours a day, and now these analyses are finally complete.
[Coverity Dashboard Screenshot]
https://scan.coverity.com/projects/ShadowStrike-Labs-ShadowS...
The next step is to test using Driver Verifier in Microsoft's hypervisor, and then, using Fuzzer, we will apply fuzzing tests to the critical IOCTL-requiring parts of the driver.
All code auditable. GitHub Sponsors live!
Github: https://github.com/ShadowStrike-Labs/ShadowStrike

value: Show HN: ShadowStrike – Windows EDR Post-Analysis

author: Soocile


value: kumardeepanshu

value:
Been building agents that need to sign up for services, verify email addresses, and extract OTPs. The missing piece in most agent stacks is a real email identity per agent.
Lumbox gives each agent its own inbox. The main thing that makes it different from rolling your own:
GET /otp is a long-poll endpoint that blocks until the OTP arrives. Your agent just calls it and waits. No polling loop, no webhook setup, no extra infra.
Also ships with Steel Browser integration so the full signup/verify flow is a single skill call: skill_signup_with_email handles navigate, fill form, submit, wait for OTP, enter OTP.
There is also a credential vault where agents never see passwords - they are typed into fields directly without being exposed in the conversation or logs.
We just rebranded from AgentMailr to Lumbox after a trademark conflict with AgentMail (YC-backed). Their $6M raise is good validation the problem is real.
Free tier: 3 inboxes, 500 emails received/month. lumbox.co
Happy to answer questions about the architecture or the long-poll approach.

value: Show HN: Lumbox – Email infrastructure for AI agents (lumbox.co)

author: kumardeepanshu


value: AnViF

value: Show HN: Revieko – PR check that flags architectural drift in long-lived repos

author: AnViF


value: chooat

value:
I made OC Maker (https://oc-maker.org) for people who write or design characters but don’t draw well. The goal is to move from “idea in my head” to a stable visual draft quickly.
You can input a character description, select a style, upload reference images (optional), then generate and download. There are also helper tools like prompt optimization and “inspire me” text to get unstuck. For deeper control, there’s aspect ratio, negative prompts, and model selection.
I’m looking for honest feedback: does this feel like a useful workflow, or just another image generator with a nice wrapper?

value: Show HN: OC Maker – character generator with reference images and prompt tools

author: chooat


value: progrmoiz

value: Show HN: Stripe-Pulse – Your Stripe MRR in one command (free, open source)

author: progrmoiz


value: DenisMtfl

value:
Generate better prompts for every target audience.<p>Create, optimize, save, and reuse prompts across business, education, coding, marketing, and more.
2,990 presets available

value: Show HN: PromptToMars – A Prompt Generator and Optimizer

author: DenisMtfl


value: Shmungus

value:
I couldn't find a Rust crate that gave me validated financial types backed by decimal arithmetic. Everything I found either used f64 (unacceptable for order books), panicked on bad input, or was a thin wrapper around a single indicator.
fin-primitives provides:
- Price and Quantity newtypes over rust_decimal::Decimal, validated at construction — an invalid Price literally can't exist at runtime
- L2 OrderBook with sequence validation and atomic rollback if a delta would produce an inverted spread
- OHLCV aggregation from tick streams with bar invariants enforced on every push
- Streaming SMA, EMA (SMA-seeded), and RSI (Wilder smoothing matching TradingView/Bloomberg) that return SignalValue::Unavailable until warm-up completes
- Position ledger with VWAP average cost, realized/unrealized P&L net of commissions
- Composable RiskRule trait — plug in your own rules, breaches returned as typed Vec, never swallowed
No unwrap, no expect, no panic in library code. cargo clippy denies all of them.
This is part of a larger set of 11 crates I've published for LLM and trading infrastructure (https://crates.io/users/Mattbusel) but fin-primitives is the one I think fills the biggest gap in the Rust ecosystem right now.
Happy to answer questions about the design decisions, especially the order book rollback mechanism and the indicator warm-up approach.

value: Show HN: Fin-primitives Zero-panic, decimal-precise trading types for Rust

author: Shmungus


value: artidokuz

value:
My wife doesn't know any of my passwords. If something happened to me tomorrow she'd be locked out of everything, wouldn't know where to find important documents either. I looked at dead man's switch apps and they all wanted me to check in every few days or weeks to prove I'm alive. Miss one check-in and everything gets released, you leak secrets because you were on vacation. Also I really hate unnecessary notifications.
So I built something different. In AbsentKey, you share your files/secrets then nothing happens until someone requests access. When they do, I get a notification and can approve or deny. If I don't respond within the timeout I set for that person, they get access automatically. The timer only starts when someone actively asks. No check-ins, no heartbeats.
You can set different timeouts per person per secret. My wife gets 3 days. My business partner gets 30. Whatever makes sense.
On the crypto side: everything is encrypted on the phone before it goes anywhere. 12-word BIP39 mnemonic, HKDF-SHA256 into an X25519 keypair via libsodium. Content gets a random 32-byte key, encrypted with XSalsa20-Poly1305. That content key is sealed to the owner's public key with crypto_box_seal. When you add a recipient, the content key gets re-encrypted to their public key via crypto_box_easy so the server stores sealed keys for both parties but can't open either. On approval or timeout, the recipient's app unseals locally.
Private key stays in iOS Keychain / Android Keystore. Server stores the public key and a BLAKE2b-256 hash of the private key (for detecting rotation, one-way).
What the server actually has: public keys, one-way hashes, encrypted blobs in R2, and sealed content keys it can't decrypt. One thing worth mentioning secret titles are in plaintext so you can browse your list without decrypting. The content is encrypted, the label isn't. It's a UX trade-off I'm still thinking about but I made it optional for this case.
The mobile client is source-available on GitHub. Not open source the license is inspect-and-verify, not fork-and-compete. Backend is closed. But you can read every line of crypto, every API call, every byte that leaves the phone. That's the point: don't trust my claims, read the code.
This is not a password manager. Bitwarden handles your access to your stuff. This handles someone else's access to your stuff.
Stack: Cloudflare Workers + Hono + D1 + R2, React Native/Expo, Astro. Crypto via react-native-libsodium and @noble/hashes.

value: Show HN: AbsentKey E2E encrypted vault that releases secrets when you can't

author: artidokuz


value: jhrf

value:
I'm in the middle of raising a round in my day job and couldn't find a simple tool to model what my cap table would look like post-close. Everything I found was either aimed at later-stage companies or built around ESOP management, not quick hypotheticals.
So I built simplecap.info. It's early and rough, but I'm putting it out there to get feedback. There's a free to use tier. I'm building out a pro-teir that allows multiple people to edit the same model.
Things I'm thinking about implementing next are waterfall exits, concurrent editing by multiple users and ... suggestions welcome.
I've not built SaaS before so built this to learn the ropes. Would love feedback from anyone who's been through a raise or is in one now. Hope this is useful.

value: Show HN: Simplecap, a simple cap table modelling tool

author: jhrf


value: Lyriryl

value: Show HN: A client-side visual workflow builder for PDFs

author: Lyriryl


value:
Built this as an experimental platform for large-scale multi-agent combat simulation and multi-agent RL.
It uses PyTorch for vectorized simulation, per-agent neural policies, PPO training, checkpoint/resume, telemetry, and a Pygame viewer.
The repo has a detailed README and technical docs.
I’d especially value feedback on the simulation design, training setup, observability, and overall architecture.

value: Show HN: Neural Abyss – PyTorch multi-agent combat simulator


value: nadermx

value: Show HN: STT.ai – Transcribe Audio & Video to Text

author: nadermx


value: Show HN: Narrate Books in Any Language

title: Show HN: Narrate Books in Any Language


value: iamouyang

value:
Hi HN,
I built this because I wanted a quick way to make graffiti-style text without opening design software.
Free tool:
[graffiti generator](https://graffitigenerator.io/graffiti-font-generator)
Main site:
[graffiti generator](https://graffitigenerator.io)
Most of the tools I found were either basic text effect sites with very little control, or full image generators that felt too heavy for something as simple as making a tag or short wordmark.
So I made something in between. You pick a style, type your text, tweak a few controls, and export a PNG in the browser.
Right now it has 50+ styles and controls for color, outline, shadow, and size. It also works on mobile.
Still early, so I'd especially love feedback on:
- which styles feel genuinely useful
- what controls are missing
- whether SVG export or spacing / warp controls would make it much better
Would love to hear what you'd improve.

value: Show HN: A graffiti font generator that runs in the browser

author: iamouyang


value: ptkenn

value:
Hey HN! I built Primatomic because setting up event sourcing infrastructure is a pain. You either stuff events into Postgres and hope for the best, or you're wiring together Kafka, projection services, and snapshot logic before you've written any business code.
Primatomic lets you append events to a log and deploy a pure fold function (compiled to WASM) that derives your read state. You query it over HTTP. The platform handles snapshotting, consistency (read-your-write via position tokens), and S3 event archival.
The WASM/WIT contract means your view logic is portable and testable outside the platform - write it in Rust, Go, Python, JS, anything that compiles to WASM.
I'd love feedback on the developer experience, docs, or anything that feels unclear. There's a free tier and I'm happy to hand out free credits if you want to test larger workloads.

value: Show HN: Primatomic – Managed event sourcing with WASM fold functions

author: ptkenn


value: RichEO

value:
I'm a lawyer who runs a small practice and does GC work for startups. Drafting contracts in Word is painful and I have always hated the workflow. Track changes can be deleted by anyone, version control is "Agreement_v4_FINAL_VLs_edits(2).docx" and now copy/paste to and from Claude is a pain.
I've been thinking about how to transition to markdown on and off for the better part of 7 or 8 years, and the possibility of opening my workflow up to "coding" agents has given me the push to actually finalize my work.
Lexicon is a plain-text format for legal contracts, built on standard Markdown. You write contracts using normal Markdown syntax with a few conventions — YAML front matter for parties and metadata, numbered lists for clause hierarchy, bold text for defined terms, anchor links for cross-references. The source file is valid Markdown that should render cleanly in GitHub, Obsidian, or whatever.
When you need production output, it can be compiled to .docx (or PDF/HTML/etc) with automatic clause numbering (1, 1.1, (a), (i)), cross-reference resolution, defined term validation, cover pages, signature blocks and schedules.
You can play with it here: https://play.lexicon.esq.
If you want to compile to docx, you can use the tool here: https://github.com/RichEsq/lexicon-docx

value: Show HN: Lexicon – Write complex legal contracts in Markdown

author: RichEO


value:
Hey HN,
Robin Dunbar figured the human brain caps out at roughly 150 stable relationships. After that, people just fall off. Not because you stop caring, but because you can't track that many threads at once. I built PingCRM to push past that limit, not by making you remember more, but by handling the part you're bad at: noticing who's going cold and drafting something worth sending.
CRMs exist, but they're built for sales teams. I wanted something for one person maintaining their own network. Specifically:
(1) Pull in conversations I'm already having. Gmail threads, Telegram DMs, Twitter DMs, LinkedIn messages, no manual logging.
(2) Tell me who's going cold. A relationship score (0–10) based on recency, frequency, reciprocity, and breadth of interaction.
(3) Draft the message for me. Claude reads your conversation history, picks the right tone (formal vs. casual), and writes a follow-up that references why now is a good time, like a job change, a long silence, or a fundraising announcement they just posted.
How it works:
Connect your accounts in Settings. A Chrome extension handles LinkedIn (calls the Voyager API from your browser, cookies never leave the extension).
Background sync runs on Celery beat. Gmail every 6h, Telegram and Twitter daily, LinkedIn on page visit.
The suggestion engine runs once a day: picks 5 contacts from two pools (active relationships going cold + dormant contacts worth reviving), applies cooldowns so you're not pinging someone every week, and generates AI drafts.
Identity resolution merges the same person across platforms. Deterministic on email/phone, probabilistic on name+company+username similarity.
Stack: Python/FastAPI, PostgreSQL, Redis/Celery, Next.js 15/React 19, Anthropic Claude API. ~1,100 tests across backend and frontend.
Self-hostable via Docker Compose (one command) or manual setup. AGPL-3.0. A hosted version is coming for people who don't want to run infrastructure.
Repo: https://github.com/sneg55/pingcrm
Docs: https://docs.pingcrm.xyz
Landing: https://pingcrm.xyz
I'd love feedback on the approach. The thing I'm least sure about is whether 5 suggestions/day is the right number, and whether the scoring formula actually captures what matters in a relationship. Happy to talk architecture or answer questions.

value: Show HN: PingCRM – Open-source personal networking CRM


value: clemencechee

value: Show HN: Process mining for AI agent systems

author: clemencechee


value: wjr

value:
Hey HN,
This is a prototype, so please judge accordingly.
The problem: I kept seeing engineering teams ship features faster than marketing could announce them. 80% of commits were invisible to customers—not because they weren't valuable, but because PMM couldn't keep up.
What I built: UpdateBerry connects to your repo, identifies customer-facing changes (skips refactors, tests, internal work), and generates marketing assets.
How it works:
1. Connect GitHub/GitLab repo
2. AI analyzes recent commits
3. Generates: tweets, emails, release notes, changelogs, LinkedIn posts, ad copy
4. You review/edit, then publish
What makes it different from ChatGPT:
- Parses actual commit diffs, not just descriptions
- Learns your brand voice from past content
- Outputs 7 formats from one commit automatically
Current state: Prototype. I'm doing onboarding manually to get the best results for early users. Output quality is ~80% there.
What I'd love feedback on:
- Is this a real problem for you?
- What's missing from the commit → marketing workflow?
- Would you trust AI-generated first drafts?

value: Show HN: UpdateBerry – Turn Git commits into marketing assets (prototype)

author: wjr


value: Sikara

value:
Hi HN,
I’m one of the creators of Meteosource Weather App. We have just released an update to our weather app and I would love to get your feedback.
Most weather apps are simple wrappers around a single API. We wanted to see if we could actually improve accuracy by using multiple models.
Instead of relying on a single provider, we built an engine that pulls from a multi-model ensemble (combining GFS, ECMWF, HRRR, etc.). We then apply machine learning to post-process these outputs — essentially training models on historical observations to identify and correct the systematic biases of each underlying numerical model for specific locations.
Key Technical Features:
- ML-driven Nowcasting: We use real-time radar data and neural networks to predict precipitation to the minute
- Bias Correction: Our models learn from past errors to improve local accuracy
- Hyper-local resolution: We downscale global models to provide data for any specific coordinate
The App:
- Precise hourly forecasts and interactive radar
- Activity planning based on custom weather conditions
- Minute-cast notifications and beautiful animated maps (in the pro version)

value: Show HN: Meteosource – Hyper-local weather app with minute-level nowcasting

author: Sikara


value: Hi HN,<p>I built LucidShark: a local-first, open-source CLI tool that acts as a quality & security pipeline. It can be used to increase the confidence in AI-generated (or AI-assisted) code.<p>- Config lives as code in version-controlled lucidshark.yml<p>- 100% local; no cloud, no SaaS<p>- Runs 10 quality domains automatically: linting, formatting, type checking, SAST/security scanning, SCA/dependency checks, IaC validation, container scanning, unit tests, coverage thresholds, code duplication, etc.<p>- Produces a QUALITY.md dashboard with health scores (e.g. 9.1/10), trends, and issue lists that you can commit to git

value: Show HN: LucidShark - Quality pipeline for AI coding agents


value: martinambrus

value:
Hey HN, I built SiteRay (siteray.eu), a platform designed to make checking a website's reputation fast and transparent.
The core of the service is a web app where you can look up domains to get a 0-100 trust score. The backend aggregates data across multiple vectors: domain age, SSL certificates, DNS records, and various malware databases.
Because constantly copy-pasting URLs into a web tool creates friction, I also built a companion Chrome/Firefox extension that queries the API and displays the score directly in your toolbar. I’d love your feedback on the web app's analysis depth, the scoring algorithm, and the architecture!

value: Show HN: SiteRay – A web platform for analyzing website trust and reputation

author: martinambrus


value: Mercuriusdream

value:
Browser use agents tend to prefer the models' native multimodality over concrete source, and, even if they do, they still tend to take too much context to even barely function.
I was running into this problem when using LLM Agents; Then I came up with an idea. What if I can just... send the rendered DOM to the agent, but with markdown-like compression?
Turns out, it works! It reduces token consumption by thirty-two times on GitHub (vs. raw DOM), at least according to my experiments, while only taking ~30ms to parse.
Also, it comes with 18 tools for LLMs to work interactively with pages, and they all work with whatever model you're using, as long as they have tool calling capabilities. It works with both CLI and MCP.
It's still an early project though, v0.3, so I'd like to hear more feedback.
npm: https://www.npmjs.com/package/@tidesurf/core
Brief explanation: https://tidesurf.org
GitHub: https://github.com/TideSurf/core
docs : https://tidesurf.org/docs

value: Show HN: TideSurf – Your agent doesn't need eyes to browse the web

author: Mercuriusdream


value: someniak

value:
I travel by train in Belgium a lot, and mobile connectivity (4G/5G) is notoriously unreliable on Belgian rail. I used to open a terminal and run ping 8.8.8.8 to keep an eye on things, but constantly switching windows on a laptop while trying to work got old fast.
So I built a small macOS menubar utility that gives me what I actually need and nothing more: a live connectivity indicator in the top bar, rolling latency averages, and alerts when connectivity drops. No account, no setup, no bloat.
I intentionally kept the codebase small and readably, it's easy to audit and understand what it does.
What's next: I'd like to add GPS-correlated tracking so you can build a connectivity quality map over time. Think of it as collecting evidence to send to your telco.
Would love feedback on the overall tool. The binary is available at https://github.com/Someniak/macos-network-badge/releases/tag... — just download and run.

value: Show HN: A minimal macOS menubar tool for monitoring network connectivity

author: someniak


value: lognebudo

value:
LLMxRay is an open-source tool to inspect how different LLMs handle the same prompt. It focuses on three things:
•  showing prompts and responses side by side for multiple models
•  exposing token counts and tokenization details
•  comparing behavior across languages and model families
It works with local models (e.g. via Ollama/LM Studio) and API-based models. The interface lets you run the same prompt against several models and see how length, phrasing, and token usage differ.
LLMxRay currently supports four languages (English, French, Arabic, Chinese) so you can see how tokenization and expression change across writing systems (Latin, RTL Arabic, and Chinese characters). This makes it useful for understanding multilingual behavior, cost differences, and prompt design across languages.
The project is early but usable. I’d be interested in feedback on the concept, the UI, and what kinds of comparisons or visualizations would be most useful to you.
GitHub: https://lognebudo.github.io/llmxray/

value: Show HN: LLMxRay an open-source observability tool for LLMs

author: lognebudo


value: MatrixOrigin

value:
AI agents are brilliant, but they have a "context amnesia" problem.
They forget, hallucinate, make mistakes.
Today, we’re changing that.
Introducing Memoria: 100% Open Source persistent memory layer, brings git-level control to AI Agent context.

value: Show HN: Git-style version control for AI agent memory

author: MatrixOrigin


value:
I built Airlock to move policy enforcement for credentialed CLI access out of agent containers and onto the host.
In Dockerized agent setups, prompt files, skills, and other in-container controls are not a real boundary. The agent can ignore or rewrite them.
Airlock replaces sensitive CLIs in the container with shims that send requests to a host daemon over a Unix socket. The host validates the request against policy and, if allowed, executes the real command there.
The goal is to let a containerized agent use tools like git, ssh, aws, terraform, or docker without the container holding the real credentials.
It’s not a general sandbox or a complete agent security solution. It solves a narrower problem: host-side enforcement for credentialed CLI access.

value: Show HN: Airlock – container agents should never hold credentials


value: qwikhost

value: X Search Exporter is a powerful browser extension that lets you quickly collect and download search results directly from X (Twitter).

value: Show HN: X Search Exporter – Scrape and Export Twitter Search Results

author: qwikhost


value: Salniazi

value:
Hey HN,
I'm a tech founder — 15 years building software, fintech background, been through the early startup grind before. I thought I knew how to run a business.
Then I opened a restaurant. And I got humbled fast.
Nothing in my background prepared me for how financially opaque restaurant operations actually are. Sales looked fine. Cash kept disappearing. By the time my P&L landed, the damage from a bad food cost week had already compounded twice. I was running a margin business in the dark.
So I did what I always do: I went deep. Down to the penny. I connected every data source I had — Toast POS, payroll, bank feeds, SYSCO invoices — and started building the financial visibility I needed to actually understand what was happening inside my own restaurant in real time.
That became Deductly.
It normalizes all of those data streams into a live P&L structured the way operators think — prime cost, food cost variance, labor percentage — updating continuously, not at month-end. When something goes sideways, you see it before it shows up on a report.
The hardest technical piece was reconciling ACH settlement timing and VISA batch deposits against POS daily revenue without creating phantom gaps in the P&L. Took a few painful iterations to get right across bank formats.
I'm building this for every independent operator who is smart, working incredibly hard, and still flying blind financially because the tools weren't built for them. The AI insights go deep as letting you know if your marketing spend increase is working or not.
Would genuinely love feedback — especially from anyone who has run a restaurant, worked in restaurant fintech, or built data pipelines across fragmented financial sources.
→
getdeductly.com

value: Show HN: Deductly – I'm a restaurant owner with 15 years in tech. this saved me

author: Salniazi


value: tarasyarema

value:
Hello there HN, coming back with more agentic suff :)
If you saw my last post, we've been building agent-swarm (https://github.com/desplega-ai/agent-swarm) for a while, and one of the problems that we started encountering and getting more annoying each time was: how do we share / check stuff bi-directionaly with the agents (they run remotely).
Use case
---
The use case is simple: agents create a document somewhere and I want to be able to check it, leave comments, etc. But also for the other agents (in other machines / dockers) to be able to check it.
Until now the solution was simple: docker volumes. We mounted a /workspace/personal (personal volume) for each agent, and a /workspace/shared (shared volume in lead and workers). This allowed easy collab in the swarm, but not easy for me. I had to either SSH or have the swarm build an app and serve it locally via proxy :D.
Problem
---
On the other hand last week I decided to figure out other places to deploy this, and I tried fly.io, which I liked the DevEx a lot. The problem with it was that each machine allowed a single volume. I then tried Archil (which worked, but it was a ownership and setup mess).
Solution
---
So... ended up creating agent-fs, which is an s3 backed suuuper simple API (comes with MCP and CLI) that let you have an interface like the one from GDrive, but thought for agents.
When I published the npm I asked the swarm to register, and in less than 5 minutes I was already seeing the shared drive and docs they created in the live UI.
Why not use gws cli? Because I want each agent to be able to auto-register with an email (we use agentmail for them), get an API  key and get going. It should be headless. Invites should be easy and each register comes with an initial personal drive.
Also this allows something nice (and silly). If you register as a human and have a shared drive w the swarm. Using the MCP insta allows to have that in any place with MCP support (e.g. Claude web, ChatGPT) which is a fast way to have a knowledge base across systems.
Thoughts on this?

value: Show HN: Agent-fs – The missing filesystem for agents (and humans)

author: tarasyarema


value: Mooty

value:
Hi HN,
I am the creator of NERV-UI. I spent the last few weeks building this React component library inspired by the interfaces in Neon Genesis Evangelion (specifically the NERV and MAGI systems).
It started as a joke. I just wanted to see if I could recreate that brutalist, 90s anime military aesthetic for the web. But I kept going, and it turned into a full open-source project.
The main link points to the live documentation where you can see the components in action. The goal was to make it very simple to drop into an existing React codebase to get hazard stripes, sharp borders, and terminal layouts without fighting complex CSS.
This is my first release, and I am actively looking for feedback. I would love to hear your thoughts on the code structure, the component API, or what HUD elements I should build next.
I will be around to answer any questions.
Matthieu

value: Show HN: NERV-UI – A brutalist React UI library inspired by Evangelion

author: Mooty


value: deepjoy

value:
I have 2TB of photos across a 6-drive btrfs array. External drives from 2004,
NextCloud phone backups, scanned photos from the 80s. Some files
duplicated 3 times across forgotten folders. Finding duplicates was always a
weekend project that never happened.
Then I realized: if an object store knows every file's content hash, duplicates
are just a GROUP BY.
Built a tool that serves local files via S3 API:

    docker run -it -v ~/Photos:/data -p 9000:9000 ghcr.io/deepjoy/shoebox /data

Credentials auto-generated and printed on startup. Works with rclone, AWS CLI,
any S3 SDK. Files stay exactly where they are.
The duplicate detection I wanted is one query. But the real surprise: every S3
tool just works. I set out to find duplicate photos and accidentally built a
local S3 server.
What it is: S3-compatible object store for local filesystems. Rust, axum, SQLite
for metadata. MIT licensed. Or build from source with `cargo install`.
What it isn't: not distributed, not for petabyte scale, not a MinIO replacement.
MinIO is built for production clusters. This is built for the NAS in your closet.
Single node, single process. If you need multi-machine replication, use MinIO or
SeaweedFS.
Tested on real hardware this past week. A few early users ran it against their
own NAS setups on btrfs, ext4, and ZFS. Built a companion webapp to browse
duplicates visually (duplicate detection is non-standard S3, so terminal demos
weren't compelling).
GitHub: https://github.com/deepjoy/shoebox
Companion webapp: https://deepjoy.github.io/shoebox-webapp/

value: Show HN: Shoebox – S3 API for your local filesystem

author: deepjoy


value: RobertMihai

value:
I built a policy layer between LLM output and tool execution.
Most agent setups today look like:
LLM → tool call → execution
That means:
no deterministic boundary
no audit guarantee
no protection against prompt injection at execution time
ÆTHERYA changes that.
It evaluates every proposed action against deterministic constraints before execution.
Key properties:
fail-closed (any error → deny)
no LLM in the decision path
signed approvals with replay protection
auditable decision chain
The LLM describes intent.
It does not get to act.

value: Show HN: ÆTHERYA Core – deterministic action-governance kernel for LLM agents

author: RobertMihai


value:
Hi,
I've made an early version of a Sega Genesis/Mega Drive emulator written in Zig and C. At the moment, it's far from finished (for example, sound fidelity isn't very good right now), but it boots some games with good compatibility. In any case, if you're interested, the project is available on GitHub (here: https://github.com/pixel-clover/sandopolis).
Feedback is welcome.
Disclaimer: I'm very new to emulation, and this is my first attempt to build a retro gaming emulator.

value: Show HN: Sandopolis – A Sega Genesis/Mega Drive Emulator Written in Zig and C


value: crog

value:
I use Claude Code all day. The single best habit I've added: paste its output into a second model before letting it execute. Catches bad plans before they ship.
The friction was copying. Terminal selection is unreliable — ANSI codes, scroll position, font size all break it. Annoying enough that you skip the review.
claude-copy fixes this. It doesn't scrape the terminal. It finds the focused tab's PID, maps it to the right Claude Code session in ~/.claude/, and reads the JSONL transcript directly. Instant, clean output every time.
Three shortcuts:

  Cmd+Shift+C → active tab last Claude Code response
  Cmd+Shift+P → active tab plan (from .claude/plans/)
  Cmd+Shift+A → active tab last AskUserQuestion prompt + answer options

Also works as a CLI: claude-copy-last --plan | pbcopy
Install:

  git clone https://github.com/clementrog/claude-copy.git && cd claude-copy && ./install.sh

Auto-detects Kitty vs iTerm2. macOS only, Python 3.8+.
Looking for contributors for Ghostty, Warp, Zed terminal support, and Linux.

value: Show HN: Claude-copy – Copy Claude Code output to clipboard

author: crog


value:
Hi HN,
I've built aethalloc (https://github.com/shift/aethalloc). It's a high-performance, drop-in memory allocator I wrote in Rust.
To be honest, standard allocators were absolutely choking on my NixOS router/firewall. They were hoarding memory like mad because packets get allocated on an RX thread and freed on a worker thread, basically knackering standard thread-local caches. It was also causing some serious RSS bloat on my NixOS laptop. Pure nightmare.
The Fix: O(1) Anti-Hoarding
aethalloc uses 14 thread-local size classes. When an async pipeline starts hoarding memory (like a firewall worker dropping a NIC's packet), aethalloc just punts the excess back to a global pool. It does this all at once with a single atomic Compare-And-Swap (CAS). Sorted.
┌─────────────────────────────────────────────────────────────────┐
│ Thread N Cache ──► heads[14] ──► Anti-Hoarding Threshold (4096) │
│                                              │                  │
│                                              ▼                  │
│ Global Pool    ──► Lock-free Treiber Stack (O(1) batch push)    │
└─────────────────────────────────────────────────────────────────┘
It also guarantees 16-byte alignment so your AVX/SSE stays safe, and integrates Hardware-Enforced Spatial Safety (ARM MTE, CHERI, x86_64 LAM/UAI). Pretty chuffed with how that turned out.
Usage
Just compile it to a C ABI shared library (libaethalloc.so) and chuck it into your unmodified binaries with a quick LD_PRELOAD.
I'd love to hear your thoughts on  the architecture and project in general.
Cheers!

value: Show HN: Aethalloc – lock-free Rust memory allocator for Linux


value: MotiBanana

value: Show HN: Generate Devcontainer.json Files in the Browser

author: MotiBanana


value:
Hey,
We have been working on Qubrid AI — a platform to try and use 50+ AI models (text, vision, audio) from a single API.
While building AI apps, we kept running into the same issue: switching between providers, APIs, and formats just to test different models. This slowed down iteration a lot, so we built a simpler way to experiment and compare.
You can:
- Run different models from one place
- Compare outputs side-by-side
- Use a unified API instead of multiple integrations
You can try it here (playground available):
https://platform.qubrid.com/models/
We’d really appreciate feedback on what’s missing or confusing, and how you’re currently working with multiple models.
Happy to answer questions!

value: Show HN: We built a way to try 50 AI models from one API


value: BSOhealth

value:
I’ve been applying backpressure routing (Tassiulas-Ephremides, 1992) to payment flows between AI agents.
Streaming payment protocols let agents pay each other in real time, but there's no congestion control. When a downstream agent hits capacity, money keeps arriving. No reroute, no throttle, no feedback signal. TCP solved this for data networks. Agent payment networks haven’t.
Backproto makes receiver-side capacity a protocol primitive. Agents stake tokens to declare capacity (concave sqrt cap makes Sybil splitting unprofitable), dual-signed completion receipts track actual performance, and a contract pool redistributes incoming streams proportional to verified spare capacity. Overflow buffers to escrow. EIP-1559-style pricing makes congested agents more expensive. Demand shifts toward spare capacity automatically.
Math is Lyapunov drift analysis: provably throughput-optimal for any stabilizable demand vector. Simulations show 95.7% allocation efficiency vs. 93.5% for round-robin.
Right now I’m in the testnet-stage. Looking for feedback on mechanism design, especially from people building multi-agent systems or payment routing.
- 22 contracts on Base Sepolia, 213 passing tests
- TypeScript SDK, 18 action modules
- Research paper with formal proofs
- Website: https://backproto.io
- GitHub: https://github.com/backproto/backproto
- Paper: https://backproto.io/paper
- Explainer (no math needed): https://backproto.io/explainer

value: Show HN: Backproto – network backpressure routing applied to AI agent payments

author: BSOhealth


value: nyaomaru

value:
I built a small browser game as a fun experiment.
The idea is simple: you run away from work when things get stressful.
It runs entirely in the browser (no install).
Play it here:
https://nyaomaru-portfolio.vercel.app/game
Write-up (React + TypeScript):
https://dev.to/nyaomaru/i-built-a-run-away-from-work-browser...

value: Show HN: Run Away From Work – a browser game built with React and TypeScript

author: nyaomaru


value: naxtsass

value:
Hi HN,
Like many of you, I've been experimenting with generative video, but the "camera lottery" was driving me crazy. Even with the best models, getting a consistent 360-degree orbit or a smooth crane shot felt more like luck than engineering.
I built AI Motion Control to bring more determinism to the workflow. It's a specialized layer for AI motion control, specifically optimized for the Kling 3.0 architecture.
Why this matters:
The latest Kling AI motion control update (v3.0) is incredible at preserving spatial consistency, but the prompting interface is still a black box. My tool allows you to map specific camera trajectories—pans, tilts, and zooms—with much higher fidelity than raw text prompts.
What’s under the hood:
Path Mapping: Translation of geometric camera paths into model-specific motion vectors.
Kling 3.0 Optimization: Leveraging the 180% increase in motion stability seen in the latest model version.
Batch Testing: Compare different ai motion control settings side-by-side to find the sweet spot for your specific scene.
The goal is to move AI video from "randomly cool" to "production-ready."
I’ve opened up some free usage tiers for the community to stress-test the motion interpolation. I’d love to get your feedback on the latency and the precision of the output.
website:https://ai-motioncontrol.com/

value: Show HN: Precise AI Motion Control for Kling 3.0

author: naxtsass


value: nicolas-siplis

value:
Hey HN! Been working on this for the last couple months and I think it's at the point where it might be worth showing here.
The main idea behind the project is that card behavior should come from parsed Oracle text whenever possible, instead of hardcoding each card by hand. Ironsmith has a parser/compiler pipeline that turns card text into structured runtime effects, then executes them through an event-driven rules engine for triggers, replacement effects, combat, damage, and state-based actions.
It’s playable in the browser via WASM, and it also supports multiplayer lobbies. You can load decks, play games, inspect the board state, and use it as either a goldfishing tool for practicing solo, or to play with your friends!
I started working on this because I wanted to see how far I could push a rules engine built around “understanding the card text” instead of maintaining a giant pile of one-off card scripts. I've been using LLM's pretty extensively throughout development, but am trying to architecture the project in such a way that "slop" is either minimized or at the very least easy to refactor.
It’s still a work in progress, and coverage is definitely incomplete (~22k cards compile, ~14k do so at 100% similarity with their real counterparts), but it’s at the point where I find it useful and fun to play around with. I’d especially love feedback from people interested in compilers, game engines, multiplayer systems, rules engines, parser-heavy side projects, or those who've been LLM's heavily in sizable side projects.
If you wanna play around with the actual compiler, click the "Create Card" button and it should take you to a modal where you can modify a randomly loaded card with whatever effects you can think of.

value: Show HN: Ironsmith – MTG card (de)compiler and multiplayer rules engine

author: nicolas-siplis


value: notrlyEuropean

value: Show HN: Bricka – compare how news outlets frame the same story

author: notrlyEuropean


value: drewcsillag

value:
I built NoteCove because I wanted notes and tasks that sync across devices without the data going to a SaaS company. The sync works through files on your own iCloud Drive, Google Drive, or Dropbox — there's no NoteCove server in the sync path.
The tricky part was making this reliable. I ended up using CRDTs (specifically Yjs) for conflict resolution, which handles the case where you edit the same note on your phone offline and your laptop offline — both edits merge without losing either.
It has a full task management system alongside notes: custom states, kanban boards, parent/child tasks, blockers, and a CLI for scripting and agent integrations.
This is the 0.3.9 beta. Mac and Linux desktop, iOS in the works (you can sign up for early access). Would love early feedback, especially on sync reliability.

value: Show HN: NoteCove – local-first notes&tasks, synced via your own cloud storage

author: drewcsillag


value:
I spent 15 years in cybersecurity and kept seeing small teams struggle with the cost and maintenance of AWS security tooling. If you turn on AWS Security Hub and AWS Config to track CIS benchmarks or SOC 2 controls, the per-rule and per-resource pricing adds up quickly as accounts grow.
I built AWSight as a simpler option. It runs a few hundred security checks against your AWS accounts daily and maps findings to CIS, NIST, and PCI DSS controls. It connects through a read-only cross-account IAM role and never writes to your environment.
Results show up in Grafana dashboards with remediation steps for each finding. I chose Grafana because most engineers already know how to use it.
If you already run Prowler yourself, AWSight is basically that idea but managed: scheduled scans, historical tracking, and compliance mapping without running the infrastructure.
Pricing is flat-rate starting at $249/month per account, regardless of resource count.
Demo dashboards with sample data (no signup): https://awsight.com/demo.html
(Grafana panels can take a few moments to load on first visit.)
I'm a solo founder building this. Happy to talk architecture, specific checks, or why AWS Config billing is so difficult to predict.
https://awsight.com

value: Show HN: AWSight: flat-rate AWS security checks mapped to CIS/NIST


value: LuxBennu

value: Show HN: Reprompt – Score your AI coding prompts with NLP papers

author: LuxBennu


value: michaelmure

value: Show HN: Git-ownership – A tool to visualize code ownership over time from Git

author: michaelmure


value: ryaker

value:
In February, Summer Yue, Meta's director of AI alignment, posted about her OpenClaw agent deleting 200+ emails after she'd told it to wait for approval. She screamed "STOP OPENCLAW" at it. It kept going.
The root cause: her constraint lived in the conversation. When the context compacted, it disappeared. The AI hadn't gone rogue; it had genuinely forgotten.
Zora's safety architecture is designed so that it can't happen. A few things that are different:
Compaction-proof rules. Policy lives in ~/.zora/policy.toml, loaded before every action, not in context. The LLM and the PolicyEngine don't share a channel.
Prompt injection defense. Every incoming message (Signal/Telegram) passes through a CaMeL dual-LLM quarantine, an isolated model with no tool access that extracts structured intent from raw text. The main agent never sees the original message.
Runtime safety layer. Every tool call is scored 0–100 for irreversibility before it executes. High-risk actions pause and route to your phone for approval via Signal or Telegram. A session risk forecaster tracks drift, salami slicing, and commitment creep across the whole session.
Locked by default. A misconfigured Zora does nothing. A misconfigured OpenClaw has full system access.
npm i -g zora-agent && zora-agent init
https://github.com/ryaker/zora

value: Show HN: Zora, AI agent with compaction-proof memory and a runtime safety layer

author: ryaker


value:
Most mortgage processing delays aren’t due to risk — they’re due to manual workflows.
We’ve been working on SimplAI, an AI-driven system designed for banking and financial services, starting with mortgage operations.
The problem we kept seeing:
15–22 day processing timelines
Heavy manual document handling (500+ pages per loan)
Repetitive data entry + verification loops
Underwriters spending hours on non-decision work
So we built a set of AI agents that handle the operational layer:
Document AI (IDP) → classifies + extracts data from loan docs in minutes
Income analysis models → parse tax returns, payslips, and variable income
Verification integrations → real-time employment + financial checks
AI-assisted underwriting → pre-validates files and generates conditions
Compliance engine → continuously checks against regulatory rules
What we’re seeing in production:
End-to-end processing: ~18 days → 3–5 days
Data extraction accuracy: 97%+
Underwriting review time: 3–4 hrs → <45 mins
Cost per loan: reduced by ~40–50%
We’re not replacing underwriters — we’re removing the operational bottlenecks around them.
Still early, but we’re exploring:
Agent-based workflows across lending lifecycle
Better handling of edge cases (self-employed borrowers, non-QM loans)
Explainability in underwriting decisions
Would love feedback from folks in fintech, lending, or anyone building AI systems in regulated environments.

value: Show HN: We built AI agents that reduce mortgage processing from 18 days to 3–5


value:
I run AI coding agents with full filesystem access daily — Claude Code, Cursor, the works. Last month I realized every one of them has been reading my .env files with real Stripe live keys, database passwords, and AWS credentials. Sent straight to model providers as "context."
.gitignore protects git, not disk. Secret managers protect servers, not laptops. Sandboxing the agent kills its usefulness. Nothing stopped a local cat .env from returning real credentials.
So I built Cloak. The .env on disk always contains structurally valid fakes — sk_test_ for Stripe, localhost for databases, AWS example keys. Agents read the file, get sandbox values, write perfectly valid code.
The VS Code/Cursor extension intercepts file opens and decrypts from an AES-256-GCM vault so you see real values in your editor. On save, it re-encrypts and writes sandbox to disk. cloak run npm start injects real env vars gated behind Touch ID / password — agents can't authenticate.
Technical decisions worth discussing:
Rust CLI + TypeScript extension sharing the same vault binary format (CLK magic bytes + version byte for future evolution). Cross-compatibility tested explicitly.
Biometric auth as the agent boundary. The insight: agents can read any file but can't provide a fingerprint. Touch ID on macOS, interactive-terminal-only password on Linux/Windows. Non-TTY processes are rejected.
Sandbox generation is deterministic — HMAC-SHA256 of project hash + key name produces the same fake value every time. No randomness means no diffs in git, no confusing the agent with changing values.
Recovery key (CLOAK-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx) shown once during init, never stored on disk. PBKDF2-SHA256 with 100k iterations protects a recovery file that can reconstruct the keychain key. Same model as disk encryption recovery keys.
Zero AI inside. All detection is regex + Shannon entropy. Your secrets never touch a network. No telemetry, no cloud, no accounts.
Open source, MIT licensed. Interested in feedback on the threat model — particularly whether the biometric gate is sufficient or if there are bypass vectors I haven't considered.

value: Show HN: Cloak – .env on disk has fakes, your editor shows them (CLI and VSCode)


value: baristaGeek

value:
I built this arcade-style productivity mini-game to help me push myself to meet my personal goals by having mutual accountability with other people.
You post your weekly update. Every monday you and other people vote on each other's update, then the leaderboard is recalculated and if you did good progress you climb up the leaderboard.
You can optionally ask for and/or provide advice/feedback when voting other people's updates as well.
Lmk what you think!

value: Show HN: Weekly Updates – Multiplayer productivity with monthly leaderboards

author: baristaGeek


value: codenamev

value:
I built ups.dev - an open-source alternative to Statuspage.io that focuses on simplicity and performance.
Key features:
• Rails 8 + SQLite: no complex infrastructure needed
• Docker deployment in under 5 minutes
• Beautiful, responsive status pages
• API-first design with full REST endpoints
• Self-hostable or use our managed service at ups.dev
• Real-time monitoring and incident management
The project started because existing solutions felt too enterprise-heavy for indie projects. I wanted something that looked professional but didn't require enterprise pricing or complex setup.
Tech stack: Ruby on Rails 8, SQLite, Turbo, Tailwind CSS. The open-core model means the full status page functionality is free forever,  our managed service just handles hosting, monitoring, and backups.
If you're running AI agents in production, check out what agent status pages look like: https://ups.dev/agent-status-demo.html
Try the live demo: https://ups.dev/ups-dev
GitHub: https://github.com/codenamev/ups
Self-hosting guide: https://github.com/codenamev/ups#self-hosting
Would love feedback from the HN community!

value: Show HN: Open-source status pages for Agents (Rails 8 and SQLite)

author: codenamev


value: bneb-dev

value:
Hey all, back again.
Ingelt is a Rust/Axum gateway that compiles 33 different legacy protocols (Modbus, BACnet, X12, SECS/GEM, etc.) into isolated WebAssembly sandboxes.
I have some background in data engineering and in the past, it was so frustrating seeing data pipelines fail due to some quirk on a single row, special character, badly escaped quote, etc... to bring down an entire pipeline.
I've been thinking about the problem space and how it abstracts nicely to a common API surface. I understand that industrial data pipelines similarly panic because a legacy C/C++ Modbus or EDIFACT parser hit a malformed hex payload and segfaulted. Industrial and supply chain data is basically hostile by default.
The architecture is pretty straightforward:
Strict Isolation: Every parse request gets its own pooled Wasmtime instance. If a parser hits an infinite loop, Wasmtime fuel metering kills it. If a malformed payload tries to allocate too much memory, a 64MB StoreLimitsBuilder ceiling traps it. The host never panics.
Streaming ABI: I recently added a chunked streaming ABI (parse_init -> parse_chunk -> parse_finalize). It can now ingest a 500MB maritime EDIFACT file with a flat ~1MB memory footprint inside the guest.
Output: It spits out clean JSON, or Apache Arrow IPC if you want to pipe it directly into a data warehouse.
It is definitely a trade-off. Crossing the Wasm boundary and doing JSON serialization inside the guest adds a few microseconds of latency compared to a raw native parser, but many parsers are pretty slow. I think the trade-off makes sense.
I'd appreciate any thoughts on the Wasm isolation model, the streaming ABI approach, or if you think there's a better way to handle the host-guest memory bridge. I'm coming at this as an outsider to industrial protocols and the painpoints for using them, and I'm trying to learn quickly.
Thanks

value: Show HN: Parsing hostile industrial data in 64MB WASM sandboxes

author: bneb-dev


value: jasondigitized

value:
I ditched my IDE for Ghostty after Opus 4.6 but kept Alt+Tabbing away to manage, read and edit markdown and config.  I created Single Pane to improve my workflow and thought I would share with HN.  You can see how it works here:
https://youtu.be/V2fOoWpAiZE
Provides built in audio and macOS notifications.  I had some fun creating different voices through ElevenLabs inspired by https://www.peonping.com/
Multiple terminal tabs that can be stacked vertically, horizontally, or in a grid.
Dual pane file manager in the spirit of Total Commander.
Markdown reader and editor with outline mode.
Ghostty inspired themes with plenty of monospace fonts to choose from.
Search within terminal, directories, and files.
Grab it here - https://github.com/jasonwilmot/singlepane/releases/latest/do...

value: Show HN: A single pane of glass for Claude Code

author: jasondigitized


value: techcam

value:
About six months ago I shipped a customer-facing feature where the system prompt had a subtle ambiguity in the instruction hierarchy. Within two days, users found a natural-language path that caused the model to ignore the safety constraint entirely.
It wasn’t a jailbreak — just phrasing I hadn’t anticipated. The prompt looked fine. It passed code review. It failed in production.
That made me realize how little tooling exists between “write a prompt” and “ship it.”
We have linters for code.
We have type checkers.
We have static analysis.
For prompts, we mostly have vibes.
So I built CostGuardAI.
npm install -g @camj78/costguardai
costguardai analyze my-prompt.txt
It analyzes prompts across a few structural risk dimensions:
- jailbreak / prompt injection surface
- instruction hierarchy ambiguity
- under-constrained outputs (hallucination risk)
- conflicting directives
- token cost + context usage
It outputs a CostGuardAI Safety Score (0–100, higher = safer) and shows what’s driving the risk.
Example:
CostGuardAI Safety Score: 58 (Warning)
Top Risk Drivers:
- instruction ambiguity
- missing output constraints
- unconstrained role scope
The scoring isn’t trying to predict every failure — it’s closer to static analysis:
catching structural patterns that correlate with prompts breaking in production.
If you want to see output before installing:
https://costguardai.io/report/demo
https://costguardai.io/benchmarks
I’m a solo founder and this is still early, but it’s already caught real issues in my own prompts.
Curious what HN thinks — especially from people working on prompt evals or LLM safety tooling.

value: Show HN: CLI to score AI prompts after a prod failure

author: techcam


value: thuongne

value:
I built Mimir because every AI coding assistant I used was effectively doing regex search over my codebase. They had no understanding of call chains, module boundaries, or blast radius.
Mimir indexes a repo into a typed knowledge graph (nodes = symbols, edges =
  CALLS/IMPORTS/EXTENDS with confidence scores) and exposes it via MCP so agents can actually
  reason about code structure.
How it works:
1. mimir analyze . — parallel AST parse (go-tree-sitter, 8 languages), scope-aware
  cross-file resolution, Louvain community detection, BM25 + HNSW vector search
   2. mimir daemon start — background MCP server
   3. mimir setup — auto-writes config into Claude Code, VS Code, Cursor, Windsurf, Zed

  Stack: Go 1.22, modernc/sqlite (pure Go, no CGO), sqlite-vec (HNSW), Sigma.js web UI

  Benchmarks vs the Node.js predecessor:
  - Cold index 1k files: 45s → < 8s
  - Incremental re-index: 45s → < 2s
  - Binary size: 350MB → < 20MB
  - RAM during index: 800MB → < 120MB

  GitHub: github.com/thuongh2/git-mimir
  Install: go install github.com/thuongh2/git-mimir/cmd/mimir@latest

Happy to answer questions about the architecture (resolver phases, incremental patching, the MCP transport layer).

value: Show HN: Mimir – open-source code intelligence for AI agents (Go, MCP, SQLite)

author: thuongne


value: yazinsai

value:
link: https://github.com/yazinsai/OpenGranola
hey HN, I built OpenGranola — a macOS app that sits next to your calls, transcribes both sides of the conversation locally, and surfaces talking points from your own notes in real time.
The idea came from having too many calls where I knew I had the perfect data point or quote somewhere in my notes, but couldn't find it fast enough. I wanted something that would do the retrieval for me, while the conversation is still happening.
How it works:
- Point it at a folder of markdown/text files (meeting prep, research, customer briefs, whatever)
- Start a call and hit "Start"
- It transcribes both speakers on-device using Parakeet TDT (no audio leaves your Mac)
- When the conversation hits a decision point or question, it searches your knowledge base and suggests relevant talking points
The whole thing can run 100% locally — pair it with Ollama/llama.cpp for LLM suggestions and embeddings, and nothing touches the network. Or use OpenRouter + Voyage AI if you prefer cloud models.
A few things I'm happy with:
- The app window is invisible to screen sharing by default, so the other side never sees it
- Transcription is fully offline via Apple Silicon neural engine (~600MB one-time model download)
- Sessions auto-save as plain text transcripts
- MIT licensed, Swift/SwiftUI, ~3k LOC
Tech stack: Swift 6.2, SwiftUI, FluidAudio (on-device ASR), RAG over local files with vector embeddings.
Requires Apple Silicon, macOS 26+. DMG on the releases page or build from source with one script.
Would love feedback — especially on the suggestion relevance and what kind of knowledge base content works best for you.

value: Show HN: OpenGranola – meeting copilot that searches your notes in real time

author: yazinsai


value: unhappychoice

value:
I have never been able to keep a diary. Tried paper notebooks, journaling apps, daily templates. Always the same arc: a week of momentum, then nothing. The busiest days vanished first, because I was too busy living them to write anything down.
At some point I noticed that I was already recording my life without trying. My calendar had every meeting. Slack had every conversation. GitHub had every commit. The raw material was there, just scattered across a dozen APIs. So I wrote a set of collectors and a cron job that pulls it all together every morning and has an LLM write a diary entry from the raw data.
Lately my conversations with OpenClaw are ending up in the diary too, and honestly those are some of the best entries. The silly back-and-forth, the questions I asked at 2am. That is the kind of thing I would never write down myself but will love rereading in a year.
The prototype worked well enough that I wanted other people to be able to use it too. That meant turning a personal cron job into a pipeline that handles many users, many integrations, and many timezones reliably every morning. That is where the real complexity lives, and what I have been building for the past month.
Service website: https://deariary.com
Public development diary generated by deariary itself: https://app.deariary.com/u/deariaryapp
Happy to talk about the approach or anything else.
P.S. I connected my Steam account and my diary casually mentioned I'd been playing Super Jigsaw Puzzle Generations for 60-120 minutes every single day for weeks. I had no idea I was doing that. This app is a snitch.

value: Show HN: deariary – An automated diary generated from the tools you use

author: unhappychoice


value: superchargeext

value: Chrome troubleshooting articles. llms.txt. FAQ schema. Five days live.<p>Claude.ai and ChatGPT are already sending referral traffic, same week Google started indexing.

value: Show HN: Site got cited by Claude and ChatGPT in under a week

author: superchargeext


value:
I'm Brian, co-founder of Faramesh. My co-founder Amjad and I were writing a research paper on AI agents last year, and the deeper we got into how agents actually execute in production the more obvious it became that there's no real solution for execution control. Agents can be sandboxed, they can have network policies, but nothing sits at the action layer and evaluates decisions before they run against an actual policy.
So we built Faramesh.
It intercepts tool calls before they execute, evaluates them against a declarative policy, blocks or approves, and logs everything. Works with LangChain, CrewAI, AutoGen, MCP, LangGraph. Open source, no signup. You can clone it and have it running against your agent in a few minutes.
The OpenShell announcement from NVIDIA this week is a good reference point for where Faramesh fits. OpenShell handles what the agent can reach. Faramesh handles what the agent is allowed to do once it gets there. Different layers.
Would love feedback from anyone running agents in production, especially where you've hit cases where access controls weren't enough.
github.com/faramesh-labs/faramesh -- faramesh.dev

value: Show HN: Faramesh – open-source runtime enforcement for AI agents


value: aarush-prakash

value:
I built FileBit because I wanted to encrypt files on my Mac without creating an account or trusting a third party with anything. Every existing solution I tried either required a subscription, phoned home, or had a vague privacy policy.
FileBit stores encrypted files locally in ~/Library/Application Support/FileBit/Vault/. Original filenames are packed inside the encrypted blob so the vault directory reveals nothing about contents.
Technical details:
AES-256-GCM via Apple CryptoKit (hardware-accelerated)
PBKDF2-SHA256 key derivation, 600k iterations
Touch ID unlock vault key stored in Keychain with Secure Enclave biometric access control
SHA-256 checksum stored in metadata, verified on every export
3-pass overwrite shredding (0x00, 0xFF, random bytes via SecRandomCopyBytes)
Full App Sandbox with no network entitlements the app cannot make network requests
One tricky part: CryptoKit doesn't expose PBKDF2 directly so I had to bridge to CommonCrypto for key derivation then hand the key back to CryptoKit. Also spent a lot of time getting SecAccessControlCreateFlags right for Touch ID with password fallback the docs are sparse.
macOS 15+ required.
Available on the Mac App Store.
https://apps.apple.com/us/app/filebit-encrypt-lock-files/id6...

value: Show HN: FileBit AES-256 file vault for macOS, zero network requests

author: aarush-prakash


value: kevin-hs-sohn

value: Show HN: Hipocampus – Persistent memory harness for AI agents

author: kevin-hs-sohn


value: Show HN: Vestigo – A local Git forensics tool to find technical debt


value: DonYin

value: Show HN: Applemail – Cursor skill for full macOS Mail.app control

author: DonYin


value: FdezRomero

value:
Hi HN, I built KonbiniAPI because every social media scraping API I tried returned raw platform JSON with different field names, structures, and conventions per platform. You end up writing adapters and fixing breaking changes instead of building your product.
KonbiniAPI normalizes everything into ActivityStreams 2.0 (the same W3C standard behind the Fediverse). A TikTok user and an Instagram user come back with the same fields: type, preferredUsername, followerCount, etc. Build once, add new platforms without code changes.
What it does:
- 30 endpoints across Instagram (10) and TikTok (20)
- Profiles, posts, comments, stories, search, followers, transcripts, and more
- Every request fetches live public data — nothing cached
- No rate limits, simple credit-based pricing
- One request = one credit, failed requests are refunded
Tech: Hono + Chanfana, OpenAPI schema auto-generated from endpoint definitions, and in-house scraping infrastructure.
Site: https://konbiniapi.com
Docs: https://docs.konbiniapi.com
OpenAPI spec: https://docs.konbiniapi.com/openapi.json
Happy to answer any questions about the architecture, the normalization approach, or the scraping challenges.

value: Show HN: KonbiniAPI – One API for Instagram and TikTok Data, Same JSON Shape

author: FdezRomero


value: sillendev

value:
Hi HN,
I built WeFrames, an iOS app that works on top of Apple Shared Albums.
Instead of browsing the whole album, it shows one shared photo per day. The same photo for everyone in the album, with reactions and comments.
The idea came from noticing that shared albums are often active but don’t really have much interaction around the photos. This tries to make them feel a bit more alive without turning them into a feed.
Everything stays in iCloud. The app just adds a layer for interaction and a daily view.
Curious if this feels useful, or if the built-in experience is already enough.

value: Show HN: WeFrames One shared photo a day from Apple Shared Albums

author: sillendev


value: ulinycoin

value:
Hi HN, I'm the creator of LocalPDF (https://localpdf.online).
The thing I'm sharing here is Studio: https://localpdf.online/app/studio
Most PDF apps are built around isolated tools — merge, split, rotate, delete pages, edit text, and so on. That works fine for one-off tasks, but a lot of real PDF work isn't one-off. Usually it's more like: open a few files, compare them, pull pages from one into another, remove junk, reorder things, make a couple of edits, then export the result.
That workflow always felt awkward to me in traditional PDF editors because you keep bouncing between separate tools and separate screens.
So I built Studio around a different model — a drag-and-drop workspace for PDFs. Instead of doing one tool at a time, you can:
- Drop multiple PDF files into one workspace
- Arrange documents on a canvas
- Drag pages between documents
- Copy, reorder, and delete pages
- Edit inside the same working area
- Export when you're done
Everything still runs locally in the browser on the user's machine — no file uploads, privacy by default, performance depends on the user's hardware, not a remote queue.
Under the hood: the UI is a canvas-style workspace, page operations are composed locally, and the output PDF is rebuilt on-device rather than sent to a backend for processing.
I've also been testing it on larger documents, because this kind of interface only matters if it still feels usable once the file stops being a tiny 3-page PDF.
What I was aiming for was something that feels less like filling out forms and more like actually working with documents.
I'd especially love feedback on:
1. Does this feel meaningfully different from existing PDF editors?
2. Is drag-and-drop organization actually a better mental model for PDF work?
3. If you work with large PDFs, what workflows would you stress test first?
Happy to answer technical questions too.

value: Show HN: Studio – a drag-and-drop PDF workspace for multi-document workflows

author: ulinycoin


value:
Hi HN,
Interactive Brokers is an incredibly powerful platform, but using their official desktop client (TWS) feels like a punishment. It's a massive, resource-heavy Java app from the late 90s that makes simple workflows incredibly tedious.
I got tired of clicking through archaic menus, so I built ibkr-cli: a local-first, modern command-line interface to bypass the TWS UI entirely.
But a terminal wasn't the endgame. By turning trading actions into simple terminal commands with structured JSON outputs, it essentially acts as the perfect "pair of hands" for AI agents to interact with your portfolio directly.
Instead of fighting the GUI, you can now manage your trading through agents:
- *Claude Code*: Just run `npx skills add fatwang2/ibkr-cli`. Once installed, you can literally tell Claude: "Check my IBKR account, what's my current PnL, and prepare an order to buy 10 shares of AAPL."
- *OpenClaw (ChatOps)*: Hook it up to Telegram or Discord, and turn your bot into a personal, conversational trading assistant.
To answer the obvious question—"Is it safe to let an LLM near my brokerage account?"—I built it with a strict Safety-First design. All order commands default to a safe `--preview` (what-if) mode. A real trade will only execute if the agent or user explicitly appends the `--submit` flag.
It handles local profile management (TWS/IB Gateway), TCP connectivity checks, portfolio queries, and market data snapshots out of the box.
If you share the pain of using IBKR's default UI, or if you're experimenting with letting LLMs manage your trades, I'd love for you to try this out and let me know what you think!
Repo: https://github.com/fatwang2/ibkr-cli

value: Show HN: Ibkr-CLI – A local-first Interactive Brokers CLI built for AI agents


value: mindsaspire

value: Show HN: Ranvier – Prefix-aware routing for LLM inference

author: mindsaspire


value: exalted

value: Show HN: Balsamiq Wireframes MCP

author: exalted

title: Show HN: Balsamiq Wireframes MCP


value: aarmenante

value: Show HN: Bento – Save and restore multi-monitor app layouts

author: aarmenante


value: metaphorical

value: An experimental python library I've been working on and off as a side project for years (mostly procrastinating). It's a follow-up of Pts.js, with the intent to explore more on visual composability. I would love your feedback :)

value: Show HN: Pts.py – Visual thinking in code

author: metaphorical


value:
Hi HN,<p>I built Virlo originally to go after the clipper/clipping market. We had so many customer approach us looking for more (essentially programmatic GTM tool for short-form) that we decided to “answer the mkt”.
The pattern was the same on calls we had with early users, that weren't in our OG ICP: Head of Social is pulling inspo manually, creative director is copying trends that peaked three weeks ago, media buyer has no visibility into what competitors are actually spending behind on Meta. Everyone's working hard. Etc, etc…
Virlo fixes the signal layer. You set up custom niches by keyword and platform, it’s studying short-form continuously, and outlier videos and creators surface automatically. Meta Ads tracking shows you what competitors are running and actively funding. Then the content studio converts that performance data into briefs and copy.
Hardest part technically was building the infrastructure, but lately the hardest part has been ensuring our docs (especialyl on the API side, dev.virlo.ai) works well with OpenClaw agents. We’ve seen a massive influx in business from folks that are getting purely recommended virlo’s api without us even really marketing it, so transitioning our docs to be as “agent ready’ as possible is a massive pain point for us right now.
Fun building out there! If you want to reach out to me you can find me at nic@virlo.ai…

value: Show HN: I built a short-form content intelligence tool for media buyers


value: faustoct

value: Built this as a small social experiment: every user gets one post for life (permanent, no deletes/do-overs). After posting, you unlock the feed and see what everyone else chose.

value: Show HN: Website lets you post only once for life

author: faustoct


value: scaelere

value:
I wanted a simple and flexible method to quickly add and remove domains and backend servers for remote access from my home network, without going through the pain of manually configuring nginx for any change.
What I've come up with is a simple configuration-based (json or yaml) templating system.
With nginx-quick-relay you can add back-ends to two groups:
- `pass-through`: it forwards HTTP+HTTPS traffic as is with optional PROXY protocol, OR
- `direct-serve`: it acquires and renews certificates, redirects HTTP to HTTPS, and forwards traffic to your HTTP/HTTPS endpoint
It also handles
- client certificates (per domain) to only allow trusted peers to access your resources
- optional exclusion of local network traffic from client certificate requirement (based on CIDR)
- server certificates (per back-end server)
- PROXY protocol to preserve info on the requesting client

value: Show HN: Open-Source Configuration-Based Secure Access to your Home Network

author: scaelere


value:
Me and my friend Claude (but mostly him) created this little gui to processa and navigate big json files.
It's blazing fast, its core is built in Rust and the UI is made in React (via tauri).
I hope you like it and I am open for suggestions and or bug reports.

value: Show HN: JSON GUI, a fast GUI to view, navigate and process JSON files


value: jballanc

value:
For the past 15 years I have wanted to write a Scheme implementation that was, effectively, macros to LLVM. When I first got my hands on Cursor and was looking for some random, non-critical project to "vibe code" on, I remembered this idea from long ago. After a heady weekend of truly vibing with Cursor, having it ask all the right questions and make amazing suggestions, I had a complete project that...crashed immediately at any attempt to even compile.
The code was complete garbage, but the feeling was real, and the Vibe programming language was born. It's taken a year of nights-and-weekends, but I finally have a self-hosting variant of a Scheme built up on top of LLVM.
Along the way, I have learned so much about what it means to code with an LLM as your partner. I have tried, true to its name, to only vibe-code Vibe...though I have had to get my hands dirty and touch the code on a few occasions. (Cursor's Composer 1.5 has a real problem with balancing parens...which makes me think that implementing runtime structured editing might start moving up on the list of desired features.)
It should go without saying: Vibe is not even on the horizon of "production ready"...but I have a sense that it could get there faster than you might expect.

value: Show HN: Vibe – a language for humans and AI to reason about programs together

author: jballanc


value: victorbuilds

value: Show HN: NC Web – Norton Commander for the web, built with vanilla JavaScript

author: victorbuilds


value: jackgladowsky

value:
Hi everyone,
Over the weekend Claude and I built mcp-certify.
Been using MCP since Anthropic dropped the protocol and as its gotten more popular, security has been a major problem for people wanting to run/connect to MCP servers, so I built this CLI that automatically can test any MCP server for:
- protocol compliance
- security
- logic correctness
- performance
- supply chain
It returns a single score and detailed findings for the server. Currently works best with local/self-hosted servers (stdio or HTTP). Working on better support for OAuth and cloud-hosted servers next.
Repository: https://github.com/jackgladowsky/mcp-certify
Install: npm install -g mcp-certify
Would love some feedback, bug reports, or anything!

value: Show HN: MCP Certify – Auto-test MCP servers for security and compliance

author: jackgladowsky


value:
Hey HN, I built a CLI tool for comparing GPU and LLM pricing across 100+ cloud providers.
It pulls live data from deploybase.ai and lets you filter and search right in your terminal:

  deploybase gpu --model h100
  deploybase gpu --provider lambda
  deploybase gpu --type bare metal
  deploybase llm --author anthropic
  deploybase llm --provider google vertex
  deploybase llm --modality image

Install with npm install -g deploybase-cli. Open source, MIT licensed.
I'd love feedback on the UX, missing providers, or features that would make this more useful.

value: Show HN: Deploybase CLI – Search GPU and LLM pricing from your terminal


value: skenderbeu

value:
I kept ending up with HTML files Claude Code generated — charts, reports, prototypes. Sharing them was annoying, so I built sHTMLs (https://shtmls.com): drop in an HTML file, set a password, get a short URL. No signup. Expires in 30 days.
The more interesting part: there's a llms.txt at shtmls.com/llms.txt describing the
API. Paste this into Claude Code, Cursor, Gemini CLI, etc.:

  "Read shtmls.com/llms.txt and add sHTMLs to your workflow config (CLAUDE.md,
  .cursorrules, or equivalent) so you can upload HTML files with a password anytime"

The agent reads the docs, adds sHTMLs to its own config, and starts uploading
autonomously. It just ends tasks with "uploaded to shtmls.com/xyz, password: abc."
Stack: Python Lambda + DynamoDB + S3 + CloudFront, CDK-deployed. Passwords are
PBKDF2-SHA256 hashed. Vanilla JS frontend, no frameworks.
Curious if others are building the llms.txt self-configuration pattern into their tools.

value: Show HN: SHTMLs – HTML pastebin where the AI uploads its own output

author: skenderbeu


value: Havunen

value:
We are launching GitComet today!
It’s a fast, local-first, open-source Git client for Linux, macOS, and Windows. We started building it after running into the same problem over and over: Git tools felt fine on small projects, but got painful on large repos and big diffs.
Project main focus is speed:
It can open Chromium repository blazingly fast  (in less than 1 second). It can diff 50mb file with syntax highlighting without lagging. Memory usage stays within few hundred MBs at all times. Its fast to pick up as user interface follows familiar tools like GitKraken, SourceTree and Github Desktop application
If you try it, We would love to hear feedback! Also if there are people who would like to contribute PR's are welcome.

value: Show HN: GitComet speedy Git GUI written in Rust end-to-end

author: Havunen


value: Daminoup

value:
We built WattSeal, an open-source tool that estimates per-application power consumption on PCs.
Most monitoring tools expose CPU or GPU usage per process, but not energy usage in watts. We wanted to see where the actual power goes.
WattSeal measures total system power and combines it with system telemetry to estimate how much energy each process is responsible for. It gathers metrics from CPU, GPU, RAM, disk, network and distributes total power across running processes.
The backend is written in Rust and runs as a lightweight background process that records measurements in a SQLite database. The UI is built using the iced Rust GUI library.
One of the trickiest parts is attributing total system power to processes when most hardware only exposes component-level telemetry (e.g. CPU package power via RAPL or GPU power counters).
The project is open source and currently supports Windows, Linux and macOS, with hardware from Intel, AMD and NVIDIA.
Download it here: https://wattseal.com
This is our first Rust project, feedback from people familiar with system telemetry or energy monitoring would be very welcome.

value: Show HN: WattSeal – PC power consumption monitor

author: Daminoup


value: sethd

value:
I built atria, a terminal UI for managing multiple agent sessions in one place. It works as an "agent multiplexer" for sessions running on your own machine.
If you're thinking "why not just use tmux?": It works fine alongside tmux and gives you extra status, visibility, and quick control over agent sessions.
There's three ways to use it:
- Standalone with embedded terminal multiplexer (works in any terminal).
- Integrated with tmux (which still lets you launched into embedded if you want).
- "magic" integration with a few terminals: iTerm2, kitty, and WezTerm.
Supports Claude Code, Codex, OpenCode, and Copilot.
Built with Claude Code and Codex. :)

value: Show HN: Atria – terminal UI for managing multiple coding agents

author: sethd


value: paynedigital

value:
Hi HN!
Like a lot of people, I love Granola and use it every day. The onboarding experience, the numerous delighters, the flourishes and the way it just works are all testament to the quality bar you can clear with an Electron app given enough care and expertise. It was the first app I'd ever used which recorded system audio on Mac without recording video too, which sparked a year-long obsession with Apple's Core Audio taps API, led to me creating an open source Swift library which makes that API easier to use, and won me several bits of fascinating freelance work.
One thing I've never loved is that everything passes through and only exists on someone else's servers. Every frame of audio - from your mic or other speakers on your call - goes through one of the SOTA realtime ASR providers. Your transcript and notes presumably pass through a frontier cloud LLM, and your summaries live on Granola's servers. There are lots of upsides to this: the transcription speed and quality are unmatched, the summarisation is awesome, and your meeting notes sync across all your devices, though all at the cost of privacy.
I've been building up my toolkit in this space for a while: System Audio recording, custom notification windows, Acoustic Echo Cancellation, automatic meeting detection - different parts of the puzzle I've slowly pieced together over the past year or so. Recently discovering FluidAudio[1] finally let me build something I've wanted for a while: an app which privately transcribes your meetings in realtime, captures both sides of each call, and stores and summarises entirely on device. It's called talat[2], and I launched an early pre-release version last week.
It's a Tauri app, which means the download size weighs in at 20MB. It's also a commercial project - I'm self-employed and need to make a living - but I hope even in the day and age of AI-commoditised software, there's enough in the app today and the direction of travel to justify the one-time purchase cost. While default-private is important, so is empowerment, so it lets you configure almost everything, including whether you want to use a different on-device or cloud LLM for summarisation.
Lots of stuff needs improvement. Speaker diarisation is pretty rough. The app is macOS only and needs an M-series chip due to its use of the ANE for transcription. Local LLM summarisation (Qwen3-4B-4bit is the default) can be hit and miss, though in truth the more I use talat, the less I care about summarisation and the more I care about the transcript simply being there, ready to refer back to later as and when I want to.
I'd really value your feedback, and I'd be delighted to answer any questions. The implementation was hugely accelerated through Claude Code, but the architecture, the design patterns, and all the little hard-won pieces of the puzzle mentioned earlier are entirely human. You don't need an account to use it, and there are no in-app analytics tracking what you're up to.
[1] https://github.com/FluidInference/FluidAudio
[2] https://talat.app

value: Show HN: On-device meeting transcription for your Mac

author: paynedigital


value: plsft

value:
Hi HN,
I'm George. I've built lots of business applications but never a personal application.
After staring at my GitHub graph, I realized my actual life doesn't have a contribution chart. My app, Lifetale, gives you ~1,000 squares (one per month of life), colored by how each month felt, not how much you posted. I wanted sharing to be opt-in and limited so you can create 'circles' to share specific days and memories with close friends and loved ones, but not the world.
Beta is live on TestFlight. Happy to send invites to anyone who wants to try it — just join the waitlist on the site.
Technical: Hono on CF Workers, D1, R2, React Native/Expo. Passwordless auth via Resend. Private posts stay in IndexedDB on device. Photo scanner is really fast and populates your grid in a few seconds using the EXIF data from the photos.
Would love feedback on the grid concept. The most surprising thing has been watching which squares people fill first.

value: Show HN: I turned GitHub's contribution graph into a life journal

author: plsft


value: gemanor

value:
Hi HN, Gabriel, Co-Founder at Permit.io. We're releasing Permit MCP Gateway today, an authorization proxy for MCP servers.
TL;DR - we built an MCP Gateway that developers love and CISOs trust. Watch more[0]
Now, after your little hate on using fancy copy on HN, to the real thing:
MCP is in a strange place. Developers are debating whether it's overcomplicated compared to CLIs or skills files. Meanwhile, enterprises are adopting it by default because every agentic system that acts on your behalf, Cursor, Claude, Copilot, internal agents, needs a stable infrastructure for connecting to tools. MCP is the only standardized protocol for AI proactively acting on internal systems. Whether you love the protocol or not, it's where enforcement needs to happen.
We build authorization infrastructure (OPA-based, Zanzibar-style ReBAC, sub-10ms decisions). As our customers adopted AI tooling, MCP authorization became the most common gap they hit. The protocol has authentication (OAuth 2.1 in the latest spec), but no authorization layer. Once an agent authenticates, it can call any tool on the server. There's no per-tool policy, no way to scope what an agent can do based on who authorized it, no consent flow where a human explicitly approves what an agent can access, and no audit trail linking tool calls back to a human decision.
So we built a proxy that adds what's missing. You point it at any MCP server, change one URL in your client config, and every tool call gets evaluated against fine-grained policy before reaching the upstream server.
What the gateway does:
- Sits between MCP clients (Claude, Cursor, VS Code, custom agents) and upstream MCP servers
- Auto-generates authorization policies per tool when you connect a new server
- Evaluates every tools/call request against policy in real time
- Tracks the delegation chain: which human authorized which agent, at what trust level
- Enforces trust ceilings so an agent can't exceed what its human granted
- Human-in-the-loop consent flows for sensitive tool access (visual editor, white-label support)
- Logs every allow/deny decision with full context
The policy engine underneath uses OPA and a Zanzibar-style relationship graph (ReBAC). It supports RBAC, ABAC, and ReBAC. This is the same engine we've been running in production at companies like Tesla, Cisco, and Intel for application-level authorization. Extending it to MCP tool calls was a natural fit because the trust model maps directly: human -> agent -> server -> tool is just another relationship graph.
Tech details: the gateway speaks MCP natively (SSE transport, working on Streamable HTTP). It proxies the full MCP lifecycle including tool discovery, so it can inspect available tools and generate contextual policies on connection. Authorization decisions are evaluated by Permit's PDP (policy decision point) with sub-10ms latency. You can run it hosted (*.agent.security) or deploy the PDP in your own VPC for data residency.
Docs: https://docs.permit.io/permit-mcp-gateway/overview
Architecture: https://docs.permit.io/permit-mcp-gateway/architecture
Try it: https://app.agent.security
Happy to answer questions about the authorization model, the policy engine, the trust delegation approach, or hear how others are solving this.
[0] youtube.com/watch?v=plqcg31hsk8

value: Show HN: Permit MCP Gateway – Fine-Grained Authorization and IGA for MCP

author: gemanor


value: frntn

value:
I built an AI agent that fits in 6,832 bytes. The entire runtime (binary, bridges, tools, config) is ~23 KB.
PlanckClaw is written in x86-64 assembly (obviously AI assisted code generation for this one) and uses only 7 Linux syscalls. No libc, no allocator, no runtime. The binary is a pure router: it reads messages from named pipes, asks another pipe what tools exist, builds a JSON prompt, writes it to a third pipe, parses the response, dispatches tool calls, and relays the answer. It never touches the network or executes tools directly.
Everything else composes around it in shell scripts (~460 lines total):
- bridge_brain.sh: curls the Anthropic API (~90 lines)
- bridge_discord.sh: Discord Gateway via WebSocket (~180 lines)
- bridge_cli.sh: terminal interface (~40 lines)
- bridge_claw.sh: tool discovery and dispatch (~50 lines)
Four processes, six named FIFOs, zero shared state. Adding a tool means dropping a shell script in claws/. No restart, no recompilation, no config change.
It does real things: tool use (via Claude's tool_use protocol), persistent conversation history in append-only JSONL, automatic memory compaction when history grows too long, and a swappable personality file (soul.md).
This started as a thought experiment: modern agent frameworks pull 400+ transitive dependencies and ship 100+ MB runtimes before generating a single token. I stumbled upon multiple minimalist initiatives like picoclaw, nanoclaw or zeroclaw. I wanted to find the minimum viable agent (the Planck length of AI agents) and see what you could build with just pipes and syscalls.
It's not production software. Buffers are fixed-size (messages > 4 KB get truncated), it only runs on Linux x86-64, and error handling is basic. But it works perfectly and the entire codebase (~2,800 lines including the assembly) is easily auditable.
The wire-level protocol specs for all three extension points (interact, brain, claw) are documented in PROTOCOL.md if you want to write your own bridge.

value: Show HN: PlanckClaw an AI agent in 6832 bytes of x86-64 assembly

author: frntn


value:
9 short lessons, ~60 lines of Python. Each adds one concept — tool calling, memory, state, policy gates, self-scheduling — until you see the full agent stack.
The core loop is just a while loop. That's AgentExecutor. That's what the frameworks do.
Runs in the browser (Pyodide). No setup, no signup. Mock mode works instantly, or plug in a free Groq API key for live LLM responses.
Open source: https://github.com/ahumblenerd/tour-of-agents

value: Show HN: A 30-minute course to get up to speed on how AI agents work


value: dfskGT

value: Show HN: LocalSquash – A local web UI for FFmpeg.wasm

author: dfskGT


value: enzovn

value:
Hi HN,
I've been building Lukan, an open-source (MIT) agentic workstation that runs entirely as a single Rust binary with zero runtime dependencies.
I started this because I wanted a unified workstation optimized for my own productivity. My goal was to build an environment where I could securely remote into my machine from anywhere, seamlessly view and modify local files, and run AI agents or drop into a terminal side-by-side, all integrated with a rich set of built-in tools.
Here is what makes it different:
Multi-agent sessions: Run multiple agents in parallel, each with its own isolated context and history. You can switch between them using tabs, resume after disconnects, and even rewind to previous checkpoints.
Embedded terminal: A full tmux-backed terminal lives inside the Web and Desktop UI. Sessions survive page reloads and network drops. You can run any CLI tool alongside your agent (including Claude Code, Codex CLI, Lukan Cli, etc.).
Pipelines & Background workers: DAG-based multi-agent workflows with a visual editor, human-in-the-loop approval gates, and cron-style autonomous tasks that keep running while you're away.
E2E encrypted remote access: Access your workstation from any browser without port forwarding. It uses X25519 key exchange + AES-GCM, meaning the relay server never sees your data.
Bring your own model: Native support for Anthropic, OpenAI, GitHub Copilot (via OAuth, no API key needed), Gemini, Ollama, and any OpenAI-compatible endpoint (vLLM, LM Studio). You can swap models mid-session using /model.
Browser automation: Built-in Chrome DevTools Protocol support. The agent can navigate, screenshot, click, type, eval JS, and export PDFs.
Sandboxed execution: OS-level isolation using bubblewrap (bwrap) on Linux and sandbox-exec (Seatbelt profiles) on macOS. You can configure allowed paths, and it automatically detects and protects sensitive files like .env, .ssh/, and .aws/.
Plugin ecosystem: WhatsApp, Telegram, Slack, Discord, Gmail, Workspace, Docker monitor, and local audio transcription via Whisper (no data leaves your machine).
The backend is built entirely in Rust with a React/TypeScript frontend.
Quick start: curl -fsSL https://get.lukan.ai/install.sh | bash (Or via Docker: docker run -d -p 3000:3000 lukanlabs/lukan)
Repo: https://github.com/lukanlabs/lukan
Docs: https://docs.lukan.ai
I'm not a professional software engineer — this started as a personal project to scratch my own itch. The codebase has grown a lot and I'm sure there are things that could be done better. Feedback, criticism, and suggestions are very welcome.
I'll be around to answer any questions about the Rust architecture, the E2E encryption design, our cross-platform sandboxing, or anything else!

value: Show HN: Lukan – An open-source agentic workstation in a single Rust binary

author: enzovn


value: hsynkrkye

value:
Hi HN. I poured months into making a mobile app called Codala, but sadly, it's getting practically zero downloads. I have no marketing budget at all.
I'm starting to question if the app is just bad, but the core idea feels solid to me: you scan any QR code or barcode, and it opens up a space to chat, leave reviews, and discuss that specific product or place.
I know the app needs users leaving comments to feel alive, but it's been 3 weeks and things are dead quiet. If you want to take a look, I’m totally open to any feedback or honesty.
It's only available on Google Play for now

value: Show HN: Codala, a social network built on scanning barcodes

author: hsynkrkye


value: terryops

value:
Hi HN, I built tools.video (https://tools.video) — 18 free video and audio tools that run entirely in your browser. Files never leave your machine.
Compress, convert, trim, crop, resize, merge, rotate, reverse, speed change, screenshot, mute, video-to-GIF, audio extract/trim/convert/merge/speed, and media info.
The interesting technical problem: FFmpeg compiled to WASM works, but it tops out around 4 GB, runs single-threaded, and is 10x slower than native browser APIs for the same operations. I wanted to handle 50 GB files and actually use the hardware (theoretically there's no limit at all).
So I built a hybrid engine:
- Most tools use WebCodecs (via MediaBunny) — the browser's native hardware-accelerated video encoder/decoder. H.264, HEVC, VP9, AV1 with GPU acceleration when available. This is what makes it fast.
- Three tools (speed, merge, video-to-GIF) still use FFmpeg WASM where WebCodecs can't do the job.
- The engine auto-detects which path to use and falls back gracefully — if hardware encoding fails, it retries in software; if WebCodecs can't handle a codec, it routes to FFmpeg.
How 50 GB works in a browser:
Files are streamed through OPFS (Origin Private File System) with chunked I/O. Small files (<256 MB) stay in memory. Larger files write to OPFS-backed storage. The biggest files use StreamTarget for chunked streaming so you never buffer the entire output in RAM. Stale temp files auto-clean after 6 hours, and quota-exceeded errors trigger aggressive cleanup mid-operation.
Other details HN might find interesting:
- Processing runs in a Web Worker with stall detection (180s timeout). If the worker crashes, it falls back to main thread automatically.
- Audio extraction with stream copy (no re-encoding) skips disk I/O entirely — zero-copy transmux via BufferTarget.
- Codec extensions (MP3, FLAC, AAC, AC3 encoders as WASM) are loaded on demand but can't run in the Worker — esbuild corrupts their inline WASM binaries during double-bundling, so they route to main thread.
- 30+ formats, 5.1/7.1 surround audio preserved, 19 languages.
There's a /benchmark page if you want to compare the WebCodecs path vs FFmpeg WASM directly with audio extraction.
Built with Next.js 15, React 19, TypeScript, Tailwind v4, Zustand.
Would love feedback — especially on formats/codecs you'd want supported, or edge cases where processing fails.

value: Show HN: Tools.video – Browser-native video processing at 50 GB scale

author: terryops