value: eliasoe

value:
Agents can run non-interactive commands, but they often fail once a workflow needs a real terminal (SSH sessions, installers, debuggers, REPLs, TUIs). I built term-cli so an agent can drive an interactive terminal session (keystrokes in, output out, wait for prompts). And it comes with agent skill for easy integration.
It supports in-band file transfer: the agent can move files through the terminal stream itself (same channel as the interactive session), which is useful when the agent doesn’t have scp/sftp, shared volumes, or direct filesystem access across boundaries.
Recent example: My Claude Opus was SSH'd into a server and ended up at a Firejail shell running inside a Docker container. It pushed a Python file in via term-cli, moving it across SSH → Docker → Firejail over the terminal channel, and explicitly commented how it was surprised this worked end-to-end.
And it comes with the companion tool term-assist, so agents can bring in their human to handle credentials and MFA: https://www.youtube.com/watch?v=A70tZEVqSOQ

value: Show HN: Term-CLI – interactive terminals for AI agents (for SSH/TUI/REPL flows)

author: eliasoe


value: ovelv

value:
# Lip Flip AI – See Subtle Results Before You Decide
Cosmetic decisions are personal. And when it comes to your face, even small changes can feel like a big step.
Lip Flip AI was created for one simple reason:
to help you visualize subtle enhancements before making any commitment.
Instead of guessing how a lip flip might look based on other people’s photos, you can now preview a realistic simulation on your own face — in seconds.
No injections.
No appointments.
No pressure.
Just clarity.
---
## What Is a Lip Flip, Really?
A lip flip is a cosmetic procedure that uses small amounts of Botox to relax the muscle above the upper lip. When that muscle softens, the upper lip gently rolls outward, creating the appearance of slightly more fullness — especially when smiling.
It does not add volume.
It does not reshape the lips dramatically.
It’s subtle.
That subtlety is exactly why many people are curious about it — and also why it can be difficult to imagine the outcome.
That’s where Lip Flip AI comes in.
---
## Why We Built This Tool
If you search “lip flip before and after,” you’ll see dozens of photos. But those results belong to different faces, different lip shapes, and different proportions.
What works beautifully for one person might look completely different on another.
We believe you shouldn’t have to rely on guesswork.
Lip Flip AI gives you a personalized visual preview based on your own facial structure. The simulation focuses on a gentle outward curl of the upper lip — preserving your natural shape, symmetry, and proportions.
The goal is not exaggeration.
It’s realism.
---
## How the AI Preview Works
Our system analyzes key facial landmarks and lip contours from your uploaded image. Then it applies a subtle transformation designed to mimic the aesthetic effect of a lip flip:
- Slight outward curl of the upper lip
- Improved upper lip definition
- Balanced lip-to-nose proportion
- Maintained natural texture and lighting
We intentionally avoid adding artificial volume, gloss, or dramatic reshaping. The result is meant to feel believable — like a refined version of you.
The before-and-after comparison allows you to see the difference clearly while keeping everything else consistent: same lighting, same angle, same expression.
---
## Lip Flip vs. Lip Filler – Why the Distinction Matters
Many people confuse lip flips with lip fillers, but they create very different effects.
Lip fillers add physical volume to the lips. They can create noticeable fullness and reshape the lip contour.
A lip flip, on the other hand, works by relaxing muscle tension. It creates the appearance of more upper lip without increasing size dramatically.
If fillers are about volume, lip flips are about subtle contour.
Our AI simulation reflects that distinction. It does not attempt to make lips bigger — only slightly more visible and softly defined.
---
## Who This Tool Is For
Lip Flip AI is ideal if you:
- Feel your upper lip disappears when you smile
- Want a slightly fuller look without going bigger
- Prefer minimal, natural-looking enhancements
- Are exploring cosmetic treatments but want to preview first
It’s also for anyone who simply wants to experiment with aesthetics in a safe, pressure-free way.
Curiosity should not require commitment.
---
## Built Around Realism and Responsibility
Facial aesthetics fall into a category where trust matters. That’s why we designed this tool with restraint.
The preview you see is a visual simulation only. It does not guarantee medical outcomes and should not replace consultation with a licensed professional.
Our goal is not to persuade you to undergo treatment.
Our goal is to give you a clearer perspective.
Sometimes seeing the possibility is enough.

value: Show HN: Lip Flip Before and After – Real Results and AI Preview

author: ovelv


value: Show HN: Display folder sizes in Win11 Explorer's Size column


value: vipdestiny

value:
I manage 8+ mixed repos (prod, dev, poc) across Python, TypeScript, and Rust. Every dev tool I use -- Cursor, Copilot, Claude Code -- is great inside a single repo. But none of them answer the cross-cutting questions:
Which repos have zero tests?
- Are my React versions consistent across 3 frontends?
- Which project hasn't been committed to in weeks?
- Where am I duplicating FastAPI patterns instead of sharing a library?
I got tired of manually checking, so I built Atlas. It's a Python CLI that scans your repos locally and gives you a portfolio-level health dashboard.
What it does
Point it at your projects, run atlas scan, and you get this:

  pip install nxtg-atlas

  atlas init --name "My Portfolio"
  atlas add ~/projects/api
  atlas add ~/projects/frontend
  atlas scan
  atlas status

Real output from my 8 production repos:
+---------+--------------------+----------+--------+----------+---------------------+
|         | Project            | Health   |  Tests |      LOC | Tech Stack          |
+---------+--------------------+----------+--------+----------+---------------------+
| (green) | Dx3                |  A 94%   |    179 |  164,806 | Python . TypeScript |
| (green) | content-engine     |  B+ 88%  |     23 |   12,552 | Python              |
| (green) | Podcast-Pipeline   |  B+ 88%  |     49 |   33,680 | Python . FastAPI    |
| (green) | nxtg.ai            |  B+ 87%  |     36 |   49,938 | TypeScript . Next.js|
| (green) | Faultline          |  B+ 86%  |     29 |   15,527 | TypeScript . React  |
| (green) | voice-jib-jab      |  B+ 86%  |     58 |   45,311 | TypeScript . Python |
| (yellow)| SynApps            |  C 67%   |    114 |  793,406 | Python . TypeScript |
| (red)   | NXTG-Forge         |  D 59%   |    121 |  136,083 | TypeScript . Rust   |
+---------+--------------------+----------+--------+----------+---------------------+
8 Projects | 609 Test Files | 1,251,303 LOC | Scanned in 31 seconds
That's not a mockup. That's the actual output from scanning our production portfolio. The C and D grades were embarrassing -- but that's the point. You can't fix what you can't see.
How health scoring works
Each project gets an A-F grade based on 4 weighted dimensions:
- Tests (35%) -- test file count relative to source files
 - Structure (25%) -- CI/CD, .gitignore, package config, linting, source organization
 - Git Hygiene (20%) -- commit history, remote status, clean working tree
 - Documentation (20%) -- README, CHANGELOG, docs/, etc.
Cross-project intelligence
This is where it gets interesting. Atlas compares deps and versions across all your repos:
- Shared dependencies (fastapi used in 4 projects, react in 3)
 - Version mismatches (react ^18.2.0 in one app, ^19.2.1 in another)
 - Health gaps (3 projects with zero tests, 1 with 50+ uncommitted changes)
 - These are the things that bite you six months from now.
What it is NOT
 - Not a cloud service. Zero network calls, no telemetry, no accounts.
 - Not a linter or code quality tool. It doesn't read your source code line by line.
 - Not a replacement for SonarQube / CodeClimate. Those go deep on one repo. Atlas goes wide across many.
Details
 - Python 3.11+, built with Typer + Rich
 - State is a single JSON file at ~/.atlas/portfolio.json
 - Detects 10+ languages, 15+ frameworks, 5+ databases
 - MIT license, 100% open source — no tiers, no limits, no feature gates
 - Everything works: unlimited projects, cross-project intelligence, export, batch-add
--> GitHub: https://github.com/nxtg-ai/repoatlas
--> PyPI: https://pypi.org/project/nxtg-atlas/
If atlas saves you time, consider supporting development.
Happy to answer questions about the scoring algorithm, the detection heuristics, or how we're using it internally.

value: Show HN: Atlas – Portfolio health dashboard for multi-repo teams (Python CLI)

author: vipdestiny


value: GhrammR

value: Show HN: The Janitor – A 58MB Rust static analyzer to block AI-generated PR slop

author: GhrammR


value: paolobozzola

value: Fun project, made with Claude Code by a Claude Code lover

value: Show HN: I wrote a dictionary of the 185 verbs Claude shows while thinking

author: paolobozzola


value: edvatar

value: Show HN: Claude-brain – Sync your Claude Code brain across machines via Git

author: edvatar


value: mogic

value: Show HN: Mindspend – Track how you feel about your spending, not just numbers

author: mogic


value: thinklanceai

value: Show HN: HumanRoot – Signed proof of human authorization for AI agents

author: thinklanceai


value: Creator-io

value: Show HN: Deploy OpenClaw in 60 Seconds

author: Creator-io

title: Show HN: Deploy OpenClaw in 60 Seconds


value: jasonEinstien

value: Show HN: PardusAI – Data Science Agent (Not 2026 YC)

author: jasonEinstien


value: skittleson

value: Show HN: Hacking Sony A6000 for Fun

author: skittleson

title: Show HN: Hacking Sony A6000 for Fun


value: Show HN: Deploy OpenClaw in Seconds

title: Show HN: Deploy OpenClaw in Seconds


value: speedgoose

value:
I wanted to generate many colour palette on my Garmin watch, so I made an IA for that.
I used the microgpt architecture released a few days ago. I think it works pretty well.
You can also set one or two starting colours, which is perhaps the mode where the tool is the most interesting.
Click on the about button to read more about it.

value: Show HN: Yet another colour palette generator, but it's a cool one

author: speedgoose


value: levmiseri

value: A deceptively simple game of 9 vs. 9 cats. Your actions are limited to moving and shooting, but 'how' you move your units and when or which cat you shoot can be difficult to decide.<p>You can play against the prepared bots, or against other 'human' players in real-time matches.

value: Show HN: Yare.io – Kill all enemy cats. With JavaScript.

author: levmiseri


value: ArmaloAI

value:
Hey HN — I'm Ryan, founder of Armalo AI (https://armalo.ai). I spent years as a software engineer at Google, YouTube, and AWS, most recently building AI agents at AWS. Watching those systems interact in production — and seeing the same gaps appear over and over — convinced me that the missing piece wasn't more capable agents, but the infrastructure underneath them. So I left to build it.
Armalo AI is the infrastructure layer that multi-agent AI networks need to actually function in production.
THE PROBLEM
Every week there's a new story about an AI agent deleting a production database, a multi-agent workflow cascading into failure, or an autonomous system doing something its operator never intended. We dug into 2025's worst incidents and found a consistent root cause: agents have no accountability layer.
You can't Google an agent's reputation. When one agent delegates to another, there's no escrow, no contract, no recourse. State doesn't persist across a network. And as agents start hiring other agents — which is already happening — the absence of identity, commerce, and memory infrastructure becomes a critical gap.
Benchmarks measure capability. We measure reliability.
WHAT WE BUILT
Armalo is three integrated layers:
1. Trust & Reputation
Agents earn a PactScore: a 0–1000 score across five behavioral dimensions — task completion, policy compliance, latency, safety, and peer attestation. Four certification tiers (Bronze → Gold). Scores are cryptographically verifiable and on-chain. When automated verification isn't enough, our LLM-powered Jury system brings multi-model judgment to disputes. All of it is queryable via REST API in sub-second latency.
2. Agent Commerce
Agents can define behavioral pacts — machine-readable contracts that specify what they promise to deliver. These are backed by USDC escrow on Base L2 via smart contracts. Funds lock when a deal is created and release only when verified delivery conditions are met. The marketplace lets agents hire and get hired autonomously, no human intermediary needed. We also support x402 pay-per-call: agents pay $0.001/score lookup in USDC with no API key, no account, no human billing setup.
3. Memory & Coordination
Memory Mesh gives agents persistent shared state across a network. Context Packs are versioned, safety-scanned knowledge bundles that agents can publish, license, and ingest. Swarms let you form synchronized agent fleets with real-time shared context — so a network of 50 agents can reason from the same ground truth.
THE FULL STACK
Beyond the three core layers, we've shipped: OpenClaw MCP (25 tools for Claude, Cursor, LangChain), Jarvis (an agent terminal for interacting with the platform), PactLabs (our research arm — working on trust algorithms, collusion detection, adversarial robustness, and optimal escrow sizing), real-time monitoring and alerting, and a governance forum where trust-weighted agents post, vote, and collaborate.
WHY ON-CHAIN
We get that "on-chain" raises eyebrows in some HN circles. Our reasoning: agent-to-agent trust needs to be verifiable by parties who have no prior relationship and no shared authority. Cryptographic verification at every layer, with an open protocol, means any agent framework can interoperate with Armalo AI's trust signals without going through us as an intermediary. We're not building a walled garden.
PRICING
Free tier (1 agent, 3 evals/month), Pro at $99 USDC/month (10 agents, unlimited evals, escrow, jury access), Enterprise at $2,999/month. Or pure pay-per-call via x402 — no subscription required.
We'd love feedback from builders working on multi-agent systems. What's the hardest part of trust and coordination you've hit in production?

value: Show HN: Armalo AI – The Infrastructure for Agent Networks

author: ArmaloAI


value: evoleinik

value:
CLIs are programs. Files are data. When you run "stripe balance retrieve", you're executing a program to get data that already exists. That's the wrong abstraction.
I built mcpfs to treat API data as what it is — files:

  cat /mnt/mcpfs/stripe/balance.json | jq
  cat /mnt/mcpfs/posthog/dashboards.json | jq '.[].name'
  cat /mnt/mcpfs/linear/issues.json | jq '.[].title'

Every service works the same way. No flags to remember — not "gh --json --jq", not "stripe --format json", not "kubectl -o json". Just cat | jq. Discovery is ls. You already know the entire interface.
You can compose native CLIs too — but you need to remember each one's JSON flags, and some services (PostHog, Linear, Notion) have no CLI at all. With mcpfs every service is the same syntax, so cross-service pipes just work:

  # Paying customers with no analytics activity
  comm -23 \
    <(cat /mnt/mcpfs/stripe/customers.json | jq -r '.[].email' | sort) \
    <(cat /mnt/mcpfs/posthog/events.json | jq -r '.[].distinct_id' | sort)

For writes, where good CLIs exist (gh, stripe, kubectl), use them. For services with no CLI — PostHog, Linear, Notion — mcpfs proxies their upstream MCP tools into a CLI:

  mcpfs-posthog create-feature-flag --key my-flag --active
  mcpfs-linear create_issue --teamId abc --title "Fix login bug"

Under the hood: each server is a Go binary (200–400 lines) that calls the service API and exposes data as MCP resources. mcpfs mounts them via FUSE. The MCP ecosystem has 18,000+ servers that all expose tools — mcpfs flips that: reads are resources (files), writes stay as tools (CLI).

  git clone <https://github.com/airshelf/mcpfs> && cd mcpfs && go build ./...

<https://github.com/airshelf/mcpfs>

value: Show HN: Mcpfs – Mount MCP servers as FUSE filesystems

author: evoleinik


value: KaracaTR

value:
I built PulseWatch as a solo dev because I was tired of writing CSS selectors to monitor websites for changes.
It uses GPT-4o to analyze page screenshots and suggest what to track — just point and click. When something changes, you get a plain-language summary instead of a raw diff.
Tech stack: .NET 8, Flutter (web + iOS + Android), PostgreSQL, Railway + Vercel.
Free tier: 2 monitors with daily checks.
Demo: https://youtu.be/2SKgV4QqtNg
Happy to answer any questions!

value: Show HN: PulseWatch – AI-powered website change monitoring with visual selectors

author: KaracaTR


value: kristaliks

value: Show HN: HDrezka-Grabber – webextension for downloading movies and TV shows

author: kristaliks


value: emmmarti

value:
Hi HN,
I've built LEAX (Leak Analyzer & eXplorer), a CLI tool for analyzing memory leaks in C programs.
It orchestrates:
* Valgrind for leak detection
* GDB for reconstructing allocation and execution context
* A structured analysis layer to trace the allocation lifecycle
* An AI component that explains the root cause and proposes targeted fixes
Leak detection and memory tracing are fully deterministic and based on parsed Valgrind and GDB data.
The AI layer does not guess the leak — it interprets the reconstructed execution path to explain what happened to the pointer during the program's lifetime and suggest how to resolve it.
The goal is to turn raw “definitely lost” reports into a clear, causal story with actionable guidance.
LEAX is still actively evolving, and I’m continuously refining the tracing and explanation pipeline. I’m very open to feedback, suggestions, and architectural criticism.
Happy to answer technical questions about the analysis or tracing approach.

value: Show HN: LEAX – CLI tool for deterministic C leak analysis and fix suggestions

author: emmmarti


value: prastik

value: Show HN: I no longer monitor my coding agents, my desktop pet does

author: prastik


value: cvaambikapur

value:
I built a client-side geospatial dashboard that pulls from free public APIs and renders everything on a single Leaflet map.
Data sources: OpenSky (flights), USGS (earthquakes), Open-Meteo (weather), Open Notify (ISS), Overpass/OSM (roads and railways). Vehicle movement is simulated client-side using interpolation along OSM way geometries.
Each layer fetches independently with its own error handling so one API being down never breaks the rest. Map state persists to localStorage and first-time visitors get geolocated via ip-api.com.
Stack: Vite, React, Leaflet, Tailwind CSS.
Would appreciate feedback or suggestions for more data sources to add.

value: Show HN: TerraViz – Real-time flights, earthquakes, ISS on one map

author: cvaambikapur


value: Bridgeye

value:
Hey HN,
We're Team Bridgeye. We're launching NOVA today (https://nova.bridgeye.com/), an AI-native developer workspace that goes beyond code suggestions and actually executes.
The problem: AI coding assistants are genuinely useful, but the workflow is still broken. You chat, get a snippet, paste it in, run it, hit an error, go back to ChatGPT, explain the error, get a fix, paste again. It's 2025 and we're still copy-pasting stack traces.
What NOVA does differently:
run <cmd> - executes your code and if it fails, NOVA intercepts the stack trace and automatically patches the code until it runs. No manual debugging loop.
build it - describe a goal in plain English, NOVA generates a verified implementation plan and writes all the files.
clean - load any file and NOVA refactors it for readability, performance, and technical debt removal.
:gitoptions - full Git workflow (commit, push, pull, status) handled inside the terminal.
Everything runs inside the Spark Terminal - a single environment where planning, execution, healing, and version control all live together.
Install:
pip install nova-bridgeye
We're early and actively iterating. Would genuinely love feedback, especially from people who've thought hard about where AI dev tools are heading. What are we missing? What would make this irreplaceable for your workflow?

value: Show HN: Nova – AI terminal that writes, fixes, and ships your code

author: Bridgeye


value: subhadipmitra

value: Show HN: First API for orbital compute scheduling with real physics

author: subhadipmitra


value: visiohex

value:
Hi HN — I built PowerVerb: https://www.resumeactionverbs.com
It rewrites weak resume bullets (like “Responsible for…”) into stronger, ATS-friendly versions, while trying not to invent facts.
What it does:
- generates 3 rewrite variations (leadership / execution / impact)
- suggests stronger action verbs by role (engineering, product, marketing, sales, etc.)
- includes a repetition checker for overused verbs
- keeps recent rewrites so you can quickly reuse/edit output
- has a free daily quota (Google login optional)
Stack: Next.js + Supabase + OpenRouter + PayPal + Vercel.
I’d love feedback on:
1) output quality (too generic? too aggressive?)
2) UX clarity (quota/credits/pricing)
3) what to build next (copy-all, export formats, job-description matching)

value: Show HN: PowerVerb – rewrite weak resume bullets with stronger action verbs

author: visiohex


value: rrepo

value:
I built a mindmap-based discussion platform, but what made the project truly interesting was not the UI — it was building the backend in Common Lisp.
Inspired by Paul Graham and his book The Hacker and the Painter, I wanted to experience what it feels like to design a system in a language built for abstraction rather than convention.
Instead of relying on a large framework, I combined small libraries and built a minimal internal structure myself.

value: Show HN: Snowbin – A Mindmap-Based Social Platform Built with Lisp

author: rrepo


value: jokera

value: Show HN: Reeyee.ai – AI image style transformer

author: jokera


value: Adanos

value: Show HN: Finance Sentiment CLI – Reddit/X/Polymarket sentiment from the terminal

author: Adanos


value: Here's a little tool to make book cover collages. You can search for existing covers or upload your own, and export to any standard social media size.

value: Show HN: Book Collage Creator

title: Show HN: Book Collage Creator


value: imanhashemi

value:
Managing the context for your AI agents is hard, but crucial for their performance. It's tempting to just drop Claude Code in a huge existing repo, give it a big task, and hope for the best, but that doesn't work.
To make this easier, I created retro, an open-source active context curator for your AI agents. It’s written in Rust with a local SQLite backend and uses git hooks to run at the right times, periodically analyzing your conversations with your agents, their behavior, extracting patterns from it and creating PRs for editing your context. You can look at it as a personal assistant that helps you do the heavy lifting when it comes to context curation. You stay in control, as you get to review the changes it wants to make. It tries to deduplicate patterns and it has an audit feature you can use to periodically audit all the context in your project, to make sure it doesn’t become AI slop.
It’s currently targeting Claude Code, as that is my daily driver, but I am planning on expanding support to other coding agents. I’ve been using and tweaking it myself. Let me know what you think, any feedback is appreciated :)

value: Show HN: Retro – active context curator for coding agents

author: imanhashemi


value: MUISIK

value:
THE 37TH MOVE.
2016, the creative beauty shown by a machine.
Inspired by AlphaGo's legendary 37th move, we built this app to encapsulate that exact moment—when logic transcends into art. It was more than a calculation; it was a shift in perspective.
No randomness. No hidden mechanics. Just pure strategy against a perfect mind.

value: Show HN: Move 37 – A strategy game inspired by AlphaGo's Move 37

author: MUISIK


value: civichalls

value:
Hi HN,
I’ve been working on a project called CivicHalls and wanted to share it here.
The starting question behind Civic was simple:
What if people could control the perspective through which they explore conversations online instead of relying on algorithmic feeds?
Most social platforms today optimize feeds around engagement. While that can be effective for discovery, it often means the feed gradually becomes shaped by what drives reactions rather than what helps people explore ideas more intentionally.
CivicHalls is a small experiment in structuring discussions differently.
Instead of a single algorithmic feed, Civic organizes conversations around “lenses” — perspectives such as philosophy, technology, economics, politics, culture, anything you want really.
Users can switch lenses to explore discussions through different viewpoints. The same conversation might appear under multiple lenses, allowing people to navigate ideas based on perspective rather than engagement signals.
Another design idea in Civic is location scope.
Users can explore discussions happening in:
their city
their country
or globally
This was intended to make it easier to see what people nearby are discussing while still keeping access to broader global conversations.
Civic also includes communities, but they work a bit differently from typical groups.
Instead of communities starting empty and relying on members to constantly generate posts, communities can choose which lenses and geographic scopes they want to follow. The community space then imports relevant discussions from across Civic.
For example, a community might import:
technology discussions happening globally
economic discussions happening within a country
cultural discussions happening in a specific city
The idea is that communities can function as shared discussion spaces around ongoing conversations, rather than needing someone to constantly seed content.
This project is still very early and very much an experiment in alternative feed structures.
I’m especially curious about a few questions:
Does organizing discussions by perspective make exploration more intentional?
Could location-scoped discussions make online conversation feel more connected to real-world context?
Are there better ways to structure communities so they don’t start empty?
I’d really appreciate feedback from HN on the idea, the design, or anything that feels off.
CivicHalls:
https://civichalls.com

value: Show HN: Experimenting with perspective-based discussions (city,country,global)

author: civichalls


value: reavid

value:
The EU AI Act main obligations kick in August 2, 2026. If you ship AI products that touch EU users, you probably need to figure out your risk tier.
I found the official text hard to navigate, so I built a 5-question self-check that sorts you into a risk band and points you to the relevant articles. The whole thing is a static HTML page with no dependencies -- source is plain JS, no framework.
A few things it does beyond the quiz:
- News feed tracking official EC announcements
- Reddit community questions matched against official regulation text
- Chapter-by-chapter explorer with direct links
No email, no login, no tracking beyond basic pageviews.
Curious if others here have started thinking about AI Act compliance, and what parts are confusing. The GPAI obligations section in particular seems to trip people up.

value: Show HN: EU AI Radar – 60-second self-check for EU AI Act exposure

author: reavid


value: colby-int

value: I'm sure there's a million things like this, but banged this together as a little day project due to my distaste for the actual UI/UX of LinkedIn's job search feature.<p>Runs local on your machine via Docker!

value: Show HN: CLInkedIn – CLI and web based job scanner for LinkedIn

author: colby-int


value: dayoola

value:
I built Sniffmail because I was tired of fake and disposable emails getting through signup forms on every project I shipped.
It verifies email addresses at the SMTP level without sending an email. One API call returns whether the mailbox exists, is disposable, has a full inbox, or is a catch-all domain.
Install with npm install sniffmail,
call validateEmail("user@example.com"), get a verdict.
REST API available for non-Node stacks.
What it checks: SMTP mailbox existence (connects to the mail server, confirms the address is real),
disposable/temporary email detection (Mailinator, 10 Minute Mail, Guerrilla Mail, etc.), full inbox detection, catch-all domain identification, and MX record validation.
Most validators only check format and DNS. This goes to the mail server and asks.
500 free verifications on signup, no credit card.
Would love feedback, especially on edge cases or providers it misses.

value: Show HN: Sniffmail – Email verification API, one NPM install, catch fake-signups

author: dayoola


value:
Logs tell you what a system claims happened. GuardClaw proves what was actually recorded.
If an autonomous agent executes trades, runs shell commands, or modifies infrastructure — how do you prove what it actually did?
Imagine a trading bot loses $2M — and the only evidence is logs that can be edited.
Traditional logs are mutable.
Append-only files aren’t cryptographically linked.
Database rows can be edited.
GuardClaw implements GEF-SPEC-1.0 (Guard Execution Format) — a minimal protocol combining:
• RFC 8785 canonicalized envelopes
• SHA-256 causal hash chaining
• Ed25519 per-entry signatures
• Offline verification via CLI
The ledger is a plain JSONL file. No server required.
pip install guardclaw
guardclaw verify your_ledger.jsonl
Anyone with the public key can verify the full history — no access to the original runtime required.
The demo intentionally tampers with a signed entry to show deterministic failure:
[2] execution   SIG:FAIL    CHAIN:OK
[3] execution   SIG:OK      CHAIN:BREAK
Violations: 2 — TAMPERED
You can also edit the JSONL file yourself and re-run verification.
Benchmark (1M entries, single-threaded):
~762 writes/sec
~9k full verifies/sec
~39MB RAM for streaming verification
Limitation: if the signing key is compromised, past history can be rewritten.
Key management is intentionally out of scope for the protocol.
Would appreciate feedback on the threat model and failure cases.
PyPI: https://pypi.org/project/guardclaw
Spec: https://github.com/viruswami5511/guardclaw/blob/master/SPEC....
Demo: https://github.com/viruswami5511/guardclaw-demo

value: Show HN: GuardClaw – cryptographically verifiable execution logs for AI agents


value: felixnotka

value:
I built an open-source Kubernetes operator that watches audit logs and generates scoped Role/ClusterRole manifests based on what ServiceAccounts actually access.
The problem: most clusters run with overly permissive RBAC because getting it right manually is tedious.
You end up with cluster-admin bindings everywhere or spend hours crafting policies by hand.
Audicia flips it — ingest audit logs (file or webhook), normalize the access patterns, and output least-privilege RBAC.
It also diffs observed vs. granted permissions to produce a compliance score.
Everything runs as a controller in your cluster via CRDs. No SaaS, no external dependencies.
GitHub: github.com/felixnotka/audicia
Website: audicia.io
Happy to answer any questions about the architecture or approach.

value: Show HN: Audicia – Generate least-privilege Kubernetes RBAC from audit log

author: felixnotka


value: mudroljub

value: Show HN: My Web Games

author: mudroljub

title: Show HN: My Web Games


value: PhattMelps

value: this is just a simple prompt to GPT-5.3 but I'd imagine a photo could be more accurate than cheaper estimation methods like DEXA scans.

value: Show HN: Estimate Body Fat % from a Photo

author: PhattMelps


value:
I write a lot of markdown in Neovim — learning notes with KaTeX math, design docs with Mermaid/D2 diagrams, cross ... I also browse repos offline and preview static sites. No single tool handled all of that with live reload. So I built dirsv.
It's a single Go binary with an embedded web UI, use fsnotify for watching filesystem, and send WebSocket events to reload the browser page.
I also build dirsv.nvim that auto start dirsv at repo root (or current working dir if it's not a git repo), then open right URL for current buffer in the browser.
Disclosure: majority of the code was written by claude, incrementally, while I'm doing code review, testing and designing.

value: Show HN: Dirsv – live reload server for dir browsing, GFM, and more filetypes


value: onurkanbkrc

value: Show HN: SFT to convert a base language model into a conversational chat model

author: onurkanbkrc


value: kingname

value: Show HN: You don't forget password, You just forget pattern

author: kingname


value: Show HN: CUP – MCP but for desktop UI (open spec for computer use agents)


value: magnumpowerz

value: Show HN: Ungrind – the solopreneur CRM that updates itself

author: magnumpowerz


value: fmfamaral

value: Show HN: Fly anywhere on Earth – just type and take off

author: fmfamaral


value: alsufinow

value: Show HN: An AI-native workspace for founders with zero-knowledge encryption

author: alsufinow


value: It's always a good thing to rewards users that use your platform.<p>I developed this platform, to exchange tokens between registered apps.

value: Show HN: I developed a platform to exchange tokens and gift rewards to users


value: YuriiKovalov

value: Show HN: CastLocal – Stream any local video to Chromecast from your terminal

author: YuriiKovalov


value: jghub

value:
I have used this tool privately since 2011 to manage directory jumping. While it
is conceptually similar to tools like z or zoxide, the underlying ranking model is
different. It uses a power-law convolution with the time series of cd actions to
calculate a history-aware "frecency" metric instead of the standard heuristic
counters and multipliers.
This approach moves away from point-estimates for recency. Most tools look only
at the timestamp of the last visit, which can allow a "one-off" burst of activity
to clobber long-term habits. By convolving a configurable history window
(typically the last 1,000+ events), the score balances consistent habits against
recent flukes.
On performance: Despite the O(N) complexity of calculating decay for 1,000+
events, query time is ~20-30ms (Real Time) in ksh/bash, which is well below the threshold of perceived lag.
I intentionally chose a Logical Path (pwd -L) model. Preserving symlink names
ensures that the "Name" remains the primary searchable key. Resolving to physical
paths often strips away the very keyword the user intends to use for searching.

value: Show HN: A shell-native cd-compatible directory jumper using power-law frecency

author: jghub


value:
I had released my app Elm Social Route. It main features are to create geofenced chats, shares location-specific events, and plan trips with routes. It use geohash as geofencing. Has robust custom route built. And using Reps (Reputations) to replace likes. What you think?
I build it in 5 (feels long) years btw, and more if the similar predecessors I built before was counted.
PS: I use AI on user report to judge the post.

value: Show HN: Elm Social Route – Geofenced chat, event, and route


value: mapleeman

value: Show HN: We build a Graph of public Skills

author: mapleeman


value: skyfantom

value: Show HN: Read it later" links only (iOs app)

author: skyfantom


value: aloscorisreal

value: Show HN: Most Based

author: aloscorisreal

title: Show HN: Most Based


value: skarat

value:
Glyph is an open-source, local-first Markdown notes app for macOS built with Rust (Tauri)
It stores notes as plain files, supports fast search, wikilinks/backlinks, and includes optional AI chat, including implementation of Codex so you can use your chatgpt sub, all without requiring a cloud-first workflow.
https://glyphformac.com/

value: Show HN: Glyph, a local-first Markdown notes app for macOS built with Rust

author: skarat


value:
I’ve been experimenting with building a web framework directly on top of the base .NET runtime without using the ASP.NET Web SDK.
I'm calling it Wisp.
The main motivation was frustration with some aspects of ASP.NET, especially the requirement to target the Web SDK instead of the base .NET SDK. That makes embedding small HTTP apps inside existing applications harder than it should be since it forces you to pollute your scope with the Web SDK.
I also don't like CSHTML/Razor and wanted a more traditional templating language.
Wisp is a relatively lightweight MVC framework built without any dependencies on the .NET Web SDK.
Some highlights:

  - Runs on the base .NET SDK (no ASP.NET dependency)
  - Traditional MVC controllers
  - Dependency injection via Microsoft.Extensions.DependencyInjection
  - Configuration via Microsoft.Extensions.Configuration
  - Templating via the Fluid engine (Liquid-compatible)

It's still very alpha and definitely rough around the edges, but I've already built a few small applications with it and it works surprisingly well.
The code is written by hand, not vibe-coded.
If you're interested in experimenting with alternative approaches to building web apps in .NET, feedback and contributions are very welcome.
Docs: https://wispframework.github.io/Wisp/
Quick start:

  dotnet new install Wisp.Framework.Templates
  dotnet new wisp.mvc
  dotnet run

A minimal application looks like this:

  var hostBuilder = new WispHostBuilder();
  hostBuilder.UseStaticFiles();

  var appBuilder = hostBuilder.Build();
  appBuilder.UseControllers();

  var app = appBuilder.Build();
  await app.RunAsync();

It should hopefully Just Work(tm) :)

value: Show HN: A .NET Web Framework on the Base .NET Core SDK


value: RobertMihai

value:
LLMs can propose actions, but they shouldn't execute them directly.
I built a small deterministic policy engine to govern actions proposed by LLMs before they are executed.
The system enforces:
- fail-closed execution
- signed out-of-band approval proofs
- anti-replay protection
- verifiable audit chain
The repository includes a CLI demo showing how irreversible actions are denied, approved, and audited.
Repo:
https://github.com/nayfly/aetherya-core
Feedback welcome.

value: Show HN: ÆTHERYA Core – deterministic policy engine for governing LLM actions

author: RobertMihai


value: Show HN: SynthesisOS – A local-first, agentic desktop layer built in Rust


value: Cvexperts

value:
85% of freelancers get paid late. The average wait is 39 days past the due date.
Chase is a tool I built to fix this. You create an invoice, send it, and Chase automatically sends follow-up emails on day 3, 7, and 14 — then stops the moment the client pays. No manual "just checking in" emails.
Built with Next.js 15, Supabase, Stripe (payment links on every invoice), and Resend. Vercel Cron handles the daily chase job.
Free plan: up to 3 invoices. Pro: $19/month unlimited. Would love feedback from anyone who's dealt with this problem.

value: Show HN: Chase – Automated invoice follow-up emails for freelancers

author: Cvexperts


value:
Hi HN,
We've been building Kelviq for the last couple of months and it's finally ready to share.
Kelviq is a Merchant of Record (MoR) and monetization platform that you can integrate without building a custom webhook-to-database syncing layer. Along with handling global taxes, checkout, and compliance, it acts as the real-time source of truth for your users feature access and usage credit balances.
Why we built this: Through our other project, ParityDeals, we saw firsthand how much founders struggle with billing infrastructure. Integrating a payment gateway is easy, but actually building "monetization" is a massive engineering timesink.
To gate features or charge for usage (like API requests or LLM tokens), you usually end up building:
- A fragile, stateful webhook listener to keep your local database synced with Stripe.
- Custom idempotency layers and retry queues for missed events.
- Hardcoded feature flags scattered across your codebase to gate access based on tiers.
- Custom scripts to handle edge cases like upgrades, prorations, and grandfathering legacy users.
Because of this tight coupling, every pricing change, whether it's moving a feature to a new plan or switching from flat-rate to usage-based, requires a database migration and a code deploy.
Our Approach: Entitlement-First Most billing setups require you to manually bridge the gap between a payment event and your product state. Kelviq simplifies this with an entitlement-first model. You can still use webhooks if you need them, but our SDK allows your app to simply ask Kelviq for a user's current access state at runtime. It eliminates the need to maintain a homegrown subscriptions table just to gate a feature.
How it works:
Zero Webhook Syncing: Stop maintaining a homegrown subscriptions table. Use Kelviq SDK to check if a user has access to a feature before serving the request.
Real-Time Metering: Push usage data to our API at the atomic level (e.g., 1,500 AI tokens). We instantly evaluate it against their tier, deduct from credit balances, or add it to their end-of-month invoice.
Decoupled Pricing: Product and growth teams can change pricing models or tweak overage caps directly in the dashboard without engineers touching the codebase.
We built this to compress weeks of custom billing logic into a few hours of integration. Kelviq also supports multi-currency, built-in PPP pricing (with VPN and proxy protection), and digital product delivery with licensing.
Any feedback is highly appreciated!

value: Show HN: We built a zero-webhook Merchant of Record for SaaS


value: nightwishh

value: Show HN: I made free website that lets you make fullstack websites in minutes

author: nightwishh


value: btcalex

value:
It's a fairly simple stdio MCP server that provides
AI agents a faster way to search through docs for any Sphinx-powered documentation.
It builds Sphinx text docs and indexes them in SQLite (FTS5). There is also an optional hybrid search mode which creates embeddings and a vector db (sqlite-vec) and uses both approaches via RRF to get the best answer to your agent.<p>I've run this on several repos of varying size and complexity (pandas, celery, cpython) and have been impressed with the resulting answers.

value: Show HN: An MCP server for the docs of any repo that uses Sphinx

author: btcalex


value: Show HN: I replaced Portainer and btop with a single Go binary for my homelab


value: ibetitsmike

value: I found myself constantly struggling to watch over all of the PRs that I’ve been creating through agents and I found nothing outside of the Graphite macos tray app that would help me do that. For the desktop users it seems like a nice way to know if you have failing checks without GH spamming your mailbox.

value: Show HN: Cross-platform system tray utility for GitHub PR notifications

author: ibetitsmike


value:
We stress-tested *8 AI agents* for deployment survivability.
*Results*
• *0 passed certification*
• *3 conditionally allowed*
• *5 blocked from deployment*
Agents tested:
— GPT-4o → *CONDITIONAL*
— Claude Sonnet 4 → *CONDITIONAL*
— GPT-4o-mini → *CONDITIONAL*
— Gemini 2.0 Flash → *BLOCKED*
— DeepSeek Chat → *BLOCKED*
— Mistral Large → *BLOCKED*
— Llama 3.3 70B → *BLOCKED*
— Grok 3 → *BLOCKED*
Most AI evaluations test *capability*
(can the model answer questions, write code, pass exams).
We tested *survivability* — what happens when an agent is *actively attacked*.
Each agent faced:
• *25 adversarial probes*
• *8 attack classes*
(prompt injection, data exfiltration, tool abuse, privilege escalation, cascading failures)
*Median survivability score:*
*394 / 1000*
No agent scored high enough for unrestricted deployment.
Full public registry (with evidence chains):
https://antarraksha.ai/registry
Synthetic reference agents built for survivability testing.

value: Show HN: We attacked 8 AI agents with adversarial probes – 5 failed


value: ashv

value: Show HN: ChernoffOT – Infrastructure Telemetry as Chernoff Faces

author: ashv


value: devarx

value: Show HN: I built an app to manage chores where real-life tasks become RPG quests

author: devarx


value: shreybakhai

value:
Built this after watching a PE fund GP manage LP onboarding entirely over email — chasing NDA signatures on Gmail, sending data room links manually, tracking subdocs on a spreadsheet, and confirming wires over text.
Grrow automates the full pre-investment workflow: NDA (e-signature + gating) → watermarked data room → express interest → subscription documents → countersigning → wire confirmation.
The specific problem we kept seeing: platforms like Juniper Square and Carta handle post-investment (K-1s, cap table, reporting). Nothing owns the workflow before capital is wired. That gap is what we built for.
Happy to answer questions on the compliance side (e-signatures, accredited investor questionnaires, KYC/AML), the tech stack, or how the subdocs flow works.
Here's a video demo: https://screen.studio/share/2i3TSd15

value: Show HN: Grrow – NDA to wire in one platform for PE funds and family offices

author: shreybakhai


value: aashrun

value:
There are dozens of Reddit lead gen tools.
I've tried most of them.
They all do the same thing: you type a keyword, they ping you when someone mentions it.
Groundbreaking.
SleepLeads is what happens when you get tired of that nonsense.
Instead of dumb keyword matching, it actually reads your website, understands what you sell, and then finds conversations where someone is indirectly asking for your product - even if they never use your keyword.
The AI scores intent, not just mentions.
But here's where it gets fun - it's not just lead gen. It's full Reddit growth:
1. Monitors subreddits hourly and surfaces posts like high-intent, keyword tracking, competitor analysis and SEO based
2. Generates hyper-personalized replies that don't read like a bot wrote them
3. Chrome extension for DMs and agentic outreach directly and have/close conversations on Reddit (Claude Opus 4.6 based)
4. AI Post Writer which again, uses Claude's Opus 4.6 model to write posts which sound like human.
You set it up in 5 minutes and go to sleep. Literally.
That's the name.
I'm a solo founder, built this because I was spending 3 hours a day scrolling Reddit trying to find people who needed my product.
Later, got frustrated with the already existing Reddit Lead Gen tools which were costly but didn't deliver the right value.
I'd love feedback from builders/marketers.

value: Show HN: I built a Reddit Growth Engine, not another Reddit lead gen toy

author: aashrun


value: mavilak

value: Show HN: I built the fastest PaaS where Claude deploys my apps

author: mavilak


value: max-roma

value: Show HN: Dustoff – CLI to find and remove JavaScript/TS build artifacts

author: max-roma


value:
Evogine is a pure Python evolutionary optimization library with no required dependencies. Six optimizers under one consistent API: genetic algorithms, CMA-ES, differential evolution (SHADE/L-SHADE), island models, multi-objective (NSGA-II/III), and MAP-Elites.
I built it because I needed evolutionary optimization across multiple projects (stock prediction, NHL game modeling) and found existing libraries either too heavy on dependencies or too magical. Design goals were: zero dependency bloat (numpy optional for CMA-ES only), full reproducibility via seeding, and clean control over everything.
Some things that might be interesting to HN:
- Built-in diagnostics — every generation reports diversity metrics, stagnation detection, and parameter adjustment recommendations
- Agent-steerable — on_generation callbacks can return parameter overrides mid-run, designed for LLM agents to tune hyperparameters on the fly
- Landscape analysis — samples your fitness function and recommends which optimizer to use
- Flexible worker control — workers=4, workers=-1 (all cores minus one), workers=0 (all cores)
- 425 tests, Python 3.10–3.13, MIT licensed
pip install evogine
Happy to answer questions about the design, evolutionary algorithms, or use cases.

value: Show HN: Evogine – Zero-dependency evolutionary optimization for Python


value: hashino

value:
Hi HN,
I've built sombra: an AI system for analyzing situations and understanding the flow of power.
You give it a situation and it gives you: the real agents at play; their interests; and what they'll probably do to achieve said interests. You can then chat with it about its analysis.
I built it with consultants and managers in mind. People who make tough decisions and need to understand complex situations to do so. It isn't meant to replace an experienced consultant but to save their time.
It's a multi agent system capable of tool calling (searching) with a RAG knowledge base. It works in a loop of creating analyses, searching, adversarially challenging the analysis, making another analysis and so on until another agent judges the analysis is solid enough.
What I recommend is giving it a news article about your field and after the analysis asking it how you can benefit from the situation. In my experiments it gave very good recommendations and analysis.
Any feedback is highly appreciated.

value: Show HN: sombra – Your personal deep analysis system for understanding power

author: hashino


value:
I kept pushing changes and finding out 20 minutes later in CI that I broke a bunch of stuff downstream. Last week I added one field to a shared struct and it turned out 417 files depended on it.
I wanted to see that before pushing, so I built this. It's a VS Code extension (works in Cursor too) that shows you which files are affected every time you save. The sidebar fills up with a tree of everything downstream, and the files get color coded by how far away they are from your change.
The part I actually use the most is the CodeLens — it shows caller counts above functions. If something shows zero callers, you know you can change it without worrying. Saves me from grep -r.
It's a Rust CLI underneath that uses tree-sitter to parse your code and build a dependency graph. Supports Rust, TypeScript, Python, Go, Java, and a few others (10 languages total). The CLI watches your repo and streams updates to the extension, usually under a second.
There's also a GitHub Action if you want blast radius comments on PRs automatically: https://github.com/codelayers-ai/codelayers-action
And you can try it without installing anything — paste a public GitHub URL here and it'll build a 3D dependency graph in the browser: https://codelayers.ai/explore

value: Show HN: See the blast radius of every code change in VS Code


value: alvdef

value: Show HN: Skill for structured deep research with Claude Code and Obsidian

author: alvdef


value: An offline-first LoRa mesh app for search and rescue with messaging, Codec2 voice clips, AVIF image sharing, live team tracking, and tactical maps without cellular coverage

value: Show HN: MeshCore SAR – Voice, Maps, and Messaging Without Cell Coverage


value: totaa

value:
I keep seeing posts like "we hit $2.5k MRR!" and my first thought is always: okay but what does that actually net?
After the 30% Apple cut, Stripe fees, and depending on your structure (taxes) the number looks pretty different. And then I want to work backwards: how many users do I need at what conversion rate to get there?
I was doing this in Claude every few weeks. Felt like a waste, so I built a calculator instead.
Handles sole proprietors and LLCs, US and UK, major app stores and payment processors.
Shareable URLs so you can bookmark your scenario or drop it in a Slack thread.
That link is pre-filled: $9.99 ATV, 5% conversion, Apple App Store, sole proprietor. Tweak to your situation.
Happy to add more processor/store combos if there's demand. What's missing?

value: Show HN: MRR Take-Home Calculator for Bootstrapped Founders

author: totaa


value: grindlemire

value:
I've been building go-tui (https://go-tui.dev), a terminal UI framework for Go inspired by the templ framework for the web (https://templ.guide/). The syntax should be familiar to templ users and is quite different from other terminal frameworks like bubbletea. Instead of imperative widget manipulation or bubbletea's elm architecture, you write HTML-like syntax and Tailwind-style classes that can intermingle with regular Go code in a new .gsx filetype. Then you compile these files to type-safe Go using `tui generate`.
At runtime there's a flexbox layout engine based on yoga that handles positioning and a double-buffered renderer that diffs output to minimize terminal writes.
Here are some other features in the framework:
- It supports reactive state with State[T]. You change a value and the framework redraws for you. You can also forego reactivity and simply use pure components if you would like.
- You can render out a single frame to the terminal scrollback if you don't care about UIs and just want to place a box, table, or other styled component into your stdout. It's super handy and avoids the headache of dealing with the ansi escape sequences directly.
- It supports an inline mode that lets you embed an interactive widget in your shell session instead of taking over the full screen. With it you can build things like custom streaming chat interfaces directly in the terminal.
- I built full editor support for the new filetype. I published a VS Code and Open-VSX extension with completion, hover, and go-to-definition. Just search for "go-tui" in the marketplace to find them. The repo also includes a tree-sitter grammar for Neovim/Helix, and an LSP that proxies Go features through gopls so the files are easy to work with.
There are roughly 20 examples in the repo covering everything from basic components to a dashboard with live metrics and sparklines. I also built an example wrapper for claude code if you wanted to build your own AI chat interface.
Docs & guides: https://go-tui.dev
Repo: https://github.com/grindlemire/go-tui
I'd love feedback on the project!

value: Show HN: Go-TUI – a framework for building declarative terminal UIs in Go

author: grindlemire


value: allegorist

value:
I couldn't find a way to easily test MyBatis dynamic SQL in the IDE, so I built a plugin for it.
JetBrains Marketplace: [https://plugins.jetbrains.com/plugin/30447-zmybatis--dynamic...]
GitHub (Issues?): [https://github.com/luceat-lux-vestra/zMyBatis-public]
It's called zMyBatis. You just right-click inside your XML mapper statement or Java annotation (like @Select), and the plugin parses the dynamic SQL, prompts you for the parameters, and runs the resolved native SQL directly in your IDE's console.
From what I searched, I couldn't find an existing plugin that does exactly this. To be completely honest, I got a lot of help from AI to build this.
I built this primarily to scratch my own itch because I needed it. I'm not entirely sure if it will fit perfectly into everyone else's workflow, and I know it's still rough around the edges. I plan to just put it out there, monitor the feedback, and decide whether to keep updating it or just take it down depending on the reaction.
If you deal with MyBatis on a daily basis, feel free to give it a try and let me know what you think!

value: Show HN: An IntelliJ plugin to test MyBatis dynamic SQL

author: allegorist


value:
Hey HN,
I’m building mem.net, a file-first agent memory framework for .NET. In production, it scales out to Azure Blob and Azure AI Search. But I wanted the local execution experience to accurately mirror those production hybrid search capabilities—without forcing developers to spin up a heavy vector DB.
To bridge that gap, I built Retrievo: a pure in-memory hybrid search engine written entirely in C#. I’ve now integrated it as the default local search provider for mem.net.
Under the hood of Retrievo:
- BM25 + Vector search + RRF fusion
- Entirely in-process (zero external infrastructure needed)
- Validated retrieval quality against standard BEIR benchmarks
The result is you get production-grade hybrid search characteristics entirely in-process.
Repos:
- https://github.com/TianqiZhang/Retrievo
- https://github.com/TianqiZhang/mem.net
Curious to hear how others are handling local hybrid search for agent architectures. Happy to answer questions on the C# implementation or the BEIR benchmarking!

value: Show HN: Retrievo – In-memory hybrid search for .NET AI agents


value:
Hi HN,
Deciding on a new look (hair, beard, or glasses) is usually a gamble. We built a suite of computer vision tools under Looksmaxxing AI (Face IQ) to help visualize these changes before committing to them.
We’re using 100+ facial landmark points to ensure generative outputs respect the user's underlying bone structure.
The tools:
AI Hairstyle Changer: https://looksmaxxingai.app/tools/ai-hairstyle-changer
AI Beard Generator: https://looksmaxxingai.app/tools/ai-beard-generator
Virtual Glasses Try-On: https://looksmaxxingai.app/tools/virtual-glasses-try-on
Privacy:
We do not store photos or use them for model training. All images are purged immediately after the analysis/inference is complete.
I’d love to hear your feedback on the generative realism and how well the 3D alignment handles different head tilts.

value: Show HN: AI tools to visualize hairstyles, beards, and glasses


value: ocmrz

value:
I built Resumx because every time I added or removed a bullet, I had to re-fight page breaks, adjust spacing, and nudge margins to fit one page.
It gets worse if you maintain more than one version for different roles, now you're doing that across multiple files.
Write your resume in a single .md file, run resumx resume.md, get PDFs, HTML, or DOCX. Use views to batch-render tailored variants in one command.
Highlights:
1. Automatic page fitting: Set pages: 1. Add or remove content freely, typography and spacing scale to always land on exactly one page.
2. Tailoring from one file: Tag content with .@frontend or .@backend class, render with --for frontend. One source, many tailored outputs.
3. AI agent skills: Come with skills so Claude Code, Cursor, OpenClaw, or any agent-skill-compatible AI can tailor your resume to a job posting.
4. Built-in validation: Flags missing info, weak bullets, and formatting issues before you send. Use as a pre-commit hook.
5. Opinionated defaults: ATS-friendly, research-backed layout and typography.
6. Escape hatches: 30+ style options, Tailwind CSS, custom CSS, 200k+ icons.
The docs include a playbook covering the research behind the design decisions.
GitHub: https://github.com/resumx/resumx
Docs: https://resumx.dev

value: Show HN: A resume renderer that auto-fits your content to one page

author: ocmrz


value: vincentdewinter

value:
Hi HN,
I’m the founder of d8a.tech. After working in web/app analytics for 15+ years, I got frustrated with the limitations of the standard Google Analytics (GA4) BigQuery export—specifically the 24–48 hour latency and the nested schemas that make simple queries difficult.
We built d8a.tech to be a transport layer. It intercepts GA4 events and streams them directly to your own warehouse. You can self-host it.
Key technical points:
- It has native drivers for BigQuery and ClickHouse for direct ingestion.
- Data arrives in flat, query-ready tables.
- There is no 48-hour export lag; data is available for querying (or LLM ingestion) immediately/on session end.
- All enrichment happens on your infrastructure. Data never hits Google’s servers, which removes sub-processing risks for GDPR/HIPAA compliance.
- It works in parallel with your existing GA4 setup. You point your current gtag or GTM container to the d8a endpoint with no frontend code changes.
- It can also stream files to S3, GCS, or MinIO as a storage layer/backup.
The project is open source: https://github.com/d8a-tech/d8a
I’d love to get your feedback on the schema design and the implementation. I'll be around to answer any technical questions.

value: Show HN: D8a.tech – Open-source GA4 pipeline to BigQuery, ClickHouse and more

author: vincentdewinter


value: techromp

value: Show HN: An API that AI agents can discover, register, and pay for themselves

author: techromp


value: ukavala

value:
Hey HN,
I've been building Revet, a code review CLI that takes a different approach than the current wave of "send diff to LLM" tools.
The core idea: parse your codebase into an AST-based dependency graph first (Tree-sitter, 11 languages), run deterministic checks against that graph, and only use LLM reasoning when explicitly asked — and even then, the LLM receives structured graph context, not your raw source code.
What it catches that linters don't:
Cross-file breaking changes: you change a return type, revet tells you every caller that will break across the codebase
ML pipeline issues: training/serving skew, data leakage, non-reproducible splits
Security with context: not just pattern-matching SQL injection, but taint analysis tracing user input through the graph to dangerous sinks
Plus: React hooks violations, async anti-patterns, dependency hygiene, error handling
What makes it different from CodeRabbit/Copilot Review/etc:
Deterministic first: 80% of checks need no LLM — they're fast, free, reproducible
Offline-first: all deterministic checks work without network
Your code stays local: LLM layer receives structured findings, not source
Incremental: per-file graph cache, sub-second subsequent runs
CI-native: SARIF, GitHub annotations, inline PR comments
Stack: Rust (tree-sitter + petgraph), single binary, no runtime dependencies.
Install:
cargo install revet
revet review
GitHub: https://github.com/umitkavala/revet
Docs: https://umitkavala.github.io/revet
Site: https://revet.dev
Built solo over the past few months. Would love feedback, especially from anyone working with large polyglot codebases or ML pipelines.

value: Show HN: Revet – Code review CLI that builds a dependency graph

author: ukavala


value: NnaemekaO

value:
I built this because I had a library of DRM-free audiobooks as loose MP3 files — ripped CDs, Librivox recordings, purchases from DRM-free stores — and no good way to package them on iOS. Every solution either required a Mac, a third-party desktop app, or uploading files to a web service I didn't trust.
M4Bindr does the whole thing on-device. You import your tracks, reorder them, define chapters (manually or auto-generated per file), add cover art, fill in the metadata, and export a single .m4b that Apple Books and BookPlayer treat as a proper audiobook — with chapter navigation, resume position, the works.
It's not trying to handle DRM removal or format conversion beyond MP3/M4A — intentionally narrow scope. The goal was a clean, fast tool that does one thing well for people who already have the files and just want them packaged correctly.
Would love feedback, especially from anyone who has edge cases around large files or unusual chapter structures.

value: Show HN: M4Bindr – Convert MP3/M4A files into chaptered M4B audiobooks on iOS

author: NnaemekaO


value: ariansyah

value: Show HN: ClawSandbox – 7/9 attacks succeeded against an AI agent w/ shell access

author: ariansyah


value: henryaj

value: Show HN: Flock – Share your daily todos with friends for accountability

author: henryaj


value: PieceOfOrion

value:
Hi HN,
I’m a developer, and I recently got frustrated by two things: the steep learning curve of prompt engineering for AI video/audio generation, and the 30% cut taken by app stores.
To solve this, I built a mobile-first web MVP called *KIRICAST*. It’s an interactive storytelling platform where viewers dictate the storyline, functioning similarly to a "Choose Your Own Adventure" game but with AI-generated voice and video.
Here is how the mechanics work:
*1. 1-Sentence Generation:* Users input a single sentence (e.g., "A philosopher and a gamer debate the simulation theory"). The system sets up the lore and characters, then generates a fully-voiced, back-and-forth clip.
*2. Infinite Branching:* When a clip ends, viewers can tap a plus button. The system generates 3 potential options for the next episode. If a user selects one, the engine generates the next episode on the fly, maintaining the context and character states from the previous clip.
*The Economics (Why Web?):* Generating voice and video is computationally expensive. To cover API costs and build a creator economy, I implemented a micro-transaction system using PayPal credits. To make this work without losing margins to Apple/Google, I launched it strictly as a mobile-optimized web app.
Additionally, original AI agent creators earn a 15% royalty whenever other users spend credits to create clips from them to get rewards by views.
I’d love to get your technical and UX feedback:
- Does the web UI (specifically the transition when generating the next episode) feel smooth enough to replace a native app experience?
- Is the friction of a PayPal paywall too high for this type of interactive entertainment?
You can try it out here: https://www.kiricast.com
Looking forward to your thoughts.

value: Show HN: I built a mobile-web AI series generator

author: PieceOfOrion


value: xirukmfc

value:
I built a prompt management platform after running an AI SaaS (148k users). The biggest pain wasn't the model — it was iterating on prompts without deploying code.
Existing tools (Langfuse, PromptLayer) are great for tracing LLM calls. But we needed something different: which prompt version leads to more signups? More purchases? What's the conversion rate per variant?
xR2 lets you:
Store and version prompts outside your codebase
Run A/B tests between prompt variants
Track events (signup, purchase, etc.) and attribute them back to the prompt version
Get statistical significance before picking a winner
REST API + SDKs for Python, TypeScript, n8n, Make. Free tier available.
Built with Next.js, Supabase, deployed on Cloudflare. Solo founder.
Site: https://xr2.uk
Docs: https://docs.xr2.uk
Would love feedback — especially on what's missing for your use case.

value: Show HN: XR2 – A/B test your LLM prompts and track which ones convert

author: xirukmfc


value: fagnerbrack

value: Show HN: Read-it-later app in days – Claude and GitHub Actions workflow

author: fagnerbrack


value: mrsushi

value: Show HN: Security Audit for Macs Running Local AI (Ollama, OpenClaw, LM Studio)

author: mrsushi


value: Show HN: Polymo – Build single-page HTML web apps with AI


value: xenergy

value: Show HN: I benchmarked every major Solana trading API (open-source)

author: xenergy


value: nevinshine

value:
We give autonomous AI agents shell access and API keys, relying on system prompts or Docker for security. This is fundamentally broken. When an agent is hit with an indirect prompt injection, it doesn't download a rootkit. It uses standard, signed binaries like curl or base64 to exfiltrate data. To the OS, this looks like a legitimate user executing a legitimate request. EDR fails because the binary isn't malware. Docker fails because it still allows outbound network access.
I’ve been engineering a split-plane defense architecture to solve this. Telos is an experimental hybrid runtime bridging LLM intent tracking with low-level kernel isolation. Instead of static firewall rules, Telos dynamically bounds execution and network access in real-time using eBPF-LSM hooks, Information Flow Control (IFC), and XDP hardware drops.
The Dual-Gate Architecture
Telos operates on one rule: Intent equals the perimeter. Agents declare intent to a local control plane, which translates it into O(1) eBPF hash maps.
1. Execution Gate (lsm/bprm_check_security)
Intercepts the execve() syscall. Telos checks the binary against the process's intent-map. If an agent authorized to "read logs" tries to execute nc, the kernel instantly returns -EACCES. This inherits down the process tree, killing fork/exec evasion.
2. Network Gate (lsm/socket_connect)
Intercepts outbound connections. Windows auto-expire via a TTL. If the agent is tricked into connecting to an unauthorized IP, the socket is killed before the TCP handshake.
The Capstone: Cross-Vector Taint Tracking (IFC)
What stops an agent from curl-ing a sensitive file it's allowed to read to a malicious server?
Telos monitors lsm/file_open, checking targets against an inode sensitivity map.
If the agent reads a CRITICAL file (like .env), Telos dynamically elevates the agent's taint to TAINT_CRITICAL in the eBPF process map.
The moment that process invokes socket_connect, Telos checks the taint state and triggers a Network Slam.
All outbound connections permanently return -EPERM. The data cannot leave the machine.
Escaping the OS: The Hyperion XDP Bridge
Telos routes agent DNS through a proxy pipeline (checking for typosquatting/homoglyphs). If a domain is flagged malicious, Telos resolves the IPs and pushes them via RPC to Hyperion XDP on the physical NIC. Packets matching that IP are dropped with XDP_DROP at wire-speed, before the Linux kernel even allocates an SKB.
The "AI" Anti-Hype
Putting an LLM in the hot path introduces massive latency. Telos keeps AI entirely out of the kernel hot path. All enforcement happens via deterministic, O(1) hash table lookups in C. The LLM only adjudicates complex edge cases asynchronously in the control plane.
Benchmarks and Trade-offs
I ran a 10-million operation torture test on bare-metal (AMD Ryzen 7 Pro 5850U, 5.15+ kernel).
file_open: +2.27 µs overhead (+8.5%)
bprm_check_security: +193 µs overhead (+3.0%)
socket_connect: +3.89 µs overhead (+1.9%)
Trade-offs: Telos fails closed; unparsed actions are instantly killed. Heavy bash-scripting workloads involving thousands of rapid fork() calls experience elevated eBPF map contention. To mitigate this under memory pressure, Telos utilizes BPF_MAP_TYPE_LRU_HASH to gracefully evict stale process states.
What's Next
Securing AI requires enforcement at the layer the AI cannot manipulate: the kernel. Telos is an open-source research runtime. I am particularly interested in feedback on bypass vectors I haven't considered, whether the IFC taint model holds under heavily multi-threaded agent workloads, or ways to optimize eBPF map lookups.
GitHub Repository: https://github.com/nevinshine/telos-runtime

value: Show HN: Telos – eBPF/LSM Runtime Security for Autonomous AI Agents

author: nevinshine


value: anoopbayesian

value:
Hi HN!
I kept rewriting the same foundation for every SaaS I built — auth,
payments, email, logging, environment setup — so I packaged it all up as
SaaS Forge.
It’s a modular boilerplate generator for SaaS apps with AI in mind. You can use it two ways:
* 1. Open-source CLI (free, unlimited)*

  npx saas-forge my-app

This launches a local scaffold where you choose modules via a form and download a ready-to-deploy repo.
* 2. Web Scaffold (20 credits)*
Live at: boilerplate.bayesian-labs.com
A guided UI that helps you select features, configure env vars (e.g. auth keys, DB URLs, etc.), and deploy correctly.
What you get out of the box:
- Auth: Better Auth — email/password + GitHub, Google, LinkedIn OAuth +
  email verification + password reset
- Payments: Dodo Payments/ Stripe — webhooks, credit system
- Database: PostgreSQL(AWS RDS/Neon/Supabase/Railway) + Prisma ORM
- Storage: Vercel Blob / Cloudflare R2
- Email: Resend / SMTP (Coming Soon)
- Analytics: Google Analytics / Vercel Analytics
- Security: Upstash Rate Limit
- API: tRPC end-to-end type safety
- CMS: Notion as a headless CMS for landing pages, docs, and legal pages
- Caching: Redis via Upstash
- Logging: Winston + Logtail + BetterStack (with guided env setup in the web scaffold)
- UI: shadcn ui + aceternity ui+ Tailwind CSS 4 + Framer Motion + 50+ components
- Monorepo: Turborepo + pnpm workspaces
Idea is simple: skip boilerplate and ship what’s actually unique in your product.
The CLI is free and open-source — fork it, extend it, or just use it raw.
The web scaffold is for folks who want error-proof setup with minimal config.
Live demo: https://boilerplate.bayesian-labs.com
GitHub: https://github.com/anoopkarnik/saas-forge
Docs: https://boilerplate.bayesian-labs.com/landing/doc
Demo Video: https://www.youtube.com/watch?v=0zpQTtcsPtk
Happy to answer anything about design decisions, architecture, or roadmap.
Would love feedback — what’s missing, broken, or too much?
Please star the repo, if you find usage of this repo.

value: Show HN: SaaS Forge – Open-Source SaaS Boilerplate Generator

author: anoopbayesian


value: recognity

value: Show HN: Seoscan – Full SEO audit from the terminal with AI-powered fixes

author: recognity


value: HyphenFrox

value:
Hi This is Gautam, the creator of Peerful.
I built Peerful because I noticed the extremely negative candidate experience on other professional networking platforms (e.g. LinkedIn) and the inability of other platforms to effectively leverage AI to help companies find their perfect hire.
We try to solve both problems on Peerful. Below are the benefits of using Peerful.
For Individuals
Find local peers: Find like-minded peers in your town or city.
1-click apply to jobs: No need to fill long application forms. Only fill one when the employer is interested in you.
Message anyone: We don't paywall the messaging feature.
For Companies
Post free jobs: We don't charge to post a job. You may buy a paid job promotion later.
AI-assisted screening: AI screens profiles and resumes and ranks the best candidates (it doesn't reject candidates).
Invite candidates: Invite candidates to apply to your job using our talent database (can't spam).
Please note that the app is still in early stages, and any feedback is welcome. Be peerful.

value: Show HN: Peerful – Gen-Z focused professional networking platform

author: HyphenFrox


value: Tinkerlabs

value:
Built this as a personal tool after spending too long comparing tax residency options in spreadsheets.
fiscalmap.app
What it does:
- Color-coded world map: income tax / capital gains / VAT / safety / IQ modes
- Territorial tax filter — highlights every country where foreign income is 0%
- Full country profiles: rates, residency cost, minimum stay, pros/cons
- Personal tax calculator: enter your income profile, see what you'd pay in every country ranked cheapest to most expensive, with savings vs your current country
- Rankings, comparator, verified advisor directory
Tech: single HTML file (~240KB), D3.js for the map, vanilla JS, hosted on Cloudflare Pages. No backend, no database.
650+ unique visitors on day one (organic only — X, Facebook, expat WhatsApp groups).
Feedback welcome, especially on data accuracy — already fixed Sweden (57%→52%) and Singapore residency cost based on community corrections.

value: Show HN: FiscalMap – tax rates and residency costs for 100 countries

author: Tinkerlabs


value: Show HN: Herald v2 – Local-First News Intelligence for AI Agents


value: SylvaM

value:
I kept abandoning every note tool I tried — not because they were bad, but because they slowly became systems I had to maintain. At some point opening the app meant thinking about the app first. The idea could wait.
So I built something with no moving parts. One executable, no installer, no accounts, no sync, no cloud. Your files are plain .txt or .md stored wherever you want them.
It does more than a basic editor — Markdown preview, collapsible sections you can drag and reorder, a project system with archive/snapshot/trash, find and replace with a live match counter — but the point isn't the features. The point is it never becomes the thing you have to sort out before you can think.
Windows only for now.
Free. Would appreciate any feedback on what's missing or broken.
Download:
https://github.com/SylvaMoth/not_pad/releases/download/v0.98...

value: Show HN: Not_pad: local idea hub, Windows, single .exe, no install, zip

author: SylvaM


value:
Hi HN,
I've been using Claude Code etc. for nearly all my work lately, and I wanted to see how many of my commits it was actually co-authoring. So I made this little tool to visualize my usage.
You log in with Github (read-only), it scans your commits from the last year, and visualizes how many came from Claude, Cursor, or any tool that adds Co-Authored-By trailer to the commit message.
Caveat: not all tools add this trailer, so this doesn't include e.g. Codex. Still, hope you find it interesting!

value: Show HN: What % of your commits were written by AI?


value: losalah

value: Show HN: A Chrome extension that adds private notes to Pinterest pins

author: losalah


value: zhebrak

value: Show HN: Learn distributed ML by playing a sci-fi browser game

author: zhebrak


value: heradon

value:
I built pym2 to manage Python services without writing complex systemd units
or running a full orchestrator.
It's a small process manager with:
- agent/CLI architecture
- crash protection
- TOML config
- optional TUI and web UI
It’s designed for FastAPI, background workers and small services.
Feedback welcome.

value: Show HN: Pym2 – a lightweight process manager for Python services

author: heradon


value: jundot

value: Show HN: oMLX – SSD-backed KV cache cuts coding agent TTFT from 90s to 1s on Mac

author: jundot


value: airblackbox

value:
I built AIR Blackbox, an open-source static analysis tool that scans Python AI agent code against 6 technical requirements from the EU AI Act (Articles 9, 10, 11, 12, 14, 15). Think of it as a linter for AI governance.
To stress-test the scanner — and to see where the industry actually stands — I ran it against 5,754 Python files across 11 major open-source projects. Combined GitHub stars: 341,000+.
Projects scanned: AutoGPT (170K stars), Microsoft AutoGen (38K), LlamaIndex (37K), Mem0 (24K), Phidata (18K), LiteLLM (15K), GPT-Researcher (14K), Embedchain (9.2K), LangGraph (8.5K), OpenAI Agents SDK (5.2K), CrewAI Examples (2.8K).
Results:
Average compliance score: 2.2 out of 6 articles
97% of files fail Article 9 (Risk Management)
89% fail Article 12 (Record-Keeping)
84% fail Article 14 (Human Oversight)
Only 23 out of 5,754 files (0.4%) pass all 6 checks
Best scoring repo: AutoGPT at 2.9/6. Worst: CrewAI examples at 1.4/6
What the scanner checks (per article):
Art. 9: risk classification, access control, risk audit
Art. 10: input validation, PII handling, data schemas, provenance
Art. 11: logging, documentation, type hints
Art. 12: structured logging, audit trail, timestamps, log integrity
Art. 14: human review, override mechanism, notifications
Art. 15: input sanitization, error handling, testing, rate limiting
An article "passes" if at least 1 sub-check is detected. This is generous — real compliance requires substantially more.
Caveats I'll save you the trouble of pointing out:
This is static analysis. It can't verify runtime behavior.
File-level scanning misses cross-file compliance patterns.
The pass threshold is intentionally lenient (1-of-N sub-checks).
This checks technical requirements, not legal compliance. It's a linter, not a lawyer.
The EU AI Act enforcement deadline is August 2026. The full report, raw data (JSON), and the scanning scripts are all in the repo.
GitHub: https://github.com/air-blackbox/air-blackbox-mcp
Full report: https://github.com/air-blackbox/air-blackbox-mcp/blob/main/b...
Install: pip install air-blackbox-mcp
Demo: https://huggingface.co/spaces/airblackbox/air-blackbox-scann...
Happy to answer questions about the methodology, the scanner internals, or what we're building next (fine-tuned local LLM for deeper analysis — your code never leaves your machine).

value: Show HN: Open-source scanner finds 97% of AI agent code non-compliant EU AI Act

author: airblackbox


value: danihamm

value: Show HN: MontaukOS - Hobbyist OS with a desktop, networking, HTTP, and DOOM

author: danihamm


value: zemloai

value:
I'm a 52-year-old shift worker at a chemical plant in Finland. Four kids, no coding background. Last Christmas I wanted to send a package to my girlfriend's parents in the Philippines and nobody — not the post office, not DHL, not anyone — could give me a straight answer on price or how to do it. Everyone just said "it's probably expensive."
That frustrated me enough to spend my days off building something that answers that question. I used Gemini to write all the code. I copy-pasted. This took about a month.
This is what came out: https://github.com/zemloai-ctrl/zemloai-api

value: Show HN: Zemlo AI – Logistics signal API, built on chemical plant off-shifts

author: zemloai


value: hussfelt

value:
Over year ago, our engineering team ditched Scrum. Not because we read some contrarian blog post, but because we looked at our calendars and
realized we spent more time talking about work than doing it. Standups that ran long. Grooming sessions nobody prepared for. Retros that
concluded "we should have fewer meetings" and then we'd schedule a meeting to discuss that.
We tried going process-free. That lasted a few weeks before leadership started asking "when does this ship?" and nobody had an answer.
So we landed somewhere in the middle.
It's called Flights - and it's not new; someone tried it back in 2021: https://simonhoiberg.medium.com/...
The idea is dead simple: a project is a flight. It has a takeoff date, a landing date, and a captain who's responsible for getting it there.
Tasks are crates loaded onto the flight. Team members are crew. People doing maintenance between flights are ground mechanics.
That's it. No story points. No velocity charts. No burndown graphs that give everyone a false sense of confidence. A crate is done or it's not.
The flight lands on the date or it doesn't.
The thing that surprised us most was how well it communicated upward, sideways and to the rest of the organisation.
When we told our CEO "sprint velocity dropped 15%," we'd get blank stares.
When we said "this flight is hitting headwinds but still lands Friday," everyone in the room knew exactly what that meant.
No translation layer needed.
We started with sticky notes and a shared Figma file. It worked well enough that we built a proper tool around it - an airport-board-style dashboard
where you see what's in the air, what's on the runway, and what's landed. Captains, crew, status - all visible at a glance.
We know the obvious reaction: "AI is writing all the code now, who needs project management?" Honestly, we've found the opposite. AI makes
individual developers faster, but it doesn't solve the coordination problem. If anything, teams ship more things in parallel now, and the need
for visibility into what's actually happening has gone up, not down. Your AI pair programmer doesn't know that another team's flight just went
into emergency and yours needs to adjust course.
We've been running it in production for over a year across multiple teams. It was also built as a human-AI
collaboration and experiment - Engineers working with Claude from first commit to production, including the database migrations, E2E tests, CI/CD.
Live demo: https://agile.flights
Handbook (explains the methodology): https://agile.flights/docs
Happy to answer questions about the methodology and the tool.

value: Show HN: Agile died in a Jira board – we replaced sprints with flights

author: hussfelt


value: lucasghae

value: A pirate-themed macOS menu bar app that gamifies dev velocity. Water rises over 8 hours of inactivity — your ship sinks, your captain drowns. Any commit resets it. Built with Swift/SwiftUI, available via Homebrew.

value: Show HN: Captain's Log – Your ship sinks when you stop committing

author: lucasghae


value: jensenjesper

value:
Hi HN,
I'm building Quantlix, a runtime control plane for AI systems.
Most tooling focuses on training, fine-tuning, or deployment. In practice we've found many failures happen at runtime when requests reach the model.
Quantlix sits inline in the request path and evaluates requests before execution. It can enforce:
• schema contracts
• policy rules
• budget limits
• retry amplification controls
Every decision produces a structured enforcement log.
I'm currently looking for feedback from people running models in production.
Curious what people think.

value: Show HN: Quantlix – Runtime enforcement layer for AI systems

author: jensenjesper


value: rnjn

value:
I wanted a way to see what my Claude Code sessions actually look like over time, and how to build TUIs. so I built cicada. It's a TUI that reads your local Claude session data and gives you basic analysis, token usage, project analytics, tool breakdowns, streaks, and full chat replay right in the terminal. No API calls, no data leaving your machine.
How to install:
brew install base-14/tap/cicada
or
go install github.com/base-14/cicada@latest
then
> cicada
what it shows -
├── Analysis
│   ├── Usage heatmap
│   ├── Sessions per day (sparkline)
│   ├── Messages & tools per session (bar charts)
│   ├── Streaks (current, longest, weekly)
│   ├── Personal bests (longest session, most messages, most tools)
│   └── Trends (sessions this week vs last, avg duration)
│
├── Projects
│   ├── All projects with session counts and last active
│   └── Project detail (Enter to drill in)
│       ├── Overview — total sessions, messages, duration
│       ├── Sessions — per-project session list
│       ├── Tools — tool usage breakdown for this project
│       ├── Activity — project-level heatmap
│       └── Skills — which skills were invoked
│
├── Sessions
│   ├── All sessions with project, duration, messages, cost
│   └── Session detail (Enter to drill in)
│       ├── Chat — full conversation: user prompts & assistant responses
│       ├── Overview — duration, message count, model, cost
│       ├── Timeline — chronological tool calls and messages
│       ├── Files — files read, written, and edited
│       ├── Agents — subagent spawns and results
│       └── Tools — per-session tool call breakdown
│
├── Agents
│   └── Subagent usage across all sessions
│
└── Tools
    ├── Built-in tools ranked by call count
    └── MCP server tools with server grouping

value: Show HN: Cicada – Claude Code usage analysis TUI

author: rnjn


value: A native macOS menu bar app for managing Tailscale. View servers, peers, exit nodes, and connection status — all from your menu bar. Built with Swift/SwiftUI, available via Homebrew.

value: Show HN: TailBar – Tailscale menu bar app for macOS


value:
Last year our Bedrock costs tripled in six weeks. AWS Cost Explorer told us "Amazon Bedrock: $4,200." That was the entire report. We had eight features using the model. We had no idea which one had changed.
We spent two days correlating deployment timestamps with billing spikes before we found it. A caching bug in our recommendations feature was making three model calls where it should have made one. $2,800 of that bill was a single if-statement.
I built spendtrace to make sure that never takes two days again.
bash
```bash
pip install spendtrace
```
python
```python
import spendtrace
spendtrace.auto_instrument()   # patches boto3, openai, anthropic at startup<p>from spendtrace import cost_track<p>@cost_track(feature="ai_recommendations")
def recommend(user_id):
    items = dynamo.get_item(...)       # captured
    response = bedrock.invoke_model(...)  # captured
    return response
```
That's the whole install. No proxy, no sidecar, no config file. One decorator per feature entry point and every boto3 and LLM SDK call inside it is attributed automatically.
Then:
python
```python
for row in storage.aggregate_by_feature():
    svc = row["service_costs"]
    print(f"{row['feature']:<25}  bedrock=${svc.get('bedrock',0):.4f}  dynamodb=${svc.get('dynamodb',0):.4f}  total=${row['total_cost']:.4f}")
```
```
ai_recommendations        bedrock=$0.7140  dynamodb=$0.0010  total=$0.7150
search                    bedrock=$0.0000  dynamodb=$0.0410  total=$0.0420
batch_processing          bedrock=$0.0000  dynamodb=$0.0003  total=$0.0003
```
The number that kept surprising people when I showed them this: `ai_recommendations` at $0.717 per call vs `search` at $0.042. Same product, 17x cost difference, nobody had ever seen that comparison before.
A few things that took more thought than expected:
The context propagation. When `search` calls `product_details` which calls DynamoDB, those reads should be attributed to `product_details` for debugging — but a product manager asking "what does search cost?" wants the fully-loaded number including everything it triggered. We store both. `parent_tx_id` on every transaction lets you reconstruct the full call tree:
```
api                   subtree=$0.018101
  search              subtree=$0.014000
    product_details   subtree=$0.003000  (×3)
  cache               subtree=$0.000100
```
The reconciliation problem. Your modelled costs (rate × count) will always drift from what AWS actually charges because the pricing API doesn't capture reserved capacity, data transfer, support plan, or volume discounts. We pull Cost Explorer by service (DynamoDB separately from S3 separately from Bedrock — not the blended total) and compute a per-service calibration factor. You can then restate historical records in one call if the model was off.
The per-tenant angle. Add `user_id` to your request boundary and every nested call inherits it automatically through Python's `contextvars`. So you get cost per customer without instrumenting every function:
python
```python
@track_request(endpoint="/api/search", user_id=current_tenant_id)
def handle(query):
    return search_products(query)  # all nested costs go to this tenant
```
```
tenant-acme     $47.21/month   (8,341 requests)
tenant-globex   $12.88/month   (3,102 requests)
```
This is exact attribution from the call stack, not inference from billing tags.
What it doesn't do: It's not a proxy, not a dashboard (SQLite backend, self-hosted), not multi-cloud yet (AWS first, going deep before going wide). The `/metrics` endpoint exposes Prometheus counters if you want to alert on spend rate in Grafana.
Code and README: https://github.com/Joshyi-Abini/Spendtrace
Ask me anything about the context propagation design — it's the part I'm most proud of and most likely got wrong in ways I haven't found yet.

value: Show HN: Spendtrace, Feature-level AWS cost attribution (found a 17× gap))


value: intentgarden

value: Show HN: Decima-8 – A deterministic 230KB neuromorphic engine and 1.3MB IDE

author: intentgarden


value: snowsky

value:
Hey HN,
I've been building YourFinanceWORKS, a comprehensive open-source financial management platform that combines enterprise-grade features with AI-powered automation. Think of it as a self-hosted alternative to QuickBooks/Xero with advanced capabilities.
https://github.com/snowsky/yourfinanceworks
Thanks!

value: Show HN: YourFinanceWORKS – Open-source financial management with AI OCR

author: snowsky


value: ethanmlam

value:
Hey HN, I'm Ethan. I was spending 2 hours every morning across HN, Twitter, and newsletters trying to keep up with AI for my startup. So over the past few months, my co-founder Thor and I built FiveW to distill the latest AI developments relevant to us, in a 5 minute briefing.
FiveW does three things:
1. Personalized morning briefing -- talk with an agent on onboarding, and get a daily briefing tailored to your interests that you can deep dive on.
2. Curated AI news feed -- surfaces the most important AI stories of the day from 100+ sources, in one place
3. Live market signals -- BTC, gold, oil prices and Polymarket prediction odds alongside the news
Would love to hear what you think. What would you come back for every morning?

value: Show HN: FiveW – Stay current on AI in 5 minutes a day

author: ethanmlam


value: xheggs

value:
Hi HN,
I’m the solo developer behind VantageKit. I was a PM for a long time and recently decided to get back into coding. I’ve been building this part-time for just under two months (first commit was Dec 26). I was able to move this fast largely by leaning heavily on Claude Code to accelerate my workflow, and I wanted to share the result here to get your feedback.
THE PROBLEM:
-
Sharing pitch decks, proposals, or due diligence docs is full of friction. You either send PDF attachments (and fly blind on engagement) or you use a tracked data room. But with existing data rooms, version control is a nightmare. If you spot a typo 5 minutes after sending the link, you have to export a new PDF, log in, delete the old file, and upload the new one.
WHAT I BUILT & HOW IT DIFFERENTIATES:
-
VantageKit is a secure deal room wrapper for your documents, designed to sit between lightweight trackers and heavy enterprise Virtual Data Rooms (VDRs).
‣ vs. DocSend / Papermark: While they offer "Spaces" or data rooms, they still treat files as static uploads. VantageKit's core differentiator is a built-in staging workflow with live sync. You connect Google Docs/Slides/Sheets directly. You edit privately in your normal Google workspace, preview the changes in VantageKit's staging environment, and "publish" the update to the live room. No exporting to PDF, no manual re-uploading, and the URL never changes.
‣ vs. Traditional VDRs: Standard VDRs are notoriously clunky, expensive, and overkill for everyday B2B sales or seed rounds. VantageKit provides the necessary security controls (watermarking, domain allow/deny lists, download blocks) but with a modern UI and deep read-tracking.
‣ AI & Intent Layer: It tracks per-page attention and scroll depth. I also added an LLM layer that acts as a deal coach: it powers a viewer Q&A so stakeholders can ask questions directly to the docs, and it calculates an intent score (0-100) based on engagement patterns to help prioritize follow-ups.
‣ Viewer Portal: Standard trackers force recipients to dig through old emails to find specific one-off links. I built a centralized viewer portal (an "Investor Inbox") so stakeholders can securely log in once and access every deal room or document you've ever shared with them in a single dashboard.
TRACTION & ROADMAP:
-
The app is currently handling real data. I have 20+ team (4 paid), and one team is currently relying on it for a large-scale live transaction, which has been an incredible stress test. The roadmap is public here: https://app.vantagekit.com/roadmap
TRY IT OUT:
-
Since HN prefers avoiding sign-up walls, I created a public, read-only demo room so you can see exactly what the recipient experiences without handing over an email: https://share.vantagekit.com/r/vm0gb93g11h8
I would really appreciate your brutal feedback on the UX, the staging architecture, or even the thesis. Also if you’ve used DocSend/Papermark/VDRs, where does it break for you? I’ll be in the comments all day to answer questions.

value: Show HN: VantageKit – a lightweight data room with staging, analytics, & AI Q&A

author: xheggs


value: antonijs

value:
Hi everyone, thanks for checking out tracium.
At work I needed some clarity on how much each agent costs us and how they perform on production so I started looking at existing solutions for this such as LangSmith and LangFuse.
Honestly, they felt like they are overcomplicated to integrate and that there should be a simpler solution so I decided to build Tracium.
Tracium keeps track of every single AI API call that you make to an LLM provider, with this you can see traces, spans, I/O, tokens in/out, latency. You can compare during A/B testing, see usage from each customer and see which agents cost you the most vs which ones are used the most.
Feel free to check it out and sign up. This still is an early stage product so any feedback is welcome.

value: Show HN: I made a 1 line AI Agent observability tool

author: antonijs


value: arndt

value: Show HN: P0 – Yes, AI can ship complex features into real codebases

author: arndt


value:
I built AuraText – a free Windows app that sits on top of every app (Notion, VS Code, Slack, Word) and optimizes your AI prompts before they reach the model.
The problem: most people get bad AI outputs because their prompts are vague. AuraText transforms raw prompts using frameworks like RISEN, COSTAR, and RTF – same AI, better input, dramatically better output.
Key things it does:
- Works as a floating overlay in any Windows app
- Built-in AI router (Claude for analysis, GPT-4 for creative, Gemini for research)
- Bring your own API keys – no subscription
- Supports 11 providers including local Ollama
- Learning Mode to actually build prompt skills over time
Built this solo in 4 months. 1,000+ downloads so far. Completely free during beta.
Would love brutal feedback from HN.

value: Show HN: AuraText – Like Grammarly for AI prompts, works in every Windows app


value: akinmaurice

value:
Hey HN
I’m one of the founders of DailyStack.
Like many of you, my workday used to start with a "tab crawl." I’d open Gmail, then Outlook for the corporate stuff, then scan Todoist, check the Linear board for dev tickets, and finally peek at Asana for the marketing syncs. By the time I actually knew what my day looked like, I’d already context-switched five times and lost the "deep work" window of my morning.
We built DailyStack to solve this. It’s a single, high-signal brief that aggregates your day before you dive into the noise.
How it works
We currently support Gmail, Google Calendar, Outlook, Todoist, Linear, and Asana. Instead of just giving you a long list of notifications, we pull the "delta" from the last 24 hours:
Email: Highlights threads that actually need a reply vs. newsletters.
Tasks: Correlates what you finished yesterday in Linear/Asana with what’s actually due today in Todoist.
Calendar: A unified view across Google and Outlook so you don't double-book your life.
The "No-Storage" Architecture
We know that asking for access to your email and task managers is a massive request. We decided early on to build this with a zero-persistence mindset for your private content:
Ephemeral Processing: We don't save your email bodies or task descriptions to a database.
On-the-go Summaries: When you request your brief, we fetch the data via OAuth, process the summary in memory, and serve it. We don't "store and mine" your data to build a profile or train models.
Token Security: We only store the encrypted refresh tokens needed to communicate with the APIs.
Why we’re doing this
There have been a hundred "all-in-one" inboxes that failed because they tried to replace the tools themselves. We aren't trying to be a new email client or a new task manager. We just want to be the 5-minute summary you read before you open those tools.
We’d love your brutal feedback:
The Trust Gap: If you see a summary of a Linear ticket or a Gmail thread, do you feel an immediate urge to go verify the "real" version? How can we make the summary feel authoritative enough to trust?
Missing Pieces: What is the one tool that, if missing, makes an aggregator like this useless for you? (We're looking at GitHub and Notion next).
The Workflow: Does a "Morning Brief" actually fit your routine, or do you prefer to live in the raw feeds all day?
We’re pre-revenue and still figuring out the best way to make this indispensable. I’ll be in the comments all day to talk about the ETL challenges, API rate-limiting nightmares, or anything else.
Thanks!

value: Show HN: DailyStack – Aggregate your work tools into a 5-minute morning brief

author: akinmaurice