value: WujieGuGavin

value:
LLMs can generate code, analysis, and dialogue, yet they still fail at maintaining a stable persona. Anyone who has built an NPC, assistant, or long running agent has seen the same pattern: the character begins coherent, then drifts, contradicts itself, or dissolves under pressure. The failure is not in prompts or fine tuning. The failure is architectural. We are trying to impose identity on a system that has no structural representation of identity.
The Persona / Character Structure Layer treats personality as a dimensional object rather than a text instruction. It is part of a seven layer structural protocol designed to convert raw data into interpretable structure and structure into controllable behavior. The persona layer is where structure becomes identity.
Personas fail
Prompt based personas collapse because they rely on surface conditioning. They have no internal constraints, no behavioral invariants, and no structural boundaries. When the model encounters novelty, the persona evaporates and the system reverts to its base distribution. A persona is not a style. It is not a tone. It is a stable attractor in behavioral space. Without structure, there is no attractor.
A structural persona
The persona layer encodes identity as a set of structural constraints:
• behavioral invariants
• cognitive asymmetries
• motivational gradients
• boundary conditions
• long range consistency rules
These constraints shape the agent’s behavior across time and context. The persona becomes a region of stable behavior, not a temporary prompt. This is the same reason simple NPCs in games often feel more consistent than LLM based characters: they have explicit state and structural rules. The persona layer brings that determinism to generative systems without freezing them.
What enables
A structural persona layer produces agents that do not drift, collapse, or contradict themselves. It supports:
• NPCs that remain coherent in long simulations
• virtual humans with persistent identity
• customer facing agents that maintain policy under stress
• multi agent systems with distinct, non degenerate characters
• narrative worlds where characters evolve without losing structure
This is not role play. It is behavioral stability.
The larger system
The persona layer sits within the WLM structural protocol:
1. Structural Language Protocol
2. World Model Interpreter
3. Agent Behavior Structure Layer
4. Persona / Character Structure Layer
5. Knowledge Structuring Layer
6. Metacognition Layer
7. World Generation Protocol
Each layer transforms unstructured signals into dimensional structure. The persona layer is the point where structure becomes a stable behavioral engine.
Last not least
As AI systems shift from chat interfaces to autonomous agents, stability becomes a requirement. An agent that cannot maintain identity cannot maintain trust. An agent that cannot maintain trust cannot operate in real environments. The persona layer is not a UX feature. It is an operating system layer for agentic AI.
Repository: https://github.com/gavingu2255-ai/WLM-Persona-Engine

value: Show HN: Why LLM Personas Collapse and How Structural Identity Fixes It

author: WujieGuGavin


value: eyedark

value: Spent the day building a universal deployment suite for FinMind. Refactored the broken K8s manifests, added Tilt support for local dev, and optimized the Docker production stack. Would love some feedback on the HPA logic!

value: Show HN: FinMind One-Click Deployment (Docker and K8s and Tilt)

author: eyedark


value: Amirso

value: Show HN: OpenBerth – Deploy AI-built apps and tools to your own server

author: Amirso


value: SDCforAll

value:
We built a multi-port USB-C PD3.2 system that treats power delivery as a software-defined problem rather than fixed-function silicon.
This started as our internal R&D platform while developing a consumer charger. We were uncomfortable with the typical “the FAE handles the firmware, you just build the hardware” model that dominates the PD ecosystem. In that model, key behavior lives in vendor-controlled binaries, arbitration rules are opaque, and meaningful customization is either discouraged or impossible.
We wanted full ownership of the system — from power stage to protocol logic — and we wanted the ability to inspect, version, test, and evolve the charging algorithms ourselves. Instead of treating firmware as a thin configuration layer on top of fixed-function silicon, we designed the charger as a programmable system from the beginning.
Furthermore, we want to empower everyone.
So we redesigned the stack with a clean separation of concerns:
* ESP32-C3 (Wi-Fi + BLE) running open firmware
* FPGA handling safety features and control plane management
* 5× PD3.2 controllers (up to 140W per port capability)
The ESP32 chip offers:
* Local HTTP/JSON API
* MQTT client
* Prometheus exporter
* OTA updates
* Telemetry aggregation
Everything works locally; no cloud required (although cloud is available).
We approached this using software engineering discipline instead of traditional embedded shortcuts:
* Software defined, and software as an asset not a liability
* Open Source firmware
* Reviewable, testable modules
* Exposed APIs instead of hidden vendor blobs
The idea is simple: if modern infrastructure is observable and programmable, power delivery should be too.
It’s fully solid-state, built with industrial components (Coilcraft inductors, Murata/Samsung MLCCs), and powered by an off-the-shelf Mean Well PSU for reliability and traceability.
Repo: https://github.com/ifanrx/IonBridge
Happy to answer technical questions.

value: Show HN: A Software-Defined USB PD Charger (ESP32, FPGA, Open Source Hardware)

author: SDCforAll


value: MarkinK

value:
I've been categorizing every transaction for over five years — from a 2 euro coffee to rent payments. At the end of each month I close the books and look at a 12-month forecast of where my money is going.
It started when I was 19 and ran my first company. I had no idea what I was doing with money, so I found an experienced financial advisor who sat me down and showed me how companies actually do budgeting. Where money goes, how much you're spending, what income to expect. Basic stuff, but nobody had explained it to me before. I just started applying the same approach to my personal finances and never stopped.
Once a week I sit down, drop my bank statements into an AI agent, and it parses everything — categorizes transactions, inserts them into the database, checks that balances match across accounts. If something doesn't add up, it asks me before fixing it.
I tried a bunch of apps over the years — CoinKeeper, ZenMoney, spreadsheets. They all worked to some degree. But the one thing I couldn't find anywhere was the ability to just hand an API key to an AI agent and let it read, write, and modify my financial data however it wants. Every app wants you to click through its UI and use its import flow. I wanted SELECT, INSERT, UPDATE, DELETE through a simple HTTP API that any LLM can call.
So I built it. During a vacation. Was supposed to rest, but I couldn't stop once I started. Migrated all my data from ZenMoney and never looked back.
The main view is a budget table. Past months show actual numbers — what I really spent and earned. The current month has both actuals and the plan side by side, so I can see how I'm tracking. Future months are pure plan — expected income, expected expenses, projected balances. Everything sums up across categories and months, so I can see at a glance whether I can afford a big purchase three months from now or if I need to cut something. It's basically how companies do financial planning, but for one person.
Under the hood it's Next.js 16 with TypeScript on top of Postgres 18. Row Level Security enforced at the database layer — not in the app code. API keys are SHA-256 hashed, plaintext is never stored. Exchange rates fetched daily from five sources (ECB, CBR, NBS, NBU, plus a USDT peg). Locally everything runs in Docker Compose — Postgres, migrations, web app, FX worker. For production there's a full AWS CDK stack with ECS Fargate, RDS, ALB + Cognito auth, and WAF. The whole thing is about 9 tables and a view — kept it flat on purpose so LLMs don't get confused.
If you're into security — please try to break it. My real financial data is in there. I can't do a formal bug bounty, I'm one person. But if you get my data, I'll buy you a pizza and a beer.
Happy to answer questions about the architecture. Feature requests welcome too.

value: Show HN: Open-source expense and budget tracker with SQL API for AI agents

author: MarkinK


value: holg

value:
I built an IFC building model viewer entirely in Rust — Leptos for the UI, Bevy for 3D rendering (WebGPU/WebGL2),
  parser. It compiles to a single WASM binary (~5.8MB Brotli), no C++ geometry kernel or JS runtime involved.

  The demo loads the BayArena stadium with 324 floodlights carrying real EULUMDAT photometric data embedded in the IFC file.

Click any fixture to see its polar light distribution, beam angles, and color temperature. Press L to toggle photometric lighting mode  it spawns actual light sources derived from the fixture data.
Source at https://github.com/holg/bimifc

value: Show HN: Pure Rust IFC/BIM Viewer in the Browser via WebAssembly

author: holg


value: maurys

value: Show HN: Swalpa – Spoken Kannada learning platform built with Antigravity

author: maurys


value: ibrahimtxyz

value: Show HN: DailyWatch – Free video discovery across 8 regions

author: ibrahimtxyz


value: vedanthbora

value: Show HN: C7 – Pipe up-to-date library docs into any LLM from the terminal

author: vedanthbora


value: anirbanfaith

value: Show HN: Commitdog – Git on steroids CLI (pure Go, ~3MB binary)

author: anirbanfaith


value: funcin

value:
Lyria.run is a web app that lets you generate music tracks using Google's Lyria 3 model.
You type a text prompt describing what you want — genre, mood, tempo, instrumentation — and get a complete track back. No musical background needed.
All generated tracks are saved to a personal library where you can preview, organize, and download them in lossless format.
A few things I'd like feedback on:
1、How well does the output follow your prompt? Try something specific and see if the model captures it.
2、Audio quality — does it hold up for actual use cases (video scoring, background music, personal playlists)?
3、Anything broken or confusing in the workflow.
I’d love your feedback，thanks.

value: Show HN: Lyria.run – Music generation powered by Google's Lyria 3

author: funcin


value: Show HN: Django-CRM – Open-Source CRM with PostgreSQL RLS Multi-Tenancy


value: aloneguid

value: Tiny screen annotator for Windows (under 3 mb). No Dependencies, no installers, no admin, no tracking, no webview, no javascript, all 100% native.

value: Show HN: Markwright

author: aloneguid

title: Show HN: Markwright


value: emirb

value:
Hey HN...I built a free CDN to solve a real problem of slow or expensive git traffic. You just prefix a repo URL:

    git clone --depth=1 https://gitdelivr.net/github.com/torvalds/linux

and you get it served from Cloudflare edge servers closest to you, cached in Cloudflare's  object storage (R2).
The idea came from reading that GNOME had to redirect git clone traffic to GitHub mirrors because their GitLab bandwidth bill [1]. As a long time open source contributor and FOSS mirror hoster myself, it seemed surprising that this is a thing in 2026. We have jsDelivr for npm, and CDNs for Docker images and ML, but GNOME out of all projects has to move to use GitHub as a mirror.
Technically Git makes this surprisingly natural to cache as the same clone request produces the same packfile, so in my Workers code I hash the request body and use that as the cache key from R2. Refs get a short TTL of 60s.
The nice thing is you don't have to trust the proxy (I know the first question might be how do we trust you?) because git itself verifies every object hash client-side. And the source code is available on GitHub [2]. It's very light and turned out to be a weekend side project to help not just GNOME but anyone either facing a) egress bills b) not willing to move to GitHub or GitLab SaaS due to costs. It's 2026 so nobody should pay for egress if we have nice things like Cloudflare Workers + R2 :)
There's also support for Git LFS. Total cost to run is about $5/month.
I tested it with a dozen of different Git remotes: GitHub and GitLab of course but also, Codeberg, Gitea, and a few self-hosted instances.
This is meant to be used on public repos only, so private repos don't work  but you can take the source code and adjust it and deploy it yourself.
If nobody uses it, it was a still fun project to see how far I can push Cloudflare's offerings. (long-time customer, but haven't really played around with Workers)
[1]: https://www.phoronix.com/news/GNOME-GitHub-GitLab-Redirect
[2] https://github.com/emirb/gitdelivr.net

value: Show HN: GitDelivr: A free CDN for Git clones built on Cloudflare Workers and R2

author: emirb


value: Show HN: Prismle – Convert your resume into a business page


value:
I kept SSHing into machines to do what my agent could already do locally — check logs, grep for errors, edit configs. So I built Claw.
It's an MCP server that deploys a small Go binary over SSH and gives your agent the same tools it already knows (bash, read, write, edit, grep, glob) on any remote machine. Works with Claude Code, Cursor, or any MCP client.
No ports to open. No daemons. No root required.

value: Show HN: Claw – Let your AI agent operate any machine as if it were local


value:
Ragtoolina is an MCP server that pre-indexes your codebase and provides targeted context to AI coding agents instead of letting them scan files one by one.
I benchmarked it on Cal.com (~300K LOC, 40K GitHub stars):
- 63% token reduction across 5 diverse query types
- 43% fewer tool calls
- Cost: $3.01 vs $7.81 per 5-query session
The benchmark covers different complexity levels — from simple call-chain tracing to architectural understanding queries. RAG overhead doesn't pay off on trivial lookups (one query was actually worse with Ragtoolina), but on complex multi-file tasks the savings are substantial (up to 79% token reduction).
Quality evaluation was done via blind AI-judge scoring (the judge didn't know which answer came from which system) across correctness, completeness, specificity, and conciseness. Ragtoolina matched or exceeded baseline quality on 4 out of 5 tasks.
Works with any MCP-compatible client: Claude Code, Cursor, Windsurf, Claude Desktop.
Free tier available, would appreciate any feedback.

value: Show HN: Ragtoolina – MCP tool that adds codebase RAG to AI coding agents


value: Shreyaskapale

value:
  Hey HN,

  We built GitAgent — a git-native, framework-agnostic open standard
  for
  defining AI agents. The idea is simple: your repo IS the agent.

      npx @open-gitagent/gitagent@latest run -r
  https://github.com/shreyas-lyzr/architect -a claude

  That one command clones the repo, reads agent.yaml + SOUL.md +
  skills/,
  and launches it with Claude Code. Switch `-a openai` or `-a lyzr`
  to run
  the same agent on a different framework. No code changes.

  Goal: is keep the gitagent as a open standard ledger for an AI Agent in a VM, with versioned memories,   skills etc.

  An agent is just files:

      my-agent/
      ├── agent.yaml      # config: model, skills, tools
      ├── SOUL.md         # identity, personality, expertise
      ├── RULES.md        # boundaries, constraints
      ├── skills/         # capabilities
      ├── knowledge/      # reference docs
      └── memory/         # persistent context

  Why Git? Because agents need the same things code needs —
  versioning,
  branching, diffing, code review, and collaboration. We already have

  the best tool for that.

  What we've built:
  - CLI that validates, exports, imports, and runs agents
  - 8 adapters: Claude Code, OpenAI, CrewAI, OpenClaw, Nanobot, Lyzr,
   GitHub Models
  - Public registry at registry.gitagent.sh — browse and share agents
  - Compliance framework (FINRA, SEC, Fed) — audit logging,
  human-in-the-loop, kill switches

  Try it: https://gitagent.sh
  Registry: https://registry.gitagent.sh
  GitHub: https://github.com/open-gitagent/gitagent
  Discord: https://discord.gg/hVZV8Xyjdc

  Patterns
  1. Human-in-the-Loop — Agents create a branch and PR for human review before updating memory or skills.

  2. Live Agent Memory — memory/runtime/ stores dailylog.md, key-decisions.md, and context.md to persist state across sessions.

  3. Agent Versioning — Every agent change is a git commit. Roll back broken prompts or revert bad skills      anytime.

  4. Shared Context via Monorepo — Root-level context.md, skills/, tools/, and knowledge/ are inherited by all agents automatically.

  5. Branch-based Deployment — Promote agent changes through dev → staging → main, just like shipping  software.

  6. Knowledge Tree — knowledge/ folder stores entity relationships as a directory tree with embeddings for structured reasoning.

  7. Agent Forking & Remixing — Fork a public agent repo, customize SOUL.md, add skills, and PR improvements back upstream.

CI/CD for Agents — Run gitagent validate on every push via GitHub Actions. Test, block bad merges, auto-deploy.

  8. Agent Diff & Audit Trail — git diff shows what changed; git blame traces every line to who wrote it and when.

Tagged Releases — Tag stable versions like v1.1.0. Pin production to a tag, canary on staging, roll back instantly.

  9. Secret Management — Agent config is version-controlled; API keys stay in .env excluded via .gitignore.

  10. Lifecycle Hooks — hooks/bootstrap.md and hooks/teardown.md define what an agent does on startup and shutdown.

  11. Git-Native — Version control, branching, diffing, and collaboration are built in.

  12. Framework-Agnostic — Works with Claude Code, OpenAI, CrewAI, LangChain, and more.

  13. Compliance-Ready — First-class FINRA, SEC, and Federal Reserve support with audit logging and supervision.

  14. Composable — Skills, tools, sub-agents, and workflows can extend, depend on, and delegate to each other.

MIT licensed. Would love feedback.

value: Show HN: GitAgent – Clone a repo, get an AI agent – Claude Code / OpenClaw

author: Shreyaskapale


value: Manpi

value:
Hi HN,
I’m a solo developer and have spent the past year building MulMarket, a desktop analytics platform for CS2 skin traders.
It aggregates price data from multiple marketplaces (Steam, Skinport, CSFloat, BUFF163, DMarket, Bitskins, etc.) and helps users track portfolio value, detect arbitrage opportunities, and analyze price trends.
The main reason I built it was frustration with existing tools — most are web-based, require account linking, or lack accurate fee calculations and long-term tracking.
MulMarket runs locally on the user’s machine, does not require Steam login, and does not collect personal data.
It’s still early stage and I’m actively looking for feedback, especially on:
• Data reliability and aggregation methods
• UX for traders managing large inventories
• Features that would make it more useful for serious traders
Happy to answer any technical or product questions.

value: Show HN: MulMarket – CS2 Skin Market Analytics Desktop App

author: Manpi


value: lforster

value:
Hi HN,
I am building a Terminal User Interface (like Claude Code) for self-hosted AI agents on Jetsons. Works in air-gapped environments.
Unlike other solutions, this is optimised for unified memory machines, as to avoid OOM errors.
The agent can do stuff like edit, read, create files - manage and interpret data locally.
Currently, it gets ~17 tok/s on Jetson Orin Nano 8GB using Qwen3-4B-Instruct-4bit
In the future, adding TensorRT .engine support which will boost inference further. I am trying to get the memory footprint down, so if anyone has knowledge on kv cache optimisation, that would be great.
I would love to get your feedback and people try running it on more capable devices and models - post your results here.
Run
```
pip install open-jet
open-jet --setup
```
Webiste: https://www.openjet.dev/
Directly on Pypi: https://pypi.org/project/open-jet/
Repo: https://github.com/L-Forster/open-jet/

value: Show HN: Open-Jet – self-hosted Agentic TUI for air-gapped Jetsons

author: lforster


value: xlii

value: As in title, just to make finding "Who is hiring" posts easier.<p>Only Gemini, but it's MIT, so feel free to submit extra adapters :)

value: Show HN: LLM Evaluator for "Who is hiring" threads

author: xlii


value: thenextechtrade

value: Show HN: Seedance.fast – Early access to ByteDance's Seedance 2.0 model

author: thenextechtrade


value: one-bit

value:
I built this to solve a problem that kept annoying me: every time I start a new AI coding session, the agent has zero memory of what happened before. Decisions, discoveries, bug fixes - all gone.
oc-mnemoria is an OpenCode plugin that gives all agents a shared persistent memory store - a "hive mind." The plan agent records a decision, the build agent sees it. The review agent flags a bug pattern, and next session the build agent knows about it.
The storage engine is mnemoria, a Rust crate I also wrote. Some details on the architecture:
- Append-only binary log with CRC32 checksum chains for integrity
- Hybrid search: Tantivy BM25 + simsimd SIMD cosine similarity
- ~95us search latency, ~9,900 writes/sec on commodity hardware
- Single file format, git-friendly
- rkyv zero-copy deserialization (no parsing overhead)
The plugin side (TypeScript) handles:
- Automatic intent capture from chat messages
- System prompt injection with relevant memories at session start
- Per-agent tagging so you know which agent recorded what
- Selective forgetting and compaction for memory maintenance
Everything runs 100% locally. No data leaves your machine. The memory store is a single binary file you can commit to git, back up, or delete to reset.
I built this because I use OpenCode daily and got tired of re-explaining the same context every session. Happy to answer questions about the Rust internals, the plugin architecture, or the append-only storage design.
GitHub: https://github.com/one-bit/oc-mnemoria
Rust engine: https://github.com/one-bit/mnemoria
npm: https://www.npmjs.com/package/oc-mnemoria
crates.io: https://crates.io/crates/mnemoria

value: Show HN: Oc-mnemoria – Persistent memory for AI coding agents

author: one-bit


value: alexgriss

value:
Hi HN,
I’ve been working on a browser-based tool for exploring and debugging Web Audio API graphs.
Web Audio Studio lets you write real Web Audio API code, run it, and see the runtime graph it produces as an interactive visual representation. Instead of mentally tracking connect() calls, you can inspect the actual structure of the graph, follow signal flow, and tweak parameters while the audio is playing.
It includes built-in visualizations for common node types — waveforms, filter responses, analyser time and frequency views, compressor transfer curves, waveshaper distortion, spatial positioning, delay timing, and more — so you can better understand what each part of the graph is doing. You can also insert an AnalyserNode between any two nodes to inspect the signal at that exact point in the chain.
There are around 20 templates (basic oscillator setups, FM/AM synthesis, convolution reverb, IIR filters, spatial audio, etc.), so you can start from working examples and modify them instead of building everything from scratch.
Everything runs fully locally in the browser — no signup, no backend.
The motivation came from working with non-trivial Web Audio graphs and finding it increasingly difficult to reason about structure and signal flow once things grow beyond simple examples. Most tutorials show small snippets, but real projects quickly become harder to inspect. I wanted something that stays close to the native Web Audio API while making the runtime graph visible and inspectable.
This is an early alpha and desktop-only for now.
I’d really appreciate feedback — especially from people who have used Web Audio API in production or built audio tools. You can leave comments here, or use the feedback button inside the app.
https://webaudio.studio

value: Show HN: Web Audio Studio – A Visual Debugger for Web Audio API Graphs

author: alexgriss


value: arturstankevicz

value: Show HN: Go WebSocket orchestrator for 11 crypto exchanges

author: arturstankevicz


value: zeekwithz

value: Show HN: AgentEmail Free and Open Source Email Infra for AI Agents

author: zeekwithz


value: PxldLtd

value: Show HN: PipeDream – A state-aware AI visualizer for CLI text adventures

author: PxldLtd


value: attakei

value: Show HN: Rst2typst – Convert from ReStructuredText to Typst Code and PDF

author: attakei


value: jsattler

value:
I built Pulse to have a quick way to see if a service is down without opening a browser or checking Slack, mails, etc. IMO, it looks beautiful and doesn't get in the way when you don't need it. It also supports macOS notification and you can easily mute individual services if needed.
No tracking, no analytics, no account. MIT licensed. Config is stored locally.
Happy to hear feedback!

value: Show HN: Pulse – a beautiful service monitor that lives in your notch

author: jsattler


value: vishnukvmd

value:
Ente Paste is a simple way to share sensitive text, API keys, snippets, notes, or instructions.
- End-to-end encrypted links (decryption key lives in the URL fragment)
- Anonymous use (no account required)
- One-time access (opening consumes the paste)
- Automatic expiry after 24 hours
- 4,000-character limit for quick, practical sharing
- Preview crawler protections to avoid accidental consumption
Source code (monorepo): https://github.com/ente-io/ente

value: Show HN: Self-destructing, end-to-end encrypted Pastebin

author: vishnukvmd


value: VanceVP

value: Show HN: AI powered platform for Brazilian due diligence

author: VanceVP


value:
I wanted to see if AI (mostly ChatGPT Pro and Gemini Pro 3.1) could figure out how to compress executable binaries better than existing generic tools without me actually knowing much about compression engineering or ELF internals.
The result is an experiment called fesh. It works strictly as a deterministic pre-processor pipeline wrapping LZMA (xz). The AI kept identifying "structural entropy boundaries" and instructed me to extract near-branches, normalize jump tables, rewrite .eh_frame DWARF pointers to absolute image bases, delta-encode ELF .rela structs with ZigZag mappings, and force column transpositions before compressing them in separated LZMA channels.
Surprisingly, it actually works. The CI strictly verifies that compression is perfectly reversible (bit-for-bit identity match) across 103 Alpine Linux x86_64 packages. According to the benchmarks, it consistently produces smaller payloads than xz -9e --x86 (XZ BCJ), ZSTD, and Brotli across the board—averaging around 6% smaller than maximum XZ BCJ limits.
I honestly have no idea how much of this is genuinely novel versus standard practices in extreme binary packing (like Crinkler/UPX).
Repo: https://github.com/mohsen1/fesh
Does this architecture have any actual merits for standard distribution formats, or is this just overfitting the LZMA dictionary to Alpine's compiler outputs? I'd love to hear from people who actually understand compression math.

value: Show HN: A compression tool that reduces linux binary downloads by 6%


value: vnykmshr

value:
sift scores HN threads by the quality of their discussion, not vote count. It looks for depth (comments at 3+ levels), practitioner markers (experience phrases, code blocks, specific tool names), author diversity, and reference density. Threads that are mostly flames or pile-ons get filtered out.
Updated 4x/day. Shows 6 above the fold, rest behind a tap. Yesterday's picks are gone — no archive, no backlog.
The entire thing is a static page. Astro build, self-hosted fonts, no JS bundles, no tracking. Runs on Cloudflare Pages free tier.

value: Show HN: Sift – 10-12 HN discussions daily, ranked by practitioner depth

author: vnykmshr


value: ripplemessenger

value: Show HN: RippleMessenger – A Blockchain-Based Messenger

author: ripplemessenger


value: thinklanceai

value:
Hi HN,
I built AgentKeeper to solve a fundamental problem with AI agents: memory persistence.
Today, agents lose memory when:
• switching providers
• restarting
• crashing
AgentKeeper introduces a cognitive persistence layer that stores facts independently of any LLM provider and reconstructs context dynamically.
It works across:
• OpenAI
• Anthropic
• Gemini
• Ollama
Memory survives provider switches and restarts.
GitHub:
https://github.com/Thinklanceai/agentkeeper
I'm curious if others have faced the same problem and how you're handling memory persistence today.

value: Show HN: AgentKeeper – cognitive persistence layer for AI agents

author: thinklanceai


value:
Hey HN,
Every frontend framework bakes environment variables into the JavaScript bundle at
build time (process.env, import.meta.env). This means your Docker image is
environment-specific — you build one for staging, another for prod, and the image
you tested is never the one you deploy.
I built REP (Runtime Environment Protocol) to fix this. It's a lightweight Go gateway
(~6MB binary, zero deps) that sits in front of your static file server and injects
env vars into HTML responses at container startup.
What makes it different from the dozens of window.__ENV__ hacks:
- Three-tier security classification: REP_PUBLIC_* (plaintext), REP_SENSITIVE_*
  (AES-256-GCM encrypted, decrypted via short-lived session key), REP_SERVER_*
  (never reaches the browser)
- Automatic secret detection — scans PUBLIC vars for high-entropy strings, AWS keys,
  JWTs, etc. and refuses to start in strict mode
- HMAC integrity verification on every payload
- Optional hot config reload via SSE
- Works with any SPA (React, Vue, Svelte, Angular, vanilla) — no build tool plugins
- FROM scratch compatible — the binary is all you need
The SDK is ~1.5KB gzipped and gives you synchronous access (rep.get('API_URL')) for
public vars and async decryption (await rep.getSecure('KEY')) for sensitive ones.
Full RFC-style spec, security threat model, and reference implementation:
https://rep-protocol.dev
I'd especially love feedback on the security model — I've tried to be honest about
what the SENSITIVE tier actually protects against vs what it doesn't. The threat
model doc doesn't pretend browser-side encryption is bulletproof.
Built this because I got tired of watching every team I've worked with reinvent the
same env.sh → window.__ENV__ hack with zero security thought behind it.

value: Show HN: REP – build-once, run anywhere. Secure runtime config for web apps


value: Show HN: EasyClaw – One-click installer for OpenClaw AI agent


value: ufira

value: Show HN: Vibma – let agents create professional design system in Figma, directly

author: ufira


value: maedanao

value:
I run 5+ Claude Code sessions in parallel throughout the day. Switching between
tmux panes to find which one is waiting for approval, typing a prompt, then
jumping back to another pane — it gets old fast.
Inspired by cmux ( https://www.cmux.dev ), I built crmux in Rust. The key difference is that it works
inside your existing tmux setup — no separate terminal environment needed.
It's a fully keyboard-driven TUI with vim-like modal keybindings (normal/insert
mode). You can navigate sessions, send prompts, and manage everything without
touching the mouse.
- Sidebar shows all Claude Code sessions with real-time status
- Insert mode lets you send prompts directly without leaving crmux
- Mark sessions to preview multiple panes at once
- Pulse animation highlights sessions that need your attention (approval, stale idle)
Demo and installation: https://github.com/maedana/crmux
Built with Rust, ratatui, and crossterm.

value: Show HN: Crmux – A Vim-like TUI to manage multiple Claude Code sessions in tmux

author: maedanao


value: Show HN: Homebutler – Manage multiple servers from chat, single binary


value: NoamMorrissey

value: Show HN: Problem-Driven AI – Build AI products starting from the problem

author: NoamMorrissey


value: janlucasandmann

value:
Hey HN,
Chatbots are amazing at conversation. They suck at getting shit done while you’re sleeping, in a meeting, or at the beach.
So I built Computer Agents: real AI coworkers that each get their own isolated computer in the cloud.
What actually happens when you create one:
It boots its own persistent workspace (files, code, memory, everything survives forever)
You give it a goal + tools/skills
It runs 24/7 on cron, webhooks, or just “keep working until done”
You get results via email, Telegram, or just check back whenever
No more “remember this for next time.” It literally remembers.
Killer features I’m stupidly excited about
Persistent workspaces: your agent can iterate on the same codebase/project for weeks
Code execution that just works – auto pip install / npm install, isolated containers, no Docker hell
Deep Research skill – reads dozens of sources, synthesizes, cites everything (actually useful reports)
Multi-agent orchestration: chain, parallel, map-reduce, conditional workflows (yes, agent teams)
Triggers: GitHub push → agent starts reviewing PR. Slack message → agent replies. Webhook with HMAC.
Native SDKs – npm install computer-agents or pip install computer-agents (TypeScript + Python)
iOS + Mac apps so you can literally yell at your agents from your phone
Real examples people are already running:
London architect: agents generate full floor plans + client presentations overnight
FireChatbot team: 80% of customer emails handled autonomously, 35% workload drop
Solo devs: daily competitive analysis reports waiting in inbox every morning
This isn’t another wrapper around Claude Computer Use or Perplexity. It’s the operating system for those kinds of agents. always-on, persistent, and actually shippable.
Free tier gives you 150 compute tokens (~15-23 solid tasks) so you can go deploy something stupid right now. First paid tier is $19/mo for basically your first full-time AI employee.
Live at → https://computer-agents.com
Docs + quickstart → https://computer-agents.com/documentation
SDKs, comparisons, research papers I wrote while building this → footer links
Would love brutal feedback, wild use cases, or just to hear what you’d make your first agent do. (I’m the solo founder, Germany-based, been glued to the product for the last 4 months.)
Ping me when it’s done. I’ll be at the beach.

value: Show HN: Computer Agents – AI Agents That Work While You Sleep

author: janlucasandmann


value: pgbouncer

value: Open-source Rust-based image processing pipeline that takes images and outputs structured JSON — 768-dim vector embeddings, semantic tags from a 68K-term vocabulary, EXIF metadata, content hashes, and thumbnails.<p>Everything runs locally via SigLIP + ONNX Runtime. Single binary, no Python, no Docker, no cloud dependency. Optional BYOK LLM descriptions (Ollama, Anthropic, OpenAI).

value: Show HN: Photon – Rust pipeline that embeds/tags/hashes images locally w SigLIP

author: pgbouncer


value: whatsthatabout

value: Show HN: AutoPiP – Safari extension for automatic PiP on tab switch (v2)

author: whatsthatabout


value: JeduDev

value:
I built this app as a hobby project to experiment with developing a full-stack product from scratch—handling everything from the core utility and vision to the actual implementation. It took me about three months to build, and it was a massive learning experience that has prepared me to tackle my next set of projects.
What it does:
The app allows you to create documents, whiteboards, and databases integrated with reminders and nested, agentic AI chats.
The "Beta" Reality:
To be completely honest, the app is still quite "broken" in several areas. You might run into loading issues, UX friction, or bugs that could interrupt your workflow. I wouldn't recommend using this for mission-critical work yet; please treat it as a live demo or a functional prototype.
About the Subscription:
You’ll see a payment option with certain limits. Honestly, I don't recommend paying for it right now given the current state of the app. If you do choose to subscribe, please consider it a donation to support further development rather than a purchase for a polished service.
Feedback & Collaboration:
I have a lot of ideas for where to take this next and I plan on iterating quickly. I’d love to get your feedback on the concept, and if anyone is interested in collaborating or just chatting about the tech, I’m all ears.
Link: www.listal.space
Tech Stack: NextJS, TailwindCSS, Typescript, Supabase(Auth and Database), Tavily(ai web search), Groq, R2 Cloudflare, Vercel(Hosting)
Thanks for checking it out!

value: Show HN: A productivity app with reminders and nested AI chats

author: JeduDev


value:
I started a solo software engineering lab earlier this year and wanted a professional foundation for my clients from day one.
I looked at platforms like HoneyBook, but they are expensive and didn't feel built for developers. I wanted a lightweight, self-hosted, and white-label solution that handled the essentials—file sharing, project tracking, and invoicing—without the SaaS tax. So I built Atrium.
It’s a clean interface that gives clients a single place to track progress and handle billing under my own branding, rather than me stitching together fragmented tools.
Core Features:
* White-Labeling: Fully customizable branding for the client-facing UI.
* Updates & Collaboration: Status updates and file sharing for clients, plus internal notes for team-only coordination.
* Asset Management: Support for S3, MinIO, R2, or local storage.
* Invoicing: Integrated PDF generation and billing.
I’m using this to run my lab’s client operations and would love technical feedback, contributions or feature requests from the community.
GitHub: https://github.com/Vibra-Labs/Atrium

value: Show HN: Atrium – An open-source, self-hosted client portal


value: eieio

value:
snakes.run is massively multiplayer snake, played over ssh. ssh snakes.run to play.
I spent a while reducing the game's bandwidth footprint as much as I could; I have a writeup on my site about how the game works if you're curious[1].
That said - there is only a single server here (Anycast shenanigans were out of scope), so latency does get worse the further you are from the server (NYC). I think the game is pretty playable for a surprising number of people, but you'll definitely struggle to play from, say, Australia.
Fun fact: two sub-problems that I encountered while thinking about this game made their way to HN's front-page - TCP_NODELAY[2] and SSH keystroke obfuscation[3].

    [1] https://eieio.games/blog/secure-massively-multiplayer-snake/
    [2] https://news.ycombinator.com/item?id=46359120
    [3] https://news.ycombinator.com/item?id=46723990

value: Show HN: MMO snake over ssh – ssh snakes.run

author: eieio


value: PowMan

value:
The US Harmonized Tariff Schedule is public — USITC publishes it and even has a REST API. The problem is everything around it: the schema shifts without notice, field names are inconsistent across chapters, and there's no reliable way to know when something changed unless you run your own diff.
I built TradeFacts.io to sit between USITC and your application. It serves the full HTS schedule (32,295 records) as a normalized JSON API with a stable schema, nightly updates, and change detection.
What it adds on top of raw USITC data:
• Versioned diffs — nightly change detection with a full history endpoint
• Webhook push — Tier 2 notifies your endpoint when tariff codes change, so you don't poll
• Schema stability — when USITC changes their format upstream, we absorb it; your integration keeps working
• Safety checks — the nightly pipeline aborts if the incoming dataset drops below 30,000 records, so a partial USITC response never overwrites live data
Auth is a single API key header. The target buyer is engineering teams at customs brokerage software companies and trade compliance SaaS vendors who are currently maintaining their own scraper or polling USITC directly.
Pricing is $199/month (Tier 1, full dataset) and $399/month (Tier 2, adds webhooks and change history). 30-day free trial, no credit card.
Docs: https://tradefacts.io/docs.html
Happy to answer questions about the data pipeline, HTS structure, or why I made certain schema decisions.

value: Show HN: Tradefacts.io – US HTS tariff schedule, a JSON API and change detection

author: PowMan


value: ZarMeikel

value: Hi HN, I hated the 50/50 guessing in Minesweeper. I built a clone with a custom solver that guarantees every board is 100% solvable by pure logic. Built with React, Vite, and Tailwind. V2.0 fixes UI scaling. Would love your feedback!

value: Show HN: Cyber-Sweeper v2.0 – A 100% logic-solvable Minesweeper

author: ZarMeikel


value: boutetnico

value:
I discovered RDAP while working on a hobby project where I needed to check if IP addresses were residential or not. RDAP was giving me more data than WHOIS, and it returns JSON instead of plain text. WHOIS is going away anyway. ICANN now requires RDAP for all gTLDs, and many registries are returning less data over port 43 or dropping it entirely. But RDAP is not easy to work with directly.
There is no single server. You have to check the IANA bootstrap registry to find which server handles each TLD, and some ccTLDs have working RDAP servers that are not even listed there. For .com and .net, the registry only has basic data. You need a second request to the registrar server to get contacts and abuse info. Then there is vcardArray, a deeply nested array-of-arrays format for contact data. And every server has its own rate limits.
I built an API that does all of that and gives you clean JSON back. One endpoint, same schema for every TLD. Here is what you get for google.com with ?follow=true (follows the registrar link automatically):

  {
    "domain": "google.com",
    "registrar": { "name": "MarkMonitor Inc.", "iana_id": "292" },
    "dates": { "registered": "1997-09-15T04:00:00Z", "expires": "2028-09-14T04:00:00Z" },
    "nameservers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"],
    "entities": { "registrant": { "organization": "Google LLC", "country_code": "US" } }
  }

You also get status codes, DNSSEC, abuse contacts, etc. There is a free lookup tool on the homepage to try it, no signup needed.
Supplemental servers. The IANA bootstrap only covers ~1,200 TLDs. I keep a list of 30 extra RDAP servers (for TLDs like .io, .de, .me, .us) that work but are not registered with IANA. Synced daily.
Registrar follow-through. For thin registries like .com, the registry only has dates and nameservers. The registrar has the rest on a different server. The API follows that link and merges both.
SDKs. Open source clients for Python, Node.js, PHP, Go and Java.
Responses are cached for 24 hours to reduce load on upstream RDAP servers.
This is my first SaaS, just launched. Would love honest feedback.
The API starts at $9/mo with a 7-day free trial.

value: Show HN: RDAP API – Normalized JSON for Domain/IP Lookups (Whois Replacement)

author: boutetnico


value: dalbaugh

value:
I’ve spent the past 4 years building software for a knitting factory, including selecting and implementing an ERP. That experience was really painful.
Most manufacturing ERPs are hard to evaluate before signing an enterprise contract, poorly documented, and clearly not designed with serious API users in mind. Even when APIs exist, they’re often inconsistent or bolted on as an afterthought.
We built Augno to change that. The goal is to provide a Stripe-like experience for manufacturing ERP. We want it to be a usable out-of-the-box product and a well-designed, cohesive API that developers can actually build on.
We put a lot of effort into API design, documentation, and sandboxing. You can create a free account, explore the sandbox, and only move to production when you’re ready. There’s a free tier to make evaluation straightforward, without sales calls or contracts. Our focus is to let teams spend their engineering time on things that drive revenue - like custom quoting, order workflows, or integrations - instead of fighting their ERP.
We’re actively expanding the public API and rolling out additional endpoints over the next few months.
I made an account that you can check out. You can login at https://www.augno.com/auth/login
username: hackernews
password: aveGLZ9Nn4MA7cg!
Docs are here: https://docs.augno.com/
I’d really appreciate feedback from anyone who’s dealt with manufacturing systems or ERPs before!

value: Show HN: Augno – a Stripe-like ERP for manufacturing

author: dalbaugh


value: rlarua

value:
AI coding agents ship code quickly.
But in real-world projects, some basic questions remain:
* What plan did this change follow?
* Was the intent reviewed before execution?
* What evidence do we have beyond “it works”?
* When something fails, does the lesson get captured structurally?
AgentTeams adds a lightweight governance layer on top of AI-driven development.
Instead of just marking tasks as “Done”, it creates a traceable execution chain:
1. Plan
   Every task starts as an explicit plan.
   Priority, risk notes, and review status are recorded before execution.
2. Completion Report
   When work finishes, a report is generated automatically.
   It includes:
* Number of files changed
* Execution time
* A quality score (e.g., 82 / 95)
* Verification summary
3. Post-mortem
   If something goes wrong, root cause and preventive actions are recorded and linked back to the original plan and conventions.
On the dashboard, you can see in real time:
* How many plans are in progress
* How many are waiting for review
* How many were completed in the last 7 days
* How many reports failed or were partially completed
* How many post-mortems are still open
The goal isn’t automation.
It’s accountability and traceability for AI work.
AgentTeams is currently in beta.
If you’re running AI-assisted development workflows, I’d love critical feedback from real usage.

value: Show HN: AgentTeams – Traceable AI coding workflows

author: rlarua


value: hejhdiss

value: V6 is the network-native evolution of the Qeltrix encrypted archiving system. It turns any data stream into a live, seekable, encrypted V6 container — without needing the entire file first.

value: Show HN: Qeltrix-V6, Encryption Gateway

author: hejhdiss

title: Show HN: Qeltrix-V6, Encryption Gateway


value:
I realize there may be some AI fatigue in the HN community, but I've genuinely seen a marked productivity boost using these tools - hence the desire to share them.
With the releases of my GhidrAssist (Ghidra) and BinAssist (Binary Ninja) LLM reverse engineering plugins over the past year, a number of people have reached out to ask "where's the IDA Pro plugin?"
Well - as of today, both IDAssist and IDAssistMCP are live on Github!
As you'd expect, they all share the same look and feel, workflow and feature set, including:
- AI-Powered Function Analysis: One-click function explanation with security assessment
- Interactive Chat: Context-aware chat with macros to inject functions, variables, and disassembly as well as builtin MCP client
- Smart Suggestions: AI-generated rename proposals for functions and variables
- ReAct Agent: Autonomous multi-step investigation using MCP tools
- Semantic Knowledge Graph: Visual graph of function relationships with similarity search
- RAG Document Search: Query your own docs (.txt, .md, .pdf) alongside binary analysis
- MCP Integration: Connect external tool servers for augmented LLM capabilities
- Multi-Provider Support: Anthropic, OpenAI, Gemini, X.ai, Ollama, LMStudio, LiteLLM, etc.
These aren't just jump-on-the-AI-bandwagon contributions. The GhidrAssist and BinAssist plugins represent over a year of steady development and refinement and are battle-tested in day-to-day use. I use them daily to score significant productivity gains in my RE day job as well as on personal projects.
If that sounds interesting, give them a try.

value: Show HN: IDAssist – AI augmented reverse engineering for IDA Pro


value: bneb-dev

value:
Hey HN,
I wanted to share the new online playground for Salt (https://salt-lang.dev/playground/), a sovereign systems language designed for high-performance, distributed workloads where paying an "abstraction tax" is no longer acceptable.
We started building Salt to bridge the gap between the raw power of manual pointer arithmetic and the safety guarantees of modern high-level languages. The architecture relies on an MLIR-based backbone and a Z3-powered "formal shadow," and the design is rooted in three main pillars:
Fast Enough: The target is to stay within 20% of C's performance, while aiming to consistently outperform Rust.
Supremely Ergonomic: We didn't want to reinvent the wheel on syntax. Instead, we've shamelessly adopted the best features and syntax patterns from Julia, F#, Rust, C, Python, Haskell, Erlang, and Go.
Formally Verified: We've integrated Z3 directly into the compilation pipeline to mathematically prove safety without sacrificing developer velocity.
You can spin up the compiler directly in your browser and mess around with the syntax and verification engine without installing anything locally.
One more link to the project landing page: https://salt-lang.dev, and as always, thanks for reading.

value: Show HN: Write and Run Salt v0.9.2 in the Browser

author: bneb-dev


value: jbwagoner

value:
We built an operating system for AI agents that actually deploy and run autonomously — not just chat interfaces you have to babysit.
The core idea: Agents should work like specialists on your team, not assistants you prompt all day.
What that means in practice:
15 prebuilt production agents (legal, finance, marketing, operations, etc.)
32+ skills from the OpenClaw library (email, web search, browser automation, code execution, council deliberation, etc.)
Deploy to Telegram, Slack, email, or dashboard
Heartbeat scheduling for proactive agents (weekly reports, daily checks, etc.)
BYOK support (Claude, GPT-4, Gemini, DeepSeek, local models)
Portable Mind Format: every agent is a JSON file you own and can export
Three layers that matter:
1. KARMA (cost governance)
Agents with unlimited API access burn money fast. Every skill call is budget-tracked. You set spending limits. Agents that exceed budget get throttled, not shut down.
2. SILA (audit)
Every agent action is logged with full context: what skill was called, what data was accessed, what was sent externally. SOC2/GDPR/HIPAA compliance isn't an afterthought — it's built into the execution layer.
3. SUTRA (orchestration)
Council deliberation as a first-class skill. 8 specialist agents (Right View, Right Intention, Right Speech, etc.) can be invoked by any other agent. You get multi-perspective analysis without manually coordinating LLM calls.
Why we built this:
Most "agent frameworks" are libraries for developers to stitch together their own infrastructure. That's fine for engineers, but it leaves everyone else stuck with ChatGPT.
We wanted something in between: opinionated infrastructure that handles deployment, security, and cost control — so you can focus on what your agents do, not how they run.
Current state:
Live in production
$9/month Explorer tier (full platform access)
Companion book: How to Use Autonomous Agents — free on Kindle March 1-5, 2026
16+ agent build examples across business, creative, and household domains
The constraint we're designing around:
Agents that "write code on the fly" are powerful in demos, brittle in production. Our bet: pre-audited, composable skills + user-defined constraints + transparent cost tracking = agents you can actually trust to run unsupervised.
Built by: JB Wagoner (patent holder for transportable AI persona architecture, founder of Sutra.team)
Feedback welcome — especially from people building agent systems in production. What's missing? What would make this more useful?

value: Show HN: Sutra.team – The First OS for Autonomous Agents

author: jbwagoner


value: WolfOliver

value: Show HN: Graph-Based Convex Alternative with Real-Time Sync

author: WolfOliver


value: rexipt

value:
I built this npm package for performance synthesis, anomaly detection, and customer segmentation via integrations like Shopify, Google Ads, etc. More coming.
Install globally: npm i -g @rexipt/ai-employee
Init: rexipt-ai init
Connect (e.g., Shopify): rexipt-ai shopify oauth-connect
Run skills: rexipt-ai run-all or rexipt-ai r dailyBriefing
75s demo: https://x.com/zaddizie/status/2028453817881129212
Feedback on features/integrations?

value: Show HN: AI Employee – AI-powered BI CLI for ecommerce reporting

author: rexipt


value: nexroo

value:
Hello,
I made this Ai-driven IDE (Claude Code based) that i use for my everyday dev.
It allow :
- Multiple context management and auto-injection
(define code practice, app context, agent context
- Clear permissions, skills and assignement management
- Global agent that delegate automatically to your specified agent
- A kanban where you create a ticket with user story, definition of done, then agent will create a plan you can validate, then all is done automatically in a git worktree and git branch until merge to base branche!
It is free and will stay free for all solo dev :)

value: Show HN: Supervisor IDE: Not your usual IDE, create a team, run tasks flow

author: nexroo


value:
I got tired of gluing together proxy rotation, fingerprint spoofing, job queues, and deploy scripts every time I needed to run browser automation (bots/scrapers) at scale. So I built an orchestration layer for it.
You write a Python script (Playwright, Selenium, or nodriver), add a JSON config, and Armada distributes the work across K8s pods. Jobs go through RabbitMQ, per-pod configs are seeded via Redis, proxies and fingerprints are handled by dedicated services. Scaling from 1 to 100+ workers needs no code changes.
It also ships with Fantomas, a browser automation lib on top of nodriver, physics-based mouse curves (WindMouse), randomized keystrokes, and an XDO mode that fires OS-level events via xdotool.
Code: https://github.com/armadasvc/armada (AGPL v3)
Docs: https://armada.services/docs
Reach out anytime.

value: Show HN: Armada, a K8s orchestrator for bots and scrapers


value: darrenmoorebkk

value:
A while ago I played Inselkampf, a slow-burn browser strategy game. I was never very good at it but I loved logging in a few times a day to build, upgrade and spy on other islands.
That idea has stuck with me for many years and I've given it ago to write the game multiple times. The original game had a good amount of depth and although the tick system is pretty straight forward my early attempts I just flaked out.
So with Claude Code on the mobile around I gave it ago. While I was on a road trip I built the backend, basic frontend and fully tested without even looking at it. It started as a bit of a challenge to see how far AI could go without even uploading or testing it. Once I got back home I git pulled it and.. well the backend and ticks worked well but the frontend was a mess. So I spent a few days tidying it up and it's ready for some play testing.
It's a real-time multiplayer browser strategy game where players build islands, train fleets, form alliances, and compete in a persistent world. Combat is timer-based and diplomacy-driven, with no pay-to-win mechanics.
It’s still early and evolving — happy to answer technical or design questions.
Link: https://inselnova.com/

value: Show HN: Rebuilt an old-school browser strategy game inspired by Inselkampf

author: darrenmoorebkk


value: coderai

value:
I built PLAI.chat because I was frustrated with two things:
1) new models ship every week and I was constantly switching between apps to keep up.
2) Every service stores my conversations on their servers.
So, PLAI.chat takes a different approach: your chat history is stored only in your browser's localStorage — never on our servers. API calls go to model providers via OpenRouter, but we don't log, store, or train on any conversations — and they aren't linked to any user identity on our end. We don't store anything. The architecture makes the privacy guarantee verifiable, not just a policy claim.
You can try it right now, no account needed. Go to plai.chat and start chatting for free. For more models or higher limits, sign in with a magic link — no forced registration, no confirmation hoops.
What it does:
- 300+ models (GPT, Claude, Gemini, Llama, Mistral, Qwen, and more via OpenRouter)
- Free to start, pay-per-use for extended usage — no subscription
- Chat history in your browser only — close the tab, it's still there; we never see it
- Switch models mid-conversation to compare responses; presets for free/balanced/premium
- Supports files, PDFs, images, and image generation
I also built a Slack version — but still waiting on Slack's marketplace approval, which has been... slow.
Stack: Next.js, Cloudflare Workers, Stripe, OpenRouter.
Thanks for your feedback and comments!
Lucas
https://plai.chat

value: Show HN: PLAI.chat – Multi-model AI chat that doesn't store your conversations

author: coderai


value:
I built two CLI tools to fix friction points with Claude Code:
claude-remote-approver – Sends permission prompts (Bash, Write, Edit) as push notifications to your phone via ntfy.sh. Tap Approve/Deny from anywhere. Falls back to terminal on timeout. Supports "Always Approve" for trusted tools.
claude-plan-reviewer – Hooks into Claude Code's plan mode and sends plans to a rival AI (OpenAI Codex CLI or Gemini CLI) for review. Feedback gets injected back, Claude revises, repeats for N rounds. Different models catch different blind spots.
Together: give Claude a task, walk away, rival AI reviews the plan automatically, phone buzzes when permissions are needed, come back to a completed task.
Both MIT licensed, zero dependencies, Node.js 18+, no telemetry.
- https://github.com/yuuichieguchi/claude-remote-approver
- https://github.com/yuuichieguchi/claude-plan-reviewer

value: Show HN: Two tools to make Claude Code more autonomous


value: ashwathstephen

value:
I built Sairo because searching for a file in the AWS S3 console takes ~14 seconds
on a large bucket, and MinIO removed their web console from the free edition last year.
Sairo is a single Docker container that indexes your bucket into SQLite FTS5 and
gives you full-text search in 2.4ms (p50) across 134K objects / 38 TB. No external
databases, no microservices, no message queues.
What it does:
- Instant search across all your objects (SQLite FTS5, 1,300 objects/sec indexing)
- File preview for 45+ formats — Parquet schemas, CSV tables, PDFs, images, code
- Password-protected share links with expiration
- Version management — browse, restore, purge versions and delete markers
- Storage analytics with growth trend charts
- RBAC, 2FA, OAuth, LDAP, audit logging
- CLI with 24 commands (brew install ashwathstephen/sairo/sairo)
Works with AWS S3, MinIO, Cloudflare R2, Wasabi, Backblaze B2, Ceph, and any
S3-compatible endpoint.

  docker run -d -p 8000:8000 \
    -e S3_ENDPOINT=https://your-endpoint.com \
    -e S3_ACCESS_KEY=xxx -e S3_SECRET_KEY=xxx \
    stephenjr002/sairo

Site: https://sairo.dev
GitHub: https://github.com/AshwathStephen/sairo
I'd love honest feedback — what's missing, what would make you actually switch to this?

value: Show HN: Sairo – Self-hosted S3 browser with 2.4ms search across 134K objects

author: ashwathstephen


value: mehmetkose

value: Ultra-fast desktop & CLI app that finds your SEO & AEO issues and allows you to extract your content as Markdown

value: Show HN: Rust Based SEO and AEO Crawler

author: mehmetkose

title: Show HN: Rust Based SEO and AEO Crawler


value: janwilmake

value: Show HN: Markdown Browser – See the Web the Way AI Sees It

author: janwilmake


value: StefanoC

value:
Aigent aims at being the best AI assistant, and to get there I believe that it needs to learn on the job. It's geared towards self reflection and takes user feedback seriously.
It already has a ton of capabilities, like async tasks, granular permissions, operate the browser through a chrome plugin, themes, a rich context explorer, STT and TTS (including a short form), command and file picker.<p>I just wanted to show you because I'm very happy with the results so far <3

value: Show HN: Aigent – A general-purpose AI agent built for self-improvement

author: StefanoC


value: harlequinetcie

value: Show HN: SVG icons via API, payment via HTTP 402 (like 1991)

author: harlequinetcie


value:
Kelos is a Kubernetes framework for orchestrating autonomous AI coding agents (like Claude Code) in ephemeral pods.
The original goal was sandboxing — I didn't want to run agents with --dangerously-skip-permissions locally. But the real unlock turned out to be declarative workflows. You define agent tasks as Kubernetes CRDs, things like:
- Watch for "bug" issues → auto-draft a fix PR
- Auto-review incoming pull requests
- Auto-triage new issues with labels and priority
- Periodically scan the codebase → propose improvements
- Test the project as a new user → surface rough edges
Self-development pipeline: https://github.com/kelos-dev/kelos/tree/main/self-developmen...
I've been using Kelos to develop Kelos. When something breaks, I refine the YAML or add features to the controller. It's early and rough around the edges, but the core loop works.
Happy to answer questions about the design or what's broken.

value: Show HN: Kelos – Define your AI coding agent workflow as YAML on Kubernetes


value: guimiran

value:
I've been working in software quality engineering for years and kept
running into the same problem: organizations trying to adopt AI coding
agents and failing — not because the tools were bad, but because their
processes weren't ready.
CMMI measures process maturity. But it says nothing about how hard it
will be to shift from code-centric to specification-centric development.
Those are different questions.
So I built a 5-level framework that tries to answer both simultaneously:
where you are, and how much work it will take to get to SDD with AI agents.
The levels go from GUIDO 1 (chaotic, very high migration effort) to
GUIDO 5 (SDD-native, specs as living source of truth).
The key insight — which I think is non-obvious — is that you can be
CMMI Level 3 and still be GUIDO 2. Process maturity and SDD readiness
are not the same axis.
It includes a whitepaper, assessment folder, and real-world scenarios.
Honest caveat: this is v1.0, published two weeks ago, zero external
validation so far. I'm sharing it here specifically because I want to
know if this resonates with engineers who've actually tried to introduce
AI agents into their dev pipelines — or if I'm solving a problem that
doesn't exist the way I think it does.
What has your experience been? Did your organization skip levels and
pay for it?

value: Show HN: Guido Scale – maturity model for SDD migration

author: guimiran


value: redmalang

value:
Duffel is a local-network markdown workspace for human + LLM collaboration.
It provides Web UI for browsing and editing notes & Lightweight CLI for search-first retrieval (using qmd).
I've found it to be very helpful for projects that require agents to have a lot of data in certain situations and they are actually quite fastidious about recording learnings and keeping everything tidy.

value: Show HN: Duffel – search centric LLM friendly workspace

author: redmalang


value: elijahlucian

value: Show HN: WaveLoop – A destructive-first looper suite I built in 8 days

author: elijahlucian


value: ndxone

value:
Hi! I have been running Apple Ads for around a year now. Couple days ago I open sourced our Apple Ads toolkit for automation:
* CLI and AI-friendly. this toolkit is being run by our AI agents daily, they use it to research, then update CSV files, log their decisions in git log and then we review PRs and apply updates to campaigns
* export/import data in CSV, store full config of campaigns, keywords, creatives in JSON/CSV
* does not require API access (which is hard/impossible to get for certain Apple Ads Orgs)
this allows us (just me really, I run all the marketing ops...), to scale of what otherwise would be impossible. and allows to fight instability/randomness of Apple Ads performance (git log contains full history of decisions, context, reasons, hypothesis).
inspired by Go analysis framework, I developed multiple "linters" that detect problems with setup, ensures best practices. you run apple-ads analyse keywords and get colorful rich ASCII with histograms, CPI/CVR. I am using very basic statistics for now (nothing beyond simple Bayesian was needed for now, which is why it is in Go).
the power of it, is that normally AI agents (say Claude Opus 4.6) would repeatedly write ad-hoc jq, awk, grep or low-quality Python scripts, which kind of the same. Now, I assembled all these learnings and what AI typically does, cleaned it up, made it better to use (based on typical problems when running it with AI agents in loop), things like time filtering, no-color output, help and documentation (inspired by Go analysis framework I made it self-discovery) so that your agent can just run apple-ads -h and learn how to run it instantly.
It is very much "Ads GitOps". It is is really effective, works well... and free. I think should belong to community. so here you go! if it helps someone save couple bucks that would made my day!
https://github.com/ndx-technologies/go-apple-ads

value: Show HN: Apple Ads Toolkit

author: ndxone

title: Show HN: Apple Ads Toolkit


value: FidelitasLLC

value:
Hi HN,
I’m the founder of Fidelitas LLC. I built HushBrief because I was tired of two things:
The "I can’t help with that" refusal messages from sanitized LLMs when trying to brief sensitive legal or investigative material.
The systemic risk of pasting core IP, depositions, or leaked documents into surveillance-backed models that train on user inputs.
HushBrief is an AI briefing tool designed around a zero-retention architecture.
The Tech Stack:
Inference: We use Venice AI for zero-retention inference (llama-3.3-70b). No training on inputs, no logging, no retention at the provider level.
Stateless Auth: We don’t use traditional accounts or databases for user profiles. Subscriptions are handled via signed httpOnly cookies (HMAC-SHA256).
Zero-Knowledge Architecture: Documents are processed in memory and immediately discarded. There is no database entry that links your identity to the documents you've briefed.
Frontend/Backend: React 18 / Express 5 / PostgreSQL (Drizzle ORM) for subscription status only.
Why this exists:
Standard AI tools have become editorialized and "safe" to the point of being useless for professionals handling raw, controversial, or sensitive legal material. HushBrief includes an "Uncensored Mode" that doesn't soften or refuse to process the document you provide. You get the actual brief, not a sanitized version.
The Friction Problem:
I hate "Magic Links" and forced signups. To make this as accessible as possible for a technical audience, we implemented a $0.99 "Day Pass" via Stripe that sets a 24-hour signed session cookie. No email/password required to use the pro features.
We also have a strictly limited 11-unit Lifetime tier ($99) for early believers who want to support the development of resilient socio-technical infrastructure.
I'd love your feedback on the UX—specifically the 3-theme design system and the Privacy Dashboard (the avatar icon in the navbar) which maps out our data usage framework.
Live at: https://hushbrief.app
I'll be in the comments to answer questions about the architecture or our privacy posture.

value: Show HN: HushBrief – A stateless, zero-retention AI document summarizer

author: FidelitasLLC


value: broskees

value:
Here's Openclaw Carapace, a CLI security scanner for OpenClaw. It audits your configs, flags CVEs, and scans skill files for vulnerabilities.
A few things it does:
- Auto-fix common misconfigurations
- Hardening profiles for typical deployment patterns
- SARIF output so it drops right into GitHub Code Scanning or your CI/CD pipeline
Would love feedback — especially on what checks or hardening rules you'd want to see next.

value: Show HN: OpenClaw Carapace – Security Scanner for OpenClaw

author: broskees


value:
This simulator brings real school lab experiments to any device so students can practise the full workflow:
- set up apparatus
- mix chemicals
- record observations
- write answers, and
- get instant mark-scheme feedback.

value: Show HN: Cambridge AS Level Chemistry Lab Simulator


value: sethuu

value:
Hi HN,
I spent 3 weekends building Rushiram Finance. I wanted a single, reliable place for financial planning without having to worry about my personal numbers being tracked, stored, or sold. As a fun note on the development process, I built this alongside Google Gemini, using it heavily as an AI coding assistant to help bring the project to life.
It features a suite of calculators for SIPs, loans, interest, and taxes.
The biggest technical priority was privacy. The financial calculators run entirely client-side, meaning your sensitive inputs never leave your browser. For full transparency: the site is hosted on Vercel and I use their built-in analytics for basic, anonymous traffic tracking, but absolutely zero personal or financial data is collected or sent to any server.
I’d love for you to try it out. Any feedback on the UI, the accuracy of the calculators, or suggestions for what to add next would be greatly appreciated!

value: Show HN: Rushiram Finance – Privacy-first, client-side financial calculators

author: sethuu


value: Oscardeng

value:
Hi HN,
I noticed people manually copy-pasting data from Excel into PDF forms, but existing solutions require uploading sensitive data (employee info, invoices) to third-party cloud servers.
I built FormFill to do all the heavy lifting entirely in the browser using pdf-lib. It parses the Excel file, maps the columns to your created PDF fields, and generates a .zip of filled PDFs locally.
Because it's 100% client-side:
1. User data never leaves their device.
2. Server computing costs are essentially $0.
You get a few free batch exports just by visiting (no sign-up required). I'd love to hear your feedback on the mapping UI and the pure frontend approach!

value: Show HN: I built a 100% client-side tool to automate Excel-to-PDF filling

author: Oscardeng


value: retlehs

value:
There's a project called tdfiglet that allows you to preview TheDraw fonts (https://www.roysac.com/thedrawfonts-tdf.html) from a CLI, but I wanted a web view to quickly browse through the font archive.
Type some text, pick a font, get ANSI color or plain block output, and filterable by style.

value: Show HN: ANSItype – Browse 900 TheDraw fonts in the browser

author: retlehs


value: arvindrajnaidu

value:
Each level is a JS function turned into a dungeon. if/else = forking paths, loops = corridors, try/catch = parallel chambers.
You forge test inputs as weapons, drag them into parameter slots, and run. Your hero walks the code path. Gems = covered statements. 100% = level complete.
Six levels, from simple branches to async functions with stubs.
Play: https://arvindrajnaidu.github.io/dungeon-coverage/
Source: https://github.com/arvindrajnaidu/dungeon-coverage
Built with PIXI.js, Istanbul for coverage, and [maineffectjs](https://github.com/arvindrajnaidu/maineffect) for isolated function execution.

value: Show HN: Dungeon Coverage – Unit testing as a dungeon crawler

author: arvindrajnaidu


value: yaniszaf

value: Show HN: GraphGPU – Force-directed graph visualization in WebGPU (not WebGL)

author: yaniszaf


value: vhatkarpratap

value:
Hi HN
I recently built PaperDraw.dev, a browser-based system design simulator aimed at helping engineers practice real system design thinking, not just draw static diagrams.
Most tools today are diagramming tools. They help you draw boxes and arrows, but they don’t help you answer questions like:
• What happens when traffic spikes 10×?
• Where does the bottleneck appear?
• How does latency propagate across services?
• What breaks first under load?
That’s the gap I wanted to solve.
What it does
PaperDraw is not just a whiteboard — it’s a simulation engine for system design.
You can:
Drag and drop components like LB, Cache, DB, Queues, Services
Connect them visually
Configure throughput, latency, capacity limits
Run real-time traffic simulations
Watch bottlenecks and failures emerge
It’s essentially trying to make system design more like a flight simulator, instead of a static drawing exercise.
Why I built this
I’ve conducted and taken many system design interviews over the years, and noticed:
People memorize patterns instead of understanding trade-offs
There’s no way to experiment with architectures
Students struggle to visualize scale dynamics
So I built this as a learning + experimentation tool.
Current usage
Launched ~10 days ago:
~1k–1.5k daily users
Mostly from developers preparing for interviews
What I’d love feedback on
Does the simulation concept feel useful?
What components or scenarios should be added?
Would templates for common architectures help?
Try it here: https://paperdraw.dev
Would really appreciate your thoughts

value: Show HN: PaperDraw.dev – A System Design Simulator

author: vhatkarpratap


value:
I built a CSS custom-properties language server and shipped it across VS Code and Zed.
It started as a TypeScript server (`css-variable-lsp`) and now also has a Rust implementation (`css-lsp-rust`).
What works today:
1. Context-aware completion inside `var(...)` (CSS/HTML/JS string contexts).
2. Cascade-aware hover (`!important`, specificity, source order).
3. Workspace-wide definition, references, rename, diagnostics.
4. Color previews/resolution through variable chains.
5. Rust-first distribution with safe fallback to TS/npm when needed.
Repos:
TS LSP: https://github.com/lmn451/css-lsp
Rust LSP: https://github.com/lmn451/css-lsp-rust
VS Code extension: https://github.com/lmn451/css-variables-vscode
Zed extension: https://github.com/lmn451/css-variables-zed

value: Show HN: CSS Variables LSP for VS Code and Zed (Rust-First, TS Fallback)


value: serendip-ml

value: Show HN: SAIA – Typed Contracts for LLM Outputs

author: serendip-ml


value: Show HN: Ralphex – autonomous GPT Codex agent loop for ChatGPT Pro users


value:
Hi,
I've made a Motorola 68000 chip emulator in C11 (called Rocket 68) as a portable C library that can easily be integrated into larger projects. If you want to know more about the project, additional information is available in the links below.
Project's GitHub repo: https://github.com/habedi/rocket68
Project's documentation: https://habedi.github.io/rocket68/

value: Show HN: Rocket 68 – A Motorola 68000 CPU emulator in C


value: kouiskas

value:
I've been helping teams learn how to leverage Claude Code the best and I've built a couple of complimentary tools to help people learn from each other.
This replay TUI, claude-replay, which lets you explore and revisit your past Claude Code sessions. And a companion optional Claude Code plugin, claude-session-trail, to automatically store your sessions in a dedicated git branch: https://github.com/Trailblaze-work/claude-session-trail
Both tools can work in tandem, as the replay client can also read project sessions from the git branch, in addition to its default of accessing the user's local sessions.
This is hot off the press, so there might be some rough edges still, but the base functionality you would expect works. I think they have purpose as learning tools at a minimum, and can be useful for self-introspection.
The automatic committing is probably too much for mature teams, for whom the export/sharing functionalities of specific sessions might be enough.
Yes, models change and what works in terms of prompting strategy now might not work on newer models in the future, but at the moment everyone develops strategies and good habits locally in parallel. Being able to look over someone's shoulders and seeing how they do it might be useful. And it lowers the effort required to share how you work inside Claude Code with others if you wish to do so.
Contributions welcome!

value: Show HN: Claude-replay – Replay your Claude Code sessions

author: kouiskas


value: Show HN: Agent Orchestrator – Built using the agents it orchestrates


value: gunnerlevi

value: Show HN: UMC – Lossless compression that beats lzma by 7-46% on numeric data

author: gunnerlevi


value:
Trust in AI-generated code is falling because models are structurally incapable of verifying their own training data. In Android development, where the ecosystem moves exceptionally fast, AI memory is often twelve to eighteen months out of date.
AndroJack is an open-source MCP server that provides 20 specialized tools for Jetpack Compose, Gradle coordination, and architecture reference. It implements a "Grounding Gate" that intercepts the AI reasoning loop and forces it to verify official documentation live.
We built this after facing constant hallucinations in a high-stakes healthcare app. It is now live as version 1.3.1. We invite technical feedback on the toolset and suggestions for further grounding strategies.

value: Show HN: AndroJack – A grounding gate for Android AI assistants


value: dahaleonkar

value:
Hi HN,
Japan is the world's 4th largest stock market, but its financial data is stuck in the 90s. Corporate filings go through EDINET — a government system that stores everything as XBRL in Japanese, with 3 different accounting standards (JP-GAAP,IFRS, US-GAAP), company-specific taxonomies, and no usable API.
I've been working with Japanese XBRL filings for 2 years. I built a parser that normalizes all of it into structured JSON. Axiora now covers 4,125 listed companies with ~10 years of history and 52 financial fields per company-year.
Built for developers:

  · REST API with full OpenAPI spec — https://axiora.dev/docs
  · Python SDK: pip install axiora
  · LangChain integration: pip install langchain-axiora (20 tools)
  · MCP server for Claude, ChatGPT, Cursor, etc.
  · llms.txt at axiora.dev/llms.txt

Try it now, no signup: https://axiora.dev/terminal
Roadmap: TDNet integration (real-time timely disclosures from JPX) and stock prices are next. Data licenses are expensive and I'm bootstrapping this solo, so those will come as paid tiers.
Tech: Python/FastAPI on Cloud Run, Supabase (Postgres), lxml for XBRL parsing.
Free tier: 10,000 req/day. I'd love feedback on the API design or what data would be most useful.

value: Show HN: I parsed 10 years of Japanese corporate filings into an API

author: dahaleonkar


value: ddesposito

value:
Hi there, are you familiar with MBTI, DiSC, Big Five? Well I'm experimenting with a new kind of personality test, Archetype 360, and I'd love for you to try it for free and tell me what you think.
- 24 traits across 12 opposing pairs -- that's three times more dimensions than MBTI or DiSC, so you get a much more nuanced profile.
- A unique narrative report generated with AI (Claude), written in natural language instead of generic type blurbs.
- Your role, goals, and current challenges are blended into the analysis, so the report feels relevant to your real‑life context, not just abstract traits.
It's an "ephemeral app" so your report only lives in your browser, there's no login, and we don't store your data. Make sure you save the report as a PDF before you close the page.
What I'm looking for is honest feedback on your archetype and report:
- Did it feel accurate and "wow" or just meh?
- Did you learn anything unexpected about yourself?
- What did it miss or not go deep enough on?
I'll use your feedback to refine the prompts and the underlying model. Just comment here or use the feedback form in the app.
If there's enough interest, the next step is to combine Archetype 360 with a variation of Holland Codes / RIASEC (vocational interest areas) to create a full‑power professional orientation report.
What else would you love to see? Ideas welcome!
Best wishes,
Daniel

value: Show HN: Try Archetype 360 – AI‑powered personality test, 3× deeper than MBTI

author: ddesposito


value: statictype

value:
Hi
This is an itch I've been meaning to scratch for some time.
https://glint.statictype.org/
Glint is a simple utility that lets you double-click xlsx and docx files in Finder and open them in your Google account.
I don't use Office and I don't like Numbers and Pages. My current workflow is to open Google Sheets/Docs and manually import files that are shared with me. Its a tedious process, and Google's design sense doesn't make it any easier.
This app tries to solve that.
It registers file handlers for .xlsx and .docx. It uploads the file the first time you open it. After that, it adds some metadata to the file so next time you open it, it directly opens the existing Google Doc without trying to upload it again.
This is the kind of utility app that exists because of agentic coding tools like Codex and Claude Code.
This problem has been an annoyance for years but not annoying enough that I wanted to spend time wading through the quagmire of Google Docs APIs and credentials and re-learning macOS UI programming with Swift.
I tried Codex for this, and while I still prefer Claude Code by a good margin, Codex pretty much one-shotted a rough version of what I wanted.
Let me know what you think!

value: Show HN: Open Finder files in Google Docs with one click

author: statictype


value: kundi

value: Show HN: Open-source Loom / Screen Studio with editing and auto-zoom

author: kundi


value: naxtsass

value:
Hi HN,
I’ve been tracking the recent surge in Grok’s AI capabilities. According to the latest search data, "Grok Imagine 1.0" is seeing breakout growth, but there is a massive (+180%) spike in developer interest for the API side, specifically for video.
I built grokimagine2.net to serve as a hub for what’s coming next in the Grok ecosystem. It focuses on the transition from image generation to high-fidelity video (which is currently the #1 trending topic in the niche).
I'd love to get your thoughts on:
The feasibility of Grok’s video model compared to Sora 2 or LTX.
What you’d like to see in a "Version 2.0" API for these types of generative models.
Open to feedback on the UI and the data!
website: https://grokimagine2.net

value: Show HN: Grok Imagine 2 – A preview of the next-gen Grok AI video ecosystem

author: naxtsass


value: appmuzzik

value:
I built Vynix, a cross-platform mobile app (iOS/Android) that aggregates 100+ AI models into a single interface. Instead of switching between different AI apps, you get image generation, video creation, TTS, music generation, and LLM chat all in one place.
Tech stack:
- Kotlin Multiplatform + Compose Multiplatform (shared UI across iOS & Android)
- Firebase (Auth, Firestore, Cloud Functions)
- Backend proxies to Replicate and fal.ai APIs
- Credit-based system — no subscriptions required
The app adds new models within days of their public availability. Currently includes models for:
- Text-to-image (multiple styles: photorealistic, anime, digital art)
- Text-to-video and image-to-video
- Text-to-speech (50+ voice options)
- AI music generation
- LLM chat (multi-modal)
Free to try — you get 40 credits on signup + daily free credits.
Website: https://vynix.app
Happy to answer questions about the KMP architecture, the API aggregation approach, or anything else.

value: Show HN: Vynix – Mobile app with 100 AI models for image/video/audio generation

author: appmuzzik


value: tonyww

value: Show HN: Predicate-Claw – Run Time Assurance (RTA) for OpenClaw via Rust Sidecar

author: tonyww


value:
MoodJot is a mood tracking app I built solo using Kotlin Multiplatform and Compose Multiplatform. It ships on both iOS and Android from a single codebase.
The main differentiator from existing mood trackers (Daylio, DailyBean, etc.) is a community feed where users can share moods and see how others are feeling.
Technical details:
- Compose Multiplatform for shared UI (31 screens)
- GitLive Firebase KMP SDK for Firestore, Auth, Storage
- ChatGPT integration for AI mood pattern analysis via Ktor
- expect/actual for StoreKit 2 (iOS) and Play Billing 7.0 (Android)
- Home screen widgets: SwiftUI WidgetKit (iOS) and RemoteViews (Android)
- Custom localization: 5 languages without platform string resources
- Kamel for cross-platform image loading, multiplatform-settings for persistence
Other features: photo attachments, 10-point intensity scale, 80+ trackable activities, 25+ achievement badges, 14 emoji themes, goal tracking.
Live on App Store and Google Play since November 2025.
https://moodjot.app
Happy to discuss the KMP architecture or any design decisions.

value: Show HN: MoodJot – Mood tracker mobile app with community feed, built with KMP


value:
I still read/post in small communities over NNTP and always wanted usenet client that is modern and easy to use on macOS/iOS, so here it is.
95% agentic (not vibed) coded, just because I can and wanted to see if I'm able to drive AIs to build something that is usable :)
Coming soonish to AppStore, ofc.

value: Show HN: Clean Express – a native NNTP/Usenet client for iOS/macOS/visionOS


value:
I built 59 single-file CLI tools because I was tired of:
- pip install hell for simple tasks
- Leaving terminal to use web converters
- Writing "quick scripts" that took 2 hours
Everything is zero-dependency Python. Copy, paste, run.
Highlights:
• HTML → Markdown converter (with article extraction)
• JSON formatter with validation
• Port scanner with banner grabbing
• Password generator with entropy analysis
• Duplicate file finder (saved me 40GB)
• Git repo health analyzer
• SSL certificate inspector
• 52 more...
All MIT licensed. No signup. No dependencies.
Live: https://workspace-ivory-one.vercel.app
Repo: https://github.com/barrowryan89-cloud/pd-researcher (currently mirroring to Vercel)
Would love feedback on which tools you'd actually use.

value: Show HN: Free CLI Tools – Zero Dependencies, MIT Licensed


value:
I built a simple, fully client-side AI watermark remover that runs entirely in the browser—no images are uploaded to any server, no accounts needed, no ads or watermarks added on output.
It targets common AI-generated watermarks like those from Grok, Gemini (Nano Banana / Imagen), Midjourney, etc., using a combination of inpainting heuristics and basic diffusion-style filling tuned for small logo/text overlays. (It's not a full advanced model like Lama or anything cloud-heavy—just lightweight JS + Canvas/WebAssembly ops for speed and privacy.)
Why this exists:
People keep asking for free, private ways to clean up watermarks from fun/experimental AI outputs without trusting third-party sites.
Most online removers upload your image (privacy risk) or add their own branding/paywalls.
This one keeps everything local, works on phones too, and is zero-friction.
Try it here: https://tools.geeksprep.com/ai-watermark-remover
(Drag/drop or paste image → process → download PNG)
Feedback welcome: Does it handle your specific watermarks well? Any edge cases (e.g., large/overlaid text)? Suggestions for improvements? Bugs? Happy to iterate if it's useful.
It's part of a bigger free tools collection at tools.geeksprep.com (200+ utilities, all client-side/privacy-focused).
Thanks for looking!

value: Show HN: Browser-Based AI Watermark Remover – No Uploads, Client-Side Only


value:
Hey HN,
I built Ledge because I kept seeing demos of AI agents with wallet keys in their .env files, and thought "this is going to end badly."
The core idea: put a policy layer between your agent and the wallet. Before any payment executes, it runs through 4 checks (technical validation, policy limits, context coherence, behavioral patterns). Agent can pay for APIs/data autonomously, but only within rules you set.
Example: your research agent has a $10 budget. It can pay $0.01 per API call for data feeds. But if it tries to send $50 to a random address, or hits the same endpoint 100 times in a minute, Ledge blocks or escalates it.
Built for x402 (pay-per-request protocol), but designed to be modular for other payment rails. Python SDK, supports KMS/Turnkey for production.
Main questions:
- Is this solving a real problem or am I overthinking agent security?
- What policies would you want that aren't here?
- Anyone else building agents that need to pay for stuff?
GitHub: https://github.com/Devendra116/ledge
Would love feedback, especially from folks building autonomous agents or working with crypto payments.

value: Show HN: Ledge - Policy layer for AI agent payments (prevents unauthorized txns)


value: stinger

value:
Have you clocked in yet?
I built Local Hours, a simple time tracking / timesheet app that treats your data as plain files instead of rows in someone else’s database.
No accounts, no backend – All time entries and timesheets are JSON files in a folder you pick. Sync happens via iCloud / Dropbox / OneDrive if you want it.
Cross-device by design – The macOS menu bar app and iOS app both point at the same folder, so they “sync” via your storage provider without any server code.
Timesheets, not dashboards – The main job is: track time, then generate a weekly/bi-weekly/monthly timesheet you can actually send to an approver.
Exports that don’t trap you – You can send an email with an embedded summary + CSV, or just open the JSON files yourself.
Privacy – No analytics, no telemetry, no in-app purchases. It’s MIT-licensed and fully open source.
Apps are free on the App Store (iPhone, iPad, Mac):
https://apps.apple.com/us/app/local-hours-simple-timesheet/i...
Repo (code, storage format, docs, screenshots):
https://github.com/gogrinimish/LocalHours
I’d especially like feedback on:
Does the “just files” approach line up with how you’d want to archive or script your own timesheets?
Is the UX for picking the storage folder and sharing it across devices clear enough?
What’s missing for you to actually use this for client work?

value: Show HN: Local Hours – Time tracking that's just files (no accounts)

author: stinger


value:
I got tired of juggling 20+ tabs for basic utilities (JSON formatting, PDF merging, regex testing, image resizing, fake document generators, etc.), so I built a single, fully client-side hub with over 200 tools that run entirely in the browser.
Key points:
Everything processes locally—no server uploads, no data leaves your device, no sign-ups, no ads, no tracking.
Works offline after the initial load (progressive web app vibes).
Categories include: Developer Tools (JSON/YAML/CSV/Regex/Base64/Epoch/etc.), PDF Tools (merge/split/compress/convert/extract), Image Tools (resize/compress/watermark remover/background remover/OCR), Encoding & Security, SEO & Network utilities, AI-assisted tools (e.g., ATS resume checker/roaster), Finance calculators (GST/salary/tax), Document & Fake Generators (resumes/invoices/fake chats/tickets/etc.), and more niche ones.
Built with plain HTML/JS/Canvas/WebAssembly where needed—lightweight, fast, mobile-friendly.
Live here: https://tools.geeksprep.com/
Why share now:
Started as a personal productivity fix for devs/designers/job seekers in India (Bengaluru-based side project).
Grew to 200+ tools via user requests and iterative additions.
Privacy angle is core: In a world of upload-heavy "free" tools, this keeps your data yours.
Would love honest feedback from HN:
Which tools are actually useful (or broken)?
Missing must-haves in dev/productivity space?
Performance/edge cases on large files or specific browsers?
Suggestions for better UX or new categories?
It's open for iteration—happy to add/fix based on real input. Thanks for checking it out!
(Part of the broader GeeksPrep career prep platform, but this tools subdomain is 100% free/independent.)

value: Show HN: Free Browser-Based Tools Client Side Only, No Uploads, No Tracking


value: daxaur

value: OpenPaw is an open-source toolkit that turns Claude Code into a full personal assistant. One command (npx pawmode), 38 skills — email, calendar, Spotify, smart home, notes, and more. No daemon, no cloud, mo extra cost beyond your existing Claude subscription.

value: Show HN: I turned Claude Code into a personal assistant

author: daxaur


value: askmuyukani

value:
Hey HN,
Over the last few years, we’ve seen an explosion of Python and TypeScript frameworks trying to wrangle LLMs. The problem is that they are bolting non-deterministic, probabilistic compute onto deterministic, sequential languages. You end up with 500 lines of Pydantic models, JSON-parsing retry loops, and async spaghetti just to coordinate two agents.
I built Turn (https://turn-lang.dev) to solve this at the language level. It is a statically-typed, compiled language with a custom Rust bytecode VM, designed specifically to treat LLMs as native ALUs.
The three core primitives of Turn:
Cognitive Type Safety (infer Struct): You define a standard struct, and call infer. The VM natively handles the schema constraints at the inference provider level. No manual parsing, no regex hacks. If you ask for a TradeDecision { action: Str, size: Num }, the VM guarantees you get a strongly-typed TradeDecision struct back.
Probabilistic Routing (confidence): Because LLMs hallucinate, confidence is a native binary operator. You can write control flow like: if confidence decision < 0.85 { return Fallback }. The VM inherently tracks the uncertainty of variables.
Erlang-style Actors (spawn_link & receive): Multi-agent orchestration in Python is a race condition nightmare. Turn uses an Actor model. Agents run in isolated VM threads (spawn_link) and communicate strictly via zero-shared-state mailboxes (receive).
Turn currently supports Anthropic, Azure OpenAI, standard OpenAI, Google Gemini, xAI Grok, and Ollama out of the box natively via a single environment variable—no SDKs required.
Here is an example of a multi-agent quantitative hedge fund written natively in Turn: https://turn-lang.dev/docs/quant-syndicate
The Rust VM source is open here: https://github.com/ekizito96/Turn
You can test the language live in the browser using your own API keys in our sandboxed playground. Would love to hear your thoughts on treating LLMs as native compute targets at the language level rather than just API wrappers.

value: Show HN: Turn – A compiled systems language for agentic computation

author: askmuyukani


value: appmuzzik

value:
I built CosmicMeta.ai, a tech platform that publishes daily analysis on AI,
machine learning, and emerging tech.
The interesting technical bit: every article goes through a two-pass
humanization step that detects and rewrites 24 specific AI writing patterns
(significance inflation, copula avoidance like "serves as" instead of "is",
em-dash overuse, formulaic conclusions, etc.). It's based on research from
the blader/humanizer framework.
Tech stack: Spring Boot, OpenAI + Perplexity APIs, WordPress for publishing,
Firestore for data. The pipeline is fully automated - from topic selection
to research to writing to humanization to publishing.
I'm curious what HN thinks about the humanization approach. Is stripping AI
patterns enough to make AI-generated content genuinely useful, or is there a
deeper issue with AI-written tech analysis?
https://cosmicmeta.ai

value: Show HN: CosmicMeta – Daily AI and tech analysis with a humanization pipeline


value: bjpless

value:
We're a team of founding Plaid engineers, backed by the funds of the Plaid CEO and Max Altman.
https://res.cloudinary.com/dxxog3y9j/image/upload/v177246957...
We've to build a conversationa way to talk to your money. It lives entirely in Claude right now -- no standalone mobile or web app.
To our knowledge, there are few, if any, full-featured consumer apps that exist entirely as MCP servers. We believe that's chat surfaces with MCP servers will become the primary user interface of the future.
The user experience is genuinely very cool, from cleaning your Plaid transaction history to projecting future cash balances.
We initially started with ChatGPT for obvious distribution reasons but found that Claude is the only viable option right now for consumer MCP experiences due to its multi-tool calling  ability -- it's critical.
A potential next step goal with this project is to make it self-hosted and remove all third-party data sharing, aside from your bank.

value: Show HN: MCP server ONLY app for personal finances

author: bjpless


value:
I built a free URL shortener with features that competitors
typically charge $20-200/month for.
What it does:
- Bulk API: shorten up to 100 URLs in one POST request
- QR code generation: PNG + SVG, customizable sizes (100-2048px)
- Click analytics: GeoIP (MaxMind) for country/city, device
  classification, browser detection, UTM parameter preservation
- Custom short codes: 4-20 alphanumeric characters
- Hash-based deduplication: same URL = same short code, deterministic
- Redis caching layer for sub-millisecond redirect lookups
- URL sanitization for malformed Unicode characters
Why I built it:
Most URL shorteners either charge for analytics and QR codes,
or limit their free tier so aggressively that it's unusable for
real work. I wanted something API-first, with real analytics,
that I could use in my own projects without hitting paywalls.
Tech stack: Spring Boot 3.4, MySQL, Redis (Jedis), MaxMind GeoIP2,
ZXing for QR codes.
Try it: https://u2m.io
Happy to answer technical questions about the architecture or
design decisions.

value: Show HN: U2m.io – Free URL shortener with bulk API, QR codes, and geo analytics


value: emanuele-em

value:
  I built this over the past couple of years as a way to inspect HTTP/HTTPS traffic (learning project). It started as a Tauri desktop app but I recently simplified the whole thing — dropped the
  desktop GUI and replaced it with three simpler interfaces (TUI with ratatui https://github.com/ratatui/ratatui, terminal, web) that you pick with a CLI flag.

  The proxy intercepts both HTTP and HTTPS, works as a forward or reverse proxy, and lets you search and drill into individual request/response pairs. The TUI is the default — it gives you a live table of traffic
  with detail panels. The web interface streams everything over WebSocket if you prefer a browser. Terminal mode just prints colored lines, useful for piping or logging.

  Setup is pretty minimal — install, run, point your system proxy at it.

  Happy to hear feedback or ideas. Still a lot I want to improve.

value: Show HN: Proxelar – MitM proxy with (rata)TUI, terminal, and web interface

author: emanuele-em