2026年3月2日 の Show HN

I built a voice agent from scratch that averages ~400ms end-to-end latency (phone stop → first syllable). That’s with full STT → LLM → TTS in the loop, clean barge-ins, and no precomputed responses.

What moved the needle:

Voice is a turn-taking problem, not a transcription problem. VAD alone fails; you need semantic end-of-turn detection.

The system reduces to one loop: speaking vs listening. The two transitions - cancel instantly on barge-in, respond instantly on end-of-turn - define the experience.

STT → LLM → TTS must stream. Sequential pipelines are dead on arrival for natural conversation.

TTFT dominates everything. In voice, the first token is the critical path. Groq’s ~80ms TTFT was the single biggest win.

Geography matters more than prompts. Colocate everything or you lose before you start.

Govbase tracks every bill, executive order, and federal regulation from official sources (Congress.gov, Federal Register, White House). An AI pipeline breaks each one down into plain-language summaries and shows who it impacts by demographic group.

It also ties each policy directly to bias-rated news coverage and politician social posts on X, Bluesky, and Truth Social. You can follow a single bill from the official text to how media frames it to what your representatives are saying about it.

Free on web, iOS, and Android.

https://govbase.com

I'd love feedback from the community, especially on the data pipeline or what policy areas/features you feel are missing.

Hey HN!

Over the past few months, I've been working on building Omni - a workplace search and chat platform that connects to apps like Google Drive/Gmail, Slack, Confluence, etc. Essentially an open-source alternative to Glean, fully self-hosted.

I noticed that some orgs find Glean to be expensive and not very extensible. I wanted to build something that small to mid-size teams could run themselves, so I decided to build it all on Postgres (ParadeDB to be precise) and pgvector. No Elasticsearch, or dedicated vector databases. I figured Postgres is more than capable of handling the level of scale required.

To bring up Omni on your own infra, all it takes is a single `docker compose up`, and some basic configuration to connect your apps and LLMs.

What it does:

- Syncs data from all connected apps and builds a BM25 index (ParadeDB) and HNSW vector index (pgvector) - Hybrid search combines results from both - Chat UI where the LLM has tools to search the index - not just basic RAG - Traditional search UI - Users bring their own LLM provider (OpenAI/Anthropic/Gemini) - Connectors for Google Workspace, Slack, Confluence, Jira, HubSpot, and more - Connector SDK to build your own custom connectors

Omni is in beta right now, and I'd love your feedback, especially on the following:

- Has anyone tried self-hosting workplace search and/or AI tools, and what was your experience like? - Any concerns with the Postgres-only approach at larger scales?

Happy to answer any questions!

The code: https://github.com/getomnico/omni (Apache 2.0 licensed)

A filter list for uBO that blurs all video and non-follower content from Instagram. Works on mobile with uBO Lite.

related: https://news.ycombinator.com/item?id=47016443

Hi HN,

I’ve been working on a browser-based tool for exploring and debugging Web Audio API graphs.

Web Audio Studio lets you write real Web Audio API code, run it, and see the runtime graph it produces as an interactive visual representation. Instead of mentally tracking connect() calls, you can inspect the actual structure of the graph, follow signal flow, and tweak parameters while the audio is playing.

It includes built-in visualizations for common node types — waveforms, filter responses, analyser time and frequency views, compressor transfer curves, waveshaper distortion, spatial positioning, delay timing, and more — so you can better understand what each part of the graph is doing. You can also insert an AnalyserNode between any two nodes to inspect the signal at that exact point in the chain.

There are around 20 templates (basic oscillator setups, FM/AM synthesis, convolution reverb, IIR filters, spatial audio, etc.), so you can start from working examples and modify them instead of building everything from scratch.

Everything runs fully locally in the browser — no signup, no backend.

The motivation came from working with non-trivial Web Audio graphs and finding it increasingly difficult to reason about structure and signal flow once things grow beyond simple examples. Most tutorials show small snippets, but real projects quickly become harder to inspect. I wanted something that stays close to the native Web Audio API while making the runtime graph visible and inspectable.

This is an early alpha and desktop-only for now.

I’d really appreciate feedback — especially from people who have used Web Audio API in production or built audio tools. You can leave comments here, or use the feedback button inside the app.

https://webaudio.studio

A little weekend project, made so I can pause/play/rewind directly on the piano, when learning a song by ear.

Hey HN,

I just released v4 of my gapless playback library that I first built in 2017 to handle our audio playback on https://relisten.net where we stream live recordings and gapless playback is paramount.

It's built from scratch backed by a rigid state machine (the sole dependency is xstate) and is already running in production over at Relisten.

The way it works is by preloading future tracks as raw buffers and scheduling them via the web audio API. It seamlessly transitions between HTML5 and web audio. We've used this technique for the last 9 years and it works fairly well. Occasionally it will blip slightly from HTML5->web audio, but there's not much to be done to avoid that (just when to do it - lotta nuance here). Once you get on web audio, everything should be clean.

Unfortunately the web audio support still lacks on mobile. But if you drive a largely desktop experience, this is fine. On mobile, most people use our native app.

You can view a demo of the project at https://gapless.saewitz.com - just click on "Scarlet Begonias", seek halfway in the track (as it won't preload until >15s) and wait for "decoding" on "Fire on the Mountain" to switch to "ready". Then tap "skip to -2s and hear the buttery smooth segue.

We needed a side project to give agentic coding a try, and created tensorspy.com together with Junie and ChatGPT 5.2.

Tensor Spy lets you quickly inspect the contents of numpy & pytorch tensors locally (your tensors are not uploaded to any servers).

This is useful to validate your deep learning data pipelines, to check which layers in your diverging model are actually going haywire, and just because it's kind of cool & a lot more convenient for one-off inspections than loading things up in python.

If you work with diffusion models, inspecting the latent space can be quite informative: you want some "noise" in there but it should probably be fairly smooth for your LDM (Latent Diffusion Model) to be able to target it well.

Also, if you haven't looked at your data, it's probably not what you think it is ;)

Basic stats are auto-computed, and any inf/nan values are both counted and rendered with contrasting colors, to help you quickly identify issue hotspots.

The site is free, and our broad intention is to keep it that way (we run a bunch of pro-bono little utility sites in addition to our commercial ones, they're all linked on the about page).

Would love to hear your thoughts, I'm sure there are some stats or utility features we missed, so please give it a spin and let us know!

---

Agentic coding is a brave new world. Three years ago, after the initial rush of ChatGPT's launch, I commented to some friends that "we're standing on the beach and the water just receded". The tsunami is really hitting now. As in: this project took about 2 weeks, and not only would we not have done it without agentic coding, it would have taken months using "traditional methods". With agentic coding, adding .pt/.pth support was basically a single request. And it just worked. Time to adapt yet again.

I've built airdefense.dev, which is able to simulate all kinds of ballistic missiles, one-way-attack drones like Shaheds, and most of the commonly deploy anti-air defence systems. All of this inside the browser. I've now added a scenario of the current attacks in the Middle East by Iran. It was quite the challenge to optimize it enough to not completely kill a common laptop, although it still runs best on a bit beefier systems.

Hi there, are you familiar with MBTI, DiSC, Big Five? Well I'm experimenting with a new kind of personality test, Archetype 360, and I'd love for you to try it for free and tell me what you think.

- 24 traits across 12 opposing pairs -- that's three times more dimensions than MBTI or DiSC, so you get a much more nuanced profile. - A unique narrative report generated with AI (Claude), written in natural language instead of generic type blurbs. - Your role, goals, and current challenges are blended into the analysis, so the report feels relevant to your real‑life context, not just abstract traits.

It's an "ephemeral app" so your report only lives in your browser, there's no login, and we don't store your data. Make sure you save the report as a PDF before you close the page.

What I'm looking for is honest feedback on your archetype and report:

- Did it feel accurate and "wow" or just meh? - Did you learn anything unexpected about yourself? - What did it miss or not go deep enough on?

I'll use your feedback to refine the prompts and the underlying model. Just comment here or use the feedback form in the app.

If there's enough interest, the next step is to combine Archetype 360 with a variation of Holland Codes / RIASEC (vocational interest areas) to create a full‑power professional orientation report.

What else would you love to see? Ideas welcome!

Best wishes, Daniel

Visualize and analyze complete Git commit histories as animated force-directed graphs. See how commit density, branch activity, and contributor participation evolve over time.

Live site: https://nshcr.github.io/git-commits-threadline/

This project helps you quickly inspect:

- repository growth over long time ranges

- branch structure and active thread distribution

- contribution patterns across maintainers and collaborators

Code: https://github.com/ehrlich-b/punchcards

Just for fun, I've only spent a few hours on it so far. What are everyone's punch card emulation needs?

I got tired of coding agents that feel like IDEs in disguise. Slow to start, full of chrome, opinionated about where you work. So I built one that doesn't get in the way.

It's called *mini-coder*. The command is `mc`. Tagline: Small. Fast. Gets out of your way.

Oh — and it mostly wrote itself (with some help from me).

---

## What it is

mini-coder is a terminal-native AI coding agent built on *Bun.js* — fast startup, native TypeScript, built-in SQLite, no ceremony. It routes to *Anthropic, OpenAI, Google, Ollama, and Zen* and auto-detects your provider from env vars. No config file to write. No account to create. No telemetry.

Session memory lives in local SQLite. Resume your last session with `mc -c`, or pick one with `mc -r <id>`. Your history stays on your machine.

---

## How it works

The LLM gets a tight set of tools: `glob`, `grep`, `read`, `create`, `replace`, `insert`, `shell`, and `subagent`. That last one is the interesting bit — mini-coder can spawn parallel sub-agents for independent subtasks, up to 3 levels deep. It delegates, waits, synthesizes. It works the way you do.

Inside the REPL, `!command` runs shell commands inline and `@file` references files with tab completion. Slash commands cover the essentials: `/model` to switch providers, `/plan` for read-only mode, `/ralph` for a fully autonomous loop, `/review`, `/undo`, `/new`, and `/help`.

16 ANSI colors only. It inherits your terminal theme. Always.

---

## The `.agents` folder

This is the part is to help with community configurations. mini-coder follows the `.agents` convention that's emerging across the AI coding tool ecosystem — the same one used by Claude Code, Opencode, and others. Write your config once, and it works everywhere. (It supports the .claude conventions as well out of the box!)

Here's what drops in there:

- *`.agents/commands/.md`* — a Markdown file becomes a slash command - *`.agents/agents/.md`* — a Markdown file becomes a custom agent, callable with `@agent-name` - *`.agents/skills/<name>/SKILL.md`* — reusable skills you inject with `@skill-name` - *`.agents/hooks/post-<tool>`* — scripts that auto-run after any tool call (e.g., auto-format after every file write) - *`AGENTS.md`* — project context injected into every system prompt

MCP is supported too — connect tools like Exa web search or the MMO Spacemolt all work. Wire them in via `/mcp`.

The philosophy here is community over invention. Follow existing conventions. Don't make people learn a new system.

---

## Get it

```sh bun add -g mini-coder # or npm install -g mini-coder ```

GitHub: [https://github.com/sacenox/mini-coder](https://github.com/sacenox/mini-coder)

---

The best tools disappear into your workflow. That's what I was going for. Here's what the early adopter had to say:

> "sean this is fucking sick" — vpr99

That's good enough for me. Give it a spin. I would love some feedback, contributions, or just a star on. Github!

OpenPaw is an open-source toolkit that turns Claude Code into a full personal assistant. One command (npx pawmode), 38 skills — email, calendar, Spotify, smart home, notes, and more. No daemon, no cloud, mo extra cost beyond your existing Claude subscription.

Hi HN,

I’ve been exploring whether pandas can be used as a computation description, rather than a runtime.

The idea is to write data logic in pandas / NumPy, then freeze that logic into a static compute graph and execute it in pure C++, without embedding Python.

This is not about reimplementing pandas or speeding up Python. It’s about situations where pandas-style logic is useful, but Python itself becomes a liability (latency, embedding, deployment).

The project is still small and experimental, but it already works for a restricted subset of pandas-like operations and runs deterministically in C++.

Repo: https://github.com/CVPaul/xpandas

I’d love feedback on whether this direction makes sense, and where people think it would break down.

I built two CLI tools to fix friction points with Claude Code:

claude-remote-approver – Sends permission prompts (Bash, Write, Edit) as push notifications to your phone via ntfy.sh. Tap Approve/Deny from anywhere. Falls back to terminal on timeout. Supports "Always Approve" for trusted tools.

claude-plan-reviewer – Hooks into Claude Code's plan mode and sends plans to a rival AI (OpenAI Codex CLI or Gemini CLI) for review. Feedback gets injected back, Claude revises, repeats for N rounds. Different models catch different blind spots.

Together: give Claude a task, walk away, rival AI reviews the plan automatically, phone buzzes when permissions are needed, come back to a completed task.

Both MIT licensed, zero dependencies, Node.js 18+, no telemetry.

- https://github.com/yuuichieguchi/claude-remote-approver

- https://github.com/yuuichieguchi/claude-plan-reviewer

Built this after dealing with overlapping cron jobs that quietly exhausted server resources. The cron daemon will happily spawn multiple copies of your script simultaneously until your server runs out of memory — with no warning. Paste your crontab (supports standard crontab -l format), and it shows a 24-hour timeline with overlap detection, Server Load Warnings, and human-readable job descriptions. No signup. No data leaves your browser. Everything runs client-side. Would love feedback from anyone who runs cron jobs in prod. https://configclarity.dev

Oclock is an interactive 3D WebGL globe that visualizes real-time daylight cycles. Built with Globe.gl and pre-processed spatial data pipeline.

Processing Pipeline

The data generation is handled by timezone_data_generator.py. This script performs the following:

1. Geometry Analysis: Uses shapely to find a representative point inside each country's boundary.

2. Timezone Mapping: Uses timezonefinder to look up the specific IANA timezone string for those coordinates.

3. Data Injection: Injects the timezone and coordinates back into the GeoJSON properties for use by the frontend.

Live Demo: https://azialle.github.io/Oclock/

About 6 years ago I wrote a blog post [0] with some ideas on how to help popular open source maintainers deal with all the noise on Github. Patted myself in the back and never did anything about it :)

There's recently been a lot more discussion around this due to AI, so I've built a simple tool called "Slop Meter" [1]. It gives maintainers a quick snapshot of the user's history in open source:

1) Do they just open issues and expect you to do everything, or will they put in the work to fix the problems and open a PR? What's the issues : PR ratio? 2) If they do contribute, what percentage of their PRs actually gets merged?

I feel like these are the two most important signals when triaging what to pay attention to in open source.

You can install this on any Github repo and it will automatically post a comment with the stats. We do not run this on maintainers or existing contributors.

You can also go on the web and look up a Github profile; it will take a minute or so to import depending on how much public data they have (maybe longer if this makes the front page...).

Example profile: https://slopmeter.kernellabs.ai/u/mitchellh

If you are an OSS maintainer, I'd love to hear any feedback.

[0] https://www.alessiofanelli.com/posts/how-can-we-help-oss-mai... [1] https://slopmeter.kernellabs.ai/

I started a solo software engineering lab earlier this year and wanted a professional foundation for my clients from day one.

I looked at platforms like HoneyBook, but they are expensive and didn't feel built for developers. I wanted a lightweight, self-hosted, and white-label solution that handled the essentials—file sharing, project tracking, and invoicing—without the SaaS tax. So I built Atrium.

It’s a clean interface that gives clients a single place to track progress and handle billing under my own branding, rather than me stitching together fragmented tools.

Core Features:

* White-Labeling: Fully customizable branding for the client-facing UI.

* Updates & Collaboration: Status updates and file sharing for clients, plus internal notes for team-only coordination.

* Asset Management: Support for S3, MinIO, R2, or local storage.

* Invoicing: Integrated PDF generation and billing.

I’m using this to run my lab’s client operations and would love technical feedback, contributions or feature requests from the community.

GitHub: https://github.com/Vibra-Labs/Atrium

I’ve spent the past 4 years building software for a knitting factory, including selecting and implementing an ERP. That experience was really painful.

Most manufacturing ERPs are hard to evaluate before signing an enterprise contract, poorly documented, and clearly not designed with serious API users in mind. Even when APIs exist, they’re often inconsistent or bolted on as an afterthought.

We built Augno to change that. The goal is to provide a Stripe-like experience for manufacturing ERP. We want it to be a usable out-of-the-box product and a well-designed, cohesive API that developers can actually build on.

We put a lot of effort into API design, documentation, and sandboxing. You can create a free account, explore the sandbox, and only move to production when you’re ready. There’s a free tier to make evaluation straightforward, without sales calls or contracts. Our focus is to let teams spend their engineering time on things that drive revenue - like custom quoting, order workflows, or integrations - instead of fighting their ERP.

We’re actively expanding the public API and rolling out additional endpoints over the next few months.

I made an account that you can check out. You can login at https://www.augno.com/auth/login username: hackernews password: aveGLZ9Nn4MA7cg!

Docs are here: https://docs.augno.com/

I’d really appreciate feedback from anyone who’s dealt with manufacturing systems or ERPs before!

Hi folks, zi2zi-JiT is the follow-up work to the original zi2zi project (https://github.com/kaonashi-tyc/zi2zi). Now with JiT (Just image Transformer) as the backbone, it can generate high-fidelity fonts in under one hour on a single GPU.

Fonts created with zi2zi-JiT:

- Zi-QuanHengDuLiang (权衡度量体): https://github.com/kaonashi-tyc/Zi-QuanHengDuLiang - Zi-XuanZongTi (玄宗体): https://github.com/kaonashi-tyc/Zi-XuanZongTi - Eva-Ming-Simplified (Eva明朝简体): https://github.com/kaonashi-tyc/Eva-Ming-Simplified

Pretrained weights and LoRA fine-tuning scripts included.

I'm sharing it here in the hope that this tool reaches more people and truly helps individual CJK font designers.

Hey HN,

I built Ledge because I kept seeing demos of AI agents with wallet keys in their .env files, and thought "this is going to end badly."

The core idea: put a policy layer between your agent and the wallet. Before any payment executes, it runs through 4 checks (technical validation, policy limits, context coherence, behavioral patterns). Agent can pay for APIs/data autonomously, but only within rules you set.

Example: your research agent has a $10 budget. It can pay $0.01 per API call for data feeds. But if it tries to send $50 to a random address, or hits the same endpoint 100 times in a minute, Ledge blocks or escalates it.

Built for x402 (pay-per-request protocol), but designed to be modular for other payment rails. Python SDK, supports KMS/Turnkey for production.

Main questions: - Is this solving a real problem or am I overthinking agent security? - What policies would you want that aren't here? - Anyone else building agents that need to pay for stuff?

GitHub: https://github.com/Devendra116/ledge

Would love feedback, especially from folks building autonomous agents or working with crypto payments.

I grew up with Tamagotchis and wanted to reimagine that experience for the generative AI era. The result is OpenTamago.

It is an experimental MVP where you can share AI character cards and chat using P2P connections. Because it bypasses external servers to communicate, it is designed to be private and safe.

I'm exploring the potential of P2P architecture in AI chat interfaces. Feedback is always welcome. Code is open sourced.

I built Sairo because searching for a file in the AWS S3 console takes ~14 seconds on a large bucket, and MinIO removed their web console from the free edition last year.

Sairo is a single Docker container that indexes your bucket into SQLite FTS5 and gives you full-text search in 2.4ms (p50) across 134K objects / 38 TB. No external databases, no microservices, no message queues.

What it does: - Instant search across all your objects (SQLite FTS5, 1,300 objects/sec indexing) - File preview for 45+ formats — Parquet schemas, CSV tables, PDFs, images, code - Password-protected share links with expiration - Version management — browse, restore, purge versions and delete markers - Storage analytics with growth trend charts - RBAC, 2FA, OAuth, LDAP, audit logging - CLI with 24 commands (brew install ashwathstephen/sairo/sairo)

Works with AWS S3, MinIO, Cloudflare R2, Wasabi, Backblaze B2, Ceph, and any S3-compatible endpoint.

  docker run -d -p 8000:8000 \
    -e S3_ENDPOINT=https://your-endpoint.com \
    -e S3_ACCESS_KEY=xxx -e S3_SECRET_KEY=xxx \
    stephenjr002/sairo

Site: https://sairo.dev GitHub: https://github.com/AshwathStephen/sairo

I'd love honest feedback — what's missing, what would make you actually switch to this?

I realize there may be some AI fatigue in the HN community, but I've genuinely seen a marked productivity boost using these tools - hence the desire to share them.

With the releases of my GhidrAssist (Ghidra) and BinAssist (Binary Ninja) LLM reverse engineering plugins over the past year, a number of people have reached out to ask "where's the IDA Pro plugin?"

Well - as of today, both IDAssist and IDAssistMCP are live on Github!

As you'd expect, they all share the same look and feel, workflow and feature set, including:

- AI-Powered Function Analysis: One-click function explanation with security assessment

- Interactive Chat: Context-aware chat with macros to inject functions, variables, and disassembly as well as builtin MCP client

- Smart Suggestions: AI-generated rename proposals for functions and variables

- ReAct Agent: Autonomous multi-step investigation using MCP tools

- Semantic Knowledge Graph: Visual graph of function relationships with similarity search

- RAG Document Search: Query your own docs (.txt, .md, .pdf) alongside binary analysis

- MCP Integration: Connect external tool servers for augmented LLM capabilities

- Multi-Provider Support: Anthropic, OpenAI, Gemini, X.ai, Ollama, LMStudio, LiteLLM, etc.

These aren't just jump-on-the-AI-bandwagon contributions. The GhidrAssist and BinAssist plugins represent over a year of steady development and refinement and are battle-tested in day-to-day use. I use them daily to score significant productivity gains in my RE day job as well as on personal projects.

If that sounds interesting, give them a try.

I still read/post in small communities over NNTP and always wanted usenet client that is modern and easy to use on macOS/iOS, so here it is.

95% agentic (not vibed) coded, just because I can and wanted to see if I'm able to drive AIs to build something that is usable :)

Coming soonish to AppStore, ofc.

I wanted to see if AI (mostly ChatGPT Pro and Gemini Pro 3.1) could figure out how to compress executable binaries better than existing generic tools without me actually knowing much about compression engineering or ELF internals.

The result is an experiment called fesh. It works strictly as a deterministic pre-processor pipeline wrapping LZMA (xz). The AI kept identifying "structural entropy boundaries" and instructed me to extract near-branches, normalize jump tables, rewrite .eh_frame DWARF pointers to absolute image bases, delta-encode ELF .rela structs with ZigZag mappings, and force column transpositions before compressing them in separated LZMA channels.

Surprisingly, it actually works. The CI strictly verifies that compression is perfectly reversible (bit-for-bit identity match) across 103 Alpine Linux x86_64 packages. According to the benchmarks, it consistently produces smaller payloads than xz -9e --x86 (XZ BCJ), ZSTD, and Brotli across the board—averaging around 6% smaller than maximum XZ BCJ limits.

I honestly have no idea how much of this is genuinely novel versus standard practices in extreme binary packing (like Crinkler/UPX).

Repo: https://github.com/mohsen1/fesh

Does this architecture have any actual merits for standard distribution formats, or is this just overfitting the LZMA dictionary to Alpine's compiler outputs? I'd love to hear from people who actually understand compression math.

Every agent framework gives you logs(each its own flavour of logs). Unstructured text. Maybe some spans if you're lucky. When your agent breaks something, you get to grep through a wall of output in some proprietery system.

Why can't i easily see what the agent did to produce the PR? why can't i restart a different agent from a state?

I got tired of this. agd is a content-addressed object store and causal DAG for recording agent behavior. It works like git (blobs, trees, refs, immutable objects identified by hash), but the object types are specific to LLM interactions: messages with typed content parts, tool definitions, and workspace snapshots that form a causal graph.

The core idea is stolen from git: the data model is the API. You interact with objects directly. Everything is immutable, everything has a hash.

An "action" in the DAG records: what messages the agent saw (observed state), what it produced (produced state), which tools were available, which model was used, and what caused it (parent actions).

Two states per action, both full snapshots, not deltas. You diff them to see what changed. What you get: - agd log --session s1 shows one conversation's full causal chain - agd show <action> --produced --expand shows the exact prompt and tool calls - agd diff between two actions compares messages and workspace files - agd rewind moves a session back to a previous point (old actions stay in the store) - agd replay reconstructs the exact input state and reruns an action

It integrates as middleware/plugin. Wraps your existing LLM calls, records before/after state, doesn't require rewriting your agent code. The session ref (like a git branch pointer) auto-advances on each action, so parent tracking is a single ref read.

Written in Zig. Most of the code was written with heavy AI assistance. The store is append-only loose files, like git's object directory. Write path targets low single-digit ms per action with batched fsync. Sessions can be bundled and published to a remote for sharing and viewing(working on a POC of this, have some core questions)

This is pre-alpha. The object model and write path work. Workspace capture, session sharing, and a Phoenix LiveView web viewer are functional.

Plenty is still missing: resume-from-any-point, proper diffing, the replay command. The on-disk format will probably change. I wouldn't depend on it for anything you care about yet.

What it does not do: orchestrate agents, make agents smarter, stream in real time, or replace your framework.

Looking for feedback, thoughts, contributors

Repo: https://github.com/frontman-ai/agd

Hey HN,

I wanted to share the new online playground for Salt (https://salt-lang.dev/playground/), a sovereign systems language designed for high-performance, distributed workloads where paying an "abstraction tax" is no longer acceptable.

We started building Salt to bridge the gap between the raw power of manual pointer arithmetic and the safety guarantees of modern high-level languages. The architecture relies on an MLIR-based backbone and a Z3-powered "formal shadow," and the design is rooted in three main pillars:

Fast Enough: The target is to stay within 20% of C's performance, while aiming to consistently outperform Rust.

Supremely Ergonomic: We didn't want to reinvent the wheel on syntax. Instead, we've shamelessly adopted the best features and syntax patterns from Julia, F#, Rust, C, Python, Haskell, Erlang, and Go.

Formally Verified: We've integrated Z3 directly into the compilation pipeline to mathematically prove safety without sacrificing developer velocity.

You can spin up the compiler directly in your browser and mess around with the syntax and verification engine without installing anything locally.

One more link to the project landing page: https://salt-lang.dev, and as always, thanks for reading.

The US Harmonized Tariff Schedule is public — USITC publishes it and even has a REST API. The problem is everything around it: the schema shifts without notice, field names are inconsistent across chapters, and there's no reliable way to know when something changed unless you run your own diff. I built TradeFacts.io to sit between USITC and your application. It serves the full HTS schedule (32,295 records) as a normalized JSON API with a stable schema, nightly updates, and change detection. What it adds on top of raw USITC data: • Versioned diffs — nightly change detection with a full history endpoint • Webhook push — Tier 2 notifies your endpoint when tariff codes change, so you don't poll • Schema stability — when USITC changes their format upstream, we absorb it; your integration keeps working • Safety checks — the nightly pipeline aborts if the incoming dataset drops below 30,000 records, so a partial USITC response never overwrites live data Auth is a single API key header. The target buyer is engineering teams at customs brokerage software companies and trade compliance SaaS vendors who are currently maintaining their own scraper or polling USITC directly. Pricing is $199/month (Tier 1, full dataset) and $399/month (Tier 2, adds webhooks and change history). 30-day free trial, no credit card. Docs: https://tradefacts.io/docs.html Happy to answer questions about the data pipeline, HTS structure, or why I made certain schema decisions.

I built Pulse to have a quick way to see if a service is down without opening a browser or checking Slack, mails, etc. IMO, it looks beautiful and doesn't get in the way when you don't need it. It also supports macOS notification and you can easily mute individual services if needed.

No tracking, no analytics, no account. MIT licensed. Config is stored locally.

Happy to hear feedback!

Hi HN,

I built AgentKeeper to solve a fundamental problem with AI agents: memory persistence.

Today, agents lose memory when:

• switching providers • restarting • crashing

AgentKeeper introduces a cognitive persistence layer that stores facts independently of any LLM provider and reconstructs context dynamically.

It works across:

• OpenAI • Anthropic • Gemini • Ollama

Memory survives provider switches and restarts.

GitHub: https://github.com/Thinklanceai/agentkeeper

I'm curious if others have faced the same problem and how you're handling memory persistence today.

For the past few weeks I was looking for a decent Gmail tool but everything good costs $25-30/month and forces you to leave your Gmail inbox entirely. I also didn't trust where my email data was going. So I built NeatMail. It lives inside your Gmail, no new inbox to learn. What it does: - Auto-labels incoming emails instantly (Payments, University, Work etc — custom or pre-made) - Drafts replies automatically for emails that need a response, right inside Gmail - Everything is customizable — fonts, signature, labels, privacy settings The model is built in-house. Open source so you can read every line. Your data never hits a third party server. It's in beta. Looking for honest feedback from people who live in their inbox. GitHub: https://github.com/Lakshay1509/NeatMail Try it: https://www.neatmail.app/

Sometimes you’re not at your computer. But your computer should still be with you. -- Just thought how Steve Jobs would introduce this :)

I built a tool that lets you send prompts, screenshots, or voice notes from Telegram and have your computer execute them locally through Antigravity. No cloud relay, no exposed ports, but Antigravity runs natively on your machine.

I've been using it daily for the past week as my "away from keyboard" workflow. It's completely written with Claude Code.

Try it here and I would love to know what you think. npm install -g remoat && remoat setup

Or: brew tap optimistengineer/remoat && brew install remoat

GitHub: https://github.com/optimistengineer/Remoat

MoodJot is a mood tracking app I built solo using Kotlin Multiplatform and Compose Multiplatform. It ships on both iOS and Android from a single codebase.

The main differentiator from existing mood trackers (Daylio, DailyBean, etc.) is a community feed where users can share moods and see how others are feeling.

Technical details: - Compose Multiplatform for shared UI (31 screens) - GitLive Firebase KMP SDK for Firestore, Auth, Storage - ChatGPT integration for AI mood pattern analysis via Ktor - expect/actual for StoreKit 2 (iOS) and Play Billing 7.0 (Android) - Home screen widgets: SwiftUI WidgetKit (iOS) and RemoteViews (Android) - Custom localization: 5 languages without platform string resources - Kamel for cross-platform image loading, multiplatform-settings for persistence

Other features: photo attachments, 10-point intensity scale, 80+ trackable activities, 25+ achievement badges, 14 emoji themes, goal tracking.

Live on App Store and Google Play since November 2025.

https://moodjot.app

Happy to discuss the KMP architecture or any design decisions.

Hey HN – I've been building in the agent payments space for a while and the biggest bottleneck I see isn't the protocol (x402 is great) — it's that most API providers have no idea how to actually integrate it. The docs exist, the middleware exists, but going from "I have a REST API" to "agents can discover and pay for my endpoints" still takes way more work than it should.

CrowPay fixes that. We integrate x402 payment headers into your existing API and configure USDC settlement on Base. You go from zero to agent-accessible in days, not months.

How it works:

You have an existing API (Express, Next.js, Cloudflare Workers, any HTTP server) We add x402 payment capability — your endpoints return 402 with payment instructions, agents pay in USDC and get access USDC settles to your wallet on Base. You get a dashboard with real-time analytics on agent payment volume.

That's it. You don't have to learn how x402 works under the hood, run blockchain infra, or change your API architecture. Why this matters now: There are over 72,000 AI agents paying for services via x402, with $600M+ in annualized volume across 960+ live endpoints. Stripe just added x402 support. CoinGecko is charging agents $0.01/request. This is going from experiment to real money fast — and most API providers are leaving it on the table because the integration is still too annoying.

The agent-side story: We also handle wallet creation and spending budgets for agent builders. If you're building agents that need to pay for things, Crow lets you create a wallet, fund it, set spending limits, and let your agent loose. The agent gets a budget, and you don't wake up to a surprise $10k bill.

What I'd love to hear:

What's keeping you from adding agent payments today? Is it technical complexity, uncertainty about demand, or something else? Agent builders: how do you handle spending controls? Is "agent gets a wallet with a budget" the right abstraction?

I built workz to solve a daily frustration: git worktree add drops you into a directory with no .env, no node_modules, and 2GB of disk wasted per branch if you reinstall.

workz does three things:

Auto-syncs — symlinks heavy dirs (node_modules, target, .venv) and copies .env files into every new worktree Fuzzy switching — skim-powered TUI to jump between worktrees, with shell cd integration like zoxide MCP server — workz mcp exposes 6 tools so Claude Code/Cursor can create and manage worktrees autonomously without human intervention Written in Rust, single binary, zero config for Node/Rust/Python/Go/Java projects.

cargo install workz or brew install rohansx/tap/workz

https://github.com/rohansx/workz

Hi HN,

I’m the founder of Fidelitas LLC. I built HushBrief because I was tired of two things:

The "I can’t help with that" refusal messages from sanitized LLMs when trying to brief sensitive legal or investigative material.

The systemic risk of pasting core IP, depositions, or leaked documents into surveillance-backed models that train on user inputs.

HushBrief is an AI briefing tool designed around a zero-retention architecture.

The Tech Stack:

Inference: We use Venice AI for zero-retention inference (llama-3.3-70b). No training on inputs, no logging, no retention at the provider level.

Stateless Auth: We don’t use traditional accounts or databases for user profiles. Subscriptions are handled via signed httpOnly cookies (HMAC-SHA256).

Zero-Knowledge Architecture: Documents are processed in memory and immediately discarded. There is no database entry that links your identity to the documents you've briefed.

Frontend/Backend: React 18 / Express 5 / PostgreSQL (Drizzle ORM) for subscription status only.

Why this exists:

Standard AI tools have become editorialized and "safe" to the point of being useless for professionals handling raw, controversial, or sensitive legal material. HushBrief includes an "Uncensored Mode" that doesn't soften or refuse to process the document you provide. You get the actual brief, not a sanitized version.

The Friction Problem:

I hate "Magic Links" and forced signups. To make this as accessible as possible for a technical audience, we implemented a $0.99 "Day Pass" via Stripe that sets a 24-hour signed session cookie. No email/password required to use the pro features.

We also have a strictly limited 11-unit Lifetime tier ($99) for early believers who want to support the development of resilient socio-technical infrastructure.

I'd love your feedback on the UX—specifically the 3-theme design system and the Privacy Dashboard (the avatar icon in the navbar) which maps out our data usage framework.

Live at: https://hushbrief.app

I'll be in the comments to answer questions about the architecture or our privacy posture.

Open-source Rust-based image processing pipeline that takes images and outputs structured JSON — 768-dim vector embeddings, semantic tags from a 68K-term vocabulary, EXIF metadata, content hashes, and thumbnails.

Everything runs locally via SigLIP + ONNX Runtime. Single binary, no Python, no Docker, no cloud dependency. Optional BYOK LLM descriptions (Ollama, Anthropic, OpenAI).

Hi HN, I’m a chemical engineer and I manage logistics at a refinery down in Texas. Whenever I try to explain downstream operations to people outside the industry (including my kids), I usually get blank stares. I wanted to build something that visualizes the concepts and chemistry of a plant without completely dumbing down the science, so I put together this 5-minute browser game.

I am not a software developer by trade, so I relied heavily on LLMs (Claude, Copilot, Gemini) to help write the code. What started as a simple concept turned into a 9,000-line single-page app built with vanilla HTML, CSS, and JavaScript. I used Matter.js for the 2D physics minigames.

A few technical takeaways from building this as a non-dev: * Managing the LLM workflow: Once the script.js file got large, letting the models output full file rewrites was a disaster (truncations, hallucinations, invisible curly-quote replacements that broke the JS). I started forcing them to act like patch files, strictly outputting "Find this exact block" and "Replace with this exact block." This was the only way to maintain improvements without breaking existing logic.

* Mapping physics to CSS: I wanted the minigames to visually sit inside circular CSS containers (border-radius: 50%). Matter.js doesn't natively care about your CSS. Getting the rigid body physics to respect a dynamic, responsive DOM boundary across different screen sizes required running an elliptical boundary equation (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry) > 1 on every single frame. Maybe this was overkill to try to handle the resizing between phones and PCs.

* Mobile browser events: Forcing iOS Safari to ignore its default behaviors (double-tap zoom, swipe-to-scroll) while still allowing the user to tap and drag Matter.js objects required a ridiculous amount of custom event listener management and CSS (touch-action: manipulation; user-select: none;). I also learned that these actions very easily kill the mouse scroll making it very frustrating for PC users. I am hoping I hit a good middle ground.

* State management: Since I didn't use React or any frameworks, I had to rely on a global state object. Because the game jumps between different phases/minigames, I ran into massive memory leaks from old setInterval loops and Matter.js bodies stacking up. I had to build strict teardown functions to wipe the slate clean on every map transition.

The game walks through electrostatic desalting, fractional distillation, hydrotreating, catalytic cracking, and gasoline blending (hitting specific Octane and RVP specs).

It’s completely free, runs client-side, and has zero ads or sign-ups. I'd appreciate any feedback on the mechanics, or let me know if you manage to break the physics engine. Happy to answer any questions about the chemical engineering side of things as well.

For some reason the URL box is not getting recognized, maybe someone can help me feel less dumb there too. www.fuelingcuriosity.com/game

Kelos is a Kubernetes framework for orchestrating autonomous AI coding agents (like Claude Code) in ephemeral pods.

The original goal was sandboxing — I didn't want to run agents with --dangerously-skip-permissions locally. But the real unlock turned out to be declarative workflows. You define agent tasks as Kubernetes CRDs, things like:

- Watch for "bug" issues → auto-draft a fix PR

- Auto-review incoming pull requests

- Auto-triage new issues with labels and priority

- Periodically scan the codebase → propose improvements

- Test the project as a new user → surface rough edges

Self-development pipeline: https://github.com/kelos-dev/kelos/tree/main/self-developmen...

I've been using Kelos to develop Kelos. When something breaks, I refine the YAML or add features to the controller. It's early and rough around the edges, but the core loop works.

Happy to answer questions about the design or what's broken.

Sharing a little hobby project of mine, that i've been working on for the last few months.

The motivation is the midlife crisis (and an amazing video explaining it linked in the project) and trying to wrap my thoughts about life in general.

With this project I tried to build a model about how one's life unfolds and what are the powers we have to influence the outcome.

Hi HN, I’m Pranav (founder). I design hardware and kept seeing a weird split: Engineers don’t trust AI to design full PCBs (hidden assumptions, stackups, manufacturing constraints, EMI/return paths, and the cost of being even slightly wrong - why tools like Flux still aren’t widely trusted for full designs). But customers keep asking ChatGPT to “review” boards. They paste screenshots/Gerbers and expect a real sign-off. It often sounds right, but it can hallucinate or miss what actually causes respins. Lesson building this: the hard part isn’t more AI, it’s deterministic, reproducible detection with explicit assumptions, with AI only to explain findings and suggest fixes. Would love critique: what’s worth catching pre-fab, what’s too noisy, and what would make you trust this as a release gate.

Ragtoolina is an MCP server that pre-indexes your codebase and provides targeted context to AI coding agents instead of letting them scan files one by one.

I benchmarked it on Cal.com (~300K LOC, 40K GitHub stars):

- 63% token reduction across 5 diverse query types - 43% fewer tool calls - Cost: $3.01 vs $7.81 per 5-query session

The benchmark covers different complexity levels — from simple call-chain tracing to architectural understanding queries. RAG overhead doesn't pay off on trivial lookups (one query was actually worse with Ragtoolina), but on complex multi-file tasks the savings are substantial (up to 79% token reduction).

Quality evaluation was done via blind AI-judge scoring (the judge didn't know which answer came from which system) across correctness, completeness, specificity, and conciseness. Ragtoolina matched or exceeded baseline quality on 4 out of 5 tasks.

Works with any MCP-compatible client: Claude Code, Cursor, Windsurf, Claude Desktop.

Free tier available, would appreciate any feedback.

I kept running into the same annoying friction with Claude Desktop and Cursor: I’d snip a Python traceback, the AI would tell me to "run pip install pandas," and then I’d sit there and type it out myself. If the AI clearly knows the fix, why am I doing the typing?

So I built OmniGlass.

The UX is simple: You draw a box on your screen, local OCR extracts the text, and an LLM classifies what you're looking at. But instead of generating a chat response, it gives you an action menu.

The core difference from Claude Desktop isn't the AI—it’s what happens after the AI thinks. Claude reads your screen and writes you a paragraph. OmniGlass reads your screen and runs the command.

What it does today:

Snip a traceback → Generates the fix command, you confirm, it runs.

Snip a data table → Opens a native save dialog and spits out a clean CSV.

Snip a Slack bug report → Drafts a GitHub issue with all the context filled in.

Menu bar input → Type plain English, and it triggers the appropriate command.

The security elephant in the room (Why I built this): Nobody is really talking about the security risks of MCP plugins yet. Claude Desktop runs them with your full user permissions. A rogue plugin—or a clever prompt injection—can just read your SSH keys, scrape your .env files, and ship them off.

To fix this, OmniGlass sandboxes every plugin at the macOS kernel level using sandbox-exec. Your /Users/ directory is completely walled off. Environment variables are aggressively filtered. Shell commands strictly require your manual confirmation before executing. I wanted to be able to run community plugins without sweating about what they can access.

The Stack:

Frontend/Backend: Tauri (Rust + TypeScript)

Vision: Apple Vision OCR (local)

Plugin System: MCP over stdio

Models: Works with Claude Haiku, Gemini Flash, or fully local via llama.cpp using Qwen-2.5 (takes ~6s end-to-end, nothing leaves your machine).

Current Status: I just shipped our second working plugin (a Slack Webhook) to run alongside the GitHub Issues plugin. It's two real-world plugins proving the architecture actually works, not just a boilerplate template and a promise. Both are under 250 lines of code.

Where I'd love your help:

Break the sandbox. Seriously. If you can figure out a way to read ~/.ssh/id_rsa from a plugin, that is a critical bug and I want to know about it.

Build a plugin. There are 8 open issues in the repo right now with full MCP schemas, manifests, and implementation hints. Most take less than 100 lines.

Port to Windows/Linux. The Windows build compiles in CI but hasn't been tested on real metal. Linux needs Tesseract + Bubblewrap to replace the Apple OCR and sandbox.

Requires macOS 12+ right now. Fully open source (MIT).

Would love to hear your thoughts or answer any questions about the sandboxing setup!

kindof like sublime merge, but for JJ VCS, works for remote repositories over ssh.

Author here. ClawShield is a security proxy that sits in front of OpenClaw (open-source AI gateway) and scans all inbound/outbound messages.

The core is an HTTP/WebSocket reverse proxy in Go (~6k lines) with four scanners:

1. Prompt injection detection - three tiers: regex heuristics (role overrides, instruction injection, delimiter attacks, encoding attacks), structural analysis (base64-decoded instruction blocks, imperative verb density scoring), and canary token leak detection.

2. Secrets/PII scanning - regex argument filters applied to decoded JSON values (defeats unicode escape bypasses like \u0070assword).

3. Vulnerability scanning - SQLi (UNION, tautologies, blind with SLEEP/BENCHMARK), SSRF (private IPs, cloud metadata at 169.254.169.254, decimal/hex IP encoding, dangerous schemes like gopher://), path traversal (double URL-encoding, null bytes), command injection (shell metacharacters, backtick execution), XSS.

4. Malware detection - magic bytes for PE/ELF/Mach-O, YARA-like signature rules for reverse shells and C2 frameworks, archive bomb detection via compression ratio, Shannon entropy analysis.

Policy engine is deny-by-default YAML. You define tool allowlists, denylists, per-tool argument filters, domain allowlists, and per-agent/per-channel restrictions. Every decision is logged to SQLite.

Optional extras: iptables egress firewall (Go, generates validated rules from YAML) and eBPF kernel monitor (Python/BCC - traces execve, tcp_v4_connect, openat2, setuid for fork bomb/privesc/port scan detection).

Docker quickstart is 3 commands. Ten cross-compiled binaries on the release (proxy + setup wizard for linux/mac/windows, amd64/arm64).

We run this in production at clawshield.sleuthco.ai.

I built this because I was contributing security patches to OpenClaw and the netfilter suite and kept seeing the same gap: the AI ecosystem has sophisticated multi-agent routing but no standardized way to inspect and control what flows through it.

Happy to answer questions about the scanner architecture, policy engine, or threat model.

I was on a flight with airplane mode on. When I landed, my AI had built two product landing pages, set up Stripe, written 5 blog posts, and sent me a Telegram summary of everything it did.

No instructions from me mid-flight. It just ran.

Here's how I set it up:

Most people use LLMs like a stateless calculator -- you ask, it answers, session ends, it forgets you exist. That's not leverage, that's just autocomplete.

What I wanted was an AI agent with: - Persistent memory (knows my projects, preferences, goals across sessions) - A job description (knows what to work on without being told) - Scheduled autonomous tasks (cron jobs that run while I sleep) - Tool access (browser, file system, email, APIs) - A communication channel (Telegram alerts when something happens)

I used OpenClaw (self-hosted, runs on a Mac mini) with Claude as the underlying model. Total cost: ~$20/month in API calls.

The key insight: the difference between a useful AI and a useless one isn't the model -- it's the scaffolding. Memory files, a job description, tool access, and a persistent process change everything.

I documented the exact setup -- the file structure, prompts, job description template, and week-by-week implementation plan -- in a guide for people who want to replicate it.

Happy to answer questions about the technical setup, the OpenClaw config, or the memory/identity system.

I built Steward because most AI assistants still have to be summoned.

The idea here is different: Steward runs in the background, watches signals from tools like GitHub, email, calendar, chat, and screen context, and tries to move low-risk work forward before the user explicitly asks.

The core mechanism is a policy gate between perception and execution. Low-risk and reversible actions can be handled automatically with an audit trail. Higher-risk or irreversible actions must be escalated for explicit approval. Instead of constant notifications, the system is designed to brief the user periodically on what was done, what is pending, and what actually needs judgment.

Right now it is an early local-first prototype. It runs with a simple `make start`, opens a local dashboard, and uses an OpenAI-compatible API key.

I’d love feedback on a few things:

* whether “policy-gated autonomy” is the right abstraction for this kind of agent * where the boundary should be between silent automation and interruption * how people would structure connectors and context aggregation for a system like this

I built greens because most of my day-job work is in private org repos, so my public GitHub graph looked inactive.

The tool runs locally, scans repos you choose in read-only mode, extracts commit timestamps for your author email, and creates empty commits with those timestamps in a public mirror repo. No source code, diffs, or filenames are copied.

If `gh` is configured, it can also mirror PR/review/issue activity. It's a bash CLI, installable via Homebrew (`brew install yuvrajangadsingh/greens/greens`).

I know some people view this as graph-gaming, fair point. My intent is not to imply public OSS output, only to make private work volume visible. Also worth noting: check your company policy before using it.

Feedback welcome, especially on edge cases or failure modes.

For the past few months, I've been building OxyJen, an open-source framework for building reliable, multi-step AI pipelines in Java. In most Java LLM projects, everything is still just strings. You build a prompt, make a call, and then parse your regex and wait if it works on the "almost-JSON" that comes back. It's brittle, untestable, and feels like the opposite of Java's "contract-first" philosophy.

OxyJen's approach is different. It's a graph-based orchestration framework(currently sequential) where LLMs are treated as native, reliable nodes in a pipeline, not as magical helper utilities. The core idea is to bring deterministic reliability to probabilistic AI calls. Everything is a node in a graph based system, LLMNode, LLMChain, LLM api is used to build a simple LLM node for the graph with retry/fallback, jitter/backoff, timeout enforcements(currently supports OpenAI).

PromptTemplate, Variable(required/optional) and PromptRegistry is used to build and store reusable prompts which saves you from re writing prompts.

JSONSchema and SchemaGenerator is used to build schema from POJOs/Records which will provide Json enforcements on outputs of these LLMs. SchemaNode<T> wraps SchemaEnforcer and validator to map LLM output directly to the classes. Enforcer also makes sure your output is correct and takes maximum retries.

Currently working on the Tool API to help users build their custom tools in Oxyjen. I'm a solo builder right now and the project is in its very early stage so I would really appreciate any feedback and contributions(even a small improvement in docs would be valuable).

OxyJen: https://github.com/11divyansh/OxyJen

I save 10-20 web articles a day for policy research. The workflow was: Ctrl+P, fix the garbage output, upload to Drive, rename the file. Repeat. 30+ minutes of busywork daily.

So I built Pooch PDF — a Chrome extension that extracts the article content, strips the clutter, and saves a clean PDF to Google Drive in one click. Searchable metadata, structured filenames, accessible on any device.

Three modes: - Quick PDF: faithful page capture - Clean PDF: reader-mode extraction (strips ads, navbars, cookie banners, sidebars) - Save to Drive: either mode → PDF → Google Drive with smart filename and AI-generated abstract

Everything runs client-side. No article content leaves the browser. Google Drive scope is drive.file (narrowest — can only see files the extension created).

Free tier: unlimited local PDFs, 60 Drive saves per 60-day cycle. Pro: $3/60 days.

https://poochpdf.com

CWS: https://chromewebstore.google.com/detail/pooch-pdf/hiikmbddi...

Happy to answer questions about the architecture, MV3 pain points, or Chrome Web Store review process.

I built Axiom after repeatedly running into the same problem with my own handwritten STEM notes.

On paper, everything looks clean — equations aligned, steps grouped properly, tables laid out clearly. But the moment I scanned those pages and ran them through OCR (including LLM-based tools), the structure would fall apart. The characters were mostly correct, but the layout — which is what actually makes math readable — was gone.

Aligned equations would lose alignment. Multi-step derivations would collapse into a single paragraph. Numbered problems would merge together. Tables would turn into plain text. Technically it was “extracted,” but practically it was unusable without manually fixing everything in LaTeX.

That gap is what Axiom tries to solve.

Instead of focusing purely on transcription accuracy, I focused on structural preservation. The current pipeline looks roughly like this:

1. OCR from image or PDF.

2. A structural prompt tuned specifically for math alignment, derivation grouping, numbered block preservation, and table detection.

3. A post-processing layer that normalizes LaTeX/Markdown output, merges math blocks, protects numbering tokens, and stabilizes table columns.

4. Export as compile-ready LaTeX, Markdown, or searchable PDF.

The hardest part wasn’t getting the characters right. It was preventing structural drift — especially with aligned equations and multi-line derivations. I added alignment pattern detection, atomic pagination for LaTeX environments, and normalization passes to keep math blocks intact across pages.

The goal isn’t “AI transcription.” It’s making handwritten STEM notes survive digitization without losing their mathematical structure.

It runs entirely in the browser:

https://www.useaxiomnotes.com

I kept SSHing into machines to do what my agent could already do locally — check logs, grep for errors, edit configs. So I built Claw.

It's an MCP server that deploys a small Go binary over SSH and gives your agent the same tools it already knows (bash, read, write, edit, grep, glob) on any remote machine. Works with Claude Code, Cursor, or any MCP client.

No ports to open. No daemons. No root required.

I built this to solve a problem that kept annoying me: every time I start a new AI coding session, the agent has zero memory of what happened before. Decisions, discoveries, bug fixes - all gone. oc-mnemoria is an OpenCode plugin that gives all agents a shared persistent memory store - a "hive mind." The plan agent records a decision, the build agent sees it. The review agent flags a bug pattern, and next session the build agent knows about it. The storage engine is mnemoria, a Rust crate I also wrote. Some details on the architecture: - Append-only binary log with CRC32 checksum chains for integrity - Hybrid search: Tantivy BM25 + simsimd SIMD cosine similarity - ~95us search latency, ~9,900 writes/sec on commodity hardware - Single file format, git-friendly - rkyv zero-copy deserialization (no parsing overhead) The plugin side (TypeScript) handles: - Automatic intent capture from chat messages - System prompt injection with relevant memories at session start - Per-agent tagging so you know which agent recorded what - Selective forgetting and compaction for memory maintenance Everything runs 100% locally. No data leaves your machine. The memory store is a single binary file you can commit to git, back up, or delete to reset. I built this because I use OpenCode daily and got tired of re-explaining the same context every session. Happy to answer questions about the Rust internals, the plugin architecture, or the append-only storage design. GitHub: https://github.com/one-bit/oc-mnemoria Rust engine: https://github.com/one-bit/mnemoria npm: https://www.npmjs.com/package/oc-mnemoria crates.io: https://crates.io/crates/mnemoria

I discovered RDAP while working on a hobby project where I needed to check if IP addresses were residential or not. RDAP was giving me more data than WHOIS, and it returns JSON instead of plain text. WHOIS is going away anyway. ICANN now requires RDAP for all gTLDs, and many registries are returning less data over port 43 or dropping it entirely. But RDAP is not easy to work with directly.

There is no single server. You have to check the IANA bootstrap registry to find which server handles each TLD, and some ccTLDs have working RDAP servers that are not even listed there. For .com and .net, the registry only has basic data. You need a second request to the registrar server to get contacts and abuse info. Then there is vcardArray, a deeply nested array-of-arrays format for contact data. And every server has its own rate limits.

I built an API that does all of that and gives you clean JSON back. One endpoint, same schema for every TLD. Here is what you get for google.com with ?follow=true (follows the registrar link automatically):

  {
    "domain": "google.com",
    "registrar": { "name": "MarkMonitor Inc.", "iana_id": "292" },
    "dates": { "registered": "1997-09-15T04:00:00Z", "expires": "2028-09-14T04:00:00Z" },
    "nameservers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"],
    "entities": { "registrant": { "organization": "Google LLC", "country_code": "US" } }
  }

You also get status codes, DNSSEC, abuse contacts, etc. There is a free lookup tool on the homepage to try it, no signup needed.

Supplemental servers. The IANA bootstrap only covers ~1,200 TLDs. I keep a list of 30 extra RDAP servers (for TLDs like .io, .de, .me, .us) that work but are not registered with IANA. Synced daily.

Registrar follow-through. For thin registries like .com, the registry only has dates and nameservers. The registrar has the rest on a different server. The API follows that link and merges both.

SDKs. Open source clients for Python, Node.js, PHP, Go and Java.

Responses are cached for 24 hours to reduce load on upstream RDAP servers.

This is my first SaaS, just launched. Would love honest feedback.

The API starts at $9/mo with a 7-day free trial.

V6 is the network-native evolution of the Qeltrix encrypted archiving system. It turns any data stream into a live, seekable, encrypted V6 container — without needing the entire file first.

Ultra-fast desktop & CLI app that finds your SEO & AEO issues and allows you to extract your content as Markdown

Aigent aims at being the best AI assistant, and to get there I believe that it needs to learn on the job. It's geared towards self reflection and takes user feedback seriously. It already has a ton of capabilities, like async tasks, granular permissions, operate the browser through a chrome plugin, themes, a rich context explorer, STT and TTS (including a short form), command and file picker.

I just wanted to show you because I'm very happy with the results so far <3

Each level is a JS function turned into a dungeon. if/else = forking paths, loops = corridors, try/catch = parallel chambers.

You forge test inputs as weapons, drag them into parameter slots, and run. Your hero walks the code path. Gems = covered statements. 100% = level complete.

Six levels, from simple branches to async functions with stubs.

Play: https://arvindrajnaidu.github.io/dungeon-coverage/ Source: https://github.com/arvindrajnaidu/dungeon-coverage

Built with PIXI.js, Istanbul for coverage, and [maineffectjs](https://github.com/arvindrajnaidu/maineffect) for isolated function execution.

I got tired of juggling 20+ tabs for basic utilities (JSON formatting, PDF merging, regex testing, image resizing, fake document generators, etc.), so I built a single, fully client-side hub with over 200 tools that run entirely in the browser. Key points:

Everything processes locally—no server uploads, no data leaves your device, no sign-ups, no ads, no tracking. Works offline after the initial load (progressive web app vibes). Categories include: Developer Tools (JSON/YAML/CSV/Regex/Base64/Epoch/etc.), PDF Tools (merge/split/compress/convert/extract), Image Tools (resize/compress/watermark remover/background remover/OCR), Encoding & Security, SEO & Network utilities, AI-assisted tools (e.g., ATS resume checker/roaster), Finance calculators (GST/salary/tax), Document & Fake Generators (resumes/invoices/fake chats/tickets/etc.), and more niche ones.

Built with plain HTML/JS/Canvas/WebAssembly where needed—lightweight, fast, mobile-friendly. Live here: https://tools.geeksprep.com/ Why share now:

Started as a personal productivity fix for devs/designers/job seekers in India (Bengaluru-based side project). Grew to 200+ tools via user requests and iterative additions. Privacy angle is core: In a world of upload-heavy "free" tools, this keeps your data yours.

Would love honest feedback from HN:

Which tools are actually useful (or broken)? Missing must-haves in dev/productivity space? Performance/edge cases on large files or specific browsers? Suggestions for better UX or new categories?

It's open for iteration—happy to add/fix based on real input. Thanks for checking it out! (Part of the broader GeeksPrep career prep platform, but this tools subdomain is 100% free/independent.)

Started as a personal research tool — I was buried in notes and needed something that could connect sources without hallucinating. Instead of feeding it content, I built a system-prompt structure using curated knowledge graphs that shape the model's prior. It surfaces things I'd never heard of without just pulling from generic top-10 lists.

Over 14 months it grew into something I'd call a DIY OS. Key parts:

- A recursive learning system that tracks tool usage and re-ranks tools based on your habits - An intent coordinator that abstracts the interaction layer so you can plug in game controllers, MIDI, gestures, or voice without hard-wiring each one - A built-in app SDK — the system generates its own apps based on usage patterns (the calendar and study timer were made by Prvctice itself)

It's free and open source. I also wrote a longer piece about the 14-month journey here: https://prvctice.com

I wanted to explore Valkey's vector search capabilities for AI workloads and had been looking for an excuse to build something with Bun. This weekend I combined both into a memory layer for Claude Code.

https://github.com/BetterDB-inc/memory

The problem: Claude Code has CLAUDE.md and auto memory, but it's flat text with no semantic retrieval. You end up repeating context, especially around things not to do.

BetterDB Memory hooks into Claude Code's lifecycle (SessionStart, PostToolUse, PreToolUse, Stop), summarizes each session, generates embeddings, and stores everything in Valkey using FT.SEARCH with HNSW. Next session, relevant memories surface automatically via vector similarity search.

The interesting technical bit is that Valkey handles all of it - vector search, hash storage for structured memory data, sorted sets for knowledge indexing, lists for compression queues. No separate vector database.

There's also an aging pipeline that applies exponential decay to old memories based on recency, clusters similar ones via cosine similarity, and merges them to keep the memory store from growing unbounded.

Self-hostable with Ollama for embeddings and summarization, or plug in any LLM provider. Runs on Bun, ships as compiled binaries. MIT licensed.

Hey yall,

I wanted to share *smart-commit-rs*, a fast, lightweight cross-platform TUI I built to facilitate managing git commits, including generating messages via LLMs.

Here are some of the main features:

* *Convention following:* The tool by default will generate commit messaged according to the Conventional Commit standard, and optionally according to Gitmoji as well. * *Extensive LLM Provider Support:* Built-in integration for Groq (default), OpenAI, Anthropic, Gemini, Grok, DeepSeek, OpenRouter, Mistral, Together, Fireworks, and Perplexity. * *Customer LLM Support:* You can easily point it to a custom provider like a local Ollama instance using OpenAI-compatible endpoints. * *LLM Presets:* You can save various provider presets, being able to freely switch between them. If your primary API throws an HTTP error, you can also configure a fallback rank so the tool automatically retries using the alternate LLM presets you've configured. * *Diff Exclusion Globs:* You can exclude minified assets, `.lock` files, PDFs, etc., from the LLM analysis to save tokens, while still officially committing them. *Advanced Git Tooling:* Message generation doesn't work just with commits. You can use `cgen alter <hash>` to rewrite a specific commit's message, `cgen undo` for a safe soft reset with Conventional Commit-compliant revert messages, or `cgen --tag` to automatically compute and create the next semantic version tag. * *Commit Tracking:* It maintains a per-repository cache of managed commits, browsable via `cgen history` with native `git show` integration.

*A quick note on development:* While the project is rigorously human-reviewed and heavily backed by strict unit testing (matching CI coverage gates), a large portion of the boilerplate and core logic was written using agentic AI.

You can grab it via Cargo (`cargo install auto-commit-rs`) or via the curl/PowerShell install scripts in the repo: https://github.com/gtkacz/smart-commit-rs

Any feedback or contribution is more than welcome, and GitHub stars are greatly appreciated.

Thank you for your time!

If you'd like to learn about how I corralled the agents to do this, check out this blog post https://vers.sh/blog/elixir-webassembly-billion-tokens

And, of course, here's the GitHub https://github.com/hdresearch/firebird

I also posted a thread to Twitter where I ship nifty stuff if fun uses of technology is interesting to you https://x.com/itisyev/status/2028543436388016510

I'm building a tiny embeddable VM in Rust, where the core primitive is a Task with its own state and executable bytecode instructions.

Recently I added new example: Implementation of Binary Coded Decimal decoder from Petzold's "Code" book — every logic gate (bits switch, inverters, AND gates) is a task carrying its own instructions.

It works simple : cargo run 1001 -> 9 and as output it will show AND gate with inputs and output

bcd-decoder: https://github.com/tracyspacy/spacydo/tree/main/examples/bcd-decoder

I built a small WebGPU library that gives you a NumPy-like API in the browser—arrays, matmul, softmax, that kind of thing. No shaders to write, no TensorFlow.js. Just `gpu.array([1,2,3])` and `await a.add(b)`.

It falls back to WebGL2 when WebGPU isn't available (Safari, Firefox) and to CPU for Node/headless. Same API everywhere. ~160KB minified, zero dependencies.

The shaders are pre-built WGSL—add, mul, relu, layer norm, attention scores, etc. I added FFT and spectrogram recently, plus conv2d and pooling (CPU for now). Reductions like sum/max use multi-pass since you can't fit 1M elements in one workgroup.

Demos: [phantasm0009.github.io/accel-gpu](https://phantasm0009.github.io/accel-gpu/) — basic math, image processing, heatmap, neural net inference, N-body sim. Would love feedback.

GitHub: [github.com/Phantasm0009/accel-gpu](https://github.com/Phantasm0009/accel-gpu)

aft was my stab at having a way to understand what claude is doing and also having the language to reason about differences in model behavior when we make them do long agentic runs / change prompts / alter tools etc. The intention of the toolkit to provide an empirical measure of how agent behavior can differ as things changes like environments, tools, prompts etc.

It gives the tools to measure the changes in "behaviors that the users define". This means that it is more like a hypothesis testing framework for what the agent is doing over actually telling what the agent might do.

The reasoning and derivations behind these tools is given over here https://technoyoda.github.io/agent-science.html

Would be very happy to hear feedback and questions. (Please ignore the names given to theorization, it was for shits and giggles)

For the last few months, we've been working on a fundamental architectural shift in how autonomous agents are governed. The current industry standard relies almost entirely on probabilistic alignment (RLHF, system prompts, constitutional training). It works until it's jailbroken or the context window overflows. A statistical disposition is not a security boundary.

We've built an alternative: Deterministic Policy Gates. In our architecture, the LLM is completely stripped of execution power. It can only generate an "intent payload." That payload is passed to a process-isolated, deterministic execution environment where it is evaluated against a cryptographically hashed constraint matrix (the constitution). If it violates the matrix, it is blocked. Every decision is then logged to a Merkle-tree substrate (GitTruth) for an immutable audit trail.

We filed 99 provisional patents on this architecture starting January 10, 2026. Crucially, we embedded strict humanitarian use restrictions directly into the patent claims themselves (The Peace Machine Mandate) so the IP cannot legally be used for autonomous weapons, mass surveillance, or exploitation.

I wrote a full breakdown of the architecture, why probabilistic safety is a dead end, and the timeline of how we filed this before the industry published their frameworks: Read the full manifesto here: https://salvatoresystems.medium.com/the-death-of-probabilist...

The full patent registry is public here: https://aos-patents.com

I'm the founder and solo inventor. Happy to answer any questions about the deterministic architecture, the Merkle-tree state persistence, or the IP strategy of embedding ethics directly into patent claims.

react-redact is a zero-dependency React “demo-safe mode” you can toggle with a single keyboard shortcut.

Wrap your app in <RedactProvider> and hit Cmd+Shift+X (or Ctrl+Shift+X) to instantly blur, mask, or replace marked (or auto-detected) PII like emails, phone numbers, SSNs, credit cards, and IPs.

It’s a visual-only helper for demos and screenshares (it does not remove data from the DOM), and it’s Next.js and TypeScript friendly.

Hey HN,

I've been building YourFinanceWORKS, a comprehensive open-source financial management platform that combines enterprise-grade features with AI-powered automation. Think of it as a self-hosted alternative to QuickBooks/Xero with advanced capabilities.

## What makes this interesting for HN:

*Technical Architecture:* - Multi-tenant design with database-per-tenant isolation - FastAPI + PostgreSQL + Redis + Kafka stack - AI-powered OCR using vision models (95%+ accuracy) - Event-driven architecture with background processing - Plugin system for extensibility - Docker deployment with production-ready configuration

*AI Integration:* - Receipt/invoice OCR with structured data extraction - Natural language queries ("Show me overdue invoices") - Fraud detection and anomaly analysis - Risk scoring for financial documents - Configurable prompt management with versioning

*Key Features:* - Professional invoicing with AI templates - Automated bank reconciliation - Multi-level approval workflows - Real-time financial dashboards - Advanced audit trails and compliance - Investment portfolio tracking plugins

*Open Source Innovation:* - Dual-licensing model (AGPL for core, Commercial for enterprise) - Transparent AI prompt engineering - Community plugin ecosystem - Comprehensive documentation (100+ pages)

## Why I built this:

After paying thousands for financial software that didn't meet our needs, I wanted to create something that: - Respects user privacy (self-hosted) - Provides enterprise features without enterprise pricing - Leverages modern AI for actual automation (not just buzzwords) - Has a transparent, extensible architecture

## Quick start: ```bash git clone https://github.com/snowsky/yourfinanceworks.git cd yourfinanceworks docker-compose up --build -d ```

## Interesting technical challenges solved: - Secure multi-tenancy at database level - High-accuracy financial document OCR - Real-time financial dashboards with WebSocket updates - Configurable approval workflows with AI validation - Cross-tenant analytics while maintaining isolation

The project is production-ready with comprehensive documentation, automated tests, and deployment guides.

*GitHub:* https://github.com/snowsky/yourfinanceworks

Would love feedback from the HN community on the architecture, AI implementation, or any aspect of the system. What features would make this compelling for your use case?

Most AI systems today rely on probabilistic recall: RAG, embeddings, and prompt-based memory.

This makes it hard to enforce invariants, audit facts, or maintain a clear separation between reasoning and ground truth.

I built a minimal proof-of-concept showing a different approach: a deterministic symbolic memory layer accessible via MCP.

Instead of storing “memory inside the model”, knowledge is resolved just-in-time from an explicit symbolic layer.

The goal is not to replace RAG or assistant memory, but to provide a missing infrastructure layer: a controllable knowledge backbone for AI systems.

This repo demonstrates the minimal viable form of that idea.

Hey HN,

I built Leyoda — founders create an interactive startup card and share it as a single link. Investors get everything at a glance: metrics, stage, team, fundraising status. Tap to flip for pitch deck, video, and socials.

Every card has real analytics — views, shares, card flips, top referrers (we detect WhatsApp, LinkedIn, Telegram, in-app browsers), geographic breakdown via GeoIP, and device stats. We also track which AI systems are crawling your card (70+ bots identified, from ChatGPT to Gemini to Perplexity).

The idea: replace the "check out my deck" cold email with one link that tells you who viewed it and where they came from.

Free during alpha. Would love feedback — is this the kind of link you'd actually send to an investor?

I built a free directory and comparison tool for Earned Wage Access (EWA) / on-demand pay providers. It covers 21+ providers across 21+ countries and 5 regions (Americas, Europe, Middle East & Africa, Asia-Pacific). You can filter by region/country and compare features side by side.

EWA is growing fast globally – employers use these tools to offer workers access to earned wages before payday. Useful for HR leaders, CFOs, payroll teams, and anyone evaluating EWA solutions.

Feedback and suggestions for missing providers very welcome!

Hi HN,

I built vim-claude-code, a Vim/Neovim plugin that integrates Claude CLI directly into the editor to enable AI-assisted development workflows without leaving Vim.

The goal was not to build “chat inside Vim,” but to enhance real workflows developers already use.

Current features:

Generate and improve Git commit messages from diffs

Refactor selected code

Generate tests

Summarize code blocks

Send visual selections directly to Claude

Terminal-based integration (no background daemons)

Technically, the plugin follows standard Vim plugin architecture:

Lightweight plugin/ bootstrap

Lazy-loaded autoload/ modules

Modular command dispatcher

Terminal bridge to Claude CLI

Configurable keymaps

Separation of Git, workflow, and terminal logic

It works with both Vim and Neovim.

I’d appreciate feedback from the Vim community — especially around workflow improvements and architecture decisions.

Repo: https://github.com/rishi-opensource/vim-claude-code

Happy to answer questions.

Hi HN,

I’m introducing Securos, a security-focused platform built around disciplined engineering and hardened system design.

The project emphasizes controlled infrastructure ownership, structured deployment practices, and long-term maintainability rather than rapid feature iteration. The goal is to create a stable foundation for security-oriented tooling and services.

Securos is part of the broader Temple Enterprise portfolio, where each platform follows consistent engineering and operational standards.

I’m looking for technical feedback, especially around architecture decisions, security assumptions, and overall direction.

Hi HN,

We built this because we got tired of becoming accidental platform engineers.

Multi-database stacks are the default now, but the operational overhead is brutal. We wanted one auth layer, one dashboard, and one way to provision and monitor everything.

Live now: `Redis` + `TigerBeetle` (weird combo, but that’s what our beta users needed).

Next up: - `MySQL` - `ClickHouse` - `Postgres` + `PostGIS` - `VectorDB`

SDK-first approach. `Node` and `Python` ready.

npm: <https://www.npmjs.com/search?q=%40bridgebase>

PyPI: <https://pypi.org/project/bridgebase/>

Would love feedback from anyone running multi-database workloads in production.

What’s the biggest pain point we missed?

I'm open-sourcing Send to X4, an iOS/Android app that turns shared links into clean EPUBs entirely on-device, then transfers them to an Xteink X4 over local Wi-Fi — no accounts, no cloud.

Repo (MIT): https://github.com/Xatpy/send-to-x4-mobile-app Product page + screenshots: https://chapiware.com/send-to-x4

WHY I BUILT IT The X4 is a focused e-ink device, but getting long-form content onto it from a phone almost always involves a cloud step somewhere. I wanted a pipeline where the phone handles extraction and packaging entirely, and the device only ever receives finished files over LAN. Turns out doing this well on-device is more interesting than I expected.

INTERESTING TECHNICAL BIT - Reader mode extraction: Mozilla Readability + linkedom (a fast DOM implementation) to keep extraction lightweight inside RN. - Client-side rendered pages: for sites where "fetch HTML and parse" fails, I use a headless WebView render → DOM capture → extract pipeline. This is the most fragile part of the stack and where I'd most value outside eyes. - EPUB generation: downloads inline images locally, normalizes formats (transcoding problem types to JPEG for e-ink compatibility), then builds a compliant EPUB. - Local transfer: pushes the resulting EPUB / .xtc / .bmp to the device via its local API (stock + CrossPoint firmware supported).

STACK React Native / Expo (Hermes + new architecture).

WHAT I'M LOOKING FOR - Feedback on the on-device extraction architecture — JS thread vs native, the WebView approach, perf pitfalls - Ideas for making extraction less whack-a-mole (site adapters, heuristics, test corpus) - PRs for niche sites / edge cases are very welcome

Hey HN – I built Nightmarket because I kept running into the same problem building AI agents: every time my agent needed a new capability (weather data, enrichment, web scraping, whatever), I had to go sign up for a service, grab an API key, store it, figure out billing, and wire it all together. Multiply that by 10 services and it's a mess. Agents can't sign up for accounts. They can't enter credit cards. They can't manage API keys. But they can hold a USDC balance and pay per request. Nightmarket is a marketplace where AI agents discover and pay for API services on-chain. No accounts, no API keys, no subscriptions. Your agent pays per call in USDC via x402. How it works:

Browse the marketplace — each service shows pricing, live usage stats, and docs Give your agent the Nightmarket skill (one line in your system prompt, or npx skills add Fallomai/skills --skill nightmarket) Your agent discovers, calls, and pays for services automatically. USDC settles on Base per request.

The whole flow: Agent → discover → call → pay → 200 OK One integration unlocks every service on the marketplace. Your agent doesn't need a separate key for each provider — it just pays and gets data. For sellers: list your API, set a per-call price, and go live immediately. No approval process. Agents start calling as soon as you're listed. You get paid in USDC. Every listing shows live call volume and revenue so buyers can pick providers with proven track records. What makes this different from existing API marketplaces: RapidAPI and friends are built for humans with credit cards. Nightmarket is built for agents with wallets. The x402 protocol (HTTP 402 "Payment Required") means payment is native to the HTTP request itself — no webhooks, no billing dashboards, no invoices. An agent hits an endpoint, gets a 402, pays, retries, gets data. One round trip. We're live at https://nightmarket.ai — you can browse services now and plug the skill into any agent (Claude, GPT, open-source, whatever). Curious to hear from HN:

API providers: would you list your service? What's stopping you from monetizing to agents today? Agent builders: what APIs do you wish your agents could just pay for and use without the signup/key dance? Anyone: poke holes in the model — what breaks when agents are the primary buyer?

Hey HN! I'm building a deceptively simple chat application fronting a local LLM (Ollama or any OpenAI compatible API). TamAGI is the culmination of about 6 months worth of scattered thoughts and incredibly frustrating code sessions (I _suck_ at Python). With OpenClaw's release, I had the "Aha" moment I was looking for and used Claude Code to help fill in the gaps (to be frank, quite a lot of gaps) and make this project a reality.

The TLDR: TamAGI is a virtual agent, in the spirit of Tamagotchis. Where it differs is developing a personality and growing as an "entity" the more you interact with it. It ships with a hand full of tool calls out of the box, and has an extensible framework for the Agent to create its own tools. Memory is handled by ChromaDB with RAG providing context injection via system prompt dynamically. It supports only a single user currently, but has optional authentication for client-server use on bare metal or in containers.

I'm quite happy with how it is shaping up, and I'm looking for any feedback to drive the next iteration. Thank you for looking!

Game: A blackjack game where the dealer commentary is openly contemptuous of everyone at the table. Daily leaderboard with 21 hand limit.

Maker: Former online gambling product manager, now working in a big corporate.

Large backlog of unsuccessful side projects that were great fun to work on :)

I built ajax-hooker, a browser-side AJAX interceptor for runtime request/response control (debugging, userscripts, extension tooling, temporary API rewrites).

GitHub: https://github.com/Arktomson/ajaxInterceptor npm: https://www.npmjs.com/package/ajax-hooker

What it does:

One unified hook model for XMLHttpRequest + fetch Mutate request fields: URL / method / headers / body Observe or rewrite response payloads Chain multiple hooks (auth/logging/rewrite separated) Stream interception for SSE/NDJSON-like responses Typical use cases:

Add auth/tracing headers globally Switch API domain/version without touching app code Mock or patch responses during integration/debug Build userscript or Chrome-extension request tooling I’d really appreciate feedback on:

API ergonomics for hook composition edge cases around fetch response semantics stream interception behavior in real-world apps

Hi HN, I built this because I kept pasting sensitive info into ChatGPT without thinking client names, financial details, API keys.

PrivacyShield detects 15+ types of PII as you type, masks them with placeholders like [PERSON_A] before sending, then unmasks the AI's response so you see your real data back.

Everything runs locally. No servers, no data collection. AES-256 encrypted mappings that auto-expire.

Chrome Web Store: https://chromewebstore.google.com/detail/privacyshield/nklgh...

This is v0.1 — would love feedback. Bugs: [email protected] or GitHub issues.

Private macOS AI Chat - Powered by Apple's On-Device Models

Offline, no model downloads, 100% local. Natural voice chat, generate images via Image Playground, search your calendar, and run code — all on-device.

Freeware experiment testing Apple's foundation model capabilities for chat (performance varies; not production-ready).

Github: https://github.com/codeeverywhereca/FoundationsLLMChat

Duffel is a local-network markdown workspace for human + LLM collaboration.

It provides Web UI for browsing and editing notes & Lightweight CLI for search-first retrieval (using qmd).

I've found it to be very helpful for projects that require agents to have a lot of data in certain situations and they are actually quite fastidious about recording learnings and keeping everything tidy.

Have you clocked in yet?

I built Local Hours, a simple time tracking / timesheet app that treats your data as plain files instead of rows in someone else’s database.

No accounts, no backend – All time entries and timesheets are JSON files in a folder you pick. Sync happens via iCloud / Dropbox / OneDrive if you want it.

Cross-device by design – The macOS menu bar app and iOS app both point at the same folder, so they “sync” via your storage provider without any server code.

Timesheets, not dashboards – The main job is: track time, then generate a weekly/bi-weekly/monthly timesheet you can actually send to an approver.

Exports that don’t trap you – You can send an email with an embedded summary + CSV, or just open the JSON files yourself.

Privacy – No analytics, no telemetry, no in-app purchases. It’s MIT-licensed and fully open source.

Apps are free on the App Store (iPhone, iPad, Mac): https://apps.apple.com/us/app/local-hours-simple-timesheet/i...

Repo (code, storage format, docs, screenshots): https://github.com/gogrinimish/LocalHours

I’d especially like feedback on: Does the “just files” approach line up with how you’d want to archive or script your own timesheets? Is the UX for picking the storage folder and sharing it across devices clear enough? What’s missing for you to actually use this for client work?

I've been working in software quality engineering for years and kept running into the same problem: organizations trying to adopt AI coding agents and failing — not because the tools were bad, but because their processes weren't ready.

CMMI measures process maturity. But it says nothing about how hard it will be to shift from code-centric to specification-centric development. Those are different questions.

So I built a 5-level framework that tries to answer both simultaneously: where you are, and how much work it will take to get to SDD with AI agents.

The levels go from GUIDO 1 (chaotic, very high migration effort) to GUIDO 5 (SDD-native, specs as living source of truth).

The key insight — which I think is non-obvious — is that you can be CMMI Level 3 and still be GUIDO 2. Process maturity and SDD readiness are not the same axis.

It includes a whitepaper, assessment folder, and real-world scenarios.

Honest caveat: this is v1.0, published two weeks ago, zero external validation so far. I'm sharing it here specifically because I want to know if this resonates with engineers who've actually tried to introduce AI agents into their dev pipelines — or if I'm solving a problem that doesn't exist the way I think it does.

What has your experience been? Did your organization skip levels and pay for it?

Hi HN,

I've built an MCP Server for Himalayas (https://himalayas.app) to make our entire recruiting workflow accessible via AI chat.

It's great seeing Claude able to search for talent for a role, evaluate them, and then message them all by asking something like "Find me talent for <X> role in Australia".

I've also integrated the ability to manage and post job listings (including with Stripe checkout for paid postings).

Open to any ideas for how to build this out further and simplify the employer's workflow.