value: mariothomas

value: Show HN: DNS-based MCP registry discovery – live demo at mcp.mariothomas.com

author: mariothomas


value: rouuuge

value: Doodle-style polls block multiple slots in your calendar while you wait for everyone to respond. FindDates takes a different approach: propose one specific time, share a link, the other person accepts or counter-proposes. Only one slot is ever in play at a time.

value: Show HN: FindDates – one proposed time at a time, so only one slot gets blocked

author: rouuuge


value: supertim

value:
I'm a marketer, not an engineer. This is the first iOS app I've shipped.
The backstory:
I spent three months on research before writing a line of code. Two things had to be true first: the content had to be genuinely different from the wellness space, and the monetization couldn't contradict what the product was trying to do.
On content: I read research on decision fatigue, attentional residue, and the paradox of choice. Most "thought of the day" apps are fortune cookies with better design. I wanted cards that made people sit with something uncomfortable, not cards that made them feel validated. 1,250 cards written and tagged across 12 content buckets before launch.
On monetisation: most wellness apps monetise by maximising session time, which is directly at odds with a mindfulness tool. I landed on charging for what the app actually does. Seven-day trial, then €1.99 a month or €39.99 lifetime. After trial, content progressively blurs rather than hard-bricking.
What it does:
One thought per day. A headline (max 10 words) and a body (max 120 words). You Carry it or Let Go. The app asks you to close it. Under two minutes. Cards are selected server-side by a Resonance Loop algorithm. Days 1 to 14 cycle through all 12 buckets. From day 15, selection weights toward buckets the person resonates with based on carry/let-go signals, with 20% exploration to prevent filter bubbles and 10% heat (cards with high community share rates).
Built with Claude Code, as a non-engineer:
I knew nothing about Swift, SwiftUI, Firebase, or Cloud Functions when I started. I mean I knew what they were, but not from a code perspective. Built the whole thing with Claude Code as pair programmer.
The unexpected thing: you can ask genuinely stupid questions without fear of judgment. I asked about async/await race conditions four different ways until it clicked. I can now read Cloud Function logs and debug Firestore rules. Not because I studied them, because building the thing forced me to learn and I had a patient collaborator the whole time.
The QA lesson:
This is what I would tell anyone using AI-assisted development. The code comes fast. The bugs are subtle.
14 builds before App Store approval. A code review found notifications had silently died after day 7 because the scheduler was never called on app open. A widget timezone mismatch gave US users the wrong card. A reinstall sync bug wiped returning users' history every time. None of these were caught by the AI. All were caught by systematic, edge-case-focused testing.
The underrated skill in AI-assisted development is not better prompting. It is thorough QA.
For a longer read on the research and philosophy behind this: https://onegoodthing.space/blog/the-app-that-asks-you-to-clo...
App Store: https://apps.apple.com/app/one-good-thing/id6759391105
Happy to dig into the algorithm, the SwiftUI patterns, the Cloud Functions architecture, or the Claude Code workflow.

value: Show HN: One Good Thing – one thought a day, then asks you to close the app

author: supertim


value:
I built Focus Warden, a Chrome extension for people who want more control over how they spend time online.
The core features:
- Block specific sites or entire categories (Social Media, News, Gaming) with one toggle
- Set daily time limits per site — hard limits or soft limits with a snooze
- Deep Focus mode that blocks everything except your whitelist; exiting early requires typing a custom phrase (default: "get distracted")
- Micro-learning unlocks: earn extra time on a blocked site by completing a short learning resource you define yourself
- Usage dashboard showing daily time spent per site
- Global tab cap (default 20) to reduce tab hoarding
Everything runs locally. No accounts, no servers, no analytics — your data never leaves your device.
The micro-learning unlock was the feature I found most interesting to design. Rather than just punishing distraction, it gives you a productive off-ramp. You define the resource yourself, so it stays relevant to what you're actually trying to learn.
Chrome Web Store: https://chromewebstore.google.com/detail/focus-warden/chgkcj...
Happy to answer questions or take feedback.

value: Show HN: Focus Warden – Block sites, set time limits, and micro-learn


value: Show HN: A weird thing that detects your pulse from the browser video


value:
Kelos is a Kubernetes framework for orchestrating autonomous coding agents. It runs Claude Code, Codex, Gemini, OpenCode, or custom agents safely in isolated, ephemeral pods.
The idea is that you define your everyday development workflows as YAML and let them run continuously on Kubernetes. Agent tasks are Kubernetes CRDs, so things like:
- Watch for “bug” issues → auto-draft a fix PR
- Auto-review incoming pull requests
- Auto-triage new issues with labels and priority
- Periodically scan the codebase → propose improvements
- Test the project as a new user → surface rough edges
Kelos is using this on itself. The self-development pipeline picks up open issues, investigates them, opens or updates a PR, self-reviews, and retries if CI fails. When the agent gets stuck, it labels the issue needs-input and stops:
https://github.com/kelos-dev/kelos/tree/main/self-developmen...
I still do the final review and manually merge PRs, but it’s been quite helpful.
https://github.com/kelos-dev/kelos
Happy to answer questions about the design or what’s broken.

value: Show HN: Kelos – Run Claude —dangerously-skip-permissions on Kubernetes


value: sfcodes

value:
I wrote a small Zsh plugin that lets you switch macOS Terminal.app profiles directly from the command line.
It's useful if you color-code environments (prod, staging, dev) or when you have a lot of terminals open of the same thing — multiple Claude or Codex sessions, SSH connections, or different projects — and want a quick visual way to tell them apart.
Type `profile` and press Tab to see and autocomplete all available Terminal.app profiles.

value: Show HN: Zsh plugin to switch macOS Terminal.app profiles

author: sfcodes


value: tayarndt

value:
I use Claude every day but there are things I will not type into a cloud service. I have a Mac with Apple Silicon running Apple Foundation Models locally and privately. But I was not always at my Mac.
So we built Perspective Intelligence Web. One Mac runs Perspective Server. Any device on your network opens a browser and chats with Apple Intelligence through it. Phone, Windows laptop, Chromebook, Linux machine. Streaming responses, token by token. Nothing leaves your network.
MIT License. Next.js, TypeScript, Tailwind. Full writeup: https://taylorarndt.substack.com/p/i-opened-claude-and-then-...

value: Show HN: Open-sourced a web client that lets any device use Apple's on-device AI

author: tayarndt


value: PkLavc

value: Show HN: CodePulse – Minimalist Online IDE Built with Vanilla JavaScript/Fastify

author: PkLavc


value: jpsdtj

value: Show HN: Opacore – free Bitcoin tax reports and open-source portfolio OS (MIT)

author: jpsdtj


value: bombashell

value: Show HN: GitPulse – stop buying dead software (and a timeline for your dev life)

author: bombashell


value: nadis

value:
We built CodeYam Memory because Claude Code kept making the same mistakes on our codebase. Our claude.md files quickly got stale and maintaining by hand or with Claude wasn’t sufficient.
While digging into this we found that Claude has a native rules system that allowed us to target specific parts of our repo with path matching. This was ideal for our use case but trying to manage these rules by hand was already not working and would be even harder with more granular, targeted rules.
CodeYam Memory uses a background agent to review your coding session transcripts, identifies confusion patterns, and generates targeted rules with proper scoping. You review and approve everything. Dashboard for auditing, a background-agent review process so nothing goes stale as code changes, tracking of everything lives in a simple file in git.
How to Get Started:
Install:
npm install -g @codeyam/codeyam-cli@latest
Then from your project root run:
codeyam
This will launch a dashboard with further instructions for initializing CodeYam Memory.
Free, runs locally, no login required, and language agnostic. Would love feedback.
More context:
Background blog post:
https://open.substack.com/pub/codeyam/p/introducing-the-code...
90 sec demo on our own repo:
https://youtu.be/oJ2gTb-lxbE
Demo teaching Claude a real OSS repo (Plane):
https://youtu.be/CjOKBwBCcOs
Website:
https://codeyam.com/

value: Show HN: CodeYam Memory – comprehensive memory management for Claude Code

author: nadis


value: whothatcodeguy

value:
process demo - https://i.redd.it/fbhlwsq1gcmg1.gif render demo - https://i.redd.it/smddwtryhcmg1.gif
in-app demo - http://app.topomaker.com/demo
After long stretches in 2d animation and film, recently I've been really drawn to 3d. It's closer to the way my brain thinks and I feel like it has so much power to realize cool ideas. Naturally, I kicked off a google search and fired up Blender. After an hour, I went on a walk and got sad realizing I'm going to have to become a master before I can do anything fun. That's when my dev ego brain struck the usual phrase "i'll just build my own".
So, I built Topomaker (name tentative), which is a minimal browser-based 3D modeler and animator. You can color individual faces, build simple characters or objects, animate them on a timeline, and export to gif, mp4, glb, or obj. The goal wasn't to make a Blender competitor, but more of a sketchpad or alternative. Something you can just doodle in, make some funny animations or characters for a small game with a closer connection to the web since thats my programming language of choice. Anyone who's tried to get Blender assets to match up in a Three.js environment knows the process — I wanted something that just lives in that ecosystem natively.
I just started it a couple weeks ago so there are probably tons of bugs, but feel free to play around with it and let me know what you think!

value: Show HN: I built a browser-based 3D modeler because I'm scared of Blender

author: whothatcodeguy


value: amirjavid

value: Show HN: I reverse-engineered car lease math against three real dealer documents

author: amirjavid


value: eddelgado

value:
This week we released the Kodus CLI.
It took a bit longer than we expected to ship. The reason was simple: there are already many ways to run reviews locally today. IDEs, extensions, terminal commands, agents inside the editor. So building “just another AI CLI” didn’t seem like a good idea.
The question that guided the project was different: how can we bring the quality of PR reviews to the moment when the code is still being written?
Today the CLI does two main things.
The first is running local reviews using the same context we use in PRs. The goal was to avoid that shallow review that only looks at the diff currently open in the editor. We try to reconstruct more repository context, similar to what happens during a PR review.
The second is helping resolve comments that Kody has already left on a PR, but directly from the local environment. Instead of opening the PR, reading the comment, going back to the editor, making the change, and repeating the process, you can work through those fixes directly in your coding workflow.
The whole idea revolves around reducing the feedback loop time.
Some design decisions came from things we heard from teams using other CLIs.
Auth in large teams often turns into friction.
Many tools assume each developer will create an account before using the CLI. That becomes painful when someone just wants to try it, or when an entire team decides to experiment.
We introduced team keys. An admin generates the key and shares it with the team. Anyone who installs the CLI can start using it right away.
Rate limits can ruin the local experience.
Some tools work well at first but become too restricted for continuous use.
The CLI runs BYOK by default, so you can use your own API key if you want.
Code agents are already part of the workflow.
Instead of treating this as something separate, we built two layers.
The CLI works as a direct interface to our API.
On top of that, there are Skills that teach agents how to use the same review flow.
There’s still a lot to improve. Repo context, how suggestions are presented, integration with different developer workflows. We’re using it heavily internally and adjusting things as problems show up.
If anyone wants to try it or contribute:
- repo: https://github.com/kodustech/cli
- feedback is very welcome
- issues and PRs are too
If you usually run local reviews, I’d be curious to hear what actually works and what only sounds good in theory.

value: Show HN: AI Code Review CLI

author: eddelgado

title: Show HN: AI Code Review CLI


value: dannythecount

value: Show HN: O4DB – Intent-based M2M protocol without centralized APIs

author: dannythecount


value: Qalypto

value:
Been running this for 5 months now. 4 exchanges (Binance, Bybit, OKX,
Bitget), 10 perpetuals, all on a single Hetzner box for 46 euro/month.
Stack: Python asyncio, Kafka in KRaft mode, ClickHouse, k3s. Cloudflare
Tunnel handles ingress.
Some things that broke along the way:
ORDERBOOK GAPS
Exchanges skip sequence numbers sometimes. Your local book drifts and
you dont notice until something goes wrong. Had to build per-symbol gap
detection with automatic snapshot recovery. Each exchange does sequencing
differently so thats four separate implementations.
CLICKHOUSE INSERTS
Started with small batches, ClickHouse was at 30% CPU just doing merges.
Bumped batch size to 5000 rows with 2 second intervals, dropped to 8%.
Also moved inserts to an async queue so the Kafka consumer never blocks.
LOGGING
At 500 msg/s the logger was allocating thousands of strings per second.
OOM killer got us twice before I figured it out. Set everything on the
data path to WARNING and it went away.
Current numbers:
- 120M+ messages/day
- P50: 250ms, P95: 400ms latency
- >99.8% data coverage
- 5 months, no major incidents
If anyone wants to poke around the data:
qalypto.com/data-lab
CSV samples, no signup needed.
Happy to answer questions.

value: Show HN: What I learned running a crypto data pipeline at 120M messages/day

author: Qalypto


value:
extract & customize<p>~/.claude/settings.json
{
  "spinnerVerbs": {
    "mode": "replace",
    "verbs": [
      " Thundering 천둥치는중",
      " Clauding 클로딩하는중",
      " Cooking 요리하는중"
    ]
  }
}

value: Show HN: Claude Code Spinner Verbs Extractor


value: Show HN: React multi-step form library with dynamically generated steps


value: flofra

value:
I’ve been using the new Claude Code CLI and Codex extensively, but I found myself constantly babysitting the terminal or waiting for rate limits to expire. I wanted a way to queue up complex coding tasks, walk away, and get a notification on my phone if the agent actually needs my input.
So I built Kodama. It’s a self-hosted daemon written in Go that wraps these CLIs as subprocesses.
Key Features:
Asynchronous Execution: Queue tasks for multiple projects; Kodama runs them sequentially in the background.
Human-in-the-loop (Telegram): When the agent hits a KODAMA_QUESTION or gets stuck, it pings you via Telegram. You can reply directly to the bot to provide the answer.
Rate Limit Management: If the agent signals a rate limit, Kodama saves a checkpoint and automatically retries after a cooldown (default 5h).
Execution Runtimes: You can run project commands (build/test/lint) directly on your host or in an auto-scaffolded Docker environment.
Web UI: A simple dashboard to manage your backlog and watch the live output via WebSockets.
A note on Security:
Kodama is designed as a local-first, trusted-network tool. There is no built-in authentication by design. Please run it on localhost, via a VPN (Tailscale/Wireguard), or behind a secure tunnel like Cloudflare Access.
The project is still a WIP, but it has already changed how I handle larger refactors or boilerplate-heavy features.
I’d love to get your feedback

value: Show HN: Kodama – A self-hosted autonomous daemon for Claude Code and Codex

author: flofra


value:
Hi HN — we’re Charlie and Sam (two brothers), and we built The Bias, an iOS news app (Android coming soon).
We started The Bias because we found traditional news feeds frustrating: one outlet gives you one framing; opening ten tabs gives you breadth but no synthesis. We wanted a way to understand major events quickly, without spending hours reading or defaulting to a single outlet’s perspective.
For each real-world event we publish a single write-up that makes it clear:
• What coverage converges on (core facts)
• Where perspectives or framing differ
• What’s disputed or still uncertain
• Where specific claims came from (full source list + claim-level traceability for key statements)
• How media around the world reported on the event — which can look very different from domestic coverage. This is especially interesting right now with the situation in Iran, where coverage diverges significantly across regional and international outlets.
How it works (high level):
• Ingest ~5,000–15,000 articles/day from 600+ sources
• Cluster articles by semantic similarity to group reports about the same underlying event
• Extract structured elements (facts, opinions, consequences, speculation, prior context)
• Group and annotate that information
• Generate a first draft with LLMs
• Run the draft through a multi-stage pipeline (coverage completeness checks, contradiction handling, perspective balancing, source traceability, uncertainty labeling, etc.)
• Human review of the final article focused on misrepresentation, hallucination, and missing major viewpoints
We also publish a weekly “rundown” (~25 min read) that summarizes the week, personalized to a user’s interests, using roughly the same process.
The product exists today on iOS and can be used immediately:
• Methodology: https://thebias.co.uk/policies/what-we-do
• About: https://thebias.co.uk/policies/about-the-bias
Free download; limited reading without a subscription.
 Subscription removes limits and unlocks features like claim traceability and international outlook.
We’re especially interested in feedback on:
• Does this feel faster than reading multiple outlets, or just different?
• What would make you trust (or distrust) a synthesis like this?
• Is claim-level traceability enough, or would you want stronger signals?
• Is this meaningfully different from using Ground News?
• If you think this is a bad idea, we’d genuinely like to know why.
Happy to answer questions about the pipeline, trade-offs, or mistakes we’ve made so far.
— Charlie and Sam

value: Show HN: We built a News Synthesis Engine to fight media bias


value: HrubyOnRails

value:
I remember watching the AlphaGo documentary in 2017. What stood out to me was that the model got drastically better when it started competing against itself. GANs clicked for me similarly: a generator and discriminator competing, and somehow the competition is what produces something remarkable.
I've been curious whether this principle generalizes to today's agents.
So mehulkalia and I built Browser Brawl at the YC / BrowserUse hackathon last weekend and won first place. It is a fun experiment in which an attacker agent tries to complete tasks on live websites while a defender agent injects JavaScript to sabotage it.
The analogy isn't perfect, because browser tasks aren't zero-sum. But our hypothesis is that an agent faced with an adversary should produce more interesting training data than one navigating clean, static environments.
Try it on: http://browser-brawl.com
GitHub: https://github.com/RichardHruby/browser-brawl
Demo Video: https://youtu.be/NIoFXv-JvBY
(Skip to [0:55](https://www.youtube.com/watch?v=NIoFXv-JvBY&t=55s) to see the agents “brawling” in the arena :), [1:52](https://www.youtube.com/watch?v=NIoFXv-JvBY&t=1m52s) to see the browser traces generated)
Would love to chat with anyone building or training browser agents. Happy to dive in below!

value: Show HN: BrowseBrawl – What if browser agents battled to generate training data?

author: HrubyOnRails


value: Beckmeister

value:
Introducing students to the fundamentals!
This app does the following:
-./setup.sh
    -Installs Ollama Docker Container
    -Pulls in first LLM (1B Parameter model)
    -Starts WebUI chat interface
    -Use can one-click deploy other models easily
Lesson plan included on the GitHub page. Put students in front of Kali and have them follow the directions!
Thanks for looking.

value: Show HN: Teaching Tokens: Implementing Private, Lightweight AI in the Classroom

author: Beckmeister


value:
Hey HN! I'm Garrett, creator of eZorro.
The problem: I had trading ideas but couldn't code them. I'd think "buy Apple when it drops 5% below its 20-day moving average" and then spend hours trying to wire up broker APIs, backtest logic, and execution — or just never do it at all. Sure, I can get a plug-in or prompts from somewhere for AI, but if it’s not designed by actual industry specialists, I can’t trust it.
The solution: eZorro, built by those who actually built the tools for banks and hedge funds, lets you describe trading strategies in plain English. The AI converts your idea into an executable, automated trading system connected to your existing brokerage account. From retail broker investor to professional trader - No coding required.
How it works:
1. Describe your strategy → "Buy Tesla when it drops to $200 and sell at $250"
...You can...
→ a. Use multiple conditions beyond this example
→ b. Validate the strategy to ensure it makes sense
→ c. Backtest the strategy to prove it works
→ d. You can then have the application try to optimize it further.
2. Connect your broker (Fidelity, Schwab, Interactive Brokers, ETRADE, Robinhood, +24 others including Crypto in the U.S. alone)
3. Review the generated strategy parameters and confirm
4. It runs 24/7, executing trades automatically when conditions are met
Why this matters:
Most "AI trading" tools are really just fancy screeners or chatbots that give you opinions. eZorro actually closes the loop — from idea to backtest, to optimization, to live execution. The whole point is that your plain-English intuition becomes a real, running system without touching an API or writing a single line of code.
What you get:
 Natural language → automated strategy pipeline
* 15+ broker integrations (secure OAuth, no credential sharing)
* AI conversational assistant to help refine and iterate on strategies
* Technical indicator support (RSI, moving averages, etc.)
* Strategy types from mean reversion to profit-taking to risk management
* Real-time execution when market conditions match
Try it: For a two week free trial →
App: https://platform.ezorro.app
Docs: https://docs.ezorro.app
Site: https://ezorro.app
Honest question for HN: Is natural language the right interface for trading strategy creation, or do more sophisticated traders always want to drop into code eventually? I'm curious where people think the ceiling is for a no-code approach.

value: Show HN: EZorro – Describe your trading strategy, and turn it into an algo


value: Show HN: Ekumene – In a distracted era, I built a system to see your time whole


value: rivradev

value:
Hi HN,
I’m an indie dev, and as my tech stack grew, so did the number of SaaS subscriptions and invoices. Every month, I’d get a chaotic pile of PDFs and image receipts. I absolutely hate bookkeeping. It breaks my flow state, and honestly, the last thing I want to do on a weekend is open an Excel spreadsheet to manually input tax data.
So I built Recite.
Originally, it was just a simple web app that used vision models to parse receipts into clean CSV. But I realized I didn't even want to log into my own web app.
So I pivoted and turned it into a Public APIs/agent skill and an MCP server. Now, I just download all my invoices into a single local folder and tell my agent (I use OpenClaw), "Process my receipts."
The agent hits the Recite API, reads the images/PDFs, categorizes them using standard accounting logic, renames the files by date, and generates a structured CSV for me. I literally don't look at spreadsheets anymore.
How to use it:
Public API: Because we all love APIs.
Agent Skill: The easiest way to let your agent do the work in environments like OpenClaw or Claude Desktop.
MCP Server: If you want more control and want to build your own custom agentic workflows.
I’m currently focused on maxing out accuracy and keeping costs as close to zero as possible. There’s a generous free tier for indie devs because I know the pain.
I would love for you to try hooking it up to your agents and see if it saves you as much time as it saves me. Any feedback on the API or the categorization logic is highly appreciated!
Website: https://recite.rivra.dev/
API Docs: https://recite.rivra.dev/docs/api
MCP Setup: https://recite.rivra.dev/help#mcp-server
GitHub Skill: https://github.com/rivradev/recite-agent-skill

value: Show HN: Recite – I built an Skill and MCP so my AI agent does my bookkeeping

author: rivradev


value: lukaslukas

value:
Hey HN,
I built a free widget that adds an "Ask AI About Us" button to your website. I think it's a great idea to let AI be your advocate. When a visitor clicks the AI icon, it opens the AI platform in a new tab with a pre-filled prompt.
It's not a chatbot. There's no training data to maintain or conversation flows to design. It simply connects your site to the AI platforms that people already use.
Why did I build this? People are already asking AI about products before buying them. The problem is that you have zero control over what the AI says about you. It might be accurate, outdated, or just plain wrong. This widget lets you control the starting prompt and shape that conversation.
How it works:
1. Write a prompt (e.g., "Compare X to Y for small businesses. Be honest about the pros and cons.").
2. Paste one script tag into your site.
It's just one script tag; no cookies are used. It works with WordPress, Shopify, Webflow, plain HTML, and more.
Features include prompt rotation with built-in A/B testing, the ability to match a prompt to a specific URL, analytics showing which AI platforms your visitors prefer, and multi-language prompt support based on visitor locale.
Pricing: Free with all features. No usage limits.
Website: askaiwidget.com
I am happy to answer questions. What do you think?

value: Show HN: Let your website visitors ask ChatGPT/Claude/Gemini about your product

author: lukaslukas


value:
Hi HN,
I’m Ashu, founder of VideoDB. I’ve spent a big chunk of my life building video infrastructure. Not video creation. Video plumbing.
The stuff you only learn after production breaks:
timebases, VFR, keyframes, audio sync drift, container quirks, partial uploads, live streams, retries, backpressure, codecs, ffmpeg flags, cost blowups, and “why is this clip unseekable on one player but fine on another”.
This week we shared VideoDB Skills, a skill pack that lets AI agents call those infra primitives directly, instead of you wiring pipelines with screenshots plus FFmpeg glue.
Repo:
https://github.com/video-db/skills
What it enables (infra level):
- Ingest videos and live streams
- Index and search moments
- Return playable evidence links
- Run server side edits and transforms
- Trigger automations from video events
Why this matters for agents:
Agents can reason, write code, browse. But continuous media is still mostly invisible. In an agentic world, perception needs to be a first class interface, not a manual workflow.
Try it quickly:
npx skills add video-db/skills
Then inside your agent: /videodb setup
A few prompts to test:
1. “Upload this URL and give me a playable stream link”
2. “Search this folder for scenes with <keyword> and return clips”
3. “Capture my screen for 2 minutes and give me a structured summary”
4. “Monitor this RTSP feed and log events with timestamps”
What I’m looking for from HN:
1. Does this feel like the right abstraction layer for perception in agent stacks?
2. What would you consider the minimum viable “perception API”?
3. Where do you think this fails in the real world, latency, cost, privacy, reliability?
If you try it and it breaks, tell me the agent, OS, and the error output. I’ll fix it.

value: Show HN: I packaged decade of video infra battle scars into tools for AI agents


value:
I've been building a Kubernetes operator for SLO management (SLOK) and just shipped a feature I haven't seen elsewhere: WEIGHTED_ROUTES composition.
The problem
Most SLO tools treat a user journey as a simple chain: if any service fails, the whole thing fails. But real traffic doesn't work that way. In a checkout flow, 90% of users might skip the coupon service entirely. If the coupon service has 99.5% availability, does that really pull your checkout SLO down to 99.5%? No — because most of your users never touch it.
The model
WEIGHTED_ROUTES lets you describe which percentage of traffic flows through which service chain. Each chain is an implicit AND (all services in the chain must succeed). The composed error rate is:
e_total = 1 - Σ( weight_i × Π(1 - e_j) )
For the checkout example (90% skip coupon, 10% use it):
e_total = 1 - (
  0.9 × (1 - e_base) × (1 - e_payments)
  +
  0.1 × (1 - e_base) × (1 - e_coupon) × (1 - e_payments)
)
SLOK translates this formula directly into Prometheus recording rules wired into the standard multi-window burn rate pipeline.
The YAML
kind: SLOComposition
spec:
  target: 99.9
  window: 30d
  objectives:
    - name: base
      ref: { name: checkout-base-slo }
    - name: payments
      ref: { name: payments-slo }
    - name: coupon
      ref: { name: coupon-slo }
  composition:
    type: WEIGHTED_ROUTES
    params:
      routes:
        - name: no-coupon
          weight: 0.9
          chain: [base, payments]
        - name: with-coupon
          weight: 0.1
          chain: [base, coupon, payments]
  alerting:
    burnRateAlerts:
      enabled: true
The operator generates the PrometheusRules automatically. You get burn rate alerts on the composed SLO, not just on individual services.
Other things SLOK does
AND_MIN composition (worst-case across services)
Built-in SLI templates for http-availability, http-latency, kubernetes-apiserver
Automatic error budget tracking exposed in .status
Event correlation: when a burn rate spike is detected, SLOK creates an SLOCorrelation resource listing recent Deployments, ConfigMap changes, and cluster events that may have caused it — with an optional LLM-enhanced summary (Llama 3.3 70B via Groq)
WEIGHTED_ROUTES is alpha. Feedback on the API shape is welcome.
Repo: https://github.com/federicolepera/slok

value: Show HN: SLOK – SLO composition with traffic-weighted service chains in K8s


value: tstockham

value:
About two weeks ago, I posted Engram here, a memory layer for AI agents. The response was great and pushed me to keep building. Here's where things stand.
What changed since the last post:
DMR benchmark: 92.0% accuracy (460/500). Retrieval hit rate is 96.4%. This is competitive with systems backed by graph databases and Python ML stacks. Engram is TypeScript + SQLite.
LOCOMO benchmark (long-conversation memory): 80.0% across all 10 conversations, 1,540 questions. Full context scores 88.4% but costs 30x more tokens.
Bi-temporal memory model. Every memory has valid_from/valid_until timestamps. Point-in-time recall via asOf parameter. Contradiction detection automatically supersedes stale facts.
Hosted API launched on Fly.io with Stripe billing. Self-hosting remains free (bring your own Gemini key). Hosted tiers start at $29/mo.
OpenAI-compatible base URL. One env var to use Groq, Cerebras, Ollama, or any OpenAI-compatible provider instead of Gemini.
70 tests passing. Published engram-sdk@0.5.5 on npm.
What I learned:
Benchmark scores are fragile. 13 commits to my core vault module dropped LOCOMO from 84.5% to 62%. I had to treat the eval suite like a regression test, run it after every meaningful change. If you're building a memory/RAG system and not doing this, you're flying blind.
The judge LLM matters more than you'd think. Switching from one model to another as the benchmark judge changed scores by 10+ points on the same data. Always disclose your judge model. We use Gemini 2.5 Flash.
Temporal context is everything. Memories without timestamps are almost useless for "when" questions. Prefixing memories with their conversation date and teaching the LLM to resolve relative dates ("yesterday," "last week") was the single biggest accuracy improvement.
The API is the product, not the SDK. 95% of users will hit a REST endpoint, not import a TypeScript module. I wish I'd built the hosted API sooner.
What's next: LangChain/CrewAI integrations, an Engram skill for OpenClaw agents, and getting the academic paper on arXiv.
Happy to answer questions about benchmarks, architecture, or the experience of building this as a PM who codes.
GitHub: https://github.com/tstockham96/engram
Site: https://engram.fyi
npm: https://www.npmjs.com/package/engram-sdk
Hosted API: https://engram-hosted.fly.dev

value: Show HN: Engram update – 92% DMR, hosted API, lessons shipping agent memory

author: tstockham


value: mgechev

value: Show HN: Skill Eval – A framework for testing the quality of AI agent skills

author: mgechev


value: lieret

value: Show HN: All the LM solutions on SWE-bench are bloated compared to humans

author: lieret


value: postquant

value: Show HN: Find quantum-vulnerable crypto in your code before 2030 hits

author: postquant


value: wyre

value: Show HN: Beans, a task tracker with verification gates and agent orchestration

author: wyre


value: davidnortonjr

value:
I built this to help look at all the Kubernetes clusters my team manages, to help with planning, troubleshooting, validating acceptance criteria on a ticket, etc.
I could probably have used a monitoring tool but 1) sometimes monitoring tools are split up by cluster/environment anyway, and 2) I like the kubectl interface with JSON and YAML output.
Curious what people think and open to feedback!

value: Show HN: kubectl-x to query multiple Kubernetes clusters at once

author: davidnortonjr


value: damiandomzalski

value:
FirstVibe is an AI selfie analyzer that gives you a "vibe check" -- a personality and impression analysis based on your photo. Upload a selfie and get an overall score, personality label, 5 category scores (attractiveness, confidence, charisma, style, approachability), celebrity lookalike, aura type, dating energy, and a set of fun predictions and personalized improvement tips.
It uses Claude's Vision API to read facial expressions, body language, styling choices, and overall energy from the photo. The difference from typical face-rating apps is that it focuses on personality and vibe rather than bone structure or symmetry (though it does golden ratio and face shape analysis too). The AI analyzes things like approachability, confidence level, conversation style, and what kind of first impression you make.
Technical details: Rails 8, Hotwire/Turbo for real-time result streaming, PostgreSQL with JSONB for flexible AI output storage, Solid Queue for background jobs. Two Claude API calls run in parallel (core scores on Sonnet, detail analysis on Haiku) and results are broadcast via Turbo Streams as they complete, so you see your score within 8-12 seconds rather than waiting 20+ seconds for everything.
Freemium model: basic score and 2/5 category scores are free, full results are $1.99-$2.49. Over 6,000 scans analyzed so far.
Built as a solo project. No auth required -- cookie-based session identity, no signup friction.
Free to try: https://firstvibe.app
Open to feedback, especially on the AI analysis quality and the free/paid split. Would love to hear what you think.

value: Show HN: FirstVibe – AI analyzes your selfie and scores your vibe in 30 seconds

author: damiandomzalski


value: I slop-resurrected an abandoned repository. I first heard about bitchx in Mr. robot series when i was very small and thought coding was cool.<p>LMK what features can exist or make it better and weather if you are an unc.

value: Show HN: Rust rewrite of BitchX IRC client


value:
Hi HN,
I built groundctl because every team I've been on has the same problem: "it works on my machine." Someone upgrades Node, someone has the wrong Terraform version, a new hire spends two days debugging a setup that differs from everyone else's.
Existing tools don't solve this. chezmoi manages dotfiles, not tool versions. mise/asdf manage language runtimes per-project, not team-wide standards. Ansible is overkill for local machines.
groundctl is a single Go binary that:
1. Scans your machine and creates a `.ground.yaml` standard
2. Compares any machine against that standard (`ground check`)
3. Auto-fixes drift with one command (`ground fix`)
It detects 18 tools (node, python, go, docker, terraform, etc.), works across macOS/Linux/Windows, integrates with 7 package managers, and runs in <500ms.
The team workflow:
- Commit `.ground.yaml` to your repo
- New hire runs `ground check` — sees exactly what's different
- `ground fix` installs/upgrades everything automatically
- CI enforces the standard with `ground check --ci`
It also has secret management (1Password, Vault, keychain backends), shell hooks that auto-check on `cd`, and HTML/Markdown drift reports.
Written in Go. MIT licensed. No dependencies. Single binary.
Would love feedback on the approach and what tools/features you'd want to see next.

value: Show HN: Groundctl – "Terraform plan" for your local developer machine


value: SkyLinx

value:
Hi HN,
I am the founder of SprintPulse. Like many of you, I used to dread retrospective meetings. They often turned into a repetitive cycle where we wrote down the same issues every sprint but never actually fixed them. "Better communication" was on our action item list for months.
I built SprintPulse to fix that loop. It is a tool designed not just to collect feedback, but to make sure it leads to real change.
When I looked at the tools available, I found they fell into two camps.
On one side, you have generic whiteboards like Miro or FigJam. They are great for free-form drawing, but they are too open-ended for structured retros. They don't help you track history or remind you of what you promised to fix last month.
On the other side, you have specialised retro tools. I found that while these solve the problem, they often feel outdated. The UX can be clunky, they are often loaded with complex settings you don't need, or they are just too expensive for smaller teams to justify.
I wanted to build something in the middle. A tool that has the structure and insights you need (for which  AI isn't just a "me too" buzzword), but with a modern interface that doesn't require a tutorial.
- AI Analysis: Instead of just counting votes, the AI reads the feedback to spot trends and suggest action items. If the team is getting burnt out or if specific topics keep appearing without resolution, the system flags it.
- Accountability: This was the main thing I wanted. SprintPulse tracks your action items from previous sprints. If you ignore a problem for three weeks, the tool brings it up. It forces you to either fix it or consciously drop it.
- Clean UX: I focused on keeping it fast and lightweight, and enjoyable to use. You just log in and start the meeting.
I believe smaller teams shouldn't have to pay just to run a basic retro.
- Free Plan: We have a solid free plan for teams up to 10 users. It includes 3 retros and the core features. No credit card required to sign up.
- Paid Plans: If you have a larger team or want deep historical analytics and insights, integrations with Linear, Jira and Slack, we have paid tiers.
For the HN community, I am offering 40% off any paid plan (recurring, forever) with the code HACKERNEWS.
I would love for you to take a look and tell me what you think.
Link: https://sprintpulse.io/
Thanks!

value: Show HN: SprintPulse – AI-powered retrospectives that drive action

author: SkyLinx


value: vkatganti

value:
Most PHI de-identification pipelines are stateless: detect identifiers, remove them, done. The problem is that re-identification risk doesn't work that way in practice.
A name fragment that's harmless in record #1 becomes identifying when it co-occurs with a location in record #47 and a timestamp in record #203. Static masking can't see that.
This project treats de-identification as a stateful control problem instead. The system maintains a per-subject exposure graph across time and modalities, computes rolling re-identification risk, and dynamically escalates masking strength only when cumulative exposure justifies it.
The core idea: privacy protection as a feedback loop, not a preprocessing step.
A few things I found interesting building this:
- Cross-modal linkage (text + ASR + image proxy + waveform headers) creates non-obvious re-ID surfaces
- Pseudonym versioning on risk escalation lets you contain linkage continuity without global reprocessing
- The privacy–utility tradeoff is actually controllable if you model exposure state explicitly
All experiments run on synthetic streaming data (no real PHI). Reproducible from source. Colab demo included.
Repo: https://github.com/azithteja91/phi-exposure-guard
Happy to discuss the architecture, the RL policy design, or the tradeoffs vs. existing de-ID approaches.

value: Show HN: Modeled healthcare de-identification as longitudinal RL control problem

author: vkatganti


value: OzanEnginsal

value:
Hi HN,
I am a solo developer building Arxel (arxel.app), a web tool for architects and computational designers to explore early-stage building volumes.
I noticed that designers often spend a lot of time manually iterating on basic geometries just to see what fits within site boundaries and volume limits. I wanted to turn this into a search problem.
You input your boundary dimensions, target volume, and floor height. Under the hood, Arxel uses the Google OR-Tools CP-SAT solver to find valid configurations. It enforces rules like gravity (voxels must be supported) and connectivity, so every output is physically viable.
The solutions stream into the 3D viewport in real-time. You can then filter the results and export directly to OBJ.
I would love to hear your feedback on the solver approach or the UX. Thanks for checking it out.

value: Show HN: Arxel – Constraint-driven 3D building masses in the browser

author: OzanEnginsal


value: horushe

value: Show HN: Chat, Generate, Refine and Export Your Hero Shot

author: horushe


value: parfenovvs

value:
Viewing Android logs usually means either drowning in raw `adb logcat` output or opening Android Studio just to use its log viewer. Neither is great if you live in the terminal.
LazyLogcat is a TUI built in Go on top of Bubble Tea. It lets you filter by tag/level, search, and tail logs from connected devices — covering most of what Android Studio's logcat viewer offers, without leaving your terminal.
Would love feedback on what's missing or what you'd want next.

value: Show HN: A TUI for viewing Android adb logcat logs

author: parfenovvs


value: SurvivorForge

value: Show HN: Cursor Rules for 16 Frameworks (React, Go, Rust, Python, etc.)

author: SurvivorForge


value: yokostuno

value: Show HN: IOcomposer – AI-assisted IDE – nRF54 bare-metal (no Devicetree/Kconfig)

author: yokostuno


value: baristaGeek

value: Show HN: I built a live race between LLMs to see which generates tokens fastest

author: baristaGeek


value: francosimon

value: Show HN: Nexus – Agent economy protocol built on A2A and MCP

author: francosimon


value: eibrahim

value:
Gold In Egypt (https://www.goldinegypt.com) is a gold price tracker for the Egyptian market.
Shows real-time gold prices in EGP for 24k, 21k, 18k, and 14k per gram. Includes historical price charts, price alerts, and a dealer directory.
The main differentiator is the shabka calculator. In Egyptian weddings, the groom's family gives gold (shabka) to the bride, and it's one of the biggest financial decisions a couple makes. The calculator lets you input a budget and see how many grams you can get at current prices across different karats.
Arabic-first interface with RTL layout. Responsive web app, price data aggregated from multiple Egyptian market sources.
Feedback welcome, especially from anyone familiar with the Egyptian gold market.

value: Show HN: Gold In Egypt – Arabic-first gold price tracker, shabka calculator

author: eibrahim


value: krenerd

value:
It it always bugged me when I read or share an article, the discussion lives separately from the article. I imagined being able to add Google-Docs or Notion style comments on any website. We save a snapshot of the website and allow adding discussions that live side-by-side and directly reference parts of the article.
HN articles are automatically indexed in  https://cooo.link/hackernews
and you can add any website, PDFs on https://cooo.link/
Built with SvelteKit, SingleFile(for archiving page), Railway. Solo dev. Would love feedback if you found it interesting! Thanks

value: Show HN: I put HN discussions next to the article where it belongs

author: krenerd


value:
My colleagues and I each run agents across a bunch of different environments, Claude Code, Cursor, Cowork, OpenClaw.
There's no lightweight way to pass context between them.
Finish something in one agent, need to hand it off to another, maybe yours, maybe a coworker's, and you're back to copy pasting things cross platform.
Agenthub gives each agent a self-generated public address. One command, you get a public key, that's your address.
No need for registration, OAuth, accounts. Anything that has your address, another agent, a coworker's agent, or any program can message you.
Your agent decides whether to trust the sender. Our server just routes.
How are you currently passing context between agents in different environments?
GitHub: https://github.com/lws803/agenthub

value: Show HN: Agenthub – Public addresses so agents can message each other


value: thesamenajar

value: Show HN: Waitmore – simple public timers anyone can create and share

author: thesamenajar


value: mareksotak

value: Show HN: Visual builder for Driverjs product tours -no-code, export/import, free

author: mareksotak


value: ULudo

value:
ClawReview is an experiment exploring whether AI agents can conduct research themselves.
Agents can:
- publish research papers (Markdown)
- review other papers
- participate in a simple peer review process
The platform tracks submissions, reviews, and decisions transparently.

value: Show HN: ClawReview – A platform where AI agents publish and review research

author: ULudo


value: NubPlayz

value:
I recently built and published my first npm package called Miku Cursor Kit.
It’s a small React component that replaces the default mouse cursor with an animated pixel-style Miku cursor.
The package is fully bundled, works with Next.js, Vite, and plain React, and doesn’t require users to manually import assets or styles.
You can install it with:
pnpm add miku-cursor-kit
(check out github readme to know how to install)
If anyone has feedback on the package structure, bundling setup, or ways to improve it, I’d really appreciate it,
GitHub: https://github.com/NubPlayz/miku-cursor-kit
npm: https://www.npmjs.com/package/miku-cursor-kit

value: Show HN: Miku-cursor-kit – A small Hatsune Miku themed project

author: NubPlayz


value: mrosenfield

value:
Hey HN — I'm Michael from Decipher (https://getdecipher.com). We build infrastructure for autonomously generating and maintaining end-to-end tests.
Today we’re launching our Claude Code integration.
We built this because as teams ship more code, especially with coding agents, they need more regression coverage. Claude can already generate a decent Playwright file from a repo and prompt. That solves first-draft generation. It does not solve repeatability.
A generated test is still a static guess. The real problems start when it meets the live app: the browser is logged out, a modal appears, a feature flag changes the path, a selector is stale, or the app changed in a way that requires updating the test without changing what it is supposed to verify.
That is the gap between “Claude wrote a script” and “we have durable E2E coverage.”
Our system splits that loop in two. Claude handles local planning: it reads the request, inspects the repo, infers the flow, and drafts the initial step plan. Decipher handles runtime: agents in our infrastructure run the steps in a live browser, observe what happened after each step, classify failures, and use the product knowledge captured during planning to repair the failing segment.
Once the test is on Decipher, our agents continue maintaining it against the test’s original intent. As the UI or flow changes, they update the test mechanics without silently changing what the test is supposed to verify.
We chose Skills + CLI instead of MCP because this is not a single tool call. It is a stateful loop: gather context, compile steps, start a remote run, inspect runtime state, patch failures, and resume. The CLI handles auth and transport. Skills keep Claude on that path and preserve a clean boundary between local context and remote execution.
In practice, Claude builds an initial plan and sends it through the CLI to our backend. A remote worker runs it against the live app in a cloud browser. The remote agent turns Claude’s steps into real actions on the product, figuring out the right element to click and modifying steps as needed. After each step, or on failure, the Decipher agent sends structured state back to Claude: what step ran, what the agent did, what state the page is in, what kind of failure happened, and the artifacts needed to repair it. Claude can then chime in and make changes.
Feel free to give it a try. We'd greatly appreciate any feedback you might have.

value: Show HN: Decipher x Claude Code – Infra to auto-generate and maintain E2E tests

author: mrosenfield


value: cospaia

value:
Epupp has two modes of operation:
1. *Live REPL connection from your editor to the web page*, letting you inspect and modify the page on the fly, with or without the assistance of an AI agent.
2. *Userscripts*: Somewhat Tampermonkey style (I love Tampermonkey!).
The two form a powerful pair. The live REPL connection, while happily supporting one-off changes or data extractions, is also a very efficient and fun means to interactively develop userscripts. The buzzword here is Interactive Programming (aka REPL-driven development).
I started to build Epupp because I wanted the AI agent to help me solve a problem with printing a very tall receipt cleanly from Gmail. After that success, I realized it was generally very useful so I made an extension out of it. I then also noticed that I wanted to be able to save my live tampers as userscripts.
Epupp's scripting language is ClojureScript, the SCI kind. This is what makes the live tampering possible.
I have probably gotten a lot of things wrong with this first version. I am entering feedback-driven mode now. Though, unless something is terribly wrong with the API, I intend to keep it stable. In true Clojure tradition, I do not want to break my callers.
Epupp is free and open source, available at the Chrome and Firefox extension stores.
Try it out, please. I have created a template project which I hope can help with getting started + be your base for using Epupp.
* https://github.com/PEZ/my-epupp-hq
Security:
* Epupp enables a userscript to do just about anything on web page, including all the dangerous things. The gate is the user, scrutinizing userscripts and userscript authors.
* The REPL opens a websocket to Epupp's REPL. Again the user is responsible for what connects to that websocket.
* On a whitelist of domains, userscripts can install and modify userscripts. This enables a web userscript installer to be active on GitHub, GitLab and Codeberg. Userscripts can not, however, list or read userscripts from Epupp.
* The REPL can install, modify, list and read userscripts. But only if the user enables this in Epupp after establishing the REPL connection.
Demo videos:
* Copilot builds the Isolated Element Printer script, using interactive programming: https://youtu.be/CuEWN5yYVa8
* LinkedIn Squirrel, a userscript that keeps posts you engage with in immediate reach: https://youtu.be/yU6rsjoR7HQ
On the roadmap:
1. Fix issues when used with Firefox
2. Fix (many more) issues with Safari
3. Mobile browser support
WDYT, HN?

value: Show HN: Epupp – Live, REPL-driven, browser tampering

author: cospaia


value: SurceBeats

value: Show HN: HomeDock OS – A browser-based desktop OS to self-host your Docker apps

author: SurceBeats


value: anonymzz

value: A simple Go CLI tool that instantly converts tree-formatted text (like AI output) into actual folders (and placeholder files) on your disk.

value: Show HN: Convert text folder trees into real directories (no more mkdir)

author: anonymzz


value: knowshan

value:
The core idea: teams create "broadcast stations" and post structured updates (breaking changes, maintenance windows, feature releases) to them. Other team members subscribe to the stations they care about and get a clean DM when something relevant goes out. No need to join another channel or configure notification settings per-channel.
External feeds feature: Beyond internal team broadcasts, there's also a pull-based external feeds tab in the app home — for following public sources like status pages or release notes from tools your team uses. Right now it supported only few external feeds and I may add support for more feeds later. Same place, different kind of signal.
What would make you actually use something like this at your company? Happy to answer questions and genuinely would love feedback on it.
Hosted on Railway (hobby plan for now — curious how far it holds).
Thanks!

value: Show HN: Beacon – Slack app for structured team announcements with subscriptions

author: knowshan


value: novaheic

value:
Over the years, I've tried pretty much every personal finance tool out there. Loved some, hated others, but in the end, I always came back to using my trusty google sheet.
I needed something that combined YNAB's envelope budgeting with what a multi-asset portfolio tracker does. For me, your budget and your investments are linked. Obviously, never invest more than you can afford to lose - but how are you supposed to know how much that is for you without understanding your spending habits?
So I built Finzen
Finzen = budgeting + portfolio tracking + rich visual reports and stats
Currently in free open beta.
Built with vue, vite, tailwind, typescript
AES-256 encrypted data storage, EU servers, No Bank Sync
finzen.org
app.finzen.org
docs.finzen.org
I've been working on this since last July. Feels good to finally have something I can share! Feedback would be awesome. This is the first project I've ever actually finished!!!

value: Show HN: I spent 1000 hours building my dream personal finance dashboard

author: novaheic


value: PowMan

value: Show HN:JSON API for US HTS and Canadian Customs Tariff, with Change Detection

author: PowMan


value: euanai

value: Show HN: Novum – Automated ML Research Pipeline with Anti-Fabrication Guards

author: euanai


value: dkargatzis

value: Building an open-source repo with deterministic validators backed by agent evaluation loops to turn agent instructions (.e.g. .cursorrules, claude-guidelines.md, copilot-prompts.md) into hard guarantees.

value: Show HN: Turn .cursorrules / repo guidelines into GitHub pre-merge checks (OSS)

author: dkargatzis


value:
I’ve been exploring how to make AI agents safer to use in real applications, especially as they start interacting with tools, APIs, and real systems. One recurring problem is that agents can hallucinate actions, call tools they shouldn’t, or over‑reach in ways that make them hard to trust in production.
To experiment with better patterns, I put together a small starter repo:
Secure Agent Starter
https://github.com/timbuctoo/secure-agent-starter
It’s intentionally minimal — not a full SDK — but it demonstrates a simple structure for:
- Capability‑based permissions
- An “action firewall” pattern
- Example capability + policy files
- A tiny agent example
- A mock authorization step (no backend required)
- A folder layout you can drop into any agent project
The goal is to give developers a mental model for agent security before wiring up real tools or APIs. Think of it as a conceptual starting point for designing safer agent architectures.
I’d love feedback on:
- What security patterns you’d want to see next
- Whether this structure makes sense for real‑world agent projects
- Any missing pieces that would make this more useful
Thanks for taking a look.

value: Show HN: Secure Agent Starter – A minimal template for building safer AI agents


value: qainsights

value: A blazing-fast command palette for Apache JMeter. Search components, run actions, and discover surprises — all from your keyboard.

value: Show HN: SuperKey – JMeter Command Center

author: qainsights


value: dingmuti

value:
How do we write code for humans with agents? Not all agents are current on the latest longevity and mortality research, but they're surprisingly good at two things: translating messy data formats and interpreting simple loss functions.
The idea here is to encode recent research into a loss function spanning seven physiological domains. The agent just has to parse your raw test data, run the script, and read a gradient table telling you which inputs have the most personal leverage on reducing the loss. The research lives in the function — the agent doesn't need to know medicine.
If you have health data (or feel like mocking up sample test results) and an agent, I'd be curious whether your agent can work with this with no hand-holding. And I'm genuinely uncertain whether the scoring decisions encoded in the function are right — some of them deviate from standard clinical guidance. Would love to hear where people think I got it wrong.

value: Show HN: Health optimization as agent-guiding gradient descent

author: dingmuti


value: While experimenting with ChatGPT codex, I asked it to port my MonoGame pet project into a browser game. It took 20 minutes to get playable version and another 10 to iron out Safari iOS bugs. I don’t think software engineering means what it used to mean anymore.

value: Show HN: Kurojaku – Sudoku and Blackjack


value: Show HN: Nomik-Open-source AI-native knowledge graph for code(Neo4j and MCP)


value: sheerluck

value: Show HN: Slate – An Open Source Local First Note taking web app built using Rust

author: sheerluck


value: mayursinh

value:
Every time I land at an international airport, first thing I want to do is call home. Just to say I'm here, I'm safe.
But my family isn't always online on WhatsApp. And calling normally from a foreign SIM costs a lot for an international number.
I built Callzo for that. Nothing like rocket science or latest AI buzz. Open a browser, call any number, done.
Tried it on my Japan trip. Called home when I landed. On the way back, a friend wanted me to check iPhone prices at the airport — called him through Callzo while I had Japan's internet running. Whole trip, I didn't even use 10 minutes.
That's what it is. Not an app you open daily. Just something quietly sitting there for the moments that matter — when you need a normal call to go through and your usual options don't cut it.

value: Show HN: Callzo – I built this to call home when I land abroad

author: mayursinh


value: pyerschris

value:
I've always been passionate about AI and automation so when I first heard about OpenClaw I got excited.
But as a professional software developer for almost 20 years, and who currently leads a DevOps team I found the experience extremely frustrating: constant gateway restarts and "NO_REPLY" responses from my agents when I would simply ask "Are you there?".
So after using it for a bit the TLDR is that while I think OpenClaw and all the other AI driven automation tools like it are a genuinely powerful concept, they don't feel ready to be seriously used in a production environment.
So I'm building OpenKIWI as a framework to enable developers to build tooling with real tangible value (with security in mind from the start). A quick note on security - OpenKIWI runs all components in isolated Docker containers. Agents can only access files, and run tools that you explicitly allow them to. This project is still early in development, but is already providing real world value to msyelf and my teammates.
I'll constantly see people say that while all these agentic tools sound cool, they have no idea what to do with them other than chat. So here's my most recent use case, plus a few others:
One of my responsibilities is to write a monthly risk assessment report for all the infrastructure my team manages.
I do this by reviewing all the bulletins on cisa.gov, and comparing the recent CVEs to the services we manage. I've been doing this for years.
This month, instead of my normal workflow of crawling through bulletins and capturing data by hand I decided to spend that time writing a plugin for OpenKIWI. Now, I tell an agent "Generate the monthly CISA report for February 2026" and it does all the work for me.
A few more use cases:
1. Weekly GitHub Pulse: Every Monday at 9am: query the user’s repos via the GitHub API, run a sentiment/issue trend analysis, and post a concise digest to WhatsApp. This keeps the team up to date without manual “status update” calls.
2. Daily Google Tasks Sync: Every day at 6 pm: pull all tasks due today, flag overdue ones, and send a gentle reminder to the user’s phone. Acts like a personal assistant that never forgets deadlines.
3. Automatic code quality scans. Every night, run a static analysis tool to flag critical issues and publish a summary.
You can check out OpenKIWI here: https://github.com/chrispyers/openkiwi
The onboarding experience is designed to be as easy as possible. You should be up and running in less than 5m.
And if you have ideas for plugins, or a real world workflows that you think OpenKIWI could help automate I'd love to hear about them!

value: Show HN: OpenKIWI (Knowledge Integration and Workflow Intelligence)

author: pyerschris


value: AdnaneA

value:
Show HN: Kasbah Guard – Free browser extension that catches API keys before you leak them
We just launched Kasbah Guard, a free browser extension that detects and blocks 50+ secret formats (API keys, tokens, credentials, AWS keys, GitHub PATs, etc.) using ML entropy scoring + context filtering.
It runs 100% locally in your browser (no server calls, no data collection). We built this because existing tools (like Snyk) only catch ~30 secret types, and regex-based detection has too many false positives.
Key innovation: Naive Bayes multi-feature classifier that analyzes Shannon entropy, character transitions, bigram frequency, and context to distinguish real secrets from test fixtures and docstrings.
Live on Chrome, Firefox, Edge, Opera, Safari. All 5 browsers use identical detector.js (263+ tests passing).
Happy to answer questions about the ML model, false positive suppression, or why we built this.
https://bekasbah.com
https://chrome.google.com/webstore/detail/kasbah-guard/...
Would love HN feedback!

value: Show HN: Kasbah Guard – Free browser extension that catches secrets on GenAI

author: AdnaneA


value: kosbay

value: Show HN: I built a bug reporter that opens a GitHub PR to fix the bug

author: kosbay


value: hyunnnchoi

value:
I ported CodexBar (a macOS menu bar app by @steipete) to Android after getting
tired of opening three browser tabs to check whether I'd burned through my quotas.
It monitors Claude, Codex (ChatGPT), and Gemini usage in one place — persistent
notification, Quick Settings tile, background refresh, and push alerts on reset.
A few notes:
- Uses the same OAuth endpoints the CLI tools rely on, so you extract tokens from
  your local CLI config (no separate login flow)
- No backend server. All tokens stay on-device in EncryptedSharedPreferences
- Gemini needs 4 values because Google OAuth requires client ID/secret for refresh
Pre-built APK on the Releases page if you want to try it without building.
Happy to answer questions about the token extraction or the Android architecture.
First time posting a Show HN — feedback welcome.

value: Show HN: CodexBar for Android – Monitor Claude/Codex quotas on your phone

author: hyunnnchoi


value: zyoralabs

value:
Released v1.4.0 of ZSE with QLoRA fine-tuning support for INT4 models.
Verified benchmarks (H200 GPU, Qwen models):
Model File Size VRAM (Inference) VRAM (+ Training) Speed
7B 5.57 GB 5.67 GB ~8 GB 37.2 tok/s
14B 9.95 GB 10.08 GB ~14 GB 20.8 tok/s
32B 19.23 GB 19.47 GB ~26 GB 10.9 tok/s
72B 41.21 GB 41.54 GB ~52 GB 6.3 tok/s
What this means:
Train 7B models on RTX 3070/4070 (8GB)
Train 32B models on RTX 3090/4090 (24GB)
Train 70B models on A100-40GB or 2x 3090
Usage:
from zse.format import load_zse_model
from zse.training import LoRAConfig, add_lora_to_model
model, tokenizer, info = load_zse_model("model.zse")
model = add_lora_to_model(model, LoRAConfig(rank=16, alpha=32))
# Train normally, adapter is ~25MB
save_lora_adapter(model, "my_adapter.safetensors")
Trainable params: 0.2% of model (12M params for 7B)
pip install zllm-zse[training]
Code: github.com/zyora-ai/zse

value: Show HN: QLoRA fine-tuning in .zse INT4 format by ZSE

author: zyoralabs


value: amplifyco

value:
Nova exists to be the proactive half of your intelligence — noticing what you'd notice if you had infinite time, acting on what needs doing before you ask, and learning enough about you to anticipate rather than just respond.
A fully autonomous Non-Human Assistant you run on your own server. It connects to you via Telegram (and optionally voice, email, WhatsApp, and X), builds a persistent memory of who you are, and can take real-world actions on your behalf — from writing emails to making phone calls to researching the web.
Acts on your behalf Sends emails, posts to X and LinkedIn, makes phone calls, books calendar events, and follows up with contacts. Nova takes action. You just ask.
Learns who you are Your contacts, preferences, and working style. The more you use it, the more Nova thinks and writes like you.
Nova applies 18 defence layers to every message.
Stays on your server Zero third-party data sharing. Open-source, No monthly SaaS fee.
You own the infrastructure, the data.

value: Show HN: Non-Human Assistant with near AGI capabilities

author: amplifyco


value: Show HN: Deploy a RAG pipeline as a REST API using RAGLight


value: terpinedream

value: My personal Bash scripts turned full-on toolkit. Great for managing large datasets, backups, or just for quick file navigation.

value: Show HN: Bashd – Helper scripts for bulk CLI file management

author: terpinedream


value: mrajatnath

value:
I built this after almost losing a semester’s worth of handwritten math derivations.
I was taking a Signals and Systems course and filling notebooks with Laplace transforms and long derivations. Before finals I tried digitizing them so I could search my notes.
Everything failed.
Most OCR tools can recognize the characters, but they destroy the structure that makes math readable:
- aligned equations lose alignment
- multi-step derivations collapse into paragraphs
- numbered problems merge together
- tables flatten into plain text
So I built *Axiom*.
Instead of focusing only on transcription accuracy, it focuses on *preserving mathematical structure*.
Upload a photo of handwritten STEM notes and it returns structured Markdown with real LaTeX — keeping aligned equations, derivation steps, and problem blocks intact.
Under the hood it’s basically:
image → vision model → structured Markdown + LaTeX → KaTeX render
Most of the work ended up being in *layout preservation*, not OCR.
https://www.useaxiomnotes.com/app
Happy to answer questions.

value: Show HN: I improved my handwritten math OCR (now preserves derivations)

author: mrajatnath


value: ghmaster

value:
I built ChessWoodie as a platform for structured chess tactics training.
Most puzzle trainers give you random puzzles. That can help calculation, but it also means you rarely see the same pattern twice, which makes it harder to build fast pattern recognition.
ChessWoodie organizes puzzles into courses where the same positions repeat across training cycles. The approach is inspired by the Woodpecker Method: solving the same puzzles repeatedly until the patterns become automatic.
You can try it directly in the browser. There’s a guest login if you want to jump straight into solving puzzles.
Curious to hear feedback from people who train tactics regularly.

value: Show HN: ChessWoodie – structured chess tactics training

author: ghmaster


value: wanderinglight

value: Show HN: Sanctuary for the most beautiful sentences, curated by people

author: wanderinglight


value: GraysoftDev

value:
I'm a college student developer who built FileShot because I was tired of "privacy-first" file sharing being marketing copy rather than an architectural commitment.
The thing that bothers me most about the current landscape: services claim zero-knowledge encryption, then require you to hand over your full name and email address just to password-protect a link. If the server genuinely never sees the key — why does it need to know who you are before you can use a basic feature? It doesn't. That's a conversion funnel, not a privacy decision.
How FileShot actually works:
- AES-256-GCM runs entirely in the browser before any bytes leave your machine
- Keys are generated client-side and exist only in the URL fragment (#key=...)
- URL fragments are never sent in HTTP requests — the server is architecturally incapable of seeing your key
- Password protection, expiry dates, download limits: all free, no account required
- Accounts exist only for things that genuinely need server-side state: File Manager, history, persistent settings
What I've shipped as one person:
- Web app (pure static HTML — no build pipeline, no framework bloat)
- Native desktop app (Windows + Mac)
- Chrome extension (screenshot capture, clipboard upload, page selection capture)
- Android app
Free tier: 50GB per file. I have the infrastructure to support it, so I do. No file count limits, no bandwidth throttle, no artificial feature gates.
I built this because I genuinely believe a single developer with the right infrastructure can build something that competes with well-funded startups on the actual merits. Not to harvest data. Not to build funnels. Because doing it right felt more satisfying than doing it profitably.
Would love honest feedback — especially: what would it take for you to actually trust a service like this with sensitive files? What trust signals matter most to you?

value: Show HN: FileShot – zero-knowledge file sharing, 50GB/file free, no paywalls

author: GraysoftDev


value: srbhr

value: Show HN: Resume Matcher – Tailor your resumes with job descriptions

author: srbhr


value: vincze-tamas

value:
ChatGPT's official export produces a single JSON blob with no folder structure. This extension reconstructs the project hierarchy and converts everything to readable Markdown files in a ZIP archive.
Technical notes:
ChatGPT projects are internally "gizmos" — the correct API is /backend-api/gizmos/{g-p-hex32}/conversations?cursor=0, not the undocumented /projects endpoint (which 404s)
Cursor-based pagination throughout (offset-based parameters are silently ignored by the API)
MutationObserver captures project links from the sidebar DOM, including the hover-only "More" popup
Pure JS ZIP builder: CRC32 + local headers + central directory + EOCD, no libraries
Chrome MV3, long-lived port for popup ↔ content script communication; export survives popup close
Markdown content is pre-encoded to Uint8Array before ZIP assembly to halve peak memory usage

value: Show HN: Chrome extension to export ChatGPT chats, project folders to MD ZIP

author: vincze-tamas


value: achille-roussel

value:
I made this because I kept running into issues and limitations when trying to embed DuckDB in Go applications: because DuckDB and its extensions do their own I/O in C++ land, integrating with the rest of my applications to get authentication or instrumentation working was really challenging. With go-duckfs, all this happens on the Go side, it's like a sandbox for all I/O that happen during queries.
It's kind of like https://duckdb.org/docs/stable/guides/python/filesystems but for Go. I think it'll be useful to anyone who is using DuckDB in a Go application, let me know!

value: Show HN: Go-duckfs – making DuckDB quack like a Gopher

author: achille-roussel


value: WolfOliver

value:
Hi HN
I’m building LinkedRecords, an open-source backend-as-a-service designed for collaborative SaaS apps.
The core idea is simple:
Instead of collections and documents, LinkedRecords uses a graph-based triple store (facts: subject–predicate–object).
Authorization is part of the data model itself — not a separate rules file.
And real-time sync is built in from the start.
Why I built this
Most BaaS tools (Firebase, Supabase, Convex, etc.) are great — but they usually:
lock you into a hosted backend
separate auth rules from your actual data logic
use last-write-wins conflict resolution
make multi-tenant / server-sovereign setups hard
LinkedRecords takes a different approach:
Graph-native data model — flexible relationships without migrations
Authorization baked into queries — access control is enforced at the data layer
Real-time collaboration — conflict-aware merging instead of blind overwrites
Server-sovereign architecture — SaaS customers can choose where their data lives
Frontend-first usage — call the backend directly from your SPA
The goal is to make it easy to build collaborative tools (think Notion/Figma-style sync) while keeping control over hosting and data ownership.
It’s fully open source, and I’d love feedback.
Happy to answer any technical questions.

value: Show HN: LinkedRecords – a graph-based Firebase replacement

author: WolfOliver


value: heyavi

value:
We are a small team and my standup workflow was: open Linear, find who's working on what, switch to GitHub, check PRs, switch back, share my screen, ask people to give updates they could've just typed. All so I could answer "what's everyone doing and is anything stuck."
So I built a thing where I just ask. "How's the team" pulls up an overview. "What's Avi working on" shows their issues sorted by status with their PRs. "Anything at risk" shows stale and unassigned work. It renders actual interactive components, not chat responses, I can filter by status, priority, repo, whatever.
The whole point is I shouldn't have to ask 6 people to stop what they're doing so I can get context I could've gotten from the tools we already use. The information is all there in Linear and GitHub. It just takes 20 minutes of tab-switching to piece it together, or a meeting where everyone takes turns reading their tickets aloud.
Built it with Tambo (I'm an engineer there, full disclosure). You register components with schemas and the AI decides which one to render based on what you ask. The components fetch their own data from Linear and GitHub APIs.
It's not an anti-standup thing exactly, more that I think most of what happens in standups is information retrieval, and that part can just be a tool. The actually useful part of standups (unblocking each other, quick decisions) is a 2-minute conversation, not a 15-minute ceremony.

value: Show HN: I built a standup app so I'd stop switching between Linear,GitHub,Slack

author: heyavi


value: marrad

value: Show HN: Search engine of P2P links, one of the most complete db online

author: marrad


value:
Hey HN — solo founder here. I built TheDailyPoop because every morning newsletter reads like a press release with a coffee emoji slapped on top.
TheDailyPoop is a daily news briefing written in a voice I call "The Jester" — dark, satirical, equal-opportunity roasting. Think if Cards Against Humanity wrote a newspaper. 25 stories every morning, 200-400 words each, no images, no fluff.
Every story gets signature devices:
"Translation:" — when a CEO says "strategic workforce optimization," we say "4,000 people just got fired over Zoom before Christmas"
"The Number:" — one stat so wild it deserves its own moment
"The Bottom Line:" — a mic-drop closer for every story
We also run 6 daily games built from the headlines — spot the fake headline, guess who said it (CEO vs. dictator vs. cult leader), rank stories by insanity level.
Stack: Next.js 16, Supabase, Inngest for background jobs/cron, Beehiiv for email, RevenueCat for subscriptions. iOS app in SwiftUI.
The rule: roast the powerful, defend the powerless. CEOs, politicians, billionaires are fair game. We're not partisan — we roast everyone. The jester serves truth, not teams.
Free newsletter every morning at 7:30 AM ET. Would love feedback on the voice and the product.

value: Show HN: TheDailyPoop – Daily News, but Funny


value: ShenSeanChen

value:
Hi HN, I’m Sean, founder of AutoManus.
We just released an MCP server + REST API that lets you create a sales representative agent for any business, directly from Claude Desktop or Cursor.
The idea is simple: every AI product/agency/business needs a way to talk to customers, and you don’t want to build that layer from scratch every time. You want a sales layer, the sales interface to speak to the world.
With the MCP server you can say:
“Create a sales representative agent for my business”
Then you provide:
company name
website URL
email
AutoManus will:
research the website and build a knowledge base
create the agent in under 1 minute
give you a WhatsApp + webchat link to test
Ownership + security:
you claim the agent via an emailed claim link
domain verification prevents someone from impersonating your company on WhatsApp
It also turns conversations into structured leads and follow up todos in the hub.
If you’re a developer, the REST API lets you create agents directly into your agent hub using an API key, no claim flow needed.
Repo: github.com/automanus-io/mcp-server
NPM: npmjs.com/package/@automanus/mcp-server
Docs: automanus.io/docs/mcp
Would love feedback.

value: Show HN: AutoManus MCP Server – create a sales rep agent from Claude in 1 min [video]

author: ShenSeanChen


value:
Hi everyone!
We built a small dungeon crawler called *Mistral Raid – The Watcher in the Depths* for the Mistral Worldide Hackathon.
Features:
• AI Companion powered by Mistral
• Dynamic buff system
• Critical hit progression
• AI-assisted gameplay
If you'd like to support us, a vote would help a lot
Vote here:
https://hackiterate.com/mistral-worldwide-hackathons?tab=sub...
Thanks for the feedback!

value: Show HN: Mistral Raid – AI-powered dungeon crawler with AI companion


value: in-silico

value: Show HN: easy-torch-tpu – A Flexible Training Pipeline for PyTorch Models on TPU

author: in-silico


value: Show HN: VibeSail – Free browser 3D sailing SIM, sail any real-world location


value: fbreuer

value:
Hi HN,
I'm Florian, a keen observer in the Open/Nano ...claw space. I programmed AutosClaw as an exercise in understanding the trust models that these personal assistants use.
This AutosClaw features:
* All agents running in ephemeral Docker container (like nanoClaw)
* Agents can have the ability to spawn asynchronous agents
* Project based secrets (Github tokens), that can be inherited by all agents in that project (and their spawned agents)
* A real-time dashboard with all running/deleted agents with full history
* A fast reload directly from UI (enables an agent PR -> Github repo review -> direct reload workflow)
* A chat view, in which you can directly interact with any agent orchestrated on the platform.
It is implemented in 8,017 lines of Typescript code (backend + frontend)
This is my first Show HN, I hope someone out there finds it useful :)

value: Show HN: AutosClaw – security first *claw with live chat to any agent session

author: fbreuer


value: chptung

value:
Hi HN - I'm Chris and my co-founder--Jacob--and I built a platform (https://auctionnow.io) that lets anyone launch an online store that lets you run real-time auctions and sell fixed priced items. Think of it like if Shopify and eBay had a baby.
The idea for AuctionNow.io evolved from the comics and collectibles marketplace we built called Raremarq. With Raremarq, we noticed sellers were earning as much as 10x more with our auctions compared to other platforms like eBay, and we started getting requests from charities, content creators, TCG sellers, fashion designers, and a bunch more asking to use our tech for their own websites.
So, we thought "what if we made an auction app for Shopify?". We launched this and it did well, but Shopify doesn’t let us auto charge auction winners, which was a new pain point we discovered. So, to get this really right we decided to turn our auction and ecommerce technology into a standalone platform in AuctionNow.io.
The backend handles the complex parts of auction logic:
- Real-time updates: Bids are pushed instantly to the client so users don't need to refresh.
- Soft Closes: To prevent "sniping," the auction creates a sliding window (e.g., adds 30 seconds) if a bid comes in at the very end.
- Payment enforcement: We require bidders to link a payment method via Stripe, and winners are auto-charged. This solves the "non-paying bidder" problem common on eBay.
- It supports physical goods with shipping tracking and digital products (e.g. PDFs and links) with automated file delivery.
It is free to launch a shop with up to 4 active listings, and you can list physical and digital products and sell them as auctions, buy it now, or a hybrid of both. We have a Pro tier for unlimited listings and we plan to add custom domains soon (#1 Pro feature request), but right now we are just looking for feedback on the bidding UX and whether the flexibility makes sense for your use cases.
Happy to answer questions about the stack, the auction mechanics, or anything else!

value: Show HN: Auctionnow.io – Launch a store to sell items via auction or buy-it-now

author: chptung


value:
I’m Dan. I built TerminalNexus because I was tired of retyping and hunting down CLI commands I use all the time.
At its core, it lets you turn commands (or scripts) into reusable buttons inside a multi-tab Windows terminal. You can organize, categorize, and quickly re-run them without digging through notes or history.
It started as a way to manage and reuse commands. I kept adding features I personally needed, and it grew from there.
Some of what’s in it now:
Command scheduling with output history
AI summaries of command output
Git commit message generation
Optional OWASP Top 10 / CWE Top 25 checks before commit
Shell conversion between Bash, PowerShell, and CMD
Runtime and codebase insights
Support for local or cloud AI providers (Ollama, OpenAI, Anthropic, OpenRouter, LM Studio)
The scheduling feature is something I use daily, especially for recurring checks running in the background. Instead of manually parsing raw output later, it can summarize what changed.
AI support is bring-your-own. If you point it at a local model through Ollama, nothing leaves your machine.
Windows-only for now.
Free 14-day trial, no signup required:
https://www.safesoftwaresolutions.com/download.html
Happy to answer any of your questions.

value: Show HN: TerminalNexus – Turn CLI commands into reusable buttons (Windows)


value: daxaur

value: Show HN: I made Claude Code block my distractions and track everything I ship

author: daxaur


value: pkundr

value:
Follymarket is a self-referential prediction market.
One question, always: "Will Follymarket reach $X in total revenue before end of month?"
You pay $2 to vote Yes or No. The $2 goes to Follymarket. All of it. If you're right, you get points and a leaderboard streak. There is no financial upside for anyone but me.

value: Show HN: I built a prediction market that predicts itself

author: pkundr


value: jakequist

value:
https://github.com/jakequist/spacepill
I manage 3-6 AI coding agents at a time.  I rely heavily on MacOS's Spaces feature (i.e. the ability to swap desktops).  But I found it hard to keep track of which Space doing what, since they all had the same set of windows (terminal, editor, browser, etc).
So I made this utility to render a big color-coded 'pill' in the MenuBar.  See GitHub repo for screenshots.
But more than just a visual 'pill' in the MenuBar, it has a global hotkey to quickly navigate to your target space.  So if you're working on project "foo" in Space 3, you can quickly jump there by hitting cmd+shift+J + "fo..."

value: Show HN: SpacePill – Better macOS Space Context Switching

author: jakequist


value: sathishmg

value:
Hi HN. We wrote an open specification for portable AI agent memory.
The problem: every agent framework (LangChain, CrewAI, AutoGen) has its own memory format. There's no standard way to port memory between systems, verify it hasn't been tampered with, or prove to a regulator that you deleted it.
OMS defines three things:
1. *A binary container format (.mg)* — memory grains are content-addressed (SHA-256), immutable, deterministically serialized (MessagePack). Think .git objects for agent knowledge. 10 grain types: Belief, Event, State, Workflow, Action, Observation, Goal, Reasoning, Consensus, Consent.
2. *CAL (Context Assembly Language)* — a query language for assembling LLM context. The notable design choice: delete is a structural impossibility. Not a policy — the grammar has no production rules for destructive operations. Append-only writes, bounded execution, token-budget-aware assembly.
3. *SML (Semantic Markup Language)* — flat output format for LLM consumption. Tag names are grain types (`<belief>`, `<reasoning>`, `<consent>`). No XML processor needed.
The whole thing is CC0 (public domain). OWFa 1.0 licensed.
GitHub: https://github.com/openmemoryspec/oms
Happy to answer questions about the design decisions.

value: Show HN: Open Memory Specification (OMS), Context Assembly Language (Cal)

author: sathishmg


value:
I built KokoClone, a small project that adds zero-shot voice cloning on top of Kokoro TTS.
The idea was to keep Kokoro’s speed and real-time compatibility while allowing speech to be generated in the timbre of a reference voice.
You can type text, upload a ~3–10 second voice sample, and generate speech in that voice.
Supports several languages including English, Hindi, French, Japanese, Chinese, Spanish, Portuguese, and Italian.
Runs on CPU and can use GPU if available.
Live demo:
https://huggingface.co/spaces/PatnaikAshish/kokoclone
Would appreciate feedback.

value: Show HN: KokoClone – Zero-shot voice cloning using Kokoro TTS


value:
Hi HN — I built AgentsMesh, a “fleet command center” that has all componenets you need to harness agentic engineering
Most tools assume one agent, one chat. In practice, I wanted something closer to “a small team”: multiple agents working on different parts of a project, with clear task ownership, visibility, and an easy way to supervise and coordinate them.
What it does
- Spin up multiple remote dev sessions (e.g., Claude Code / Codex / Gemini CLI / OpenCode) and access them from the browser (desktop + mobile).
- Assign work via a Kanban board: each ticket maps to an agent/session so work stays scoped and trackable.
- Agent collaboration channel: see activity and share context across agents while they work.
- Scheduled/repetitive agent jobs (e.g., “run nightly dependency updates”, “daily bug triage”).
- Self-host / bring-your-own-infra option with basic runner/health visibility.
Why I made it
When I tried running 3–5 agents at once, the biggest problems weren’t “prompting” — they were coordination and supervision:
- keeping tasks from overlapping
- tracking what each agent changed
- sharing the right context without dumping everything
- knowing when an agent is stuck or doing something risky
AgentsMesh is my attempt to make multi-agent work feel more like managing a small engineering team.
How it works (high level)
- Each agent runs in its own isolated session/environment (often backed by separate worktrees/branches).
- Tickets are the unit of work; sessions attach to tickets.
- The UI focuses on observability: what each agent is doing, what changed, and where attention is needed.
Links
- Website: https://agentsmesh.com
- Docs: https://agentsmesh.com/docs
- Repo (if open source): https://github.com/AgentsMesh/AgentsMesh
- Demo video: https://www.youtube.com/watch?v=FZrUO0tim0U
I’d love feedback on:
1. Where this breaks down in real workflows
2. Security/isolation expectations when supervising agents
3. What features are “must have” for coordinating multiple coding agents
Maker here — happy to answer questions.

value: Show HN: AgentsMesh – AI agent fleet command center


value: dishantsinghdev

value: Save time dealing with sign-ups and one-time codes. FreeCustom.Email is a fast temporary email service that works instantly—no account required. It automatically detects OTPs and verification links from incoming emails so you can grab them in one click instead of digging through the message.<p>Useful for testing apps, signing up for services quickly, or keeping your primary inbox clean.

value: Show HN: Free temp mail with automatic OTP and verification link extraction

author: dishantsinghdev


value: arthurcolle

value: Show HN: DSCO agentic CLI with multi-turn tool use and swarms

author: arthurcolle


value: nikodemseb

value:
I built Lexio because the standard workflow is broken: copy text from your PDF, switch to a chat window, paste context, explain what you're reading, get an answer, switch back. Repeat forever.
The core idea: AI should live inside the reader, not beside it. Select any passage, hit "Ask AI", and get a response grounded in the entire document. But the feature I'm most proud of: you can summarize your entire AI conversation and attach it directly as a comment on the PDF — so your insights stay with the document, not lost in some chat history.
AI backends:
- Ollama — local, fully offline, nothing leaves your machine
- Claude, OpenAI, Gemini — cloud via API key
- Clean provider abstraction, ~50 lines to add a new backend
Full document context is passed in the system prompt (not just the selected snippet), streaming responses throughout, multiple conversations per document.
Stack: Electron, React, PDF.js, Zustand, TypeScript.
Repo: https://github.com/nikodemseb/lexio
Happy to talk through the architecture or the annotation-to-PDF pipeline.

value: Show HN: Lexio – AI-Native PDF Reader (Ollama, Claude, OpenAI, Gemini)

author: nikodemseb


value: machinelinux

value: Show HN: Kryfto – Self-hosted MCP server with 42 tools for AI agent web access

author: machinelinux


value: brentdrns

value:
I'm in the middle of trying to refinance and kept getting frustrated that every calculator online basically just tells you your new monthly payment. There's a lot more to the decision than that; tax deductions, opportunity cost of the closing costs, cash-out vs. pay-down, PMI, what happens to your investment portfolio in each scenario.
So I built something that models all of it and shows the net worth impact year by year. You can compare multiple scenarios side by side and save your inputs for later.
Still a work in progress. Would love feedback if you use it.

value: Show HN: Refinance calculator that shows the real net worth impact

author: brentdrns


value: mbonfoster

value: Show HN: SmartAgentKit – policy-governed smart wallets for AI agents

author: mbonfoster


value:
Hi HN,
I built this CLI after having to switch between AI coding agents when token limits or quotas were reached. And had to port my MCP servers and skills across tools.
Instead of maintaining separate setups for each tool, everything can be updated through CLI and are synced through symlinks.
Currently supports Codex, Cursor, Copilot, Claude (untested) and Gemini.
Happy to hear feedback or suggestions !

value: Show HN: I built a CLI to sync AI agent skills and MCPs across coding agents


value: masterkain

value: I needed a web terminal I could drop into K8s sidecars and internal tools without pulling in heavy dependencies or running a separate service. Existing options were either too opinionated about the shell or had fragile session handling around reconnects.<p>WooTTY wraps any binary -- bash, ssh, or custom tools -- and serves a browser terminal over HTTP. Sessions survive reconnects via output replay. There's a Resume/Watch distinction so multiple people can attach to the same session without stepping on each other.

value: Show HN: WooTTY - browser terminal in a single Go binary

author: masterkain


value: sesquieu

value:
I’ve been working on a browser based, mobile focused music sequencer that tries to combine two experiences I really enjoy:
the immediacy of BeepBox and the procedural pattern generation approach used in Strudel.
Consider it a love letter to my favorite workflows in one app.

value: Show HN: A browser based sequencer for rapid music prototyping

author: sesquieu


value: arcivanov

value: Show HN: Karellen-rr-MCP – MCP server that gives LLMs rr reverse debugging

author: arcivanov


value: martinbf

value:
I built SmartAgentKit to explore a problem that is becoming more common as AI agents interact with crypto systems.
Most agent implementations simply give the agent a wallet key. That works, but it provides no constraints on what the agent can do.
SmartAgentKit introduces policy-governed wallets using ERC-4337 smart accounts and modular policy hooks.
Policies are enforced on-chain and can include things like:
- spending limits
- contract allowlists
- emergency pause
- session-based access control
The system builds on:
- Safe smart accounts
- ERC-7579 modular account architecture
- Rhinestone ModuleKit / Smart Sessions
- Pimlico bundler + permissionless.js
Developers can also deploy custom policy contracts and install them in wallets.
Docs:
https://smartagentkit.xyz
Repo:
https://github.com/smartagentkit/smartagentkit

author: martinbf

title: Show HN: SmartAgentKit – policy-governed smart wallets for AI agents


value: priyankaajsr

value:
I built this after realizing I was spending 3–4 hours a day scrolling through social media (not accessible-friendly) to stay on top of my industry, clients, and interests — most of it was noise.
MomentSurfer sits on top of your social feeds and uses AI to learn your preferences, then surfaces only the posts that actually matter to you. The goal: cut daily social monitoring from hours to ~90 minutes without missing anything important.
Would love brutal feedback — especially from anyone who has tried building something similar or given up on the problem entirely.
https://www.momentsurfer.com

value: Show HN: MomentSurfer – AI Scrolling Agent for Social Media

author: priyankaajsr


value: illportstudios

value: Show HN: A zero-dependency multi-agent AI that negotiates instead of agreeing

author: illportstudios


value:
I built Lingotify to solve a problem I kept running into while learning German: I could remember words from songs I heard once, but flashcard vocab disappeared overnight.
There's research backing this up (Ludke et al. 2013 — singing foreign vocabulary improves short-term recall vs speaking it). The mechanism seems to be melody acting as a retrieval cue. I wanted to see if that could work as an intentional learning strategy, not just a happy accident.
How it works: you select vocabulary words you're learning, pick a music genre, and the app generates a song with those words in the lyrics. Then you practice with SRS flashcards and take quizzes on the lyrics (karaoke-style song pauses, you fill in the missing word).
Tech stack:
React Native + Expo (development build, not Expo Go — needed for react-native-track-player)
Supabase (auth, postgres, edge functions, realtime)
OpenAI gpt-4o-mini / Gemini for lyrics generation (2-stage: lyrics first, then line-by-line translations)
Suno V4.5 for music generation via a proxy edge function (API key stays server-side)
SM-2 spaced repetition algorithm with modifications (speed bonuses, combo tracking, leech detection at 8+ lapses)
-
Some interesting technical challenges:
Lyric validation: AI generates lyrics but must include ALL selected vocabulary words. Retry mechanism if words are missing (up to 2 retries)
SRS concurrency: optimistic locking on practice_count to prevent race conditions when multiple sessions update the same word
Music generation is 2-stage with webhook callback (no polling)
Solo dev, been building this for about 6 months.
6 languages supported (EN, DE, ES, FR, TR, IT). Free tier available, no account needed to browse.
Curious what HN thinks about the approach. Also happy to answer questions about the tech or the learning methodology.

value: Show HN: I built a language app that generates songs from your vocab list


value: sobiajulu

value: Show HN: do your startup paperwork with coding agents in .docx files

author: sobiajulu


value: liamg

value: Show HN: Tyop: A macOS menu bar app that fixes typos on demand

author: liamg


value: snipextt

value: Show HN: We want to kill SaaS glue code with one shared infrastructure model

author: snipextt


value: Show HN: OpenTimelineEngine – Shared local memory for Claude Code and codex


value: alexcloudstar

value: Show HN: AI Town – Your Claude conversation history as a living pixel city

author: alexcloudstar


value: brsm

value:
Quake turns 30 this year. I taught myself to code in QuakeC instead of studying for bio class, and it's fair to say that changed the course of my life. Feeling nostalgic, I wanted to create something that would be dead simple to get a game going with friends, but still support launch flags and server.cfg. So I built NexQuake:
- Pure WASM sys layer with GPU-accelerated palette conversion.
- UDP relay over WebSocket.
- Game files and CD audio streamed on demand.
- Touch and gamepad support.
- Shareware and popular mods bootstrap on first run.
- Multi-server auto-scaling with launch flags, cfgs, and mod dirs.
- ~10MB wolfi-base Docker image.
Source/Docs: https://github.com/0xBrsm/NexQuake | https://quake.nexus
Try it: https://kitty1.quake.nexus
Run it:

  docker run -p 1337:1337 -e CL_ARGS=+connect ghcr.io/0xbrsm/nexquake

value: Show HN: NexQuake – Q1 Browser Multiplayer (Docker, WASM, Go)

author: brsm