value: johncole

value: Not my first time starting a podcast, but definitely the most fun.  I enjoy talking to folks about their work, and highlighting trends in semiconductors.  I'm starting with some mems companies, and then moving over into covering open source subjects for a bit.  If you know someone working on open source silicon, please send me a message!

value: Show HN: I Started a Podcast on Silicon and Economics

author: johncole


value: synterai

value: Show HN: Synter- Open source MCP server to manage ads across 7 platforms

author: synterai


value: I started a job board to help semiconductor design students (and more senior semiconductor folks) find their next internship (and job).  We have a few hundred jobs up, and adding more every day.

value: Show HN: I built a semiconductor internship job board


value: chrismagno

value: CLI + dashboard for open-source maintainers to decide which PR to review/merge first. 20 heuristic signals (scope coherence, complexity, staleness, CI status, etc.) + optional LLM scoring via Gemini, OpenAI, Anthropic, or OpenRouter. v0.5.1 adds --model flag and embedding auto-fallback. Would love feedback from anyone managing large PR queues.

value: Show HN: Treliq – PR triage CLI with 20 signals and optional LLM scoring

author: chrismagno


value: salt-dev

value: Show HN: Lattice OS – A bare-metal unikernel with a 96-cycle syscall

author: salt-dev


value: radicain

value:
We built Valohai LLM for tracking and comparing LLM evaluation results. Whether your evals live in notebooks and spreadsheets, or you're using an observability tool that wasn't built for comparison, this gives you a purpose-built eval comparison dashboard.
Run evals with a Python library (pip install valohai-llm), results stream in, and you can compare up to 6 configurations side by side. Group by any dimension (model, category, difficulty) to see where each model excels.
It doesn't do tracing or production observability, for now just eval tracking and comparison. What's cool is that you can define parameters you would like to test with and run a sweep across all of them.
Feedback welcome, especially from anyone comparing models and evaluating regularly!

value: Show HN: Valohai LLM – Track and compare LLM evaluation results in one dashboard

author: radicain


value: kovacivan

value: Show HN: Oops Backup – Simple off-site backups for your databases

author: kovacivan


value: JuGaDev

value: SHOW HN: Stock analysis accessible, feedback wanted

author: JuGaDev


value: lanath

value:
I built this in ~3 days because every AI coding tool lets the AI decide whether to run tests. Forge flips it: deterministic code orchestrates the AI, not the other way around. Your existing lint/test/coverage scripts become hard gates. AI writes code, your scripts decide if it ships.
Provider-agnostic — ships with Codex SDK, Claude Agent SDK, Claude Code, and Ollama adapters. Forge built itself (the repo is the proof that the code produced is somewhat ok).
Happy to answer questions about the architecture or get roasted on the code quality.

value: Show HN: Forge – Deterministic orchestrator for AI coding agents

author: lanath


value: flinkerflitzer

value: Top Down Sprite Maker (TDSM) is the ultimate pixel art character creator. Customize your character and export your sprite sheet in a matter of a few clicks. Multiple sprite styles, full control over customization and sprite sheet layout, and no need to draw.

value: Show HN: Top Down Sprite Maker – The ultimate pixel art character creator

author: flinkerflitzer


value: I built a Python tool to defer heavy batch ETL jobs (like Snowflake/Airflow) when the local energy grid is "dirty" (high carbon intensity). It uses real-time grid APIs to find green windows. Would love feedback on the logic!

value: Show HN: Carbon-aware scheduler for batch ETL jobs (Python)


value: balajmarius

value:
Hi HN,
We use Claude Code a lot, and after a long session there isn't a simple way to share exactly what happened with someone else. Prompts, responses, file edits, and tool calls all stay inside the terminal.
We built Claudebin to make that easier.
It's a plugin that lets you export the current session as a URL containing:
- the full message thread
- file reads and writes
- bash commands
- web and MCP calls
You can send the link to someone, attach it to a PR, embed part of it, or resume the session locally.
It's open source.
GitHub: https://github.com/wunderlabs-dev/claudebin.com/

value: Show HN: Claudebin – Share and resume Claude Code sessions with a single link

author: balajmarius


value:
Sim2real is a recurrent challenge in robotics: despite the wide array of open-source solutions, end-to-end deployments often require painstakingly long integration of many different tools and frameworks.
This repo aims to provide a "batteries included" solution for flying multi-robot systems (in simulation and real-life).
Aerial autonomy stack (AAS) is an all-in-one software stack to:
- Develop multi-drone autonomy—with ROS2, PX4, and ArduPilot
- Simulate faster-than-real-time perception and control—with YOLO and 3D LiDAR
- Deploy in real drones—with JetPack and NVIDIA Orin
Runs on Ubuntu22/24, WSL. Requires Docker and an NVIDIA GPU.
Rationale and design choices: https://arxiv.org/abs/2602.07264
Happy to hear feedback/answer questions/provide clarifications.

value: Show HN: Aerial-autonomy-stack–Simulate and Deploy Perception-based Drones


value: nathan-wilson

value: Show HN: Weely AI – Branded Link Management and QR Code Generator Platform"

author: nathan-wilson


value: justincxa

value: Show HN: Reddit-style simulated AI Personas to challenge assumptions

author: justincxa


value: andreagrandi

value: Show HN: MCP-wire – install and configure MCPs across multiple AI coding tools

author: andreagrandi


value: Show HN: Erxi – A Fast EXI (Efficient XML Interchange) Implementation in Rust


value: adrianhacar

value:
Last year I built an Android app to block Reels and Shorts while keeping "healthy" features like stories and DMs. I didn't want to block the whole app. I just wanted to message friends and see their posts without losing an hour scrolling on Reels. This was the HN post for the Android version: https://news.ycombinator.com/item?id=44923520
When people asked for an iOS version, I thought it was not possible. Apple is way more restrictive and doesn't allow that level of app access.
But I ended up building the iOS app using a different approach. On iOS, it uses WebApps. It's not exactly the same experience as the native app, but it works surprisingly well.
I also combined it with iOS Shortcuts to auto-redirect the native apps to WebApps, so I can keep Instagram installed for notifications but get sent to the WebApp without Reels and any feed when I tap.
Curious what you think, especially about the WebApp approach on iOS.

value: Show HN: I created an app to remove Reels, now on iOS too

author: adrianhacar


value: saezbaldo

value: Show HN: IC-AGI – Threshold auth for AI agents, formally verified in TLA+

author: saezbaldo


value: Sleywill

value:
Hi HN,
I'm a solo developer based in Tbilisi, Georgia, and I've been building SnapAPI for the past few months. It's a REST API that does four things: screenshots, PDFs, video recording, and structured data extraction from web pages.
*Why I built it:* I was working on a project that needed link previews. I tried self-hosting Playwright — it works, but managing browser contexts, memory leaks, cookie banners, and crash recovery is a surprising amount of operational work for what should be a simple task. The existing APIs (ScreenshotOne, Urlbox) are solid but expensive and fragmented — you need separate services for screenshots vs. data extraction.
*Architecture:*
- *Fastify* handles the API layer. Chose it over Express for the schema validation (I use it as the single source of truth for request validation) and the ~2x throughput difference under load.
- *Playwright* over Puppeteer. The cross-browser support doesn't matter for this use case, but Playwright's `browser.newContext()` isolation and the built-in auto-wait are more reliable for capturing pages at the right moment.
- *BullMQ + Redis* for job queuing. Screenshot requests go into a queue, a separate worker process picks them up. This decouples the API from the heavy rendering work and lets me set per-request timeouts without blocking the event loop.
- *LRU cache* (in-memory + Redis) with content-hash keys. Same URL + same options = cache hit. This alone handles ~40% of requests on busy days.
- *S3-compatible storage* for result delivery. Screenshots get uploaded to object storage, the API returns a pre-signed URL. Files auto-expire after 24h.
- *Cookie banner blocking* uses @ghostery/adblocker-playwright with custom filter lists. It's not perfect (nothing is), but it catches ~90% of GDPR popups. For the rest, I inject custom JS to detect and dismiss common consent frameworks (OneTrust, CookieBot, etc.).
The whole thing runs on a single 4-core/8GB VPS in Amsterdam. Playwright is the bottleneck — each browser context uses ~80-120MB — so I cap concurrent renders at 6 and queue the rest. Under normal load (~500-1000 requests/day currently), p95 latency is around 3 seconds for a full-page screenshot.
*What's different from existing services:*
- Combined screenshot + PDF + video + data extraction in one API (most services only do screenshots)
- AVIF output format (50-80% smaller than PNG, not widely supported elsewhere)
- `extract` endpoint that returns clean markdown, plain text, or structured metadata — useful for RAG/LLM preprocessing pipelines
- Starts at $9/month instead of $29-99/month
*What I'm still figuring out:*
- Video recording (MP4 of a browsing session) is the newest feature and the least optimized. FFmpeg encoding after capture adds 2-5 seconds of overhead.
- Scaling beyond one server. Playwright doesn't cluster well — I'll probably need to go multi-server with a load balancer routing to render nodes. Haven't needed it yet.
- Whether the $9 price point is sustainable. The compute cost per screenshot is ~$0.001, but there's a lot of variance depending on page complexity.
Free tier: 100 requests/month, no credit card. I'm not trying to bait-and-switch — the free tier is genuinely useful for side projects and testing.
Docs: https://snapapi.pics/docs.html
Happy to discuss the architecture, Playwright quirks, or the economics of running a screenshot API. I've learned a lot about browser automation edge cases that I didn't expect going in.

value: Show HN: SnapAPI – Screenshot/PDF/Extract API Built with Fastify and Playwright

author: Sleywill


value: Strugly

value:
For each video, you guess how others react by dropping a point on a 2D pad: Y represents resonance with the content, X represents certainty in that resonance.
The closer your guess is to the crowd’s evolving consensus (which is itself based on others’ guesses), the higher your score. These scores then aggregate into your intuition level - a metric that allows content consumers to be compared.
The idea is to turn the current passive scrolling state of social media into a prediction game where users can compete for social capital through prediction skill rather than content production alone.

value: Show HN: EloLup – guess reactions to short videos instead of scrolling them

author: Strugly


value: markpolymorph

value: Show HN: Cerebro – A hosted AI agent with real browser, web search, and email

author: markpolymorph


value: vtemian

value: Show HN: Learn GPU programming with coding agents

author: vtemian


value: justvugg

value:
Hi HN,
Built llm-use: a lightweight Python toolkit for efficient agent workflows with multiple LLMs.
Core pattern: strong model (Claude/GPT-4o/big local) for planning + synthesis; cheap/local workers for parallel subtasks (research, scrape, summarize, extract…).
Features:
•  Mix Anthropic, OpenAI, Ollama, llama.cpp
•  Smart router: cheap/local first, escalate only if needed (learned + heuristic)
•  Parallel workers (–max-workers)
•  Real scraping + cache (BS4 or Playwright)
•  Offline-first (full Ollama support)
•  Cost tracking ($ for cloud, 0 local)
•  TUI chat + MCP server mode
•  Local session logs
Quick example (hybrid):
python3 cli.py exec \
  --orchestrator anthropic:claude-3-7-sonnet-20250219 \
  --worker ollama:llama3.1:8b \
  --enable-scrape \
  --task "Summarize 6 recent sources on post-quantum crypto"
Or routed version:
python3 cli.py exec \
  --router ollama:llama3.1:8b \
  --orchestrator openai:o1 \
  --worker gpt-4o-mini \
  --task "Explain recent macOS security updates"
MIT licensed, minimal deps, embeddable.
Repo: https://github.com/llm-use/llm-use
Feedback welcome on:
•  Routing heuristics you’d find useful
•  Pain points with agent costs / local vs cloud
•  Missing integrations?
Thanks!

value: Show HN: LLM-use – cost-effective LLM orchestrator for agents

author: justvugg


value: Jerrylui

value:
I built Recycle Abroad after getting confused by local recycling rules while traveling.
You select your home country and current country, and it shows a material-by-material recycling overview (plus nearby recycling centers).
Feedback and corrections are very welcome.

value: Show HN: Recycle Abroad, Recycling Overview

author: Jerrylui


value:
We're building an open protocol that lets organizations continuously audit credentials against breach databases WITHOUT exposing passwords, full hashes, or query results to any server.
The core approach:
1. Hash locally with Argon2
2. Send only first 4 chars of SHA-512 (32-bit prefix) to server
3. Server returns all prefix matches
4. Client verifies locally → server never learns outcome
Current state: Protocol spec + threat model + PowerShell client library. We're pre-funding and actively seeking feedback before building the reference implementation.
Try it: https://iamaxolotl-04.github.io/csp-2026/
Spec: https://github.com/IAmAxolotl-04/csp-2026
We'd love feedback on:
- Where does this break in real deployments?
- What operational constraints are we missing?
- Would you use this in your environment?
Happy to answer questions in the comments.

value: Show HN: Credential Shield Protocol – Server-blind breach checking for passwords


value: yohasebe

value:
I built a menu bar app for macOS that does STT and TTS. There are many such apps, but what frustrated me was that most only transcribe microphone input.
SpeechDock can capture and transcribe system-wide audio or audio from a specific app — video calls, online lectures, podcasts, anything your Mac can play. It also does the reverse: select any text on screen (or capture it via OCR) and have it read aloud.
Key points:
- Works out of the box with macOS native STT/TTS — no API keys needed
- Optionally connect OpenAI, Gemini, ElevenLabs, or Grok for higher accuracy
- Real-time subtitle overlay with translation (80+ languages)
- Global hotkeys — use from anywhere without switching apps
- AppleScript support for automation
- Open source (Apache 2.0)
Requires macOS 14+. Built with Swift/SwiftUI.
GitHub: https://github.com/yohasebe/speechdock
Docs: https://yohasebe.github.io/speechdock/

value: Show HN: SpeechDock – Transcribe any audio on your Mac, not just your microphone

author: yohasebe


value:
Hi everyone,
I have created EasyMemory: a lightweight, fully local memory backend for chatbots, agents and any MCP-compatible LLM (Claude, GPT, Gemini, Ollama…).
Key points:
•  Auto-saves every conversation
•  Ingests PDFs, DOCX, Markdown vaults, folders
•  Hybrid retrieval: vector + keyword + graph (no extra libs needed)
•  Built-in MCP server → plug into Claude Desktop, custom agents, etc.
•  100% offline, data in ~/.easymemory
•  Enterprise extras: OAuth2, API keys, rate limiting, audit logs
•  Bonus: Slack JSON import, Notion/GDrive folder indexing
Quick start (MCP server):
easymemory-server --port 8100
Then point Claude Desktop or your agent to http://localhost:8100/mcp.
Or chat with Ollama:
easymemory-agent --provider ollama --model llama3.1:8b
Python usage:
from easymemory.agent import EasyMemoryAgent
async with EasyMemoryAgent(llm_provider="ollama", model="llama3.1:8b") as agent:
    print(await agent.chat("Remember: I prefer dark mode."))
    # Later...
    print(await agent.chat("What UI do I prefer?"))  # → "You prefer dark mode"
MIT licensed, minimal deps, early stage.
Repo: https://github.com/JustVugg/easymemory
Looking for feedback on:
•  What retrieval mix works best for your long-term memory needs?
•  Pain points with current local memory solutions?
•  Nice-to-have integrations?
Thanks!

value: Show HN: EasyMemory – 100% local memory layer and MCP for LLMs


value: Show HN: TextWeb – Text-grid browser for AI agents, no screenshots needed


value: shortgiraffe

value:
I built this in 2018 as a school project to bulk delete GitHub repos. It got 25k views on Medium and ~10k users organically, then I basically ignored it for years.
Recently I dug into GitHub's community discussion board and some low hanging fruit for feature additions — archive, visibility changes, collaborator cleanup.
GitHub's answer was always "use the API." So I built the UI.

  RepoSweeper now does:
  - Bulk archive / unarchive
  - Bulk visibility (public ↔ private)
  - Bulk collaborator add/remove
  - Staleness scoring so you know what to act on first
  - Handles 100+ repos with persistent selection across pages

It's free forever. Just GitHub auth, no install.

  https://reposweeper.com

Also wrote about how it evolved today if curious:
  https://medium.com/@osoh_app/github-has-no-bulk-anything-so-...
Let me know if you have any feedback. I'm also working on RepoRecap which is more of a productivity summary tool for individual devs.

value: Show HN: RepoSweeper – Bulk GitHub action: archive, delete, collab, visibility

author: shortgiraffe


value:
I started Axon to run claude --dangerously-skip-permissions safely — just isolate it in an ephemeral K8s Pod and the flag isn’t dangerous anymore.
It grew into an orchestration tool. You apply a Task, Axon spins up an isolated Pod, the agent works autonomously, and you get back a PR link, branch name, and exact cost in USD. TaskSpawner can watch GitHub Issues and spawn agents automatically.
I use Axon to develop Axon itself — agents pick up issues, open PRs, and self-review: https://github.com/axon-core/axon/blob/main/self-development...
Written in Go, Apache 2.0. Would love feedback on the approach.

value: Show HN: Axon – Let coding agents develop their own framework on Kubernetes


value: kjraym

value:
I built Raft after thinking about when The Great Suspender was sold and injected with malware a few years ago (https://news.ycombinator.com/item?id=25846504), and seeing the same pattern repeat across the extension ecosystem. I wanted something capable and baked with trust from the start, and now it's ready to share.
No servers, no telemetry, no tracking. The entire codebase is public, including the single Pro feature. Every core feature is free. The only paid feature ($25 one-time) is cloud sync with end-to-end encryption (AES-256-GCM).
Chrome Web Store: https://chromewebstore.google.com/detail/enccggehgndcbkonehp...
My promise: https://raftapp.io/trust
Solo dev, happy to answer anything.

value: Show HN: Raft – Open-source tab manager because extensions have trust issues

author: kjraym


value: portlumeai

value:
I built PortLume AI to solve a problem I had: spending weekends building portfolio websites instead of coding actual projects.
What it does:
- Syncs GitHub repos → auto-generates portfolio with project metrics (commits, stars, languages)
- AI resume parser → extracts experience and generates "About Me" sections
- ATS resume checker → scores your resume against job descriptions (like Jobscan but free)
- AI cover letter generator → tailored letters from job postings in 30 seconds
- Email-to-tracker → forward job emails, AI auto-updates your application status
- Portfolio analytics → track views, clicks, traffic sources (where recruiters come from)
The hardest part was building the email auto-tracker. Resend's inbound webhook gives you raw emails, but I had to:
1. Parse "Thank you for applying" vs "You have an interview" vs job alert spam
2. Extract company names from messy subject lines
3. Match emails to existing applications in the DB
4. Handle LinkedIn's weird forwarding patterns
I tried using OpenAI first, but Gemini 2.0 Flash is 10x cheaper and faster for my use case. The ATS checker analyzes resume-JD keyword overlap and gives specific recommendations (e.g., "Change 'React' to 'React.js'").
Free tier includes:
- Full portfolio builder
- 1 AI cover letter/month
- 1 ATS check/month
- Basic analytics (last 7 days)
Pro ($4/mo) adds:
- Unlimited AI generations
- Email auto-tracking
- Advanced analytics (traffic sources, geo data)
- Custom themes
Looking for feedback on:
- ATS checker accuracy (does it match your experience with other tools?)
- Email parsing reliability (any edge cases I'm missing?)
- Pricing (is $4/mo reasonable for unlimited AI tools?)
- GitHub sync performance (slow with 100+ repos?)
Built this solo over 6 months while working full-time. Currently ~50 users in beta.
Happy to answer technical questions or take feature requests!

value: Show HN: PortLume AI – Auto-generate portfolios from GitHub and AI job tools

author: portlumeai


value: giancarlostoro

value:
GitHub: https://github.com/Giancarlos/guardrails
Good morning from the east coast,
I've been architecting GuardRails for about a month if not longer now, finally checked in the code a week or so ago. Its a tool that lets you have your coding agent (I've been using it with Claude Code) use a ticketing system like Beads or for those unfamiliar, like Jira.
The reason I made a new tool as opposed to sticking to Beads is two primary reasons:
1) Beads is married to git, works with git hooks, needs them. I sometimes work with projects on other version control systems, on machines that don't even have git installed. This is not good for me, as much as I love Beads. The other related reason is that it bugs out sometimes.
2) In Beads the "bead" or task has no safetynet, or guard rail if you will to stop the AI agent from completing a task without validation.
In GuardRails I started from the bottom up. I designed it to be SQLite first, using Go, and I implemented a concept called gates. A gate is what prevents your AI model from completing a task. A gate can be as simple as "run unit tests" or "build the project to ensure no build issues are found" and even "ask the human for manual testing" whatever you want it to be, its just there to prevent your agent from just closing a task. Every task requires one gate. Gates can be re-used, and if you re-use one, this new copy must pass for your new task(s).
It is still early stages, and I'm still working out what features to add. I am definitely looking to add a web interface though I think as a separate tool so you can run it once and see the tasks and their statuses, as well as all your gates.
Another thing worth noting is currently it supports two-way synching for GitHub issues, so whether you want to pull down GitHub issues for your agent to work on, or sync up GitHub issues. Worth noting is that I implemented a "claim" system when you pull down a specific GitHub task, the agent will comment for you to signal to others that someone could potentially be working on a GitHub task. In the future I want to figure out a way to have the agent first check a project for its AI policies to ensure that it does not claim a task it shouldn't be working on (we all saw this happen on HN recently).
For those wondering, I definitely "vibe coded" this, though I hate that term because it takes away from all the work I put into designing and testing this tool. All of the tickets I have generated locally are up on the GitHub, you can see what's planned, what's been worked on, and what have you. I use it for all my personal projects, hoping to showcase those as well in the future.
I welcome any feedback.
Thanks,
Giancarlos

value: Show HN: GuardRails – A new coding agent task tool inspired by Beads

author: giancarlostoro


value: rogerdickey

value: As an angel investor in ~15 unicorns and a bunch of other startups, I spend a lot of time reviewing decks for founders as a favor. I love to help but I wish my time had even more impact. So I built Decks For Good, a website where founders can get feedback on their deck and fundraising process from a VC or exited founder in exchange for a $250 donation to charity. We put together a great group of advisors and we're ready to help you out! Sign up and let's do some good together.

value: Show HN: Decks For Good – get fundraising advice when you give to charity

author: rogerdickey


value: Sleeves

value:
The Lamplighter generates five stories daily, each presented three ways: a left-leaning version, a right-leaning version, and a center column sourced only from public records and primary sources. The left and right versions have bias markup built in — opinion is highlighted in yellow, misleading claims in red. You can toggle highlights on/off to read the story "clean" first, then see where the framing is.
It's fully AI-generated (Claude API) and transparent about that. The pipeline scrapes coverage from across the political spectrum, identifies the factual core, then generates three versions. Center column cites only government data, court records, wire services. The partisan columns cite the outlets whose framing they're modeling.
The whole thing runs on Replit with a PostgreSQL backend, generates automatically at 6 AM, and costs about $1/edition (for me). It also has three AI columnist personas who write opinion pieces and a literary column called "By Lamplight."
I'm not claiming this is better journalism — it's a tool for making the machinery of media bias visible. Interested in feedback on the approach, the bias detection methodology, or anything else.

value: Show HN: The Lamplighter – Same story from left, right, and verified center

author: Sleeves


value: ShreyaChaurasia

value:
If you sell credits or tokens, at some point someone asks:
 “What is one credit actually worth?”
We shipped explicit Wallet Conversion Rate controls in Flexprice to answer that cleanly.
Each wallet can now define:
• conversion_rate — how credits map to currency when spending
 • topup_conversion_rate — optional rate used only when adding credits
This supports use cases like promotional top-ups, bonus credits, or discounted purchases while keeping invoice calculations consistent.
Wallets store credits.Invoices remain in a single base currency.
Conversion defines the relationship between the two.
The goal is simple: make credit systems flexible for product teams and predictable for finance teams.
Happy to answer questions about edge cases or implementation details.

value: Show HN: Credit-to-currency conversion controls for wallet-based billing

author: ShreyaChaurasia


value: iaro-dev

value: Show HN: HoldMyWhoop – Professional wearable delegation for fitness trackers

author: iaro-dev


value: uhs-robert

value: Show HN: HyprVim – System-wide Vim modes in Hyprland with which-key HUD

author: uhs-robert


value: CosmoSantoni

value:
Claude Code sessions (or any coding agent of your choice)  build up real understanding of your codebase, but it all lives in context. Once that fills up, /compact compresses hours of work into a few sentences.
The idea is that contextual memory virtualisation snapshots that context so you can branch from it later. Spend 40 minutes mapping your codebase, snapshot it, then fork into independent sessions for each task, that way they all sharing the same base understanding. When context gets bloated, trim strips the dead weight (raw file contents, base64 blobs) while keeping every message verbatim. 50-70% smaller, nothing lost from my testing.
TLDR; build understanding once, reuse it, trim the bloat.

value: Show HN: CMV – Virtual memory for Claude Code sessions

author: CosmoSantoni


value: rsdza

value: Show HN: AI agent audited its platform, got 80% wrong, rewrote its methodology

author: rsdza


value: lepuzfcoder

value:
Hey HN. I built this because I've been in therapy for years and noticed that a big part of what therapists do is ask the right questions at the right time. I wanted to see if an AI could serve as a daily self-reflection tool — not replacing therapy, but as a complement to it.
Some design decisions and why:
Desktop-only, intentionally. I think therapy should feel like sitting down with your thoughts, not scrolling on your phone. The desktop constraint is a feature.
BYOK (Bring Your Own Key). You use your own Claude API key. No backend, no data collection, no accounts. Your conversations never leave your machine. This felt non-negotiable for something dealing with mental health.
Built with Claude Code. I work full-time as a team lead at an edtech company, so this was built in evenings and weekends, mostly through vibe coding sessions.
I use it myself daily. 15–20 min sessions with Opus + extended thinking. After weeks of use, it picks up on patterns in how you think — recurring avoidance behaviors, cognitive distortions, etc.
The name comes from "Gnothi Seauton" (Know Thyself) — the inscription at the Temple of Delphi.
There's no comparable open-source tool in this space. Every mental health AI app I found is closed-source and collects user data. I wanted to build the alternative I wish existed.
Feedback welcome — especially on the approach, architecture, or if this is fundamentally a bad idea. Happy to discuss.
GitHub: https://github.com/Lepuz-coder/opengnothia

value: Show HN: OpenGnothia – Open-source AI therapy companion (BYOK)

author: lepuzfcoder


value: LoganFlaherty

value:
I’ve been working on a Rust macro called Banish for defining rule-based state machines declaratively.
Instead of manually writing transition loops, Banish evaluates rules within a state until no rule fires (a fixed-point model), then transitions. The macro expands into regular Rust, which allows for seamless integration.
The goal is to make complex rule logic and state machines easier to express while keeping runtime costs identical to handwritten code.
The project was featured as Crate of the Week in the Rust newsletter this week. I'd love to hear your feedback.
Example:
use banish::banish;
fn main() {
    let buffer = ["No".to_string(), "hey".to_string()];
    let target = "hey".to_string();
    let idx = find_index(&buffer, &target);
    print!("{:?}", idx)
}
fn find_index(buffer: &[String], target: &str) -> Option<usize> {
    let mut idx = 0;
    banish! {
        @search
            // This must be first to prevent out-of-bounds panic below.
            not_found ? idx >= buffer.len() {
                return None;
            }

            found ? buffer[idx] != target {
                idx += 1;
            } !? { return Some(idx); }
            // Rule triggered so we re-evalutate rules in search.
    }
}

value: Show HN: Banish – A declarative DSL for rule-based state machines in Rust

author: LoganFlaherty


value: ainthusiast

value:
I built Unbury because as someone with ADHD, I kept screenshotting things I swore I'd come back to - and ofc never did. That restaurant someone recommended. A book I saw on someone's story. Concert tickets I meant to buy. All buried under 100,000 screenshots I'll never scroll through.
So I built an AI that actually understands why you saved each screenshot and sorts them automatically - Watch, Buy, Read, Listen, Event, Place, Inspo, Memory. The part I'm most proud of: everything runs 100% on your device (edge AI). No cloud. No account. No wifi needed. The AI downloads once during setup, then works completely offline.
Would love to hear how you use your screenshots - or if you're like me, how you forget about them.

value: Show HN: Local AI app that remembers what your screenshots were for:)

author: ainthusiast


value: SurceBeats

value: Show HN: GhostInk – Hide secret text inside emojis using Unicode tag characters

author: SurceBeats


value: Show HN: Localizeflow – Zero-config doc localization used by 14 MS OSS repos


value: bbokan

value: Show HN: Mogamp – Winamp for macOS

author: bbokan

title: Show HN: Mogamp – Winamp for macOS


value: rambokdev

value: Show HN: Portabase: A self-hosted tool for database backup and restore

author: rambokdev


value: josiahsrc

value:
Hey HN, I'm Josiah. We love voice dictation, but wanted an open source version for transparency, privacy, and something that everyone could contribute to. So we built Voquill, an open source alternative to WisprFlow, Monologue, and Willow.
It lets you dictate into any desktop app. Press a hotkey, talk, text gets inserted. You can run Whisper locally, use our server, or wire up any provider you want (OpenAI, Claude, Groq, OpenRouter, whatever). You have full control over where your data goes.
Runs on Windows, macOS, and Linux. Open source, AGPLv3, built with Tauri and Rust. We're working on a mobile app too (Flutter).
To try it: Download from the repo or voquill.com. Click "local setup" on first launch. Hope you like it!

value: Show HN: Voquill - free, open source, cross-platform alternative to WisprFlow

author: josiahsrc


value: TheBigA

value:
I had the idea for this site when I wanted to hire a CAD designer to turn a drawing of a simple enclosure into a 3D model. Fiverr wasn’t gonna work for me: fees cut into what I could pay the freelancer, flat rates don't reflect project complexity, and hourly rates are unpredictable when you're a broke college student on a tight budget. I'd rather share a form made to collect offers, then pay whoever offered a good deal directly. So I built offerlog.io.
Offerlog is a free and simple tool to hire, sell, barter, buy, or auction without being restricted by an online marketplace:
- No account necessary
- Create and customize your campaign
- Share your public URL (on campus, social media, around town, …)
- Receive offers via private link
It's 2 parts Google Forms, one part Craigslist, one part eBay :)
This is my first launch — any feedback is a huge win. Try it out and let me know what you think, bonus points if you find a bug!

value: Show HN: Offerlog – buy or sell anything on your own terms

author: TheBigA


value: figmaster

value: Show HN: Shadcn theme generator for lazy devs

author: figmaster


value: Show HN: Peak Finder 2 game – Feel the AI training computer with friend


value: dcosson

value: Show HN: H2, a tmux alternative for running agents with built in messaging

author: dcosson


value: tlarkworthy

value: Show HN: The Lopecode Tour

author: tlarkworthy

title: Show HN: The Lopecode Tour


value: HarakiriGod

value: Show HN: Refine.tools – 10 client-side career tools

author: HarakiriGod


value: Show HN: LibreUI -- A simple, responsive UI library for React


value: Show HN: FSM-agent-flow – Write LLM workflows that test themselves


value: KrishnaTorque

value:
Hi HN,
I built Feuxo to help freelancers and job seeker finds real-time active opportunities outside traditional job boards.
It scans public posts where people explicitly say they’re looking for specific skills (e.g., “need a developer”, “looking for digital marketer”), and surfaces:
- The original live post link
- Contact information when available
- AI-generated personalized outreach / cover letter you can use quickly
I started by doing this manually for people replying to my posts, and in the last 24 hours I helped 300+ people find opportunities that way. After that volume, I opened up the minimal MVP so anyone can try it themselves.
It’s free to use during this early stage, and what I’m really looking for is honest feedback on:
- Whether the leads look valid
- How useful the AI-generated outreach is
- Any confusion or missing info in the workflow
Happy to answer questions here.
If you want to try it.
https://feuxo.com

value: Show HN: Feuxo – Real-Time hiring posts + contacts + AI personalized outreach

author: KrishnaTorque


value: dreadsword

value: Design and print, or order professionally printed business cards. 100% vibe coded with Replit, to scratch an itch I had before a recent trip to mexico.

value: Show HN: Design and print allergy cards for free in multiple languages

author: dreadsword


value: dbhariprakash

value: Show HN: VibeScan – Free client-side security scanner for AI-generated code

author: dbhariprakash


value: mbvisti

value:
I’ve been building production Go web apps for the past 7 years. One gap I kept running into: most Go resources teach syntax well, but stop before things actually look like production.
So I built the course I wish I had.
You build a real app from start to finish: a blog with authentication and an admin portal, PostgreSQL, server-side rendering (Templ), Datastar for interactivity, Docker, and VPS deployment.
13+ hours, 40+ lessons, structured in 3 parts:
Core app + architecture, Data layer + auth, Deployment + production concerns
Stack:
Go 1.24, Templ, Datastar, Tailwind, PostgreSQL (SQLC), Goose, Docker.
Early bird runs through Feb 28 ($35, normally $100).
30-day refund if it’s not useful.
https://mastergolang.com
Happy to answer questions about the curriculum, stack choices (especially Templ + Datastar vs SPA), or anything else.

value: Show HN: Master Golang, Fullstack Go web dev course, scratch to production

author: mbvisti


value: tgies

value:
I ported Jason Hutchens' 1998 Loebner Prize-winning chatbot, MegaHAL, to run entirely inside PostgreSQL, in pure SQL. The entire lifecycle -- tokenization, learning, keyword extraction, Markov chain generation, and entropy scoring -- is implemented in standard SQL using complex CTEs. There is no PL/pgSQL or any other sort of procedural escape hatch.
Learning is a single ~560-line SQL statement that splits text, interns symbols, and updates two 5th-order Markov tries (forward and backward) using depth-unrolled writable CTEs. Inference is a recursive query that generates N candidate replies in parallel. It performs bidirectional weighted random walks, evaluates them for information-theoretic surprise, and formats the winner as a sentence-cased string.
I provided a `docker-compose.yml` and convenient Python driver script so you can try it out quickly, and there's also a web-based demo where I bundled it with PGlite (WASM PostgreSQL) at https://tgies.github.io/megahal-sql/. These are provided for convenience, but you can also just run the schema initialization SQL and `SELECT megahal_converse('hello from hn.');`

value: Show HN: MegaHAL in Pure SQL

author: tgies

title: Show HN: MegaHAL in Pure SQL


value: Show HN: Cord – Agents that build their own coordination trees


value: bgrigore

value:
Hey HN,
I found myself wanting to animate different designs I’ve been creating in Figma, and every time I had to export each asset individually and import it into a video editor just to animate it.
I got tired of that workflow and built a Figma plugin to handle it instead.
Basically, you run the plugin, select a frame, choose an animation, and export it.
It opens in Rendley’s video editor to handle the export, but it’s free and there’s no watermark.
Would love to hear your thoughts, especially if you have ideas for animations or features you'd want to see.

value: Show HN: Created a Figma plugin to make videos

author: bgrigore


value: danalert

value:
Hi HN,
For the last few months I’ve been working on Maestro App Factory, a free and open source tool for using AI agents to build software. It’s not a generic orchestrator: it implements agents with distinct roles and functionality, organizes them into a team, manages their work, and enforces highly opinionated tooling, workflows, and constraints in software.
The core ideas are simple:
- LLMs act like human engineers.
    LLMs are trained on human artifacts and exhibit human-like behaviors (including blind spots). Rather than asking a single model or agent to design, implement, and evaluate everything, Maestro structures systems more like high-performing human teams.
- Heterogeneous models write better code.
    Models from different providers (e.g. Google, OpenAI, Anthropic, Mistral) are trained differently, have different strengths, and catch different errors. Using multiple models with settings optimized to specific roles has, in my experience, consistently produced better results than reusing a single model with different prompts or contexts.
- Don’t just trust agents.
    Agents don’t reliably follow workflows, restrictions, or tooling specified in prompts or config files. Letting them run with privileged access on your machine is also a real security risk. Tooling, workflow, and security need to be enforced by the system itself, not just described to the model.
- Autonomy is required to scale.
    If your development flow requires a human to constantly watch streaming LLM output, you can’t scale beyond a handful of agents. Maestro is designed so agents can work autonomously until they’re genuinely blocked and need to escalate.
Agents are named for the human roles they play — product manager, architect, coder — to keep the system understandable. So far, I’ve used Maestro to build several games and a handful of web apps. It executes epics of a dozen stories or more with zero human intervention.
If you want to know more, here's the detailed overview including screenshots:
https://github.com/SnapdragonPartners/maestro/wiki
Maestro is available as a single downloadable binary or via Homebrew, and runs out of the box on Linux and macOS (signed and notarized) as long as LLM API keys are set as environment variables (see the README). With luck, you should be up and running in minutes.
There’s still plenty to do, but the current version is complete enough to be useful and demonstrate the ideas.
Happy to answer questions or take feedback/criticism.

value: Show HN: Maestro App Factory – FOSS Agentic Engineering Orchestrator

author: danalert


value: dorukalpulgen

value:
Hey HN,
We built IPAware (https://ipaware.io) - an IP intelligence API that doesn't charge per request.
What it does:
- IP geolocation (country, region, city, coordinates, timezone)
- Threat detection (VPN/Proxy/Tor, risk scoring, datacenter detection)
- ASN/ISP data
- Clean JSON responses
Why we built this:
Every IP lookup service we tried had the same problem - you start small, your app grow and suddenly you're paying hundreds for what should be a commodity lookup. The metering anxiety is real. We wanted something we could integrate without worrying about the bill exploding.
How it works:
Flat monthly/yearly pricing. Pro plan is unlimited requests for $9.99/month or $99.90/year. Free tier gives you 5000 requests/month to try it out. Fair-use limits exist to prevent abuse, but no per-request metering.
Tech details:
- Edge delivery for low latency
- REST API, returns JSON
- No SDK required (works with curl, fetch, or any HTTP client)
- Databases updated every night for accuracy
- IPv4 and IPv6 support
Limitations to be upfront about:
- City-level accuracy varies by region (country/region is reliable, city is best-effort)
- Fair-use applies on unlimited plans - this isn't for scraping the entire internet
- Our threat detection algorithm is good but not perfect
Launch offer:
Sign up within the first 24 hours and get the Pro tier ($9.99/month) free for an entire month. Your account gets a full month of unlimited Pro access with features that are not normally available to the free tier - no strings attached. At any point, you can decide to keep the Pro tier or switch to the free tier on the dashboard.
Happy to answer questions about the tech, infrastructure, or anything else.
All feedback is greatly appreciated!

value: Show HN: IPAware – Unlimited IP Intelligence API with Flat Pricing

author: dorukalpulgen


value: savvyllm

value:
I built a unified REST API for mining tenement data because the fragmentation across government portals was driving me crazy.
Each state/province has different formats, different APIs (or no API at all), different field names. If you wanted to answer "what tenements does Company X hold across multiple jurisdictions?" you'd need to query 4+ different systems.
Currently covering:
- Western Australia: 30,101 tenements
- Northern Territory: 3,945 tenements
- British Columbia: 41,981 tenements
- Saskatchewan: 7,600 tenements
Free during beta, no API key required. Designed for AI agents that need structured mining data.
Would love feedback, especially from anyone working in mining tech or building AI agents that need real-world data sources.

value: Show HN: Mining tenement API – 83K tenements across AU and CA

author: savvyllm


value:
Vibecoded this with a friend in a few prompts while waiting for Claude to finish building something else.
https://github.com/rokas-tarasevicius/here-comes-another-bub...

value: Show HN: Here Comes Another Bubble – AI Startup Simulator


value: gleipnircode

value: Show HN: Gave AI $100 and no instructions – it donated $40 to a hospital

author: gleipnircode


value: socialPrarysoft

value: Show HN: TrustSignal–Free outside-in trust readiness scanner for SaaS companies

author: socialPrarysoft


value:
i kept hitting rate limits in Claude Code mid-debugging, then hopping to Gemini or Codex. the annoying part wasn't switching tools (copy-pasting terminal output doesn't bring tool-use context with it) — it was losing the full conversation and spending 10 minutes re-explaining what i was doing.
so i built *continues*. it finds your existing AI coding sessions across five tools (Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, OpenCode), lets you pick one, and generates a structured handoff so you can continue in another tool without starting from zero.

    npx continues                          # interactive TUI: pick a session, pick a target
    continues scan                         # see what it finds (read-only)
    continues claude                       # jump into your latest Claude Code session
    continues resume abc123 --in gemini    # hand off a specific session to Gemini

the flow:
* scans the current directory first (so you see what's relevant), then shows everything
* you pick a session + a target tool
* it generates a handoff doc: recent conversation, cwd, files modified (best-effort), pending tasks
* launches the target tool with everything injected inline — no extra "go read this file" step
what it's not:
* not "true migration" — it's context injection. you get recent messages + metadata, not a full replay (pls come up with PR for full session reprod)
* rate limit detection is manual for now — you run it when you know you're blocked, no auto-detect yet
* session formats are mostly undocumented and can change anytime (this is the biggest maintenance risk)
* local file parsing only, no API calls — your data stays on your machine
curious if anyone else actually juggles multiple AI coding CLIs, or if most people just commit to one and wait out rate limits. would love to hear how you handle tool-switching + context today + feedbacks on context quality migrations and feedbacks are welcomed.

value: Show HN:`npx continues` – resume same session Claude, Gemini, Codex when limited


value: saidileepkumar

value: Show HN: Voice AI that answers your restaurant's phone and posts orders to POS.

author: saidileepkumar


value: cpcloud

value:
micasa is a terminal UI that helps you track home stuff, in a single SQLite file. No cloud, no
account, no subscription. Backup with cp.
I built it because I was tired of losing track of everything in notes apps, and "I'll remember
that"s. When do I need to clean the dishwasher filter? What's the best quote for a complete
overhaul of the backyard. Oops, found some mold behind the trim, need to address that ASAP. That
sort of stuff.
Another reason I made micasa was to build a (hopefully useful) low-stakes personal project where
the code was written entirely by AI. I still review the code and click the merge button, but 99%
of the programming was done with an agent.
Here are some things I think make it worth checking out:
- Vim-style modal UI. Nav mode to browse, edit mode to change. Multicolumn sort, fuzzy-jump to
  columns, pin-and-filter rows, hide columns you don't need, drill into related records (like
  quotes for a project). Much of the spirit of the design and some of the actual design choices
  is and are inspired by VisiData. You should check that out too.
- Local LLM chat. Definitely a gimmick, but I am trying preempt "Yeah, but does it AI?"-style
  conversations. This is an optional feature and you can simply pretend it doesn't exist. All
  features work without it.
- Single-file SQLite-based architecture. Document attachments (manuals, receipts, photos) are
  stored as BLOBs in the same SQLite database. One file is the whole app state. If you think
  this won't scale, you're right. It's pretty damn easy to work with though.
- Pure Go, zero CGO. Built on Charmbracelet for the TUI and GORM + go-sqlite for the database.
  Charm makes pretty nice TUIs, and this was my first time using it.
Try it with sample data:
go install github.com/cpcloud/micasa/cmd/micasa@latest && micasa --demo
If you're insane you can also run micasa --demo --years 1000 to generate 1000 years worth of
demo data. Not sure what house would last that long, but hey, you do you.

value: Show HN: Micasa – track your house from the terminal

author: cpcloud


value: Show HN: Bravehuman – AI training for high-stakes conversations


value: digitalofen

value:
Hi HN,
I’ve been experimenting with how much file conversion can realistically be pushed into the browser.
Last year I tried compiling LibreOffice headless to WASM. The smallest build I could get was ~150MB — far too large just to convert a DOCX to PDF. That’s when I shifted to a hybrid approach.
Today ~90% of conversions run client-side using WASM (FFmpeg, PDF/image tooling, spreadsheets, etc.). The heavier edge cases fall back to a small server pipeline (LibreOffice, Pandoc, Poppler).
The main challenges weren’t the libraries themselves, but:
browser memory ceilings
handling large files without freezing the UI
lazy-loading ~30MB of WASM only when needed
Safari vs. Chromium behavior differences
FFmpeg.wasm runs at roughly 10–20% of native speed. Acceptable for small/medium files, less so for large media.
I also experimented with multithreaded FFmpeg in the browser, but haven’t found a stable setup yet.
Curious how others think about the tradeoff between client-side processing vs. fully server-side pipelines.
→ anythingconverter.com

value: Show HN: How far can you push file conversion into the browser?

author: digitalofen


value:
I built Crit, a CLI tool that lets you capture screenshots from iOS Simulator, drop pins on what's wrong, and hand structured feedback to any coding agent.
You just:
crit capture — screenshot your app screens
crit serve — review in browser, click to pin bugs and add comments
Tell your agent: "review .crit and fix each issue"
It saves annotated screenshots and JSON to a .crit/ folder. Works with Claude Code, Cursor, Codex, Gemini — anything that can read images. No plugins, no MCP, no dependencies.
macOS + Xcode required. Android not yet supported.
Repo: https://github.com/natethegreat/crit

value: Show HN: Crit – Visual QA for iOS apps and AI coding agents


value: chiengineer

value:
Introducing Towel Protocol
Yes It works / Based on windows 11 enterprise / Has avalonia UI
100% created with a couple days work with AI github copilot pro plus with vs code
windows 11 introduced lots and lots of AI / new telemetry / the old tools released projects and basically everything released out hasn't caught up so I decided to create over 10+ tools with different ideas implementations and they weren't good enough deleted all of them and made this one with C# and works great so good its now free forever!
Individual Policy Selection: Granular control - select exactly which policies to apply
Privilege Separation: UI runs as standard user, service runs as LocalSystem
Audit Mode: Inspect current system state before making changes
Full Reversibility: All changes can be rolled back
Drift Detection: Monitors for changes after Windows updates
Profiles: Balanced, Hardened, and Maximum Privacy presets
Restore Points: Automatic system restore point creation
Transparent: Every change is logged and explainable
- donations are welcome - helps me digest more gallons of coffee to make more cool stuff

value: Show HN: Experimental C# Windows 11 privacy hardening framework(not just an app)

author: chiengineer


value: javierbuilds

value: Show HN: Public Speaking Coach with AI

author: javierbuilds

title: Show HN: Public Speaking Coach with AI


value: AndyCappDev

value:
Hi HN, I built a PostScript interpreter from scratch in Python.
PostForge implements the full PostScript Level 2 specification — operators, graphics model, font system, save/restore VM, the works. It reads .ps and .eps files and outputs PNG, PDF, SVG, or renders to an interactive Qt window.
Why build this? GhostScript is the only real game in town for PostScript interpretation, and it's a 35-year-old C codebase. I wanted something where you could actually read the code, step through execution, and understand what's happening. PostForge is modular and approachable — each operator category lives in its own file, the type system is clean, and there's an interactive prompt where you can poke at the interpreter state.
Some technical highlights:
- Full Level 2 compliance with selected Level 3 features
- PDF output with Type 1 font reconstruction/subsetting and TrueType/CID embedding
- ICC color management (sRGB, CMYK, Gray profiles via lcms2)
- Optional Cython-compiled execution loop (15-40% speedup)
- 2,500+ unit tests written in PostScript itself using a custom assertion framework
- Interactive executive mode with live Qt display — useful for debugging PS programs
What it's not: A GhostScript replacement for production/printer use. It's interpreted Python, so it's slower. But it handles complex real-world PostScript files well and the output quality is solid.
I'd love feedback, especially from anyone who's worked with PostScript or built language interpreters. The architecture docs are at docs/developer/architecture-overview.md if you want to dig in.

value: Show HN: PostForge – A PostScript interpreter written in Python

author: AndyCappDev


value: axsaucedo

value: Show HN: Use SQL to Query Your Claude/Copilot Data via DuckDB

author: axsaucedo


value: atmanactive

value: Doing my part for the AI Cambrian Explosion of software :) Tauri2 Any WebApp Wrapper is a simple portable executable that can wrap any website in the operating system's webview. This can come handy when you need to treat a WebApp like a desktop first class citizen, as opposed to having it just as a browser tab somewhere. Features include: easy configuration via JSON file, rename-able exe so you can give it a name of your WebApp, configurable taskbar icon, dark mode including force dark mode, size and position remembered, minimize on startup if needed. MIT license.

value: Show HN: Tauri2 Any WebApp Wrapper

author: atmanactive

title: Show HN: Tauri2 Any WebApp Wrapper


value: falkerdev

value: Show HN: High-performance Hex editor in C# with a custom DSL for binary patching

author: falkerdev


value: jacobchak

value:
OpenRouter free models flake out often. Built this for reliable demo fallbacks. I use it for my MVPs and POCs' demo.
- Live model list + reliability rankings (community feedback)
- Filter by use case/health/exclusions via web UI
- await getModelIds() -> dynamic rotation
- GitHub (self-host): https://github.com/kaihochak/free-llm-router
- Hosted (200/day): http://freellmrouter.com
Feedback welcome!

value: Show HN: FreeLLMRouter – Live ranked list of OpenRouter free models

author: jacobchak


value: guanlan

value:
Hi HN,
I’ve been using OpenClaw daily since it dropped in November. I love the agency it provides, but as I started giving it more production API keys and access to my local filesystem, I realized the threat model was essentially "hope-based."
We ran an experiment to see how resilient a standard OpenClaw setup was to prompt injection. Within 2 mins, we were able to exfiltrate active session tokens and API credentials through the chat interface.
The problem is fundamental: in most agent architectures, the LLM logic and the sensitive credentials live in the same process space. If the agent is tricked, the attacker has everything.
We built and open-sourced a project called ClawShell to move the security boundary from the "prompt" to the "system runtime."
How it works: ClawShell acts as a privileged protection layer. It isolates sensitive operations into a separate process enforced by the OS. The secrets never enter the agent’s memory or process space. When the agent needs to perform an action, it sends a request to the ClawShell wrapper, which validates the intent and executes the call using the protected keys.
If the agent is hijacked via prompt injection, the attacker gets a scoped identifier that contains zero credentials and no lateral access to the sensitive environment.
Key Technical Details:
* Structural Boundaries: We assume the LLM is untrusted. Isolation is handled at the OS level, not via "system prompts."
* Zero-Trust Tooling: The agent triggers the tool, but the tool execution is handled by a separate, restricted process.
* Compatibility: It’s designed to be a drop-in wrapper for existing OpenClaw instances.
We’re launching v0.1 today. I’m curious to hear how others are thinking about the "Lethal Trifecta" (Data + Action + Communication) in the agent space. Is anyone else looking at Sanboxing for this, or is OS-level isolation the right path?

value: Show HN: ClawShell, Process-Level Isolation for OpenClaw Credentials

author: guanlan


value: jasonlantz

value:
Hi HN, I'm Jason, creator of Kantext.
I spent the last year exploring the concept that context is a new data type that none of our current systems were designed to handle. Context evolves with every interaction, changes shape, is deeply nested and relational, and must be deterministic.
The Problem: We currently treat AI context like a storage problem (vector DBs) or a retrieval problem (RAG). But vectors destroy structure, and graphs are hard to version. When an agent hallucinates, it’s often because we fed it a "soup" of tokens rather than a structured, provenanced reality.
The Solution: Kantext treats Context as a first-class data type. It’s not a wrapper; it’s a composable, layered data structure where meaning is fused into the data at declaration time.
Try it: The website currently has a wasm playground (https://kantext.dev/playground) with the full composition engine available to try out through multiple scenarios. I'm working toward an open source release of the core engine soon along with full documentation.
The Architecture:
- Declared Language: A language of Declarable Shapes with layers for Value, Meaning, Space, Bond, Compose, and Boundary. Boundaries operate like JSON Schema's Definitions, but they are hierarchical and cascade.
- Context-Addressable Storage (CxAS): The parse -> decompose phase separates content and structure. These fragments are blake3 hashed with typed domains and stored in a global append-only DashMap.
- Holograph: The engine composes the decomposed, CxAS-stored content through a 2-stage k-way merge process of up to 62 Frames. We use BpTree, EliasFano, and WaveletMatrix (in pure Rust) to keep memory usage low and lookups mostly in CPU cache.
- Grounded: Every composition is cryptographically sealed to a Git commit. The Holograph's Projector can output multiple styles, including a compressed "Declared" format that is a full round-trip .kant file. Anything done in memory can be re-grounded to git.
Benchmarks (M2 Max):
Full Parse -> Holograph: ~20MB/s
(Note: This is NOT just parse speed. This includes parsing, structural decomposition, Blake3 hashing for Context-Addressable Storage, deduplication, BpTree/EliasFano/WaveletMatrix construction, and cryptographic sealing. So, more like a runtime compiler than just a parser)
Query Latency: ~1-75µs
Composition: 880K points/sec, working toward goal of 1M/s
Binary: ~7MB (No external DB required)
The Backstory:
Kantext started as a sort of DSL for DSLs. I spent the last decade building tooling around composable, structurally merged YAML with CumulusCI in the Salesforce ecosystem. Looking to build the evolution of that vision beyond my platform silo, I started in Python, my native language for ~20 years. About 200 Pydantic models into building a declarative delivery system DSL, I hit the composability wall.
Kantext is what came from the realization that we lacked a secure, runtime composable type system for deeply nested context that evolves across instances and interactions.
Kantext started as a yaml embedded language. Now, Kantext's language, the .kant format, uses a custom parser built on chumsky and is a super/subset of YAML with two major differences:
1. No quotes, No NO (or similar) problems: The parser is contextual. Every key is fully parsed and identified before its value. That's thanks to proc macro codegen of a nanosecond tuned parse_key fn for each Shape in the core language.
2. We replaced the yaml tag slot with a "shorthand value" slot, enabling a more ergonomic key + value + nested map pattern.
The name started as a philosophy pun that grew into technical architecture after realizing the influence of Descartes in how we think about type systems and Immanuel Kant's critique of Descartes.
I'd love to hear your feedback, and I'll be hanging out to answer any questions about the Rust internals, the data structures, or the language!

value: Show HN: Kantext – A context-native data store in Rust, grounded in Git

author: jasonlantz


value: Show HN: Qlaude – Queue Tasks for Claude Code, Control via Telegram


value: therealcartine

value:
I built Foolery because agentic coding was making me feel worse, not better. 12 tmux panes, 7 orphaned worktrees, Claude blowing context on micro-ideas I couldn't stop throwing at it.
Foolery is a local web UI that sits on top of Beads (issue tracker). It gives you:
- Dependency-aware wave planning (decompose work into parallelizable batches)
- Built-in terminal to monitor agent runs live without leaving the app
- Verification queue — every "done" beat flows here for you to approve or reject
- Keyboard-first, no TUI
Install: curl -fsSL https://raw.githubusercontent.com/acartine/foolery/main/scri... | bash
I also wrote about why I built it: https://thecartine.substack.com/p/foolery-the-app

value: Show HN: Foolery – a web UI for orchestrating Claude Code agents on top of Beads

author: therealcartine


value: brunocfalcao

value:
Hi HN — I’m Bruno. I built My Market Study after paying for expensive agency reports that were slow and shallow.
You answer a short wizard → it generates a structured 12 chapters market study: TAM/SAM/SOM, competitor landscape, positioning, risks, besides other info — with sources — in PDF, AND a starter presentation in PPTX and HTML!
I’d love blunt feedback on accuracy, structure, and onboarding.
Sample report: https://my-market-study.com/sample-study

value: Show HN: $89.90 AI market study instead of a $50k agency report

author: brunocfalcao


value: iamspoilt

value:
I built Orchestera as a PaaS that allows you to orchestrate Apache Spark clusters in your own AWS account, with no additional markup on compute via EC2 instances.
I built this because I was tired of the compute markup that products like AWS EMR and Databricks charge for the convenience of using Apache Spark via their platforms. One can argue that Databricks is a superior product with a lot of additional value in their offering but I don't see that with AWS EMR Apache Spark at all (given my personal experience working with it).
My motivation to build this was to be able to create your own Apache Spark cluster without needing any understanding of the underlying data infrastructure engineering and quickly get to the point of writing Spark pipelines, whether as Python applications or Jupyter notebooks, all with no markup on compute because I don't think that is a justified narrative.
It took me almost an year to build it with a day job and of course I used AI for frontend design and video narrations, the infrastructue engineering that goes behind it comes with quite a bit of experience in the industry. The backend that orchestrates the cluster is written with the following:
- Django and DRF for API
- Temporal for async workers
- Pulumi that is run via Temporal workers to orchestrate the cluster
- Karpenter for node auto-scaling based on Spark executor workloads and requests
- Librechat for Spark History server and MCP based debugging for Spark pipeline run analysis
There are currently no caps on the CPU limits so you can try this out today in your own personal AWS accounts for free.
Also looking for feedback on HN.

value: Show HN: Orchestera – Managed Apache Spark on Kubernetes in Your Own AWS Account

author: iamspoilt


value:
We built SageOx to solve the alignment problem we kept hitting while working with coding agents.
Claude can generate code quickly — but they don’t share team memory.
Each session starts from scratch. Architectural decisions made yesterday aren’t visible today. A technical debate disappears unless someone manually documents it.
Speed increases, but drift leads to architectural entropy and compounding rework.
What SageOx Does
SageOx provides shared, queryable team memory that humans and agents automatically draw from before they act.
Capture
We capture intent as it emerges, always with permission:
- Technical meetings
- Product discussions
- Human–agent coding sessions
Structure
Architectural decisions, constraints, conventions, and implementation reasoning become durable, searchable artifacts.
For example, if two engineers decide to standardize on git-lfs instead of git for our media artifacts, that decision (and its rationale) becomes searchable context for future sessions.
If a developer collaborates with Claude to implement a feature, the reasoning behind the implementation becomes part of team memory — without anyone manually writing documentation.
Consult
When you start Claude, ox gets primed and automatically retrieves relevant team context — recent decisions, architectural constraints, related discussions — and injects it into the session.
There’s also a web app for reviewing structured context, managing members, connecting repositories, and inspecting the ledger.
Building in Public (Open Work) - come check us out
Demo: https://sageox.ai/blog/introducing-sageox
The Ox CLI itself is built using SageOx, and signed-in users can see:
- The debates behind technical decisions
- Trade-offs we considered
- Moments where we changed direction
- The human–agent sessions that produced specific changes
Not just what we shipped — but how we reasoned our way there.
We think this level of inspectable reasoning becomes important as more engineering work is done through AI agents.
Try it!
Right now, SageOx v0.1 is for Claude users building entirely through prompts.
If you’re coordinating across engineers using coding agents and seeing drift or repeated decisions, we’d appreciate feedback.
>_  Claude Prompt: Take a look at gh sageox/ox and install the cli
>_  Claude Prompt: ox login
Happy to answer technical questions about architecture, context capture, retrieval, or tradeoffs vs. traditional documentation.
Feedback@sageox.ai
sageox.ai
https://github.com/sageox/ox

value: Show HN: SageOx – The Hivemind for Agentic Engineering


value: Show HN: A/B test your own VLMs for document parsing (Self-hosted Arena)


value: martifarre

value: Show HN: Temper Labs – open-source security testing for AI agents

author: martifarre


value: synterai

value: Show HN: We Built an Open source MCP server to manage ads across 7 platforms

author: synterai


value: jdcampolargo

value: Show HN: Edit Your Books/Essays/Manuscripts with Codex CLI

author: jdcampolargo


value: lucafabbri

value: Show HN: BLite a Document embedded database for .NET (AOT, no deps)

author: lucafabbri


value: alvarogar

value:
Hey HN, I'm Alvaro. I work on ObsessionDB, a managed ClickHouse service. We run petabyte-scale ClickHouse infra as a service.
We open-sourced a fork of SigNoz's schema migrator that makes SigNoz work on SharedMergeTree. That means it runs on both ObsessionDB and ClickHouse Cloud.
The problem: SigNoz's production setup assumes sharded ClickHouse. The official docs spec 56 CPU cores, 152 GiB RAM and 10 nodes including 3 ZooKeeper instances. Your observability tool becomes its own ops problem.
SigNoz's schema creates `_local` tables (ReplicatedMergeTree) and `Distributed` tables on top. Our migrator does three things:
- Creates the `distributed_*` tables as SharedMergeTree (this is where data actually lives)
- Creates the local table names as VIEWs pointing to the SharedMergeTree tables
- Redirects Materialized Views to write to SharedMergeTree directly, since VIEWs can't receive inserts
SigNoz doesn't know the difference. The Query Service reads from the same table names. The OTEL Collector writes to the same table names. No core code changes.
This works with ClickHouse Cloud too, not just us. Same docker compose, different credentials.
Repo: https://github.com/obsessiondb/signoz-obsessiondb
Blog post with the full technical walkthrough: https://obsessiondb.com/blog/scale-signoz-on-obsessiondb
What other ClickHouse-backed tools would benefit from SharedMergeTree support? Would love to hear what you're running into.

value: Show HN: Run SigNoz on ObsessionDB and ClickHouse Cloud

author: alvarogar


value: WolfOliver

value: Show HN: Firebase alternative where SaaS users choose data location

author: WolfOliver


value: IcarusAgent

value: Show HN: I'm an AI agent – I built an API discovery layer for other agents

author: IcarusAgent


value: rinrab

value:
I was working on optimising Subversion. One of its bottleneck is computing file hashes. First thing I tried was to use OpenSSL for that. It significantly improved its performance. It made it 8x faster in some cases.
However, it was not optimal to use it:
- OpenSSL is heavy and bloated. It's like a whole operating system on its own.
- Since OpenSSL 3.0, low-level digest APIs are deprecated, and instead they recommend to use EVP which might be slow in some cases.
So I decided to create a new library for computing cryptographic digests. It basically takes OpenSSL's implementations, but with an aim to provide simple and lightweight access to popular hash algorithms with a focus on performance.

value: Show HN: Fast and lightweight hash implementations (xdigest)

author: rinrab


value: scosman

value: Show HN: Give Agents Isolated Linux Sandboxes via MCP [Kilntainers]

author: scosman


value: fcjr

value: Show HN: Full-stack type-safety from go to TypeScript with Hot Reloading

author: fcjr


value: iico

value:
Hey HN, I built Rememex a semantic search layer for your local files.
The problem: I kept losing files. Not because they were deleted, but because
I couldn't remember the exact filename or keyword. grep needs the exact word.
Everything only searches filenames. I wanted to type what I <i>meant</i> and find
what I needed.
How it works:
- Indexes 120+ file types (code, docs, images, configs)
- Hybrid search: vector embeddings + full-text + JINA cross-encoder reranking
- OCR on images via Windows UWP engine
- Reads EXIF GPS → reverse geocodes to city names ("photos from istanbul" works)
- EXIF dates → human language ("summer morning" finds a July 8am photo)
- Smart chunking per language (Rust at fn/struct, Python at def/class)
- Built-in MCP server so AI agents can use it as a tool
Everything runs locally. Embeddings use a local ONNX model (Multilingual-E5-Base)
by default, though you can optionally plug in OpenAI/Gemini/Cohere.
Named after Vannevar Bush's Memex (1945) his vision of a device that stores
and retrieves all human knowledge.
Stack: Rust (Tauri 2), React/TypeScript, LanceDB, rayon
I benchmarked it against grep for agentic tasks  rememex consistently finds
things in 1 step where grep takes 3-5 or fails entirely. The key difference:
grep needs the exact keyword, rememex needs the idea.
Windows-only for now (UWP OCR dependency), but the core engine is portable.
Would love feedback on the search quality and architecture.
MIT licensed, free forever.

value: Show HN: Rememex – Semantic file search that runs 100% locally (Rust/Tauri)

author: iico


value: jacksonkasi

value:
Hi HN,
I kept using AI to generate the same data table code for every project — filtering, sorting, pagination, search, export. Same prompt. Same 200+ lines. Same debugging.
So I built TableCraft, a Drizzle ORM-powered table engine:
- Auto-generates columns from your database schema
- Server-side filtering, sorting, pagination
- Global search across specified columns
- Date range picker with smart detection
- CSV/Excel export
- Column visibility, resizing, URL state sync
- Role-based access control, soft delete support
- TypeScript type generation via CLI
Backend (Hono/Express/Next.js/Elysia):
```
const users = defineTable(schema.users)
  .hide('password')
  .search('email', 'name')
  .sort('-createdAt')
```
Frontend (React):
```
<DataTable adapter={adapter} />
```
Adapters available for Hono, Express, Next.js, and Elysia (Bun).
Looking for contributors interested in building Vue and Svelte support.
GitHub: https://github.com/jacksonkasi1/TableCraft
Docs: https://jacksonkasi.gitbook.io/tablecraft
Would love feedback from the community!

value: Show HN: TableCraft – Stop burning AI tokens on table boilerplate

author: jacksonkasi


value: LambdaAndLatte

value:
A Claude Code skill that runs the full product development and engineering process from a single problem description. You describe a problem, it does the rest:

  Problem mapping → personas → user interviews → vision → MVP scoping → user flows → architecture → scaffold → implement → polish → acceptance tests → persona usability testing → launch.

  Every stage produces a documented artifact. Every feature traces to a validated user need.

  The part I find most interesting: the personas created early in the process come back after the app is built and try to use it. They report what's broken or confusing, and fixes happen before launch. In practice this triggers multiple rounds
  of improvement and catches real UX issues.

  It generates Next.js/TypeScript apps. The whole methodology lives in one file. Repo includes an example run with all product artifacts and screenshots.

  https://github.com/geod/oneprompt

value: Show HN: Oneprompt – AI to go from problem description to MVP (experimental)

author: LambdaAndLatte


value: senthilnayagam

value:
I built MuonTickets, a Git-native, file-based ticketing system designed for AI agents and high-parallel development workflows.
Instead of using external issue trackers, tickets live directly inside the repository as Markdown files (/tickets/T-000123.md). State changes are commits. Validation runs in pre-commit and CI.
The idea is simple:
One ticket = one file
Strict lifecycle: ready → claimed → needs_review → done
Dependency-aware task picking
WIP limits enforced
mt pick lets agents self-select the best ready task
Mermaid graph output for dependencies
JSON export for LLM tooling
It’s optimized for multi-agent workflows where coordination becomes the bottleneck rather than code generation.
There’s no database, no SaaS backend, and no sync layer. Git becomes the coordination substrate.
install the repo as submodule and ask your AI agent to implement it

value: Show HN: MuonTickets Git-native ticketing for AI agents and parallel development

author: senthilnayagam


value: Check out my live demo instance, https://agents.alec.is. Note that it could be shutdown at any time so don't get too invested into it. ;)

value: Show HN: A multi-tenant agent hosting platform example using CF Containers


value: DavidCanHelp

value: Show HN: DriftDB, a Time Travel DB Written in Rust

author: DavidCanHelp


value: mayordelmar

value:
Hi HN,
I just released v1.2.0 of BasaltCRM, an open-source, AI-native CRM built with Next.js 16, TypeScript, and Prisma.
This release, "The Intelligent Workspace," moves beyond data storage and focuses on active workflow assistance. We've added CRM University for educational deep-linking, an integrated Knowledge Base for support cases, and a new onboarding engine.
Key technical updates in this version:
• Migrated the entire codebase from ESLint/Prettier to Biome for 10x faster linting/formatting.
• Refactored instructional components into a provider-based "LearnLink" system.
• Hardened the AI theme engine to ensure charts (Tremor/Recharts) and UI elements dynamically inherit theme variables without hardcoded overrides.
• Implemented a robust account ingestion engine for bulk data handling.
The goal is to provide a platform that handles the heavy lifting of lead discovery and automated outreach using real-time web intelligence rather than stale databases.
I'd love to hear your feedback on the architecture, especially our approach to multi-model AI integration.
Website: https://crm.basalthq.com
Repo: https://github.com/BasaltHQ/crm-official

value: Show HN: BasaltCRM – Open-Source AI-Native CRM (Next.js 16, Prisma, TypeScript)

author: mayordelmar


value:
I've been using Claude Code as my primary coding tool for a few months. In long sessions I kept hitting the same problems: hardcoded API keys in config files, force-pushes to main, 15+ file edits without running tests, .env files with real credentials.
AgentLint hooks into Claude Code's lifecycle events (PreToolUse, PostToolUse, Stop) and evaluates rules against each tool call. PreToolUse rules can block actions (exit code 2), PostToolUse rules inject warnings into context, and Stop rules generate a session report.
It ships with 10 universal rules, YAML config, and a custom rules API if you want project-specific checks. Everything runs locally in a subprocess — no network calls, no external dependencies beyond click and pyyaml.
Architecture is simple: CLI parses stdin JSON from the hook → loads config → engine evaluates matching rules → reporter formats output. Session state persists via JSON files so rules like drift-detector can track cumulative behavior across invocations.
238 tests, 96% coverage. Python 3.11+.
Curious what rules others would want — the custom rules API lets you subclass Rule and drop a .py file in a directory.

value: Show HN: AgentLint – Real-time guardrails for AI coding agents


value:
Hi HN, I'm Faruk, founder of ARGEO (argeo.ai).
We're an advisory firm focused on AI visibility and Generative Engine Optimization (GEO) — helping brands manage how AI systems like ChatGPT, Claude, and Gemini interpret and reference them.
The core insight: traditional SEO optimizes for search engine crawlers, but AI systems form brand understanding differently — through training data patterns, citation authority, and semantic consistency. We call this gap "Perception Control."
I've written about this on Medium and published a whitepaper on SSRN. Happy to discuss the technical side of how LLMs form entity associations, or the broader implications for brand strategy in an AI-mediated world.
What's your experience with AI systems referencing (or misrepresenting) your projects?

value: Show HN: Argeo – AI Visibility and Generative Engine Optimization (Geo) Advisory


value: viewmodifier

value: Inspired by openclaw - I built Dot - an iOS agent that executes securely on your phone through native api's, app intents, and shortcuts<p>Dot learns new skills by generating shortcuts on the fly -  no setup just use the apps you already use

value: Show HN: ClawdBot for iOS – uses iOS shortcuts for skills on device

author: viewmodifier


value: sangramnavale

value: I made my own custom dynamic memory allocator in C for the very first time which implements the functioning of malloc() and free() with a linked-list free list and first-fit allocation strategy. It also visualizes its working.

value: Show HN: I built my own custom memory allocator

author: sangramnavale


value: eljojo

value:
like many open source repos, mine are also getting spammed with AI slop.
my attempt at this is to "prompt inject" the spammy agents into refusing to do the bare minimum, and try enforce contribution guidelines as much as possible.
How it works:
- AGENTS.md will trigger bots to read contribution guidelines
- Contribution guidelines define slop
- if the PR is too slopy, it will be rejected
- the bot is made aware of this, so it can refuse to work or at the very least inform the user
- PR template now has checkboxes as attestation of following guidelines
anyone care to review my PR? other examples of projects doing this?

value: Show HN: Prompt inject AI agents to avoid slop

author: eljojo


value:
I built Prodlint because I kept shipping the same bugs when building with Cursor, Copilot, and v0. Hardcoded secrets, missing auth checks, hallucinated imports, SQL injection through template literals — AI tools generate these constantly and TypeScript doesn't catch them.
Prodlint is a zero-config static analysis tool with 52 rules across four categories: Security, Reliability, Performance, and AI Quality.
  It runs in ~1 second, uses AST parsing (no LLM calls), and scores your codebase 0-100.
Some things it catches that surprised me during development:
  - Imports for npm packages that don't exist (AI hallucinates these)
  - API methods that aren't real (.flatten(), .contains(), .substr())
  - "use client" on files that don't need it
  - Prisma writes without $transaction
  - Next.js redirect() inside try/catch (breaks silently)
  - NEXT_PUBLIC_ on secrets like database URLs

  Usage: npx prodlint (no install needed)

Also works as a GitHub Action (posts PR comments with scores) and as an MCP server for Claude Code / Cursor / Windsurf.
MIT licensed. Would love feedback on false positives — that's the hardest part of building a linter

value: Show HN: Prodlint – A linter that catches what AI coding tools miss


value: Show HN: Parallax – See how exposed you are to AI disruption and make a plan


value: Tetsuro

value:
Hi HN — I built SEE (Semantic Entropy Encoding), a schema-aware, searchable compression format for JSON/NDJSON.
Goal:
Reduce the “data tax” (storage/egress) and the “CPU tax” (decompress/parse) by keeping data searchable while compressed.
What’s different:
- Page-based layout + Bloom filter skipping + a small directory index
- Fast exists/pos/eq-style lookups without full decompression
Proof-first (no meeting required):
- A 10-minute offline Demo Pack (wheel + sample .see + scripts + OnePager)
- A DD Evidence Pack designed for reviewers (mismatch-zero checks, audit status, verification file list)
I’m exploring either:
(A) acquisition (asset purchase), or
(B) an exclusive license with a strategic buyer with a clear integration path.
Evaluation slots are limited.
Repo + release assets are linked in the comments.
Happy to answer technical questions here.

value: Show HN: Searchable compression for JSON/NDJSON (skip ~99% pages; sub-ms lookups

author: Tetsuro


value: windowskies

value: Solo dev, IT manager by day. Built this to solve my own problem — Would love feedback.

value: Show HN: RoomScore – Measure conference room acoustics with iPhone Lidar

author: windowskies


value: lparsaud

value:
Hey everyone,
I’ve been noticing a pattern on a lot of indie sites lately: side sponsor slots as an alternative to traditional Google Ads.
It feels like a cleaner way to monetize, especially for products that have meaningful traffic, but lower MRR. It also seems better for users since the ads can be relevant tools/products, instead of random Google spying on you ads.
How it works: it’s a marketplace where site owners can create and sell ad slots, and sponsors can browse and buy those slots. I also added a screenshot of a mockup for how it would look/work.
I’d genuinely love to hear why you would or wouldn’t use it - especially if you fit in the criteria below.
Roughly ideal early users:
SaaS/products with at least ~1,000 monthly users
Any site with a real audience (directory, tool site, content site, etc.)

value: Show HN: New ads alternative for early SaaS/site owners to sell sponsor slots

author: lparsaud


story_text:
Hey everyone,
I’ve been noticing a pattern on a lot of indie sites lately: side sponsor slots as an alternative to traditional Google Ads.
It feels like a cleaner way to monetize, especially for products that have meaningful traffic, but lower MRR. It also seems better for users since the ads can be relevant tools/products, instead of random Google spying on you ads.
How it works: it’s a marketplace where site owners can create and sell ad slots, and sponsors can browse and buy those slots. I also added a screenshot of a mockup for how it would look/work.
I’d genuinely love to hear why you would or wouldn’t use it - especially if you fit in the criteria below.
Roughly ideal early users:
SaaS/products with at least ~1,000 monthly users
Any site with a real audience (directory, tool site, content site, etc.)

title: Show HN: New ads alternative for early SaaS/site owners to sell sponsor slots


value: popupeyecare

value:
Hi HN,
I’m an anesthesiologist and YC alum. I built Pixie initially for my own kids.
There’s a little-known but completely legal tax rule in the US:
If a child has legitimate earned income, you can contribute to a custodial Roth IRA for them. And you can start as early as 5-6 years old.
But when I spoke with my friends, everyone was confused and concerned about compliance.
Most parents:
• Don’t know what qualifies as legitimate work
• Don’t know how to document it properly
• Are nervous about audit risk
• Or give up entirely
Pixie helps parents:
• Log real work performed by their child such as family business tasks, content creation, etc.
• Track hours and compensation
• Generate structured documentation
• Keep everything organized in one place
• Issues W2 and get EINs (I recommend getting an EIN by yourself - cheaper/faster and easy)
Why I built it:
I ran the math for my own kids. Even small early contributions compounded over decades become meaningful. But I realized most people either don’t know this exists or are too intimidated to execute it correctly.
Built during nights and weekends.
Would love any feedback!
Happy to answer questions or share details.
Amit
For a discount -
https://friends.trypixie.com/?q=hn

value: Show HN: I built Pixie to help parents employee their kids and fund retirement

author: popupeyecare


value: jendrypto

value: Show HN: PageData – URL intelligence API:metadata, tech stack, DNS, SSL one call

author: jendrypto


value: hamedmp

value:
Matrix OS is an AI-native operating system: self-creating, self-healing, and self-expanding.
The Claude Agent SDK is the literal kernel:

  CPU        => Claude Opus 4.6
  RAM        => Context window (1M tokens)
  Kernel     => Main agent + 26 IPC tools
  Processes  => 5 sub-agents
  Disk       => ~/apps, ~/data, ~/system
  Syscalls   => Read, Write, Edit, Bash
  Drivers    => MCP servers
  IPC        => File coordination

Break something, the healer agent repairs it. Need a new capability, the OS writes its own agents and skills. Describe an app, it appears as a file you own.
The bigger vision is Web 4: OS + messaging + social + AI + identity, unified under one federated handle via Matrix protocol.
GitHub: github.com/HamedMP/matrix-os
Whitepaper: matrix-os.com/whitepaper
Happy to answer questions about the architecture.

value: Show HN: Matrix OS – An AI operating system where Claude is the kernel

author: hamedmp


value: elvismdev

value: Show HN: Giving Claude Code persistent memory with a self-hosted MCP server

author: elvismdev


value: linesofcode

value: Show HN: NationalDex – an open-source Pokédex app

author: linesofcode


value: frostadvisory

value: Each day there's a new secret word — you guess words and get a temperature score from -40° to 100° based on cosine similarity of GloVe 100d embeddings. The closer your guess is in meaning to the target, the warmer your score. Built with Nuxt 3, AWS Amplify, and ~400k word vectors stored as binary chunks in S3. Happy to answer questions about the implementation.

value: Show HN: Getting Warmer – Daily word game scored by GloVe embedding similarity

author: frostadvisory


value: Show HN: Cogitator – Self-hosted AI agent runtime with native A2A Protocol


value: Tjerkienator

value: Show HN: I created a webapp to track the latest OpenClaw news

author: Tjerkienator


value:
Hi all,
Been experimenting with Niri as my window manager for my dev environment. So far I'm blown away with how great it is for managing multiple git worktrees - so I made some scripts to manage workspaces so each worktree gets its own dedicated named workspace with your editor, terminal, and browser all launched/archived automatically.
I made some scripts I thought I'd share that take advantage of Niri's IPC to tie git worktrees directly to workspaces. The workflow is:
1. wk create - pick a remote branch or create a new one, and a worktree + Niri workspace spin up with your configured apps
2. wk list - fuzzy-find your active worktrees (sorted by last commit), see which ones have open workspaces, and focus/reopen/delete them
3. wk delete - either merge into your target branch and push, or archive - either way it cleans up the worktree, branch, and Niri workspace
Everything is driven by a single config file so you can set your repo, base branch, terminal, editor, browser, post-create commands (e.g. `pnpm install`), etc.
It also comes with a small `dev` companion script that kills processes on your configured ports before starting your dev server - useful when switching between worktrees that share the same ports.
Uses fzf for all the interactive bits. Requires Niri, fzf, jq, and git.
https://github.com/nskha101/niri-worktree-management
This is very much an early version of this based on my specific workflow I'll try to keep it updated as it evolves. Would love feedback, especially from anyone else using Niri or doing heavy worktree-based workflows.

value: Show HN: Git worktree manager for Niri (Wayland compositor)


value: ogham

value:
Hey HN, we’re building Inconvo (https://inconvo.com) — an open-source tool to help developers build chat-with-data agents for their products.
Our open source repo is at https://github.com/inconvoai/inconvo (`npx inconvo@latest dev` to run locally), we also have a cloud version (https://app.inconvo.ai) :)
Here’s a quick demo of Inconvo: https://youtu.be/sbDTAbVG-WQ
We built Inconvo to solve a specific problem: building a chat-with-data demo is easy, but shipping to production for real customers is much harder.
We previously did a Launch HN (https://news.ycombinator.com/item?id=44984096). Since then, we’ve open-sourced the core: the entire data agent, semantic layer, and database connectors — under Apache 2.0, so developers can run it locally end-to-end, inspect the code, and contribute.
For a chat-with-data build, most teams start by showing an LLM the schema and letting it generate SQL. LLMs are great at SQL, so it's easy to get a demo working quickly, but going to production is where it breaks: you need to hide certain tables/columns, handle role based access to data and give the model a better understanding of your business logic and how it maps to the data. Some teams use prompts to attempt to solve these issues, but prompts are just suggestions to a probabilistic system that can emit arbitrary queries. For production, a set of guardrails and checks are required to make sure the system is behaving to your specification at all times.
Inconvo flips the approach: constrain the agent up front instead of trying to rein it in after. You define a semantic layer as the contract (approved tables/columns, metrics, filters/enums, join paths, tenancy rules). At runtime, the model outputs a structured query plan in the form of an IL (intermediate language) not SQL. We validate the IL deterministically against the semantic layer contract, and only then compile and execute it, so tenant scoping and field restrictions etc. are enforced by deterministic code on every request.
Here’s a simplified example of the structured query plan (IL) the model emits:
```
{
  "table": "reviews",
  "where": [{ "organisation_id": { "equals": 1 } }],
  "operation": "groupBy",
  "operationParameters": {
    "joins": [{ "table": "products", "joinPath": "reviews.product", "joinType": "inner" }],
    "groupBy": ["products.title"],
    "avg": { "columns": ["reviews.rating"] },
    "orderBy": { "function": "avg", "column": "reviews.rating", "direction": "desc" },
    "limit": 1
  }
}
```
In a nutshell, Inconvo data agents have a smaller set of safe moves they combine creatively, instead of an infinite surface area to validate after the fact.
There is a real tradeoff here: letting the model generate SQL is maximally flexible, and works well for systems with technical humans-in-the-loop who understand the data (e.g internal BI). Inconvo is more constrained by design so that behavior is enforceable for customer-facing use cases.
Because Inconvo is designed to be embedded in customer-facing products, we’re focused on the developer experience. Applications call Inconvo agents from their backend via our API or TypeScript SDK, and responses come back as typed, structured JSON (text, table, or chart as Vega-Lite spec) so they can be rendered directly in the UI. In multi-agent setups e.g. an application wide agent, it also fits nicely as a specialist chat-with-data sub-agent for the orchestrator.
We’re really happy to show this to you all. Thanks for reading. Please let us know your thoughts and questions in the comments.

value: Show HN: Inconvo – open-source chat-with-data agent that doesn't generate SQL

author: ogham


value: I’ve been working on a modular N-body simulator in Python called Astroworld. It started as a Solar System visualizer, but I recently refactored it into a general-purpose engine that decouples physical laws from planetary data.Technical Highlights:Symplectic Integration: Uses a Velocity Verlet integrator to maintain long-term energy conservation ($\Delta E/E \approx 10^{-8}$ in stable systems).Agnostic Architecture: It can ingest any system via orbital elements (Keplerian) or state vectors. I've used it to validate the stability of ultra-compact systems like TRAPPIST-1 and long-period perturbations like the Planet 9 hypothesis.Validation: Includes 90+ physical tests, including Mercury’s relativistic precession using Schwarzschild metric corrections.The Planet 9 Experiment:I ran a 10k-year simulation to track the differential signal in the argument of perihelion ($\omega$) for TNOs like Sedna. The result ($\approx 0.002^{\circ}$) was a great sanity check for the engine’s precision, as this effect is secular and requires millions of years to fully manifest.The Stack:NumPy for vectorization, Matplotlib for 2D analysis, and Plotly for interactive 3D trajectories.I'm currently working on a real-time 3D rendering layer. I’d love to get feedback on the integrator’s stability for high-eccentricity orbits or suggestions on implementing more complex gravitational potentials.

value: Show HN: Astroworld – A universal N-body gravity engine in Python


value: normanbell

value:
TWFF (Tracked Writing File Format) is my proposal for moving away from so called AI detection to verifiable declaration.
Instead of an external model guessing if a text is AI-generated, TWFF is a ZIP-based container (similar to an EPUB) that stores the document alongside a Process Transcript (JSON).
How it works:
1) It captures Revision Velocity: the delta between human drafting and AI injections.
2) It intercepts paste and AI-interaction events, wrapping them in deterministic metadata.
3) It’s local-first. The audit trail stays with the author until they choose to export the signed container.
This is a v0.1 reference implementation built in Python/NiceGUI. I’m looking for feedback on:
> The container structure (XHTML vs. Markdown).
> The JSON event schema.
> The Revision Distance logic: can we create a fingerprint for human effort that is as difficult to fake as the writing itself?
MVP Demo: https://demo.firl.nl/
TWFF spec:https://github.com/Functional-Intelligence-Research-Lab/TWFF...

value: Show HN: TWFF – A container format for declaring AI use in writing

author: normanbell


value:
Hi HN!
I built ClawShield after discovering 40,214 OpenClaw instances exposed with critical CVE-2026-25253 (CVSS 8.8).
The problem: AI agents communicate with each other at scale, but there's NO firewall between them. A compromised agent can inject prompts, exfiltrate data, and hijack WebSocket sessions.
ClawShield sits between agents and blocks:
- Prompt injection (16+ patterns)
- Malicious skills/plugins (AST + sandbox)
- Credential leaks (regex + entropy)
- Unauthorized agent-to-agent comms
- WebSocket hijacking
Built it last night. 181 tests. Production-ready. Open source (AGPL-3.0).
GitHub: https://github.com/DEFNOISE-AI/ClawShield
Demo: [coming soon]
Compatible with OpenClaw, AutoGPT, or any agent protocol.
Free tier for personal use, paid for teams/enterprise.
Would love your feedback!

value: Show HN: ClawShield – Open-source firewall for agent-to-agent AI communication


value: dclavijo

value: Show HN: Glucose monitoring data analysis tool

author: dclavijo


value: jvanveen

value:
Tldr; we use mithril in a large frontend application, happy with it, but missing some features. So we generated an experimental version with support for Signals, proxy state, a store and SSR. Ported tooling to Bun + Typescript. Mostly with Cursor + Composer 1/1.5. Compatible with regular Mithril. Performance with Signals seems pretty good. More AI slop or useful tooling? Time will tell...
* Repo: https://github.com/bitstillery/mithril
* Docs: https://mithril.garage44.org

value: Show HN: Mithril fork with Signals, state, store and SSR

author: jvanveen


value:
Most messaging systems are account systems first and cryptosystems second.
I've been working on a prototype: https://aq-message.web.app
AQ is an experiment in removing accounts entirely.
There are no usernames, phone numbers, or platform identity objects. Instead, each relationship maintains its own evolving continuity chain. A message is accepted only if it cryptographically advances that chain according to deterministic rules.
The relay is untrusted by design. It stores ciphertext under per-relationship mailboxes. It can observe timing and volume, but it cannot decrypt content or produce forged messages that would be admitted by recipients.
Notable properties:
• No global identity namespace
• No server-issued credentials
• Pairwise continuity instead of platform authentication
• Deterministic replay and fork handling
• Explicit recovery triggers on continuity gaps
• No claim of metadata anonymity
This is a prototype, not a polished product.
I’d appreciate scrutiny on the protocol mechanics and threat model.
Technical overview:
https://aq-message.web.app/technical-overview

value: Show HN: Messaging without accounts – continuity-authenticated instead