2025年8月28日 的 Show HN

We built SwiftAI, an open-source Swift library that lets you use Apple’s on-device LLMs when available (Apple opened access in June), and fall back to a cloud model when they aren’t available — all without duplicating code.

SwiftAI gives you: - A single, model-agnostic API - An agent/tool loop - Strongly-typed structured outputs - Optional chat state

Backstory: We started experimenting with Apple’s local models because they’re free (no API calls), private, and work offline. The problem: not all devices support them (older iPhones, Apple Intelligence disabled, low battery, etc.). That meant writing two codepaths — one for local, one for cloud — and scattering branching logic across the app. SwiftAI centralizes that decision. Your feature code stays the same whether you’re on-device or cloud.

Example

  import SwiftAI

  let llm: any LLM = SystemLLM.ifAvailable ?? OpenaiLLM(model: "gpt-5-mini", apiKey: "<key>")

  let response = try await llm.reply(to: "Write a haiku about Hacker News")
  print(response.content)

It's open source — we'd love for you to try it, break it, and help shape the roadmap. Join our [discord](https://discord.com/invite/ckfVGE5r) / [slack](https://mi12swiftai.slack.com/join/shared_invite/zt-3c3lr6da...) or email us at [email protected].

Links * GitHub (source, docs): https://github.com/mi12labs/SwiftAI * System Design: https://github.com/mi12labs/SwiftAI/blob/main/Docs/Proposals... * Swift Package Index (compat/builds): https://swiftpackageindex.com/mi12labs/SwiftAI

Hey HN,

I wanted a grammar checker that didn’t send my writing to someone's servers, so I built Grammit, a Chrome extension that runs grammar checks locally using an LLM. Your text never leaves your computer during checking.

Here’s a 2-minute overview:

https://www.loom.com/share/baf501ee6cf14a919a7384128246ed67

Because it uses an LLM, it catches more than spelling and grammar. For example, it can correct some wrong statements like “The first US president was Benjamin Franklin.”

Grammit also includes an in-page writing assistant that can rephrase or draft new text. It also uses the local LLM.

We used many new web features to build this, such as:

- Chrome’s new Prompt API to talk to the local model.

- Anchor Positioning API to place the UI with minimal impact on the DOM.

- CSS Custom Highlights API for inline error marking.

- The new CSS sign() function to create CSS-driven layout with discontinuities.

Part of the fun of being early adopters of bleeding edge tech is we’re discovering new Chrome bugs (e.g., https://issues.chromium.org/issues/428354426, https://issues.chromium.org/issues/428039224).

I’d love your feedback on:

- Where the UX feels rough

- What do you think of the corrections and suggestions

Happy to answer questions about the tech or the Prompt API. Thanks for trying it out!

Chrome Web Store extension link: https://chromewebstore.google.com/detail/grammit-the-ai-gram...

Hey HN! We've run our privacy-focused open-source inference company for a while now, and we're launching a flat monthly subscription similar to Anthropic's. It should work with Cline, Roo, KiloCode, Aider, etc — any OpenAI-compatible API client should do. The rate limits at every tier are higher than the Claude rate limits, so even if you prefer using Claude it can be a helpful backup for when you're rate limited, for a pretty low price. Let me know if you have any feedback!

Hey HN, I built Yoink AI to solve my biggest frustration with AI tools: they constantly break my workflow. I was tired of copy-pasting between my apps and a chatbot just for simple edits.

Yoink AI is a macOS app that brings the AI to you. With a simple hotkey (⌘ Shift Y), it works directly inside any text field, in any app. If you can type there Yoink can write there

Key Features: - Automatically captures the context of the text field you're in, so you dont have to manually prime it

- Create custom voices trained on your own writing samples. This helps you steer the output to match your personal style and avoid generic, robotic-sounding text

- Yoink doesnt just dump text and run. It delivers suggestions as redline edits that you can accept or reject, keeping you in full control.

It's less of a chatbot and more of a collaborative writing partner that adapts to your workflow, not the other way around.

There's a free tier with 10 requests/month and we just launched a pro trial, which will get you 100 requests for the first 7 days to try it out!

I'm here to answer questions and would love to hear what you think - like all early stage start ups, feedback is always deeply appreciated

I built Duebase AI to solve a problem I kept running into in fintech - analyzing UK company financial health takes forever. The process usually goes: download PDFs from Companies House → manually extract data to spreadsheets → calculate ratios → interpret trends. Takes 3-4 hours per company and requires serious financial expertise. The technical challenge: Companies House filings are messy. Inconsistent formats, complex accounting structures, missing data, and you need to understand UK accounting standards to make sense of it all. My approach:

Parse 15M+ UK company records from Companies House API Built ML models to extract and normalize financial data from varied filing formats Created scoring algorithms that weight liquidity, profitability, leverage, and growth trends Generate 1-5 health scores with explanations in plain English

What it does:

Instant financial analysis of any UK company (30 seconds vs 4 hours) Real-time monitoring with alerts for new filings/director changes Risk detection that catches declining trends early No financial background needed to understand results

The hardest part was handling the data inconsistencies - UK companies file in different formats, use various accounting frameworks, and often have incomplete information. Had to build a lot of data cleaning and normalization logic. Currently focused on the UK market since I know the regulatory landscape well, but the approach could work for other countries with similar public filing systems. Link: https://duebase.com

Hey everyone!

We've been working with several MCP server maintainers and we noticed some difficulties getting drop-in logging and identity attribution working out of the box with existing vendors. A couple of challenges we hoped to solve were: - Baseline piping of tool calls to traditional vendors - How to tie tool calls to a “user session” - Understanding the context behind tool calls made by agents

So we built something. :) The MCPcat library is completely free to use, MIT licensed, and provides a one-line solution for adding logging and observability to any vendor that supports OpenTelemetry. We added custom support for Datadog and Sentry because we personally use those vendors, but we’re happy to add more if there’s interest.

Here’s how it works:

  mcpcat.track(serverObject, {...options…})

This initializes a series of listeners that: 1. Categorize events within the same working session 2. Publish those events directly to your third-party data provider

Optionally, you can redact sensitive data. The data never touches our servers (unless you opt in to additional contextual analysis, which I mention below).

Some teams might also want a better understanding of “what use cases are people finding with my MCP server.” For that, we provide a separate dashboard that visualizes the user journey in more detail (free for a high baseline of monthly usage and always free for open source projects).

We have two SDKs so far: Python SDK: <https://github.com/MCPCat/mcpcat-python-sdk> TypeScript SDK: <https://github.com/MCPCat/mcpcat-typescript-sdk>

Other SDKs are on the way!

I build runcell, an AI Agent in Jupyter Lab. It can understand context (data, charts, code, etc) in your jupyterlab and write code for you.

Runcell has built-in tools that can edit or execute cells, read/write files, search web, etc.

Comparing with AI IDE like cursor, runcell focus on building context for code agent in jupyter environment, which means the agent can understand different types of information in jupyter notebook, access kernel state, edit/execute specific cells instead of handling jupyter as static ipynb file.

Comparing with jupyter ai, runcell is more like an agent instead of a chatbot. It have access to lots of tools to work and take actions by its own.

You can use runcell with simple "pip install runcell" to start.

Any comments and suggestions are welcome.

Hey HN! We’re building Knowledgework.ai, which creates AI clones of your coworkers that actually know what they know. It's like having a version of each teammate that never sleeps, never judges you for asking "dumb" questions, and responds instantly.

As a SWE at Amazon, I constantly faced two frustrations:

1. Getting interrupted on Slack all day with questions I'd already answered

2. Waiting hours (or days) for responses when I needed information from teammates

When you compare this to the UX of an AI chatbot, humans start to look pretty inconvenient! It’s a bit of a wild take, but it’s really been reflected in my conversations with dozens of engineers, and especially juniors: people would rather spend 20 minutes wrestling with an unreliable AI than risk looking ignorant or wasting their coworkers’ time. One of my early users actually tried the product and told me she’s a bit worried her coworkers would prefer talking to her AI extension over talking to her!

Here’s how it works: It’s a desktop app (mac only right now) that captures screenshots every 5 seconds while you work. It uses a bespoke, ultra-long context vision model (OCR isn’t enough, and generic models are far too expensive!) to understand what you're doing and automatically builds a searchable, hyperlinked knowledge base (wiki) of everything you work on - code you write, bugs you fix, decisions you make, or anything else you do on a computer that could be useful to you or your team’s productivity in the future.

Even if you just turn on Knowledgework for ~30 mins while working on a personal project, I think you’ll find what it produces to be really interesting — something I’ve learned is that we tend to underestimate the extent of the valuable information we produce every day that is just ephemeral and forgotten. There’s also some really great opportunities surrounding quantified self and reflection — just ask it how you could have been more productive yesterday or how you could come across better in your meetings.

The real value comes when your teammates can query your "Extension" - an AI agent that has access to all (only what you choose to share) of your captured work context. Imagine your coworker is on vacation, but you can still ask their Extension: "I'm trying to deploy a new Celery worker. It's gossiping but not receiving tasks. Have you seen this before?"

We’ve spent a great deal of effort on optimizing for privacy as a priority; not just in terms of encryption and data security, but in terms of modulating what your Extension will divulge in a relationship appropriate way, and how you can configure this. By default, nothing is shared. In a team setting, you can choose to share your Extension with particular individuals. You can, in a fine-grained manner, grant and revoke access to portions of your time, or if you are on a tight-knit team, you can just leave it to AI to decide what makes sense to be accessed. This is the area we’re most excited to get feedback on, so we’re really aiming this launch at small, tight knit teams who care about speed and productivity at all costs who use Macs, Slack, Notion, and are all on Claude Code Max plans.

We’re also working on SOC II type 2 compliance and can do on-prem, although on-prem will be quite expensive. If you’re curious about on-prem or additional certifications, I’d love to chat - [email protected].

Check it out here: https://knowledgework.ai/

We’ve opened it up today for anyone to install and use for free. If you’re seeing this after Thursday 8/28, we’ll likely have put back the code wall — but we’d be happy to give codes to anyone who reaches out to [email protected]

I’ve been experimenting with building a Node.js HTTP framework using Rust + Hyper with N-Api.

The project started as a fully synchronous server, but I recently patched it to support async (Tokio/Hyper). That change alone nearly doubled throughput in benchmarks.

What’s different:

* Built directly on Hyper, no heavy abstraction * napi glue for Node.js bindings * Minimal core (sync and async engines side-by-side) * Focused on raw performance, not plugins (yet)

This is still experimental and not production-ready. I’d like feedback on:

* Async API design — does it feel ergonomic? * Middleware style — what patterns should be supported?

Repo: [https://github.com/Shyam20001/rsjs](https://github.com/Shyam20001/rsjs) Full benchmarks: [https://shyam20001.github.io/rsjs/](https://shyam20001.github.io/rsjs/)

This is a Python (with Rust backend) library for high accuracy orbit calculation of the entire known catalog of asteroids. It is a full N-Body integrator, including lots of additional physics, such as relativistic effects, non-spherical gravitational fields of planets, masses of large asteroids, and a number of non-gravitational forces such as radiation pressure. The design goal is essentially JPL Horizons on your laptop, but all asteroids at once.

I began this project while I worked at Caltech on a NASA mission called NEO Surveyor (which is a space telescope designed to survey Near Earth Objects). It is being used by NEO Surveyor to predict previously known asteroids in images to reduce processing costs (since it is computationally expensive to process unknown asteroids). I wrote this generally enough that it is also being used by the SPHEREx and Roman space telescopes for a similar purpose.

I got it open sourced before I left caltech for a PhD, and I am continuing to develop it as a part of my PhD.

Here is a plot of my favorite group of asteroids, the Hildas, because of Jupiter their orbits are synchronized such that they make a triangle:

https://dahlend.github.io/kete/auto_examples/plot_mpc_state....

Hey HN,

This newsletter didn’t come from a growth hack or content strategy.

It started with frustration.

Every week, I was drowning in blogs, PR blasts, and Twitter threads trying to keep up with Voice + AI. New models dropping. Partnerships overnight. Startups in India and Asia pushing infra upgrades that no one was covering.

But whenever I wanted to know what really mattered, the signal was buried under the noise.

And there wasn’t a single newsletter focused on India’s Voice AI ecosystem — most only covered the US.

So I built the thing I wished existed: Voice AI Stack — a newsletter on India, Asia, and global Voice AI updates.

What you’ll get every Friday Product launches that actually move the Voice + AI ecosystem forward

Infra upgrades & strategic deals (with context on why they matter)

Advances in speech tech, translation & agent performance

A spotlight on VideoSDK’s AI Agent features — what’s shipping, and what’s next

If you’re a developer, PM, researcher, or just curious about the future of AI voices & agents in India and beyond — this is for you.

Behind the Scenes Last night at 11:30 pm, we were testing our VideoSDK AI agent. Everything was running perfectly—smooth, steady, no problems at all.

Then suddenly, every agent started speaking in opera voices. Instead of answering questions, they were singing like they were on stage in Italy.

We couldn’t stop laughing. Then came the panic. And finally, the fix.

That’s what building in this space is really like—messy, surprising, and full of moments you don’t expect. Behind every polished demo, there are nights like this: bugs, laughter, and small wins that make the journey worth it.

This newsletter is my way of opening that door for you. A peek into the experiments, the stumbles, the “wait, did that agent just…” moments that make this space exciting.

Subscribe here to stay in the loop.

https://videosdkweekly.substack.com/p/welcome-to-voice-ai-st...

And if you’ve got a friend building or curious about Voice AI — forward this to them.

Let’s cut through the noise, together.

See you tomorrow Sagar Kava

Karton (German for “carton”) is a type-safe and web socket based solution that allows you to define a shared definition of what is synchronized between server and client side (the “Karton contract”):

- The type of state that is synced between the server- and client-side (read-only on client-side) - Server procedures that clients can call to make mutations on server-side - Client procedures that servers can call to make queries etc. to the client-side

All connections share the same state, and the state is always defined by the server. Deltas are efficiently synced through JSON-style patches (using immer under the hood).

We’re Glenn and Julian, and we built this as a tool for our startup (stagewise - YC S25). We needed a simple and type safe solution to sync a CLI app (JS-app) with a browser-based UI-app (we use React). We didn’t find any solutions out there that seemed easy to use, so we simply decided to build our own one.

We offer both the server and client in vanilla TS, but also ship a React-specific client that gives you a Zustand-style access to the state (allowing to only select slices of the whole state as well).

The API is made to be very easy to use, with just one output type that’s shared between server and client apps, making it a low-overhead solution if you build locally running JS apps that consist of multiple sub-apps. Karton is MIT-licensed, available on npm (@stagewise/karton) and currently part of our bigger OSS monorepo. It’s pretty much in beta state but we already use it in production. GitHub: https://github.com/stagewise-io/stagewise/tree/main/packages... NPM package: https://www.npmjs.com/package/@stagewise/karton Our YC Launch: https://www.ycombinator.com/launches/O3M-stagewise-the-front...

i built TXTOS because my models kept forgetting and bluffing. i wanted a portable fix that works across providers without code or setup. TXTOS is a single .txt you paste into any LLM chat. it boots a small reasoning OS that gives you two things by default: a semantic tree memory that survives long threads, and a knowledge boundary guard that pushes back when the model is out of scope.

what it is plain text. no scripts, no trackers, no api calls. MIT. the file encodes a protocol for reasoning, memory, and safety. you can diff it and fork it. it is not “a clever prompt”. it behaves like a tiny OS that the model follows.

why it exists after debugging a lot of RAG and agent stacks, the same failures kept coming back. memory broke across sessions. the model answered outside its knowledge without warning. i wanted a zero install layer that i can carry between models and keep the same behavior.

what you get

* semantic tree memory. it records ideas and relations, not just tokens. it can recall earlier branches, avoid repetition, and keep tone stable. * knowledge boundary test. ask something impossible, then run the built in check. it flags risk and proposes a safe path instead of hallucinating. * simple rules. cite then explain. stop when sources or offsets are missing. show a short audit trail. keep answers compact when you ask for compact.

try in 60 seconds

1. download TXTOS.txt, open a fresh chat with any model you like 2. paste the file content, then type: hello world 3. test memory: ask three related questions, ask it to recall the first one exactly, then switch topics and come back 4. test boundary: ask for something unknowable or very recent, then type kbtest. watch how it handles the boundary 5. optional: restart the chat and paste the same file. see how the tree helps you rebuild state fast

what to expect less overtalking. better recall of your own constraints and tone. refusal on missing citations. early warnings when your question is outside scope. the file is small by design, so even weaker models can use it. stronger models show bigger gains.

not just marketing TXTOS came out of real failures. it was built to stop two user facing problems that cost time and trust. forgetting, and unearned confidence. since it is plain text, the community can audit it and improve it.

looking for feedback

* what did the memory tree get right or wrong for your workflow * which boundary cases still slip through * what small operator would you add to the OS so it helps you daily

url is in the link field above. thanks for reading. if you break it, even better. tell me how you did it and i will ship the fix.

Hi, I’m Chris and my partners and I are building Devplan, an AI product development tool that helps teams go from idea to working code faster.

What Devplan does:

- Creates deep contextual understanding from Github and the web with our open source context engine: https://github.com/devplaninc/contextify

- Generates right-sized PRDs, user stories, and tech design based on company context

- Gives a ballpark effort and complexity estimate for every user story

- Breaks down requirements into structured coding prompts for tools like Claude Code, Cursor, Windsurf, or JetBrains Junie

- Integrates with Linear and Jira to push generated project docs and tickets to your tracking system

- Lets you kick off projects with images to refine specs with mocks, diagrams, or screenshots

- Exports detailed coding prompts as standalone files or use our CLI to work with them directly

Why we built it:

We believe the next generation of product development will be built with AI at its core. But we’ve seen first-hand how the current tools fall short:

- Docs from ChatGPT or Claude are useful but too general and lack context for real workflows

- AI coding agents lose context quickly in large repos and generated code often requires re-work

- Most approaches to planning for AI coding takes too long and isn't shared or reviewed, which slows teams down

AI should remove that friction, not create more of it. We built Devplan to make planning and execution one connected flow. It starts with outcomes, adapts to the size of your project, and produces structured inputs for the coding tools you already use. Instead of bouncing between AI assistants, PM docs, and code editors, Devplan ties it all together so you can move faster without losing context.

We have an MVP template for side projects, but the platform is being built for real teams who want to ship product with confidence while staying lean. We are still early and we’re iterating quickly.

Would love to hear feedback from other builders. What’s working for you when it comes to planning and building with AI?

P.S. If you want to try it, public beta is open: https://www.devplan.com

I started this boilerplate in July 2020 and I’ve been maintaining it for 5 years. It began on Next.js 9 and kept upgrading to Next.js 15+ (App Router), while upgrading the stack over time (Tailwind 1 → 4, ESLint 8, swapping Cypress → Playwright, etc.). The goal is simple: I kept rebuilding the same setup, so I packaged it and kept it updated.

What you get (preconfigured, keep only what you need):

- Next.js 15 (App Router) + TypeScript + Tailwind 4

- Auth with Clerk (magic links, MFA, social, passkeys)

- I18n via next-intl

- DB with Drizzle ORM (PGlite locally)

- Forms with React Hook Form + Zod validation

- Testing: Vitest (unit), Playwright (integration/E2E)

- CI with GitHub Actions; Storybook for UI work

- SEO (Open Graph, JSON-LD, sitemap, robots)

- Observability: Sentry, logging with LogTape, log management & uptime/monitoring

- Security: Arcjet (bot detection, rate limiting, shield rules)

- DX details: ESLint/Prettier, Lefthook + lint-staged, Commitlint, absolute imports, bundle analyzer

- AI code review

It’s free and open source (MIT). Today the project sits around 11.8k GitHub stars and 2.2k forks. I’m still actively maintaining it and adding features.

Repo: https://github.com/ixartz/Next-js-Boilerplate

Why I built it

Spinning up auth, a DB, i18n, tests, and lint/format/CI for each new app was repetitive. This gives me (and hopefully you) a production-ready base in minutes, with opinionated defaults you can start.

I’m open to suggestions and feedback, what would you like to see next? I’ll hang around in the comments to answer questions.

Hey everyone!

I spend a lot of time in git worktrees in Claude Code to do tasks in parallel. I made this to create and manage them easier w/o mental overhead.

Simple to create/list/delete worktrees, as well as a config for copying over .env/other files, running install commands and opening your IDE into the worktree.

Would love to get feedback. Feel free to open any issues or PRs! https://github.com/raghavpillai/branchlet

Hi HN I built Simple PDF Scanner because I was frustrated with bloated scanner apps that require subscriptions.

v1.0 includes: OCR, password-protected PDFs, custom filenames, camera + photo import, A4 support. Planned for v1.1: quality controls, estimated file size, more paper sizes, history.

I’d love feedback – what features do you always miss in simple scanner apps?

Hi HN,

I built Pocket Agent — a mobile-first interface for coding agents like Claude Code, Cursor, Codex, Gemini, and OpenCode. It lets you connect to your own dev environment (or cloud agents) and interact with them in real time from your phone.

Pocket has two parts: • Pocket Server (open-source): lightweight server (Mac + Linux today, Windows soon) you run on your machine. It securely exposes your environment to Pocket. • Pocket App (beta): your mobile interface. You can: • Chat with agents (Claude, Cursor, Codex, Gemini, etc.) • Run and monitor terminal sessions in real time • Approve or deny file edits, searches, or commands • Launch and track cloud background agents • Manage multiple projects/sessions — all from your phone

Traction in the first 24 hours: • 1,400+ unique visitors • 350+ beta signups • 130+ GitHub stars • Community already contributing: Linux support, Tailscale pairing, Claude Code auth integration

Repo: https://github.com/yayasoumah/pocket-server Website: https://www.pocket-agent.xyz

I’d love your feedback — especially if you’re building or using CLI agents. What would make you adopt and trust a mobile-first agent workspace?

Hey HN! I've built Video-2-Prompt, an AI tool that converts videos into detailed content prompts.

*What it does:* - Analyzes videos (MP4, MOV, AVI, WebM) and platform URLs (YouTube, TikTok) - Generates 600-800 word professional analysis reports - Provides insights on engagement factors and content strategy

*Key Features:* - Multi-AI integration with intelligent fallback - Deep analysis mode for comprehensive insights - Real-time processing with progress indicators - Platform-agnostic video processing

*Tech Stack:* - Next.js 14, React 18, TypeScript - Serverless architecture (Vercel) - Smart video analyzer with retry mechanisms

*Use Cases:* - Content creators analyzing viral videos - Marketing teams understanding competitor strategies - Researchers converting video content to text

*Live Demo:* https://video2prompt.org

The tool is free to use. I'd love feedback on analysis quality and feature suggestions!

AIKit is a minimal TypeScript wrapper that gives you unified access to the generation APIs of OpenAI, Anthropic, and Google Gemini—complete with streaming, multimodal inputs, and tool calling. No extra runtime packages: just the fetch that ships with modern Node and browsers.

I really like csvq, but its implemented features feel a bit heavy for me. I don't really need to perform statistics directly on CSV files, but simple modifications are what I need. Plus, I don't have a Go environment, so I created a simple awk version. All test cases are included in the except script.

Why develop it?

First of all, I don't like the idea of all in one. In particular, I almost only need words. I have used Typora. It is really good, but it can hardly satisfy me except editing. So I wonder if there is a simple Markdown editor that can manage files and has a good editing experience? Then there is MarkFlowy.

Features:

MarkFlowy has been independently developed for 2.5 years.Based on the design philosophy of being lightweight, simple, and highly available, it now boasts a considerable number of functions such as:

- Local Priority: MarkFlowy is a pure editor designed to edit your local content. The synchronization method is left to the user's choice. Currently, it provides a Git manager and will later integrate with other similar cloud storage services for synchronization. Feel free to provide feedback on this.

- User Experience First: It offers multiple editing modes, including source code and WYSIWYG (What You See Is What You Get). Additionally, it supports custom themes. Furthermore, high performance is the foundation of a good user experience. MarkFlowy has a lightweight package size and specialized performance optimization. Real-world testing shows that on an M1 Mac device, editing documents with over 200,000 characters can still ensure smooth writing in both Chinese and English.

- AI Support: MarkFlowy integrates with multiple AI vendors such as Deepseek, Openai, and Ollama. It also supports using their features within the editor for tasks like Q&A, summarization, translation, etc., to enhance your writing efficiency.

- Simplicity: Out-of-the-box usability. You only need to familiarize yourself with Markdown syntax to use it easily. It also provides synchronization methods such as Git and a powerful file management tree.

Apart from these features, MarkFlowy can edit text files (txt), JSON files, and view image files, among other useful functions. We welcome everyone to experience, exchange ideas, and participate.

Hi! I vibe coded a small tool that I think is relatively unique — at least, I haven't found anything like it — and I've found personally extremely useful. I don't know if anyone else will, but I'm sharing it just in case someone does find it useful. Basic description:

HTML Commenter is a zero-dependency, self-contained document annotation tool for any static HTML page. This system allows users to annotate the text on a web page, auto-saves their comments to local storage, and lets them share their comments with others via compressed links or back them up with JSON files, all without requiring a server or external libraries.

The goal of this project is to provide a lightweight collaborative document annotation experience for people who:

- don't want to use SaaS and/or heavy PWAs

- don't want to have to install and maintain software on their own server

- don't want to ask users to install software (like LibreOffice)

don't want to have to send - multiple versions of files around like it's 1990 and we're dealing with Word Documents

- prefer writing in plain markup languages (like Markdown, Org, or HTML), exporting to HTML, and posting their writing to their domain (either self hosted or on things like NeoCities)

Github: https://github.com/alexispurslane/html-commenter/ URL for trying it out: https://alexispurslane.github.io/html-commenter/try.html

A few weeks ago I shared the Persistent Mind Model (PMM) — a Python framework for giving an AI assistant a durable identity and memory across sessions, devices, and even model back-ends.

Since then, I’ve added some big updates:

- DevTaskManager — PMM can now autonomously open, track, and close its own development tasks, with event-logged lifecycle (task_created, task_progress, task_closed).

- BehaviorEngine hook — scans replies for artifacts (e.g. Done: lines, PR links, file references) and uto-generates evidence events; commitments now close with confidence thresholds instead of vibes.

- Autonomy probes — new API endpoints (/autonomy/tasks, /autonomy/status) expose live metrics: open tasks, commitment close rates, reflection contract pass-rate, drift signals.

- Slow-burn evolution — identity and personality traits evolve steadily through reflections and “drift,” rather than resetting each session.

Why this matters: Most agent frameworks feel impressive for a single run but collapse without continuity. PMM is different: it keeps an append-only event chain (SQLite hash-chained), a JSON self-model, and evidence-gated commitments. That means it can persist identity and behavior across LLMs — swap OpenAI for a local Ollama model and the “mind” stays intact.

In simple terms: PMM is an AI that remembers, stays consistent, and slowly develops a self-referential identity over time.

Right now the evolution of it "identity" is slow, for stability and testing reasons, but it works.

I’d love feedback on:

What you’d want from an “AI mind-layer” like this.

Whether the probes (metrics, pass-rate, evidence ratio) surface the right signals.

How you’d imagine using something like this (personal assistant, embodied agent, research tool?).

Hi HN! I built TipTour because I'm frustrated with React Tour and similar libraries that force users through rigid, linear onboarding flows. Users should be able to discover your product naturally, not be railroaded through predetermined steps.

What TipTour does differently: - Always-on, ambient help - The tooltip follows your cursor smoothly, providing context without blocking anything - Non-intrusive - No overlays, no "Next" buttons, no forced flows. Users stay in control - Discovery-friendly - Add contextual hints that appear as users naturally explore your interface

Prompting arena site where users win money breaking prompts and earn money creating them. Alternative to https://hackaprompt.com / https://app.grayswan.ai/arena,

Open to feedback/improvements/bugs.

- Uses USDC on polygon just like polymarket. - Fun and a good way to actually prove your prompting abilities. - See every attempt live as it's happening and improve from what your opponents are doing.

We've been building text-to-SQL at TigerData and kept hitting the same problem: evaluation tools that tell you your accuracy score but nothing about how to improve it.

Getting a 60% pass rate is meaningless if you don't know whether failures are from bad schema retrieval or poor SQL generation. It's the difference between actionable insights and meaningless benchmarketing.

So we built, and are now open-sourcing, text-to-sql-eval with a simple insight: run every query three different ways:

- Normal mode - let the system retrieve schema and generate SQL - Full schema mode - provide all tables to test upper bound accuracy - Golden tables mode - give it the right tables to isolate reasoning issues

The performance delta between modes tells you exactly what's broken.

PostgreSQL-specific because database quirks matter for correctness. Works with any LLM or text-to-SQL system. Includes an LLM-as-judge option because deterministic matching produces too many false negatives on complex queries.

We've been using this internally to improve our (also open-sourced) text-to-sql system.

Open sourcing both the eval suite and a companion tool for generating test datasets from your production schema.

Built with uv for easy setup. TimescaleDB for tracking results over time. Simple Flask UI for exploring failures.

Try it, break it, tell us what's missing.

I built a small project that integrates Gemini Flash Image but makes it more affordable to use compared to the official API. It allows you to generate high-quality images with the same model, and also provides simple editing features for refining results. The goal is to make experimenting with Google’s image model cheaper and more accessible for people who create a lot of images.