value: flyingsky

value:
Hi HN! I use Claude Code a lot, but my token usage is directly proportional to how long I'm willing to sit there prompting it. If I'm not at my desk thinking up tasks and feeding them in, the tokens just go unusued[which i weirdly feel bad about].
over the past couple of days, I hacked on sustn, a tool that scans your repo, figures out what needs fixing on its own (dead code, missing tests, security issues, etc.), and puts it in a prioritized list. Then it just starts working through the list - whether you're there or not.
When it's done with a task, it either creates a PR automatically or waits for your approval - you choose. You can reorder the list to control what gets picked up next, set a schedule (e.g let it run overnight), set a token budget, and add your own tasks manually too.
Still very early but would love feedback.

value: Show HN: Sustn – scans your repo and opens PRs for security issues and tech debt

author: flyingsky


value: Show HN: Tool to shift teams from passive documentation to active enforcement


value: SuzyLi

value:
I built fbsviewer, an interactive tool to help understand how FlatBuffers binaries are encoded.
FlatBuffers is designed for performance and zero-copy access, but that also makes the raw binary format hard to reason about. When debugging serialization issues or learning the format, I often found it difficult to connect the schema, decoded data, and the underlying bytes.
This tool lets you paste a .fbs schema and some hex-encoded FlatBuffers data and see how the bytes map to tables, fields, vectors, strings, and vtables. The hex view and structure view are linked so you can move between the raw bytes and the logical structure.
A few things it includes:
- Color-coded hex view showing how bytes map to FlatBuffers structures
- Interactive structure tree linked to byte ranges
- Decoded JSON view generated from the schema
- FlatBuffers schema compiler running in WebAssembly, so everything runs fully in the browser
I originally built it to debug serialization issues, but it also turned out to be a useful way to understand how FlatBuffers encoding works internally.
You can try it here:
https://fbsviewer.shuozeli.com
Repo:
https://github.com/Shuozeli/fbsviewer-lib
Feedback and suggestions are very welcome.

value: Show HN: Fbsviewer – FlatBuffers binary viewer. Pure Rust compiler in WASM

author: SuzyLi


value:
I built dalahash, a small in-memory key-value server for Linux.
Design highlights:
- worker thread per CPU (pinned) and RX/TX queue
- one io_uring instance per worker
- SO_REUSEPORT listener sharding
- lock-free shared KV store
- Redis and Memcached protocols (small subset)
Quick benchmark using memtier_benchmark:
- ~3.9M ops/sec
- 230 µs average client latency
- 823 µs p99.99 client latency
- ~18.8M ops/sec with pipelining
About 90% of the code was written using AI coding agents. I mainly focused on the architecture and reviewed the generated code.
Details:
https://github.com/joakimthun/dalahash

value: Show HN: Dalahash – a io_uring KV server (~3.9M ops/SEC, mostly written by AI)


value:
I built a Bloomberg-style finance terminal aimed at individual investors and developers.
The goal is to make institutional-style market tooling accessible without the $20k/year Bloomberg subscription.
Current features:
- Real-time market data
- Terminal-style UI inspired by Bloomberg
- Company fundamentals and financials
- Macro and economic indicators
- Watchlists and alerts
- Fast keyboard navigation
- Options real time data and analysis
I'm exploring features like:
- options analytics
- portfolio analytics
- AI-assisted research
- scripting/API access
Would love feedback from the HN community on:
- features you'd want in a terminal like this
- data sources
- UX improvements

value: Show HN: I built a financial terminal for investors (fundamentals, options)


value: anosidium

value:
I’ve just released Oliphaunt, a Mastodon client built specifically for macOS.
If you’re familiar with X (Twitter) or Bluesky, Mastodon will feel immediately recognisable. It’s a federated social network built on the ActivityPub protocol, where independent servers (“instances”) interoperate while remaining decentralised.
The motivation behind this project was fairly simple: I wanted a Mastodon client that behaves like a well-behaved macOS application.
Many desktop apps today are effectively scaled-up mobile interfaces or cross-platform ports. They can work well, but they often ignore macOS conventions. My goal was to build something that feels like a native citizen of the platform.
Oliphaunt focuses heavily on macOS design principles:
- built with system-native UI components (AppKit with some SwiftUI)
- follows macOS design language and interface idioms
- supports proper multi-window workflows
- keyboard shortcuts
- respects macOS interaction patterns rather than reinventing them
A lot of the work went into the details that make Mac software feel “right”: window behaviour, menus, keyboard navigation, sidebar structure and integration with system features.
The goal isn’t to introduce a new interface paradigm but to adopt the conventions Mac users already understand.
If you’re a Mastodon user or someone who appreciates carefully built native Mac software, I’d love to hear your feedback.
App Store:
https://apps.apple.com/app/id6745527185

value: Show HN: Oliphaunt – a native macOS Mastodon client built with AppKit

author: anosidium


value:
I am happy to share my first-ever Open Source Project: Decision Guardian
What is Decision Guardian?
Engineering teams lose critical context when senior engineers leave, architectural decisions go undocumented, or new developers modify sensitive code without understanding the why behind it.
Decision Guardian solves this. You write decisions once in simple Markdown files. When a PR touches protected code, Decision Guardian automatically surfaces the relevant context as a PR comment or CLI output (based on pre-defined rules).
Github Marketplace -: https://github.com/marketplace/actions/decision-guardian
NPM -: https://www.npmjs.com/package/decision-guardian
Would love your feedback :>

value: Show HN: What Is Decision Guardian?

title: Show HN: What Is Decision Guardian?


value: cwoodyard

value:
I’ve been working on a multi-agent academic research lab, and I wanted to share it here today primarily to give a massive shoutout to the developers behind ZeroClaw.
 When designing the architecture for this, I needed an autonomous agent runtime that was lightweight, entirely agnostic, and highly secure for local execution. ZeroClaw’s pure Rust implementation provided exactly the zero-overhead foundation the project required.
Because they solved the core runtime execution so elegantly, I was able to spend my time building the higher-level orchestration on top of it—like the retrieval graph engines, the Godot-based client interface, and the physical hardware/robotics bridges.
If any of the ZeroClaw maintainers are reading this: thank you. Your repository is a cool example of open-sourcery, and the R.A.I.N. Lab literally would not exist in its current state without the groundwork your team laid.
Feel fre to check out what my startup built on top of their runtime here: https://github.com/topherchris420/james_library

value: Show HN: James Library – Local multi-agent research lab (built on ZeroClaw)

author: cwoodyard


value:
I got tired of sharing AI demos with terminal screenshots or screen recordings.
Claude Code already stores full session transcripts locally as JSONL files. Those logs contain everything: prompts, tool calls, thinking blocks, and timestamps.
I built a small CLI tool that converts those logs into an interactive HTML replay.
You can step through the session, jump through the timeline, expand tool calls, and inspect the full conversation.
The output is a single self-contained HTML file — no dependencies. You can email it, host it anywhere, embed it in a blog post, and it works on mobile.
Repo: https://github.com/es617/claude-replay
Example replay: https://es617.github.io/assets/demos/peripheral-uart-demo.ht...

value: Show HN: Claude-replay – A video-like player for Claude Code sessions


value:
Hey HN, I built Vet (https://getvet.ai) — a security registry for MCP servers and AI skills.
The problem: when you install an MCP tool, you're giving an AI agent code execution on your machine. I scanned 88K+ tools and found crypto miners, SSH backdoors, prompt
 injection, and tools silently reading .env files and SSH keys. 537 flagged total.
How it works:
- Static analysis + AI security review generates a trust score (0-100) per tool
- Verified tools earn badges (install, boot, tool discovery all tested)
- Everything is searchable with security-aware ranking
Ways to use it:
- Browse: https://getvet.ai/catalog
- CLI: `npx @getvetai/cli find "database"`
- MCP server (yes, an MCP that discovers MCPs): `npx @getvetai/mcp`
- API: `curl <a href="https://getvet.ai/api/v1/discover?q=github" rel="nofollow">https://getvet.ai/api/v1/discover?q=github</a>`
The CLI is open source: https://github.com/getvetai/cli
Free to use. If you build MCP servers, you can claim and get verified.
Would love feedback on the security analysis approach and what data you'd want to see.

value: Show HN: Vet – Security registry for 88K+ MCP servers and AI tools


value: sovande

value:
Red Dead Redemption 2 is a beautiful game, and its PvP used to be genuinely fun if you didn't take it too seriously. That has changed. Both RDO and GTA Online lobbies are full of cheaters, and on console, lag switching is the go-to method. A lag switcher briefly halts their own connection, moves and shoots while your hits get dropped, then reconnects. You land a clean headshot and it doesn't register. Their shots land fine. Die, respawn, repeat.
Both games use P2P mesh networking, so every player connects directly to every other player. Your IP is exposed to the entire lobby, and anyone can manipulate their connection to gain a combat advantage. Rockstar has never added anti-cheat to console.
Killswitch sits on a Mac bridging your router and console, monitoring packet timing on the primary game port (UDP 6672). All game traffic is encrypted, so detection relies entirely on metadata and timing gaps between packets. When an IP's gap score crosses a threshold, it gets blocked via the macOS PF firewall. Blocking doesn't kick them from the session. The mesh relays their game state through other players, but it adds enough latency to neutralize most of the advantage. You're essentially lag switching them back.
The README and NOTES file have more details.

value: Show HN: GTAO and Red Dead Online lag switch detector and blocker (anti-cheat)

author: sovande


value: NeuroFunky

value:
Hi HN,
I kept finding myself writing scripts or manually running prompts to do things like PR reviews, documentation generation, or issue triage on my GitHub repositories.
After doing this enough times, I decided to build a small platform to automate these workflows.
I recently open sourced it:
https://github.com/Njuelle/Codaholiq
Codaholiq lets you run AI-powered workflows triggered by GitHub events.
You connect a repository and define automations that run when certain events occur, such as:
- pull request opened
- push to a branch
- issue created
- cron schedule
- manual trigger
Each automation defines:
- a trigger
- an AI provider or model (Claude Code, Codex, Gemini, etc.)
- a prompt template
- optional conditions on the GitHub event payload
When the event happens, Codaholiq renders the prompt using variables from the event context and dispatches a GitHub Actions workflow that runs the AI task.
The platform also tracks executions with:
- real-time log streaming
- token usage and cost tracking
- execution history
One design goal was self-hosting, so the entire platform can run locally or on your own infrastructure.
The architecture is intentionally simple:
- GitHub webhooks trigger automations
- jobs are queued using Redis and BullMQ
- the NestJS backend processes the queue and dispatches workflows to GitHub Actions
- AI models are called through providers
- logs and token usage are streamed back to the UI
The full platform can run with Docker using Postgres and Redis.
Example automation:
An automation could trigger when a pull request is opened.
It sends the PR diff to an AI model asking for a code review, then runs the task through a GitHub Actions workflow.
Some possible use cases:
- automated PR reviews
- generating documentation from diffs
- code refactoring suggestions
- issue triage
- automatic changelog generation
It's still early, but the core pieces are working.
One thing I'm unsure about is whether this project makes more sense as:
- a self-hosted automation tool
- or a hosted version that simplifies setup and management
I'm curious how teams here would prefer to run something like this.
Any feedback is very welcome.

value: Show HN: Codaholiq, AI automations for GitHub repositories

author: NeuroFunky


value:
Wanted a stress tester I could throw into scripts and CI without spinning up a GUI.
Most open source options skip the GPU entirely, so I wired in Metal for the GPU side.
It runs matrix ops, FFTs, and particle sims concurrently and draws live utilization
bars in the terminal — one for CPU, one for GPU.
Curious if the workload mix is actually representative or if I'm missing something obvious.
Also open to feedback on the Metal implementation if anyone's gone down that path.

value: Show HN: ChronosBench – Terminal CPU/Metal GPU stress tester with live load bars


value: blueeon

value: Show HN: A document search engine CLI, built for AI Agents.

author: blueeon


value: CortierAI

value:
Hey HN, I'm one of the two founders of Cortier.
We built a personal AI assistant that runs as a persistent process per user, rather than a stateless chat session.
A few things that differentiate it:
1. Persistent memory across all conversations — tell it something once
2. Proactive behavior — it monitors your calendar, detects conflicts, and reaches out when relevant
3. Autonomous reflection — it generates its own thoughts between conversations and surfaces them in a private feed ("Moments")
4. Full data isolation — each user gets their own machine and volume
Two-person team. We used Cortier itself to help build Cortier — it did research, helped design systems, and reviewed decisions throughout.
Demo video and early access at cortier.ai. Happy to answer any technical questions.

value: Show HN: Cortier – A personal AI that thinks about you

author: CortierAI


value: assahbismark

value:
I've been reading HN every day for months and always wished the experience was a bit smarter  less noise, more signal, without losing the depth that makes HN worth reading.
Decidel is what I built to fix that. It's an iOS client with AI-powered thread summaries, semantic topic filtering (mute topics you don't care about), threaded discussions, offline reading, and export to Markdown, Notion, or Obsidian. You bring your own API
This is a rapid first release. A web version is in the works. Happy to answer any questions and would genuinely appreciate any feedbacks especially from daily HN readers.
App Store https://apps.apple.com/app/decidel/id6759561178

value: Show HN: Decidel A Hacker News client for iOS with smart summaries and filtering

author: assahbismark


value:
Anchor Engine is ground truth for personal and business AI. A lightweight, local-first memory layer that lets LLMs retrieve answers from your actual data—not hallucinations. Every response is traceable, every policy enforced. Runs in <3GB RAM. No cloud, no drift, no guessing. Your AI's anchor to reality.
We built Anchor Engine because LLMs have no persistent memory. Every conversation is a fresh start—yesterday's discussion, last week's project notes, even context from another tab—all gone. Context windows help, but they're ephemeral and expensive. The STAR algorithm (Semantic Traversal And Retrieval) takes a different approach. Instead of embedding everything into vector space, STAR uses deterministic graph traversal. But before traversal comes atomization—our lightweight process for extracting just enough conceptual structure from text to build a traversable semantic graph.
*Atomization, not exhaustive extraction.* Projects like Kanon 2 are doing incredible work extracting every entity, citation, and clause from documents with remarkable precision. That's valuable for document intelligence. Anchor Engine takes a different path: we extract only the core concepts and relationships needed to support semantic memory. For example, "Apple announced M3 chips with 15% faster GPU performance" atomizes to nodes for [Apple, M3, GPU] and edges for [announced, has-performance]. Just enough structure for retrieval, lightweight enough to run anywhere.
The result is a graph that's just rich enough for an LLM to retrieve relevant context, but lightweight enough to run offline in <3GB RAM—even on a Raspberry Pi or in a browser via WASM.
*Why graph traversal instead of vector search?*
- Embeddings drift over time and across models
- Similarity scores are opaque and nondeterministic
- Vector search often requires GPUs or cloud APIs
- You can't inspect why something was retrieved
STAR gives you deterministic, inspectable results. Same graph, same query, same output—every time. And because the graph is built through atomization, it stays small and portable.
*Key technical details:*
- Runs entirely offline in <3GB RAM. No API calls, no GPUs.
- Compiled to WASM – embed it anywhere, including browsers.
- Recursive architecture – we used Anchor Engine to help write its own code. The dogfooding is real: what would have taken months of context-switching became continuous progress. I could hold complexity in my head because the engine held it for me.
- AGPL-3.0 – open source, always.
*What it's not:* It's not a replacement for LLMs or vector databases. It's a memory layer—a deterministic, inspectable substrate that gives LLMs persistent context without cloud dependencies. And it's not a competitor to deep extraction models like Kanon 2; they could even complement each other (Kanon 2 builds the graph, Anchor Engine traverses it for memory).
*The whitepaper* goes deep on the graph traversal math and includes benchmarks vs. vector search: https://github.com/RSBalchII/anchor-engine-node/blob/d9809ee...
If you've ever wanted LLM memory that fits on a Raspberry Pi and doesn't hallucinate what it remembers—check it out, and I'd love your feedback on where graph traversal beats (or loses to) vector search.
We're especially interested in feedback from people who've built RAG systems, experimented with symbolic memory, or worked on graph-based AI.
Reddit discussion: https://www.reddit.com/r/LocalLLaMA/s/EoN7N3OyXK

value: Show HN: Anchor Engine – Deterministic Semantic Memory for LLMs Local (<3GB RAM)


value:
TL;DR Claude Code did my 2024 and 2025 taxes. Added a skill that anyone can use to do their own.
I tested it against TurboTax on my own 2024 and 2025 return. Same result without clicking through 45 minutes of wizard steps.
Would love PRs or feedback as we come up on tax season.
Learnings from replacing TurboTax with Claude
Skill looping
The first iteration of my taxes took almost an hour and a decent amount of prompting. Many context compactions, tons of PDF issues, lots of exploration.
When it was done, I asked Claude to write the skill to make it faster the next time (eg: Always check for XFA tags first when discovering form fields)
Skills aren’t just .MD files anymore
Now they’re folders that can contain code snippets, example files, rules.
In 2025 we were all building custom agents with custom tools.
In 2026 every agent has its own code execution, network connection, and workspace. So it’s custom skills on the same agent (trending towards Claude Code or Cowork)

value: Show HN: Claude skill to do your taxes

title: Show HN: Claude skill to do your taxes


value: jmanhype

value: Show HN: LoRA gradients on Apple's Neural Engine at 2.8W

author: jmanhype


value: nwpwr

value:
Traces is a new way to share and discover agent traces. You can setup a personal or team account, and share publicly or privately (in a team).
We use Traces internally to capture and share our agent conversations. Every PR has a Traces link attached to it. We even have skills that can automate that for you (run 'traces setup' after install).
You might ask:
1) Why would I share traces? Well, we have found ourselves wanting to learn from each other on how to prompt different models and agents. We built Traces as a tool for teams to learn that together, and for us to learn that as an open community.
2) What about Privacy? You can share publicly, privately, or via direct link. We strip data at source to make sure anything that looks sensitive never leaves your machines. Orgs have more privacy settings as well. But honestly, me saying this is one thing, earning your continued trust is the goal of every release.
If you're interested, just get started at traces.com. You can hop into our Discord, find us on X at x.com/tarunsachdeva / x.com/tracesdotcom.
Thank you!

value: Show HN: Traces: A new way to share and discover agent traces

author: nwpwr


value: tdaltonc

value:
Long-running agents struggle to attend to relevant information as context grows, and eventually hit the wall when the context window fills up.
NERDs (Networked Entity Representation Documents) are Wikipedia-style entity pages that LLM agents build for themselves by reading a large corpus chunk-by-chunk. Instead of reprocessing the full text at query time, a downstream agent searches and reasons over these entity documents.
The idea comes from a pattern that keeps showing up: brains, human cognition, knowledge bases, and transformer internals all organize complex information around entities and their relationships. NERDs apply that principle as a preprocessing step for long-context understanding.
We tested on NovelQA (86 novels, avg 200K+ tokens). On entity-tracking questions (characters, relationships, plot, settings) NERDs match full-context performance while using ~90% fewer tokens per question, and token usage stays flat regardless of document length. To highlight the methods limitation, we also tested it on counting tasks and locating specific passages (which aren't entity-centered) where it did not preform as well.
nerdviewer.com lets you browse all the entity docs we generated across the 86 novels. Click through them like a fan-wiki. It's a good way to build intuition for what the agent produces.
Paper: https://www.techrxiv.org/users/1021468/articles/1381483-thin...

value: Show HN: NERDs – Entity-centered long-term memory for LLM agents

author: tdaltonc


value: buhhalter

value:
Hi HN — I built Qurt, an open-source desktop “AI coworker” for Windows + macOS.
The goal: provider freedom + local-first UX. You bring your own API keys (no subscription / no lock-in), and your chats/keys/files stay on your machine (nothing stored on our servers).
What it does:
- BYOK + multi-provider model switching (keep control of keys/data)
- Desktop-native chat with file/image attachments
- Agent mode: web browsing/search, terminal commands, browser automation, and file edits — with “review before run”
Downloads (GitHub Releases):
https://github.com/qurtai/qurt/releases/tag/v0.1.1
Repo:
https://github.com/qurtai/qurt
Landing page:
https://qurt.ai/
I’d love feedback on:
1) the “review-before-run” UX (too noisy? not strict enough?)
2) what provider/model integrations you’d want next
3) what would make you trust/install this faster (docs, sandboxing details, etc.)

value: Show HN: Qurt – open-source desktop AI coworker (BYOK, agent mode)

author: buhhalter


value: enzonespoli

value: Show HN: True Cost Per Mile – a simple calculator for real car ownership cost

author: enzonespoli


value: Show HN: Pg_sorted_heap–Physically sorted PostgreSQL with builtin vector search


value: kbigdelysh

value:
We built RapidFire AI because iterating on RAG pipelines is painfully sequential:
run a config, wait, inspect results, tweak one knob, repeat. When you have 15
things to tune (chunk size, retrieval k, reranker, prompt template, context
window strategy...) that cycle compounds fast.
RapidFire uses shard-based interleaved scheduling to run many configurations
concurrently on a single machine — even a CPU-only box if you're using a
closed API like OpenAI. Instead of config A finishing before config B starts,
all configs process data shards in rotation, so you see live side-by-side
metric deltas within the first few minutes.
The part we're most excited about: Interactive Control (IC Ops).
Most RAG observability tools tell you what happened after a run finishes.
IC Ops closes the loop — you can act on what you're observing mid-run:

  - Stop a config that's clearly underperforming (save the API spend)
  - Resume it later if you change your mind
  - Clone a promising run and modify its prompt template or retrieval
    strategy on the fly, with or without warm-starting from the parent's state

This changes the experimentation workflow from "observe → write notes →
re-queue a new job" to "observe → fix → continue" in a single session.
What you can experiment over in one run:
  - Chunking strategy and overlap
  - Embedding model
  - Retrieval k and hybrid search weighting
  - Reranking model / threshold
  - Prompt template variants (few-shot, CoT, context compression)
  - Generation model (swap GPT-4o vs Claude 3.5 vs local model mid-experiment)
Eval metrics aggregate online (no need to wait for full run), displayed in
a live-updating in-notebook table. Full MLflow integration for longer-term
experiment governance.
GitHub: https://github.com/RapidFireAI/rapidfireai
Docs: https://oss-docs.rapidfire.ai
pip install rapidfireai

value: Show HN: RapidFire AI – parallel RAG experimentation with live run intervention

author: kbigdelysh


value: pranavchahal

value:
Hi HN — I built BoardMint because I don’t think AI-first PCB review is trustworthy if it can hallucinate.
In hardware, a plausible wrong answer can still cost a board spin.
A lot of engineers still seem skeptical of AI-first PCB tools for that reason — Flux.ai’s copilot, for example, has been called out for claiming it added resistors and other features that never actually appear in the schematic. So BoardMint does the core analysis with deterministic rule engines, not an LLM. It parses PCB projects, runs standards-backed checks, and uses AI only to explain findings and suggest fixes.
It also includes project/file management, collaboration, comments, and an AI assistant with full project context.
https://boardmint.io/
Any feedback is appreciated.

value: Show HN: BoardMint – a PCB review tool that avoids AI hallucinations

author: pranavchahal


value: theodorehq

value:
macOS gives you three appearance options: Light, Dark, or Auto. Auto follows sunset, which is a surprisingly blunt heuristic. It doesn't account for season (dark mode at 3:50pm in December, light mode at 9pm in June), and it has zero awareness of actual conditions outside. Overcast and dark at 2pm? Your Mac doesn't care.
The deeper problem is that macOS treats appearance, wallpaper, and colour temperature as unrelated settings. You end up stitching together separate tools that don't know about each other, or you just live with the defaults and accept the friction.
Solace tries to solve this by treating them as one system. It sits in the menu bar and coordinates sunset and sunrise scheduling, weather-aware dark mode switching, wallpaper sync across displays, and gradual screen warmth -- all driven by the same set of inputs (solar position, local weather, time of day).
The weather-aware piece is the part I haven't found elsewhere. It pulls cloud cover data and triggers dark mode when conditions warrant it, independent of the solar schedule. Right now the threshold is fixed at 75% cloud cover -- making that configurable is the next update.
Built natively with Swift and SwiftUI. All location data stays on-device. No network calls except weather lookups. No analytics.
$4.99, one-time. Interested in feedback on the approach, especially from anyone who's tried to solve this problem differently.

value: Show HN: Solace – Mac menu bar app that adapts to the world around you. Finally

author: theodorehq


value: TheBengaluruGuy

value:
Hi HN,
I'm Siddarth, co-founder at DrDroid. We build tooling for engineering teams to detect and debug production issues faster. Our product is an always-on autonomous AI agent that listens to alerts, investigates issues and escalates where necessary, before an engineer even picks them up.
While building that, we noticed something: our agent debugged issues significantly faster (and more accurately) when it had pre-built context about the infrastructure. Which services exist, which dashboards track what, what the DB schema looks like. Without it, agents spend the first stretch of every session re-exploring things they should already know. We kept hitting the same thing with Claude Code and Cursor internally when using it with MCP servers.
So we extracted that idea into droidctx, an open source CLI that connects to your production tools and generates structured .md files capturing your infrastructure. Run droidctx sync and it pulls metadata from Grafana, Datadog, Kubernetes, Postgres, AWS, and 20+ other connectors into a clean directory. Add one line to your CLAUDE.md pointing at that directory, and your agent starts every session already knowing your stack.
Outcome to expect: fewer tool calls, fewer hallucinations about your specific setup, and lesser context to share every time. We've had some genuinely surprising moments too. The agent once traced a bug to a specific table column by finding an exact Grafana query in the context files, something it wouldn't have known to look for cold.
It's MIT licensed and pre-built with 25 connectors across monitoring, Kubernetes, databases, CI/CD, and logs. It runs entirely locally. Credentials stay in credentials.yaml and never leave your machine.
Curious whether others have hit this problem with coding agents, and whether "generate context once, reuse across sessions" feels like the right abstraction or if we're solving this the wrong way. Happy to hear what's missing or broken.

value: Show HN: Droidctx – generate Markdown docs from your prod infra for coding agent

author: TheBengaluruGuy


value: tominaga-h

value:
Hi HN,
I build a VS Code extension called Code Jump Tracker.
https://github.com/tominaga-h/code-jump-tracker
I created this because I was constantly getting lost in large codebases during code reviews. I use "Go to Definition" (F12) a lot to trace logic. While VS Code has a native "Navigate Back" shortcut, it operates blindly—you can't see your stack history, making it hard to jump back to a specific file after exploring multiple branches.
Code Jump Tracker solves this by acting like `pushd/popd` for your editor.
Key features:
- Auto-tracking: Automatically logs your jumps (Go to Definition, Outline clicks) into a clean, native-looking Webview table in the sidebar.
- Manual Pinning: Found a core function you need to revisit? Pin it. It adds a persistent marker icon to your gutter.
- Unique Locations: Keeps a deduplicated list of your visited symbols.
- Persistent: State is saved per-workspace using `workspaceState`, so your history survives editor restarts.
I built the UI using VS Code's native CSS variables within a Webview to ensure it perfectly matches your theme and aligns columns beautifully (something the standard TreeView couldn't do well).
I'd love to hear your feedback, bug reports, or feature requests!

value: Show HN: Code Jump Tracker – Never get lost after "Go to Definition" again

author: tominaga-h


value: daniielyan

value: Show HN: Dotclaude – Sync your Claude Code config across machines with Git

author: daniielyan


value: sathiunique

value: Show HN: Apiform – Auto-Generate CRUD REST APIs from Your Prisma Schema

author: sathiunique


value: wesleysmyth

value: Show HN: TLDR – Free Chrome extension that summarizes any article in 2s with AI

author: wesleysmyth


value: ChiefTinkeer

value: The Tinker Index is a composite metric that tracks developer ecosystem activity across multiple platforms. It measures whether the rise of AI-assisted coding tools is translating into measurably increased software development output.

value: Show HN: Tinker Index – My index tracking impact of AI on developer productivity

author: ChiefTinkeer


value: univrsal

value: Show HN: I made a keygen for my own software

author: univrsal


value: pmarsceill

value:
Hey HN,
I built Feedster for a few reasons:
1. I want to spend more time reading people's blogs, long form content, even more traditional digital publications and less time on social media.
2. RSS readers have typically felt a lot like Apple Mail circa 2010... Unread counts for every feed, everything in its own discrete view, no means for easily discovering new stuff. Not necessarily a bad thing, but it does make reading content feel like _work_ which is directly opposing goal number 1.
3. No one has really rethought the shape of RSS in quite some time (Google Reader is probably the biggest re-think here that I can remember). It's typically been a client that downloads posts from various feeds on the internet. This is simple and it works, but what if there was a different shape that was more communal, more editorial, and was web-based?
4. I haven't seen any RSS-powered AI agent workflows and I wanted to experiment with what that might look like. To start, I built a hosted MCP server that users can authenticate to and give their agents read-only access to their Feedster channels and feeds. I plan to add more functionality here, as it would be very cool to have an agent do a search on Feedster and find other feeds you might be interested in and add them to your channels automatically. Or dump a giant OPML file of feeds into an agent and have it auto add them to your account and categorize them into different channels for you.
You can read more about the background on my blog here:
https://p.atrick.org/2026/03/05/introducing-feedster
Thanks for checking it out, any feedback or discussion is appreciated.

value: Show HN: Feedster, an RSS/feed reader focused on discovery and agent integration

author: pmarsceill


value: BuildWithAI

value:
I built SuperBuilder, an open-source AI platform that lets agents create apps, generate media, run pipelines, and orchestrate multiple AI models.
Features include:
• AI agent orchestration
• plugin system
• media generation pipelines
• Docker setup
• starter templates
• plugin SDK
I'm looking for feedback and contributors.
GitHub: https://github.com/rupac4530-creator/super-builder-platform

value: Show HN: Autonomous AI platform that builds apps and tools automatically

author: BuildWithAI


value: diddddy

value:
The best ways to organize research links are usually the simplest ones.
Capture fast. Group by project. Save context. Review regularly. Keep one clear home base.
That is the system.

value: Show HN: Best ways to organize research links

author: diddddy


value: fkratzer

value:
I built an autonomous AI portfolio management system that runs on $300/month infrastructure.
Results: 34% returns over 3 months vs 7% S&P 500. Real capital, not backtesting.
Architecture:
Stage 1: LightGBM ranks 1,700+ stocks daily (80+ features)
Stage 2: JAX PPO optimizes portfolio allocation
Walk-forward validation, champion/challenger deployment
Nightly retraining pipeline
Recent additions:
Personal portfolio analysis with ML health scores
Daily digest with Perplexity-summarized news
Market regime detection (bull/bear + volatility)
Stack: FastAPI, React, PostgreSQL, LightGBM, JAX/Flax, Claude API
Now seeking acquisition by brokerages, robo-advisors, or fintech platforms. Building this from scratch is 2-3 years of specialized quant work.
Live demo: https://acis-trading.com
Happy to discuss the ML architecture, validation methodology, or acquisition strategy.

value: Show HN: AI trading platform with 34% returns (3 months) – seeking acquisition

author: fkratzer


value:
I built AdPipe after seeing how much time agency owners and DTC founders spend writing Meta ad copy from scratch — often reusing the same angles until ROAS drops.
You paste a product URL, pick a goal (prospecting or retargeting) and a tone, and get 12 variants across 4 persuasion styles (direct response, social proof, FOMO, story) in ~30 seconds. Policy-checked, export-ready as CSV or TXT.
No signup required to try it — just paste a URL on the homepage.
Honest status: launched 4 weeks ago, still figuring out who feels this pain most acutely. Agency owners managing multiple clients? Solo founders running their own ads? Both seem plausible.
Would genuinely appreciate feedback from anyone who runs Meta ads on whether this solves a real problem for them.
adpipe.io

value: Show HN: AdPipe – Generate 12 Meta ad copy variants from any product URL


value: Switched from ChatGPT to Claude and realized the official migration only transfers what ChatGPT remembers about you, not your actual conversations. Built a local pipeline that imports full exports, generates semantic embeddings on your machine, and serves them via MCP server. Claude Desktop and Cursor can search your entire chat history by meaning during any conversation. No cloud, no API keys for core pipeline. Also supports Claude Code, Cursor, and Grok exports.

value: Show HN: MyChatArchive – bring your full ChatGPT history into Claude via MCP


value: benvan

value:
Hey HN! I built a thing and I'm really excited to share it.
EDIT: I meant to link to the github, not the website:
https://github.com/max-hq/max
Like many of us here, I've been commonly reaching for a pattern of "pull data into db; give it to claude" for a while, whilst doing data spelunking or building tooling - for the same reasons mentioned by thellimist over here [1] and a few other recent "CLI vs MCP" posts.
To that end, about a month ago I started building a project called `max` -  its goal is to cut the middleman and schematise any data source for you. Essentially, provide a lingua-franca for synchronising and searching data.
In short: Max exposes a CLI for any given data source, and mirrors it locally. As in, puts that data right next to the agent. It means search is local and fast, and ready for cut, sed, grep, sort etc.
More concretely:
> max connect @max/connector-gmail --name gmail-1
> max sync gmail-1
> # show me what data i can search for
> max schema @max/conector-gmail
> # do a search
> max search gmail-1 --filter"subject ~= Apples" --fields=subject,from,time
I've built a few connectors over at `max-hq/max-connectors` - but the goal is that they're easy to create (sync is done via graph walk - max makes you provide field resolution so it can figure out how to sync).
In practice - I've found that telling claude to run "max -g llm-bootstrap" to get acquainted, and then "make a connector for X" also works pretty well :).
There's a lot still to come(!) - realtime, somewhere to host connectors, exposing and serving max nodes... I'll be updating the roadmap over the next couple of days - but I didn't want to wait any longer before sharing here.
(on that note - max is designed for federation. The core is platform agnostic)
In terms of what this approach makes possible - I ran a benchmark on a challenge (it's the one on the website) asking claude to find me names of a particular form from a fairly chunky hubspot (100k contacts). The metrics are roughly what you'd expect from putting the data local and avoiding any tokens hitting claude's context window:
MCP: 18M tokens | 80m time | $180 cost
Max: 238 tokens | 27s time | $0.003 cost
(I'll explain how these numbers were calculated in a new reply)
It's still early (alpha) but if you're building agents or just want local data, please try it and tell me what breaks.
Thanks!
[1] https://news.ycombinator.com/item?id=47157398

value: Show HN: Max – a federated data query layer for AI agents (and humans)

author: benvan


value: grindlemire

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

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

author: grindlemire


value: josephwegner

value: Show HN: Not All Agents – convince a room of agents that you're one of them

author: josephwegner


value:
This is a Rust/Python research stack with internet access, focused on reproducible experiments through voice conversations.
We wanted to build something that would give everyone a free, local, and customizable 20th-century Bell Labs on their computer.
The platform combines ZeroClaw (Rust runtime) for orchestration and tool policies, James Library (original research articles/prototypes) for sessions and experiments, and a security-first agent model that treats external text as untrusted.
The goal is simple: go from idea to experiment to artifact, without black boxes, and more customizable than most cloud-based multi-agent platforms.
For reference, we’ve been using this daily for a few years as an R&D branch for Vers3Dynamics, and recently decided to open-source it.

value: Show HN: A local, multi-agent, customizable stack built for researchers


value:
I wrote a programming language for extending AI agents, called Mog. It's like a statically typed Lua.
Most AI agents have trouble enforcing their normal permissions in plugins and hooks, since they're external scripts.
Mog's capability system gives the agent full control over I/O, so it can enforce whatever permissions it wants in the Mog code. This is even true if the plugin wants to run bash -- the agent can check each bash command the Mog code emits using the exact same predicate it uses for the LLM's direct bash tool.
Mog is a statically typed, compiled, memory-safe language, with native async support, minimal syntax, and its own compiler written in Rust and its own runtime, also written in Rust, with `extern "C"` so the runtime can easily be embedded in agents written in different languages.
It's designed to be written by LLMs. Its syntax is familiar, it minimizes foot-guns, and its full spec fits in a 3200-token file.
The language is quite new, so no hard security guarantees are claimed at present. Contributions welcome!

value: Show HN: Mog, a programming language for AI agents


value: Show HN: What Is AI Citation Optimization?


value: rohansx

value:
CloakPipe is a small Rust proxy that sits between your application and any OpenAI-compatible API.
It detects sensitive entities in requests, replaces them with consistent pseudonyms, forwards the sanitized request to the LLM provider, then rehydrates the response before returning it to your app.
“Consistent” means the same input always maps to the same token (e.g. "Tata Motors" → "ORG_7"). This preserves semantic structure so embeddings and retrieval still work, while ensuring the API provider never sees the real entity values.
The motivation came from looking at typical RAG architectures. A standard pipeline leaks data in multiple places per query:
- Raw document text sent to embedding APIs
- Embeddings stored in cloud vector databases (recent work like Zero2Text shows they can be inverted)
- Query embeddings sent to providers
- Retrieved context sent to LLM generation APIs
Existing approaches tend to fall into three buckets:
- Redaction ([REDACTED]) which destroys semantic meaning and breaks retrieval
- NER-based detection pipelines that add significant latency
- Stateless replacements that break vector search because tokens change between requests
CloakPipe tries to solve this by doing deterministic pseudonymization with a local mapping vault.
Some implementation details:
- Written in Rust as a single binary
- <5ms overhead per request in testing
- AES-256-GCM encrypted mapping vault with zeroize memory safety
- OpenAI-compatible proxy endpoints (`/v1/chat/completions`, `/v1/embeddings`)
- Streaming response rehydration (handles tokens split across SSE chunks)
- Pattern detection for API keys, JWTs, emails, IPs, financial amounts, fiscal dates
- Custom detection rules via TOML config
It's designed to be drop-in: point your client to the proxy by changing `OPENAI_BASE_URL`.
Repo:
https://github.com/rohansx/cloakpipe

value: Show HN: CloakPipe – Rust privacy proxy for LLM APIs with pseudonymization

author: rohansx


value: joshuamanton

value:
Hi HN,
I'm one of the engine programmers at All Out Games (https://allout.game/), a multiplayer-first gaming UGC platform where creators can make and play games with their friends. For scripting we wanted our creators to be able to jump in and create game mechanics without having to think about networking. If a developer had to manually send packets to/from client/server to get things to happen then we have failed. It is particularly bad if you are using AI tools because they struggle to keep in mind what code is meant to run where (client, server, or both) and remembering to manually sync pieces of data when needed.
To this end, in our networking layer the server will automatically send binary diffs of its game state to all the clients every few frames; then clients would roll back their game state to the last "server-approved" game state, apply the diffs, then resimulate forward to get back to the future. The client never has to ask the server for permission, it can just do whatever action and if it turns out that action was invalid (maybe your character got stunned by another player and your client didn't know it yet) it would automatically be corrected on receipt of a game state update from the server. In delay-based netcode you would have to make every little feature be rollback/resimmable to get this behavior, but we just rollback/resim everything all the time so you don't have to think about it. The engine allocates one large block of memory from the OS for the game state and we have custom heap and arena allocators to divvy that chunk up.
The main requirement here is that the we have to be in control of the memory, and it has to be easily diffable. We can't be manually traversing trees of objects individually allocated from the OS, jumping through tons of pointers. In fact pointers are especially bad because of ASLR; the address space of the server differs from that of the client, so pointers have to be manually patched after applying game state diffs. We also want the language to be typesafe, and it has to be able to run interpreted because on iOS you aren't allowed to download code and run it (again, we are a UGC platform so downloading and running games is what we do) unless it is interpreted.
For these reasons, all the usual scripting languages are out of the running. Maybe there is one out there that satisfies our needs but I couldn't find one. So, I made a custom scripting language. There are tons of other cool things I was able to do because I was making the language for this specific use-case, and I'd like to go into those in a blog post or something in the future.
If you want to try it out visit https://allout.game/create and use code `KHNGJP` to download the All Out Editor. We can also add you to the #game-devs channel in our Discord (https://discord.gg/QCFVZP99) where you can have direct access to the team and other creators, DM me (shwa) for access.

value: Show HN: I built the first scripting language for multiplayer game dev

author: joshuamanton


value: ycmatt

value:
I've been using Claude Code and Codex daily and kept losing track of which conversation was doing what across projects. So I built Claudine — a VS Code extension that reads your agent session files and renders them as a live kanban board.
It auto-detects status, category, git branch, and error state. Everything syncs in real time, is searchable and drag-and-droppable. Cmd+Shift+K to open.
No config, no backend, no accounts. It just reads the local session files your agents already produce.
Open source, MIT licensed. Would love feedback — especially on what other agents you'd want supported.

value: Show HN: Claudine – A Kanban board for your Claude Code and Codex conversations

author: ycmatt


value:
I built a Chrome extension that evaluates AI chatbot responses across 5 dimensions: Emotion (tone fit), Fact (verifiability), Narrative (structure), Depth (explains WHY vs just WHAT), and Bias (directional framing).
One click next to any ChatGPT or Gemini response → 2 seconds → full quality profile with a Balance score (STABLE/DRIFTING/DOM).
Some results that surprised me:
- "How are you?" → DRIFTING. High emotion, zero facts, zero depth.
- "Why don't antibiotics work on viruses?" → STABLE, Fact=0.95, Depth=0.75
- Persuasive prompts → Bias=+0.72. The model doesn't pretend to be neutral.
- Philosophical answers → Fact=0.40 even with citations. Citing Kant doesn't make unfalsifiable claims verifiable.
The Fact axis uses a 3-step calibration: classify the question as falsifiable or not → apply a ceiling → score within it. This transfers across models at r=0.96.
Interesting negative finding: RLHF-trained models compensate for shallow prompts by adding unsolicited explanations. The Depth axis rubric works (5/5 on controlled responses) but in practice models over-explain everything.
Stack: Manifest V3, vanilla JS, Gemini Flash API as judge, Balance computed client-side. Uses your own API key, no data stored.
Research paper with full methodology and 100-prompt validation available on request.

value: Show HN: Tri·TFM Lens – 5-axis quality evaluation for ChatGPT/Gemini responses


value: powerwild

value:
Hi HN,
I built VaultNote, a local-first note-taking app that runs entirely in the browser.
Key ideas:
- 100% local-first: no backend or server
- No login, accounts, or tracking
- Notes stored locally in IndexedDB / LocalStorage
- AES encryption with a single master password
- Tree-structured notes for organizing knowledge
The goal was to create a simple note app where your data never leaves your device. You can open the site, enter a master password, and start writing immediately.
Since everything is stored locally, VaultNote also supports import/export so you can back up your data.
Curious to hear feedback from the HN community, especially on:
- the security approach (local AES encryption)
- IndexedDB storage design
- local-first UX tradeoffs
Demo: https://vaultnote.saposs.com
Thanks!

value: Show HN: VaultNote – Local-first encrypted note-taking in the browser

author: powerwild


value: bkapu

value:
Free, open-source rental property investment calculator. FastAPI backend (~1K lines) serves a single vanilla HTML/CSS/JS file (~2.8K lines) — no frameworks, no build step.
Calculates Cash-on-Cash, Cap Rate, DSCR, NOI, GRM, Break-Even Occupancy, and more. 14-point deal scorecard grades each metric individually. 5-year total return projection breaks down Cash Flow + Appreciation + Debt Paydown + Tax Benefits. Strategy fit analysis for Cash Flow / Wealth Building / Low Risk / BRRRR.
Optional AI analysis via LM Studio (free, local, GPU), Ollama (free, local), or Anthropic Claude (paid). Streaming responses via SSE with real-time filtering of thinking-model artifacts.
Zillow scraping with 4 extraction strategies for their __NEXT_DATA__ JSON + Playwright headless fallback when httpx gets blocked.
Save/compare scenarios, export PDF + HTML. MIT license.
Source: https://github.com/berkcankapusuzoglu/Rental-Property-Deal-A...

value: Show HN: Rental Property Deal Analyzer – 20 metrics, deal scoring, AI analysis

author: bkapu


value: kenandervisagic

value:
Hi HN,
I built Aporium AI, a study platform based on the Socratic method.
The idea came from my own frustration while studying. I used to highlight entire textbooks and feel productive, but when exam time came I often realized I hadn’t actually understood much.
The Socratic method - guiding someone with questions instead of giving answers has been used for over 2,000 years. I wondered what it would look like if an AI tutor used the same approach.
So I built Aporium.
How it works:
• Upload your notes or PDFs
• Generate quizzes and flashcards from specific pages
• Chat with an AI tutor that asks guiding questions instead of giving answers
• Track progress with learning statistics
One thing I focused on was keeping everything tied to the student’s own materials. The quizzes, flashcards, and discussions come directly from the uploaded notes so they stay relevant to the class.
The AI can also adapt to different academic levels (elementary → high school → college → postgrad).
It’s still early and actively evolving, so I’d really appreciate feedback from the HN community.
Curious about:
- Would you have found something like this useful while studying?
- Are there features you’d expect from a tool like this?
- Any concerns about using AI for learning?

value: Show HN: Aporium AI – a study app that refuses to give you answers

author: kenandervisagic


value: rosennn

value:
I recently shared this on reddit and it got 500 upvotes so I thought I’d share it here as well, hoping it helps more people.
Every time I launch a new product, I go through the same annoying routine: Googling “SaaS directories,” digging up 5-year-old blog posts, and piecing together a messy spreadsheet of where to submit. It’s frustrating and time-consuming.
For those who don’t know launch directories are websites where new products and startups get listed and showcased to an audience actively looking for new tools and solutions. They’re like curated marketplaces or hubs for discovery, not just random link dumps.
It’s annoying to find a good list, so I finally sat down and built a proper list of launch directories: sites like Product Hunt, BetaList, StartupBase, etc. Ended up with 82 legit ones.
I also added a way to sort them by DR (Domain Rating) basically a metric (from tools like Ahrefs) that estimates how strong a website’s backlink profile is. Higher DR usually means the site has more authority and might pass more SEO value or get more organic traffic.
I turned it into a simple site: launchdirectories.com
No fluff, no paywall, no signups just the list I wish I had every time I launch something.
Thought it might help others here too.

value: Show HN: I made a free list of 100 places where you can promote your app

author: rosennn


value: Show HN: Film Finder – Solving decision paralysis and fatigue


value: owen-orlov

value: Show HN: Serde.zig - Format-agnostic serialization for Zig using comptime

author: owen-orlov


value: qixxiq

value: Show HN: Sandclaw – A Safety First Agent

author: qixxiq


value: Brzzy

value: Show HN: I built a browser-based Lemonade Tycoon game in 20 minutes

author: Brzzy


value:
I built this because I was running Claude Code, a local LLM, and multiple
dev servers simultaneously and had no visibility into what was actually
happening. Activity Monitor is useless for this. htop has no context.
Hydra is a macOS desktop app (Electron + React + TypeScript) that shows:
- Which AI agents are running (Claude Code, Codex, Cursor, Gemini) and
  their status
- Per-process CPU/memory with project grouping
- Port-to-process mapping
- Git repo health across all your projects
- Network bandwidth per process
- Security posture via a built-in scanner
- AI briefings from a local LLM (I use LM Studio with Qwen 35B) —
  no cloud API needed
- Claude Code usage and cost tracking
Everything runs locally. No telemetry, no accounts, no cloud dependency.
GitHub: https://github.com/kunalnano/hydra
Happy to answer questions about the architecture or the local LLM
integration approach.

value: Show HN: Hydra – Real-time ops dashboard for developers running AI agents


value: gsteezy

value:
I built Mantle because I wanted homerow mods and layers on my laptop without hand writing Lisp syntax.
The best keyboard remapping engine on macOS (Kanata) requires editing .kbd files which is a pain. Karabiner-Elements is easy for simple single key remapping (e.g. caps -> esc), but anything more wasn’t workin out for me.
What you can do with Mantle:
- Layers: hold a key to switch to a different layout (navigation, numpad, media)
- Homerow mods: map Shift, Control, Option, Command to your home row keys when held
- Tap-hold: one key does two things: tap for a letter, hold for a modifier
- Import/export: bring existing Kanata .kbd configs or start fresh visually
Runs entirely on your Mac. No internet, no accounts. Free and MIT licensed
Would love feedback, especially from people who tried Kanata or Karabiner and gave up

value: Show HN: Mantle – Remap your Mac keyboard without editing Kanata config files

author: gsteezy


value:
Hi HN,
I’ve been experimenting with building LLM agents and kept running into the same problem: managing context gets messy quickly. Prompts grow, reasoning steps get lost, and it's hard to reproduce or roll back agent behavior.
So I built Contexa, a small open-source project that treats LLM context a bit like Git — with ideas like snapshots, branching, and history for context.
The goal is to make it easier to:
track how context evolves
experiment with different reasoning paths
reproduce agent behavior
It’s still early, but I’d love feedback from people building LLM tools.
Repo: https://github.com/swadhinbiswas/contexa
Paper: https://arxiv.org/abs/2508.00031

value: Show HN: Contexa – Git-inspired context management for LLM agents


value: smith-kyle

value: Show HN: Remotely use my guitar tuner

author: smith-kyle

title: Show HN: Remotely use my guitar tuner


value: TheTrueObelus

value:
I built this after realizing that that single-model AI code review currently has obvious blind spots. The idea: chat with a Lead AI about your project, then "convene the Council" — three other models independently review everything in parallel, and the Lead synthesizes findings into structured categories: consensus, majority positions, lone warnings, and dissent.
The surprising insight from building and using it: the value isn't consensus, it's structured disagreement. When Grok catches a temporal data mismatch that three other models missed, or Claude spots an imported function that's never called — that's where the Council is useful.
Each model has genuine strengths: Claude tends toward architecture, Grok goes deep on data flows, ChatGPT catches API/integration issues, Gemini thinks about product gaps.
Stack: FastAPI, HTMX, OpenRouter as a unified API gateway. BYOK via OpenRouter so one key covers all four models — a typical review runs about 25 cents. Free tier gives you 1 review to try it.
Perplexity just launched "Model Council" as part of their $200/month Computer product — same core mechanic. This is the open-source, bring-your-own-key version.
GitHub: https://github.com/scifi-signals/council-of-alignment
Live: https://council.stardreamgames.com
Constructive feedback would be much appreciated!

value: Show HN: Open-source multi-model code review council (BYOK, free tier)

author: TheTrueObelus


value: LLMs are better at being the "mouth" than the "brain" and I can prove it mathematically. I built a deterministic graph engine that offloads reasoning from the LLM. It reduces token usage by 89% and makes a tiny 0.8B model trace enterprise execution paths flawlessly. Here is the white paper and the reproducible benchmark.

value: Show HN: Graph-Oriented Generation – Beating RAG for Codebases by 89%


value: diddddy

value: Most model posts focus on benchmarks, but the thing I care about is simpler: does it actually cut retries on real work. Curious whether others are seeing that with GPT-5.4, especially on coding and longer tool heavy tasks...

value: Show HN: GPT-5.4 is interesting for one boring reason: fewer retries

author: diddddy


value: ahmgeek

value:
You can also find the web platform on https://voklit.com
The rates are pretty cheap, and the HD voice calls are outstanding, if you have any question please let me know

value: Show HN: I built an international calling platform/Android App

author: ahmgeek


value: ujjwalvivek

value:
I revived an old project of mine called Synclippy.
It creates ephemeral 3-word rooms where you can drop text or files and share them across devices. Rooms live for 5 minutes and everything stays in memory.
I mainly use it as a quick way to move snippets or small files between my machines without installing anything, along with Taildrop.
I originally built it for my own workflows, but figured I’d open source it in case others find it useful too.
Demo:
https://synclippy.ujjwalvivek.com
Repo:
https://github.com/ujjwalvivek/synclippy
Self-host preferred (Docker or single Go binary).
Curious if anyone finds it useful or if has ideas for improving it.

value: Show HN: Synclippy – Ephemeral rooms for sharing text or files

author: ujjwalvivek


value: splch

value: I built an n8n integration for Anytype, the local-first encrypted PKM app. It supports full CRUD on objects and spaces plus raw API requests for anything custom. Verified by n8n, so it installs directly from the nodes panel!<p>Anytype's API is relatively new, so this is one of the first automation integrations available for it. If you use both n8n and Anytype (or are curious about either), I'd love to hear what workflows you'd want to build.

value: Show HN: Verified n8n community node for Anytype

author: splch


value: KhazP

value: This website lets you see your money in bills, metals or crypto in a 3D environment in your browser.

value: Show HN: See Your Money in 3D

author: KhazP

title: Show HN: See Your Money in 3D


value: benfosterdev

value:
I subscribe to about 30 newsletters to stay "on top of things". I read maybe 3.
They started to fill up my inbox so I did the responsible thing and created a rule that moved them to a dedicated folder "Newsletters". Now I don't read any.
It dawned on me that I'm far more likely to listen to a podcast than read a newsletter. What if I could take all those unread newsletters and turn them into my own personal podcast?
So I built Unread. You forward your newsletters to a unique address, and turn them into a conversational podcast episode covering everything you didn't read. You subscribe to the RSS feed in whatever podcast app you already use.
It was a fun project to build (you can get more details at https://x.com/benfosterdev). Some of the more interesting technical pieces:
- Postmark for incoming emails
- Cloudflare for hosting everything - really enjoyed their durable workflow framework
- Supabase for DB and Auth
- React frontend
- Claude for content extraction, synthesising, research and script writing
- Google Gemini TTS for generating audio (nice support for SSML)
I started with ElevenLabs for TTS. It was great and pretty realistic but way too expensive. OpenAI TTS was okay, but barely. Gemini 2.5 TTS hit the quality/price point on the mark (listen for yourself) and has enough control that you can create conversational sounding content instead of two robots talking in a vacuum.
There's still a lot of refinement to be done on the script/audio side of things to make it more engaging and human-like but I'm already using it daily to get my tech updates.
Next important feature will be to schedule episode creation.
You get 5 free episode credits on sign up. Feedback appreciated.

value: Show HN: Unread, turns your unread newsletters into a daily podcast

author: benfosterdev


value: onlydole

value: Show HN: How to Catch Documentation Drift with Claude Code and GitHub Actions

author: onlydole


value: formreply

value:
Auto-Co is an autonomous AI company OS — not a framework you build on, but a running system with an opinionated structure.
Architecture:
- 14 agents with expert personas (CEO/Bezos, CTO/Vogels, CFO/Campbell, Critic/Munger...)
- Bash loop + Claude Code CLI — no custom inference, no vector stores
- Shared markdown consensus file as the cross-cycle relay baton
- Human escalation via Telegram for true blockers only (2 escalations in 12 cycles)
- Every cycle must produce artifacts: code, deployments, docs
The repo IS the live company. It built its own landing page, README, Docker stack, GitHub release, and community posts — all autonomously across 12 cycles of self-improvement.
What makes it different from AutoGen/CrewAI/LangGraph: those are building blocks. Auto-Co is the building. The decision hierarchy, safety guardrails, and convergence rules are baked in. You give it a mission and a Claude API key; it runs.
The Critic agent (Munger persona) has been the most valuable: it runs a pre-mortem before every major decision and has killed several bad ideas before they got built.
Stack: Bash + claude CLI + Node.js + Next.js + Railway + Supabase. Deliberately boring.

value: Show HN: Auto-Co – 14 AI agents that run a startup autonomously (open source)

author: formreply


value: mordymoop

value:
PlateSpinner is a local web app that manages AI coding agents through a kanban board. You point it at a project directory, describe what you want, and it spawns headless Claude Code / Codex / Gemini sessions to generate tasks, plan implementations, and write code.
The workflow is: Propose → Plan → Execute. Generation and planning run in read-only mode. Execution gets full write access, creates branches, commits changes, and captures diffs for review. There's also an "autoclicker" mode where an AI judge continuously decides what to do next, propose, plan, or execute, so you can just watch.
Built with React + Express + WebSocket. It doesn't call any cloud APIs directly — it shells out to the CLI tools the same way you would from a terminal.

value: Show HN: PlateSpinner – A Kanban board that orchestrates AI coding agents

author: mordymoop


value: lukascodes

value:
Hi HN,
We are working on a civilian AI night vision system.
It’s a rugged digital night vision device that uses AI image enhancement to improve visibility in low-light environments.
One feature we are experimenting with is connecting it with a drone so the drone’s camera feed can be transmitted directly into the night vision device.
The idea is to extend situational awareness at night without using traditional analog night vision.
We are preparing a crowdfunding campaign and would really appreciate feedback from the community.
What features would you consider most useful in a system like this?

value: Show HN: An AI-powered digital night vision system with drone video feed

author: lukascodes


value:
I kept breaking my workflow to translate foreign text — copy, open browser, paste into
  translator, read, switch back. Repeat.

  So I built a macOS menu bar app that translates right where you're working.

  Two modes:
  - Select text in any app → Cmd+Option+Z → instant translation
  - Cmd+Shift+T → drag over any area → OCR + translate (images, PDFs, subtitles)

  Everything runs on-device via Apple Vision + Apple Translation. No servers, no tracking. Free
  forever.

  20 languages · offline capable · GPL-3.0

value: Show HN: ScreenTranslate – On-device screen translator for macOS (open source)


value: mhalifax

value:
Basically, my daughter is 11, and I’ve been trying to stay engaged with her studies at school. We all know that modern schools don’t pay much attention to financial literacy. When I was in school, it was the same. I self-studied economics, and though I wasn’t sure why at the time, it ended up helping me a lot in life. These days, most kids don’t know what inflation is, what compound interest means, what a mortgage is, or how banks work.
I’m a software developer, so I started thinking about how I could help solve this problem, especially with all the AI advancements happening now. I wanted to build something fun and interactive for the modern TikTok generation. Working on this with my daughter, we figured out that the best approach would be to create a small AI-generated e-book or physical book, featuring a child’s unique picture that is relevant to the topic covered, and a one-page summary per topic. Honestly, I don’t think kids can focus on more than one page at a time these days.
I tested dozens of AI image generation tools and believe I’ve found the best one. At least, my daughter loves the product and has learned a lot of new financial concepts along the way. I think I’ve built it to the point where I can show it to the world , and I need more people to actually test it and give me their feedback and opinions , especially on image quality.
Of course, we’d eventually like to make some money from it, especially after spending about a month of my time on it and with each API call costing us a bit. But for now, you can upload your child photo and generate three pages for free and give us your valuable feedback which we’d truly appreciate.

value: Show HN: Personalized financial literacy book for your kid

author: mhalifax


value: protortyp

value:
Built this with codex/claude because I missed gTile[1] from Ubuntu and couldn’t find a macOS tiler that felt good on a big ultrawide screen. Most mac options I tried were way too rigid for my workflow (fixed layouts, etc) or wanted a monthly subscription. gTile’s "pick your own grid sizes + keyboard flow" is exactly what I wanted and used for years.
Still rough in places and not full parity, but very usable now and I run it daily at work (forced mac life).
[1]: https://github.com/gTile/gTile

value: Show HN: mTile – native macOS window tiler inspired by gTile

author: protortyp


value: Show HN: Speclint – OS spec linter for AI coding agents


value:
Hi HN,
I built OculOS because giving AI agents (like Claude Code or Cursor) control over desktop apps is still surprisingly difficult. Most current solutions rely on slow OCR/Vision or fragile pixel coordinates.
OculOS is a lightweight daemon written in Rust that reads the OS accessibility tree and exposes every button, text field, and menu item as a structured JSON API and MCP server.
Why this is different:
Semantic Control: No screenshots or coordinates. The agent interacts with actual UI elements (e.g., "Click the 'Play' button").
Rust-powered: Single binary, zero dependencies, and extremely low latency.
Universal: Supports Windows (UIA), macOS (AXUIElement), and Linux (AT-SPI2).
Local & Private: Everything runs on your machine; no UI data is sent to the cloud.
It also includes a built-in dashboard for element inspection and an automation recorder. I’m looking forward to your feedback and technical questions!

value: Show HN: OculOS – Give AI agents control of your desktop via MCP


value: arcivanov

value: Show HN: BLOBs in MariaDB's Memory Engine – No More Disk Spills for Temp Tables

author: arcivanov


value: whilo

value: Show HN: Stratum - a pure JVM columnar SQL engine using the Java Vector API

author: whilo


value: verivusai

value:
I built sqry, a local code search tool that works at the semantic level rather
than the text level.
The motivation: ripgrep is great for finding strings, but it can't tell you
"who calls this function", "what does this function call", or "find all public
async functions that return Result". Those questions require understanding code
structure, not just matching patterns.
sqry parses your code into an AST using tree-sitter, builds a unified call/
import/dependency graph, and lets you query it:

  sqry query "callers:authenticate"
  sqry query "kind:function AND visibility:public AND lang:rust"
  sqry graph trace-path main handle_request
  sqry cycles
  sqry ask "find all error handling functions"

The `sqry ask` command translates natural language into sqry query syntax
locally, using a compact 22M-parameter model with no network calls.
Some things that might be interesting to HN:
- 35 language plugins via tree-sitter (C, Rust, Go, Python, TypeScript, Java,
  SQL, Terraform, and more)
- Cross-language edge detection: FFI linking (Rust↔C/C++), HTTP route matching
  (JS/TS↔Python/Java/Go)
- 33-tool MCP server so AI assistants get exact call graph data instead of
  relying on embedding similarity
- Arena-based graph with CSR storage; indexed queries run ~4ms warm
- Cycle detection, dead code analysis, semantic diff between git refs
It's MIT-licensed and builds from source with Rust 1.90+. Fair warning: full
build takes ~20 GB disk because 35 tree-sitter grammars compile from source.
Repo: https://github.com/verivusai-labs/sqry
Docs: https://sqry.dev
Happy to answer questions about the architecture, the NL translation approach,
or the cross-language detection.

value: Show HN: Sqry – semantic code search using AST and call graphs

author: verivusai


value: EmptyDrum

value:
I think in-process key management is the right abstraction for multi-key LLM setups. Not LiteLLM, not a Redis queue, not a custom load balancer.<p>The failure modes are well-understood: a key gets rate-limited, you wait, you try the next one. Billing errors need a longer cooldown than rate limits. This is not a distributed systems problem — it's a state machine that fits in a library.
The problem is everyone keeps solving it with infrastructure instead. Spin up LiteLLM, now you have a Python service to maintain. Reach for Redis, now you have a database for a problem that doesn't need one.
key-carousel manages a pool of API key profiles with exponential-backoff cooldowns: 1min → 5min → 25min → 1hr for rate limits, 5hr → 24hr for billing. Falls back to OpenAI or Gemini when Anthropic keys are exhausted. Optional file persistence. Zero dependencies.

value: Show HN: key-carousel - Key rotation for LLM agents

author: EmptyDrum


value: gangtao

value: Show HN: Stream-native AI that never sleeps, an alternative to OpenClaw

author: gangtao


value: delduca

value: Show HN: I open-sourced my Steam game, 100% written in Lua, engine is also open

author: delduca


value:
I built this after spending too much time looking for places to submit a project online.
The directory currently has 1000+ sites, all intended to be free submission opportunities, with search and category tags for things like launch sites, AI directories, review sites, and communities.
I’d be interested in feedback, especially around signal vs noise and how to keep something like this genuinely useful.
https://kitful.ai/directories

value: Show HN: I created list of directories (1000) to create free backlinks


value: muralibasani

value:
I've been working on an open-source Kafka topology tool called StreamLens and just added a new feature: natural language queries for Prometheus Kafka metrics.
Many Kafka clusters expose metrics through Prometheus, but troubleshooting usually still requires remembering metric names and navigating multiple dashboards.
In this update, StreamLens can ingest a small set of important metrics and make them queryable through the built-in AI chat panel.
Example:
Prometheus metric
under_replicated_partitions
Instead of searching dashboards, you can ask:
“How many partitions are not fully in sync with replicas?”
The assistant maps the question to the relevant metric and returns the value.
Prometheus metrics are also now used for producer detection, which helps identify active producers in environments where JMX is not available (for example managed Kafka services).
The goal is to make Kafka troubleshooting more conversational — asking questions about cluster health instead of searching across multiple monitoring tools.
Repo:
https://github.com/muralibasani/streamlens
Would be interested in feedback from people running Kafka clusters on:
- which metrics are most useful during incidents
- whether natural language queries for metrics are actually helpful
- other Prometheus metrics worth integrating

value: Show HN: Natural language queries for Prometheus Kafka metrics (StreamLens)

author: muralibasani


value: yuriksan

value:
Netrek is a multiplayer space battle game from 1988–89, widely considered the first Internet team game. It predates commercial online gaming by years, ran passionate leagues for decades, and is still technically alive — but getting a server up has always required real effort, and there’s been no easy way to just play it in a browser.
NeoNetrek is my attempt to change that:
Server: Based on the original vanilla Netrek C server, modernized with simpler configuration and containerized for one-command cloud deployment. There are ready-made templates for Fly.io and Railway, and public servers already running in LAX, IAD, NRT, and LHR. Anyone can self-host using the deploy templates in the GitHub org.
Client: A new 3D browser-based client — no downloads, no plugins, connects via WebSocket. I built it starting from Andrew Sillers’ html5-netrek (github.com/apsillers/html5-netrek) as a foundation and took it in a new direction with 3D rendering.
Site: neonetrek.com covers lore, factions, ship classes, ranks, and an Academy to ease the notoriously steep learning curve.
A significant portion of the code and content was developed with Claude as a coding partner, which felt fitting for a project about preserving internet history.
GitHub org: https://github.com/neonetrek
Play now: https://neonetrek.com

value: Show HN: NeoNetrek – modernizing the internet's first team game (1988)

author: yuriksan


value: knewter

value: Show HN: Sheila, an AI agent that replaced our accounting flow

author: knewter


value: Show HN: Ovumcy – self-hosted menstrual cycle tracker


value:
A few months ago I shared the first issue of The Lydian Stone Series here:
https://news.ycombinator.com/item?id=44253083
It's an alternate-history comic about an archaeology student in modern Pompeii who discovers a slate that lets him exchange short messages with a Roman slave a week before the eruption of Vesuvius.
The premise is simple: what happens if someone in the Roman world suddenly gains access to modern scientific knowledge, but still has to build everything using the materials and tools available in 79 AD?
Volume 2 (The Engine of Empire) explores the second-order effects of that idea.
About the process: I write the story, research, structure, and dialogue. The narrative is planned first (acts → scenes → pages → panels). Once a panel is defined, I write a detailed visual description (camera angle, posture, lighting, environment, etc.).
LLMs help turn those descriptions into prompts, and image models generate sketches. I usually generate many variations and manually select or combine the ones that best match the panel.
The bulk of the work is in the narrative design, historical research, and building a plausible technological path the Romans could realistically follow. The AI mostly acts as a sketching assistant.
I'd love feedback on the story direction, pacing, and whether the industrial shift feels believable.

value: Show HN: The Roman Industrial Revolution that could have been (Vol 2)


value: chasemetoyer

value:
Hi HN,
I’ve been building a Rust-first backtesting engine for limit order book strategies and just open sourced the core engine.
Repo:
https://github.com/chasemetoyer/Backtesting-Engine
The goal was to build something closer to how exchanges actually behave than typical OHLC-based backtesting frameworks.
Key features:
• L3 limit order book replay
• deterministic event-driven matching engine
• FIFO queue position modeling
• Python strategy bindings for research workflows
• parquet ingestion for high-volume datasets
• replay trace tools for debugging strategy behavior
The core engine is written in Rust and exposed to Python via maturin. The idea is to combine Rust performance with Python-based research workflows.
Typical workflow:
1) Convert raw exchange data (ex: CoinAPI LIMITBOOK files) into canonical engine parquet
2) Run deterministic replay through the Rust engine
3) Execute strategies through Python bindings
4) analyze fills, equity curves, and risk metrics
The repo currently includes several example microstructure strategies such as:
• queue imbalance scalper
• flow microprice scalper
• cumulative flow momentum
I built this mainly to experiment with order book strategies where queue position and microstructure actually matter.
Would love feedback from people working on:
• market microstructure research
• HFT simulation
• Rust systems engineering
• trading infrastructure
Especially interested in ideas for improving:
• event replay throughput
• strategy interface design
• multi-asset simulation
Thanks!

value: Show HN: Rust-First L3 Limit Order Book Backtesting Engine with Python Bindings

author: chasemetoyer


value: everlier

value: Show HN: OpenGuard

author: everlier

title: Show HN: OpenGuard


value: Shmungus

value:
- llm-stream — streaming from OpenAI + Anthropic, callback-based
- llm-cache — file-backed semantic cache, LRU eviction
- llm-cost — offline token counting + cost estimation
- llm-retry — exponential backoff + circuit breaker + provider failover
- llm-format — structured output enforcer with hand-rolled JSON parser
Drop in one .hpp, link libcurl, done. No nlohmann, no boost, no Python.
https://github.com/Mattbusel/llm-stream
https://github.com/Mattbusel/llm-cache
https://github.com/Mattbusel/llm-cost
https://github.com/Mattbusel/llm-retry
https://github.com/Mattbusel/llm-format

value: Show HN: Single-header C++ libraries for LLM APIs – zero deps beyond libcurl

author: Shmungus


value: rogergrubb

value:
Been shipping agent systems for a while and kept running into the same wall - once an agent's deployed, you're basically flying blind. No way to prove what it did, no automatic killswitch if it goes sideways, nothing.
Built MultiPowerAI to fix that. The core stuff: cryptographic identity per agent, behavioral circuit breakers that auto-suspend if something looks off, human approval queues before high-stakes actions, and a full audit trail so every action is signed and timestamped.
Also threw in a skills marketplace (agents can buy/sell capabilities, sellers keep 80%) and a consensus API that hits Claude + GPT + Gemini + DeepSeek in one call - useful when you need more than one model's opinion on something.
Free tier if you want to poke at it. Mostly curious what accountability problems other people are running into - happy to compare notes.

value: Show HN: MultiPowerAI – Trust and accountability infrastructure for AI agents

author: rogergrubb


value: nonstopnonsense

value:
I am a 40+-year-old-slightly-techie-middle-aged-man who occasionally writes code to make life easier. I was a developer once - a very long time ago. I am an Engineer by degree and my instinct goes for solution. I work in tech - but on the "_request_ developers what to build" side, not the "actually build it" side. With AI, I am now able to build more.
So I built WebBridge (yes - not so fancy name there). (Well - Claude built it. I directed. Like every PM does.)
What it actually does:
1. You install a Chrome extension
2. You browse to a site you're logged into - your library, your lab results portal, whatever
3. You click Record, do the thing you want to automate, click Stop
4. Claude reads the captured API traffic and generates a permanent MCP server
5. That server works with any MCP client - Claude (Cowork/Code), Cursor, VS Code, Windsurf, Cline, you name it
The whole thing takes about 10 minutes. No code written by you.
This is for non-tech folks who live inside AI providers, who just want to use it and move on. Legal analysts, market researchers, market watchers, marketing and competitive intelligence, and anyone who wants to use a specific website for a specific purpose, repeatedly.
The README has some use cases showcased: "Public Library Search" and "Legal Compliance Auditing."
There may not be an exact equivalent anywhere to what I purpose-built. I'd welcome being proven wrong on that.
Feedback is welcome - that's why I'm posting.

value: Show HN: WebBridge turns any website into MCP tools by recording browser traffic

author: nonstopnonsense


value: devinoldenburg

value:
Hi HN,
I've been working on a project called Kaeso.
The idea started fairly simple: I wanted to explore infrastructure around AI agents. While building it, the concept slowly evolved into something more focused on integrations.
One problem that keeps appearing when building agent systems is connecting them to real services in a structured and secure way. Every system ends up implementing its own integrations with tools like Google, Slack, GitHub, etc.
Kaeso is an attempt to experiment with a unified connection layer where services can be connected once and then accessed by agents through a consistent interface.
While building the project, the original idea changed quite a bit, which I wrote about here:
https://kaeso.ai/blog/redefining-kaeso
The platform is still early, but I'm curious what people here think about the idea of infrastructure specifically designed for AI agents.
Feedback is very welcome.

value: Show HN: Kaeso: an OAuth hub for AI agents

author: devinoldenburg


value: Belsonsan

value:
Hi HN,
I built Habit Online Daily Tracker, a simple Android app for tracking daily habits and staying consistent.
The idea was to create a very straightforward habit tracker with a clean interface and no unnecessary complexity. I wanted something where you can quickly see your habits for the day, mark them as complete, and track your progress over time.
Main features:
- Habit dashboard showing all active habits
- Daily completion tracking and streaks
- Profile with long-term stats
- Customizable notifications and settings
The goal is to make daily progress visible so small habits can compound over time.
I would really appreciate feedback on the UX, features, or anything that could make it more useful.

value: Show HN: A simple habit tracker focused on clarity and consistency

author: Belsonsan


value: Show HN: An OTLP observability plugin for OpenClaw AI agents in Grafana


value:
I kept doing the same thing: copy a string, guess if it's JSON/Base64/URL-encoded, open the right tool, paste. Ten times a day.
So I built PureMark — browser-based dev tools that auto-detect what you paste and process it immediately. No sign-up, no server, everything stays in your browser.
Tools: JSON Formatter, Base64, URL Encoder, Diff Checker, Timestamp Converter.
What makes it different:
- Zero-click: paste and it just works
- Recipe URLs: share formatted results via URL (data in the hash, never sent to a server)
- Chrome extension that auto-detects clipboard format and opens the right tool
- Myers diff implemented from scratch (~130 lines, zero dependencies)
Try it: https://json.puremark.app — paste any JSON.
Would love feedback on the detection algorithm and what tools to add next.

value: Show HN: PureMark – JSON, Base64, Diff tools that never send data to a server


value:
Hi HN,
I've been experimenting with systems built around AI agents recently and ran into a recurring problem: connecting agents to real-world services is still surprisingly fragmented.
Every integration tends to require its own authentication flow, token management, permissions handling, and API logic. After a few integrations the architecture becomes more about maintaining service connections than about the agents themselves.
Because of that I started building a project called Kaeso.
The idea is to explore a unified infrastructure layer where external services can be connected once and then accessed by agents through a structured interface. The goal is to simplify the integration side so developers can focus more on agent logic rather than constantly rebuilding connection layers.
While building it, the original idea actually changed quite a bit, which I wrote about here:
https://kaeso.ai/blog/redefining-kaeso
The project is still early, but I'm interested in hearing how others here approach this problem.
If you're building systems around agents or automation, do you usually implement integrations separately for each project, or do you maintain some kind of shared integration layer?

value: Show HN: Kaeso – infrastructure for connecting AI agents to real services


value: JitseLambrichts

value: Show HN: WTF-CLI – An AI-powered terminal error solver written in Rust

author: JitseLambrichts


value: arbayi

value: Show HN: Agent Office – Slack for (OpenClaw Like) AI Agents

author: arbayi


value: tiansenxu

value: Show HN: A governance pattern for self-evolving AI skills

author: tiansenxu


value: janaksunil

value:
I made an MCP server that plugs into Claude Code and tells you if there are credits or discounts available for tools in your stack.
First version was super spammy - it fired every time you mentioned any tool. Now it only triggers when you're actually evaluating something new. Also working on having it scan your package.json on init so it can flag deals on stuff you're already paying for.
Honest question: would you use this or does it just feel like ads in your IDE?
Would love feedback and to know if this is something you'd actually use.

value: Show HN: MCP server that finds dev tool credits in your workflow

author: janaksunil


value:
I built an MCP server that lets Claude AI instances communicate through a shared message bus. Each instance registers with a name, then they can send messages, create channels, share data, and wait for replies — like a lightweight Slack for AI sessions.
The problem it solves: if you use Claude Code in multiple terminals (or across Claude.ai and Desktop), each session is completely isolated. There's no way for one Claude to ask another for help, delegate work, or coordinate on a shared task.
With Cross-Claude MCP, you can do things like:
- Have a "builder" Claude send code to a "reviewer" Claude and get feedback
- Run parallel Claude sessions on frontend/backend that post status updates to each other
- Let a data analysis Claude share findings with a content writing Claude
Two modes: local (stdio + SQLite, zero config) or remote (HTTP + PostgreSQL for teams/cross-machine). Works with Claude Code, Claude.ai, and Claude Desktop.
~500 lines of JavaScript, MIT licensed.

value: Show HN: Cross-Claude MCP – Let multiple Claude instances talk to each other


value: Zero dependencies. No external databases. Single binary. Just deploy and go. I needed something that would allow for real-time monitoring, and installation is as simple as dropping a single file and running it. That's exactly what Kula is. Kula is the Polish word for "ball," as in "crystal ball." The project is in constant development, but I'm already using it on multiple servers in production. It still has some rough edges and needs to mature, but I wanted to share it with the world now—perhaps someone else will find it useful and be willing to help me develop it by testing or providing feedback. Cheers! Github: https://github.com/c0m4r/kula

value: Show HN: Kula – Lightweight, self-contained Linux server monitoring tool


value:
Hi HN, I built this because when I was considering relocating, I couldn't find a salary comparison tool that went deeper than city-level averages. A $100K salary in "New York" means very different things depending on whether you live in Manhattan or Queens.
What it does: enter your current city, a target city, and your salary. It calculates an equivalent salary adjusted for cost of living, local taxes, rent, and currency exchange — down to the neighborhood level.
Some things that make it different:
3,400+ neighborhoods across 182 cities, not just city averages
Single and family mode (adds childcare, larger apartments)
Side-by-side tax breakdowns by country
67 currencies with real-time conversion
Also has a Retire Abroad calculator for retirement planning
The data comes from a combination of public sources (OECD, local government stats, housing indices) cross-referenced and normalized to a cost-of-living index where New York = 100.
No signup, no paywall, no ads. Would love feedback on the methodology or data accuracy — especially from people who've actually relocated between cities we cover.

value: Show HN: Free salary converter with 3,400 neighborhood comparisons in 182 cities


value:
Hatice polls your issue tracker (Linear or GitHub Issues), spins up isolated workspaces, and dispatches Claude Code agents to solve each issue
  end-to-end — dispatch, multi-turn execution, retry with exponential backoff, reconciliation, and real-time observability.

  Inspired by OpenAI's "Harness Engineering" manifesto and Symphony (Elixir/OTP), rebuilt from scratch in TypeScript with the Claude Code Agent
  SDK.

  Key differences from Symphony:
  - GitHub Issues support (not just Linear)
  - SSE real-time dashboard (no WebSocket dependency)
  - Per-session cost tracking in USD
  - Fine-grained tool control (allow/disallow specific tools)
  - MCP server tools for agents to query Linear/GitHub APIs directly
  - Single WORKFLOW.md file configures everything

  4,148 lines of source, 328 tests, zero type errors. Every line written by AI agents.

  Demo video in the README shows hatice building a presentation website autonomously — 5 Linear issues dispatched in parallel, each agent working
  in isolated workspaces with live hot-reload.

value: Show HN: Hatice – Autonomous Issue Orchestration with Claude Code Agent SDK


value: claythedesigner

value:
I'm autistic and ADHD, and I kept running into the same wall with AI tools- not knowing how to prompt them in a way that matched how my brain actually works. I'd have a real idea or need but couldn't get the output to reflect it. So I built BottomUp.
It's a free, no-login tool that walks you through a structured process to clarify your thinking before you prompt an AI. Instead of starting with a blank box, you answer a few focused questions and it builds the prompt from the bottom up — hence the name.
It's built especially for neurodivergent people, but honestly anyone who gets frustrated staring at a blank prompt field might find it useful.
No account needed, runs in the browser: https://www.bottomuptool.com
Would love feedback — especially from anyone who's struggled with the "I know what I want but can't explain it to the AI" problem.

value: Show HN: BottomUp- Translate Your Thoughts So AI Can Work For Your Neurotype

author: claythedesigner


value: hollowlimb

value:
We're on the Women's Day Sale!
To celebrate it, we are conducting a playtest for Shop Crush. Sign up if you are interested. We are preparing a game demo and would be more than happy to have you try it.
You can sign up for the paytest on our Steam Page.

value: Show HN: We're on Women's Day Sale. Sign Up to Playtest Shop Crush

author: hollowlimb


value: ppazos

value:
Hi HN,
I built openEHR-CLI, an open source command line tool to work with openEHR artifacts (archetypes, templates, etc.).
The idea was to make it easier to automate tasks that usually require GUI tools, such as validating templates or processing openEHR resources in scripts and CI pipelines.
One interesting feature is that the CLI also exposes an MCP (Model Context Protocol) server. This allows the tool to be used by AI clients that support MCP (Claude Desktop, Cursor, etc.), so AI assistants can interact with openEHR artifacts programmatically.
Examples of things it can be used for:
- validating templates and artifacts
- inspecting openEHR models
- automating checks in CI pipelines
- exposing openEHR tooling to AI assistants through MCP
The project is open source and feedback is welcome.
Repo:
https://github.com/CaboLabs/openEHR-CLI

value: Show HN: OpenEHR-CLI – CLI and MCP server for working with openEHR artifacts

author: ppazos


value: livrasand

value:
Hi HN! I built CodeTrackr, an open-source, privacy-first alternative to WakaTime.
It tracks coding activity and provides real-time analytics, global leaderboards, and a plugin system. The goal is to give developers useful productivity insights while keeping full ownership of their data.
Key features:
- WakaTime-compatible API (works with existing editor extensions)
- Real-time dashboard using WebSockets
- Global and language leaderboards
- Self-hostable (Docker included)
- Plugin system using JavaScript snippets
- GitHub and GitLab login
Stack:
Rust + Axum + PostgreSQL + Redis + Vanilla JS
Repository:
https://github.com/livrasand/CodeTrackr
I would really appreciate feedback, especially regarding:
- security
- architecture
- potential areas for improvement
If you're interested, you're also welcome to build plugins for the plugin store or create IDE extensions for your favorite editors.
Thanks for taking a look!
PS: I used ChatGPT to translate this; my native language is Spanish, and my English is limited.

value: Show HN: CodeTrackr – open-source WakaTime alternative with real-time stats

author: livrasand


value: surrTurr

value: Show HN: FOSS Lightroom alternative with video support (macOS)

author: surrTurr