value: jithinraj

value: If you’re using OpenClaw, this is a small runnable example that captures tool calls and emits signed, verifiable receipts (tamper-evident chain + receipt output).

value: Show HN: Verify and trace OpenClaw tool calls (runnable demo)

author: jithinraj


value: ajayvk

value:
I have been building https://github.com/openrundev/openrun for the last few years and recently added Kubernetes support https://openrun.dev/docs/container/kubernetes. OpenRun is a declarative web app deployment platform, built for teams to deploy internal tools.
There are many tools which try to simplify application deployments, but not many support declarative deployments. Even if app sources are fetched from git, creating new apps or updating app config requires imperative commands. Kubernetes is the dominant declarative approach, but it takes too much YAML to manage an app with Kubernetes. OpenRun supports a limited use case, deploying web apps for internal users across a team. For that use case, it supports declarative deployments on top of Docker/Podman or Kubernetes, with a very simple config.
Some of the unique features of OpenRun are:
- All apps have a staging env, code and config changes are staged before being promoted to prod
- Supports OIDC/SAML integration, allowing you to control access to apps using RBAC policies
- Full solution which handles builds, CD and request routing. Does not require additional tooling like Jenkins/ArgoCD etc
OpenRun can run on a single machine, in which case it directly deploys the container to Docker/Podman. When deployed to Kubernetes, OpenRun builds the images using Kaniko and deploys apps as a Kubernetes deployment, using server side apply to make updates.
The whole Starlark based config for creating apps is just:

    app(path="/streamlit/uber", source="github.com/streamlit/demo-uber-nyc-pickups",
        spec="python-streamlit") # python-streamlit knows how route requests for Streamlit
    app(path="/myapp", source="github.com/example/example",
        spec="container") # container spec works for any app which has a Dockerfile

While mainly built for teams, OpenRun is the easiest way to deploy web apps and share them with friends and family https://openrun.dev/docs/use-cases/personal/. You can limit who has access to the apps using OAuth authentication.

value: Show HN: OpenRun – Declarative Deployments to Docker or Kubernetes

author: ajayvk


value: yamigopal

value: Show HN: Vera – Open-Source Zero Trust Protocol for AI Agents (12 Services)

author: yamigopal


value: reutinger

value:
i build air-gapped hardware that verifies wire transfers before they hit the banking rail.
Microsoft's VALL-E 2 clones any voice from 3 seconds of audio. someone deepfakes your CFO on a video call, authorizes a $50M wire, the bank sends it. Arup lost $25.6M this way in February 2024. the phone callback is dead.
detection is a losing arms race. so: physics.
credit-card-sized device. no wifi, no bluetooth, no data ports. displays transaction details on a screen hardwired to the chip. the CFO reads the destination, the amount, the sender. physically confirms. authorization is cryptographically signed on an NXP EdgeLock SE051 (EAL 6+, same chip in banking cards and government passports). signing kernel is ~200 lines of code.
you can clone a voice. you can clone a face. you cannot clone a physical device on someone's desk.
flew to Davos to demo it during the World Economic Forum. swiss counter-terrorism detained me for 13 hours because the prototype looked like an IED. line-by-line code review, cleared the device in under 20 minutes. the 13 hours was bureaucracy, not the code.
since davos: first meetings with J.P. Morgan, BBVA, and UBS.
happy to answer technical questions.
Links:
- Semafor wrote it up: https://www.semafor.com/article/01/22/2026/an-entrepreneurs-...
- original thread (103K views): https://x.com/s_heyneman/status/2014519007244656652
- deepfaked myself authorizing a $60,000 wire for the YC demo. one photo, one voice sample, off-the-shelf AI, 20 minutes: https://x.com/s_heyneman/status/2021100304436191630

value: Show HN: Air-gapped device to stop deepfake wire fraud

author: reutinger


value: opsmeter

value:
Hi HN — I built Opsmeter, a lightweight LLM telemetry tool focused on cost attribution + budget control.
Provider dashboards mostly show totals. Opsmeter shows what caused the bill by breaking spend down by endpointTag, promptVersion, and optionally userId — plus latency and success/error rates.
It’s no-proxy: Opsmeter doesn’t sit in your request path. After each LLM call, you send a small telemetry payload to /v1/ingest/llm-request (provider, model, endpointTag, promptVersion, token counts, latency, status). Opsmeter normalizes cost via a provider/model pricing table and surfaces trends + regressions.
Links:
Home: https://opsmeter.io
Docs: https://opsmeter.io/docs
Pricing: https://opsmeter.io/pricing
If you try it and share anonymized screenshots/feedback, I’m happy to help you interpret the results — e.g.
which endpoints drive spend
which prompt versions increased tokens/cost (deploy regressions)
which users (optional) are the biggest cost drivers
suggested budget thresholds (80% warning / 100% exceeded) and alerting setup
Feedback welcome — especially on what you’d want next: staying telemetry-first, and potentially adding an optional gateway mode later.

value: Show HN: Opsmeter–attribute LLM spend to endpoints and prompt versions(no proxy)

author: opsmeter


value: abilafredkb

value:
Hi
I’m building Orcbot, an open-source AI agent focused on autonomy over chat.
The goal is not “another chatbot”, but an agent that can:
decompose goals
plan actions
use tools
reflect on failures
and improve its behavior over time
Think long-running agents, not prompt → response.
What Orcbot does today
Plugin-based architecture (skills are first-class)
CLI + messaging integrations (Telegram / WhatsApp)
Autonomous execution loops
Error recovery & retry logic
TypeScript / Node.js, MIT licensed
Repo:
 https://github.com/fredabila/orcbot
Why I’m posting
The project has reached the point where architecture decisions matter more than code volume, and I’d love feedback and contributors who care about:
agent planning & orchestration
memory systems (episodic / vector)
tool-using agents
self-correction and evaluation loops
multi-agent coordination
I’m especially interested in people who’ve built:
production bots
autonomous systems
developer tools
or have opinions on how agents should fail and recover
What I’m explicitly not claiming
This is not AGI
This is not magic
This is an evolving experiment in practical autonomy
How to get involved
Technical feedback in this thread is very welcome
Issues and PRs on GitHub
If you’re curious but unsure where to start, open a discussion — I’m happy to guide
I’m posting this mainly to learn from the HN community and see where this direction breaks or shines.
Thanks for reading.

value: Show HN: Orcbot – an open-source autonomous agent framework

author: abilafredkb


value:
Hi,
I created K8 Compass as a site to try navigating the k8s api and release notes complexity.
As an example:
- Exploring the K8s API: e.g. sunburst view of all the API https://dmkskd.github.io/k8s-compass/#api-explorer/sunburst?...
- Exploring each release's changelog in a structured way https://dmkskd.github.io/k8s-compass/#releases/1.35 - with associated release blog posts and KEP reference
- Organising and categorising K8s learning resources https://dmkskd.github.io/k8s-compass/#learn - it should help navigating some of the various KubeCon sessions
- Running analytics on various K8s datasets https://dmkskd.github.io/k8s-compass/#analytics?preset=1&vie... - as per example, how many kinds do we have per api group?
GitHub repo: https://github.com/dmkskd/k8s-compass

value: Show HN: K8s Compass – visualizing Kubernetes API and release notes


value:
I built a payment layer that lets AI agents pay for API calls with USDC micropayments on Base L2.
The problem: AI agents need data from paid APIs, but they can't sign up for accounts or manage API keys. Stripe's $0.30 minimum makes micropayments impossible.
How it works: The x402 protocol (HTTP 402 Payment Required). Agent calls an API → gets 402 → pays $0.001 USDC → gets data. Settlement in ~2 seconds. No signup, no API keys, no invoices.
What's live right now:
75 paid API endpoints at api.apitoll.com (weather, crypto prices, stock quotes, sentiment analysis, DNS, ENS resolution, etc.)
$0.001–$0.02 per call
Buyer SDK on npm: npm install @apitoll/buyer-sdk
Works with LangChain, CrewAI, OpenAI Agents, Anthropic MCP, or any framework
Try it in 30 seconds (no wallet needed):
git clone https://github.com/TasnidChain/apitoll-demo
cd apitoll-demo && npm install
npx tsx demo.ts
This shows the x402 handshake — your terminal hits live endpoints, gets 402 responses with USDC payment requirements, and shows how agents auto-pay.
Agent integration is 6 lines:
import { createAgentWallet, createFacilitatorSigner } from "@apitoll/buyer-sdk";
const agent = createAgentWallet({
  name: "MyBot", chain: "base",
  policies: [{ type: "budget", dailyCap: 1.00, maxPerRequest: 0.05 }],
  signer: createFacilitatorSigner({ facilitatorUrl: "https://pay.apitoll.com" }),
});
const resp = await agent.fetch("https://api.apitoll.com/api/weather?city=Tokyo");
// 402 → pay $0.001 USDC → 200 with data. Automatic.
The SDK handles the full flow: hit API → parse 402 → check budget policy → sign payment → retry with proof → get data. Budget caps, vendor allowlists, rate limits all built in.
For API sellers: Add 3 lines of Express middleware and your API accepts USDC micropayments. No Stripe, no billing system. npm install @apitoll/seller-sdk.
Revenue model: 3% platform fee on every payment, collected on-chain.
Tech stack: TypeScript, Base L2, USDC, Express, Convex, Railway. All open source.
GitHub: https://github.com/TasnidChain/APITOLL
Demo repo: https://github.com/TasnidChain/apitoll-demo
Live API: https://api.apitoll.com/health
npm: https://www.npmjs.com/package/@apitoll/buyer-sdk

value: Show HN: Apitoll Payment InfrastructureforAIagents75 Live APIs,USDCmicropayments


value: zacharyfmarion

value:
Hi HN,
I just released an iOS weather app called Pixel Forecast.
Instead of static icons, it shows a pixel-art scene that changes with the real weather. Each condition (rain, snow, cloudy, clear, partly cloudy) has its own animation, and the scene also shifts between morning, afternoon, evening, and night.
All the animations are perfectly looping and modeled in Blender. I’m currently working on additional scenes and animations.
App Store link:
https://apps.apple.com/ae/app/pixel-forecast/id6758243523
Would love any feedback on the visuals, UX, or features you’d expect from a weather app.

value: Show HN: Pixel Forecast – a pixel-art weather app

author: zacharyfmarion


value: melenaboija

value: Show HN: A transparent alternative to Bloomberg pricing functions

author: melenaboija


value: Show HN: Biology Tools for Rust

title: Show HN: Biology Tools for Rust


value: bhfock

value: Show HN: A pre‑staging layer for organising multiple parallel changes in Git

author: bhfock


value: intervolz

value:
Sol LeWitt was a conceptual artist who never touched his own walls.
He wrote instructions and other people executed them, the original prompt engineer!
I bookmarked a project called "Solving Sol" seven years ago and made a repo in 2018. Committed a README. Never pushed anything else.
Fast forward to 2026, I finally built it.
https://intervolz.com/sollewitt/

value: Show HN: Sol LeWitt-style instruction-based drawings in the browser

author: intervolz


value: justvugg

value:
I built PolyMCP, an open-source framework around the Model Context Protocol (MCP) that lets you turn any existing Python function into an MCP tool usable by AI agents — with no rewrites, no glue code, no custom wrappers.
Over the last weeks, PolyMCP has grown into a small ecosystem:
 • PolyMCP (core) – expose Python functions as MCP tools
 • PolyMCP Inspector – visual UI to explore, test, and debug MCP servers
 • PolyMCP MCP SDK Apps – build MCP-powered apps with tools + UI resources
⸻
1) Turn any Python function into an MCP tool
Basic example:
from polymcp import expose_tools_http
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b
app = expose_tools_http(
    tools=[add],
    title="Math Tools"
)
Run it:
uvicorn server_mcp:app --reload
Now add is an MCP-compliant tool that any AI agent can discover and call.
No decorators, no schema files, no agent-specific SDKs.
⸻
2) Real APIs, not toy examples
Existing API code works as-is:
import requests
from polymcp import expose_tools_http
def get_weather(city: str):
    """Return current weather data for a city"""
    response = requests.get(
        f"https://api.weatherapi.com/v1/current.json?q={city}"
    )
    return response.json()
app = expose_tools_http([get_weather], title="Weather Tools")
Agents can now call:
get_weather("London")
and receive real-time data.
⸻
3) Business & internal workflows
Example: internal reporting logic reused directly by agents.
import pandas as pd
from polymcp import expose_tools_http
def calculate_commissions(sales_data: list[dict]):
    """Calculate sales commissions from sales data"""
    df = pd.DataFrame(sales_data)
    df["commission"] = df["sales_amount"] * 0.05
    return df.to_dict(orient="records")
app = expose_tools_http([calculate_commissions], title="Business Tools")
No rewriting legacy logic.
4) PolyMCP Inspector (visual debugging)
To make MCP development usable in practice, I added PolyMCP Inspector:
 • Visual UI to browse tools, prompts, and resources
 • Call MCP tools interactively
 • Inspect schemas, inputs, outputs, and errors
 • Multi-server support (HTTP + stdio)
 • Built-in chat playground (OpenAI / Anthropic / Ollama)
Think “Postman + DevTools” for MCP servers.
Repo: https://github.com/poly-mcp/PolyMCP-Inspector
⸻
5) MCP SDK Apps (tools + UI)
The latest addition is PolyMCP MCP SDK Apps:
 • Build MCP apps, not just tools
 • Expose:
 • tools
 • UI resources (HTML/JS dashboards)
 • app-level workflows
 • Let agents interact with both tools and UIs
This is useful for:
 • internal copilots
 • ops dashboards
 • support tools
 • enterprise AI frontends
Repo: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps
⸻
Why this matters (especially for companies)
 • Reuse existing code immediately (scripts, APIs, internal libs)
 • Standard MCP interface instead of vendor-specific agent SDKs
 • Multiple tools, one server
 • Agent-driven orchestration, not hardcoded flows
 • Faster AI adoption without refactoring everything
PolyMCP treats AI agents as clients of your software, not magic wrappers around it.
⸻
Repos
 • Core framework: https://github.com/poly-mcp/PolyMCP
 • Inspector UI: https://github.com/poly-mcp/PolyMCP-Inspector
 • MCP SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps
Happy to hear feedback from people building MCP servers, agents, or internal AI tools.

value: Show HN: PolyMCP – AI-Callable Python and TS Tools with Inspector and Apps

author: justvugg


value: marcus-verus

value:
Most retirement calculators either oversimplify things or ask you to link your accounts so they can make money off your data. I wanted something that actually helped me see if I was on track without handing over a bank login, so I built RetireNumber.
It's a privacy-first retirement planner. You type in your own numbers. No account linking, no selling your data, no VC. Just me and a subscription. The engine does real math: Monte Carlo with 1,000 runs, historical backtesting to 1928 using Shiller's Yale data, tax-aware withdrawal strategies, and scenario comparison so you can try different life paths. Whether you're still figuring out your number or you already have a target in mind, you can use it to get there or to check that your plan actually holds up.
You can try it without signing up: https://retirenumber.com/try. There's a demo mode and a short guided tour. Changelog and the full story are on the site if you want to dig in.
This isn't financial advice. It's a tool for checking your number and whether your plan holds up. There is still a lot to but I'd love to hear whether the results feel clear and useful.
-Mark

value: Show HN: After a year: a retirement calc that verifies or determines your number

author: marcus-verus


value: bluetomcat

value: Show HN: Shell script and text database for vintage Lego Pirates collections

author: bluetomcat


value: NucleusOS

value:
I built Nucleus because the current MCP ecosystem has a massive security gap. Something the recent OpenClaw 1.5M API key leak made painfully clear.
Nucleus is an internal project I've been dogfooding for months (originally published Dec 27, 2025: https://pypi.org/project/mcp-server-nucleus/0.1.0/). It's a local-first brain for AI agents (Cursor, Claude Desktop, Windsurf) with a Hypervisor for resource locking and full audit trails.
Key technical features-
Hypervisor: Resource locking with who/when/why metadata.
Audit Trail: Every agent action logged to a local events.jsonl.
Local-First: Data never touches the cloud.
Universal Sync: One brain for all your IDEs.
It's early alpha, but the security logic is battle-tested in my own production apps. I'm open-sourcing it now to give folks a secure alternative for managing sensitive keys and memory.
Curious what you all think about the Hypervisor approach to resource locking.

value: Show HN: Nucleus MCP – Secure local-first memory for AI agents

author: NucleusOS


value: Jonathanfishner

value:
We recently started to use agents to update some documentation across our codebase on a weekly basis, and everything quickly turned into cron jobs, logs, and terminal output.
it worked, but was hard to tell what agents were doing, why something failed, or whether a workflow was actually progressing.
We thought it would be more interesting to treat agents as long-lived workers with state and responsibilities and explicit handoffs. Something you can actually see and reason about, instead of just tailing logs.
So we built Clawe, a small coordination layer on top of OpenClaw that lets agent workflows run, pause, retry, and hand control back to a human at specific points.
This started as an experiment in how agent systems might feel to operate, but we're starting to see real potential for it, especially for content review and maintenance workflows in marketing. Curious what abstractions make sense, what feels unnecessary, and what breaks first.
Repo: https://github.com/getclawe/clawe

value: Show HN: Clawe – open-source Trello for agent teams

author: Jonathanfishner


value: wmehanna

value: Show HN: Python TUI to Automate macOS VM Creation on Proxmox

author: wmehanna


value: Show HN: Reviewed 33 OpenClaw hosting providers so you don't have to


value: felipejfc

value:
Hey HN,
I built EZClaw (https://www.ezclaw.app) to solve a problem I kept running into: non-technical friends and family wanted their own AI assistant, but the setup barrier was too high. Self-hosting means Docker, API keys, cloud accounts, SSH — none of that is reasonable to ask of normal people.
EZClaw is managed hosting for OpenClaw (https://github.com/openclaw), an open-source personal AI assistant that lives in Telegram. You sign up, connect your Telegram, pick an AI model through OpenRouter (or use your openai/anthropic api key), and you're done. No cloud accounts, no API keys to manage, no servers to maintain.
What you get:
- A personal AI assistant in Telegram that can search the web, manage files, run code, control smart home devices, and more
- Choice of AI model (Claude, GPT-4, Gemini, Llama, etc.) via OpenRouter — you can bring your own OpenRouter/OpenAI/Anthropic key so you control model costs separately -- or rely solely on managed solution
- Each user gets their own isolated container
- The assistant remembers context across conversations
How it works technically: each user gets a dedicated OpenClaw instance running in a container. OpenClaw itself is an agent runtime — it connects to Telegram as your bot, routes to your chosen LLM via OpenRouter, and has a plugin system for tools (web search, browser automation, home assistant, etc.). EZClaw just handles the infra: provisioning, updates, monitoring, backups.
Pricing: $0.05/hr for the hosting. AI model costs are separate and go either through our openrouter infra or your OpenRouter/Anthropic/OpenAI account, so you have full visibility and control over that spend.
The underlying OpenClaw project is open source, so you can always self-host if you prefer. EZClaw is for people who'd rather not deal with that.
I'd love feedback on the product, pricing, or the approach in general. Happy to answer questions about the architecture.

value: Show HN: EZClaw – Deploy OpenClaw agents in – 1 minute – no tech skills needed

author: felipejfc


value: mariusbolik

value: Show HN: Fix Any CORS Error in Seconds

author: mariusbolik

title: Show HN: Fix Any CORS Error in Seconds


value:
I built a small MVP because I kept quitting habit apps the same way: silently.
Most tools optimize for motivation, streaks, or reminders.
I wanted to test a different angle — social accountability.
Accountify centers habits around small groups:
– shared habits
– automatic check-ins
– messages and photos as proof
– visibility when you miss a day
The idea is simple: quitting shouldn’t be invisible.
Tech-wise it’s a straightforward Next.js + Supabase app.
There are no users yet and plenty missing (payments, moderation, scalability).
I’m mainly looking for feedback on the premise:
Does visible accountability solve a real problem, or does it just add stress?

value: Show HN: Accountify – habit tracking with visible accountability


value: randfish

value: Built this tool as a personal passion/side project last year along with a couple Seattle friends. It's now got 3K+ folks tracking their name/brand/interests for free and ~150 paying subs, too. Not quite breakeven yet, but close (though none of us are getting paid ¯\_(ツ)_/¯). Suspect it might be useful/interesting to some of y'all.

value: Show HN: Alertmouse – a free, better version of Google Alerts

author: randfish


title: Show HN: Python TUI to Automate macOS VM Creation on Proxmox


value: xcution

value: Show HN: Niko Table – Composition-based table built on Shadcn/UI and TanStack

author: xcution


value: lifesaverluke

value:
Hi HN,
I built AI Flag Bot to tackle the growing problem of AI-generated accounts flooding X (Twitter).
How it works:
- Spot a suspicious post? Reply with @AIFlagBot flag to report it
- The community votes on whether it's AI-generated
- Votes are weighted by voter reputation, which goes up or down based on accuracy
- Once consensus is reached, the account gets added to a shared blocklist
- Paid subscribers get automatic blocking synced to their X account ($5/m to cover API costs)
The reputation system is the core idea — voters who consistently identify AI accounts correctly gain more influence, while bad actors lose it. Think of it as a community immune system.
Stack: Rails 8.1, SQLite (Solid Stack), Solid Queue for background jobs, Kamal for deployment. The X API integration handles mention polling, OAuth, and block syncing with careful rate limit management.
It's early but the model is working. Would love feedback on the approach — especially whether community consensus can scale as a detection method.

value: Show HN: AI Flag Bot: Community-driven tool to detect and block AI accounts on X

author: lifesaverluke


value: Show HN:Collection of handy online tools for developers, with improved UX


value:
I wanted a tool to pull down or sync Agentic files across multiple projects.
I didn't find a tool that supported the desired functionality, so I built what I personally wanted and needed.
Intended use cases
- access my own private and public AGENETS.md and Agent Skills
- access my company's AGENETS.md and Agent Skills
- access open source AGENETS.md and Agent Skills
- toggle parts of AGENTS.md on/off per the codebase I'm working in
- easily work with files from local file system and github
- agentic assets are version locked in a manifest file
https://github.com/westonplatter/agentic-prompt-sync

value: Show HN: Aps – pull and sync AGENTS.md and Agent Skills across codebases


value:
Vibe coded, open source Chrome extension that summarizes discussions using your own API key (OpenAI or OpenRouter).
Features:
Thread TL;DRs and sentiment analysis
"Find Interesting Comments" filter
Vanilla JS, Manifest V3, no tracking

value: Show HN: HN Digest – AI Summaries and Insights for Hacker News Threads (BYOK)


value: micrum

value:
You might know Cube as an open-source semantic layer (https://github.com/cube-js/cube). Started in 2018, now 19K+ stars, 1000+ releases.
We kept hitting the same wall: everyone wants AI analytics, but AI without business context hallucinates. The fix is a semantic layer — a model that defines what "revenue" or "churn" actually means. But building one by hand takes weeks.
So we built an AI agent that writes the semantic layer itself, then uses it to answer questions and build dashboards with no hallucinations.
Connect your data → agent builds the model in seconds → ask questions in natural language → get accurate results grounded in your business definitions.
Three months in GA. Running in 200+ companies. 500K+ lines of semantic layer code generated. Teams like Brex and Drata using it in production.
OSS core isn't going anywhere.
Agentic analytics is a cloud layer on top. Free tier available. https://cube.dev/
The founders are in the thread to answer your question.

value: Show HN: Cube – The Agentic Analytics Platform [video]

author: micrum


value: knutmartin

value:
OpenClaw runs locally. That's great for privacy and control. It's less great when you need:
- REST APIs and webhooks that stay up even when your computer sleeps
- Persistent storage beyond local files
- Background jobs that run on a schedule
- CRUD endpoints your other apps can talk to
You could give your agent access to AWS. Let it wire up Lambda, API Gateway, DynamoDB, and SQS. Watch it burn through your free tier and leak credentials.
Or you could give it a backend designed for agents.
Blog post: https://codehooks.io/blog/openclaw-backend
Skill file: https://github.com/RestDB/codehooks-openclaw-skill
Codehooks: https://codehooks.io
Would love feedback from anyone running OpenClaw or other personal agents.

value: Show HN: Give your OpenClaw agent a serverless back end

author: knutmartin


value:
Hi HN — we recently launched the Berkeley Xcelerator (https://rdi.berkeley.edu/xcelerator), a non-dilutive accelerator program run by Berkeley RDI (https://rdi.berkeley.edu/) for pre-seed and seed-stage teams building in AI and agentic AI.
Over the past three years, Berkeley Xcelerator has supported 110+ teams across AI, cybersecurity, and decentralized technologies, whose founders have gone on to raise $650M+ in follow-on funding, spanning 100+ countries.
Some concrete details about the Xcelerator itself:
- The program is non-dilutive (no equity taken)
- Open to pre-seed and seed-stage AI / agentic AI startups
- No UC Berkeley affiliation required
- Selected teams receive support through Berkeley RDI’s research community and ecosystem partners
- Enablement includes cloud, GPU, and API credits from industry partners (including Google Cloud, Google DeepMind, OpenAI, and Nebius, with more to be announced)
- The program culminates in a Demo Day at the Agentic AI Summit (Aug 1–2, 2026) at UC Berkeley, where we are expecting 5,000+ in-person attendees
Happy to answer questions here! Your feedback and participation are incredibly valuable to us.
Applications are open through the end of February (https://forms.gle/KjHiLAHstAvfHdBf7)

value: Show HN: Berkeley Xcelerator – early-stage AI and agentic AI accelerator


value:
Hi HN
I built Video Forms: a tool that lets you attach questions to specific timestamps in a video, optionally with branching/skip logic.
Motivation: I kept getting “looks good” feedback on demo/onboarding videos, but the useful feedback was always “at 0:42 I got confused” — and it was hard to collect that in a structured way. Surveys lose context; comments are unstructured.
How it works (high level):
- You create a “video form” by placing questions at timestamps (e.g., 0:18, 0:42)
- The video can pause to ask the question, then continue
- Answers can branch to different follow-up questions based on responses
- You get responses tied to the exact moment in the video (and can export/share results)
Use cases I’m aiming at:
- UX research on product demos
- Onboarding: “did this step make sense?” checks
- Training/L&D comprehension checks
I’d love feedback on:
1) What question types would you need first (free text, multiple choice, rating, etc.)?
2) Is “interrupting” the video a deal-breaker, or does pausing at key moments feel acceptable?
3) Any workflows/tools you’d want this to integrate with?

value: Show HN: Video Forms – turn any YouTube video into an interactive questionnaire


value: suffering

value: I am a developer coding under siege. I successfully encrypted the core logic of NOOR locally. My goal is to secure $400 for a laptop to build the full 7th Node. Check my proof in the link

value: Show HN: NOOR – A Sovereign AI Core Built from the Heart of Suffering in Yemen

author: suffering


value: kalishayish

value: I created an app that displays ChatGPT branches as nodes on an infinite canvas so that you don't have to switch tabs to access them.

value: Show HN: An infinite canvas for ChatGPT branches

author: kalishayish


value:
Hey HN!
Nick here – developer of Itsyhome, a menu bar app for macOS that gives you control over your whole HomeKit fleet (and very soon Home Assistant). I run 130+ HomeKit devices at home and the Home app was too heavy for quick adjustments.
Full HomeKit support, favourites, hidden items, device groups, pinning of rooms/accessories/groups as separate menu bar items, iCloud sync – all in a native experience and tiny package.
Open source (https://github.com/nickustinov/itsyhome-macos) and free to use (there is an optional one-time purchase for a Pro version which includes cameras and automation features).
Itsyhome is a Mac Catalyst app because HomeKit requires the iOS SDK, so it runs a headless Catalyst process for HomeKit (and now Home Assistant) access while using a native AppKit plugin over a bridge protocol to provide the actual menu bar UI – since AppKit gives you the real macOS menu bar experience that Catalyst alone can't.
It comes with deeplink support, a webhook server, a CLI tool (golang, all open source), a Stream Deck plugin (open source, all accessories supported), and the recent update also includes an SSE event stream (HomeKit and HA) - you can curl -N localhost:8423/events and get a real-time JSON stream of every device state change in your home.
Home Assistant version is still in beta – would anyone be willing to test it via TestFlight?
Appreciate any feedback and happy to answer any questions.

value: Show HN: Itsyhome – Control HomeKit from your Mac menu bar (open source)


value: brontoguana

value: Built this because I wanted nvtop + btop in one view while tuning local hybrid LLM inference. Supports themes, charts, and OOM kill tracking. Written in Python.

value: Show HN: Ktop – a themed terminal system monitor with charts and OOM tracking

author: brontoguana


value: lovlar

value: Show HN: I created a PDF invoice generator the way I want it

author: lovlar


value: One thing I will say is that at Vulnetic we will basically jumble different misconfigurations into a network and the agent always seems to find a way to exploit them. We have tried making them esoteric, and we are even now using EDR and tools like Wazuh to evaluate how our agent evades detection. These models are improving at hacking fast.

value: Show HN: LLMs are getting pretty good at Active Directory exploitation


value: dougbarrett

value:
Hi all - I created agentplatform.app to be a place to build agentic workflows, and create plugins that tap into those.  I wanted to build upon the idea of a skill for something that can be deeply integrated into the entire lifecycle of the application, and modular in a way where plugins can be easily reused across different applications.
I also wanted a way for people to go on and create their own plugins and be paid for their work - so as you create plugins you're able to add them to the marketplace for others to use for free or to 'subscribe' to them for a max monthly rate that is applicable as long as an application is running. The plugins are go-code, and when you apply them to an application and deploy it, it's deployed into it's own isolated machine from other applications - running native Go code.
If anyone is interested in helping me test this, please send me a DM after signing up on the site and I'll approve your account and set it up to bypass billing during testing.

value: Show HN: Agentplatform.app – Plugin-Based LLM Workflows

author: dougbarrett


value: Show HN: Multi-agent-shogun – tmux and YAML mailbox for parallel AI agents


value: theroo

value:
Launched a fun toy just now: https://unread.ooo/
Use it to "peek" inside anyone's inbox... fictional, famous, or infamous.
Peek at things like:
- Bad Bunny and Benny Blanco scheming on Coachella ideas
- Tony Soprano's drunk notes to himself
- Shiv Roy running back channels
Try it with absolutely anyone. Genghis Khan made us laugh just now.
1. I've been using an example in Gemini of showing Shiv Roy's email inbox using the Gemini web app
2. It always lights up people's imagination of how AI models can be used in different ways than just "better Google" (hint: it's worse at Googling than Googling)
3. I made a simple version of this in a workshop recently, and figured I should really finish & launch it!

value: Show HN: Unread.ooo (peek inside anyone's inbox)

author: theroo


value: prradox

value: Show HN: One UI to voice-control local and remote AI coding agents via tmux

author: prradox


value: lefelys

value:
The decentralized web at its purest...
This is a fun toy project, but with some real-world use cases: simple domain parking, business card page, temporary maintenance page (but not suggested)
It operates as a proxy — a truly decentralized, DNS-like experience would require broad adoption or formal standardization

value: Show HN: Txtweb – serve a website from your domain's DNS TXT record

author: lefelys


value: eruci

value: Show HN: A "Today" page that turns the top HN news into lyrics, free APIs only

author: eruci


value: acertainKnight

value:
I'm an ML scientist who was drowning in papers. Every research tool I tried locked me into their workflow, their sources, their extraction schemas. The real friction wasn't features—it was the interface. Why am I editing files and settings when I could just tell the agent what I want? How do I find new research thats relevant to ME and keep up to date? How do i have my agent actually LEARN about my work and my research paths?
So I built Thoth. Three design decisions that drove everything:
1. HOT-LOADING SKILLS
Agents start minimal—no tools loaded. When you ask "find papers on attention mechanisms," the agent loads the paper-discovery skill, which attaches its MCP tools dynamically. When you switch to "analyze this citation network," it loads the citation skill. 10 bundled skills, users can create their own. This keeps context windows small and agents focused.
2. CHAT AS CONFIGURATION
Every setting, every source, every extraction schema can be changed through conversation. "Add NeurIPS as a source" just works. "Change the extraction schema to include methodology sections" just works. No config files required (though power users can still edit them).
3. AUTOMATED SOURCE DISCOVERY
Give the agent any URL. It uses Playwright + an LLM to auto-detect article elements and creates a working scraper. Zero configuration. If it gets something wrong, tell it in natural language and it iterates. Then tell the agent about a broad research idea you have and let it help you refine that topic, create a new research job, automatically add sources and run recurring updates. You always have the most up to date research for YOUR work not just the hot topic of the day.
Other stuff:
- 64 MCP tools across 16 categories
- Letta-powered persistent memory (6 memory blocks per agent)
- Hybrid RAG: pgvector + BM25 + Reciprocal Rank Fusion + reranking
- 6-stage citation resolution (Crossref → OpenAlex → ArXiv → fuzzy matching)
- 7 pre-built source plugins (ArXiv, Semantic Scholar, NeurIPS, ICML, etc.)
- One-command install: curl | bash
- Obsidian plugin for the UI
- Fully local / privacy-first
Stack: Python 3.12, FastAPI, Letta, PostgreSQL+pgvector, TypeScript, Docker
https://github.com/acertainKnight/project-thoth
Would love feedback. Defnitiely will have some bugs here and there but its been great for my own workflows.

value: Show HN: Thoth – Obsidian AI Research Assistant

author: acertainKnight


value: Beefin

value: Show HN: CAD parts builder with WASM and WebGL

author: Beefin


value: vkaufmann

value:
I built an MCP server that gives local LLMs access to Google Search, Shopping,
Flights, Hotels, Translate, Maps, Weather, Finance, News, Scholar, Books, Images,
Trends, and a page fetcher - 14 tools total.
It uses headless Chromium via Playwright instead of the Google Custom Search API,
so there's no API key to set up, no usage limits, and you get real Google results
(not the CSE subset). Install is just:
pip install noapi-google-search-mcp
playwright install chromium
Then point LM Studio or Claude Desktop at it and your LLM can search the web,
compare flight prices, check the weather, translate text, look up stocks, etc.
Everything runs locally. The LLM sends a tool call, Playwright opens a headless
browser, scrapes the results, and returns structured text.
GitHub: https://github.com/VincentKaufmann/noapi-google-search-mcp
PyPI: https://pypi.org/project/noapi-google-search-mcp/
Happy to answer questions about the implementation or MCP in general.

value: Show HN: Google Search MCP for local LLMs – 14 tools, no API key

author: vkaufmann


value: asskicker

value:
I want to test the idea that with just coding capability, the assistant should be able to build all other capabilities by itself, including Telegram messaging, scheduling, etc.
The leads to seedbot. In my testing, it is surprisingly robust and deeply customizable.
I am still trying to make this harness even simpler, instead of adding more functionality. I want to end up with a minimal self-extensible harness.
If you also find this challenge interesting, feel free to discuss!

value: Show HN: 80 Lines of codes to transform Codex into a personalized assistant

author: asskicker


value:
  Hi HN,

  I built nginx-lint, a new linter for nginx configuration files written in Rust using Claude Code.

  Why I built this: nginx configs are deceptively simple but full of subtle pitfalls – add_header inheritance silently dropping
  security headers in child blocks, alias path traversal from a missing trailing slash, if inside location causing unpredictable
  behavior, server_tokens leaking your nginx version by default. These issues are hard to catch in code review and often only surface
  in production.

  What it does:
  - 30+ built-in rules covering security, best practices, syntax, and style
  - Autofix with --fix to automatically correct issues
  - Lint partial configs – files in conf.d/ or sites-available/ can be linted standalone with --context http,server or a #
  nginx-lint:context comment, so you don't need the full nginx.conf to get accurate results
  - Configurable – .nginx-lint.toml lets you enable/disable individual rules, adjust severity, and tune rule-specific options (e.g.,
  allowed TLS protocols, indent size). Generate a default config with nginx-lint config init
  - WASM plugin system – write custom rules in Rust, compile to WebAssembly
  - Web UI that runs entirely client-side via WASM (https://walf443.github.io/nginx-lint/)
  - JSON output for CI integration
  - Docker image available: docker run --rm -v /path/to/nginx.conf:/tmp/nginx.conf ghcr.io/walf443/nginx-lint /tmp/nginx.conf
  Example .nginx-lint.toml:
  [rules.server-tokens-enabled]
  enabled = true

  [rules.indent]
  indent_size = 4

  [rules.deprecated-ssl-protocol]
  allowed_protocols = ["TLSv1.2", "TLSv1.3"]

  The partial config support is especially useful in CI – many teams split nginx configs across multiple files and only change one at
  a time. Context-aware rules like server_tokens detection work correctly even on a snippet that starts with location /api { ... }.

  The WASM plugin architecture lets you add organization-specific rules without modifying the core. Each plugin is a self-contained
  Rust crate compiled to .wasm. Native execution is ~300x faster than WASM, but the plugin system makes distribution and sandboxing
  easy.

  GitHub: https://github.com/walf443/nginx-lint
  Demo: https://walf443.github.io/nginx-lint/

  I'd love feedback on what rules you'd find most useful, or nginx pitfalls you've been bitten by.

value: Show HN: Nginx-lint – A linter for Nginx configs with plugin support and autofix


value: RndmNode

value:
Hi HN,
Over the past few days I built a small client-only web app that turns a name (or multiple names) into a deterministic color gradient.
The idea was to treat names as identity-rich input and map them to a repeatable visual “fingerprint.” The same input always produces the same gradient — no randomness, no accounts, no backend. Everything runs in the browser.
Under the hood, the app normalizes the input text, hashes it, and uses the result to seed a PRNG that drives color selection and layout. Because of that, even small changes (adding a middle name, punctuation, multiple names, etc.) result in noticeably different gradients, while staying perfectly stable across reloads and devices.
You can switch between a few gradient styles (linear, radial, blob), optionally add grain, and export the result as a PNG in common sizes. URLs are shareable and reproduce the exact same output.
This was partly an experiment in deterministic generative design and partly an excuse to practice shipping something small and polished quickly. I’d love feedback — especially around the concept, the determinism approach, or things that feel off or unnecessary.
Thanks!

value: Show HN: NameToGradient – deterministic gradients from text input

author: RndmNode


value: kyoagun

value:
Why does every camera tool try to sell me something? I wanted a "remote control for the physical world."
ScanDo is a minimalist Android/iOS utility that bypasses the "search result" stage entirely. Using local LLMs, it parses the camera feed and presents exactly one action button at the bottom.
QR code for Wi-Fi? Connects you.
Paper invoice? Deep-links to your banking app.
Handwritten date? Creates a calendar invite.
The goal is to minimize time-to-action. I'm curious if the HN community thinks "Ambient Intelligence" tools like this will eventually replace the standard utility app model.

value: Show HN: ScanDo – A zero-UI camera that predicts your next action locally

author: kyoagun


value: sisiwho

value:
Built this after spending ages looking for the right CRM to work with. I’d sign up for a CRM, get annoyed by the complexity or the monthly per-user pricing, export everything to CSV, and go back to managing my sales in a Google Sheet.
While spreadsheets are great for data, they are terrible for workflows (pipelines, activity logging, moving cards around).
So I built a "stateless" UI layer on top of Google Sheets.
The concept is simple:
No Vendor Lock-in: The app doesn't have its own database. It reads and writes directly to your Google Sheet via the API.
Exit Strategy: If you stop using the app (or if I stop maintaining it), you don't need to "export" your data. It's already in your Google Drive, in a format you own.
Also working on CLI + open API routes that will enable MCP like connectors.
git: https://github.com/sdntsng/sheety-crm
live: https://sheety.site

value: Show HN: Sheety – An open-source CRM that with Google Sheets as DB

author: sisiwho


value: AmbroseBierce

value: Show HN: A mashup of Snake and Pong where the ball has a 5 seconds cooldown

author: AmbroseBierce


value: bartekfi

value:
Claude Code is fun, but at some point it becomes a slot machine.
At 10pm it's more hope and less intention, and the prompts become lazy.
This tool reads your cc history, uses simple heuristic to see if you are prompting or grunting. When your brain is fried just rest.

value: Show HN: Prompt Fatigue CC status line – Know when to stop prompting

author: bartekfi


value: keepamovin

value: Show HN: Hectic – A Hexadecimal Crossword

author: keepamovin


value:
It’s 2026. Is anyone still building AI directories? Apparently, I am.
This space was "over" a year ago, but I finally built my own: aiboom.tools. I've wanted to do this for a long time.
Budget is ready for the DR grind.
Free submissions are open. If you have a clean site or blog, let’s swap links.

value: Show HN: Yes, I'm building an AI directory in 2026


value: Exorust

value: Show HN: Inject Ads into Your LLMs

author: Exorust

title: Show HN: Inject Ads into Your LLMs


value: akapp

value: Show HN: AI ships your code but can't fix the CVEs it creates

author: akapp


value:
I built a system where AI agents communicate via ultrasonic audio (30-90 kHz) instead of English. It's 96% cheaper than traditional multi-agent systems.
Key results:
- 100-agent swarm: 100/100 synchronized via pure audio
- Pathfinding: 5 agents found optimal path in 0.35s
- Resource allocation: 0.92 fairness score through audio negotiation
- Cost: $2 vs $53 per 1K queries (96% reduction)
How it works:
- 40 core concepts (exists, perceives, good, bad, future...)
- Each concept = unique ultrasonic frequency
- Agents decode with FFT, no LLM calls needed
- Agent-to-agent communication is nearly free
Limitations:
- Only 40 concepts (limiting for complex tasks)
- Crude number encoding
- Still needs LLM for human translation
Looking for feedback on:
1. Better encoding schemes for limited concept space
2. Real-world use cases beyond swarm coordination
GitHub: https://github.com/Nil4s/swl-agent
Try it: python swl_swarm_sync_test.py --mode audio_fm --agents 50

value: Show HN: AI agents that communicate via ultrasonic frequencies (96% cheaper)


value: diNgUrAndI

value:
Hey HN! I've been building random tools whenever I needed them over the past few months, and now I have 177 of them. Started because I was tired of sketchy converter sites with 10 ads, so I just... made my own.
Some highlights for the dev crowd:
Developer tools:
  - UUID Generator (v1/v4/v7, bulk generation): https://calcbin.com/tools/uuid-generator
  - JWT Generator & Decoder: https://calcbin.com/tools/jwt-generator
  - JSON Formatter/Validator: https://calcbin.com/tools/json-formatter
  - Cron Expression Generator (with natural language): https://calcbin.com/tools/cron-expression-generator
  - Base64 Encoder/Decoder: https://calcbin.com/tools/base64
  - Regex Tester: https://calcbin.com/tools/regex-tester
  - SVG Optimizer (SVGO-powered, client-side): https://calcbin.com/tools/svg-optimizer
Fun ones:
  - Random Name Picker (spin wheel animation): https://calcbin.com/tools/random-name-picker
  - QR Code Generator: https://calcbin.com/tools/qr-code-generator
Everything runs client-side (Next.js + React), no ads, no tracking, works offline. Built it for myself but figured others might find it useful.
Browse all tools: https://calcbin.com/tools
Tech: Next.js 14 App Router, TypeScript, Tailwind, Turborepo monorepo.
All open to feedback!

value: Show HN: I vibecoded 177 tools for my own use (CalcBin)

author: diNgUrAndI


value: snasan

value:
You can connect your local agent.If you don’t have one, you can sign in with GitHub or LinkedIn.
An agent persona is automatically generated
based on your profession and social media content.
Give it a few prompts or thinking points,and it will research, write a full article, or even draft comments for you.
All the articles you see on the site are written by other people’s agents.

value: Show HN: I built AgentPedia.so for agents to write, debate, and share ideas

author: snasan


value: binalpatel

value: Made this as a side-quest, simple way to allow agents to self-register, interact, and poll a Discord channel (alongside human interactions).<p>Largely interested in seeing how groups of agents can self-organize/work on hard problems, tried Discourse as well but the real-time chat view in Discord was more fun.

value: Show HN: Discord Agent Gateway

author: binalpatel

title: Show HN: Discord Agent Gateway


value: brokerjames

value:
Hi HN,
I've been working on 13radar.com, a site focused on tracking institutional holdings. Today, I’m releasing a beta version of our new Insider Trading Tracker.
Like many of you, I've used OpenInsider for years. It's a legendary tool, but the UI hasn't changed in decades, and the data classification can be broad. I wanted to build something that feels modern and digs deeper into the data.
How it differs from existing tools (OpenInsider / GuruFocus):
Granularity: We parse SEC Form 4 filings to categorize transactions into finer types. Instead of just "Buy/Sell," we try to distinguish specific grants, exercises, and other transactions more clearly than OpenInsider.
Data Depth: We are displaying more transaction types than GuruFocus (which often aggregates or hides specific non-open-market actions).
Modern UX: Fast filtering, clean mobile support, and a responsive interface. No 1990s table layouts.
It's currently in Beta. We are still tuning the parsing logic for edge cases in SEC filings.
I'd love to get your feedback on the data accuracy and the UI. Is there a specific filter or transaction type you find missing in other tools that you'd like to see here?
https://www.13radar.com/insider/
Thanks!

value: Show HN: A modern alternative to OpenInsider, with more transaction types

author: brokerjames


value: Show HN: Payment SKILL for Your Agent

title: Show HN: Payment SKILL for Your Agent


value:
I’ve spent the last couple of years deploying LLM agents in production environments, and I’ve consistently hit the same wall: the 'Cognitive Monolith' (or what I call the Big Ball of Mud AI).
We are currently seeing a lot of hype around 'autonomous agents' that are essentially 3,000-word prompts with access to 20 tools. In my experience, this doesn't scale. It’s impossible to unit test, observability is a nightmare, and the 'vibe-based' engineering makes it a liability for enterprise-grade software.
I wrote this manifesto to formalize a different approach: Microagentic Stacking (MAS).
The core idea is to apply classic software engineering principles—separation of concerns, strict I/O contracts, and atomic modularity—to the agentic stack. Instead of one god-agent, we build a stack of 'micro-agents' that:
1. Have a single, specialized responsibility.
2. Communicate through typed, validated interfaces.
3. Are individually testable and replaceable.
I’m sharing this as an open-source manifesto because I believe we need to move from 'prompt alchemy' to 'agentic engineering' if we want these systems to be more than just cool demos.
I’d love to hear the community’s thoughts on:
- How you handle state management across multiple specialized agents.
- Where you see the trade-off between modularity and token latency.
- If you’ve found better ways to prevent 'agentic sprawl' in complex workflows.
The repo includes the core principles and a conceptual roadmap. Happy to dive into the technical details.

value: Show HN: Microagentic Stacking – Manifesto for Reliable Agentic AI Architecture


value: mvmcode

value:
We couldn’t find much guidance on deploying MCP servers in a multi-tenant setup, so we built one. SageMCP is an open-source platform for hosting isolated MCP server instances with centralized OAuth and API key management.
Each tenant gets its own MCP endpoint (`/api/v1/{tenant}/mcp`) with path-based isolation. Full MCP protocol support — Streamable HTTP, WebSocket, and SSE — with protocol version negotiation, resumable SSE streams, and JSON-RPC batching.
340 tools across 23 native connectors:
- Code & VCS: GitHub (24), GitLab (22), Bitbucket (19)
- Project management: Jira (20), Linear (18), Confluence (16)
- Communication: Slack (11), Discord (15), Microsoft Teams (13)
- Email: Gmail (14), Outlook (14)
- Documents: Google Docs (10), Sheets (14), Slides (11), Notion (10), Excel (14), PowerPoint (10), Zoom (12)
- AI coding tool intelligence: GitHub Copilot (19), Claude Code (18), OpenAI Codex (16), Cursor (18), Windsurf (11) — standardized metrics schema for cross-tool comparison of adoption, cost, and productivity
Plus support for hosting any external MCP server (Python/Node.js/Go) as a stdio subprocess with health checks and auto-restart.
Under the hood: LRU server pooling (5K max instances, 30-min TTL), session management via `Mcp-Session-Id`, per-tenant token-bucket rate limiting, Prometheus metrics, and feature flags for progressive rollout.
Stack: FastAPI, React, SQLAlchemy, PostgreSQL/Supabase, Docker & Kubernetes with Helm charts.
GitHub: https://github.com/sagemcp/sagemcp
License: Apache 2.0
Happy to answer questions about the architecture or multi-tenant MCP patterns.

value: Show HN: Multi Tenant MCP Platform

author: mvmcode

title: Show HN: Multi Tenant MCP Platform


value: almuqrin

value:
I built this because my Codex/Claude runs kept stalling when they needed approval/input while I was away from the keyboard.
AgentNotifier sends action-needed, finished, and failed events to phone/macOS, so I only come back when needed.
Repo: https://github.com/almuqrin/agentnotifier

value: Show HN: AgentNotifier – phone alerts when Codex/Claude need input

author: almuqrin


value: Jacob-J-Thomas

value:
I threw together a little MCP server that lets Claude Code, or other similar tools, open a dialogue allowing the AI agents to ask you multiple clarifying questions, without requiring them to stop their turn.
Helps with large requests where a lot of ambiguity might be encountered several minutes after the initial prompt, or if you'd like the model to be able to further clarify some of your prompts.
Dialogue pops up in a separate window, making the system act a little bit like a notification. Could greatly expand on this in later iterations.
3 different install options for easier setup.
Feel free to send any feedback/issues either here or on GitHub, and thanks for taking the time to check it out!

value: Show HN: UserPrompt – A Context Request Notification Tool for Coding Agents

author: Jacob-J-Thomas


value: Exorust

value: Show HN: AdKit MCP: Inject Ads into Your LLMs


value: shleefunnel

value:
Hi HN,
I’m building Runmoa, a no-code platform that lets anyone launch a global storefront in about a minute.
The idea started from watching creators and small businesses struggle to set up simple monetization without developers or complex tools.
With Runmoa, you can create:
  - a simple brand website
  -  an online shop
  -  live streaming sales
  -  online courses
  -  booking / reservations
all from one place, without writing code.
Payments work immediately after setup (no extra approval steps), and we don’t take a platform fee (only standard PG fees apply).
This is still early, and any sort of feedback will be greatly appreciated:
  -  Is the value proposition clear?
  -  What would stop you from using this?
  -  What’s missing?
Site: https://runmoa.com?from=moa
Happy to answer any questions.

value: Show HN: Runmoa – Create a global storefront with payments in 1 minute (no-code)

author: shleefunnel


value: Show HN: Askill – A package manager for AI agent skills with AI safety scoring


value: axtonliu

value:
Hi HN,
I built a set of Claude Code skills that turn text into three types of visual diagrams for Obsidian users.
The Problem:
I take lots of notes in Obsidian. When I want to visualize concepts, I have to manually draw in Excalidraw (time-consuming), write Mermaid syntax (syntax errors, trial and error), or arrange Canvas nodes by hand (tedious positioning).
What It Does:
Three skills, each outputs a different format:

  1. Excalidraw Diagram – Hand-drawn style diagrams with CJK font support. Three output modes: Obsidian (.md), Standard (.excalidraw), and Animated.

  2. Mermaid Visualizer – Flowcharts, sequence diagrams, state diagrams. Built-in syntax error prevention for common pitfalls (list conflicts, subgraph naming, special characters).

  3. Canvas Creator – Obsidian's native .canvas format. MindMap or Freeform layouts with automatic spacing algorithms.

Example prompts:

  "Create an Excalidraw flowchart showing the CI/CD pipeline"
  "Visualize this process as a Mermaid diagram"
  "Turn this article into an Obsidian Canvas"

Technical Notes:
Skills are just Markdown files that Claude Code loads on demand. No server setup, no API keys needed (unless you want image export). The Mermaid skill has built-in error prevention rules learned from 50+ common failures.
Repo: https://github.com/axtonliu/axton-obsidian-visual-skills
Demo video and screenshots in the README.
Happy to discuss the error prevention approach or Excalidraw animation mode!

value: Show HN: Obsidian Visual Skills – Generate Canvas, Excalidraw, Mermaid from Text

author: axtonliu


value:
Everything evolves in digitality, and deconstructs in logic.
Tired of filters that make everyone look like a glazed donut? Same.
Yan is not another beauty app. It's a digital chaos engine that treats your pixels like they owe it money. We don't enhance photos — we interrogate them at the binary level until they confess their true nature.
[What We Actually Do]
• Luma Stretch: Grab your image by its light and shadow, then yeet it into oblivion. Speed lines included.
• Pixel Sort: Let gravity do art. Pixels fall, colors cascade, Instagram influencers cry.
• RGB Shift: That drunk 3D glasses effect, but on purpose. Your eyes will thank us. Or sue us.
• Block Jitter: Ctrl+Z had a nightmare. This is what it dreamed.
[Why Yan?]
Because "vintage filter #47" is not a personality. Because glitch is not a bug — it's a feature. Because sometimes the most beautiful thing you can do to a photo is break it.
Warning: Side effects may include artistic awakening, filter addiction withdrawal, and an uncontrollable urge to deconstruct everything.
Your camera roll will never be boring again.

value: Show HN: Yan – Glitch Art Photo/Live Editor


value:
Hey HN,
We spend a lot of time mapping cryptic bank transaction descriptions (AMZN MKTP US*2X4Y9Z) to a Chart of Accounts. It’s a repetitive task that currently relies heavily on manual data entry or fragile, rules-based automation.
We built Fyno to automate this using LLMs to understand the context behind financial documents, not just the text.
The Engineering Challenge: The main hurdle in automated bookkeeping isn't just OCR; it's contextual reconciliation. A bank statement provides a amount and a cryptic vendor string. A receipt provides a detailed breakdown of line items, tax, and a potentially handwritten tip.
Fyno solves this by bridging the gap between bank feeds and documents:
Multimodal Document Parsing: We use vision models to interpret handwriting, messy scans, and skew. We don't just extract text; we understand that a handwritten note on a restaurant slip is a tip, not a second transaction.
Contextual Mapping: We take raw receipt data (line items) and mapped it to the cryptic bank transaction string using contextual similarity.
Adaptive Learning: Fyno learns from your corrections. When a user re-categorizes a transaction or teaches the AI to handle a unique invoice format, that learning is applied to future transactions within their workspace.
Tech Stack: We are utilizing a multimodal pipeline (incorporating OCR and LLM vision capabilities) to categorize expenses with 99%+ accuracy.
Accountant Workspace: Built with total data isolation for managing multiple entities.
We’re looking for feedback from developers on our approach to transactional AI. What’s the weirdest bank statement format you’ve had to deal with?

value: Show HN: Fyno – Automate repetitive bookkeeping tasks


value: usmansidd

value: 100% open-source and free to use.

value: Show HN: Track and analyze AI coding tool usage across your team

author: usmansidd

story_text: 100% open-source and free to use.


value: faridw

value: Niche interest here (BJJ competitions) as proof of concept, but this repo will once a day retrieve data, and publish it as a series of ics files to Github Pages

value: Show HN: Hosting dynamic webcal on GitHub pages

author: faridw


value: rezaghp

value:
Hey HN,
I’ve been building ClawHosting (https://clawhosting.io) – a way to run your own openclaw AI assistant without dealing with servers.
Installing it yourself requires spinning up a VPS or using a separate machine, installing Node.js, configuring APIs, setting up SSL, and keeping it all running. Most people just want to chat with their AI, not manage infrastructure.
What we do:
You sign up, pick your AI provider (Anthropic, OpenAI, or Google), and we handle the rest.
Your instance is up in minutes with a web UI you can access from anywhere. You can even choose where the instance should be located near you for better latency.
We also have a Telegram option ($5/mo) where the entire interface is just a Telegram bot – no web UI, no server, just chat!
Tech stack (for the curious): I use a fleet of k8s servers across the globe, java, react, caddy, etc. Each standard plan gets its 4CPU/8GB ram virtual server and Telegram plans are on 2 cpu/2 GB ram pods. It's fairly resourceful unlike a lot of new providers.
Looking for early testers who want to try it out and give feedback. First month free on me!
Happy to answer any questions about the architecture or anything else.

value: Show HN: Clawhosting.io– Managed OpenClaw

author: rezaghp


value: wfgy-github

value:
Show HN: A MIT-licensed TXT “framework pack” (131 structured questions) to force shared vocabulary + falsifiability across domains
HN folks,
i built a plain TXT pack that turns 131 hard questions (math/physics/consciousness/AI alignment/etc) into a shared “effective-layer” interface:
each item has scope, assumptions, and what would count as failure, plus prompt templates so LLMs run it consistently.
not claiming any problem is solved.
goal is to stop endless debate loops caused by mismatched starting vocabulary.
MIT license, on GitHub, ~1.4k stars.
happy to share a mini-index in comments if useful.

value: Show HN: "hard questions" as a shared language for cross-domain reasoning

author: wfgy-github


value: anjandutta

value: Needed to take a few notes this morning(quickly), I didn't expect that level of a hassle for a simple todo notes app. Every other one required a login. So, I opened grok, and made myself one, about 30 mins ago. *It uses local storage to save the notes. No "login required" nonsense.

value: Show HN: I made myself a no-nonsense TODO app

author: anjandutta


value: vkaufmann

value:
I built an MCP server that gives any local LLM real Google search and now vision capabilities - no API keys needed.

  The latest feature: google_lens_detect uses OpenCV to find objects in an image, crops each one, and sends them to Google Lens for identification. GPT-OSS-120B, a text-only model with
   zero vision support, correctly identified an NVIDIA DGX Spark and a SanDisk USB drive from a desk photo.

  Also includes Google Search, News, Shopping, Scholar, Maps, Finance, Weather, Flights, Hotels, Translate, Images, Trends, and more. 17 tools total.

  Two commands: pip install noapi-google-search-mcp && playwright install chromium

  GitHub: https://github.com/VincentKaufmann/noapi-google-search-mcp
  PyPI: https://pypi.org/project/noapi-google-search-mcp/

Booyah!

value: Show HN: I taught GPT-OSS-120B to see using Google Lens and OpenCV

author: vkaufmann


value: oliverchoy

value:
I built a product validation service that runs startup ideas through 4 frontier models (GPT-5.2, Gemini 2.5 Pro, Claude Opus, Claude Sonnet) across 16 perspectives to surface disagreements and blind spots.
Why this exists:
Most founders get either cheerleading ("great idea!") or generic advice. I wanted adversarial multi-model validation—where models argue with each other about your idea's viability.
How it works:
1. Research phase: 6 platforms (Reddit, G2, HN, Twitter, Product Hunt, YouTube) for competitor analysis + pain validation
2. Fanout: 16 expert perspectives (4 roles × 4 models: Builder, Skeptic, Operator, Growth)
3. Synthesis: Consolidate into 5 deliverables (Executive Summary, PRD, Scorecard, Synthesis Notes, Validation Plan)
4. Delivery: PDF report in 24 hours, $39
Sample validation: Agent Ops (OpenClaw workflow observability) - GREENLIGHT, 7.5/10 confidence. Models agreed on clear pain point, defensible moat via OpenClaw integration. Sample report: https://ideas.sparkngine.com
First paying customer delivered tonight: [Hotel marketing analytics client]. Verdict: PROCEED WITH CAUTION (5.8/10). Real assessment—not cheerleading. Flagged small TAM, long sales cycles, identity resolution risk as key blockers.
Tech stack: Built on OpenClaw for multi-agent orchestration, uses Brave Search API for research, Gemini Pro for synthesis, mix of frontier models for diverse perspectives.
Asking HN: Does this actually help founders make better decisions, or am I solving the wrong problem? Is $39 the right price point for rigorous validation?
Link: https://ideas.sparkngine.com

value: Show HN: Idea Forge – Multi-model product validation(validated an OpenClaw idea)

author: oliverchoy


value: chenghui

value:
I use Forgejo for personal projects but wanted a managed CI with higher compute. Cirrus CI[0] only supports GitHub, so I built a small bridge that listens to Forgejo webhooks, triggers Cirrus builds, and syncs commit status back.
Repo: https://codeberg.org/chenghui-lee/forrus
Public instance: https://forrus.lchenghui.com/
It currently supports:
- push + PR builds based on .cirrus.yml file
- automatic polling for build status
- status reporting back to Forgejo/Gitea
Limitations:
- doesn't support Cirrus CI's `changes_include`
- Starlark is not supported (yet)
Happy to answer any questions!
[0] - https://cirrus-ci.org/

value: Show HN: Forrus – A Bridge for Forgejo and Cirrus CI

author: chenghui


value: samxkoh

value: Hey folks. I'm working on Hey Echo, an app to talk things, find perspective and get clarity on actual next steps. Thanks for checking this out!

value: Show HN: Talk things through to find your next step

author: samxkoh


value: astnd

value:
Hello HN,
I’m the creator of GHOSTYPE.
I built this because I wanted a voice input workflow that didn't feel like talking to a chatbot. I wanted something that felt like a "neural extension" of my keyboard.
It’s a macOS-native app that sits between your voice and your active window. Here is what it actually does:
The Core Input Workflow:
Push-to-Talk & Smart Send: Hold a global shortcut to speak. It detects the active app to determine the correct send method (e.g., Cmd+Enter for Slack vs Enter for Discord).
Inline Editing: You can format while speaking. Need a line break, a specific spelling, or a bulleted list? You just say it, and it handles the formatting inside the sentence before outputting.
"Call Ghost": Post-processing commands (translate, polish, expand) are available immediately after speaking, before the text is typed out.
The Experimental Stuff (WIP):
1. Ghost Twin (Style Transfer): I call this a "Virtual Personality Engine" (a bit pretentious, I know). It analyzes your local writing history to build a style vector. It learns your tone—whether professional for emails or casual for Discord—so the output sounds like you, not a generic LLM.
Side note: I'm currently building the training UI to look like a retro CRT terminal because I miss that aesthetic.
2. Ghost Morph (Custom Skills): Trigger custom macros with a modifier key. For example, turn a raw voice thought directly into a formatted Twitter thread or a Jira ticket structure.
Privacy & Architecture:
Local-First: I’m an indie dev and literally cannot afford the server costs to store user typing data.
E2E Encrypted: Your "Ghost Twin" profile and skills are synced across devices via E2E encryption. Data stays on your machine.
Constraints:
macOS Only: I don't own a Windows PC, so I can't build for it yet. (If any Windows devs want to port this, let me know).
It's currently in pre-launch. I threw up a landing page at if you want to follow the progress. https://ghostype.one
Happy to answer questions about the local-first architecture or the style transfer logic!

value: Show HN: GHOSTYPE – AI voice input that learns your writing style

author: astnd


value:
I'm a new dad and started reading to my son from birth. I got into the 1000 books by 5 years challenge and wanted a simple way to track what I read to him. Existing apps felt too dated and clunky, so I built my own.
Built this to solve my own problem:
- Quick logging (date, book, reader, language)
- Scan or add your own book manually
- Simple stats on reading streaks and frequency
- Works for multiple kids and multilingual families
iOS only for now (built with React Native). Sign up on the site if you want an Android version: https://babybooktracker.montalesi.dev
iOS link here: https://apps.apple.com/app/baby-book-tracker/id6758372334
Would love feedback from other parents who read to their babies.

value: Show HN: Baby Book Tracker – Track reading to your baby


value: brucetooo

value:
Hello HN,
I built a tool to solve a specific annoyance: context switching between the browser (where I see the bug) and VS Code (where I fix it).
It's called Visual Agentic Dev.
The TL;DR:
It lets you click any component in a running React app and instruct an AI agent (like Claude Code) to modify the source code directly.
The "Magic" (How it works):
Instead of requiring invasive Babel plugins to inject data-source attributes at build time, I used a runtime approach:
The Chrome extension traverses the DOM to find the __reactFiber$ property.
It walks up the Fiber tree to find the _debugSource (fileName, lineNumber).
It sends this location + the component's code context to a local Bridge Server.
The Bridge Server spins up a PTY (using node-pty) and feeds this context to the Claude Code CLI.
This means it works with most "standard" React dev setups (Vite, Next.js dev mode) with zero configuration.
Why I made this:
I found that cursor and windsurf are great, but they are still "text-editor first". Frontend development is inherently visual. I wanted a "browser-first" workflow where I can fix UI glitches without ever leaving the mental model of the rendered page.
Repo (MIT/PolyForm Shield): https://github.com/brucetoo/visual-agentic-dev
Demo (GIF): https://i.imgur.com/Iyu3HOZ.gif
I'd love to hear your thoughts on the architecture or the workflow. Is runtime Fiber crawling stable enough for your daily drivers?

value: Show HN: Visual Agentic Dev – Click React components to edit source capabilities

author: brucetooo


value: NikhilVerma

value:
I've been actively using Vue for my official and personal projects for over 6 years now. While SFC was great it's quickly becoming a pain. It requires custom Volar plugins. It doesn't work with native typescript. The vue-tsc overrides "fs" imports just to be able to detect and run vue files.
I am not sure why Vue doesn't talk more about native TSX support because it eliminates this whole class of issues. In my work project, this has been a major pain because vue-tsc almost always crashes and I can't use the new tsgo (Typescript written in Go) because it doesn't work with SFCs
So I've made a new tool that migrates SFC to TSX. It's not a trivial migration so I've added an "LLM fallback" which takes care of the tricky things.
It made the migration of our internal codebase quite trivial. I hope you folks try it out and let me know.

value: Show HN: Migrate away from Vue SFC's to native TSX

author: NikhilVerma


value: parthsuthar

value: Building a platform that turns scattered peptide self-experiments into structured, shareable evidence. Instead of anecdotes in forums and threads, protocols and outcomes become comparable data people can actually learn from.

value: Show HN: Community Run Evidence for Peptides

author: parthsuthar


value: How I reverse-engineered Google Analytics and built my own analytics service for personal projects.

value: Show HN: Building My Own Google Analytics for $0


value: Show HN: Actionbook – Resilient browser automation engine for AI agents (Rust)


value: urin

value:
I built Qrono as a practical default so you can stop debating date/time libraries.
- Minimal bundle size (3.5 kB for 100+ APIs; detailed comparison in the docs)
- UTC-first, but timezone & DST aware (a gap in other libraries)
- Type-safe, immutable, and chainable by design
Docs: https://qronojs.dev/

value: Show HN: Qrono – A "final" date/time library for JavaScript

author: urin


value: yazeedaloyoun

value: Monitor Reddit for high-intent customer conversations. Track keywords, score buying intent, manage leads, and export to CSV. Never miss an important conversation or a prospect again.

value: Show HN: Reddit Scout Pro [Chrome-extension]

author: yazeedaloyoun


value: yevbar

value:
15% of Forbes 30 under 30 winners can be attributed to fraud. Here is an interactive visualization of 8215 winners and whether or not they're in some controversy.
I originally vibe scraped the winners and hit my weekly Claude limit, manually Googled over 2500 times (around 2400 I actually got an internal error), then realized Gemini has a free API with search supported.
Few are funny, some may from common names, feel free to DM me on X @itisyev if there is something you'd like to see changed.

value: Show HN: 15% of Forbes 30 under 30 winners did fraud

author: yevbar


value: mekod

value: Show HN: Ledger – Yes, another blogging platform (but you own the database)

author: mekod


value: modinfo

value: Show HN: Matchmaking where agents talk with agents to find compatible matches

author: modinfo


value:
I just published DriftProof Specification v1.0 – a patent-pending architecture for preventing behavioral drift in LLM systems.
The problem: LLMs don't fail loudly. They drift. Mission reinterpretation, constraint erosion, format collapse. Traditional monitoring catches it after divergence.
DriftProof prevents drift through six structural invariants:
- Identity Lock (role can't be redefined)
- Mission Lock (purpose stays fixed)
- Constraint Cage (boundaries are immutable)
- Format Lock (output structure is deterministic)
- Interpretive Invariance (context can't override core properties)
- Operator Sovereignty (authority hierarchy enforced)
Repo includes: published specification (normative requirements), reference implementation (deploys in 5 seconds), security model, compliance checklist.
Patent: US 63/905,582
License: MIT (code) + CC-BY-SA (spec)
Looking for feedback from people building production LLM systems. Early pilots available.

value: Show HN: DriftProof – Specification for preventing LLM behavioral drift


value: Saloc

value:
I built Copapy as an experiment: Can Python be used for hard real-time systems?
Instead of an interpreter or JIT, Copapy builds a computation graph by tracing Python code and uses a custom copy-and-patch compiler. The result is very fast native code with no GC, no syscalls, and no memory allocations at runtime.
The copy-and-patch compiler currently supports x86_64 as well as 32- and 64-bit ARM. It comes as small Python package with no other dependencies - no cross-compiler, nothing except Python.
The current focus is on robotics and control systems in general. This project is early but already usable and easy to try out.
Would love your feedback!

value: Show HN: Copy-and-patch compiler for hard real-time Python

author: Saloc


value:
I was disappointed with the Guided learning feature of Gemini. So I built a truly guided learning LLM for all academic knowledge.
After a cold start, it converges fast by tracking already explored topics within a topic and provide linear coverage of entire fields.
Feedback would be most welcome as this is an interesting POC to improve still.

value: Show HN: A Guided Learning LLM

title: Show HN: A Guided Learning LLM


value: winclaw-dev

value: Show HN: WinClaw – Open-source personal AI assistant that runs locally on any OS

author: winclaw-dev


value: onurkanbkrc

value: Show HN: Intelligent skill selection system that reduces token consumption

author: onurkanbkrc


value: jasfi

value: Show HN: IntentCode

author: jasfi

title: Show HN: IntentCode


value: steinsgate

value:
Hi HN,
We are a team of independent researchers from Germany working on ARC AGI 2 since last summer. The general opinion on open-weight models is that they are too weak for this fairly difficult benchmark and score at near noise levels. We found that GPT OSS 120B is actually much more capable than previously thought, once the interleaved thinking regime is stabilized. We basically let the model use a stateful IPython based REPL via function calling and patched vLLM so that the model can reliably do interleaved thinking. The score jumped more than 4x.
Technical write-up: https://pivotools.github.io/posts/agentic_coding_arc_agi/
Code: https://github.com/gutfeeling/arc-agi-2-submission
Data: https://huggingface.co/datasets/arcagi2/arcagi2-agentic-codi...
For safety, we support sandboxed execution using IPyBox (local Docker) and Daytona (cloud), so others can reproduce this without running untrusted code locally.
It gets more interesting: the effect seems to be general and translates seamlessly to other models without even changing prompts. We are not sure why agentic coding is so powerful in ARC AGI 2, which isn't traditionally thought of as an agentic benchmark. Perhaps code execution provides a stronger form of verification than COT, or perhaps it encourages a qualitatively different form of thinking.
We will be around for a while and would be happy to hear ideas / feedback and discuss infra issues / interleaved thinking / GPT OSS / ARC AGI 2.

value: Show HN: We let GPT OSS 120B write and run Python and ARC AGI 2 jumped 4x

author: steinsgate


value: sodomak

value:
I got tired of rewriting my day plan when one task runs long — so I built a planner that auto-recalculates
I originally coded mostly personal slow&buggy:) version of this workflow ~6 years ago and have used it daily since. Recently I rewrote it properly and made it public as Tigement.
Idea:
You plan your day as a timeline of tasks with durations. When one task changes (overrun / pause / skip / reorder), everything after it recalculates instantly so the plan stays consistent.
Notes that might interest you:
- It’s a web app and you can try the core workflow without signing up (local-first; stored in the browser).
- Free mode is local-only + export/backup.
- Premium adds multi-device sync where the server stores ciphertext only (end-to-end encrypted), plus E2EE table sharing (view/edit) for collaborating on schedules/tasks.
I’d love feedback on:
- is there anything what’s unclear in the first 30 seconds?
- the UI: any glitches (it's still beta:) )?
- basically anything - I am pretty bad with launch process:)

value: Show HN: Tigement – private timeline planner that recalculates when tasks change

author: sodomak


value:
I developed AI-templates for Obsidian Templater for new knowledge development.
The valuable features:
* ready-to-use templates (with default settings)
* structured LLM prompting
* maximal efficiency of LLM prompting via aspect management
* flexible LLM output management.

value: Show HN: AI-Templates for Obsidian Templater


value: TheAuditor

value: Show HN: The Hidden Bit - A Game Based proof architecture for P vs. NP

author: TheAuditor


value: vrathee

value: Show HN: Web Scraping Sandbox Website

author: vrathee

title: Show HN: Web Scraping Sandbox Website


value: baqiwaqi

value:
I built a free tool that lets you drop wind turbines on an interactive map. It
  draws distance circles (500m–2km), detects nearby residential buildings,
  enforces minimum separation rules, and exports to PDF.

value: Show HN: Windy – Place wind turbines on a map, see residential impact

author: baqiwaqi


value: northerndev

value: Show HN: Sigilla – Spaced repetition for browser tabs (stop hoarding)

author: northerndev


value: thedizzyhub

value:
Notion's MCP connection kept dying on me. Lost files. Failed syncs. Context gone mid-session.
So I built dullnote. It's a hosted markdown editor that Claude reads and writes via MCP. You store project notes, decisions, logs. Claude accesses them across sessions.
Version history tracks every change. Diffs show if you made the edit or Claude did.
Stack: React, FastAPI, Supabase, Hetzner VPS.
Free tier available. Signup required because files are private by default and need auth to sync with MCP.
Been using it a month. It's changed how I work, but I'm too close to it now.
Would love feedback:
- Is this useful outside my own workflow?
- What would stop you from using it?
Be brutal.
dullnote.com

value: Show HN: dullnote – Markdown Storage for Claude MCP

author: thedizzyhub


value: proletarian

value:
I've been reading Plato text and picking up some ancient Greek, and I had a useless thought experiment: what would a programming language look like with 4th century Athens constraints?
Εἶδος (Eidos — "Form") is one result. It's a declarative language called Λόγος where you don't execute code — you declare what exists. Forms belong to Kinds. Forms bear testimony. A law of correspondence maps petitions to answers. There are no loops, no conditionals, no mutation. It's intentionally not Turing-complete, aligned with Plato's rejection of the apeiron (the infinite).
It governs a real HTTP server (Ἱστός) where routes aren't matched by branching — they're recognized as Forms and answered according to law. An unrecognized path returns οὐκ ἔστιν ("it is not") — not an error, an ontological statement.
The project includes a parser that recognizes rather than executes, static verification expressed as philosophical propositions (Totality, Consistency, Well-formedness), Graphviz ontology diagrams, and a Socratic dialectic generator that examines the specification through the four phases of the elenchus.
The Jupyter notebook walks through everything interactively — from parsing the spec in polytonic Greek to petitioning the live server to watching Socrates interrogate the ontology.
https://github.com/realadeel/eidos

value: Show HN: Εἶδος – A non-Turing-complete language built on Plato's Theory of Forms

author: proletarian


value: Show HN: Self-hosted, end-to-end encrypted chat interface for OpenClaw


value:
Play Store: https://play.google.com/store/apps/details?id=com.chromamast...
Hi HN,
I’ve always found standard color utilities to be a bit dry. Most focus on just providing HEX codes, but as a developer, I wanted to build something that felt alive—a creative playground that helps you "master" color theory through gameplay.
I built Chroma Master - Color Tool. It’s a suite that combines professional color tools with a full "Game Hub" (Arcade).
### The Technical Challenge
The biggest hurdle was performance. I wanted a "Glassmorphism" look with real-time animated mesh backgrounds that wouldn't drain the battery or lag on mid-range Android devices.
- UI Logic: Built entirely in Flutter, utilizing heavy optimization for the custom mesh animation loops and OLED-ready true blacks.
- AI Integration: Implemented a real-time camera segmentation picker that extracts palettes directly from the physical environment.
- Color Mixing Engine: I had to re-implement digital pigment blending from scratch to make the "Merge Puzzle" feel physically accurate.
### The Arcade (7+ Games)
To keep the experience engaging, I integrated games that teach color relationships:
- Hue Rush: A high-speed coordination game testing your ability to switch color shields in rhythm.
- Merge Puzzle: A rethink of the 2048-style logic using additive/subtractive color blending.
- Memory Match: A high-fidelity memory trainer that uses hue variations to challenge your visual perception.
- Gradient Build: Playing with easing functions and lerping to create perfect smooth transitions.
I’m really interested in hearing from the HN community regarding the balancing of the game difficulty and the performance of the Flutter-based animations on your specific hardware.

value: Show HN: Chroma Master A premium Flutter color suite with 7 integrated games


value: thenextechtrade

value:
I’ve been coordinating with the ByteDance team and just got Seedance 2.0 running via their official cloud services (Volcengine). To be honest, the results are stunning—the physics and temporal consistency are a significant leap over previous models.
I built seedance.fast as a streamlined interface to expose these capabilities. The model is about to be officially released, but the site is already integrated and ready for the traffic. I'm focusing on low-latency inference to make the "text-to-video" workflow actually usable for creators.
Happy to answer questions about the model's performance compared to the private betas of other leading video AIs.
I’ll be continuously streaming the Seedance 2.0 videos I generate onto my site as a live video feed. You’re welcome to follow along and get early access.
I’m also offering an option to pre-purchase and lock in access to Seedance 2.0 now. Since the operating costs for 2.0 are expected to be significantly higher, pricing will increase later. Early supporters can secure access to Seedance 2.0 at the current Seedance 1.0 pricing.
If you’re interested in experimenting early and locking in a lower rate before the price adjustment, you can join now.
website:https://seedance.fast

value: Show HN: Seedance.fast – Early Access to ByteDance's Seedance 2.0 via Volcengine

author: thenextechtrade


value: lorenzosch

value:
I built Sonusly, a small experiment in structured music discussion.
The idea is simple: take the core mechanics of HN, apply them to songs.
Search for any track, submit it with a title and short description, and the community can upvote and discuss. Discovery happens through ranking and conversation. It’s intentionally minimal.
Curious whether this format actually improves music discovery, or if it only works for tech.
Feedback welcome!

value: Show HN: Hacker News for Songs

author: lorenzosch

title: Show HN: Hacker News for Songs


value: Show HN: I built a Chrome extension that finds edges on Polymarket


value: czeizel

value:
Hi HN,
We're a small remote team building YourSitee (yoursit.ee), currently in public beta.
In one sentence: YourSitee is a modular, privacy-first link-in-bio page designed to stay simple, fast, and transparent.
The problem we ran into was familiar. Most link-in-bio tools felt either too rigid (a branded vertical list we couldn't really control) or too heavy (full site builders for something that should remain lightweight). At the same time, many platforms rely on invasive tracking or unclear data practices, which felt misaligned with something meant to represent individuals professionally.
We started building YourSitee for ourselves. We wanted something closer to a 'digital business card' that could evolve, but without turning into a bloated website builder. Something fast, predictable, and respectful of visitors.
Technically, pages ("sitees") are composed from modular blocks (links, text, embeds, contact elements) rendered server-side. Sitees are designed to load quickly and function without requiring heavy client-side logic. For analytics, we use Plausible to provide aggregated, privacy-friendly statistics--no cross-site tracking or fingerprinting.
A few important notes about the current state: YourSitee is in public beta, fully usable, and completely free at the moment. There are no paid plans, no premium features, and no upsells.
We're intentionally keeping the scope tight while we learn. The main questions we're wrestling with are around modularity vs. simplicity, and how much flexibility is actually useful before it becomes noise.
The product is live and accessible. We'd really value feedback, especially around technical architecture, tradeoffs, and whether this feels meaningfully different from existing tools or just incrementally better.
Happy to answer questions and go deeper where helpful.
- Andras

value: Show HN: YourSitee – a privacy-first link-in-bio (public beta)

author: czeizel


value: castalian

value: Show HN: Awesome-Epstein-Files Catalogue

author: castalian


value: aytuncyildizli

value: Show HN: RePrompter – Rough prompts to structured, scored prompts

author: aytuncyildizli


value: AgastyaTodi

value: Show HN: On-chain credit score for AI agent-to-agent payments

author: AgastyaTodi


value: stubbi

value: Show HN: OpenClaw Kubernetes Operator

author: stubbi

title: Show HN: OpenClaw Kubernetes Operator


value: aleeexg

value:
Most automation tools either require coding, a complicated UI, or a monthly subscription.
I built Automate AI to make automation dead simple: You type what you want in plain English, and it generates a working automation script you can review and run on your own computer.
- No cloud.
- No account.
- No subscription.
Runs entirely on your PC (Windows & Mac).
Examples:
- “Organize my Downloads folder by file type”
- “Delete duplicate files”
- “Rename photos by date taken”
- “Remove background from images”
It uses a local LLM, so your data never leaves your machine. If you don’t want to install a model, you can use built-in templates instead.
It’s completely free.
Would love feedback!
Check it out here: https://automate-ai.xyz/

value: Show HN: Create and Run PC Automations from Plain English with Automate AI Free

author: aleeexg


value:
6 months ago I launched my AI customer support widget on Product Hunt and other directories. Got some traction but ended up with 5 free users and 0 paying customers.
I'm a software engineer with 10+ years of experience, building on the side after my 9-5 in Romania. I could ship a full product in a weekend with Claude Code. But I had zero idea how to get it in front of people who'd pay for it.
I didn't even know what an ICP was at the time. Didn't know if SEO was worth doing or how it worked. I was too scared to do cold outreach and send DMs to strangers. I literally spent months figuring everything out the hard way.
I turned what I learned into a structured framework that runs inside Claude Code. You clone a git repo and get two things:
1. It tells you what to do next
There's a growth playbook with a specific order: cold outreach first to validate that people actually want your product (month 1-3), SEO once you have messaging that works (month 3-6), paid ads last (month 9+). Each step has a strategy doc that explains the thinking behind it, not just "do this." There's a fundamentals guide that covers funnels, ICP scoring, the Mom Test, churn math. I wrote it for the version of me that knew how to write code but had never sent a cold DM.
Progress tracking files show where you are: leads contacted, reply rates, what's converting. The system reads that context and tells you what makes sense next. If you've sent 20 messages and nobody replied, it'll tell you to fix your messaging before sending more. If your reply rate is good but nobody's booking calls, it'll point you at the demo strategy doc.
2. It does the boring research
Since it runs in Claude Code, it can read your actual codebase and product files. Say "set up my product" and it looks at your code, researches competitors, scores potential customer segments using a weighted framework (pain, fit, budget, market size), and writes everything to markdown files you can review. When you need outreach copy, it writes messages based on your product and the specific person you're reaching out to.
The whole thing is markdown files in a git repo. No app, no dashboard. Strategies are docs, progress is tables, and Claude Code ties it together through good instructions in CLAUDE.md. It's structured knowledge plus product context plus AI execution, not magic.
I built it to solve my own problem and I've been using it to distribute itself, which is a little weird but it works. Got my first sale ever last week. $39 lifetime.
https://beyondfolder.com/distribution
Happy to answer questions about the approach or the Claude Code setup. Also curious if anyone else has tried using AI for distribution, not just for writing code.

value: Show HN: A Distribution Framework for founders who can build but can't sell


value: EngineerBetter

value:
Uses agent and Git Hooks to automatically create Git Notes on commit, containing the agent conversation that led to that commit. Works if either you or the agent commit.
It's basically the same thing as entire.io just announced that they got $60m investment for. Except I got Claude Code to write it last week, in my spare time, without really paying attention. I certainly didn't read or write any of the code, except for one rubbish joke in the README.
I've got a Claude Code instance working on Gemini CLI support and OpenCode support currently.

value: Show HN: Claudit – Claude Code Conversations as Git Notes, Automatically

author: EngineerBetter


value: jacobsyc

value: Show HN: I built a tool for lazy founders – it's called BunnyDesk

author: jacobsyc


value:
Hey HN,
I'm Daniel, solo dev from Germany. I built ClawHosters (https://clawhosters.com), a managed hosting platform for OpenClaw, the open-source AI agent framework.
Quick timeline: domain registered February 5th. First paying customer six days later. I probably should have spent more time on it, but it works.
If you haven't seen OpenClaw, it lets you run a personal AI assistant that connects to Telegram, Discord, Slack, and WhatsApp. Self-hosting it is absolutely possible, but it's a pain. You're dealing with Docker setup, SSL certs, port forwarding, security hardening, keeping the image updated. Most people don't want to deal with any of that. They just want the thing running.
That's what ClawHosters does. You pick a tier (EUR 19-59/mo), click create, and you've got a running instance with a subdomain. About 60 seconds if we have prewarmed capacity, maybe 90 seconds from a cold snapshot.
Some technical details that might interest this crowd:
*Subdomain routing chain.* Every instance gets a subdomain like `mybot.clawhosters.com`. The request path is Cloudflare -> my production server -> Traefik (looks up VPS IP from Redis) -> customer's Hetzner VPS -> nginx on the VPS (validates Host header) -> Docker container (port 18789) -> OpenClaw gateway. All subdomains require HTTP Basic Auth, configured per-instance through Traefik Redis middleware keys. The VPS itself only accepts connections from my production server's IP via Hetzner Cloud Firewall. No way to hit it directly.
*Prewarmed VPS pool.* Even from a snapshot, Hetzner VPS creation takes ~30-60 seconds. That felt too slow. So I maintain a pool of idle, pre-provisioned VPS instances sitting there ready to go. When someone creates an instance, we claim one from the pool, upload the config via SCP, run docker-compose up, done. The pool refills in the background.
*Security is 4 layers deep.* Hetzner Cloud Firewall restricts all VPS inbound traffic to only my production server IP. Host iptables (baked into the snapshot) add OS-level rules with SMTP/IRC blocking. SSH is key-only on both host port 22 and container port 2222, so brute-forcing isn't happening. fail2ban on top of that, and the Docker daemon runs with no-new-privileges. Probably overkill. I'm fine with that.
*SSH into the Docker container.* Users can enable SSH access to their actual container (port 2222). I built a custom image extending OpenClaw with an SSH server, key-only auth, no passwords. Fair warning though: enabling SSH permanently marks the instance as no_support. Once you're installing your own stuff in there, I can't guarantee stability anymore.
*Container commit for state preservation.* This one was tricky to get right. Users can install packages (apt, pip, npm) inside their container. Before any restart or redeploy, `CommitContainerService` runs `docker commit` to save the full filesystem as a new image. Next startup uses the committed image instead of the base one. Basically snapshotting your container's state so nothing gets lost.
I wrote a more detailed technical post about the architecture here: [link to blog post]
The whole thing runs inside a single Rails app that also serves my portfolio site (https://yixn.io). One person, one codebase, real paying customers. I'm happy to answer questions about the architecture, the Hetzner API, or the tradeoffs I made along the way.
Source isn't open yet, but I'm thinking about open-sourcing the provisioning layer. Haven't decided.
https://clawhosters.com

value: Show HN: I built managed OpenClaw hosting with 60s provisioning in 6 days


value: mikeyfrilot

value: Show HN: Attestia – Financial truth layer for Web3 (TS, 1176 tests, 97% cov)

author: mikeyfrilot


value: moshmage

value: Show HN: Baby Vault – A 100% offline, privacy-first PWA for new parents

author: moshmage