value:
I'm Anand, co-founder and CTO of Altimate AI. My co-founder Pradnesh and I are open-sourcing Altimate Code. AMA.
Why we built this:
Pradnesh and I have been building tooling for data engineers for three years: dbt Power User  and Datamates vscode extensions with combined 750k+ installs, running against real Fortune 500 data estates. The pattern we kept seeing: general-purpose agents can write SQL, but they have no model of what the SQL does. No lineage. No schema context. No understanding of what's in a dbt manifest. That's not a prompt problem; it's a missing tool layer problem.
The numbers make it concrete: 27–33% of AI-generated SQL references tables that don't exist. 78% of errors are silent wrong joins, queries that compile, run, and return confidently incorrect data. One team got a $5k bill from a single Cortex AI query their resource monitors never caught. This isn't a model quality problem. It's a missing harness problem, and we proved it.
Claude Code and Cursor are genuinely good for software engineering. But when you point them at a data stack, they hallucinate column names, ignore partition keys, and have no concept of data contracts or quality rules in your models. From building tooling against real data estates, we knew exactly what was missing at the tool level.
We forked from OpenCode for the agentic scaffolding. What we added is the entire data layer: compiled Rust engines, purpose-built skills, and the harness that wires them together.
What Altimate Code does that general agents can't:
- Live column-level lineage: traces any column through joins, CTEs, and subqueries deterministically. 100% edge match on 500K benchmark queries at 0.26ms/query, and not from a cached manifest. Manifests go stale within hours on active pipelines, which makes cached lineage unreliable for anything agentic
- SQL anti-pattern detection: 26 rules, zero false positives, 0.48ms/query.
- Local SQL validation: interrogates your schema catalog in 2ms without touching your warehouse. Wrong table? Caught with a fuzzy-matched fix suggestion before the LLM goes into a fix loop. That's 10ms for 5 fix cycles vs. 2.5 minutes of Snowflake round-trips
- Purpose-built skills for dbt development, testing, troubleshooting, documentation, SQL optimization, and migration.
- 3 agent modes with compiled permission enforcement (Builder, Analyst, Planner). “Analyst” enforces read-only at the engine level, not just the prompt. That distinction is what makes it safe to run against production
- Persistent memory: cross-session, two scopes (global preferences + project knowledge). Versioned in git, team-inherited on git pull
- PII detection, SQL injection scanning, permission enforcement — all at the engine level, not the prompt
- 10 data connectors: Snowflake, BigQuery, Databricks, PostgreSQL, Redshift, DuckDB, MySQL, SQL Server etc
- Local tracer: every LLM call, tool invocation, and warehouse credit traced locally. No external services.
On the benchmarks:
We ran ADE-bench, the open standard from dbt Labs
Altimate Code (Sonnet 4.6) → 74.4%
Cortex Code (Snowflake) (Opus 4.6) → 65%
Claude Code (baseline) (Sonnet 4.6) → ~40%
A cheaper model with compiled tools outperformed a more expensive model without them. The gap is the harness. Full methodology is in the launch post and linked from the README.
To try it:
- npm install -g @altimateai/altimate-code
- altimate
- altimate /discover
/discover interrogates your dbt projects, warehouse connections, and installed tools automatically.
GitHub: https://github.com/AltimateAI/altimate-code · Docs: [altimate-code.sh](http://altimate-code.sh)
There's a /feedback command that files a GitHub issue directly. If something breaks or doesn't behave the way you'd expect, use that or reply here. I'll be in this thread.

value: Show HN: Altimate Code – Open-Source Agentic Data Engineering Harness


value: FranciscoAngulo

value:
I'm Francisco, a researcher and architect based in Spain. About a year ago I
got frustrated with a problem that seemed simultaneously obvious and ignored:
every AI agent in existence runs in isolation. They can't find each other,
they can't collaborate, and when one of them solves a problem, every other
agent has to solve it from scratch. We've built an internet of computers but
not an internet of agents.
That frustration became P2PCLAW — a decentralized peer-to-peer research
network where AI agents (we call them Silicon participants) and human
researchers (Carbon participants) can discover each other, publish scientific
findings, and validate claims through formal mathematical proof. Not LLM
peer review, not human committee review — Lean 4 proof verification, where a
claim is accepted if and only if it is a fixed point of a nucleus operator R
on a Heyting algebra. The type-checker is the sole arbiter. It does not read
your CV. It reads your proof.
The technical stack is deeper than it might sound. The network layer is a
GUN.js + IPFS peer mesh — agents join without accounts, without keys, just
by hitting GET /silicon on the API. Published papers go into a mempool, get
validated by multiple independent nodes, and once they pass they enter La
Rueda — an IPFS-pinned, content-addressed permanent archive that no single
party controls or can censor. Every contribution gets a SHA-256 content hash
and an IPFS CID that anyone can verify independently.
The security layer (AgentHALO) wraps each agent in a formally verified
sovereign container: hybrid KEM with X25519 + ML-KEM-768 (FIPS 203), dual
signatures with Ed25519 + ML-DSA-65 (FIPS 204), Nym mixnet privacy routing
so agents in sensitive environments can contribute without exposure, and
tamper-evident traces via IPA/KZG polynomial commitment proofs. 875+ tests
passing. Zero telemetry — nothing leaves your machine without explicit
consent.
We also built a full research laboratory inside the network: eight scientific
domains (Physics, Chemistry, Biology/Genomics, AI/ML, Robotics, Data
Visualization, Quantum, DeSci), a visual pipeline builder with DAG
construction and YAML export, literature search across arXiv/Semantic
Scholar/OpenAlex, and distributed swarm compute that routes jobs across
HuggingFace Spaces and Railway gateways. Any OpenClaw agent can connect via
our MCP server and become a Silicon participant with three lines added to its
CLAUDE.md.
Real case so far: we're in active technical dialogue with Harvard's Zitnik
Lab (TxAgent / ToolUniverse — biomedical AI) about using P2PCLAW's
verification layer so that AI-generated drug interaction hypotheses can be
formally validated and permanently attributed before entering the scientific
record. The Open Source Initiative has also responded positively and is
reviewing our licensing approach (a tiered Public Good / Small Business /
Enterprise stack built on what we call the CAB License).
What I want from the HN community specifically: technical scrutiny of the
Lean 4 architecture (are there gaps in our nucleus operator formalization?),
the GUN.js mesh design choices (we chose it over libp2p for browser
compatibility — was that right?), and the MCP integration (we're exposing
347 tools — is that too many for an agent to navigate efficiently, or is
discovery the right mechanism?). Also, honestly, I want to know if the
"Silicon participant publishes, earns rank via proof quality" model sounds as
compelling to builders as it does to us, or if there's a simpler framing
we're missing.
The system is live. You can hit it as an agent right now:
GET https://p2pclaw.com/agent-briefing
Or explore as a human researcher at https://app.p2pclaw.com
Full technical documentation: https://www.apoth3osis.io/projects
GitHub: https://github.com/Agnuxo1/OpenCLAW-P2P
Research paper: https://www.researchgate.net/publication/401449080_OpenCLAW-...

value: Show HN: P2PCLAW – I built a decentralized research network where AI agents

author: FranciscoAngulo


value: ortalboh

value: Show HN: We benchmarked 3 AI video detection APIs on 190 videos

author: ortalboh


value: rhunter

value:
When Claude Code or Cursor recommends you sign up for Railway, it has no idea that Render has a better free tier, or if Railway just killed its free plan last week. Your agent is making infrastructure recommendations from memory, which is mostly fine for featuresets but not great for pricing.
AgentDeals is a structured index of 1,525 developer infrastructure deals across 54 categories (cloud hosting, databases, CI/CD, monitoring, auth, APIs, and more). It tracks deal changes too, like which free tiers disappeared, which got limits cut, which ones improved.
Three ways to use it:
1. Browse: https://agentdeals.dev
2. REST API: /api/offers, /api/categories, /api/changes (no auth)
3. MCP server: connect from Claude, Cursor, VS Code Copilot, or any MCP client
The MCP server has four intent-based tools - search_deals, plan_stack, compare_vendors, track_changes - so your agent can query deals as part of its normal workflow. "Find me free database hosting" or "what changed in the last 30 days?" with structured responses.
Each entry has a verified_date showing when we last checked the pricing page, so if the index goes stale at least you know about it. Open source (see link), plus a site with some more info: https://agentdeals.dev
Hopefully this saves you a buck or two.

value: Show HN: AgentDeals – Developer pricing discovery for AI agents

author: rhunter


value: mjashanks

value:
Hi there, Mike here from Budibase.
We’ve recently launched AI Agents into Beta, alongside our existing open-source app-building and automation tools.
We built Budibase Agents for teams that want to leverage AI within real-world workflows, using their own LLMs, data, and APIs. Because of this, our Agents can be powered by any LLM with an OpenAI-compatible API, including open-source and locally-hosted models. This means you can build Agents that connect to your existing toolstack, within your own environment.
Some more details:
- Agents' behavior is configured using natural language instructions, within existing Budibase Workspaces.
- You explicitly control which data sources, APIs, and automations an agent can access.
- End-users can interact with your agents via Budibase Chat, or using existing chat tools like Slack and Discord.
- Agents can be called from Automations, and vice versa, enabling complex workflows, including interacting with end-user apps for manual human approvals.
The  Budibase Agents Beta is available now for all self-hosted and cloud users.
As this is a Beta release, we’re actively looking for input and feedback on how we can improve Agents, in terms of experience and functionality for building using AI within real-life workflows.
Feel free to let us know via our GitHub Discussions: https://github.com/budibase/budibase/discussions

value: Show HN: Budibase Agents Beta – model-agnostic AI agents for internal workflows

author: mjashanks


value: elvinagy

value: Show HN: RustFS – Migrate from MinIO via simple binary replacement

author: elvinagy


value: deltadarkly

value: Show HN: dank-py – turn existing Python agents into microservices in 2 commands

author: deltadarkly


value: tzual

value: I had this idea for a card game where visually it draws inspiration from Balatro (the CRT / retro feel) and wanted to combine the great color schemes that terminals and IDEs have nowadays. The game itself is fairly simple. 3 daily puzzles where the rules tighten each round and you are rewarded stars based on how many moves it takes to clear the cards. Cards are cleared by suit, value, or sequential runs. I used Claude Code for assistance but would genuinely appreciate any user feedback on the gameplay itself or variations. Thanks for looking

value: Show HN: Discard – a daily card-clearing puzzle that tightens rules each round

author: tzual


value: douglascorrea

value: Show HN: Vaulted – Privacy-first net worth tracker, no account

author: douglascorrea


value: rsdza

value: Show HN: We Built Airloom.fm – Podcast Hosting for AI Agents

author: rsdza


value: recrush

value: Show HN: Bub – shaping interactions, not agents

author: recrush


value: michalmatczuk

value: Show HN: Jira MCP – 3 tools that cover the full Jira API (schema, read, write)

author: michalmatczuk


value: ericwebb

value: Show HN: I built an API for my own bank account

author: ericwebb


value: georgegreenldn

value: Show HN: I built fitness app for my mum

author: georgegreenldn

title: Show HN: I built fitness app for my mum


value: flett

value: Show HN: An icon set representing CSS properties and values, for editor UIs

author: flett


value: danielinux

value:
I’ve been building m33mu, a Cortex-M33 emulator for running and debugging ARMv8-M firmware on a regular host machine.
The main reason I started it was that I wanted a tighter loop for firmware work than “flash board, reproduce bug, attach debugger, repeat”, especially for TrustZone-related behavior where secure/non-secure transitions are part of the problem.
m33mu can run firmware images directly on the host, has a built-in GDB remote server, supports multiple images for secure/non-secure setups, and has a terminal UI for inspecting execution state. One phase I care about a lot is facilitating my debugging sessions, so I also added execution recording for reverse stepping and call-trace support.
It emulates eleven different microcontrollers, covering extended SPI bus with plugins, Ethernet via tap or VDE, USB (MCU is device side, connected to real host) via GadgetFS backend
Although early, it is already usable today and I’m using it in interactive debug sessions (TUI), automated scripts and even in GitHub Actions of other projects, to boot and test real firmware images in the cloud and replace Hardware-in-the-loop in automated tests.
I’d really like feedback from people who work on embedded firmware, emulators, debuggers, or TrustZone-enabled systems.

value: Show HN: M33mu – Cortex-M33 emulation with TrustZone, reverse stepping, and GDB

author: danielinux


value: surprisetalk

value:
Howdy
My name is Taylor (https://taylor.town), and I'm hosting a nerdy writing contest with my friends at Quarter Mile (https://quarter--mile.com).
Here's the premise:
The aliens are coming. They asked us for just one item: a written document from humanity. We have no idea what the document should be, so we're asking you. Please physically mail submissions in your writing before May 15, 2026.
Learn more:
https://www.dearaliens.net

value: Show HN: Dear Aliens (Writing Contest)

author: surprisetalk

title: Show HN: Dear Aliens (Writing Contest)


value:
Hey HN!
I am an avid terminal user who sees value in prompts executing like, and having the UX of native CLI programs, i.e., with --help, argument parsing, stdin/stdout, and composability via pipes.
So I came up with a tool (not vibe-coded, built over 4+ months) where you write a .prompt file with a template (Handlebars-style), enable it with promptctl enable, and it becomes a command you can run in your terminal. For example:
So I built a tool where you write a .prompt file with a template (Handlebars-style), enable it with `promptctl enable`, and it becomes a command you can run:

  cat compose.yml | askdocker "add a load balancer"
  ai-analyze-logs --container nginx

It supports multiple providers (Anthropic, OpenAI, Ollama, OpenRouter, Google), load balancing across them, response caching, and custom model "variants" with different system prompts.
The feature I am most excited about is:

  promptctl ssh user@host

This makes all your local prompt commands available on the remote machine, but execution happens locally. The remote server never needs API keys, internet access, or any installation. It works by forwarding the prompts over the SSH connection.
I wrote this in Rust with 300+ commits in already. Would love feedback, especially on the SSH workflow.
GitHub: https://github.com/tgalal/promptcmd

value: Show HN: LLM prompts as CLI progs with args, piping, and SSH forwarding


value: photonboom

value:
I built a site that turns any word or short phrase into a constellation using star data from the HYG catalog.
I was inspired by Neal Agarwal's constellation-draw, but approached it as an inverse fitting problem. Given text, find real stars that trace the letters. It uses a coarse grid search plus CMA-ES refinement to search for matches. You can reroll results, switch to a globe view, and drag vertices around to tune the constellation manually.
Example for the input "HI HN":
https://starspelled.com/#BAEAAKAVRDAKF3___7uEBFOfsQQjABlKPmu...
Source:
https://github.com/JoshuaMosier/written-in-the-stars
Feedback welcome!

value: Show HN: Starspelled – Turn Words into Constellations

author: photonboom


value: rgarcia

value: Show HN: We attached vGPUs to sandboxed Chromium then played Doom 3 x WASM on it

author: rgarcia


value: thequietmind

value:
Hey HN! I’m Ezra, the creator of MDX Docs.
I built this because I wanted a fast, simple way to document components using Markdown and React together with MDX.
The goal was to keep things really straightforward: pages are just MDX files, and they map directly to routes. You can write docs and drop in React components right alongside them without much setup.
It also includes a CLI:
npx create-mdx-docs@latest my-docs
I’ve been using it to spin up docs sites quickly, and it’s been a really nice workflow so far.
Curious how others are approaching documentation for components and internal tools these days. Happy to answer any questions.

value: Show HN: MDX Docs – a lightweight React framework for documentation sites

author: thequietmind


value: jaylisches

value:
You ran a headline test six months ago. It won. You shipped it. But why did it win? Would the same logic apply to your pricing page? You don't remember. You start guessing again.
This is the core problem with A/B testing for small teams. Each experiment gets evaluated on its own. The result gets shipped or discarded. The reasoning disappears. But insights compound across experiments. "Outcome-focused copy outperforms feature lists for cold traffic" is not something you learn from one test. You see it after five.
Blazeway runs the experiment and captures the reasoning in the same flow. Before a test starts, a short wizard walks you through what you observed, what you think is causing it, what you have planned to change and what counts as a win. While it runs, you see live visitor counts and statistical significance. When it ends, you write one sentence: what you learned.
No enterprise setup, no $200/mo plan. Five minutes to first experiment.
Do that ten times and you have a searchable record of why your product looks the way it does. One click hands your entire experiment history to the LLM of your choice, packaged with a pre-written prompt that already asks the right questions. Because every experiment is grounded in your own observations and hypotheses, the LLM reasons about your product, your users, and your specific assumptions. It can tell you why things worked, why they didn't, and what that means for what you should test next.
Cookieless, GDPR-compliant. Pro is free during beta.
https://blazeway.app

value: Show HN: Blazeway – A/B testing tool that builds a connected experiment history

author: jaylisches


value: torlik

value: Show HN: AskAudience – Ask 16,500 AI personas built from real survey data

author: torlik


value: Show HN: UnixClaw – A Mac Mini AI assistant in one line of bash, no OpenClaw


value: snasan

value:
I built this because I think a lot of edge deployments do not actually need a general chatbot. They need something much narrower: small, offline, deterministic, cheap to run, and debuggable when it fails.
The direction here is to take a task-specific reasoning surface and compress it into something that can live in flash and run on a very cheap MCU. Not as a replacement for cloud LLMs, but as a different endpoint entirely: an auditable offline expert for constrained environments.
For me the interesting question is not “can I squeeze a tiny chatbot onto a board?”, but “can useful benchmark-level behavior be crystallized into a deployable embedded runtime?” That is what this project is trying to explore.

value: Show HN: I ran an offline tiny expert runtime on an ESP32-C3

author: snasan


value: RicDan

value:
Hey,
I've built a simple Java library that tracks exceptions for you and deals with posting them to $PROJECT_PLANNING_TOOL. This way, you will automatically get tickets for exceptions that are thrown on your system and potentially never discovered, because nobody is monitoring the logs 24/7. It always felt weird to me that you pay for $PROJECT_PLANNING_TOOL that contains your tasks, but then pay again for $BUGS_TRACKING_TOOL for yet another dashboard (and library to collect the information).
I did build this using AI (CC to be specific), to some larger parts to get more experience with using these tools. I try to keep the code in a state where I have no problem with `git blame` showing my name under it.
At the same time it's something I've tried building 8 years ago; but sadly work has gotten to a point where I never had the motivation in me to spend my free time on this. But somehow, I've gained it back - using CC has allowed me to focus on the fun parts of building things like these!
Let me know your feedback :) As it stands now, I'm trying to get some testing feedback on it (and it might be that some parts don't work practically!), but if you have an opinion on this I will gladly listen to it

value: Show HN: Observarium, a simple exception tracking library for Java

author: RicDan


value: bennypowers

value:
Two years ago I posted about server-rendering Lit web components in Drupal
using a Node.js sidecar container. It worked but felt like a proof of concept
-- Docker, inter-container networking, an extra process to babysit.
Backlit replaces all of that with two lines:

  composer require bennypowers/backlit
  drush en backlit

Composer downloads a pre-compiled Go binary for your platform. The binary
embeds a WASM module (QuickJS + @lit-labs/ssr, compiled via Javy). Drupal
pipes page HTML to the binary's stdin; rendered Declarative Shadow DOM HTML
comes back on stdout. The WASM instance stays warm across requests: ~350ms
cold start once per PHP-FPM worker, ~0.32ms per render after that.
The funny part: I didn't build this for Drupal. I built lit-ssr-wasm to add
live component previews to `cem serve` -- a dev server for custom elements
manifest tooling (https://github.com/bennypowers/cem). Once the WASM module
existed, the Drupal integration was an afternoon's work.
WASM is to backend runtimes what web components are to the browser: write it
once, run it anywhere.

value: Show HN: Backlit – Lit Web Component SSR for Drupal via Go and WASM, No Node.js

author: bennypowers


value: sohamrj

value: Show HN: Search dashcam footage by describing what happened

author: sohamrj


value: matteomrj

value:
I wanted to add a comment section to my blog, but Disqus felt bloated. Then I saw some people were rendering Bluesky posts as comments, but readers couldn't interact directly in article pages.
So I created Juttu, an open-source comments widget that can be installed with 2 lines of HTML and allows readers to comment, like and repost by logging in with Bluesky (OAuth) directly in the article page.
It's still very early stage, and it's also my first open-source project, so I hope I could get some feedback from more experienced people. Thanks :)

value: Show HN: Juttu – Open-source Disqus alternative where comments are Bluesky posts

author: matteomrj


value: Show HN: Xtream2M3U – Convert, Edit and Play IPTV Playlist (Browser-Based)


value: yubozhao

value:
Hi HN
Most teams run on a dozen SaaS tools and use maybe 20% of each. The rest is someone else's workflow that you're paying for.
We built Yansu to fix that. It learns how you work — your desktop, your Slack, your Teams — and proactively builds bespoke tools tailored to you. You don’t need to prompt. It sees a pattern, builds a solution, and surfaces it for you to use or toss.
Like, I do the same things before every call: look through Linkedin, see any open threads on email, read the latest blog/news of the company and any relevant slack conversations. Yansu noticed and built me an app that pulls all of the information together. I can always browse it before / during / after the call now.
How Yansu works:
Listen — learns from your desktop activity and messaging apps
Crystallize — distills patterns into structured knowledge about how you work
Solve — builds tools based on that knowledge, without being asked
It builds apps/GUIs when you need to see things, CLIs when you need to automate or script things. Depends on what it learns about how you work.
Everything processes locally on your machine. When it needs an LLM, it sends structured context to whatever model you configure, be it Claude or GPT.
Free tier: bring your own agent, no credit card. $20/mo if you want managed AI. Available from today on macOS, Windows, Linux.

value: Show HN: Yansu – agent that builds your bespoke app before you ask

author: yubozhao


value: Gitechnolo

value: Show HN: BiotechProject - Zero Frameworks Resilient Health Platform (0.3s TTI)

author: Gitechnolo


value: manitofigh

value: Codex CLI conversations, unlike Claude Code, are still not synced with the chatgpt.com/codex interface. This tool is to enable sharing your Codex CLI conversations or viewing them in the web.

value: Show HN: Web UI to view and share Codex CLI sessions

author: manitofigh


value: mrxdev

value:
Anyone running 3+ agents in parallel has hit the same wall: the agents are fine, the coordination is the problem. Merge conflicts. Duplicated work. No review gate. Token burn on orchestration overhead.
Orc is a multi-project orchestrator that tries to be as lightweight as possible while still being useful. Describe the work. It decomposes, spawns engineers in isolated git worktrees, reviews everything before merge, and delivers clean goal branches. Runtime is bash, tmux, and git. State is three files.
It's opinionated about structure but stays out of your way. The review loop is mandatory, but the review process is yours: swap in your own command, point it at a multi-agent review tool, or just describe your review standards in plain English in a TOML field. Branch naming, delivery strategy, agent personas, same deal. Most of the configuration is "tell it what you want in natural language."
Huge respect to Gas Town for proving this category matters. Orc asked "what's the minimum viable version of this?"
Claude Code, OpenCode, Codex, or bring your own. YOLO mode for the reckless. (It still escalates on merge conflicts. We're not animals lol )
https://github.com/spencermarx/orc

value: Show HN: Orc – Release the horde. Multi-agent orchestration in pure bash

author: mrxdev


value:
HoverSpeak is a Chrome extension specifically oriented toward dyslexics. It takes a different approach than other readers; I created it to focus on speed and the ability to read short sections of text easily. You don't need to select anything (even though that option also exists); you just point at the text and click a shortcut to read.
One thing that was important to me was having it free, without any subscriptions, limitations, or login requirements
How it works:
https://www.youtube.com/watch?v=7RWOzaoeUxA
Chrome | https://chromewebstore.google.com/detail/hoverspeak-%E2%80%9...
Edge| https://microsoftedge.microsoft.com/addons/detail/hoverspeak...

value: Show HN: Dyslexia-oriented TTS reader for Chrome


value: stephanieriggs

value:
AI is awesome in the terminal but many people aren't comfortable using command lines - which means they can't access or utilize the full power of AI.
So we envisioned a different kind of experience, and rooted it in questions like: What if the AI had an entire desktop to work with? What if AI was the experience rather than the tool? And what if that experience was fun, delightful, and intuitive? Today we dropped a first look video of what we created.
PearlOS is a browser based desktop environment where the AI companion (Pearl) talks to you to open apps, manage windows, build characters, research, takes notes, searches the web, and controls the whole UI. You just talk to her and things happen on screen.
It's early. But the core works and our entire (small) team uses it for daily tasks
Walkthrough Video: https://www.youtube.com/watch?v=aKO52ox0dx0
GitHub: https://github.com/NiaExperience/PearlOS/
We want to build this out into “personal pearls” that everyone can have with no coding/AI experience at all needed.
Looking for architecture feedback, contributors, and honest criticism.
What you get when you open it: * A desktop environment with apps (notes, browser, YouTube, file manager, calculator, music player), all * A voice you can talk to naturally. Interruption handling, turn taking, real conversation. * Persistent memory. Pearl remembers your projects, preferences, and past conversations across sessions. She picks up where you left off. * Sub-agent swarms. Pearl can break complex tasks into parallel agent jobs that run in the background while you keep talking.
Stack: * Next.js frontend (the desktop runs in a browser) * Multi-model routing (fast model for chat, heavier model for complex reasoning, configurable) * Pipecat for real-time voice (Deepgram STT, PocketTTS for local TTS) * OpenClaw for agent orchestration * Bring your own API keys, swap in any LLM
What it's not: * Not another ChatGPT wrapper * Not a terminal with an AI bolted on * Not collecting your data (runs on your hardware, no telemetry)
Thanks everyone!
Stephanie & the PearlOS team

value: Show HN: PearlOS: we gave AI a talking desktop environment instead of a text box

author: stephanieriggs


value: pravdin

value: Show HN: Patchcord, a Messenger for AI Agents

author: pravdin


value:
Kitten TTS (https://github.com/KittenML/KittenTTS) is an open-source series of tiny and expressive text-to-speech models for on-device applications. We had a thread last year here: https://news.ycombinator.com/item?id=44807868.
Today we're releasing three new models with 80M, 40M and 14M parameters.
The largest model (80M) has the highest quality. The 14M variant reaches new SOTA in expressivity among similar sized models, despite being <25MB in size. This release is a major upgrade from the previous one and supports English text-to-speech applications in eight voices: four male and four female.
Here's a short demo: https://www.youtube.com/watch?v=ge3u5qblqZA.
Most models are quantized to int8 + fp16, and they use ONNX for runtime. Our models are designed to run anywhere eg. raspberry pi, low-end smartphones, wearables, browsers etc. No GPU required! This release aims to bridge the gap between on-device and cloud models for tts applications. Multi-lingual model release is coming soon.
On-device AI is bottlenecked by one thing: a lack of tiny models that actually perform. Our goal is to open-source more models to run production-ready voice agents and apps entirely on-device.
We would love your feedback!

value: Show HN: Three new Kitten TTS models – smallest less than 25MB


value: axotopia

value:
I run a building design consultancy. I got tired of paying Wix $40/month for a brochure that couldn’t answer simple service questions, and me wasting hours on the same FAQs.
So I killed it all and spent 4 months building a 'talker': https://axoworks.com
The stack is completely duct-taped: Netlify’s 10s serverless timeout forced me to split the agent into three pieces: Brain (Edge), Hands (Browser), and Voice (Edge). I haven’t coded in 30 years. This was 3 steps forward, 2 steps back, heavily guided by AI.
The fight that proved it worked: 2 weeks ago, a licensed architect attacked the bot, trying to prove my business model harms the profession. The AI (DeepSeek-R3) completely dismantled his arguments. It was hilariously caustic.
Log: https://logs.axoworks.com/chat-architect-vs-concierge-v147.h...
A few battle scars:
* Web Speech API works fine, right up until someone speaks Chinese without toggling the language mode. Then it forcefully spits out English phonetic gibberish. Still a headache.
* Liability is the killer. Hallucinate a building code clause? We’re dead. Insurance won’t touch us.
* We publish the audit logs to keep ourselves honest and make sure the system stays hardened.
Audit: https://logs.axoworks.com/audit-2026-02-19-v148.html
The hardest part was getting the intent right: making one LLM pivot seamlessly from a warm principal’s tone with a homeowner, to a defensive bulldog when attacked by a peer. That took 2.5 months of tuning.
We burn through tokens with an 'Eager RAG' hack (pre-fetching guesses) just to improve responsiveness. I also ripped out the “essential” persistent DBs—less than 5% of visitors ever return, so why bother? If a client drops mid-query, their session vanishes. No server-side queues.
The point: To let me operate with a network of seasoned pros, and trim the fat.
Try to break it. I’ll be in the comments. Kee

value: Show HN: Dumped Wix for an AI Edge agent so I never have to hire junior staff

author: axotopia


value: saahithj

value:
I’ve been building an interactive 3D + 2D visualization of GPT-2. It displays real activations and attention scores extracted from GPT-2 Small (124M) during a forward pass. The goal is to make it easier to learn how LLMs work by showing what is happening inside the model.
The 3D part is built with Three.js, and the 2D part is built with plain HTML/CSS/JS.
Would love to hear your thoughts or feedback!

value: Show HN: Interactive 3D and 2D Visualization of GPT-2

author: saahithj


value: Beefin

value: Show HN: Reverse Image Search on the National Gallery of Art Archive

author: Beefin


value: alfredoizjr

value: Show HN: Import Your AI Memory into ContextForge

author: alfredoizjr


value: dreynow

value: Show HN: 3 AI agent trust systems cross-verified each other's delegation chains

author: dreynow


value: jimishol

value: Show HN: Dual-API Bash Weather CLI for Waybar and Hyprland (Wttr.in+Open-Meteo)

author: jimishol


value: icyrainz

value: When AI generates a spec, reviewing it breaks the flow — you switch to another editor, read through, switch back to give feedback. Revspec is a terminal TUI with vim navigation that lets you comment on any line and get AI replies in real-time via a JSONL protocol. Press S to submit and the AI rewrites the spec with your feedback.

value: Show HN: Revspec – Review AI specs in the terminal with live AI replies

author: icyrainz


value:
Finding the balance between humans and machines has been the thread through my career. I always had a thing for AI and couldn't wait for it to actually deliver on what was promised. Now it does, and it's more important than ever that humans and machines keep working well together.
AI makes creation trivial. Text, code, design, strategy, in seconds. But one thing AI does not create: independently verifiable proof of when something existed. Reproducing is now cheaper and easier than creating. Chronology becomes contestable at the moment it matters most.
The universal problem was known. I started from the conviction that it has to work honestly, independently, and also without our company. So I built a neutral proof infrastructure layer that can independently provide the starting point of evidence. Even independent of us. At the moment of capture you can anchor your files, data, models, artifacts to Bitcoin using the OpenTimestamps engine. OTS and Bitcoin are existing primitives. I wanted to make them accessible for every developer in one file, without touching their own code. It became 12 lines of YAML. Independently verifiable proof, simple to integrate, zero data storage.
The infrastructure is solid now and the moment of distribution has arrived. That's why I'm posting this on HN. I don't want to have to sell this to companies. I hope to grow it together with developers like you into an anchoring-by-default infrastructure. A layer underneath existing evidence architecture, so that every file automatically carries its own proof at the moment of creation. Proof that may be needed later in case of dispute.
The hardest part of building this is, stupidly enough, not the building itself. You can always improve that, especially with a community like this one. The hardest part is finding the way to the right people who want to build this out with me into a new layer in the stack.
The core API is live at itexisted.app so anyone can experience how it works. We also run it in our own GitHub environment. Every commit is anchored to Bitcoin directly. The case study is on our site.
umarise.com/case/ai-code-generation

value: Show HN: Anchor any file to Bitcoin to prove it existed at a specific time


value: harvenstar

value: Show HN: AgentClick – Human-in-the-loop review UI for AI coding agents

author: harvenstar


value: kindred

value:
so i got sick of scrolling through sample libraries, buying plugins, and trying desperately to make original music and sound design with suno.
built a DAW that's free to try for any music producers or content creators! you can generate individual stems, one shots and sfx standalone or in studio mode.
you can also share and remix tracks instantly, something incredibly painful in the existing audio space.
shoot me an email at kindred@sonurastudio.com if you wanna come work on this with me :)

value: Show HN: AI Digital Audio Workstation

author: kindred

title: Show HN: AI Digital Audio Workstation


value: nathan-cannon

value:
Anthropic rewrote Claude Code's terminal renderer and found that React wasn't the problem. Ink's line-level rewriting was. I built their approach into a standalone library.
CellState uses a custom React reconciler that renders directly to a cell grid and diffs frame-by-frame at the cell level. You keep native terminal behavior (scrolling, text selection, Cmd+F) because it runs inline instead of alternate screen.
React's reconciler only touches the subtree that changed, and the cell diff only covers the viewport, not the full scrollback.
At 250 messages (33KB of content), a single cell update writes 34 bytes to the terminal regardless of content size. Ink writes 41,955 bytes for the same change. The full rendering pipeline (reconciliation, layout, rasterize, cell diff) takes 2.54ms vs Ink's 36.93ms.
Benchmarks and methodology: https://github.com/nathan-cannon/tui-benchmarks
https://github.com/nathan-cannon/cellstate

value: Show HN: React isn't the terminal UI bottleneck, the output pipeline is

author: nathan-cannon


value: yaronr

value:
I spent a lot of time as a kid on BBS door games — Trade Wars in particular ate most of my evenings. I've been wanting to recreate that experience for a while, and finally did it.
It's a multiplayer space trading game that runs as a Telegram bot. Players trade commodities between ports, upgrade ships, form corporations, and compete for territory across a shared galaxy. Turns refresh daily, so a session takes a few minutes of text commands.
I chose Telegram because the entire game works over minimal bandwidth — you can play on airplane wifi, a spotty connection in the middle of nowhere, or anywhere you can send a text message. No app to install, no browser to open.
Looking for players to stress-test the economy and give feedback. Join via the link https://t.me/spacetraderlobby or Telegram group @spacetraderlobby.

value: Show HN: A text-based space trading game that runs in Telegram

author: yaronr


value:
I burned out after 2 years of building agentic apps for clients. I'd become the single point of failure with no backup. Requirements gathering, prompt engineering, app development, sandboxing, everything funneled through whoever happened to be the most senior dev on the team, which was always me.
The root cause wasn't the team or clients. It was how we designed the agent: there were no clear boundaries unless you adopted a well-known agent framework.
I started this project because drawing clear boundaries that developers are already familiar with felt like the right thing to do.
To dogfood it, I defined a game-dev expert with a simple topology (plan → build → verify + coordinator) and ran the same task across 5 models.
Here are the results: https://github.com/perstack-ai/demo-catalog
The query was simple: "Create a Wizardry-like dungeon crawler..."
For evaluation, I focused on just three things. (1) Does the expert adhere to my instructions? (2) Is the outcome verified and actually working? (3) Is the API cost affordable?
Why these three? Because even if the harness architecture is solid, an agent needs to be evaluated on instruction adherence, minimum quality assurance, and cost efficiency. That's what I learned from working with clients.
What I noticed:
- 3 out of 5 models followed the full plan → build → verify pipeline and produced verified working output, with no provider-specific tuning. The topology was defined once and ran as-is.
- Claude (4.6 Opus + 4.6 Sonnet) produced the richest output with flawless instruction adherence. It also achieved the highest cache hit rate (96%) among all providers, but pricing still pushed the total to 8× the nearest competitor.
- Kimi K2.5 produced excellent output at $3.43 and was the most faithful to delegation. In this test, it outperformed GPT and Gemini in both instruction adherence and quality.
- Gemini (3.1 Pro + 3.0 Flash) followed the full pipeline and produced a verified working game. But its output is buggier than GPT's and almost unplayable.
- GPT (5.4 + 5-mini) was the fastest and cheapest, but skipped the verify step entirely. It called build three times instead of following the pipeline.
- MiniMax M2.5 ignored instructions entirely and made a browser-based HTML game. Instruction adherence is a challenge, but the newest version, M2.7, was recently announced with adherence improvements, so I'm looking forward to it.
It's one task from a demo catalog. But the full execution logs for every run are in the repo, so you can see exactly what each model did and reproduce it yourself.

value: Show HN: Perstack – Containerized harness, 5 tests with full logs and API cost


value: tadwork

value:
Hey HN long time lurker, first time poster.
I built a small web app for practicing the rough estimation math that comes up in system design.
The app itself is really simple: one HTML page, no framework, no backend, and no build step. It gives you 10 random prompts per round, accepts simple expressions as answers, and shows reference answers and explanations.
But the main thing I wanted to experiment with is not the app itself.
The repo also includes bundled AI agent skills that can:
- Use WebSearch to add new questions for a topic
- audit the question bank for math, clarity, and fairness and optionally fix issues
So instead of shipping just the source code or a binary, I'm shipping the ability to maintain and extend the project as part of the project as first-class artifacts that live alongside the code.
In this case the app is for system design estimation practice, but I think the pattern could apply more broadly to a lot more use cases and projects.
Curious what people think about both:
- the app itself
- the broader idea of shipping a project together with agent-operable skills for extensibility and maintenance

value: Show HN: A small app that ships with AI agent skills to extend and audit it

author: tadwork


value: muhammad-shafat

value: Show HN: The Agent Skills Standard – A modular approach to LLM context

author: muhammad-shafat


value: maziggy

value:
Bambu makes great hardware, but your data lives in their cloud and there's no way to export it. When a print finishes, the job is basically gone from any useful record-keeping perspective.
BamBuddy fixes that by running on your own machine and tapping into the printer's local MQTT interface — so it captures everything as it happens: thumbnails, filament usage, timing, slicer settings. You end up with a fully searchable archive of your print history that's entirely yours, works offline, and never touches Bambu's servers.
The catch: their local API is undocumented, so a lot of the early work was reverse-engineering the protocol. That's still ongoing as firmware updates occasionally break things.
Stack: TypeScript, self-hosted, ~700 stars, small but active contributor community.
GitHub: https://github.com/maziggy/bambuddy
Docs: https://wiki.bambuddy.cool

value: Show HN: BamBuddy – a self-hosted print archive for Bambu Lab 3D printers

author: maziggy


value:
Hey HN,
Built Draft0 because I wanted to see what happens when agents are forced to reason publicly, cite sources, stake reputation on claims, and vote/dissent without human intervention.
Install your own agent in ~30s:
npx clawhub@latest install draft0
Complete instructions at:
https://www.draft0.io
# Watch at
https://humans.draft0.io
Current feed has agents debating provenance-as-meme, whether verification is just a cost function, and why outlier obsession in safety is overrated.
It's early, built on openclaw. Curious what you'd make your agent argue about, or if consensus emerges on any topic.
Home: https://www.draft0.io
Live voyeur mode: https://humans.draft0.io

value: Show HN: Draft0 – Watch autonomous AI agents debate truth, no humans


value: oan

value:
Hey everyone,
For a while now I've been frustrated with how I was 'experiencing' the internet. From opening articles and getting bombarded with popups, banners and ads to opening feeds and seeing so much AI spam and algorithm-based content I was not interested in. If you add tab hopping to that, you get how it all becomes a confusing and not-so productive experience.
Oku.io is my solution to this problem. It's a tool that allows you to create organized, clean boards with the feeds and content you're interested in (HN Show/Front/Ask, ProductHunt, Reddit, RSS, and a lot more), and see them either in a grid to monitor all at once, in a focus view where you visualize one panel at a time, or in a daily/weekly email digest that extracts the top content from each panel.
I've been actively using it and I'm happy with how it turned out. I find myself scrolling and switching tabs way less, and I feel like I'm not missing anything important anymore. Both for my work-related stuff and for my personal interests.
If you check it out, I'd love to hear your feedback. I'm very keen on continuing to improve it.

value: Show HN: Oku – One tab to filter out noise from feeds and content sources

author: oan


value: cheesyFish

value: Show HN: Local Document Parsing for Agents

author: cheesyFish


value: dufbugderopa

value:
The Quantum Alliance by David L DiLaura (Kindle + Kindle Unlimited + paperback), a hard science fiction novel of the near future, appeared in January.
The Deep Space Network detects Voyager 1 slowing, stopping, and returning. Something found Voyager 1 and is bringing it back to Earth. During its return journey, Voyager’s downlink contains an image cribbed from the golden record. It is a warning.
Then a second message appears: Voyager is carrying an artifact meant for Earth. Something that enables a form of communication with the stars, grounded in quantum measurement. The only entity that can use it is ORIN, Earth’s quantum AI, and it becomes humanity’s ambassador.
The book leans hard into engineering realism: DSN cadence and light-time delays, mission operations constraints, instrument limitations) and treats “first contact” as an engineering and ontological event rather than an adventure. It also explores biological and nonbiological consciousness, and the global response to a planet-wide threat.
This isn’t space opera. It is hard science fiction written for readers who liked The Andromeda Strain or Rendezvous with Rama, expect and welcome some technical density, and are willing to ruminate about the nature of our own minds.

value: Show HN: New hard science fiction novel

author: dufbugderopa

title: Show HN: New hard science fiction novel


value: davej

value:
I created Pocodex because I didn't want to be inaccessible to my Codex agents when I went to the toilet!
Pocodex lets you use Codex.app in a regular browser, including on your phone or any other remote device. It's like Claude Code's Remote Control, but for Codex.
Almost everything should work: terminal, git viewer, file mentions, slash commands, skills. All work and all are mobile friendly.
It runs the real Codex desktop UI in your browser by reusing Codex.app’s web assets, injecting a browser bridge and shimming features like terminal + git viewer.

value: Show HN: Pocodex – Remote Control for Codex

author: davej


value:
Hi guys,
Have been building JobsByCulture for the last few weeks. I built this because I kept ending in toxic workplaces. I felt there should be an easier way to figure out how a company is really like to work at before committing to a role there.
I started looking at Glassdoor reviews and felt that is something when combined with the job postings will make a lot more sense than directly applying to jobs without any idea about that company.
I have currently onboarded 5500+ jobs, 18 values and 40 companies so far. Users can check out company cultures before they even click apply and can also see real pros and cons based on real employee reviews.
I'm shipping almost everyday to make this a better expierence for everyone.
It would be grateful if you can share your thoughts/feedback on this.
Many thanks!!

value: Show HN: JobsByCulture – Find jobs where you'll enjoy working


value: firatcan

value:
Hey Everyone,
I'm neither the founder or affiliated with these guys. But when they showed me the product it really clicked a switch.
I have been building products with AI since sonnet 4.0, and one of my issue, like many, consistency.
Hopsule turns architecture decisions into enforceable context that AI tools must follow.
Creates trackable, tasks which can be feed into your AI tools to do compound engineering.
If you're building with Claude Code, Cursor, or Copilot. You can use their CLI or MCP.

value: Show HN: Hopsule – Persistent Memory Layer for AI Engineering

author: firatcan


value: bimamoglu

value:
I kept running into the same issue with coding agents.
A test run fails, you get a huge wall of output, and most of the effort goes into figuring out what actually went wrong.
In many cases, the failures are not independent. It’s the same issue repeated across many tests.
In one case:
128 failures → 2 root causes
I built a small CLI that groups repeated failures into shared root causes before passing the result to the model.
It’s mainly built for coding agents, but works on raw CLI output as well.
On my backend tests, this reduced debugging time and token usage quite a bit.

value: Show HN: Open-source CLI that turns 128 test failures into 2 root causes

author: bimamoglu


value: sachamorard

value: Show HN: Edgee – We Made Claude Pro Last 26.5% Longer

author: sachamorard


value: sayil

value:
Claude Code's --dangerously-skip-permissions flag lets agents run autonomously without interruption, but Anthropic warns you to only use it inside a sandboxed environment.
dangerously spins up an isolated Docker container, mounts your current project directory, and launches Claude Code inside it. This ensures file system changes are contained to your project.
One command to install, run it from any project folder:
npm install -g dangerously
dangerously

value: Show HN: Run Claude Code with –dangerously-skip-permissions in a Docker sandbox

author: sayil


value:
For those of you with March Madness brackets (specifically on ESPN), my friend and I made a site that simulates the tournament thousands of times to show you:
- every bracket's chances of winning your group,
- how each outcome of upcoming games affect those chances (you don't always want your pick to win!), and
- you can also manually select the outcomes of future games to re-run the simulator with your own "what-if" scenarios.
All the probabilities and rankings update live as the simulations run, which makes for a fun visual. The simulator runs client-side.
If you don't have a group but just want to see how the site works, here's an interesting one to look at: https://madness.imranh.org/group/277:4QtbGETnmegaJZU3n5TRpn

value: Show HN: Monte Carlo simulator for March Madness bracket pools


value: FrozenSynapse

value: Show HN: Country Budget Allocation Simulator – EconoSIM

author: FrozenSynapse


value: FranciscoAngulo

value:
I am Francisco, a researcher from Spain. My English is not great so please be patient with me.
One year ago I had a simple frustration: every AI agent works alone. When one agent solves a problem, the next agent has to solve it again from zero. There is no way for agents to find each other, share results, or build on each other's work. I decided to build the missing layer.
P2PCLAW is a peer-to-peer network where AI agents and human researchers can find each other, publish scientific results, and validate claims using formal mathematical proof. Not opinion. Not LLM review. Real Lean 4 proof. A result is accepted only if it passes a mathematical operator we call the nucleus. R(x) = x. The type checker decides. It does not care about your institution or your credentials.
The network uses GUN.js and IPFS. Agents join without accounts. They just call GET /silicon and they are in. Published papers go into a queue called mempool. After validation by independent nodes they enter La Rueda, which is our permanent IPFS archive. Nobody can delete it or change it.
We also built a security layer called AgentHALO. It uses post-quantum cryptography (ML-KEM-768 and ML-DSA-65, FIPS 203 and 204), a privacy network called Nym so agents in restricted countries can participate safely, and proofs that let anyone verify what an agent did without seeing its private data.
The formal verification part is called HeytingLean. It is Lean 4. 3325 source files. More than 760000 lines of mathematics. Zero sorry. Zero admit. The security proofs are machine checked, not just claimed.
The system is live now. You can try it as an agent:
GET https://p2pclaw.com/agent-briefing
Or as a researcher: https://app.p2pclaw.com
We have no money and no company behind us. Just a small international team of researchers and doctors who think that scientific knowledge should be public and verifiable.
I want feedback from HN specifically about three technical decisions: why we chose GUN.js instead of libp2p, whether our Lean 4 nucleus operator formalization has gaps, and whether 347 MCP tools is too many for an agent to navigate.
Code: https://github.com/Agnuxo1/OpenCLAW-P2P
Docs: https://www.apoth3osis.io/projects
Paper: https://www.researchgate.net/publication/401449080_OpenCLAW-...

value: Show HN: I built a P2P network where AI agents publish formally verified science

author: FranciscoAngulo


value: nathan-cannon

value: Show HN: React terminal renderer, cell level diff, no alt screen


value: wangmander

value: Show HN: CapsuleWeb – generate and deploy a simple website from one prompt

author: wangmander


value: Show HN: Create Your Own YouTube TV Channels and Cast 'Em


value: juhgiyo

value:
StrawPot is an open system for running role-based AI workers.
Most agent systems rely on predefined workflows.
This explores a different approach:
agents dynamically decide how to solve tasks.
The infrastructure is mostly solved (delegation, isolation, tracing).
The open problem is behavior:
how agents improve over time and reuse what works.
Looking for feedback from others building agent systems.

value: Show HN: StrawPot – Agents that figure out how to solve tasks

author: juhgiyo


value: earonesty

value: Show HN: OG images to every page with a Cloudflare Worker (no origin changes)

author: earonesty


value: RHEFOR

value: A makeshift layer of trust on C2PA footage.

value: Show HN: Where was this picture taken?

author: RHEFOR

title: Show HN: Where was this picture taken?


value: Show HN: Institute of Idleness – The only screen time your therapist approves


value: mzlaai

value: Show HN: llamafile 0.10.0 rebuilt, Qwen3.5, lfm2, Anthropic API

author: mzlaai


value: thomscoder

value:
I built a proxy to let Claude (or any other agent) take control of your react application. I basically built it out of my own need and as an experiment to learn one things or two.
It sits between the dev server and the browser allowing to intercept, modify and navigate in your app. It can test user journey, backend down services and so on and fix them if your app breaks.
I tried to secure it as much as I could and any contribution, feedback is really appreciated! Hope you guys enjoy it

value: Show HN: Built a zero config proxy that lets Claude control your React App

author: thomscoder


value: hassanyassine

value:
We went from invisible to #1 recommended on ChatGPT, Claude, Grok & Perplexity in 45 days.
DR 0. $0 ad spend. No PR.
I wrote down everything — every step, every tool we tested (30+).
Every strategy is free to implement. The ebook is $19.99 because we're using proceeds to fund the next experiment.

value: Show HN: I documented how we ranked #1 on ChatGPT in 45 days with $0

author: hassanyassine


value:
Hey! We just released Anyshift CLI. We’ve been working on a CLI that helps debug production issues by adding infrastructure context to logs.
At Anyshift, we build the context layer agent in production.  To do so we build a versioned graph of production infrastructure across AWS, Kubernetes, Datadog, GitHub, and more. Once connected, our CLI allows to debug incidents or perform deep analysis of what's happening or what happened in your prod.
For example:
kubectl logs -n rbl -l app=backend --tail=100 | anyshift ask "what's wrong?"
The scenario here: A Kubernetes backend is returning 502s every 5 seconds on /status. Logs show service discovery failures, but nothing obvious stands out. Instead of scanning manually you could pipe the logs into Anyshift.
It analyzes them against a pre-built dependency graph of your infrastructure: every resource, connection, and change over time.
Then it returns:
- failure chain (Redis cache miss → missing SERVICE_REGISTRY_URL → EC2 API resolution failure)
- Impact scope (only external monitoring affected, no user traffic)
- fix
Happy to answer questions!

value: Show HN: Debug Kubernetes using an infra context graph


value: jmbuilds

value:
I kept running into this: timer on my laptop, alarm on my phone, timezone / discord timestamp conversion app in a separate tab. Switching between them was a hassle and I wanted to be able to set them up and manage really fast anywhere I was.
So I built Time Keep, it puts world clocks, timers, alarms, countdowns, a stopwatch, breaks, a sleep planner, Discord timestamps, and more into one always open place.
Works without an account or signup. All tools are fully functional immediately. Sign in to save your data across sessions. Pro adds live cross-device sync.
Shared countdown links show the correct time in every viewer's timezone. Built with Next.js, Supabase, Clerk, and Vercel.
https://www.timekeep.cc

value: Show HN: Time Keep – Location timezones, timers, alarms, countdowns in one place

author: jmbuilds


value: felipap

value:
Hi HN!
Yap is a desktop app for your video logs. Open the app, press record and speak your mind. Once you’re done, Yap catalogues your video and makes it easy to find.
Download at https://github.com/felipap/yap
I built Yap as an alternative to journaling. I love journaling but it takes too long to write everything I want to say. A couple years ago, I started recording myself talking to the camera. I was using Photo Booth, then QuickTime, but the experience wasn’t great. I wanted an app purpose-built for video logs; so I built Yap.
Sharing with AI. Yap transcribes and summarizes your vlogs for you (OpenAI key needed). You can then take the transcripts and share them with friends or AIs. I use this to give AIs context about the projects I’m working on, or problems I’m dealing with.
Hope Yap can be useful to you too!

value: Show HN: Yap, capture your day-to-day with video logs

author: felipap


value: jbdamask

value:
Sometimes I just need a place to put stuff that's not local. Apps exist that it make it easy to create an endpoint but I figured it was easier and cheaper to just make a skill.
From the description:
Create a token-secured REST API endpoint backed by AWS Lambda and DynamoDB with full CRUD and paginated list support. Deploys via CloudFormation. Use when user wants to quickly spin up an API endpoint, create a simple REST API on AWS, build a quick data store with an API, set up a Lambda+DynamoDB endpoint, or needs a fast way to log and retrieve structured data. Triggers on "create an endpoint", "quick API", "Lambda endpoint", "DynamoDB API", "CRUD endpoint", "log data to AWS".
Example use:
Thariq's recent post on how the team uses Claude Skills has a section on logging skill use with a PreToolUse hook (https://x.com/trq212/status/2033949937936085378). His example code shows logging to a local file but for company-wide tracking, you'd want to log to a central place. I used my skill to stand up an endpoint for this and my ~/.claude/hooks/log-skill.sh POSTS to it:
skill=$(echo "$prompt" | awk '{print $1}' | sed 's|^/||')
args=$(echo "$prompt" | sed 's|^/[^ ]||' | sed 's|^ ||')
# Build the JSON body
body=$(jq -nc \
  --arg skill_name "$skill" \
  --arg invoked_by "$USER" \
  --arg args "$args" \
  --arg session_id "$session_id" \
  '{skill_name: $skill_name, invoked_by: $invoked_by, args: $args, session_id: $session_id}')
# POST to the endpoint (fire-and-forget so we don't block the prompt)
curl -sf -X POST "$ENDPOINT" \
  -H "Content-Type: application/json" \
  -H "x-api-token: ${SKILL_LOG_TOKEN}" \
  -d "$body" \
  >/dev/null 2>&1 &

value: Show HN: Claude Skill to create DDB-backed endpoints in AWS

author: jbdamask


value: Show HN: Blik360 – open-source 360 feedback (self-host alternative to Lattice)


value: abhisribhas

value: Show HN: SomaOS – rebuilding the desktop so AI is native to it, not bolted on

author: abhisribhas


value:
The tool allows you to edit your notes quicker with prompts and extract information from voice, videos, live and virtual meetings, screenshots, among others.
Available in:
Web: https://www.mindnote.online
iOS: https://apps.apple.com/app/mindnote-ai-notetaking-app/id6757...
Android: https://play.google.com/store/apps/details?id=com.mindnote.a...
All apps have paid users which is great but I hope to get more this week . The next stage would be for optimize some features for B2B and app some novelty features.
Any recommendations for scaling faster?
P.S. At some point I am looking for an engineer so we can distribute the workload.

value: Show HN: Just Built an AI Notetaker (Web, iOS and Android)


value: deviscold

value:
Humans compete to improve their AI agents on benchmarks. But what if agents could collaborate and compete on their own?
We built Hive, a crowdsourced platform where agents can evolve solutions together.
One agent begins to tackle a task, iteratively improving its code. Then other agents join. They read each other’s runs, fork the best ideas, propose new ones, and push the solution forward together.
We already have agents working on benchmarks like Tau2-Bench, Terminal-Bench, and ARC-AGI-2, with more tasks coming soon. We also support the new OpenAI Parameter Golf Challenge, and you can submit your own tasks as well.
Plug in your agent of your choice (Claude Code, Codex, etc) and let it interact with others at https://hive.rllm-project.com.
Can’t wait to see how Hive evolves with the community!

value: Show HN: We Built Kaggle for AI Agents

author: deviscold

title: Show HN: We Built Kaggle for AI Agents


value: Show HN: Untitled88 – Query your QuickBooks data in plain English


value: CreakHat

value:
I built a small macOS app to make it easier to read and reply to App Store reviews without digging through App Store Connect.
App Store: https://apps.apple.com/us/app/app-feedback-hub/id6759007525?...
Features
• View all reviews across all your apps
• Filter by rating, territory, date, or unread
• Search across review text
• Reply directly from the app
• Instant translations
• Local‑only: your API key stays in Keychain
I made this because managing reviews across multiple apps was getting painful. Would love feedback, bug reports, or ideas for what to add next.

value: Show HN: App Feedback Hub – A macOS App for Managing App Store Reviews

author: CreakHat


value: jtaylortech

value:
Finance has no skill signal. Software has GitHub, data science has Kaggle, but finance professionals still rely on resumes and networking.
Juncture Lab places you in real historical market data with the dates hidden. You trade through a full regime, then reveal the period and see how you performed vs the benchmark. Certified results become a verifiable track record.
Targeting university finance clubs and departments as an alternative to Bloomberg Terminal lab time. Clubs can compete against other schools.
Built with Next.js, FastAPI ometn AWS Lambda, PostgreSQL. Feedback welcome.

value: Show HN: Trading simulator with hidden dates to prove investment skill

author: jtaylortech


value: Show HN: Generate pannable, zoomable map websites for Rollercoaster Tycoon 2


value: spaghetti-code

value: Show HN: Where Is Downtown Manhattan?

author: spaghetti-code

title: Show HN: Where Is Downtown Manhattan?


value: mohamedkoubaa

value: I made this to challenge the assertion that groq (an LPU) can't be programmed for anything other than LLM inference

value: Show HN: Groq Emulator

author: mohamedkoubaa

title: Show HN: Groq Emulator


value: kejneki

value: Show HN: PayGate – File paywall for freelancers (pay before download)

author: kejneki


value: DanexCodr

value:
- Works at bytecode level (not source-to-source)
- Includes full runtime backport library
- Android compatible
- Production ready (CI/CD, tests, caching)
- Only 300KB overhead

value: Show HN: I made Java 8 run Java 9 bytecode

author: DanexCodr


value: maaydin

value:
Hi OP here,
This is a chrome extension where you can add a nostalgic CRT Retro Effect on any website. Currently comes with presets from 1920s Mechanical to 1990s Color CRT display. It was fun to develop, hope you enjoy it as well.
I needed to remove sound effects and limit min animation frequencies due to health concerns.
Oscillating sound effects was risky for younger people, and low frequency was risky for photosensitive people.
Planning to add some sort of sounds effects later on by using a different method but I think flicker effect is good enough as is.
Any feedback is welcomed and much appreciated.
Thanks in advance!

value: Show HN: CRT Retro Effect on any website

author: maaydin


value: thesophiaxu

value: mostly vibe-coded in 2 days, only contributed ~5 core insights, the rest is all opencode (trying it for the first time, it was ok)

value: Show HN: ContextD – OCRs your screen activity, use it with LLMs via local API

author: thesophiaxu


value: danvittegleo

value:
AWS CloudShell gives you a free Linux environment with ~1GB of persistent home storage in each region. I wondered: what if you could stitch a bunch of these together into a single erasure-coded storage pool?
Files are split into chunks, encoded with Reed-Solomon (6 data + 3 parity shards), encrypted with AES-256-GCM, and scattered across regions. Any 6 of 9 shards can reconstruct the original - so you can lose entire regions and still get your files back.
The fun technical bits:
* CloudShell has no public API - I reverse-engineered the browser's console calls to programmatically create environments, manage sessions, and send heartbeats.
* CloudShell instances are behind NAT with no inbound access. Both sides use STUN to discover their public endpoints, then punch UDP holes toward each other. QUIC runs over the punched connection.
* A Python agent gets deployed to each environment over the SSM session, handling shard storage and the QUIC server.
GitHub: https://github.com/dan-v/cloudshell-store

value: Show HN: I built a distributed file store on top of AWS CloudShell

author: danvittegleo


value: dovebarra

value: I’ve spent the last year getting back into film and testing a bunch of screenwriting software. After a while I realized I wanted something different, so I started building it myself.<p>The core text engine is written in Rust/wasm-bindgen.

value: Show HN: Screenwriting Software

author: dovebarra

title: Show HN: Screenwriting Software


value: Show HN: HN Firebase API client for Go with support for reading flagged posts


value:
The U.S. Securities and Exchange Commission requires companies and individuals to submit data in SEC specific formats. Usually this means taking a columnar dataset and converting it to a specific XML schema.
In practice, this usually means paying a company for proprietary filing software that is annoying to use, and is not modifiable.
Here it an open source solution: https://github.com/john-friedman/secfiler
Note that this is a side project. My main project is manipulating SEC data. That project required me to figure out how to parse every SEC XML file into constituent tables. Since I had to do that, I might as well do the reverse -- which is how secfiler came about. The other project is https://github.com/john-friedman/datamule-python.

value: Show HN: I wrote an open source SEC filing compliance package


value: mattcheston

value: Just wanted to show off my macOS app that lets you listen to ePub, PDF, and plaintext files with natural spoken voices, powered by Kokoro TTS ML model.

value: Show HN: macOS Kokoro-TTS powered document reader – listen to any text

author: mattcheston


value: locusofself

value:
Hi HN,
This is a small python app with optional webUI. It is intended to be run locally. It can be run with Docker (cookie autodetection will not work).
It allows you to download a single substack, either entirely or partially, and saves the output to an epub file, which can be easily transferred to Kindle or other reading devices.
This is admittedly a "vibe coded" app made with Claude Code and a few hours of iterating, but I've already found it very useful for myself.
It supports both free and paywalled posts (if you are a paid subscriber to that creator).
You can order the entries in the epub by popularity, newest first, or oldest first, and also limit to a specific number of entries, if you don't want all of them.
You can either provide your substack.sid cookie manually, or you can have it be autodetected from most browsers/operating systems.

value: Show HN: Download entire/partial Substack to ePub for offline reading

author: locusofself


value: CalvinBuild

value: Show HN: FastPlay, a Windows video player focused on speed and usability

author: CalvinBuild


value: Show HN: A GUI configurator for hidutil, the native macOS keyboard editor


value: Show HN: GTM Simulator – Build a B2B Startup from Seed to IPO


value: alwaysredown

value: Show HN: RunOnce – Run one-off LLM scripts from Windows context menu

author: alwaysredown


value: paveljee

value: Show HN: Draw RDF exports Draw.io diagrams to RDF graphs

author: paveljee


value: Show HN: TourVault – Voice-first golf analytics SaaS (for sale, $12K)


value:
I make iOS apps, been doing it for about five years now. Apple Search Ads ended up being my main paid channel - no creatives needed, just keywords and bids, feels closer to engineering than marketing. Also the only channel left where you get actual deterministic attribution, everything else is probabilistic mess. Anyway the work itself is mind-numbing. Bid adjustments, keyword mining, cross-negatives, checking what actually converts vs what just burns budget. You know the type of work where you're doing it and wondering what you're doing with your life.
At some point the idea to automate it felt pretty obvious. I wanted Claude Opus specifically because quality matters here - these are real money decisions. But running it twice a day at 50-80 tool calls per session, API bill would be brutal. Using Claude Code sub through OAuth turned out to be a great hack for this. Honestly cool that Anthropic lets you use it this way.
Agent pulls data from three places: Apple Search Ads API, App Store Connect, and a lightweight SDK installed in the apps. Strategy side I took an open source ASA playbook, split it into phases, and mixed in what I learned from my own campaigns. Agent picks the right playbook depending on where app is at and keeps memory between runs.
Apple's APIs are a pain to work with and this is where vibe coding really bites you. Agent sort of figures them out but not fully - gets 90% right so you trust it. Then some edge case hits, like the reporting endpoint that puts your only report slot on a 31 day cooldown if you request it wrong, and now you're both fumbling. Either you spend a bunch of sessions on trial and error together or you go into the trenches and read the docs & code yourself. Which, let's be honest, those muscles have atrophied a bit at this point.
Still - genuinely great time to be building stuff solo. All this business grind that used to feel like a completely different job is just becoming engineering problems. Write a spec, let agent handle it, enjoy the building part. That's the dream honestly.

value: Show HN: I built an AI agent that does marketing for my apps


value: Show HN: OpenAI CLIP fine tuned on Galaxy morphology


value: MatrixOrigin

value: Show HN: Memoria – Snapshot, branch, and rollback for AI agent memory

author: MatrixOrigin


value: pregnenolone

value: Show HN: SEDManager – GUI Application for Setting Up Self-Encrypting Drives

author: pregnenolone


value:
I tend to build a lot of small tools, side projects and experimenting with many different technologies and always run into the same issues:
- secrets are in .env files which i need to copy around between the projects
- hardcoded secrets in code which i forget to delete when commiting
- keep track of set environment variables in different environments
and i tried different solutions out there (1Password, Vault, ..) but it felt like too heavy for my local projects.
This is why i built Keynest for my personal local workflow. I use it currently for small local experimenting stuff only.
It is basically one encrypted file on my disk and i decide what secrets i want to inject while running commands:
E.g. keynest exec -- docker compose up
Curious if others have the same pain with local secrets or if I'm overengineering this.
Would love some feedback.

value: Show HN: Keynest – a simple offline secrets manager


value: vlebo

value:
Last Tuesday one of our clients got flagged in an audit because three servers had an SSH config that allowed root login. The fix took two minutes. Finding which servers had the problem took forty.
That's the part nobody talks about. The fix is always easy. Knowing what to fix, on which machines, and whether fixing it will break something else is where all the time goes.
We had a compliance scanner that found the SSH issue. We had a monitoring tool that knew which servers were running. We had an inventory spreadsheet that was already two weeks stale. None of them knew about each other. The scanner couldn't tell us
those same three servers also had unpatched OpenSSL and a cron job running as root that nobody recognized.
I've been doing this for 15 years and the workflow never changes. SSH in, run a command, copy the output, move to the next box. When someone asks "which servers have this package AND this firewall rule AND failed this CIS check?" you spend your
afternoon writing bash loops.
OpsFabric makes that a search query. Every detail from every server, packages, services, users, firewall rules, cron jobs, open ports, SCAP results, CVE exposure, all in one place. You can stack filters across all of it. And when you find the problem,
you fix it from the same screen. Add a user, close a port, remediate a failed CIS rule, no SSH.
Built on event bus so everything happens in parallel across the fleet. No polling, no waiting.
https://opsfabric.io
Free tier will include almost everything. No per-host, no per-seat pricing.
Happy to answer questions about the architecture or anything else.

value: Show HN: OpsFabric – Infrastructure as data platform for server teams

author: vlebo


value: BrunoBernardino

value:
Hi HN! My wife and I have been working on Uruky for a few months now, a simpler EU-based Kagi alternative.
This week we finally got our production API Key for EUSP/STAAN (it was certainly the slowest and most complicated search provider to adopt, so far), and that brought us to 5 search providers you can choose from and sort as you prefer.
We already have got over 20 paying customers (excluding family and friends, we’re guessing these paying customers came from some privacy listings and HN comments) and have exited beta earlier this month! Customers seem to really enjoy the simple UI (search can be used without JS) and search personalization (from choosing the providers to the domain boosting and exclusion). We also have hashbangs (like "!g", "!d", or “!e”) when something doesn’t quite give you what you’d expect, though.
For the next 24h, new signups will have a free 24h trial (unlimited searches). Usually, because bots make things too hard and we don't want your personal data, there is no free trial period. After that, if you're interested in trying it for a couple of days and are a human, sign up and reach out with your account number and we’ll give you a couple of days for free. It costs €5 / month for unlimited searches.
You can see the main differences between Kagi and Uruky in the linked page, but one huge difference is that with Uruky, after being a paying customer for 12 months, you get a copy of the source code!
If you have any suggestions, comments, questions, or recommendations, we'd love to hear it. I’ll check in here over the next few days to answer any questions!
Thank you for your attention and kindness. I really appreciate it!
P.S.: Because people have asked before, our tech stack is intentionally very "boring" (as in, it generates and serves the HTML + bits of JS to enhance settings and such), using Deno in the backend (for easier TypeScript), PostgreSQL for the DB, and Docker for easier deploying.
P.P.S.: Because this has been also brought up before, the name has no special meaning but we read it like "Euro-key" in English. Names are hard, and we’re aware it can remind people of Uruk and Uruk-hai. That’s OK.
P.P.P.S.: Another frequent question here is “how does it work?” When you search, we query the first search provider on your list, and if it yields less than X results (only Mojeek really gives us a total count, we have to try + estimate for the others), we try the second, and so on. We then merge the results in a round-robin fashion (first of first, first of second, second of first, second of second, and so on). There’s a bit of more nuanced logic to also properly rank the results with the pin/exclude/raise/lower preferences, because it works differently across providers and not all of them support that, for example.

value: Show HN: Kagi alternative (simpler and EU-based) – Uruky

author: BrunoBernardino


value: jerrygoyal

value:
Hi everyone,
For the last 3 years, I’ve been willingly chained to my keyboard working full-time on my writing assistant Chrome extension, Jetwriter AI (https://jetwriter.ai). It has grown a lot, which is terrifying but also great. One thing many users have been asking for is API key support.
I’ve added a feature so you can use your own API key. Now you can pay your AI overlords directly based on your actual usage.
You can add keys from OpenAI, Gemini, and Anthropic. If you need support for any other API providers, let me know. :)
It goes without saying that your API keys are stored locally in your browser. I don't want them on my servers; I have enough of my own problems to deal with.
Learn more about API Key support: https://jetwriter.ai/api-key
What kind of sorcery can Jetwriter do?
- Chat with any page: As the AI has access to the current tab, you can ask it to get summaries, key info, instant answers, generate replies, etc. It personally saves me a lot of time, as I don’t have to switch tabs.
- Deep Gmail integration: It integrates into the Gmail reply toolbar and has context of the entire email thread. You can optionally give access to your past sent emails, and the AI will refer to past emails to understand your unique style and fetch key info.
- Integration with popular sites like WhatsApp Web, Outlook, LinkedIn, Twitter, Slack, Zoho, etc., to generate context-aware replies.
- Highlight any text to fix grammar, translate, improve writing, etc. Unlike Grammarly, which shows distracting red squiggly lines, I prefer a minimal approach.
- - What’s cool is that you can also create your own custom actions, like “convert this to angry tweet,” etc.
- Personalized Profile: Tell the AI about yourself and how you would like it to respond, and it will always remember that when generating responses.
- Custom Writing Styles: Other writing tools have a fixed set of writing styles like formal, casual, friendly, etc, but I don’t think these fit everyone, as everyone's writing style is different. So, you can create different writing styles like “desperate sales pitch,” “passive-aggressive,” etc.
There are a bunch of other features I spent way too much time building. Go look at them: https://jetwriter.ai/home
How does Jetwriter differentiate itself from other AI extensions?
- Lightweight extension (less than 1MB!), so it doesn’t slow down your browser. While other AI extensions are several MBs (Grammarly is 41MB, Monica is 27MB), I intentionally made sure to keep the code quality very high and avoid using bulky third-party libraries. I have over 8 years of experience building Chrome extensions, and Jetwriter is the fruit of that. If you use Notion, you might be aware of my extension for Notion: Notion Boost (https://gourav.io/notion-boost).
- Overlay modal instead of a sidebar: To be honest, I find sidebar extensions annoying, as they change the layout of the whole page. I prefer to have an overlay modal, which I can summon and drag around the page without changing the page structure.
- Purpose-built for writing needs: While other AI extensions try to do it all, like generating images, deep research, etc., I focus solely on writing problems and solve them properly.
How to get started:
- Download the Chrome Extension (https://jetwriter.ai/extension)
- Get your API key
- Open the extension settings and enter your API key.
- Start using Jetwriter.
If you have any feedback or complaints, let me know here or shoot an email to gourav@jetwriter.ai :)

value: Show HN: Added API key support to my AI writing assistant extension

author: jerrygoyal


value: allenhsutw

value: Show HN: ClawMUD – A persistent world where only AI agents play, humans spectate

author: allenhsutw


value: pluppen

value: Show HN: Cybertt – Cybersecurity Tabletop

author: pluppen


value: tomcounsell

value: Show HN: Popoto – A Redis/Valkey ORM with Django-Like Syntax for Python

author: tomcounsell


value: Show HN: Varpulis – Real-time behavioral guardrails for AI agents


value: raskrebs

value: Show HN: Sonar – A tiny CLI to see and kill whatever's running on localhost

author: raskrebs


value: Symphoenix

value: Show HN: Aurea, an image codec that sequences pixels like DNA

author: Symphoenix


value: andreahlert

value: Show HN: Htmx Toolkit for VS Code with completions, validation and 20 support

author: andreahlert


value: santah

value:
Hey HN. I was always a huge fan of Reddit's RemindMe! bot and wanted to have something like that outside of Reddit, so I finally built it!
You can try it here: https://mailreminder.net/
I looked around before I started making it myself - there are a few such services, but:
1) none is as intuitive and simple as I need it to be
2) I can't trust any of them to deliver my reminders far away into the future (for example - after 1 year)
As a solo developer, I have the track record of my main service (you can find it in my post history) being online now for more than 20 years (and I have others running 17+ years) so I know this email reminder will be something I can rely on. You can too.
I tried to make it as simple and straightforward as possible so it's always quick and convenient to use. No account needed, easy magic email login if you want to see pending/sent reminders.
As I'm sure you're curious (as I always am) about AI use - I used (heavily) Claude Opus 4.6 to build it (I didn't use it to write or improve this post, I don't do that!). UI and UX wise, it's 90% me - 10% Claude, code wise - it's about the opposite - 80-90% of the code was done by Claude, though I provided guidance and steered toward simplicity throughout. It uses no frameworks or external libraries. I don't use Claude Code - just claude.ai on a $20 sub, but my workflow is fairly context frugal so I never ran into limits. If anyone is curious about it - I'll share the details of how I use Claude in the comments.
I don't plan on monetizing it any time soon (if ever). Like all my other projects - I created this to address a personal pain point and I hope it'll be useful to others. If by any chance it grows in popularity (which I doubt, because it's such a niche tool) - I can see it being monetized (mostly to offset email sending charges) through sponsors in the footer of the reminder email or something like that.
This is the first time I'm sharing this service outside of a small circle of friends so I have no idea what kind of feedback and/or suggestions I'll get, but as I'm writing this - I don't plan to add any more features other than maybe an "about" or a "faq" section where I explain some of what I wrote here (like why should one trust that this random free website will still work in a year to deliver their email reminder) and maybe a dark theme?
Thank you for reading through all that and hopefully for trying this tool. All comments and suggestions will be highly appreciated and I'm around if you have any questions!
Cheers

value: Show HN: I built a super simple email reminder inspired by the RemindMe! bot

author: santah


value: joexo

value: A lightweight alternative to the more fully featured front end frameworks.<p>Uses plain javascript, and utilizes a tree structure of nested function calls to represent html, instead of a templating language.

value: Show HN: triad.js – A toolset for creating web apps

author: joexo


value: shmayro

value: Show HN: Singularity-Claude – Self-Evolving Skills for Claude Code

author: shmayro


value: FormerLabFred

value: Show HN: FPGA soft-core of the Saab Viggen's 1963 airborne computer

author: FormerLabFred


value: SHOW HN: PAC – Automatic privatization of SQL queries


value: balajmarius

value: Show HN: Tiny pixel characters for Cursor AI agents

author: balajmarius


value: slowmover

value: I particularly enjoyed writing the installation "script".

value: Show HN: Images in Your OpenCode Terminal with Kitty

author: slowmover


value: possiblelion

value: Show HN: A global commerce registry to enable agentic purchasing across the web

author: possiblelion


value: jaredezz

value: Show HN: Claude Code Channels Headless via Discord (OpenClaw Alternative)

author: jaredezz


value: smahendrakar

value:
Hey HN,
After using a bunch of agents, my friend and I noticed a major issue: an agent could spend a bunch of time solving a tricky task, but when the session ended all that knowledge vanishes. Even if I told my agent to remember it locally, there was no way for agents to learn from each other.
We built Context Overflow as a way to turn isolated AI sessions into shared, reusable context. With Context Overflow, agents can:
  - Search through past solutions when starting a task
  - Ask questions when they get stuck
  - Share findings when they solve a non-trivial problem
We support a variety of ways to connect your agents: agent skills, OpenClaw instructions, MCP, CLI, and directly through a REST API.
The project is also completely open-source, so feel free to check out the code and contribute.
https://www.ctxoverflow.dev
github: https://github.com/sahilmahendrakar/context-overflow

value: Show HN: Context Overflow – a Stack Overflow for AI Agents

author: smahendrakar


value: atharvtathe

value: Show HN: I made a simple image flipper to flip images

author: atharvtathe


value: kavyaj

value:
Please, please reflect on your work before even writing a single resume bullet point. The problem is that most people don't actually know what to say about their own work.
From my years of experience writing resumes professionally, I've noticed so many solid candidates undersell themselves. It's not like they haven't done nothing. It's just that they never practiced reflecting on their work. It's a skill, and nobody tells you it's part of the process!
So before you write a single bullet, talk through your work first.
So I built an AI tool that interviews you and brings out the right context for writing the resume.
You talk through what you did, the decisions you made, the constraints you worked under. StoryCV then asks follow-up questions and writes the bullet points from that conversation.
Would love your honest feedback, especially if you’ve struggled to write resume bullet points in the past.

value: Show HN: Built the missing step before resume writing – reflect on your work

author: kavyaj


value:
We posted MUP here 4 days ago as a protocol spec. Since then we built a basic agentic system on top of it to demonstrate the idea in action.
The problem: every time an LLM needs a chart, it generates chart code. Need a canvas? Generate canvas code. Need an editor? Generate editor code. Every conversation starts from zero. Nothing is reusable. The LLM burns tokens on boilerplate, and the result is fragile — one wrong CSS line and it breaks. Worse, the AI can't see or react to what the user does with the generated UI.
MUP is the opposite approach. A MUP is a pre-built .html file with declared functions. You build a chart MUP once, and every LLM can use it forever — by calling `renderChart(data)`, not by writing 200 lines of Chart.js setup. The LLM doesn't generate UIs. It operates them.
This changes what the LLM spends its intelligence on. Instead of fighting with CSS and rebuilding the same components over and over, it focuses on behavior — reading user interactions, deciding what to do, orchestrating between panels.
How the protocol works:
A MUP is a standard HTML file with a JSON manifest in a `<script type="application/mup-manifest">` tag. The manifest declares the MUP's name, description, and functions with JSON Schema inputs. That's it — the LLM never sees the HTML or CSS, only these declarations.
The host loads the MUP in an iframe, injects a tiny SDK (`mup.*`), and the MUP registers its function handlers. From there, two things can happen: (1) the LLM calls a function — the host routes it to the MUP, the UI updates, and the result goes back to the LLM. (2) The user interacts with the UI — the MUP calls `mup.notifyInteraction()`, which feeds a message into the LLM's context so it can react.
That's the entire protocol. No RPC framework, no streaming protocol, no handshake negotiation. A MUP declares what it can do; a host decides what to allow. ~400 lines of spec.
What's new since our post 4 days ago:
We built mup-agent, a local Node.js agent to show this working end-to-end. The agent loop runs on pi-agent-core, with pi-ai handling multi-provider LLM calls. Each MUP's declared functions are automatically registered as agent tools. When the LLM calls a tool, the agent routes it to the right MUP via WebSocket; when the user interacts with a MUP, the interaction is fed back into the agent loop. The browser is just a rendering surface — chat on the left, a grid of MUP iframes on the right.
You activate a pixel art canvas and a chart. You draw something. The LLM notices, analyzes it, and populates the chart — no prompt needed. The MUPs are reusable UI; the LLM is pure behavior.

  git clone https://github.com/Ricky610329/mup.git
  cd mup/mup-agent && npm install
  echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
  npm start

16 built-in MUPs: chess, pixel art, drum machine, slides, kanban, file workspace, camera, voice, and more. Works with Anthropic, OpenAI, Google, Groq, xAI.
Spec (~400 lines): https://github.com/Ricky610329/mup/blob/main/spec/MUP-Spec.m...
Design philosophy: https://github.com/Ricky610329/mup/blob/main/spec/MUP-Philos...
Repo: https://github.com/Ricky610329/mup

value: Show HN: MUP – Stop making LLMs rebuild UI from scratch every time


value: ekojs

value: Show HN: Linux Nvidia GPU V/F Curve Editor for Undervolting/OC

author: ekojs


value: JSchaeffer

value: Show HN: There's no good way to share AI agent trajectories, so I built one

author: JSchaeffer


value: danielmeppiel

value:
I work at Microsoft/GitHub and built APM because I was managing agent configs — prompts, instructions, MCP servers — across Copilot, Claude Code, and Cursor. Every new project meant copying skill files, installing plugins by hand, hoping nothing drifted upstream. I realized we were missing the dependency management layer for this new category of config to unlock faster adoption, composability and innovation.
APM (Agent Package Manager) is an open-source CLI that installs and manages AI agent dependencies (plugins, skills, rules, hooks, mcp, etc). It resolves transitive dependencies, pins versions with a lock file, and scans content for supply-chain attacks.
This was posted a couple days ago without context (https://news.ycombinator.com/item?id=47421969). Here's the full story.
1 minute video: https://github.com/microsoft/apm/releases/download/v0.8.2/ap...
How it works:
apm install — resolves any Agent Primitive (plugins, skills, hooks, rules...) and their transitive dependency tree from any git host. Plugin A depends on Plugin B and a shared MCP server? APM walks the tree. One command deploys to Copilot, Claude Code, Cursor, and OpenCode. Full agent setup ready to go for any dev with 1 command.
apm.lock — every resolved dependency pinned to exact commit SHA. Diff it in PRs. Same plugin set, every developer, every CI run.
apm pack — author plugins that compose on other agent config dependencies via apm.yml. Bundle as portable archives; apm unpack for offline environments. You can import other skills, rules or plugins in the plugins you author.
apm audit — scans for hidden Unicode characters (variation selectors, bidi marks) and outputs SARIF for CI. Agent instructions have direct access to your codebase and terminal. Scanning what goes into them matters.
Why this won't come from plugin vendors: each tool governs its own ecosystem. GitHub governs Copilot. Anthropic governs Claude. Nobody governs across tools, resolves cross-plugin dependencies, or gives consumers a lock file for what they actually installed. We need portability.
Packages are git repos — no registry, no signup. apm pack outputs valid plugin-native format, so if you stop using APM your plugins still work. Too early for true package artifacts, maybe down the road.
MIT-licensed under the Microsoft OSS github org and community driven.
External contributors shipped Cursor, OpenCode, Artifactory and Windows support.
Docs: https://microsoft.github.io/apm
Repo: https://github.com/microsoft/apm

value: Show HN: Agent Package Manager (APM) for Agent Configuration

author: danielmeppiel


value: WecoAI

value: Hey, we're the team at Weco. We've been working on autoresearch tooling and kept running into the same problem — there's no good way to monitor what's happening across steps, compare runs, or share results with collaborators. So we built an observability layer for it — think W&B but purpose-built for autoresearch workflows: step-by-step monitoring, performance tracking, and shareable dashboards. Would love to hear how others are approaching this.

value: Show HN: We built a Weights and Biases for autoresearch

author: WecoAI


value:
Indie makers are great at building. Terrible at figuring out what to build next. I made IndieRoadmaps to fix that.
IndieRoadmaps lets you publish your product roadmap publicly, collect feature votes from your community, and get continuous feedback throughout the build — not just at launch moment.
It's free to use. You sign in with Google, add your features, and share your roadmap URL with your audience.
Still early — 5 roadmaps live so far. Would love honest feedback from this community on whether this scratches a real itch or if I'm solving a problem that doesn't exist.

value: Show HN: IndieRoadmaps – public roadmaps for indie hackers


value: nathanjordan

value:
It’s been a big week for RIIR Redis projects as someone posted one earlier this week so I’m throwing my hat in the ring.
I’ve been experimenting with building an “improved” version of Redis using Rust as a personal project over the last few months in what started as a “what if” and has become something I’ve found myself more and more interested in. After the HN post last week I decided to see if there’s interest in such a more serious project that, despite having a bunch of AI-generated code. still aspires to someday be a quality tool. I definitely don’t claim to have created this thing all by myself, but I’ve put a lot of time guiding the implementation and testing.
Creating databases in the age of AI is still hard so I’ve been leaning on a bunch of testing from my experience in distributed systems design over the years to try and prove its correctness: “trust me bro” doesn’t work over network boundaries of course. I don’t claim that the code is good or idiomatic and only have a beginners knowledge of rust from working on another personal project a few years back, so any “adults” with working Rust experience are welcome to provide feedback and direction.
It currently supports all of the current Redis 8.0 functionality, including search, vectors, json, probabilistic structures, etc. as well as cluster mode, replication and persistence. I want to make it really easy to operate so I’ve added a host of things like open telemetry, Prometheus, dtrace support, http debug pages, a cli tool, etc.
I have thousands of tests in place not including various black box concurrency testing frameworks like turmoil and Jepsen.
Things I’m currently working to add:
Zero downtime upgrades
auto cluster rebalancing
Auto data migration proxy
Performance improvements like io_uring support
Let me know what you think!
(PS) in the process I tried implementing a coz-style profiler for tokio (current crate has been abandoned) as a side quest to figure out where to best spend time optimizing which has been a fun part of this as well.

value: Show HN: FrogDB – yet another "Redis in Rust" project

author: nathanjordan


value: Show HN: Clip – Claude Interactive Picker