Daily AI Digest — 2026-07-11
Hacker News Signals
GPT-5.6 Sol Ultra produces proof of the Cycle Double Cover Conjecture [pdf]
The Cycle Double Cover Conjecture (CDC) — open since Szekeres (1973) and Seymour (1979) — asserts that every bridgeless graph has a collection of cycles such that every edge is covered exactly twice. The PDF released by OpenAI claims a complete proof, which, if verified, resolves one of the central problems in topological graph theory. The argument reportedly proceeds by establishing a stronger result about nowhere-zero flows and their relationship to cycle covers in cubic graphs, then lifting to the general bridgeless case via standard reduction. The proof is long-form mathematical prose with formal lemmas, not a formal verification in Lean or Coq, so independent human review is the immediate bottleneck. The mathematical community’s reaction has been cautious: several graph theorists on MathOverflow and the HN thread note that the structural lemmas around Petersen graphs and their snarks need careful scrutiny, as these are precisely the cases where previous attempted proofs collapsed. The significance is hard to overstate for combinatorics — CDC implies a host of corollaries about surface embeddings and nowhere-zero 4-flows. Whether the model was used as an autonomous prover or as a heavily scaffolded assistant is not disclosed; OpenAI’s framing leaves this ambiguous. The computational irreducibility of proof verification means this will take weeks to months to settle even with serious effort from domain experts. The broader implication, independent of correctness, is that large reasoning models are now producing outputs that are at least syntactically indistinguishable from plausible professional mathematics at the frontier research level.
Source: https://cdn.openai.com/pdf/04d1d1e4-bc75-476a-97cf-49055cd98d31/cdc_proof.pdf
Inference Optimization for MiMo v2.5: Pushing Hybrid SWA Efficiency to the Limit
Xiaomi’s MiMo v2.5 blog post details inference-level engineering for a hybrid sliding-window attention (SWA) model. The core challenge: SWA models interleave local windows with periodic full-attention layers, which breaks the uniform KV-cache layout assumed by most serving stacks. The post describes several concrete optimizations. First, layer-type-aware KV cache allocation: local SWA layers need only a fixed-size circular buffer proportional to the window w, while full-attention layers need the full O(n) cache; statically partitioning VRAM accordingly reduces peak memory by reported 30-40% on long contexts. Second, kernel-level chunked prefill is tuned separately for SWA and full-attention layers to avoid padding waste from mismatched tile sizes. Third, speculative decoding is adapted so draft verification respects window boundaries — a naive draft verifier would incorrectly cache tokens outside the acceptance window. The post quantifies throughput on 128k-context requests: MiMo v2.5 achieves roughly 2.1x higher token/s versus a naive vLLM baseline on the same hardware, primarily from the memory savings enabling larger batch sizes. There is also discussion of a continuous batching scheduler that tracks per-layer cache types rather than per-request, enabling tighter bin-packing. The write-up is engineering-focused rather than research-novel — most individual techniques are known — but the integration across allocator, scheduler, and kernel layers for a hybrid architecture is non-trivial and the numbers are credible. Relevant for anyone deploying SWA-family models (Mistral, Gemma 2, etc.) at scale where the naive “treat it like full attention” approach leaves significant efficiency on the table.
Source: https://mimo.xiaomi.com/blog/mimo-v2-5-inference
Geosql: A Claude/Codex skill for geospatial data
Geosql is a thin integration layer that exposes geospatial query capabilities to LLM agents via a structured tool interface. The implementation wraps DuckDB with its spatial extension (which provides PostGIS-compatible functions over Parquet, GeoJSON, and other flat files) and surfaces a query(sql: str) -> GeoJSON tool that agents can call. The interesting design choice is schema introspection at tool registration time: the wrapper inspects available datasets, extracts column names and spatial reference systems, and injects a compact schema summary into the system prompt so the model can write valid SQL without hallucinating column names. The repository includes a prompt template that instructs the model to prefer ST_Within, ST_Intersects, and related spatial predicates over coordinate arithmetic, which matters because DuckDB spatial’s query planner can index-accelerate the former. The zero-dependency claim applies to the agent interface layer; DuckDB itself is a binary dependency. The practical use case is natural-language querying of geospatial datasets — census boundaries, OSM extracts, satellite-derived rasters rasterized to vector — without standing up PostGIS. A notable limitation is that DuckDB spatial does not yet support all PostGIS operations; complex topology operations (e.g., ST_BuildArea on self-intersecting inputs) either silently return null or error, and the wrapper does not currently surface these failure modes clearly to the agent. For exploratory analysis on GeoParquet files, though, the combination of DuckDB’s columnar engine and the agent interface is genuinely useful and fast.
Source: https://github.com/dekart-xyz/geosql
Show HN: FableCut – A browser video editor AI agents can drive (zero deps)
FableCut is a browser-native video editor implemented entirely in vanilla JavaScript with no npm dependencies, designed with an explicit agent-driving API. The technical core is a declarative timeline model: the internal state is a plain JSON structure describing clips, cuts, transitions, and text overlays, which can be serialized and deserialized completely. An agent — or any external caller — interacts via a set of command functions (addClip, trimClip, applyTransition, etc.) that mutate this state and trigger re-render. Video decoding and compositing use the browser’s native <video> elements with Canvas 2D for compositing, avoiding WebCodecs for compatibility reasons, which limits frame-accurate seeking on some codecs. The zero-dependency claim holds up: the repo has no package.json at all; it is plain HTML, CSS, and JS files. The agent interface is intentionally narrow — JSON in, JSON out — which makes it straightforward to connect to any tool-calling LLM without custom serialization logic. The main engineering limitation is performance: Canvas 2D compositing at 30fps for multi-track timelines with transitions runs into CPU bottlenecks quickly on long or complex projects, and there is no WebGL compositor. For short-form content (< 2 min, 2-3 tracks) targeted at agent-driven assembly pipelines — where an LLM generates cut lists from transcripts — it is a reasonable proof of concept. The architectural choice to make state fully serializable as a first-class design goal, rather than retrofitting agent access onto an existing editor, is the notable decision here.
Source: https://github.com/ronak-create/FableCut
Show HN: Reverse-engineering web apps into agent tools
This submission describes a methodology and associated tooling for converting arbitrary web applications into structured agent tool APIs without access to source code or official APIs. The approach consists of three stages: (1) record-and-replay traffic capture using a browser automation harness (Playwright-based) to record HTTP request/response pairs for key user flows; (2) schema inference over the captured payloads — JSON bodies are schema-extracted, form submissions are parsed into typed field definitions, and authentication token patterns are identified via heuristic header analysis; (3) generation of a tool manifest (OpenAPI-compatible JSON) that wraps replay of the captured requests with parameter substitution. The interesting technical problem is handling session state: many web app actions require a valid CSRF token or session cookie that changes per-session, so the generated tool wrappers include a lightweight re-authentication step before each call. The HN discussion raises the obvious concern about terms-of-service violations and the fragility of this approach — any frontend change breaks the recorded flows — but the technical mechanism is sound for internal tooling or legacy systems with no API surface. A related hard problem not fully addressed is JavaScript-heavy SPAs where meaningful state transitions happen entirely in client-side code without corresponding network requests; the current approach misses these. The practical niche is giving agents access to enterprise SaaS tools that lack API tiers or have expensive API add-ons, where the operator controls the account and the ToS question is settled.
Source: (no URL provided by submitter)
GLM 5.2 is nearly as accurate as a human bookkeeper
Toot Books benchmarks several LLMs on a structured VAT accounting task: given a set of business transactions described in natural language, produce correct VAT categorizations, applicable rates, and a compliant summary return. The benchmark is narrow but concretely defined — UK MTD VAT rules — with ground-truth answers validated by a chartered accountant. GLM 5.2 achieves 94.3% transaction-level accuracy versus a human bookkeeper baseline of 96.1%, outperforming GPT-4o (91.2%) and Claude 3.5 Sonnet (89.7%) on this task. The methodology details matter: the eval uses 200 transactions across 12 VAT categories including edge cases (partial exemptions, mixed-use assets, reverse charge), with scoring that penalizes both wrong category and wrong rate independently. GLM 5.2’s relative strength appears to come from better handling of compound rules — transactions that require applying multiple VAT provisions in sequence — possibly reflecting training data with more structured regulatory text. Limitations of the benchmark are real: 200 transactions is small, UK VAT only, no multi-period or adjustment scenarios, and the human baseline is one bookkeeper rather than a distribution. The HN thread debates whether 94% is “good enough” for unsupervised deployment; the practical answer depends on whether errors cluster on high-value transactions (bad) or are uniformly distributed (more tolerable with review). The result is still interesting as evidence that smaller specialized models can match or exceed frontier models on narrow, rule-governed professional tasks where the rules are well-represented in training data.
Source: https://toot-books.com/blog/glm-5-2-vat-benchmark
Home made GPU escalated quickly [video]
This YouTube video documents a hobbyist project building a functional GPU from discrete logic and FPGA components. The architecture is a tile-based rasterizer: a fixed-function pipeline with a triangle setup unit, edge function evaluator, and a small framebuffer in SRAM, implemented partly in a mid-range Xilinx FPGA and partly in 7400-series TTL logic for the parts the creator wanted to understand at gate level. The “escalated quickly” refers to the scope expansion from a simple scanline rasterizer to implementing perspective-correct texture interpolation, which requires dividing 1/z-interpolated coordinates at each fragment — non-trivial in fixed logic. The interpolation is handled by a lookup-table-based reciprocal unit for 1/z followed by a multiplier chain, accurate to roughly 8 bits of mantissa, sufficient for the demo scenes shown. Clock speed is low (~10 MHz on the TTL sections, higher on the FPGA fabric) and the framebuffer is 320x240 at 8-bit color, but the pipeline is genuinely functional and renders textured quads in real time. The educational value is in the concrete implementation of concepts that are abstracted away in modern GPU architectures: the video shows exactly how edge function evaluation parallelizes across tile quads, why z-fighting occurs at limited depth buffer precision, and what the rasterization rules for shared edges look like in hardware. No novel research content, but technically rigorous and a good reference for anyone teaching or learning computer graphics architecture below the API level.
Source: https://www.youtube.com/watch?v=qMR3IXF2sWw
Building a real-time AI tutor for 5-year-olds
Ello’s engineering blog post details the latency constraints and architectural choices for a speech-based reading tutor targeting sub-1000ms end-to-end response time. The pipeline is: device-side VAD (voice activity detection) to segment utterances, streaming ASR to a self-hosted Whisper variant fine-tuned on child speech (which has substantially higher WER on standard Whisper due to pronunciation variability), a small context-management layer that tracks reading position and error history, an LLM call for pedagogical response generation, and TTS. The 1000ms budget is broken down explicitly: ~150ms ASR (streaming, first token), ~400ms LLM (constrained to short outputs via max-token limits and a fine-tuned smaller model rather than a frontier API), ~200ms TTS, ~150ms network and audio buffering. Child speech ASR is the hardest sub-problem: the post reports that standard Whisper large-v3 gives ~18% WER on their internal benchmark of 5-year-old readers versus ~4% on adult speech; their fine-tuned model gets this to ~9%. The pedagogical response model is kept small (reported as a 7B-class model fine-tuned on tutoring interactions) precisely to hit the latency target — larger models push total latency to 1.5-2s, which causes children to re-speak or lose attention. The post is honest about the remaining hard problem: detecting whether a child has genuinely understood versus memorized a word, which requires richer signal than ASR output alone.
Source: https://www.ello.com/blog/teaching-a-child-in-1000-ms
Noteworthy New Repositories
nullpointexception-i/agent-sphere
An LLM-driven agent orchestration platform implementing the perception → planning → execution → feedback loop. The decision engine wraps an LLM planner that selects from a capability registry at each step; registered capabilities include built-in tools, MCP (Model Context Protocol) endpoints, arbitrary CLI invocations, and browser automation. The architecture separates the planner from executors, letting each capability expose a typed interface the LLM can reason about. The closed-loop design means execution output is fed back as context for the next planning step, enabling multi-step tasks without human re-prompting. Relevant if you want a self-hosted orchestration layer with heterogeneous tool backends rather than depending on a managed agent API. The MCP integration is notable: it provides a standard wire protocol for tool calls, making new capabilities pluggable without modifying the core planner.
Source: https://github.com/nullpointexception-i/agent-sphere
modiqo/skillspec
SkillSpec is a specification and verification framework for LLM agent skills — discrete callable units of agent behavior. The core idea is treating skills as formal contracts: each skill has a structured interface definition, preconditions, postconditions, and an alignment proof that the implementation matches the declared contract. The “Doctor” component performs static risk analysis over a skill graph, flagging unsafe compositions, missing error handling, or contract mismatches before deployment. Guided imports enforce that skills brought in from external sources are reviewed against the contract schema before use. The testability angle is practical: because contracts are machine-readable, test scaffolding can be auto-generated. This is directly useful in production agent pipelines where skill composition failures are hard to debug post hoc. The “provable” framing borrows from formal methods and is more rigorous than typical prompt-based skill descriptions.
Source: https://github.com/modiqo/skillspec
modiqo/cliare
CLI Agent-Readiness Evaluation (cliare) measures how well a command-line tool can be driven by an LLM agent without human intervention. It performs command-shape inference — parsing help text, man pages, and observed behavior to build a structured model of a CLI’s subcommand tree, flags, and argument types. From this model it produces an agent-readiness score covering predictability of output format, idempotency signals, error code consistency, and machine-parseable output availability. CI scorecard integration means you can gate a release on readiness regression, which matters when agents are a first-class consumer of your tooling. The inference pipeline is useful independently: it produces a typed schema of a CLI’s interface that can be fed directly to a tool-calling LLM without manual documentation. Targets DevOps and platform teams building AI-automated pipelines over existing CLI toolchains.
Source: https://github.com/modiqo/cliare
lemma-work/lemma-platform
An open-source collaborative workspace designed around mixed human-agent teams rather than treating agents as external tools. The architecture models both humans and agents as first-class workspace participants sharing task state, context, and artifacts through a common API surface. This avoids the typical pattern of bolting agents onto a human-centric interface via side channels. The platform maintains a shared task graph where work items can be assigned to either humans or agents, and handoffs between them are tracked with provenance. Open-source self-hosting is the primary deployment model, which matters for teams with data residency requirements. The design is relevant to organizations moving from “agent as automation script” toward “agent as collaborator” workflows where accountability and auditability of agent actions within a team context is a hard requirement.
Source: https://github.com/lemma-work/lemma-platform
umputun/agterm
A terminal emulator purpose-built for agentic workflows rather than human interactive sessions. Standard terminals assume a human reading output and typing responses; agterm adds a structured event layer over terminal I/O so that an agent process can programmatically observe output streams, detect prompts, inject input, and handle long-running command lifecycles. Written in Go, it targets embedding in agent execution environments where you need reliable terminal interaction without the fragility of screen-scraping or expect-style scripting. The agentic flow model means it can handle branching interaction patterns — where the next input depends on parsed output — as first-class constructs rather than hacked-together state machines. Useful as an infrastructure component under higher-level agent frameworks that need to drive legacy CLI tools or interactive programs that lack a programmatic API.
Source: https://github.com/umputun/agterm
yeet-src/httpinspect
A live terminal dashboard that surfaces the most active plaintext HTTP endpoints on the local host, modeled on the top interface. It captures HTTP traffic on loopback and LAN interfaces, parses request/response pairs in real time, and ranks endpoints by request rate, error rate, and response latency — all displayed in an auto-refreshing ncurses-style TUI. No proxy or instrumentation of the target service is required; it operates at the packet capture layer. This is directly useful for debugging microservice traffic, identifying hot endpoints during load tests, or auditing what HTTP (not HTTPS) traffic is actually flowing on a host. The plaintext HTTP focus is a practical constraint — it trades coverage for zero-configuration operation. Relevant for development environments, internal service meshes using unencrypted HTTP, or legacy systems where TLS termination happens elsewhere.
Source: https://github.com/yeet-src/httpinspect
alvinunreal/lazyskills
Mission control for agent skills: a management layer that centralizes skill registration, versioning, invocation routing, and monitoring across an agent deployment. Rather than scattering skill definitions across agent codebases, lazyskills provides a registry where skills are declared once and referenced by name and version. The “lazy” in the name reflects deferred loading — skills are not instantiated until invoked, reducing overhead in agents with large skill sets. The control plane exposes skill health, invocation counts, failure rates, and latency, giving operators visibility into which skills are used, which are failing, and which can be retired. This addresses a real operational gap: most agent frameworks make it easy to add skills but give no tooling for managing them at scale. Targeted at teams running multiple agents that share a common skill library.
Source: https://github.com/alvinunreal/lazyskills
AI-Builder-Club/skills
A codebase harness and loop engineer for agent skill development. The repository provides a standardized scaffold for implementing, testing, and iterating on agent skills within a tight development loop: write a skill, run it against a harness that simulates agent invocation, observe structured output, and iterate. The “loop engineer” framing means the harness actively drives the skill through edge-case inputs generated from the skill’s declared contract, surfacing failures before integration into a live agent. The codebase is designed as a community-contributed library of reusable skills, with the harness enforcing a consistent interface so skills are composable across different agent frameworks. For teams building skill-based agents, this reduces the per-skill setup cost and provides a shared testing vocabulary. The community contribution model makes it relevant as a reference implementation library for common agent tasks.