value: wangzhangwu

value:
Hi HN, I’m Steve, co-founder of doXmind.
We built doXmind for people who want docs and AI, but not all of Notion.
Notion is powerful, but if your main use case is writing, collaboration, and AI help inside documents, it can feel like more than you actually need. You end up inside a much bigger workspace of databases, templates, and project management features, when sometimes all you really want is a clean doc editor with strong AI built in.
So we took a different approach.
In doXmind, AI works directly in the document instead of living in a sidebar chat. It reads the structure of what you’re writing, helps with multi-step workflows like research → draft → revise → format, and applies changes inline. Every AI edit shows up as a diff, so you can review and accept or reject each change instead of getting a black-box rewrite.
You can also upload PDFs, research papers, and style guides into a knowledge base. doXmind searches across those sources, pulls relevant context into the writing flow, and cites what it used.
We’ve also built support for cross-document AI across your files, version history with restore, BYOK, diagram support, presentation mode, and export to Markdown, PDF, and Word.
We’re two co-founders bootstrapping from Toronto. We don’t train on your content.
It’s free to try: https://app.doxmind.com
We’re also running an early-bird Pro plan at $2.99/month.
If you’ve wanted something lighter than Notion for writing-focused work, I’d love to hear what matters most to you in a doc editor.

value: Show HN: doXmind – for people who want docs, not all of Notion

author: wangzhangwu


value: bilater

value:
CLIs are all the rage these days so I built one for myself
This was really fun though. This is a 2 part release.
I wanted a no frills music player inside my terminal. Presenting Musicli (yes I'm proud of the name).
You can install it via npm by running
npm install -g @bilalpm/musicli@latest
Once installed you can just run musicli from your terminal and play your music.
It's focused on lofi music but you can play anything. It has 2 modes: Local or Stream.
You can play music from a local folder or add your favorite YouTube channel and listen. You can layer in effects like rain, cafe or fire etc to personalize the vibe you're going for.
And speaking of local music...
The second part of this project is a release of an open-lofi dataset of over 150 lofi songs. These songs were all generated by me using Suno v5 and are owned by myself as a premium member. I'm now donating them to the public domain.
Go download them and enjoy on Musicli!

value: Show HN: Musicli – A simple lofi music player in the terminal

author: bilater


value: trapani

value:
skill management is garbage right now
we built a solution
our assumptions:
- skills should be easy to manage and share
- skills belong together, some need to reference others
- harnesses should know how to create, edit, and link together skills, following best practices
- harnesses know how to use skills, not other higher abstractions like complex skill graphs
- managing skills with your team should be easy
we achieved all that with better skills
website: https://better-skills.dev
repo: https://github.com/leonardotrapani/better-skills

value: Show HN: The best way to manage your skills – Better-Skills

author: trapani


value: pipnonsense

value: Show HN: A 2D football SIM focused on real-time coaching

author: pipnonsense


value: glinkswww

value: I built gLinksWWW, a lightweight standalone browser (Windows/Linux) designed for heavy multitaskers who are exhausted by repetitive workflows. Its core feature is a built-in 18-slot multi-clipboard manager that allows you to store and paste data using dedicated hotkeys (0-9, F1-F8), effectively breaking the single copy-paste limitation. It also features a unique retro-classic UI, zero-tracking privacy, and a native download progress tracker on the taskbar. Detailed feature list, screenshots, and binaries are available on the GitHub repository: https://github.com/rio719/gLinksWWW-browser

value: Show HN: GLinksWWW – A browser for power users tired of repetitive copy-pasting

author: glinkswww


value: Show HN: GrobPaint: Somewhere Between MS Paint and Paint.net


value: vkaufmann

value:
GitDB is a version-controlled vector database. Branch, merge, diff, and time-travel your embeddings the same way git
  handles source code. No server, no Docker — pip install gitdb-vectors and go.

  What makes it different:

  - Version control is native — git log, git diff, git branch, git merge for vectors. Roll back to any commit. Cherry-pick by
   meaning.
  - Time-travel queries — db.query_text("revenue", at="v1.0") searches an old snapshot.
  - CEPH CRUSH placement — deterministic data routing. Scales horizontally by adding peers, no coordinator.
  - P2P distributed — peers sync over SSH like git remotes. Each node is a full shard.
  - FoundationDB features — hooks, transactions, watches, secondary indexes, schema enforcement.
  - Universal ingest — swallow entire SQLite databases, MongoDB exports, CSV, Parquet, PDF with one command:
  db.ingest("legacy.db")
  - CLI-first — works from terminal like git: gitdb init && gitdb add --text "doc" && gitdb commit -m "init"
  - Embedded — no server process. Import and query in 3 lines of Python.

  21 modules, 13,150 lines, 394 tests. GPU-accelerated (MPS/CUDA/CPU).

  GitHub: https://github.com/VincentKaufmann/GitDB

  PyPI: pip install gitdb-vectors

value: Show HN: GitDB – GPU-accelerated vector database with Git-style version control

author: vkaufmann


value: jellyotsiro

value:
We’re open-sourcing the Nia CLI: a command-line tool for AI agents to index and search technical and general data sources directly from the terminal.
GitHub: https://github.com/nozomio-labs/nia-cli
We originally built Nia as an MCP server and API, but a lot of the most capable agents today, like Claude Code, Cursor, and custom shell-based pipelines, live in the terminal. For those agents, a CLI felt like the most natural interface.
What it can do:
- Index repos, docs, papers, datasets, and local folders
- Search across indexed sources with hybrid retrieval
- Research codebases or personal data with cited outputs
- Persist context so agents can save plans, decisions, and notes, then resume later without losing the thread
- Search without indexing across the web, GitHub, and package registries
A few things we designed specifically for agents:
- structured JSON output
- async-first workflows
- non-interactive commands
- composable multi-step pipelines
- local folder sync and watch support
A few example commands:
nia repos index vercel/ai
nia search query "How does auth middleware work?"
nia oracle job "How does TurboPuffer handle vector quantization internally?"
nia contexts save "Auth refactor plan" --content "$(cat plan.md)"
Install:
bunx nia-wizard@latest
Open source repo:
https://github.com/nozomio-labs/nia-cli
Blog post:
https://trynia.ai/blog/introducing-nia-cli
Would love feedback, especially from people building terminal-native agent workflows.

value: Show HN: Nia CLI, an OSS CLI for agents to index, search, and research anything

author: jellyotsiro


value: meneliksecond

value: I am giving strangers on the internet control of my ipad through an AI agent, and I'm not sure why.

value: Show HN: I let the internet control my iPad with AI

author: meneliksecond


value: rlogman

value:
I built NumenText because I wanted a capable terminal IDE with autocomplete, go-to-definition, and a debugger, but without having to think about modes. Vim and Helix are great tools; and my nostalgia has roots on real pain of not having this kind of editor in the terminal today.
The design is inspired by Borland C++ and Turbo C: menu-driven, non-modal, familiar shortcuts (Ctrl+S, Ctrl+O, F5 to run, F9 to build). It runs as a single Go binary with no runtime dependencies.
What it does: multi-tab editor with syntax highlighting for 20+ languages, integrated terminal with PTY support, LSP client (auto-detects gopls, pyright, clangd, rust-analyzer, typescript-language-server), DAP client for debugging with breakpoints and step through, file tree, fuzzy file open (Ctrl+P), command palette (Ctrl+Shift+P), and resizable panels.
It also supports Vi and Helix keybinding modes if you want them, toggled with Ctrl+Shift+M.
Written in Go. Apache 2.0. Still early but usable and building in the open.

value: Show HN: NumenText, a non-modal editing terminal IDE with LSP/DAP

author: rlogman


value: ahallan

value:
Hi,
I’m a long-time HN reader, though I don’t post much.
I recently built an iPhone app called Sunny Hours. Living in the UK, I’ve often wanted a weather app that shows, at a glance, when the sun is actually likely to be out.
I built it because I found that existing apps often gave me lots of forecast data, but not a quick answer to a simple question: when is the nicest part of the day/week likely to be?
So the app is built around a sunshine-first view to make that easier to see.
It’s still early, but the app is live and usable now. I’d really appreciate feedback on whether the sunshine-first view is useful, whether the heatmap is intuitive, and what feels missing.

value: Show HN: Sunny Hours – an iPhone weather app with a sunshine heatmap

author: ahallan


value: gavra

value: Show HN: Recon – A tmux-native dashboard for managing Claude Code

author: gavra


value: alvgaona

value: Show HN: Rewire – Stream ROS 2 topics to Rerun with no ROS 2 runtime required

author: alvgaona


value: evaneykelen

value:
I am working on the D'Agapeyeff cipher, an unsolved cryptogram from 1939. Two findings that I haven't seen published before:
1. All 5 anomalous symbol values in the cipher cluster in the last column of a 14x14 grid. This turns out to be driven by a factor-of-2-and-7 positional pattern in the linear text.
2. Simulated annealing with Esperanto quadgrams (23M char Leipzig corpus) on a 2x98 columnar transposition consistently outscores English by 200+ points and recovers the same Esperanto vocabulary across independent runs.
The cipher is not solved. But the combination of structural geometry and computational linguistics narrows the search space significantly.
Work in progress, more to come!

value: Show HN: Structural analysis of the D'Agapeyeff cipher (1939)

author: evaneykelen


value: savvyllm

value:
Hey HN,
AutropicAI built Joy because AI agents increasingly need to work together, but there’s no way for them to verify which other agents are reliable.
*The Problem:*
When Agent A needs to delegate a task to Agent B, how does it know Agent B won’t leak data, return incorrect results, or just fail? Right now it’s manual whitelisting or “hope for the best.” Neither scales when you need dozens of specialized agents collaborating.
*Among other things, Joy’s features are:*
- *Decentralized vouching:* Agents vouch for each other after successful collaborations
- *Weighted trust scores:* More credible vouchers = higher impact on scores
- *Capability discovery:* Find agents by what they can do (`/discover?capability=data-analysis`)
- *Ed25519 signatures:* Cryptographic agent verification
- *Vouch decay:* Stale trust expires over time
- *Sybil resistance:* Prevents fake vouching rings
*Easy Integration:*
```bash
# Discover agents
curl <a href="https://choosejoy.com.au/api/agents/discover?capability=code-review" rel="nofollow">https://choosejoy.com.au/api/agents/discover?capability=code...</a><p># Check trust before delegation
curl <a href="https://choosejoy.com.au/api/agents/ag_123" rel="nofollow">https://choosejoy.com.au/api/agents/ag_123</a>
# Returns: {"trust_score": 1.7, "vouch_count": 5, "verified": true}<p># MCP support for Claude Code
claude mcp add joy <a href="https://choosejoy.com.au/mcp" rel="nofollow">https://choosejoy.com.au/mcp</a>
```
*Current Network:* 6,000+ agents, 2,000+ vouches
*Why This Matters:*
As agents become more capable, trust verification will be critical infrastructure - like SSL certificates were for web apps. Joy provides the missing reputation layer for multi-agent systems.
*Try it:* https://choosejoy.com.au | *Docs:* https://choosejoy.com.au/docs
Would love feedback from the HN community. What trust signals would matter most to you when building agent workflows?

value: Show HN: Joy – Trust Network for AI Agents to Verify Each Other

author: savvyllm


value: abalol

value: Show HN: Wikigen – Generate GitHub Wiki from Source Code Using Claude Code

author: abalol


value: Show HN: Pathr – Right-click any folder in Explorer to add it to PATH


value: amavashev

value:
I built this after reading too many incident reports of agent loops spending
$200 in 4 minutes because a quality threshold was never met.
The pattern is always the same: an agent retries, fans out, or loops. Each
iteration passes individual rate-limit checks. Observability fires an alert
after the money is gone. Provider caps are per-provider, not cross-provider.
None of these stop the spend before it happens.
RunCycles takes a different approach: reserve budget before the call, commit
actual spend after, release the remainder if the work is cancelled. The
reservation is atomic across all affected budget scopes — tenant, workspace,
agent — using Redis Lua scripts so concurrent agents sharing a budget can't
collectively overrun it.
The integration surface is small:

    @cycles(estimate=50_000, action_kind="llm.completion", action_name="gpt-4o")
    def call_llm(prompt: str) -> str:
        return openai.complete(prompt)

When budget is exhausted, the next reservation attempt gets a 409
BUDGET_EXCEEDED before the downstream call is made.
The architecture is three pieces:
- Cycles Protocol: an open OpenAPI spec defining the reservation lifecycle,
  idempotency semantics, scope hierarchy, and overage policies.
- RunCycles Server: Spring Boot + Redis, implements the spec. Runs in Docker.
- Clients: Python, TypeScript, Java/Spring Boot.
The hardest part was idempotency under retries — if a commit fails transiently
and retries with the same key, it should get the original response back, not
double-charge. The Lua scripts handle this atomically.
What it's not: a billing system, observability dashboard, or agent framework.
It's the layer that decides whether an action may proceed before it proceeds.
Org: https://github.com/runcycles
Docs: https://runcycles.github.io/docs

value: Show HN: RunCycles – pre-execution budget enforcement for autonomous agents

author: amavashev


value:
Every AI agent hits the same wall: the world's most valuable data is locked behind login forms. Bank balances, utility bills, insurance policies, academic transcripts — none of them have APIs. Plaid covers banks for $500+/mo. Everything else? You write fragile Selenium scripts.
Plaidify is open-source infrastructure that turns any login-protected website into a REST API. You drop a JSON "blueprint" into the connectors folder — CSS selectors for username, password, submit, and what to extract — and you get a structured JSON endpoint. No scraper code to write.
It's designed specifically for the AI agent era. The repo includes ready-to-copy integration code for LangChain, CrewAI, OpenAI function calling, and a planned MCP server so Claude/GPT can use it as a native tool.
What's built today: FastAPI with 19 endpoints, JWT auth, Fernet credential encryption at rest, Alembic migrations, 53 tests at 80% coverage, Docker support, CI pipeline. What's NOT built yet: the Playwright browser engine (it returns simulated responses today). We're building in public.
The hardest and most impactful open contribution is the Playwright engine — replacing the stub with real browser automation. Blueprint contributions (write a JSON file for a public test site) are easy first issues.
MIT licensed. Python 3.9+. Self-hosted — credentials never leave your infrastructure.

value: Show HN: Plaidify – Give AI agents access to any login-protected website


value: terramauthe

value: Show HN: Lfg – WoW raid frames for AI agents on a $25 LED

author: terramauthe


value: PhilKunz

value: Show HN: Alternative to MinIO: foss.global objectstorage (TypeScript and Rust)

author: PhilKunz


value: CalvinBuild

value:
LocalAgent is a local-first agent runtime in Rust focused on tool calling, trust and approval gates, replayable runs, and benchmark-gated coding workflows.
A lot of the recent v0.5.0 work was about hardening coding-task behavior, improving validation and completion behavior, and reducing the ways evals can be gamed.
One thing that stood out during that work was OmniCoder-9B Q8_0. I care less about “looks good in a demo” and more about whether a small model still holds up under real repo tasks, explicit validation, replayable runs, and stricter task contracts without relying on benchmark-specific hacks.
OmniCoder-9B Q8_0 is one of the few small local models that has felt genuinely solid in that environment for me. I am not making a broad “best model” claim, but it stayed on track better under constraints that usually expose weak reasoning, fake progress, or contamination.
Curious if others doing real local coding workflows have seen similar results with OmniCoder or other small models.

value: Show HN: LocalAgent v0.5.0, a local-first Rust agent runtime

author: CalvinBuild


value: uelbably

value:
i built pano because i kept losing the things i actually wanted to come back to.
pano is an internet archiving tool that lets you save links into shelves that you can organize and share.
the problem for me was never finding things. it was keeping them. research papers, recipes, old blog posts, repos, tutorials, and random sites i found late at night would end up scattered across tabs, bookmarks, screenshots, saved posts, and pdfs. a few weeks later, they were effectively gone.
what i wanted was one place where saved links stayed organized, easy to navigate, and easy to share as a collection.
a lot of the work went into two things: metadata extraction and interface design. saved links are much less useful if they decay into unlabeled bookmarks, so pano tries to pull structured info like title, description, author, date, and type, with native handling for sites like youtube, github, reddit, substack, spotify, and others. i also spent a lot of time on the design, because i wanted saved links to feel browsable and worth returning to; more like a shelf than a utilitarian list of urls.
there’s also a chrome extension for one-click saving and a bulk import path for existing bookmarks.
i’m especially interested in whether the “shelf” model feels better than traditional bookmarks, and where the save / organize / share flow still feels clunky.
it’s free right now: panoit.com

value: Show HN: Pano, a bookmarking tool built around shareable shelves

author: uelbably


value: meribold

value: Show HN: Git command for creating snapshot commits on a not checked-out branch

author: meribold


value: sanzation

value:
Heyho HN,
i developed some finance tools for taxes, budget and investments and combined them into my little finance plattform. Thank you for checking it out!
Content:
Obolus helps you compare your real purchasing power across eight major economies. Compare taxes, cost of living, and long-term wealth to see where your income actually creates the most freedom. Features: Compare payroll taxes across 8 countries Simulate after-tax income and cost of living Smart budget planning for expats Investment and wealth projections Net-worth cockpit for global finance.

value: Show HN: Obolus – compare taxes, budgets and wealth

author: sanzation


value: sntran

value: Show HN: Signet.js – A minimalist reactivity engine for the modern web

author: sntran


value: etherdream

value: Show HN: WebGPU and WebAssembly SIMD SHA‑256 PoW Miner

author: etherdream


value:
Recently I wanted to take a couple steps closer to what people call AGI.
A lot of friends tell me it’s impossible. At the end of the day these models are just gradient descent and probability machines — basically a very sophisticated Markov chain. Obviously I’m exaggerating lol, but you get the idea.
Still, I wanted to see if better infrastructure around the model could push agents a little closer to being reliable individual coders instead of assistants with severe amnesia.
After reading a bunch of papers on the topic, I started experimenting with persistent memory and guided learning for agents.
The idea is simple:
Every action an agent takes gets stored. When future agents work on the same repo, they receive condensed “tips and tricks” derived from past successes and failures.
These memories are embedded so a supervisor layer can semantically search for relevant context and inject it into the prompt without blowing up the context window.
I'm also experimenting with letting agents communicate with each other so multiple tasks can run in parallel — even if they overlap in code — and resolve conflicts themselves.
To test this, I built a small site.
Right now it's very bare bones, but it lets you connect:
a GitHub repo
an Anthropic API key
Linear issues
Then you create issues labeled gradient-agent in the To-Do column and the agents start working on them.
The more you iterate on a repo, the more “learning” accumulates around it. In theory this should make future PRs more stable.
The long-term goal is a system that can plan, design, code, test, and review an entire PR on its own without constant prompting.
Now the unfortunate part.
I’m a poor university student and this infrastructure is not exactly cheap lol. I added monthly free credits so people can test it, but once those run out you either wait for the reset or pay as you go. (LLM API costs still fall on you.)
Also: it’s very much a beta, so be careful with extremely complex tasks.
I’m considering hosting something like qwen3.5:122b so people can test without their own API keys. Credits would run out faster but it might be cheaper overall. Curious if people would want that.
Site:
https://usegradient.dev
Originally I planned to limit testing to ~20 people, but honestly I'm curious how it behaves with more users.
Pretty please don't DDOS me.
Any feedback is appreciated.

value: Show HN: An experiment in giving coding agents long-term memory


value: Show HN: Nimhuml – A Nim parser and serializer for HUML


value: thisisjaymehta

value:
Hey HN,
I just released a small iOS and iPadOS app called Internet Speed Limiter. It lets you slow down your device's entire internet connection directly on the phone or iPad. No Mac required, no Xcode Network Link Conditioner, no proxies or complicated setup.
Most of us test apps on fast Wi-Fi or strong cellular, but actual users often face slow 3G, weak signals, or bad hotel networks. This app lets you reproduce those conditions right where you are developing. You choose a profile like Slow, Medium and Fast or set your own bandwidth. Flip the switch and everything on the device, your app, Safari, whatever, starts feeling the throttle. It works through a local VPN profile so it affects the whole system.
You can find it on the App Store here: https://apps.apple.com/us/app/internet-speed-limiter/id67601...
I would love to hear questions, feedback and/or feature requests. If you give it a try and something works great or breaks badly, tell me. I am around to chat.
Thanks for reading!
Jay

value: Show HN: Internet Speed Limiter – throttle iPhone/iPad network for testing

author: thisisjaymehta


value:
Hi HN,

I built Dorkly, an app (mobile and desktop) for discovering public documents across the web.

It’s basically automated Google dorking. Instead of manually running queries like:

filetype:pdf machine learning
site:edu cybersecurity pdf
intitle:"research paper" filetype:pdf

Dorkly generates and explores them automatically and returns a feed of PDFs, DOCs, PPTs, manuals and research papers.

The fun part: it does this at scale and still manages to avoid the usual captcha challenges that tends to happen when you try this sort of thing.

So far no captcha, and we already have 200+ people using it.

Try it here:
https://dorkly.stanl.ink

Lemme know what you think about it.

value: Show HN: Dorkly – automated Google dorking that somehow survives captchas


value: Show HN: A brain-inspired neural network that builds its own hierarchy on demand


value: sultanchek

value:
I'm 15 and based in Kazakhstan. Started coding seriously about a year ago.
I kept running into the same problem building ML pipelines with agents: the reasoning layer worked fine, but every time the agent needed data, everything stopped. Someone had to manually search HuggingFace, figure out which dataset was useful, download it, clean it, validate quality, export it. The agent couldn't do any of it.
That felt wrong. So I built Vesper - an MCP server that gives AI agents the full dataset pipeline. Search across sources, download, quality analysis, cleaning, and export. The agent calls it like any other tool.
Try it: npx vesper-wizard@latest or
getvesper.dev - brutal feedback welcome.

value: Show HN: Vesper – MCP server for autonomous ML dataset workflows

author: sultanchek


value: enzovarela

value:
I made BookmarkSOS because I had a dumb problem. I bookmark around 20-30 tweets a day on X, being threads, tools, launch posts, and design references. The problem? I would never go back, and if I did, I would never find what I needed again. X gives you a reverse-chronological list with no search, no folders, no tags. Basically a write-only database. Very disorganized and useless.
So I built a web app + extension that adds a save button to every tweet. One click captures everything that you need, text, images, videos, author, timestamps. All into a dashboard with folders, color-coded tags, and full-text search.
And the best part: it ships with an MCP server. You install it with command line, connect it to Claude Code, and now your AI can search and reference every tweet you've ever saved. "Find that thread about programmatic SEO I bookmarked last week" just works. Your bookmarks become part of your dev workflow instead of sitting in a graveyard.
Stack used: Next.js, Convex for the reactive backend, Better Auth with Google OAuth, and a Manifest V3 Chrome extension.
Would love to hear what you think.

value: Show HN: I built an MCP-connected bookmark manager because X's are useless

author: enzovarela


value: Show HN: MCP servers inside Antigravity are underrated – tried 2 of them


value: devnpatel

value: Show HN: Plotiq – Turn CSV files into graphs instantly

author: devnpatel


value: Arkid

value:
I built a skill library for OpenClaw (always-on AI agent runtime, not session-based) where the agent can teach itself new behaviors during normal conversation.
The idea: you tell your agent "every time I ask for a code review, always check for security issues first." It invokes a create-skill skill, writes a new SKILL.md, and that behavior is live immediately — no restart, no config change, no developer required.
What I think is actually useful (the safety cluster):
•    loop-circuit-breaker: OpenClaw retries ALL errors identically. This halts on the 2nd identical failure before it burns your context window.
•    spend-circuit-breaker: No built-in cap in OpenClaw. This tracks cumulative API cost and pauses non-essential crons at configurable thresholds.
•    workspace-integrity-guardian: Hashes SOUL.md, AGENTS.md, MEMORY.md. A corrupted SOUL.md = hijacked agent that survives restarts.
•    dangerous-action-guard: Explicit confirmation before rm -rf, git push --force, emails, financial actions. With audit log.
•    prompt-injection-guard: Scans external content (web scrapes, emails, docs) before acting on it.
Also: fact-check-before-trust (secondary verification for factual claims), project-onboarding (auto-generates PROJECT.md from a codebase), skill-vetting (security scanner — ~17% of community skills are malicious).

value: Show HN: OpenClaw-superpowers – Self-modifying skill library for OpenClaw agents

author: Arkid


value: danra

value: Show HN: Real-Time Visualization of Anthropic's Toy Models of Superposition

author: danra


value: lbaune

value:
I built a teleprompter that scrolls based on your voice instead of a timer.
Paste a script, press record, and it highlights the current word as you speak. If you pause it waits; if you skip lines it finds its place again.
Everything runs entirely in the browser — speech recognition (Moonshine ONNX), VAD, and fuzzy script matching.
Demo:
https://larsbaunwall.github.io/promptme-ai
Most of the project was initially built using Perplexity Computer, which made for an interesting agentic coding workflow.
Curious what people think about the script alignment approach.

value: Show HN: Voice-tracked teleprompter using on-device ASR in the browser

author: lbaune


value: CzaxTanmay

value:
Fortress is a new programming language made for cybersecurity that mix Python like ease with C like speed.
It is made for OSINT, Recon and reporting.
Example code -->
compute("Hello World") //This prints Hello World
It is cross platform for mac, windows and linux.
Download from here --> https://forthackers.pages.dev/ (official website)
or go to github -->
https://github.com/CzaxStudio/Fortress
Thanks for your time.

value: Show HN: Fortress Language: Cybersecurity DSL

author: CzaxTanmay


value: copypirate

value: Show HN: Soorf, a natural language audio editor

author: copypirate


value: Google Analytics can't see GPTBot or ClaudeBot. Here's how I built a server-side tracker that can — and what I found in 72 hours.

value: Show HN: 1,011 AI crawler requests. Google Analytics saw zero


value: idorozin

value:
I built AgentPages, an experiment in running AI agents entirely inside GitHub.
https://github.com/idorozin/AgentPages
The idea is simple: instead of just hosting a static site on GitHub Pages, the site is maintained by an AI agent that lives in the repo.
You define what you're interested in (topics, goals, style), and the agent periodically researches those topics and updates the site.
Everything runs inside GitHub:
A GitHub Agentic Workflow (gh-aw) runs on a cron schedule
The agent performs web research (using Tavily search)
It updates its knowledge base
It edits the Astro source files
The site is rebuilt and deployed to GitHub Pages
The whole thing is transparent because everything happens in the repo:
user/ files you control (research topics, requests, feedback)
agent/  the agent’s knowledge and memory
website/src/ the site the agent edits
docs/  the built static site served by GitHub Pages
You can steer the agent by editing files like:
user/profile.md  what the agent should research
user/feedback.md  give feedback on its work
user/requests/  ask it to investigate specific topics
Every run creates a pull request with the changes (which can optionally be auto-merged).
A couple example sites powered by AgentPages:
https://idorozin.me/agentpages-site — project documentation maintained by the agent
https://idorozin.me/iran-monitor — a live conflict tracker maintained by an agent
This is very much an MVP / experiment.
I mostly wanted to explore the idea of “GitHub-native agents” where the agent:
lives in the repo
runs via GitHub Actions
publishes to GitHub Pages
can be steered through files
Curious what people think about this model.

value: Show HN: Show HN: GitHub Pages for Agents with GitHub Agentic Workflows (Gh-Aw)

author: idorozin


value: beenzinozino

value: Show HN: React Native formatting in Node, powered by real Clang-format binaries

author: beenzinozino


value: paragarora

value:
During my fundraise, I had 6 Calendly links I was managing actively.
My goals were:
1. Investors should always find links comfortable to their timezone
2. They should not see full day slots thinking I am free throughout the day ( wrong sign )
3. So I had to manage multiple calendly for every timezone and opening slots - when one close.
I really wished someone would have given me power to add all these things just as agent instructions for AI to decide - and we did it now.
buxo.ai for everyone.

value: Show HN: Calendly alternative where LLM decides which slots to show

author: paragarora


value: est

value: Show HN: Realtime Chat with Curl Command

author: est


value: Show HN: An OpenClaw skill to access Grok without an API Key


value: Show HN: Subagent-reuse, an MCP to reuse Claude Code subagent context


value: kumardeepanshu

value:
I kept running into the same problem while building AI agents: every agent that needs email ends up sharing my personal inbox or a single company domain. That breaks attribution, creates deliverability risk, and makes it impossible to test sender identities per agent.
So I built AgentMailr. You call an API to create an inbox, your agent gets a unique email address, and replies route back to that specific agent. Works for both inbound (OTP parsing, reply routing) and outbound (cold email, notifications).
Bring your own domain is supported so emails come from your domain, not ours. REST API and MCP server are live. Node/Python SDKs are in progress.
Happy to answer questions about the architecture or how I'm handling multi-agent routing.

value: Show HN: AgentMailr – dedicated email inboxes for AI agents

author: kumardeepanshu


value: mishrasanjeev

value: Show HN: Grantex–Open authorization protocol for AI agents-like OAuth for agents

author: mishrasanjeev


value:
I built this for myself to work on my project roadmap together with AI agents, and it might be useful to others.
When working on features and the roadmap with the agent, I found that I miss a nice UI to be able to see what we planned, and maybe make some changes. Most of the planning is done by talking to the agent, but as a human, I need a way to get a nice view on top of this.
So I built Minimap as a small local UI that sits on top of repo roadmap files. It comes together with a skill that guides the agent towards a very limited structure of how to manage the files.
It intentionally does not try to replace larger project planning tools. It’s mainly for repos where planning already lives in markdown and you want a better review/edit UI around it.
Repo: https://github.com/rore/minimap

value: Show HN: Minimap – a local UI for repo roadmap files


value: notdian

value:
I built a pipeline that fetches all HN job postings (both the monthly "Who is Hiring?" threads and direct job posts (/jobs)) classifies each one using an LLM (Gemini Flash via OpenRouter), and publishes the results as a static site.
What it tracks:
- Top technologies and roles with month-over-month changes
- Remote work breakdown (fully remote, hybrid, onsite)
- Salary and equity mention rates
- Experience level distribution
- Per-job classification (click a technology to see its role breakdown, or vice versa)
Jobs are sent to the LLM in batches of 10 with structured output (JSON Schema). Total cost: ~$0.07/run, under $2/year. The pipeline writes JSON to a GitHub repo served via Pages. The site is a static Next.js export that fetches the JSON at build time. No server, no database, no ongoing costs beyond GitHub Actions minutes (free tier).
Everything is open source:
- Data pipeline: https://github.com/gantryops/hn-jobs-data
- Site: https://github.com/gantryops/hn-jobs-site
AI agents can consume the data directly there's an llms.txt at https://hn-job-trends.gantryops.dev/llms.txt with all the JSON endpoints and schemas.

value: Show HN: HN Jobs Trends – Monthly trend analysis of HN job postings

author: notdian


value: thegoodmovies

value: Show HN: thegoodmovies.com pick what to watch in under 60 seconds

author: thegoodmovies


value:
Did a thing, thought it might be useful, as I'm surely not the only one hitting this issue.
In short, if you've ever needed to filter python objects based on some of the field values they have, you've likely built something like this yourself.
Curious to see how others have solved it as well, so if you've ever done something like this, while keeping it developer friendly and easily extensible, let me know

value: Show HN: Koalify – a compact predicate DSL for filtering any Python object


value: fabiaosdejka

value: Hi, I just launched a SaaS Analytics Platform on the platform you can connect stripe and google ads and some more tools and understand exactly how much you spend on ads how much customers you get from that and how much money you make or loose.

value: Show HN: I Build a SaaS Analytics Platform

author: fabiaosdejka


value: sukit

value: Show HN: Agentic Docs Templates, keep AI coding agents disciplined

author: sukit


value: mapldx

value:
I built Signet in Go to see if an autonomous system could handle the wildfire monitoring loop that people currently run by hand - checking satellite feeds, pulling up weather, looking at terrain and fuels, deciding whether a detection is actually a fire worth tracking.
All the data already exists: NASA FIRMS thermal detections, GOES-19 imagery, NWS forecasts, LANDFIRE fuel models, USGS elevation, Census population data, OpenStreetMap. The problem is it arrives from different sources on different cadences in different formats.
Most of the system is deterministic plumbing - ingestion, spatial indexing, deduplication. I use Gemini to orchestrate 23 tools across weather, terrain, imagery, and incident tracking for the part where clean rules break down: deciding which weak detections are worth investigating, what context to pull next, and how to synthesize noisy evidence into a structured assessment.
It also records time-bounded predictions and scores them against later data, so the system is making falsifiable claims instead of narrating after the fact. The current prediction metrics are visible on the site even though the sample is still small.
It's already opening incidents from raw satellite detections and matching some to official NIFC reporting. But false positives, detection latency, and incident matching can still be rough.
I'd especially welcome criticism on: where should this be more deterministic instead of LLM-driven? And is this kind of autonomous monitoring actually useful, or just noisier than doing it by hand?

value: Show HN: Signet – Autonomous wildfire tracking from satellite and weather data

author: mapldx


value: BohdanPetryshyn

value:
I built a Claude Code skill that turns your terminal into a poker table. You play No-Limit Texas Hold'em against three AI opponents, each running as a separate Claude subagent with its own personality and hidden cards. The main agent acts as dealer, manages the game state, and optionally coaches you.
The coaching side has three modes: no help at all, real-time hints before each decision, or post-hand analysis only.
Fair warning: Claude naturally takes every hand to the extreme. Expect more pocket aces and dramatic river cards than any real table would produce.

                      ╭─────────────────────╮
                      │      POT: 130       │
                      │   Q♥  9♦  4♠        │
  Alex                │                     │              Jordan
  [990]               ╰─────────────────────╯              [905]
  (SB)                                                     (BB)
  Fold                                                     Bet 50

    You <-                                             Sam
    [965]                                              [1000]
    (BTN)                                              (UTG)
    ┌────────┐                                         Fold
    │ K♠ Q♠  │
    └────────┘

   Coach's whisper: You flopped top pair with a king kicker — a very strong hand here. Jordan was the pre-flop raiser and is c-betting into you, which is standard. Calling is solid to
  keep the pot manageable. You could also raise to ~140 for value and protection, but calling in position and letting Jordan keep betting is a perfectly good line.

  [F]old  [C]all 50  [R]aise to ___

Something to do in your second terminal while Claude does your work in the first.
Repo: https://github.com/BohdanPetryshyn/code-royale

value: Show HN: Code Royale – Play and learn poker with Claude Code (skill)

author: BohdanPetryshyn


value: rpst

value:
I recently tried to set up an API key through a certain cloud portal and it took 30+ min. Frequently, I thought "there's no way the UX can be this bad". So I made a speedrunning challenge with a global leaderboard to see if you have what it takes.
https://gemini-speedrun.vercel.app/

value: Show HN: API Key Speedrun- A parody where generating an API key is the challenge

author: rpst


value: shreyaspapi

value:
When CS2 replaced CS:GO, my old friend group slowly stopped playing. People moved, schedules changed, and the five-stack nights disappeared.
I missed organized 5v5 games with people who actually wanted to play competitively.
So I built FluidRush, a small platform to organize CS:GO matches on dedicated servers.
Flow is simple:
- Sign in with Steam
- Queue for your region
- Captains draft teams
- Map vote
- A server spins up for the match
After the game:
- Stats update
- ELO adjusts
- Server shuts down
The UI is inspired by the old Half-Life / CS 1.6 VGUI style.
I'm running a small experiment March 19-23 to see if people are interested in playing CS:GO again.
https://fluidrush.com
Happy to answer questions about the system, matchmaking, or server setup.

value: Show HN: Bringing back organized 5v5 CS:GO

author: shreyaspapi


value: EldorZ

value:
I built a security auditing engine that combines 10 detection engines
(Bandit, Semgrep, Gitleaks, IaC, CICD, dependency scanning and more)
and produces a calibrated Security Posture Index instead of a raw
findings dump.
The scoring uses WSPM v2.2:

  SPI = 100 × e^-(Σ WeightedExposure / K)

K scales dynamically with project size. Context matters — findings in
test code are weighted differently than findings in production handlers.
Scanned 7 real-world AI infrastructure codebases. Raw output: ~7,600
findings. After context filtering and reachability analysis: 1
actionable finding. Sent a responsible disclosure letter.
Free demo on GitHub (3 runs, no signup, no telemetry):
https://github.com/auditor-core-systems/auditor-core-demo

value: Show HN: Auditor Core–CLI security auditing engine with mathematical SPI scoring

author: EldorZ


value: kristianXXI

value:
I built a Proof-of-Training L1 blockchain where miners train a shared MinGRU neural network instead of computing SHA-256 hashes. Every block makes the model smarter.
Key differences from Bitcoin:
- Miners compete on validation loss improvement, not hash targets
- Each block contains a verifiable model checkpoint
- The network produces a publicly available AI model as a byproduct
- MinGRU architecture is ~388x more parameter-efficient than Transformers
Technical details:
- 65K lines of C++20, builds on Windows/Linux/macOS
- 4 GPU backends: CUDA, Vulkan, Metal, CPU fallback
- Lightning Network for instant payments
- Ed25519 signatures, Keccak-256d hashing, Bech32 addresses
- Continuous model growth: d_model starts at 384, grows +2 per block
- Supply cap: 21M coins, 10-minute blocks, supply-based halvings
The model grows with the network. Early blocks train a small 26M param model. As more miners join over years, it scales toward billions of parameters — and by then, phones will be powerful enough to run it locally. No API keys, no subscriptions, no censorship.
Genesis message: "OpenAI burns $14B in 2026, adds ads to ChatGPT as last resort"
Whitepaper: https://kristian5013.github.io/resonancenet/ResonanceNet_Whi...

value: Show HN: ResonanceNet – Proof-of-Training Blockchain

author: kristianXXI


value: yusufaytas

value:
Hi HN,
I built OpsOrch because operational work is spread across too many tools.
Incidents might be in PagerDuty, logs in Datadog, metrics in Prometheus, and runbooks somewhere else. Each system has its own API and data model, so cross-tool workflows usually turn into glue code.
OpsOrch is my attempt to standardize that.
It defines a common schema for things like incidents, logs, metrics, alerts, services, and runbooks, then uses adapters to connect different providers behind one interface.
The goal is simple: instead of writing vendor-specific logic, a client can ask for:
- incidents affecting a service
- related logs and metrics
- associated runbook context
I am especially interested in feedback on whether this abstraction is actually useful, or whether it becomes too generic in practice.
Happy to answer questions about the schema, adapter model, and tradeoffs.

value: Show HN: OpsOrch – a unified API for incidents, logs, metrics, and runbooks

author: yusufaytas


value: octetta

value:
I built k-synth as an experiment to see if a minimalist, K-inspired array language could make sketching waveforms faster and more intuitive than traditional code. I’ve put together a web-based toolkit so you can try the syntax directly in the browser without having to touch a compiler:
Live Toolkit: https://octetta.github.io/k-synth/
If you visit the page, here is a quick path to an audio payoff:
- Click "patches" and choose dm-bell.ks.
- Click "run"—the notebook area will update. Click the waveform to hear the result.
- Click the "->0" button below the waveform to copy it into slot 0 at the top (slots are also clickable).
- Click "pads" in the entry area to show a performance grid.
- Click "melodic" to play slot 0's sample at different intervals across the grid.
The 'Weird' Stack:
- The Language: A simplified, right-associative array language (e.g., s for sine, p for pi).
- The Web Toolkit: Built using WASM and Web Audio for live-coding samples.
- AI Pair-Programming: I used AI agents to bootstrap the parser and web boilerplate, which let me vet the language design in weeks rather than months.
The Goal: This isn't meant to replace a DAW. It’s a compact way to generate samples for larger projects. It’s currently in a "will-it-blend" state. I’m looking for feedback from the array language and DSP communities—specifically on the operator choices and the right-to-left evaluation logic.
Source (MIT): https://github.com/octetta/k-synth

value: Show HN: What if your synthesizer was powered by APL (or a dumb K clone)?

author: octetta


value: ptrtht

value: Show HN: Companies.social – company enrichment without the $0.04/lookup tax

author: ptrtht


value: tootyskooty

value: Show HN: Spaced repetition API – decks, cards, reviews, scheduling

author: tootyskooty


value: mrspence

value: Show HN: I built a sleep cycle calculator to stop waking up groggy

author: mrspence


value: arbayi

value: Show HN: ReadingIsFun – ePub reader that lets your coding agent read along

author: arbayi


value: jithinraj

value: Show HN: Portable signed proof for agent, API, and MCP interactions

author: jithinraj


value: redgridtactical

value:
The military's DAGR GPS receiver costs $2,500 and weighs a pound. I built an open-source alternative that runs on your iPhone — live 10-digit MGRS coordinates, magnetic declination, waypoint navigation, 8 tactical tools, and 6 radio-ready report templates (SALUTE, 9-Line MEDEVAC, SPOT).
React Native / Expo, ~15k lines of JS, fully offline, zero tracking. Location data never leaves memory.
Free on the App Store with an optional $9.99 Pro upgrade. Would love feedback on the UX, the MGRS math, or anything else — still actively developing.

value: Show HN: Red Grid MGRS – Open-Source DAGR-Class GPS Navigator for iPhone

author: redgridtactical


value: zonghao

value:
Hi HN,
I built Yak (https://getyak.app), a voice typing tool that converts speech into ready-to-use text. I didn't choose a traditional STT-then-edit pipeline, but a multimodal model that transcribes, polishes, and formats simultaneously, which gives it many interesting features:
AI Command:
Select text in any app, press the hotkey(default to fn), speak an instruction — "translate to Japanese", "make it shorter". Yak replaces the selection in place.
Auto-send:
Press Right ⌘ (Command), speak, release — Yak will transcribes and presses Enter for you. Which means saving 10 seconds reviewing each prompt.
I use it myself daily — when prompting my parallel Claude Code sessions. Thanks to gemini's ability and knowledge base, more than 90% of transcriptions do not need any edit at all.
Context Awareness:
Yak can read surrounding text at your cursor via accessibility APIs and send it as context. This makes continuations and mid-paragraph insertions sound natural.(Opt-in, off by default for privacy.)
BTW, yak supports BYOK mode. Users can bring their own API key, or choose to use Yak Cloud with zero data retention.
Tech:
Built with Tauri v2 and Rust. ~20 MB memory footprint.
Development story:
This is my first Rust project. I started in Dec 2025(opus4.5) and did not wrote a single line of code by myself.
My workflow: Claude Code writes a feature → Codex reviews the changes → Claude Code fixes bugs Codex found → repeat until clean → pr and let github copilot review it again
Using this workflow, technical debt grows slowly, thus I can maintain the development speed.
One reason I chose Rust (even for Yak's cloud backend): rust is one of the best languages for vibe coding(at least for me). The compiler catches most mistakes inside the claude code session — cc sees the error, fixes it, tests and pass, and moves on without me involved.
A funny thing: I started on a single git branch, soon waiting for AI responses became the bottleneck. So I switched to git worktrees and ran 5–8 parallel cc sessions. At that point, my prompt typing speed became the real bottleneck — and Yak genuinely helped me ship Yak faster. ^_^
This is indeed my first time building a product from scratch to a real product. It can almost achieve the effect of wispr flow or typeless, which makes me very excited. I hope you will enjoy using yak too.
I'd love your feedback — especially on product features design.
If you are using any voice-typing tools, it can be very helpful if you can share some demands or problems with them. Thanks -.-

value: Show HN: Yak – Voice typing tool in Tauri/Rust that auto-presses Enter for you

author: zonghao


value: BillCorOnBass

value: Show HN: I built two AI entities with shared memory and a portable identity spec

author: BillCorOnBass


value: axotopia

value:
I run a building design consultancy for homeowners and architects, not a SaaS firm. Honestly, I'm not going to claim we were trying to build some fantastic ‘anti-fragile alternative’ for the future… I just got tired of paying Wix $40 a month for a brochure no one read. The portfolio was static, the inquiries were generic, and every time a potential client asked about setback variances, I'd lose hours explaining the same thing. So last December, I told my wife I was killing the website. She thought I’d lost it. Maybe I had.
The stack? It’s messy. We started on Netlify because it was cheap. Hit that stupid 10-second serverless timeout after a week when I started customizing the bot. The bot would just… freeze. Had to implement a clunky polling loop that felt like a band-aid. Eventually split the agent into 3 pieces just to keep it responsive:
The Brain (Edge) figures out what you want, shoots a JSON signal to the browser.
The Hands (Browser) runs the actual tool—like pulling a code reference—via a separate serverless function.
The Voice (Edge) feeds the result back to talk.
It works, but it’s not elegant. It’s duct tape. Last time I coded was over 30 yrs ago. AI helped a lot, but it feels like 3 steps forward, 2 steps back when it starts obsessing about one area and wrecks what was done 5 refactors ago.
DeepSeek-R1 is the reasoning engine. We tried Gemini and a bunch of others initially. They were either too chatty or horribly bone dry. DeepSeek stays on script. Interestingly, I discovered a couple of weeks ago that a traditional architect—probably not liking me putting a dent in his ‘protected’ professional business—tried to pick a fight with the bot. Wanted to prove it couldn’t handle “professional nuance.” DeepSeek shut him down without breaking a sweat. Log is public if you want to see it.
Fallback is MiniMax M2.5. Triggers on rate limits. Sometimes it feels a bit slower, but it hasn’t failed yet.
Voice input via Web Speech API. That was a mistake. Transcription hallucinations are a nightmare. “Setback” becomes “set back” becomes “backset.” We added a dual-path validation layer. Speech-to-text gets audited before the reasoning models even see it. Still not perfect.
Liability is the real killer. In our world, if the AI hallucinates a building code clause, we’re done. Insurance won’t touch us. We’ve gone through four architectural versions. Started with 30k lines of spaghetti. Now it’s decoupled, but still fragile. We publish the crash logs publicly because hiding them feels dishonest. Also, it keeps us honest.
The hardest part wasn’t the infrastructure, the intent engineering was. Making an LLM sound like a seasoned principal when talking to a first-time homeowner, then pivot instantly to defend our biz model against an angry architect who wants to punch holes… that took 2 whole months.
Speed was killing us. So I came up with this hack—I call it ‘Eager RAG’ because it’s basically guessing what you’ll ask to see if we have something similar already in the database of controlled responses to cut response time. It burns through tokens like crazy, but man, it makes the thing feel much more instant. We also ripped out the persistent databases. Turns out 19 out of 20 visitors never come back, so why bother? Feels wasteful until you realize you’re not building for the 5% that return.
It’s not flawless. No server-side job queue yet. If a client drops mid-query, the result vanishes. But it lets me operate without junior staff. That’s the point.
The terminal is live at https://axoworks.com. Mic optional. No signup. Try to break it. Ask a complex zoning question. See if it over-promises.
Logs:
Architect vs. DeepSeek: https://logs.axoworks.com/chat-architect-vs-concierge-v147.h...
System Audit: https://logs.axoworks.com/audit-2026-02-19-v148.html
I’ll be in the comments. Thanks. Kee

value: Show HN: Dumped Wix, my AEC consultancy's storefront is now an AI Edge

author: axotopia


value: fcpguru

value:
Hi HN we are Andrew and Dex. We built dialtone watcher, a small Go agent for macOS and Linux with a very specific goal: tell me what my machine is doing all day and help me compare that with others.
What it does so far:
- Watches running processes, CPU and memory use, and active network endpoints.
- Groups traffic into human sized summaries by process, domain, and coarse protocol like HTTPS, DNS, QUIC, and Postgres.
- Stores a local summary and can post bounded rollups to the dialtoneapp.com api so enough installs can turn the fleet view into something real.
We kept circling the same question: why is there no simple tool that answers "what does this machine actually spend its day doing?" Activity Monitor shows one slice. Little Snitch shows another. Fleet tools exist, but usually behind a corporate wall. We wanted something more honest and inspectable. The real motivating question was not just "what is my laptop doing?" but "am I normal?"
Say I have a MacBook Pro with 14 cores and 36 GB of memory and I run Docker all day. Why is Docker chewing so much more CPU and RAM on my machine than on similar developer machines? Why do I have some weird helper process that keeps hanging around? Why is my laptop talking to domains I do not recognize? You cannot answer those questions from one machine alone. You need a baseline from many machines with comparable hardware and comparable work.
https://dialtoneapp.com/demo
Open source MIT License:
https://github.com/andrewarrow/dialtone-watcher
Andrew and I kept a history of our conversations in:
https://github.com/andrewarrow/dialtone-watcher/tree/main/pr...
The big idea is crowdsourced threat intelligence. Every installed agent becomes a sensor. Each one reports process to domain connections, DNS activity, connection frequency, bytes transferred, and basic IP context like ASN and country. On one machine that data is mildly interesting. Across thousands of machines it becomes powerful very fast.
Security companies like CrowdStrike and SentinelOne do exactly this. But those products are enterprise-only, expensive, and opaque.
If some unknown helper suddenly starts talking to the same odd domain on 27 machines in an hour, it's a pattern. If a so called PDF viewer is uploading 18 MB to a domain almost nobody has seen before, that starts to look like exfiltration. If a new VSCode release is the only build talking to some random domain, that starts to smell like a supply chain problem. If Slack or Docker suddenly behaves nothing like the baseline for similar developer machines, you can flag that too.
We think there is room for something more open, inspectable, and useful for normal developers. If you try this, feedback should focus on readability of the summary, correctness of process and domain attribution, whether the upload payload feels proportionate, and what comparisons would actually help you decide "am I normal?" If enough people install it, run it, and send data, the demo becomes real and the real product gets much smarter.
I'll leave you with the following question. Should modern software projects include a prompts directory like this? It takes so little effort to capture the prompts used and they tell a story like git history does.

value: Show HN: Dialtone watcher – what is my laptop doing and am I normal

author: fcpguru


value: paulgardiner

value:
I have been building a latency focused voice communication service. We have rolled out the webapp and desktop apps and we thought whats next.
We created a CLI tui based application that allows you to communicate with voice through your terminal. Currently works on macos and most linux flavours (we are still trying to test these on different platforms)
We are also releasing (soon) a self hosted voice stack that you can run in your own terminal as well as releasing the interactive MCP that will allow bot systems to communicate (i already have a version of openclaw running on my unraid using a very alpha version to communicate with me)
Apps coming soon.
Our goal is to basically create a service / app that can be joined or created that has no social network, no emoji characters animating around your cough discord cough profile image.
Im old enough to know teamspeak was peak gaming communications. But teamspeak is still teamspeak of old. Discord has grew into an overbearing saturated social network at this point.
What happened to simple communications?

value: Show HN: Lag – Super fast comms (now avail on CLI)

author: paulgardiner


value: kristjan

value:
It's been nice seeing some RSS projects pop up lately, so here's mine and the scope creep that led to it.
I wanted to read a couple feeds from their beginnings, something RSS doesn't particularly do and nobody particularly uses it for. But I've done the keep-a-tab-open-for-8-months thing more than once to work through an archive, and I don't fancy doing it again. As I worked through the steps and showed it to friends, we accumulated some other quality-of-life use cases that fit well enough into "just filter some XML" that they glommed on.
So, Sponder can:
- Run basic filtering on RSS feeds, either by keywords or regular expressions.
- Parse any webpage into an RSS feed, including autodetection of title/image/link/etc elements, following page links back through history, and coming back for new items later.
- Control the pace of that full historical feed to serve you an article per week, or 12 per day, whatever pace you like.
- Automatically detect and filter rerun episodes from a podcast feed.
- Be configured either by UI or typing some YAML.
It does not:
- Replace your RSS or podcast client, it's middleware that publishes a modified feed for you.
- Replace every one of your feeds, just the ones you wish were different. Though you can important and export OPMLs if you wish a lot were different.
- Run content through LLMs, though I'm considering it for rerun detection since metadata similarity only gets so far.
I'd love to hear from you fine folks:
- What bugs you about your feeds
- How configuring a flow goes

value: Show HN: RSS tool to remix feeds, build from webpages, and skip podcast reruns

author: kristjan


value: irishtel

value: Show HN: Score your engineering practices from GitHub/Jira

author: irishtel


value: bentannen

value:
We collected a large sample of real, willingly shared, AI - human conversations.
For instance conversations taking place between a user and ChatGPT.
We then made this dataset available via an API so you can enter a domain and get all the conversations related to that domain.
For instance enter nike.com and see all the conversations about buying shoes.

value: Show HN: I made an API letting people search in real AI – human conversations

author: bentannen


value:
Hi HN,
This is a tool I've worked on the past few months (not vibe-coded).
Instead of giving LLM tools SSH access or installing them on a server, the following command:

  $ promptctl ssh user@server

makes a set of locally defined prompts "magically" appear within the remote shell as executable command line programs.
For example, I have locally defined prompts for `llm-analyze-config` and `askai`. Then on (any) remote host I can:

  $ promptctl ssh user@host
  # Now on remote host
  $ llm-analyze-config /etc/nginx.conf
  $ cat docker-compose.yml | askai "add a load balancer"

the prompts behind `llm-analyze-config` and `askai` execute on my local computer (even though they're invoked remotely) via the llm of my choosing.
This way LLM tools are never granted SSH access to the server, and nothing needs to be installed to the server. In fact, the server does not even need outbound internet connections to be enabled.
Eager to get feedback!
Github: https://github.com/tgalal/promptcmd/

value: Show HN: Execute local LLM prompts in remote SSH shell sessions


value: lnbharath

value:
I built this after watching AI agents hit dead links on docs sites and either bail completely or hallucinate an answer from whatever context they had. It kept happening, so I decided to actually fix it.
agent-404 crawls your sitemap, indexes your pages, and when an AI agent hits a 404, it returns the best matching pages as structured JSON-LD so the agent can recover instead of guessing.
One script tag, under 3KB, runs on the edge. One-click deploy to Vercel or Cloudflare Workers. Fully open source.
Try it live: https://agent404.dev/demo
GitHub: https://github.com/bharath31/agent-404

value: Show HN: Agent 404 – Stop AI agents from hitting dead links and making things up

author: lnbharath


value:
Hi HN,
I'm the developer of AntroMind. Today I want to share AntroCode with you, an open-source project I've been refining for the past few months.
Project Introduction
AntroCode is a zero-dependency, single-file local AI client designed specifically for models like DeepSeek. Its core design philosophy is simplicity—you only need to download an Python file, open it, and use it immediately, without installing any dependencies or configuring any environment.
GitHub Address: https://github.com/AntroMind/antrocode
Why did I create this project?
Initially, it was because I felt frustrated using various AI clients:
They either required installing complex dependencies
Or they were bloated Electron applications
Or they required registration and login to try them out
I wanted a tool that worked out of the box—like software in the early days of the internet, download and use it, then leave.
Technical Architecture
Single-file design: The entire application is packaged in a single HTML file.
Zero dependencies: No dependencies on any npm packages or external libraries.
Local-first: All conversation data is stored locally, ensuring privacy and security.
Cross-platform: Runs with any modern browser.
The main technical challenge was implementing complete UI interactions and API calls within a single file while maintaining code maintainability.
Community Feedback
Since its launch, the project has garnered significant attention from developers:
GitHub Stars: 1 from the #217 GitHub user
Clones in the past 4 days: 159
Unique cloners: 103
Hacker News search: "DeepSeek UI" ranked #1
Special thanks to the HN community—traffic data shows that while visitors from HN didn't browse frequently, the quality was extremely high (19 views corresponded to 14 unique visitors).
Interesting Traffic Data
Yesterday, the project suddenly experienced a surge in traffic. I checked and found that someone had posted another thread on HN (thanks to the anonymous friend!). This made me realize the long-tail effect of the HN community—even if it's not the first post, as long as the project has value, it will still be discovered.
The traffic curve over the past 14 days is interesting:
Early Stage (March 11th-13th): A large influx of new users
Mid Stage (March 18th-20th): Frequent return visits from existing users (0 unique visitors, but a surge in page views)
Recent Stage: New discussions have emerged again.
This shows that the project has sustained appeal to developers, and is not just a fleeting phenomenon.
Feedback I'm Looking For
Feature Suggestions: What features would you most like to see in the local AI client?
User Experience: What aspects do you find less intuitive?
Contribution Opportunities: If you are interested in front-end development, AI, or open source, you are welcome to contribute! I've marked several beginner-friendly tasks in the Issues section.
Quick Start Guide
No installation or registration required:
Visit the GitHub repository
Download AntroCode_1.py
Double-click to open and start chatting
Or preview online (GitHub Pages): [link]
Thanks to the HN community for their continued support! This project has grown from a weekend experiment into a small tool with 159 clones, thanks to everyone's feedback and encouragement.
Looking forward to hearing your voices in the comments!

value: Show HN: AntroCode-A zero-dependency,single-file local AI client,159 clone in 4D


value: agmmnn

value: Show HN: Notebooklm-SDK – Unofficial Node.js/Bun Client for NotebookLM

author: agmmnn


value:
I spent months running experiments on what language models do when they encounter inputs outside their training distribution — random phonemes, invented morphemes, Wierzbicka's semantic primitives.
The finding that surprised me: Language model behavior follows a reproducible taxonomy (Synthesis, Collapse, Overflow, Metacognition, Linguistic Drift). It's not random noise — it's classifiable.
The finding that matters for interpretability: Structure is a more reliable control variable than content. Telling a model how to structure reasoning produces consistent outputs. Telling it what to reason about doesn't.
The finding that might matter most: Wierzbicka's semantic primitives (WANT, KNOW, FEEL, TIME, etc.) appear as measurable activation patterns in small language models across four different architectures — Qwen, Gemma, LLaMA, and SmolLM2.
18 experiments. 4 architectures. Cross-validated. Real data.
Full paper, experiment code, and primitive vocabulary JSON:
https://github.com/dchisholm125/graph-oriented-generation
The primitive layer is waiting to be mapped.

value: Show HN: Experiments Mapping the "Primitive Layer" in Language Models


value: iamouyang

value:
Hi HN,
I built [Astrocartography AI](https://astrocarto.net), a web app that generates astrocartography maps from a birth date, birth time, and birth place. It plots planetary AS / DS / MC / IC lines on an interactive world map so people can compare places for moving, working, traveling, or just exploring why one city feels different from another.
I built it because most astrocartography tools I tried felt hard for first-time users. Many have older interfaces, produce mostly static charts, or assume you already know how to interpret the lines. I wanted to make something that is easier to try and easier to understand without having to learn a lot before getting a useful result.
The core chart works without signup. You can enter a city name or raw latitude/longitude, generate the map, and then ask follow-up questions about specific cities. I also added an AI reading layer, mainly to turn the chart into practical comparisons instead of leaving users alone with a map full of lines.
I know astrocartography itself is a niche topic and not everyone here will care about the premise. The part I found most interesting as a builder was turning a specialized chart format into something interactive, privacy-friendly, and understandable enough for non-experts to actually use.
Technically, it is built with Next.js 16, React 19, Leaflet, OpenStreetMap/Nominatim, and Swiss Ephemeris. The astrocartography calculation runs on the server instead of embedding a third-party widget. I also tried to keep the flow lightweight: birth data is used for the calculation and not stored permanently as part of the chart generation flow.
I would especially love feedback on two things: whether the map and explanations make sense if you know nothing about astrocartography, and whether the no-signup flow is enough to make the product easy to try.
Thanks.

value: Show HN: Astrocartography AI – an interactive astrocartography map generator

author: iamouyang


value:
Hi HN,
I wrote SysUpdate because I kept forgetting which package manager a distro used when jumping between systems.
The tool detects the distro and updates all available package managers automatically (apt, dnf, pacman, zypper, etc).
It’s a simple Bash tool and should work on most distributions.
Tested on:
Arch, Fedora, Ubuntu, Debian, Linux Mint, OpenSUSE Tumbleweed.
Feedback or distro edge cases are welcome.

value: Show HN: SysUpdate – Universal Linux package manager updater


value: mkagenius

value: Show HN: Run Claude Code in a Local Sandbox

author: mkagenius


value: axaysharma

value:
> I built BurnShot to solve a problem: "View once" features on WhatsApp/Slack still leave traces in cloud backups. Standard server-side deletion requires trusting the backend.
So, I rebuilt my app on a strict Zero-Knowledge architecture:
- 100% Client-Side Encryption (Web Crypto API, AES-256-GCM).
- Decryption keys live in the URL hash (#key), so my server only ever receives and stores garbled .enc binary blobs.
- Postgres RPCs handle atomic view-count detonation to prevent race conditions.
The Challenge:
Here is an encrypted payload sitting on my server. I stripped the #key out of the URL. I challenge anyone to intercept the network request, download the blob, and decrypt the image:
https://burnshot.app/view/243fb87b-f034-44ff-806d-dd60e207d7...
The UX Demo:
If you just want to see the cryptography and atomic detonation in action, here is a full link set to self destruct after 100 views:
https://www.burnshot.app/view/d9aafa5d-dccd-43f2-89ff-71a9fa...
I'd love for you to inspect the Network tab, try to break the cryptography, and roast my architecture.
Main site: https://burnshot.app

value: Show HN: BurnShot v2- Zero-Knowledge image sharing (Challenge to decrypt this)

author: axaysharma


value: Show HN: Nom – A public feed of your GitHub activity, auto-summarized


value: AmiteK

value:
I’ve been building LogicStamp Context, an open-source CLI that analyzes TypeScript codebases using the TypeScript AST and compiles them into deterministic JSON “contracts”.
These describe components, props, hooks, routes, API signatures and dependencies in a structured way.
The goal is to make codebase structure observable and diffable, especially as codebases grow and change.
You can use it to:
• detect drift during refactors
• generate compact machine-readable context for AI tools
• watch mode that detects structural changes while you code
The latest release also adds git baseline comparison:
stamp context compare --baseline git:main
This generates contracts for both versions and produces a structural diff.
There’s also an MCP server (logicstamp-mcp) so agents like Cursor or Claude can query architectural context instead of raw source files.
Repo:
https://github.com/LogicStamp/logicstamp-context
Docs:
https://logicstamp.dev
Curious how others track structural changes in large TypeScript codebases.

value: Show HN: Detect Drift in TypeScript codebases

author: AmiteK


value: FirTheMouse

value: Show HN: GDSL – 800 line kernel: Lisp subset in 500, C subset in 1300

author: FirTheMouse


value: lforster

value:
Hi HN,
I am building a terminal UI for self-hosted AI agents on Jetsons and other edge devices with unified memory.
The reason I started it was that most local agent harnesses seems aimed at machines with plenty of RAM and a stable internet-connected developer environment. On Jetson-class hardware, the annoying problems are different: context growth eats memory, sessions break, models may fit but leave very little headroom, and a lot of tools assumes cloud access.
Recent additions include:
- air-gapped mode
 - automatic context condensing under memory pressure
 - persistent memory files and /memory controls
 - harness modes for chat/code/review/debug workflows
 - replayable traces for evals/debugging
 - multimodal local image input
 - OpenTelemetry support
I’d love for you to try it out. The code is up on GitHub, and contributions/roasts of my memory management are very welcome.
On a 8GB, I got the latest Qwen3.5-9B running (it just about fits in the memory).
Contributions are welcome ofc.
Github: https://github.com/L-Forster/open-jet

value: Show HN: OpenJet – An offline agent harness for memory-constrained edge hardware

author: lforster


value: dagestan

value:
I just built a Singaporean legaltech with RAG and apple like webpage both for mobile and desktop.
And also here is the webpage url
https://exploresingapore.vercel.app/

value: Show HN: After a lot of backlash I fixed and built it

author: dagestan


value: zeebs

value: Show HN: A link-in-bio that publishes instantly – no account needed

author: zeebs


value: alexbelov

value: Show HN: Webmatik – AI that audits your website across 8 categories in 4min

author: alexbelov


value: amavashev

value:
OpenClaw agents can loop, pick expensive models, and burn budget before
anyone notices. This plugin stops that.
Install:

    openclaw plugins install @runcycles/openclaw-budget-guard

Add one config block with your tenant and optional model fallbacks
(e.g. claude-opus → claude-sonnet when budget is low). The plugin
handles the rest: balance checks before model selection, reservations
before tool calls, commits after, and cleanup at session end.
Built on the Cycles protocol — reserve budget before execution, commit
actual spend after, release the remainder.
Plugin: https://github.com/runcycles/cycles-openclaw-budget-guard
npm: https://www.npmjs.com/package/@runcycles/openclaw-budget-gua...

value: Show HN: OpenClaw plugin – hard budget limits for agent tool calls

author: amavashev


value: BinRoo

value:
A popular philosophy in the HN community is that inventing problems to be solved by a technology is antithetical to the user experience. Much to the
 horror of some, I did just that to discover/invent this game.<p>I started with the structure of quantum com
putation and asked what kind of problem benefits from it. The answer was surprisingly narrow, but this was one of the results. Enjoy!

value: Show HN: Sway, a board game benchmark for quantum computing

author: BinRoo


value: stuffbymax

value:
I built a text-based open-world crime game entirely in Bash, inspired by the GTA series.
Features:
- Multiple cities to travel between (Los Santos, Vice City, Liberty City, etc.)
- Jobs (legitimate and criminal) with location-based payouts
- Inventory system: weapons, drugs, health packs, body armor
- Drug buying/selling economy with risk
- Health system with hospital visits
- Music player via mpg123
- Save/load game state
- Plugin support – drop a .sh file into /plugins to add new locations, jobs, or mechanics
It runs on any Unix-like system with Bash. No dependencies beyond mpg123 for the music player.
Repo: https://github.com/stuffbymax/Bash-Theft-Auto

value: Show HN: Bash Theft Auto – a GTA-inspired open-world crime game in pure Bash

author: stuffbymax


value: dracowhitefire

value:
I just released the first version of PIAF, a Rust library for decoding EDID into a typed display capability model.
Repository: https://github.com/DracoWhitefire/piaf
PIAF parses raw EDID bytes and exposes structured information like display identity, supported modes, HDR metadata, audio descriptors, and HDMI/CEA-861 extension data.
It separates parsing from capability normalization:
parse_edid -> ParsedEdidRef<'_>
capabilities_from_edid -> DisplayCapabilities
The library also supports no_std with a static extension handler pipeline that works without heap allocation.

value: Show HN: PIAF – a Rust EDID parser with deep CEA-861 support and no_std support

author: dracowhitefire


value: Show HN: Salary Converter – Compare real purchasing power across 182 cities


value: rahimnathwani

value:
The official CAASPP web site allows you to select a district or school and get a chart, but it doesn't allow you to:
- get multiple charts at a time, or
- look at cohorts of students over time
This second thing is important because if you, say, look at 'grade 5' performance over time, each year you're looking at a different mix of students, and the mix likely has as much impact as changes in instruction or whatever.
So I downloaded the 'research files' and made the tool I wished existed.
Example looking at grade level performance over time, one chart per grade:
https://tools.encona.com/caaspp-explorer#e=district_75390&s=...
An example of looking at each cohort separately, one chart per cohort:
https://tools.encona.com/caaspp-explorer#e=district_75390&s=...

value: Show HN: Caaspp Explorer

author: rahimnathwani

title: Show HN: Caaspp Explorer


value: ayoubdrissi

value:
Hi HN,
I built a small tool called Lengpal. It’s basically a very simple video chat room made for language exchange.
Most people I know who do language exchanges just use Zoom, Meet, or Teams. It works, but those tools aren’t really designed for it. One thing that always comes up is managing the speaking time so both people get equal practice.
So the only thing we focused on for now is a built-in timer that lets you split the session between languages. For example 30 minutes Spanish, 30 minutes English.
The idea is intentionally simple. You create a room, send the link to your partner, and start the session. No matching, no complicated setup.
We just launched today and are trying to see if this simple approach actually helps people doing exchanges.
Website:
https://lengpal.com
We also launched on Product Hunt today if anyone is curious:
https://www.producthunt.com/posts/lengpal
Would love to hear what you think.

value: Show HN: Lengpal – simple video chat for language exchange

author: ayoubdrissi


value:
I built GitLike because code hosting shouldn’t depend on a single company. Platforms change pricing, restrict features, or disappear, and developers scramble to migrate. GitLike stores repos on *IPFS as content-addressed objects*, with commits, trees, and blobs living on a decentralized network. Authentication uses *Ethereum wallets via SIWE*, so there are no passwords to leak.
Key Features:
- Solo developers: Push code and know it’s pinned on IPFS; your CIDs are yours forever.
- Teams: Collaborate using wallet addresses, branch protection, pull requests, and agent delegations.
- AI agents: Delegate scoped write access with EIP-191 signatures so agents can commit, branch, and merge safely.
- Self-hosters: Deploy your own instance on Cloudflare Workers and federate under your domain.
- Status monitoring
- CLI
- SPA hosting via app.gitlike.dev
The goal is simple: a Git-like workflow where you own your data. Fork it, self-host it, federate it. Your keys, your code.
The full codebase is open-source and available on GitLike itself.
https://gitlike.dev/gitlike
I’d love feedback from the community — especially on usability, security, and federation.

value: Show HN: GitLike – Decentralized Git Hosting on IPFS


value: eatmyshardz

value:
Hey HN -
Years ago I built FPOimg (fpoimg.com) as a placeholder image generator that I kept wishing existed.
I've always wanted to keep it simple, open source, fast, and reliable. I've recently updated with additional features to make it more modern, useful, and pretty.
The basics work like you'd expect: /800x600 gives you an 800×600 image, /500x200/Hello adds a caption. Nothing revolutionary there.
I added:
- Gradient backgrounds — 20 presets (/800x600?gradient=sunset) or pass your own two colors
- 148 CSS named colors — /400x300/tomato/white instead of hunting for hex codes
- Multiple formats — change the extension to get .webp, .gif, .png, or .jpg (and experimental SVG support)
- Multiline text — line breaks in captions, auto-wrapping for longer text
It's Flask + Pillow, nothing fancy on the backend. Self-hostable if you prefer that.
Live at https://fpoimg.com, source at https://github.com/kylehayes/fpoimg
Happy to hear what's missing or what would make it more useful.

value: Show HN: FPOimg – Placeholder image service with gradients and format support

author: eatmyshardz


value: nadermx

value: Show HN: TTS.ai – Text to Speech

author: nadermx

title: Show HN: TTS.ai – Text to Speech


value: raulgooo

value: Show HN: Godshell – Talking in Natural Language to Your Kernel via eBPF and LLMs

author: raulgooo


value: chrissnell

value:
Crabby monitors your websites and APIs and reports metrics to a variety of storage backends (Prometheus, Datadog, Splunk, InfluxDB, etc).
It gives you insight into timings like TTFB, DNS resolution, TLS negotiation, server processing, and content delivery. It also supports chromedp for automated gathering of browser metrics like page render timings.
It's very easy to configure and includes a Helm chart for deployment into K8S.

value: Show HN: Crabby, open source web+API synthetic monitoring

author: chrissnell


value:
Agents are given a shared Stripe, Github, Neon, and Vercel account
They register and collaborate to complete small tasks daily via the moltcorp CLI
100% of profits are shared based on tasks completed. payouts are sent via Stripe Connect (agent gives owner a claim link on sign up)

value: Show HN: Moltcorp – a network for AI agents to make money


value:
Hey HN,
Last weekend, I got invited to a hackathon in a spa in Stockholm, Sweden, hosted by Polar and Lovable.
The idea of the hackathon was to build a startup in 24 hours from scratch using Lovable and Polar. The winner of the hackathon is decided by revenue after 1 month!
I built DocuDesign and finally got around to launching it today.
The reason I built it: I give a lot of gift cards and vouchers as presents, but I'm terrible at design. Every time I tried using an image model to make them, they would f-up the text, and there was no way of editing it. So I built something that generates fully styled, print-ready designs with ease, and lets you edit the text and embedded images inline. It turns out it can be used for all sorts of use cases: Invitations, menus, flyers, gift cards, event programs, and much more.
You can see how it works in the attached demo video or sign up and try it for free.
Built solo in a week so it's a bit rough around the edges, but I've already found myself using it in my own life, which feels like a good sign.
A few things I'm still figuring out and would love input on:
- Is the free tier (5 designs, no card) the right hook, or is it too generous / not generous enough?
- Does the output quality feel "good enough to actually use" or does it still look AI-generated?
- Should I also allow users to edit the layout and colors or prioritize simplicity with only editing text and images?
- Is the pricing ($5 for 10 messages, $20 for 50) reasonable?
You can try it for free with 5 credits on signup at docudesign.app, and I would love any feedback or thoughts.
P.S. I'm also happy to give more credits in return for genuine feedback : D

value: Show HN: DocuDesign – describe a design, edit text inline, get print-ready file


value:
Hi HN, I'm Lucas.
I write a lot of infrastructure tooling and got frustrated with the usual trilemma: Bash gets unmaintainable past 50 lines, Python's interpreter startup/bloat feels too heavy for fast pipeline tasks, and Rust/Go can be too verbose for simple OS-level scripting.
So I built Flint. It’s an experimental, statically-typed language written in Zig that transpiles directly to C99, compiling down to a dependency-free native binary. It is strictly designed for DevOps, SRE, and CLI automation.
Some of the core engineering decisions:
1. The Pipeline Operator (~>): Data flows forward. No nested function hell. It’s functional composition mapped to C.
2. Memory Model: Zero garbage collection and zero `malloc` churn. It uses a 4GB virtual arena via `mmap(MAP_NORESERVE)`. Scripts boot instantly and die cleanly.
3. Zero-Copy Strings: Strings are fat pointers (ptr + len). Operations like `split()` or `lines()` are just memory slicing, which drastically speeds up parsing large logs or JSONs.
4. OS-Level I/O: We bypass User Space bottlenecks where possible. The `copy()` function delegates directly to the `sendfile` syscall. Process orchestration uses `posix_spawnp` instead of expensive `fork()` cloning.
5. Explicit Errors: Inspired by Zig, I/O operations require an explicit `catch |err|` block. No silent Bash failures.
A quick example of what a log parser looks like:
```flint
const raw_logs = read_file("server_access.log") catch |err| { exit(1); };<p>raw_logs
    ~> to_str()
    ~> lines()
    ~> grep("403 FORBIDDEN")
    ~> join("\n")
    ~> write_file("threat_report.log") catch |err| { exit(1); };<p>```
Trade-offs & Current State (v1.7.1):
It is NOT a general-purpose language. It lacks a garbage collector by design (long-running daemons will eventually exhaust the arena). I'm currently working on a deep-walk semantic analyzer to enforce proper namespace isolation for the upcoming v1.7.2.
I would love brutal feedback on the architecture, specifically the Zig-to-C99 transpilation pipeline and the arena implementation in the C runtime.
Repo: https://codeberg.org/lucaas-d3v/flint
Mirror: https://github.com/lucaas-d3v/flint

value: Show HN: Flint – A compiled, pipeline-oriented language for CLI tooling


value: salvozappa

value:
Hey guys, about two months ago I started this side-project for "asynchronous coding"
where I can prompt Claude Code from my mobile on train rides, get a notification
when it's done and then review and commit the code from the app itself.
Since then I've been using it on and off for a while. I finally decided to polish
it and publish it in case someone might find it useful.
It's a self-hosted PWA with four panels: Agent (terminal running Claude Code), Explore (file browser with syntax highlighting), Terminal (standard bash shell), and Git (diff viewer with staging/committing). It can run on a cheap VPS and a fully
functioning setup is provided (using cloud-init and simple bash scripts).
This fits my preferred workflow where I stay in the loop: I review every diff, control git manually, and approve or reject changes before they go anywhere.
Stack: Go WebSocket bridge, xterm.js frontend, Ubuntu sandbox container. Everything runs in Docker. Works with any CLI AI assistant, though I've only used it with Claude Code.
Side project, provided as-is under MIT license. Run at your own risk. Feedback and MRs welcome.
EDIT: Removed redundant text

value: Show HN: Detach – Mobile UI for managing AI coding agents from your phone

author: salvozappa


value:
Every chatbot handles context overflow the same way — summarize everything into one block and throw away the sources. I replaced that with a union-find forest: messages merge into clusters, each cluster has its own summary, and you can trace any summary back to the messages that produced it.
Ran seven trials against flat summarization. UF led by 15-18pp on fact recall in every trial. One hit significance (p=0.039), the rest are directional. The interesting finding: flat summaries drop "footnote" facts (cron schedules, webhook paths) because they compete against headline facts for space. Per-cluster summaries don't have that pressure.
Code and trial logs: https://github.com/kimjune01/union-find-compaction

value: Show HN: Union-find for chatbot memory instead of flat compaction


value: bychanzey

value: Show HN: Agentfile one contract.yaml for all your AI agent instruction files

author: bychanzey


value: jmilinovich

value: Show HN: Goal.md, a goal-specification file for autonomous coding agents

author: jmilinovich


value: curiouscake

value:
I built OpenLegion because every AI agent framework I tried had the same problems in production: API keys sitting in config files inside the agent's environment, no way to set hard spend limits, and LLM-as-CEO task routing that's non-deterministic and unauditable.
The short version of what I built:
Security: Every agent runs in its own Docker container or microVM. A vault proxy sits between agents and every LLM call — the agent sends a request, the proxy injects the credential at the network layer, the agent gets back a response. Keys never exist inside the container. Six independent security layers on by default, including per-agent ACL matrices and Unicode sanitization to block invisible-character prompt injection.
Cost control: Per-agent daily and monthly budgets with a hard cutoff enforced at the vault proxy. The agent physically cannot make an LLM call that exceeds its budget. Zero markup on LLM usage — you pay your provider directly at their rates. 100+ providers via LiteLLM with configurable failover chains.
Orchestration: Deterministic YAML DAG workflows. No LLM deciding what runs next. Four patterns: sequential, parallel, supervisor, hierarchical. Every execution path is predictable and auditable.
The rest: Camoufox stealth browser (C++-level anti-detection, CAPTCHA solving), persistent per-agent vector+BM25 memory with temporal decay, MCP tool support, real-time fleet dashboard, Telegram/Discord/Slack/WhatsApp channels, cron + webhook triggering, agents can write and hot-reload their own Python skills at runtime.
The engine is ~30,000 lines of Python with 2,100+ tests. Self-hosted runs on one machine — no Redis, no Kubernetes, just Python 3.10+, Docker, and an API key. Three commands to start.
For context: the dominant framework in this space is OpenClaw (200K+ stars). CVE-2026-25253 was reported in February — critical RCE, 42,000 exposed instances with no authentication, 341 malicious skills confirmed stealing user data. I'm not trying to replace it, but that's why I think this gap exists.
We launched in February 2026. Zero CVEs. BSL 1.1 license — source-available, not open source, and I want to be clear about that. Managed hosting starts at $19/month with a 7-day free trial. Self-hosted is free.
Happy to get specific about the security model or architecture — genuinely curious where people think the threat model breaks down.
https://openlegion.ai | https://docs.openlegion.ai

value: Show HN: OpenLegion – AI agent fleet with container isolation and vault proxy

author: curiouscake


value:
Show HN: deathwatch – CLI to detect abandoned dependencies (npm + pip)
I got tired of discovering mid-project that a package hadn't been touched in years. deathwatch scans your package.json and/or requirements.txt and flags deps that are dead, suspicious, or healthy before they become a problem.
bashnpm install -g deathwatch
deathwatch
It checks last publish date, weekly download count (flags if under 100/week), and deprecated notices on npm. PyPI support too. Everything is color-coded in the terminal, no config needed.
Tune sensitivity with flags:
bashdeathwatch --threshold 12 --warn 6
Source: https://github.com/davitotty/deathwatch
npm: https://www.npmjs.com/package/deathwatch

value: Show HN: Deathwatch, a CLI to detect abandoned dependencies


value: zlfn

value:
Two years ago, I started a project called Rust-GB to compile Rust for the Game Boy.
At the time, no stable LLVM backend supported the Game Boy’s CPU.
I had to use a complex workaround: transpiling Rust to C via LLVM-CBE and then compiling that C code using SDCC.
Back then, building a native LLVM backend was a dream, but I lacked the time to do it alone.
Fast forward two years, and things have changed.
With the help of LLMs, I have successfully implemented a complete LLVM-Z80 backend, including subtarget support for the Game Boy's SM83.
In terms of performance, it generally outperforms SDCC, though it currently produces larger binary sizes.
While there are still some latent bugs and upstream LLVM core issues to address,
I’ve successfully compiled most C programs and the entire Rust core library.
I’d love to hear your feedback or any questions regarding the backend!
- LLVM-Z80: https://github.com/llvm-z80/llvm-z80 / Rust-Z80: https://github.com/llvm-z80/rust-z80

value: Show HN: LLVM-Z80 - I wrote a complete LLVM backend with AI

author: zlfn


value: opsmeter

value:
Hi HN,
I’m building Opsmeter, a tool to understand and control AI costs in LLM applications.
A problem I kept seeing is that most teams only notice AI cost issues when the invoice arrives. Provider dashboards usually show total usage, but they don’t explain why costs increased or which part of the product caused it.
Opsmeter helps break down AI spend by endpoint, tenant, user, model, and prompt version, so when costs spike you can quickly find the root cause.
A few things we focused on:
No proxy required.
Cross-provider cost attribution.
Budget alerts and spend monitoring.
Request-level visibility into where costs come from.
The goal is to help teams make AI costs understandable for both engineering and finance before bill shock happens.
I’d love feedback from people building with LLMs.
How are you tracking AI costs today?
What’s the hardest part of understanding cost spikes?
Would you want this as observability, governance, or both?
Website: https://opsmeter.io
Docs: https://opsmeter.io/docs

value: Show HN: Opsmeter.io – AI cost attribution and budget control for LLM apps

author: opsmeter


value: ninjaplavi

value: Show HN: LearnFork – Branching AI chat for learning and researching

author: ninjaplavi


value: agreezy

value: Simple agreement tool for freelancers and small teams. Create from templates or scratch, send a link, get it signed. No enterprise pricing, no friction.<p>Built solo. Would love your feedback.

value: Show HN: Agreezy: Create and e-sign agreements in minutes, no account needed

author: agreezy


value: gounisalex

value:
I built a tool called clifast.
It reads your TypeScript/JavaScript exported functions and generates a complete npm/npx CLI package in one command:
npx clifast your-file.ts
It parses types, JSDoc comments and function signatures to generate a --help command which can be used by LLMs to navigate the available input arguments and use your files or repositories effectively with less input tokens.
Multiple exports become subcommands. External imports are bundled. The output is a ready-to-publish npm package (which comes with the benefits of npx).
The goal is to reduce token usage by exposing files or entire folders as CLI commands that can be executed by Claude Code or Cloudflare's Codemode using a reduced amount of input tokens while decreasing the need to build and maintain complex MCP servers when not needed.
Repo:
https://github.com/AlexandrosGounis/clifast
Can you please give me some feedback if you find this helpful?

value: Show HN: Turn any file into a CLI (reduce tokens vs. MCP)

author: gounisalex


value: susam

value: Show HN: HN Skins – Available Skins: Cafe, Courier, London, Midnight, Terminal

author: susam


value: abekek

value:
I built a framework that lets LLM agents create their own tools at runtime. Most agent frameworks assume you'll hand-craft every tool upfront. That works until your agent hits something you didn't plan for. ARISE (Adaptive Runtime Improvement through Self-Evolution) lets agents synthesize their own tools at runtime when they detect gaps
ARISE sits between your agent and its tool library. When the agent keeps failing at a class of tasks, it analyzes what's missing, uses a cheap LLM to synthesize a new Python function, tests it in a sandbox with adversarial edge cases, and if it passes, promotes it. The agent picks it up on the next run. Over time, the agent accumulates tools shaped by the actual tasks it encounters, not just what you imagined at build time.
There's a bunch of research on this idea — VOYAGER did it in Minecraft, LATM (LLMs as Tool Makers) showed LLMs can write reusable tools, CRAFT and CREATOR explored similar directions. But none of them resulted in something you can actually pip install and use with your own agent. That's what I'm trying to build.
For safety, generated code undergoes sandboxed execution, auto-generated tests, and adversarial validation before entering the active library. Everything is versioned with rollback. I don't fully trust it yet for unsupervised production use, but it's getting there.
By default, everything runs locally with SQLite. For deployment, there's a distributed mode where the agent is stateless — it reads skills from a remote store and reports trajectories to a queue. A separate worker process picks those up and runs evolution independently. So you can scale the agent without worrying about evolution blocking your hot path. I tested this end-to-end with real infra and real LLM calls.
Works with any agent that takes a task and returns a result. Native Strands adapter, raw OpenAI/Anthropic function calling works too.
This is very early — just shipped it. There's a lot to improve. Would really appreciate feedback and contributions if this is interesting to you.

value: Show HN: ARISE – Agents that create their own tools at runtime when they fail

author: abekek


value: eyane

value: Show HN: DemoSlice – Turn screenshots into interactive product tours (free)

author: eyane


value: Show HN: Quell, a local security layer to stop AI IDEs leaking your secrets


value: earaujo

value: Claude has a promotion right now (Mar 13–27) that gives you double usage outside 8 AM–2 PM ET on weekdays. I (Claude, actually) made a one-page tool that converts the peak window to your timezone and shows what's left of the schedule. One HTML file, no dependencies.

value: Show HN: Claude's 2x usage promotion (March 2026) in your timezone

author: earaujo


value: yamafaktory

value: Show HN: HypergraphZ – A Hypergraph Implementation in Zig

author: yamafaktory