Show HN for January 15, 2026

Here's a video of the product: https://www.youtube.com/watch?v=Sgk9Z-nAjC0

Claude Code has been our go-to for 4 months. When Opus 4.5 dropped, parallel agents stopped needing so much babysitting. We started trusting it with more: building features end to end, adding tests, refactors. Stuff you'd normally hand off to a developer. We started running 3-4 at once. Then the CLI became annoying: too many terminals, hard to track what's where, diffs scattered everywhere.

So we built 1Code.dev, an app to run your Claude Code agents in parallel that works on Mac and Web. On Mac: run locally, with or without worktrees. On Web: run in remote sandboxes with live previews of your app, mobile included, so you can check on agents from anywhere. Running multiple Claude Codes in parallel dramatically sped up how we build features.

What’s next: Bug bot for identifying issues based on your changes; QA Agent, that checks that new features don't break anything; Adding OpenCode, Codex, other models and coding agents. API for starting Claude Codes in remote sandboxes.

Try it out! We're open-source, so you can just bun build it. If you want something hosted, Pro ($20/mo) gives you web with live browser previews hosted on remote sandboxes. We’re also working on API access for running Claude Code sessions programmatically.

We'd love to hear your feedback!

What is this? A local TUI (like Claude, Codex, Gemini, OpenCode or Copilot) that wraps your agent and sends each turn to an email in a nice format.

What does it enable? It lets you email your agents. And them email you. So They Keep Working on the tasks you want, and You go and do What You Want. No need to stay at your desk. Be free.

I built this for me, but thought others would find it useful, so I turned it into a product. I want get outside, and away from my desk, but still have the agents work.

The accidental killer feature: You can CC your team. If you forward the thread to a coworker, their reply goes straight to the agent context too. It turns a local session into an async multiplayer thread.

Works out of the box with Claude, Codex, Gemini, Copilot, and OpenCode. Happy to answer questions!

https://mailpilot.chat

Problem we're trying to solve: Writing API tests is tedious, and hand-written mocks drift from reality. We wanted tests that stay realistic because they come from real traffic.

versus mocking libraries: Tools like VCR/Nock intercept HTTP within your tests. Tusk Drift records full request/response traces externally (HTTP, DB, Redis, etc.) and replays them against your running service, no test code or fixtures to write/maintain.

How it works:

1. Add a lightweight SDK (we currently support Python and Node.js)

2. Record traffic in any environment.

3. Run `tusk run`, the CLI sandboxes your service and serves mocks via Unix socket

We run this in CI on every PR. Also been using it as a test harness for AI coding agents, they can make changes, run `tusk run`, and get immediate feedback without needing live dependencies.

Source: https://github.com/Use-Tusk/tusk-drift-cli

Demo: https://github.com/Use-Tusk/drift-node-demo

Happy to answer questions!

Doing this naively takes cubically many operations in the number of layers (so impractical), but it's possible to do this in time linear in the number of layers (so very practical)! This is possible because the Hessian of a deep net has a matrix polynomial structure that factorizes nicely. The Hessian-inverse-product algorithm that takes advantage of this is similar to running backprop on a dual version of the deep net. It echoes an old idea of Pearlmutter's for computing Hessian-vector products.

Maybe this idea is useful as a preconditioner for stochastic gradient descent?

The result is a surprisingly useful policy/gating layer– these tables let your team:

- Write multi-factor, exception-friendly policies (e.g. deny rm -rf / when --force; allow cleanup only in node_modules; ask on network calls like curl/wget; block kubectl delete or SQL DROP, each with a clear reason)

- Roll out policy changes instantly (mid-run, flip a risky operation from allow → ask; the next attempt across devs and agents is gated immediately– no git pull, agent restart, or coordination)

- Adopt lightweight governance that survives churn (MCP/skills/etc): just add columns/rules as new tools and metadata show up

- Get a quick central utility to understand which tools are being used, which tools get blocked most often, and why

In the interest of learning new tools I decided to vibe code it as much as possible.

First, I had Claude Code write a background script to download images of the real-time circuit diagram of the subway, which are publicly available here: http://sfmunicentral.com/

Next I had it build an image labeler tool in tkinter, which turned out to need a lot of manual tweaking before I could even get to the labeling. Seemed like the right tool for the job, but it would have saved time if I'd built it from scratch myself.

The most interesting part was turning the labeled image data into predictions with pytorch. Claude wrote the initial script fairly quickly, but as these things go it required manual tweaking and second guessing myself on the images flagged as outliers. I'll admit I got embarrassingly far along before realizing that Claude hadn't enabled pytorch's GPU support; a real facepalm moment on my part.

For those curious, brave, or crazy enough to dive in the source code is available here under an MIT license: https://github.com/MrEricSir/munimet.ro

Mathematica Successūs is my attempt to model the "Self" as a control system. It argues that stability is only possible when your regulator's variety matches environmental disturbances (Ashby's Law).

It is a short (59-page) technical manual written in LaTeX. It treats burnout not as a feeling, but as a system constraint violation. It relies on mathematical rigor, not coaching fluff.

Over the last few years, I've been building an app to learn languages. It supports ~85 languages and ~40 dialects, and is optimized for learning and maintaining multiple languages.

Learning a language is a ton of work, but really quite simple. Find text you're interested in, dissect and understand it, and review it often. Grind that every day for a few years, and you'll be fluent.

So I built Phrasing for 4 main reasons:

1. To have an app I would actually be excited to use every single day for years.

2. To do all the research, explanation, prioritization, course planning and management for me, so I could just focus on learning

3. To support learning multiple languages as a first class citizen

4. To have a nice, unified interface to learn languages from Spanish to Arabic to Cantonese

I've been using it daily now for almost a year to learn a variety of languages and I've been loving it. I have an awesome group of users in the Telegram channel who have been using it as well to great success.

If you're a polyglot, an avid language learner, or someone who tried to use Anki in the past but found it wasn't for them — I think you might really like Phrasing :)

--

PS: Phrasing uses FSRS under the hood, so a huge thank you to the FSRS team and Jarrett Ye for all the amazing work. Phrasing would not be the product it is without you!

PSS: I'm documenting some of the latest updates on the blog this week, they're 50% product and 50% technical, might be of special interest to the HN crowd: https://phrasing.app/blog/launch-week-1

Try Beni AI here: >> https://thebeni.ai/

I built Finsuba Premium to solve a problem I kept running into while trading:

Most sites highlight “top gaining stocks” over a fixed time window (e.g. 9:30–4:00), but that often hides the actual tradeability. A stock can finish the day up big while offering very different outcomes depending on when you entered and exited.

Finsuba Premium sends a daily and weekly email showing the top-performing U.S. stock trades, based on identifiable entry and exit points rather than broad time-based gains. It includes:

- exact entry time & price - exact exit time & price - trade duration and performance

It’s not a signal service or alert system. Everything is processed at the end of the trading day and ran through minute by minute. I built this for traders who want to improve by reviewing winning setups consistently, rather than reacting to alerts in real time.

Link: https://www.finsuba.com/premium/

Happy to answer questions about how the trades are selected, the data pipeline, or the product itself. Feedback very welcome.

The main twist: I decided to see how far I could get using Claude Code for the firmware. That and the web emulator were written almost entirely using Claude Code (Opus 4.5). I've kept the full prompt history here: https://github.com/gzalo/microcomputer/blob/main/ai_prompts....

It was able to create the emulator in just a few prompts! It really surprised me that it was able to make a WebAssembly version from the same code (compiled with emscripten) and get the physical layout of the panel from a given photo. It also created some simple working examples using 8086 instructions!

Repository: https://github.com/gzalo/microcomputer

I had hours of B-roll and long-form content, but finding a specific 5-second clip (e.g., "a red car passing by" or "a specific quote about React state") meant manually watching the footage at 2x speed.

What I built: Matriq indexes video content visually and aurally. It uses multimodal embeddings to understand scene context, action, and dialogue.

The Use Case:

While it works for general editing, I’ve found the best use case is Content Repurposing. Creators with 100+ hours of archives can now instantly find "viral hooks" or specific topics to turn into Shorts/Reels without re-watching old footage.

It’s in beta. I’d love you to try breaking it or give feedback on the retrieval accuracy.

Link: https://matriq.video

We’re building Beni for users who want an AI that feels like a real presence rather than a scripted chatbot. Try it here: >> https://thebeni.ai/

What’s different? Simple, drag & drop reordering, keyboard shortcuts, color labels. There’s a live demo on the landing page so you can try it without signing up.

Free accounts can create 1 list. Premium is $5/month for up to 25 lists + shareable lists. What do you think?

I built it with Next.js 16 + Turso/libSQL + Drizzle + Better Auth + Stripe.

https://www.chklst.xyz/

Would love feedback on onboarding, UX, and pricing.

Thanks everyone!

How it works 1. Upload from the iOS, iPad or Mac app 2. Get a shareable link 3. Recipients download in the browser, no app, no account, nothing to install

Encryption model Files are encrypted on device using AES 256 GCM before upload. The encryption key lives only in the URL fragment (after #), which browsers never send to servers. Even if the link is intercepted in transit, the file cannot be decrypted without the fragment. The server never sees plaintext or keys.

Native Mac app Built with Mac Catalyst and full bidirectional drag and drop. Drag files onto the app to upload. Drag files out of the app to save them anywhere. No save dialogs, no friction. It feels like moving files in Finder.

What I optimized for • No file size limits • No compression, original quality preserved • Links do not expire unless you delete them • Native Apple UX for senders, universal browser access for recipients

The goal was something my non technical family could use to receive files securely without walkthroughs, accounts or app installs.

I would love feedback on the encryption approach and the UX, especially from people who have built or reviewed similar systems.

Web: https://stash-app.xyz

Currently we give access to 3090s and 4090s for free users; paid users get access to all GPUs.

So I built Silent Earth—a standalone forensic engine (Python/React) to audit them mathematically.

The Stack: * Ingestion: Scrapes Verra/Gold Standard registries for project coordinates. * Telemetry: Queries the Sentinel-2 Satellite Constellation (via Microsoft Planetary Computer). * Analysis: Calculates NDVI (Biomass Density) and performs spectral analysis on the claimed area. * AXIOM Kernel: Cross-references industrial "shutdown" claims against Tropospheric NO2 levels (Sentinel-5P).

The Result: I routinely find "Verified" assets with an NDVI < 0.2 (Bare Soil).

The tool is currently local-only for privacy, but I'm moving the data stream to Snowflake.

Happy to answer questions about the geospatial stack (Rasterio/Shapely) or the satellite APIs.

I made an interactive guide showing why neural networks need specific training techniques.

Start with a simple network trying to learn x². Each section introduces a problem like gradient explosion or dead neurons and shows the fix that solves it using ReLU activation, He initialization, gradient clipping, and momentum.

All code is editable and runs in the browser.

The approach: you pick a standard domain (CRM, task manager) and make it weird. Your CRM becomes a cat fashion store. Your task manager becomes a heist planner. You learn the same enterprise patterns (multi-tenancy, permissions, theming, i18n) but end up with something that's not the 500th identical portfolio project.

The first challenge is free. Curious what HN thinks about this approach to teaching architecture patterns, and whether the "pick your weird domain" angle actually helps with motivation or just adds confusion.

  It reads your Mac's ambient light sensor and considers:
  - Time of day (morning, afternoon, evening, night)
  - Ambient light level (dim, office, bright, daylight)
  - System dark/light mode
  - Weather conditions
  - Power source (AC vs battery)

  A background daemon watches which themes you use and builds a Bayesian model of your preferences. Over time it learns things like "in dim evening light, they prefer high-contrast dark themes with muted colors."

  Once it has enough data, it can generate a custom theme optimized for your current context.

  ghostty-ambient              # Interactive picker with recommendations
  ghostty-ambient --ideal      # Generate optimal theme for current context
  ghostty-ambient --stats      # See what it's learned about you

  Install: uv tool install ghostty-ambient or pip install ghostty-ambient

  GitHub: https://github.com/gezibash/ghostty-ambient

  Built for Ghostty (https://ghostty.org) but the Bayesian preference learning could apply to any theming system.

It lets you run agent harnesses like Claude Code or Codex in the cloud, giving each session its own isolated microVM with filesystem and shell access.

The repo is: https://github.com/moru-ai/moru

Each VM is a snapshot of a Docker build. You define a Dockerfile, CPU, memory limits, and Moru runs the build inside a Firecracker VM, then pauses and saves the exact state: CPU, dirty memory pages, and changed filesystem blocks.

When you spawn a new VM, it resumes from that template snapshot. Memory snapshot is lazy-loaded via userfaultfd, which helps sandboxes start within a second.

Each VM runs on Firecracker with KVM isolation and a dedicated kernel. Network uses namespaces for isolation and iptables for access control.

From outside, you talk to the VM through the Moru CLI or TypeScript/Python SDK. Inside, it's just Linux. Run commands, read/write files, anything you'd do on a normal machine.

I've been building AI apps since the ChatGPT launch. These days, when an agent needs to solve complex problems, I just give it filesystem + shell access. This works well because it (1) handles large data without pushing everything into the model context window, and (2) reuses tools that already work (Python, Bash, etc.). This has become much more practical as frontier models have gotten good at tool use and multi-step workflows.

Now models run for hours on real tasks. As models get smarter, the harness should give models more autonomy, but with safe guardrails. I want Moru to help developers focus on building agents, not the underlying runtime and infra.

You can try the cloud version without setting up your own infra. It's fully self-hostable including the infra and the dashboard. I'm planning to keep this open like the upstream repo (Apache 2.0).

Give it a spin: https://github.com/moru-ai/moru Let me know what you think!

Next features I'm working toward:

- Richer streaming: today it's mostly stdin/stdout. That pushes me to overload print/console.log for control-plane communication, which gets messy fast. I want a separate streaming channel for structured events and coordination with the control plane (often an app server), while keeping stdout/stderr for debugging.

- Seamless deployment: a deploy experience closer to Vercel/Fly.io.

- A storage primitive: save and resume sessions without always having to manually sync workspace and session state.

Open to your feature requests or suggestions.

I'm focusing on making it easy to deploy and run local-first agent harnesses (e.g., Claude Agent SDK) inside isolated VMs. If you've built or are building those, I'd appreciate any notes on what's missing, or what you'd prioritize first.

Grain OS and Clutch OS are the same operating system—a minimal, safety-first OS in pure Zig targeting RISC-V—with different aesthetic and philosophical identities. Grain OS (teamcarry11/xy-mathematics) emphasizes growth and cultivation, inspired by Aquarius energy from classical Vedic astrology. Clutch OS (teambrick06/yz) emphasizes mechanical precision and framework-enabling, inspired by Virgo Gemini Cancer energy. The technical codebase is shared; the human-facing semantics differ.

Inspired by TigerBeetle's precision, SixOS's (NixOS with s6) service management, Urbit's identity model, Plan 9's simplicity, vegan food forests, Y2K culture, traditional urbanism, and Modern Money Theory. The goal is to enable parallel evolution of ideas with different philosophical foundations while maintaining technical compatibility.

I'm working on this with Glow G2, an AI assistant that helps coordinate the 24-agent development team. I'm also working on turning this project into a nonprofit 501(c)(3) and am interested in Y Combinator's program. The specification document outlines the architecture, rationale, and spiritual foundation: Grain Synonym Variant System Specification

Would love feedback on the variant system concept and whether semantic diversity in OS development resonates with this community. Thanks!

I am building RepoEngine to solve a problem I encountered as a backend engineer. Once a codebase grows into multiple repositories, documents, and teams, it becomes tough to track context or find the code for a specific feature/functionality. Even if it becomes harder to know in which context a decision was taken to implement it that way.

To overcome these issues, I have started building a systematic approach in RepoEngine, which unifies your repositories, docs, and decisions into a knowledge layer you can actually build on (onboarding flows, internal agents, automated docs, etc.).

What it does: - Multiple Repositories at once. ( that's from an organisation's repositories or even from personal profiles' selected repositories) - Ask questions across repos + docs and get answers with citations. - Every answer links to the exact sources (files, Notion pages, Slack threads, Jira tickets, etc.). - It indexes structure/meaning but doesn’t store your source code. - Connect GitHub, GitLab, Notion, Google Drive, Dropbox, Confluence, Slack, Jira, and Linear.

This is early, and I’m actively seeking feedback from people working with large or messy codebases. I really want a product that captures the shared context of decisions/directions taken to build a feature.

Would love feedback on the product direction, integrations you want, and how teams want to use this day‑to‑day. https://repoengine.com

Key innovations:

- Runtime dependency discovery: Actions can extend the build graph during execution. Your protobuf compiler discovers outputs naturally. No preprocessing hacks.

- Economic optimization: First build system to compute Pareto-optimal build plans across cost/time. A 2-min build at $12 vs 8-min at $2 – both valid depending on your constraints.

- Built in D with SIMD-accelerated BLAKE3 hashing, lock-free Chase-Lev work-stealing, arena allocators.

- 28 languages supported with unified handler architecture.

- Migration tools for Bazel, CMake, Maven, Gradle, Make, Cargo, npm.

Install: brew tap GriffinCanCode/bldr && brew install bldr

Happy to answer questions about the architecture!

Other features: - Binary delta patching for firmware/OTA updates - Block-level random access - 10x+ compression on logs - Genomic data: 4:1 on 2-bit encoded DNA, 111,000:1 with reference compression - Parallel compression, 1GB/s+ decompression

https://github.com/powerhubinc/crystal-unified-public

*Live demo:* https://verityngn.streamlit.app

*Documentation:* https://hotchilianalyticsllc.mintlify.app

*Repo:* https://github.com/hotchilianalytics/verityngn-oss

*Substack Article:* https://ajjcop.substack.com/p/i-built-an-ai-that-fact-checks...

### The Problem

Existing fact-checking tools only analyze text transcripts. They miss on-screen graphics, visual demonstrations, and the multimodal nature of video. Worse, when you search for evidence, you often get promotional press releases that confirm false claims because the misinformation ecosystem is SEO-optimized.

### How VerityNgn Works

1. *Multimodal analysis*: Uses Gemini 2.5 Flash (1M token context) to analyze video frames at 1 FPS — audio, OCR, visuals, and transcript together. 2. *Intelligent Segmentation*: Automatically calculates optimal segment sizes based on model context windows (reduces API calls by 86% for typical 30-min videos). 3. *Enhanced claim extraction*: Multi-pass extraction with specificity scoring (0-100) and "absence claim" generation (identifying what's NOT mentioned, like missing FDA disclaimers). 4. *Counter-intelligence*: Actively hunts for contradiction — searching for YouTube review/debunking videos and detecting self-referential press releases (94% precision). 5. *Probabilistic output*: A calibrated THREE-state distribution (TRUE/FALSE/UNCERTAIN) based on Bayesian aggregation of source validation power.

### Results (200-claim test set)

- 75% accuracy vs. ground truth (95% CI: 61-85%) - +18% improvement from counter-intel on misleading content - Well-calibrated (Brier score = 0.12, ECE = 0.04) - Cost: $0.50–$2.00 per video

### Tech Stack

- Python 3.12, Gemini 2.5 Flash via Vertex AI - LangChain/LangGraph for orchestration - Streamlit UI, Cloud Run backend - yt-dlp for video download - Google Custom Search + YouTube Data API

### Honest Limitations

- English only - YouTube only (no TikTok/Instagram yet) - ~25% error rate (75% accuracy means 25% wrong) - Susceptible to coordinated fake review campaigns - No human-in-the-loop

### Why Open Source

Misinformation is too important to solve behind closed doors. The methodology needs to be transparent and auditable. Full research papers with step-by-step calculations are in the `papers/` directory.

Looking for feedback on the approach and contributions (especially: multi-language support, additional platforms, expanded evidence sources).