Cloud routine outcomes config creates a feature branch, so the agent commits and pushes there instead of main. Fix: remove outcomes + add explicit git checkout main in skills. Also hit a list API pagination bug (cursor never advances) along the way.
omp's runLoopBody uses a double while loop: the inner loop drives the core model call → tool execution rhythm; the outer loop, when the agent would stop, drains queued steering / follow-up / asides to decide whether to run another turn. This design solves delivery timing for 'user typing while model streams' and 'background tasks quietly queueing messages'.
Looplane's old synchronous M6 path completed one real deployed coding run. It has since grown into an asynchronous control plane with RunSession, SSE, approvals, cancellation, and artifacts, but that newer path has not been live-revalidated. Audience-separated HMAC capabilities enter the Sandbox while provider credentials stay in the Worker; this is not production-traffic or SLO proof.
Looplane clones an exact Git commit into a detached-HEAD workspace inside the run directory before a runtime edits or verifies code. The source repository, execution workspace, and run artifacts therefore have distinct boundaries. This provides source isolation and an audit bundle, but it is not an OS sandbox.
`ExternalCodingRunner` is Looplane's second runtime lane. The external coding CLI owns its model loop and credentials; Looplane hands off a task and disposable clone, then treats the returned patch as untrusted input and reruns path audit, verification, and the source invariant. This is a capability-bounded handoff, not another `ModelProvider`.
Looplane collapses OpenAI-compatible, Responses, Anthropic, Gemini, Workers AI, scripted, and experimental Codex OAuth adapters into one `ModelProvider` contract. The Codex OAuth transport reads SSE but still reduces it inside the adapter into one canonical `ModelTurn`; AgentRunner does not consume token deltas.
Looplane's native lane is controlled by AgentRunner: prepare a workspace, request a model turn, execute tool calls, append observations, and enter verification only when the model stops calling tools. Step, wall-time, repetition, token, and cancellation guards can terminate the run independently of the model. Protocol translation belongs to the next article.
Looplane maintains append-only `events.jsonl` and atomically replaced `session.json`, reconciling sequences before crash recovery. The same event contract now supports deterministic replay, canonical JSON replay, fork seeds at a selected sequence, and new workspaces without replaying old side effects; ambiguous `tool.started` or `verification.started` states still hard-fail.
This article follows one Looplane tool call through its mechanical execution boundary: `SafePathPolicy` for paths and symlink escape, fixed argv with `shell=False`, a sanitized subprocess environment, read-version hashes plus atomic replace for writes, and process-group cleanup at timeout. Permission policy, OS containment, and tool programs are reserved for later articles.
Looplane's TUI and plain CLI are two interfaces over the same runtime paths. The CLI selects a presentation mode from TTY state and flags, runners emit events, and the TUI projects those events into thinking, tool, approval, verification, and terminal states. The screen distinguishes native and external runtimes without treating UI entry points as proof of backend maturity.
Browser Run gives Workers access to Cloudflare-managed headless Chrome. Quick Actions fit one-shot tasks such as screenshots, PDFs, HTML, JSON, and crawls; Browser Sessions fit Puppeteer, Playwright, CDP, and Stagehand automation where you need full control.
Cloudflare Cache Rules are zone-level cache policy: request expressions decide what is eligible for cache, how Edge TTL and Browser TTL behave, what dimensions enter the cache key, and how stale content, ETags, and purge interact. Use them for CDN cache policy; use the Worker Cache API for programmatic caching.
Cloudflare Containers let a Workers app call on-demand serverless containers for workloads that need a full filesystem, a specific runtime, existing container images, or more CPU, memory, and disk. They do not replace Workers; Workers still handle entry, routing, and platform bindings while containers run the heavy runtime-specific work.
The Cloudflare Edge Platform series answers one product question: how do Workers, D1, KV, R2, Durable Objects, Queues, Workflows, Cache, Images, Email, Turnstile, Observability, Browser Run, and Containers help you run a website or app cheaply and reliably?
Before a Cloudflare app goes live, do not stop at a successful deploy. Check Custom Domains, Routes, www/root redirects, maintenance pages, CPU/memory/subrequest limits, log sampling, and fallback paths. This appendix turns the Edge Platform series into a production checklist.
Cloudflare Email Service connects transactional email, magic links, notifications, and inbound routing to Workers. Arbitrary outbound sending currently requires Workers Paid; inbound routing is available on Free and Paid, with DNS, quota, message-size, bounce, and anti-spam limits still shaping the design.
Hyperdrive solves the latency and connection-pooling problem when Workers connect to existing Postgres / MySQL databases. It uses edge connection setup, database-near pooling, and read query caching so a regional database works better with global Workers.
Cloudflare Images has two paths: transform images stored in R2/S3/origin at the edge, or store images in Images and deliver named variants. The first is priced by unique transformations; the second also involves stored and delivered images.
Workers Observability is for debugging and request tracing; Workers Analytics Engine is for high-cardinality product events and custom metrics; GraphQL Analytics API is for querying existing Cloudflare product data. Keeping those roles separate prevents logs from becoming a database and keeps billing, monitoring, and product analytics from blending together.
Smart Shield is Cloudflare's origin protection bundle: Smart Tiered Cache, connection reuse, Argo Smart Routing, Regional Tiered Cache, Cache Reserve, Health Checks, and Dedicated CDN Egress IPs reduce requests and connections reaching your origin.
Turnstile is Cloudflare's CAPTCHA alternative: the client widget generates a token, and the server must validate it with the Siteverify API. Tokens expire after 300 seconds and are single-use; a widget without server validation is incomplete.
Cloudflare Workflows turns multi-step Workers processes into durable steps: each step can retry, sleep, wait for events, and register rollbacks, while instances can be inspected, paused, resumed, or terminated. Queues fit single-step background work; Workflows fit long processes that must remember progress.
A sandbox is not a single package but a spectrum—Namespace, cgroups, seccomp, gVisor, and Firecracker stacked by trust boundary; local OS sandboxes bound blast radius, cloud microVMs bound multi-tenancy, and the choice hinges on trust and ops cost.
Looplane turns a coding-agent task into inspectable boundaries: native side effects cross Looplane tools, permissions, and sandboxing, while external runtimes retain their own loops and tools before returning a patch for Looplane audit. This article maps the planned 20-part series.
Near 85% context pressure, Looplane has two distinct paths: the native loop can apply one bounded deterministic history fallback, while a conversation runtime with native compaction can compact after a completed turn. Both paths re-anchor the next request with workspace context.
Looplane normalizes up to 200 diagnostics and 32 visible files into bounded, repository-local, untrusted context. Its VS Code and managed-LSP paths supply signals rather than completion, rename, code actions, or full IDE RPC.
Looplane can wrap configured local commands and verification in macOS sandbox-exec, Linux bubblewrap, or Landlock/seccomp. A required unavailable backend stops with exit 126 instead of running bare, but external CLIs, MCP/LSP processes, and the entire Looplane process are outside this boundary.
Looplane uses a static model-role catalog and retries or falls back only after retryable provider errors. Cache data is a provider hint plus trace, while cost is a static-table estimate; neither is live routing intelligence or a bill.
Looplane loads project MCP servers only through an explicit allowlist, projects stdio or Streamable HTTP capabilities into the existing ToolExecutor, and preserves hooks, approvals, timeouts, and cleanup.
Looplane applies a non-bypassable critical floor, evaluates user, organization, and project denies before any allows, and keeps execute operations policy-gated even in dangerous mode. This decides authority; it is not an OS sandbox.
Looplane resolves user and root-to-leaf project instructions before rendering named prompt sections for runtime, skills, workspace state, and the latest 20 explicit memories. The pipeline is traceable and reloadable, but it is not semantic memory and repository text does not become system authority.
Looplane exposes bounded-run and conversation contracts through a typed 0.x SDK facade. WebSocket attach wraps one prebuilt, controller-owned runtime session rather than providing conversation-ID resume or multi-client routing.
Looplane treats skills as bounded repository-local guidance, hooks as opt-in host commands that can only deny, and local plugin manifests as packages for skills and hooks; their authority is deliberately different.
Looplane normalizes each subagent dispatch into dependency waves of at most four nodes, runs read-only children concurrently in isolated workspaces, then makes the parent repeat hooks, approval, and transaction execution for any modification.
Looplane parallelizes calls only when they are read-only, concurrency-safe, and classified as READ. Tool programs provide bounded read-only repeat and branching, while transactions snapshot and restore possible workspace-file changes; external side effects are not rolled back.
Week 1 shifts to knowledge representation: propositional logic syntax, model checking, Modus Ponens/Resolution inference, CNF conversion. Projects: Knights (logic puzzles) and Minesweeper (probabilistic inference).
Week 2 shifts from deterministic to probabilistic: Bayes rule, Bayesian nets with D-separation, Markov chains, PageRank random walks. Projects: Heredity (genotype inference) and PageRank (web ranking).
From SGD to Adam: pick the right optimizer and scale LR with batch size using scaling rules
Week 3 tackles optimization: hill climbing, simulated annealing escaping local optima, CSP framework with AC-3 arc consistency, backtracking with MRV/degree heuristics. Project Crossword builds a crossword puzzle generator.
Regularization isn't just anti-overfitting — mechanisms & combo strategies for WD, Dropout, BN, Label Smoothing
Week 4 enters ML: supervised classification (k-NN, SVM, Perceptron), model evaluation, RL basics (MDP, Q-learning, ε-greedy). Projects: Shopping (purchase prediction with k-NN) and Nim (learning to play via Q-learning).
Hand-write NumPy MLP + backprop → verify with PyTorch Autograd, fully reproducing OCW HW1 core concepts
Week 5 enters deep learning: perceptron to multi-layer nets, backprop chain rule, loss functions, optimizers, TensorFlow/Keras modeling, CNN conv/pool. Project Traffic trains CNN to classify traffic signs.
Lec 4 core: why CNN is the natural choice for grid data — convolution, translation equivariance, pooling, and classic architectures in one go
Week 6 processes natural language: N-gram conditional probability & smoothing, CFG syntax parsing with CYK, TF-IDF vector retrieval, attention mechanism & Transformer basics. Projects: Parser (syntactic generation) and Questions (TF-IDF QA system).
ResNet's skip connections solve degradation, enabling 100+ layer nets; EfficientNet compound scales depth/width/resolution; ConvNeXt absorbs Transformer design to reclaim CV crown.
Synthesis 1: Tracing how seven weeks form a deliberate knowledge arc from symbolic search to language models, revealing the design philosophy from classical AI to modern ML.
Optimization is not an isolated numerical problem: view SGD spectrally, the magnitude of weight updates determines feature learning; Maximal Update Parameterization transfers LR/init across width, and the critical batch size sets the marginal return of trading compute for convergence.
Synthesis 2: Complete comparison of 12 projects — core algorithms, LOC estimates, difficulty tiers, check50 acceptance criteria, transferable skills. With difficulty grading and learning sequence advice.
A Transformer is not an architecture from nowhere: tokens discretize data, attention does soft aggregation, positional codes restore order. Seen next to MLPs/CNNs/GNNs, all of them are special cases of 'weighted aggregation over neighbors'.
Series finale: Retrospecting timeless core from 7 weeks/12 projects, gaps in 2020/2023 recordings vs 2026 reality, free OCW route completeness, and forward roadmap (Transformers, LLM fine-tuning, RAG, Agents, Evaluation).
Training neural nets is closer to engineering than magic: look at the data, overfit a mini-batch to prove capacity exists, then regularize back the generalization; learning rate is always the highest-leverage knob.
An RNN compresses the past into a hidden state, but recurrence makes gradients multiply over time — they either vanish or explode; LSTM decouples 'memory' from 'update' via input/forget/output gates so long-range information flows stably. Attention later replaced it because it reaches any history in O(1).
Representation learning compresses raw data into a 'useful' vector: autoencoders force a meaningful latent space via reconstruction, VQ discretizes it into a codebook, and self-supervision turns 'mask-and-reconstruct' into free supervision.
Similarity-based representation learning does not reconstruct input; it directly shapes latent geometry: pull same-class representations together, push different ones apart. InfoNCE turns this into 'spot the positive among negatives', and alignment / uniformity give it interpretable metrics.
Take a net to infinite width and its random-init output becomes a Gaussian process (NN–GP); its training dynamics freeze into the Neural Tangent Kernel (NTK). This theory analyzes nets and, in reverse, guides us to design the 'right inductive bias'.
Generative models learn the data distribution p(x). Density models model probability directly, energy models use an unnormalized potential + sampler, GANs let a discriminator force realistic samples, autoregressive predicts the next token step by step, and diffusion dodges tricky maximum-likelihood via 'add noise then learn to denoise'.
A single hidden layer can in principle approximate any continuous function (universal approximation), but width can blow up exponentially with dimension; Barron's theorem lets error decay as 1/sqrt(n) independent of dimension for a specific function class; and depth yields exponential width savings on compositional functions — that is the real reason deep beats shallow.
A GNN is essentially 'an MLP with local message passing on a graph' — it generalizes CNN's fixed-grid neighborhood to arbitrary topology. It must satisfy permutation equivariance/invariance. In theory, a first-order GNN's expressiveness is bounded by the Weisfeiler–Lehman graph isomorphism test: some structures it can never tell apart, which is exactly the gap GIN, positional encodings, and subgraph tricks later fill.
The core of VAE is ELBO + reparameterization: log p(x) is replaced with E_q[log p(x|z)] − KL(q(z|x)‖p(z)); the encoder outputs μ/σ and z = μ + σ⊙ε (ε ~ N(0,1)) makes sampling differentiable. Training = reconstruction + KL in tension, which gives rise to β-VAE, posterior collapse, VQ-VAE, and related fixes.
The key to conditional generation is 'feed y into the model': cGAN concatenates y into G/D; cVAE passes y to both encoder and decoder; in diffusion, Classifier Guidance uses gradients from an external classifier to push samples toward a class, while Classifier-Free Guidance trains conditional + unconditional together and linearly combines them at inference — the latter is the standard weapon behind Stable Diffusion and Imagen.
Lecture 1 is the 6.7960 opener: deep learning took off because data + compute + algorithms matured together; the course threads from architectures (CNN/GNN/Transformer) through training, representation, generation, transfer, scaling, and LLMs; ends with a ~30-line PyTorch training loop to confirm your environment works.
OOD failure is not a bug, it's the i.i.d. assumption breaking: covariate shift (image style changes), label shift (class proportions change), concept shift (a word's meaning changes) each need different responses; the most common cause is the model latching onto spurious correlations (using grass as a cue for cows); IRM and domain randomization try to fix this in training data structure, test-time adaptation fixes it at inference.
Transfer learning's core insight is 'features learned on big data are good general-purpose representations': freeze the backbone and train only a linear head when downstream data is tiny; full fine-tune when data is plentiful; reach for LoRA / adapter when compute is tight. SimCLR and MAE removed the need for upstream labels and pushed downstream quality another notch.
Formerly AutoRAG, the managed search primitive: drop files into built-in storage or attach R2 and websites, auto-index with Markdown conversion plus vector and BM25, retrieve with hybrid, RRF, and reranking, and query from Workers via namespace or instance bindings, REST, or MCP.
GPUtw.ai is a Taiwan-based short-rental GPU cloud. Its main value is not maximum scale, but Taiwan data centers, prepaid credits, Jupyter/ComfyUI/Ollama/vLLM templates, Vault storage, and team billing. Public information is enough for a service introduction, not enough for procurement or production endorsement.
Entering '我想找入門的ai課程' in Ask AI showed zero searched posts and triggered a refusal, while Related Reading recommended exactly the right article. The first fix addressed Chinese tokenization, the LIKE fallback, and the Vectorize data path. A second pass added short Han-and-number tokens, post metadata retrieval, and a rule that exposes sources only after both Validation and Critic pass.
HW0 checks CS181 prerequisites in four problems — y=Xw solvability, optimizing an objective, reasoning about randomness, and OLS in Python. The problem that slows you down most is the gap to patch before HW1.
HW1 uses an 800k‑year ice‑core temperature dataset to implement three regression models (OLS, RBF kernel, MLP) and compare them on the same data, laying the groundwork for later classification and deep‑learning assignments.
CS181 2026 is A3 with hw0–6 as the weekly clock (no public recordings); 2025 adds a practical, 2024 has two midterms, 2023 was taught by Weiwei Pan. Start with HW0, then follow hw1→hw6.
Week 0 opens with search algorithms: BFS for shortest paths, Minimax for adversarial play, Alpha-Beta for pruning. Two projects: Degrees (BFS) and Tic-Tac-Toe (Minimax).
Moshi is an iOS/Android terminal app (plus a free Moshi Desktop web UI) that connects over SSH/Mosh straight to your own machine to drive Claude Code, Codex, and other coding agents. The free tier is a complete terminal; Pro ($7.99/mo and up) unlocks Mosh's connection resilience, deep tmux integration, and the diff viewer.
FLUX is Black Forest Labs' image-model family. The Stable Diffusion team launched it in August 2024 with a 12B rectified-flow transformer. Two years later it spans klein 4B ($0.014 and the only current Apache-2.0 model) / 9B, pro ($0.03), flex ($0.05), max ($0.07 with live web grounding), and open-weight 32B dev. FLUX 3 extends Self-Flow to video, synchronized audio, and robot actions. This guide covers the FLUX.1-to-FLUX 3 evolution, three-tier licensing, and model selection.
Speech models split into two lines. Whisper led ASR: its MIT-licensed 1.55B model drove transcription cost toward zero in September 2022; after v2, v3, and turbo cut the decoder from 32 layers to four, OpenAI moved to closed gpt-4o-transcribe. In TTS, ElevenLabs grew to an $11B valuation and $500M ARR, while Kokoro (82M, Apache-2.0) and Chatterbox preserved self-hosting. Speech-to-speech Realtime APIs are now rewriting live conversation.
Sora's February 2024 preview shocked the industry, but the landscape reversed in two and a half years: OpenAI closed the consumer Sora app in April 2026 and scheduled its API for retirement on September 24; Veo 3.1 became the narrative default with native audio and Flow; Kling 3.0 became a unified multimodal model with $240M annualized revenue; and Runway Gen-4.5 briefly led Artificial Analysis in a November 2025 snapshot while defending the professional market through enterprise workflows. This guide compares four families by generation, specifications, pricing, and use case.
Querying “認證” returned only ~10 hits while 149 files (509 occurrences) matched; 41 posts and 76 chunks were found via LIKE, but D1 chunks_fts had 0 rows and unicode61/trigram both returned 0 for 2-char CJK terms. Fix: LIKE fallback with char-level OR first, then trigram migration + pnpm sync, then pagination beyond the hard limit of 12.
MiniMax started as a consumer chat app company, then M2.5 scored 80.2% on SWE-bench Verified at 1/10-1/20 the cost of Claude Opus; M3 (456B total / 45.9B active) became the first open-weight model to clear 59% on SWE-bench Pro, with 1M context powered by their novel Sparse Attention mechanism.
Nous Research doesn't pretrain — they fine-tune and do RL. Hermes 4 scores 96.3% on MATH-500, NousCoder-14B improves Qwen3-14B's coding ability by 7% using only 24K training samples. But the real moat is Hermes Agent: 236K GitHub stars, #19 globally, 3,000 contributors.
DeepReinforce's Ornith 1.5 family, trained with self-improvement RL: the 397B flagship scores 86.0 on SWE-bench Verified, matching Claude Opus 4.8; the 35B-A3B activates only 3B parameters per token yet leads every coding benchmark in its class; the 9B runs on phones. MIT-licensed, fully open-source.
`claude agents` gives you one screen listing every background session, with Needs input, Ready for review, Working, Completed, and related states managed in one table. Press Space to peek, Enter to attach. Combined with cross-session messaging (ListAgents / SendMessage, v2.1.224+), sessions can also message each other; same-machine delivery uses a local socket and never touches Anthropic servers.
Claude Code splits its configuration across the project `.claude/` folder and your home directory — 20+ file locations. Only two mental models matter: settings merge across layers and are enforced; CLAUDE.md and rules concatenate into context as guidance. And every file is committed, gitignored, or Claude-written.
After GitHub PR review is configured, a fleet of agents reviews PRs according to the repo's trigger mode — 20 minutes on average, about $15–25 per review, with findings posted as inline comments on the offending lines. For larger changes, /code-review ultra launches a cloud deep review that reports independently verified bugs in 5–10 minutes at roughly $5–25 per run; Pro/Max plans include 3 free runs.
Claude Code costs accumulate with context size: enterprise deployments average ~$13 per developer per active day and $150–250 per month. This post covers /usage and /insights tracking, six token-saving tactics, and a systematic answer to 'which model should I use': provider-dependent model aliases, effort levels, fast mode ($10/$50 per MTok for Opus 5/4.8), and the advisor tool.
When CLAUDE.md rules are ignored, hooks never fire, or an MCP server shows no tools, the file usually didn't load, loaded from an unexpected location, or got overridden. This guide covers what the diagnostic entries (/context, /memory, /skills, /doctor, /mcp, and more) actually show, safe-mode bisection, and a table of six high-frequency error messages with fixes.
Add Anthropic's official Dev Container Feature (`ghcr.io/anthropics/devcontainer-features/claude-code:1.0`) to `.devcontainer/devcontainer.json` and three steps—write the config, rebuild the container, run `claude` to sign in—put every teammate's Claude Code behind the same container definition. The same definition feeds GitHub Codespaces and CI; a five-step rollout gets the whole team there.
Dynamic workflows let Claude write multi-agent orchestration as a JavaScript script that a runtime executes in the background — up to 1,000 agents per run, savable as a /<name> command. This piece covers trigger methods, the save-and-rerun flow, three fit scenarios (codebase audit, large migration, cross-checked research), and where they differ from Agent Teams.
Claude Code runs an agentic loop — gather context, take action, verify results — until the task is done. This entry to the series breaks down its five tool categories, the model/harness split, and the two safety rails: checkpoints and permission modes.
The official docs split Claude Code's parallel work into 4 approaches: subagents delegate inside one session, agent view lets you supervise background sessions yourself, agent teams coordinate workers through a lead, and dynamic workflows run scripted fleets of subagents with cross-checks; file collisions are always handled by worktrees. Includes a translated comparison table and a three-question decision guide.
Claude Code on the web runs tasks in cloud environments, Anthropic-managed VMs by default or self-hosted environments when routed there: authorize GitHub, dispatch from browser or mobile, start cloud sessions with --cloud, and pull them back local with --teleport. Research preview on Pro/Max/Team; no separate compute charge, but rate limits are shared.
Claude Code ships six permission modes; day to day you cycle Manual, Accept edits, Plan, and Auto with Shift+Tab. On Pro/Max/Team plans, eligible interactive terminal and VS Code sessions start in auto mode by default, with a background classifier reviewing most actions and blocking force pushes, `curl | bash`, production deploys, and more by default. This post covers the four-mode spectrum, permission rule syntax, and organization-level trust config.
Claude Code's prompt caching works by exact prefix matching: a cache read bills at roughly 10% of the standard input rate, but switching models, changing effort, enabling fast mode, toggling MCP servers, or denying an entire tool forces the next turn to reprocess everything. The TTL defaults to five minutes; the main conversation and a few helper requests on a subscription get one hour.
Claude Code writes every session line by line to a JSONL file under ~/.claude/projects/, kept for 30 days by default. This post breaks down --continue vs --resume, session naming rules, /branch fork semantics, and transcript export and cleanup settings.
Work through install and login failures in five steps: verify PATH on your OS, confirm there is only one installation, test downloads.claude.ai for a 200, recover failed OAuth callbacks by pasting the login code or using claude auth login, then finish with claude doctor.
Five classes of runtime fixes: diagnose high memory with /compact plus /heapdump; recover a hung session with Ctrl+C and claude --resume; write large tables to files instead of forcing terminal output; escape autocompact thrashing by reading files in chunks or running /compact with a focus; fix broken search by installing system ripgrep and setting USE_BUILTIN_RIPGREP=0.
Apple Foundation Models (AFM) is Apple's closed-ecosystem AI family. It evolved from a 3B dense model with LoRA adapters in 2024 into five models in 2026. AFM 3 Core Advanced runs a 20B IFP sparse architecture on phones while activating only 1–4B parameters; Cloud Pro runs on Google Cloud NVIDIA GPUs and is refined through Gemini distillation. There is no public API price or third-party benchmark, and access is limited to Apple's Foundation Models framework.
No budget needed: Tailscale plus built-in Screen Sharing is free and the most reliable stack for daily remote work on Mac — upgrade to Jump Desktop only if you want it smoother. This guide compares four options and fixes lid-close and sleep pitfalls in 5 minutes.
The key question in self-hosted inference isn't how fast the engine is — it's your GPU utilization. A fully saturated A100 costs ~$0.70 per million output tokens; at 10% utilization that becomes $7, more than most cloud APIs. This overview maps seven tools across three layers to help you decide which layer you need.
TensorRT-LLM is NVIDIA's open-source LLM inference library (Apache 2.0). It offline-compiles model weights and compute graphs into optimized TensorRT engines, then serves them with custom CUDA kernels, in-flight batching, and multi-dimensional parallelism. The cost: NVIDIA GPUs only, compilation takes tens of minutes, and switching models or quantization means rebuilding.
Text Generation Inference (TGI) is HuggingFace's own LLM inference server, built in Rust and Python. It pioneered continuous batching and Flash Attention in open-source inference engines. The GitHub repository was archived on March 21, 2026, and HuggingFace recommends migrating to vLLM or SGLang. TGI still matters: it defined the architectural baseline that successor engines inherited, and many HuggingFace Inference Endpoints still run it.
You cannot take model vendors' self-reported scores at face value. This guide covers the most important independent evaluation platforms, domain benchmarks, adoption indicators, and official sources in 2026: what each measures, how to read it, where it is biased, and which figures matter for different use cases.
Claude is Anthropic's closed-source LLM family, known for Constitutional AI training, agent capabilities, and coding performance. In July 2026, Opus 5 scored 96% on SWE-bench Verified to claim the coding crown, while Fable 5 led general capability at 83% on LiveBench. Four tiers (Fable / Opus / Sonnet / Haiku) span $1–$10, making this the only family in the series with zero open weights.
Cohere is the only family that ships generation, retrieval, reranking, and multilingual as distinct products. Command A runs 256K context on two GPUs at 111B, Embed v4 does mixed image-text retrieval, Rerank v4 handles 32K semi-structured data, and Aya covers 101 languages — a four-piece stack built for RAG. This post breaks down each pillar's positioning, licensing, and selection guide.
DeepSeek used MLA and MoE innovations to drive inference costs to an industry low. V4 Flash activates only 13B parameters while approaching frontier-model quality and ranks first by OpenRouter usage. This guide traces V1 through V4, the R1 reasoning branch, and how to choose each version.
Gemini is Google DeepMind's native multimodal LLM family, famed for a 1M-token context window and native video/speech input plus scientific reasoning. 3.1 Pro tops GPQA Diamond 94.1% and ARC-AGI-2 77.1% to claim science-reasoning dual crowns, at $2/$12—1/6 of Claude. 3.7 Flash delivers near-Pro agent capability for $0.75/$3.75.
GLM is Zhipu AI (Z.ai)'s open LLM family from Tsinghua's KEG Lab. GLM-5.3 (2026/08) lifts coding +50% over the previous generation, hits 84.5% on CyberGym ahead of Anthropic Mythos 5 and OpenAI GPT-5.6 Sol, and scores 60 on the Artificial Analysis Intelligence Index tied with Kimi K3 for open-source #1. The only frontier open model trained entirely on Huawei Ascend.
GPT is OpenAI's LLM family, from 117M parameters in 2018 to the three-tier GPT-5.6 Sol/Terra/Luna lineup in 2026, serving 1B+ users and 2M enterprise customers. GPT-5.6 Sol leads LiveBench 81.1%, Terminal-Bench 2.1 88.8%, and Artificial Analysis Coding Agent Index 80 across multiple agentic benchmarks, while OpenAI's first open-weight model GPT-OSS ships under Apache 2.0.
Grok is xAI's LLM family: founded July 2023, opened with a 314B MoE under Apache 2.0 in March 2024, and two and a half years later spans Grok 4.6 (500K, $2/$6, four reasoning levels), Grok 4 Fast (2M), Imagine for image/video, and Grok Build for terminal coding — its moat is distribution (X / grok.com / Tesla / Bedrock), not single-model supremacy. This post traces Grok 1→4.6, sub-line positioning, pricing, and licensing traps.
Kimi is Moonshot AI's LLM family, born from ultra-long context. Kimi K3 (2026/07) is the world's first open 3T-class model—2.8T params, 104B active, 1M context, scoring 60 on the Artificial Analysis Intelligence Index tied with GLM-5.3 for open-source #1. Its Kimi Delta Attention brings a 2.5× scaling efficiency gain.
Llama is Meta's open-source LLM family, with the largest enterprise deployment footprint and the most mature ecosystem. Llama 4 Scout (10M context) and Maverick (17B active / 400B total MoE) are the current open multimodal benchmarks, but Meta pivoted to closed-source Muse Spark in April 2026—Llama 4 is likely the last major open Llama, and its license is not truly open (Llama 4 Community License, separate license required above 700M MAU).
Mistral is Europe's most successful AI startup, cutting through the market with a 'smaller, faster, cheaper' strategy and European data-sovereignty positioning. Mistral Large 3 is Europe's strongest commercial LLM, Small 4 is the 24B efficiency king, and Medium 3.5 is the open Modified-MIT model optimized for agentic coding. Its moat is not technical scale but the 'European compliance' card.
Qwen is the most-downloaded model family on HuggingFace, spanning sizes from 0.8B to 2.4T. In August 2026, Alibaba open-sourced a Max-tier flagship for the first time (Qwen3.8-2.4T-A95B) — but swapped the customary Apache 2.0 license for custom terms. Meanwhile the other new release, Qwen3.8-27B, runs native vision on laptop-class hardware and is the only one shipping under Apache 2.0. This post traces the family from 2023 through generation 3.8, explains how the open line and the commercial line split apart, and helps you pick the right model at each tier.
In 2026, AI models span seven major categories and more than 20 subcategories. This introduction to the AI Model Families series maps use cases to models and models to families, with current rankings and selection advice for each use case.
At Google I/O 2026, Antigravity CLI (agy) replaced Apache 2.0 Gemini CLI with a closed-source Go binary. Technical upgrades — multi-agent orchestration, native sandbox, millisecond startup — but free tier cut 98%, open-to-closed source, 28-day transition window. Community reaction was sharp.
Grok Build is xAI's Rust coding agent — 845K LOC, 8 parallel sub-agents, Arena Mode. May 2026 beta, July open-sourced (Apache 2.0) — but the direct trigger for open-sourcing was a privacy incident: it silently uploaded entire repos (including SSH keys, .env files) to Google Cloud Storage at a 27,800x traffic ratio. The exfiltration code remains in the binary, disabled only by a server-side flag.
In August 2026, Meta Superintelligence Labs released Muse Code beta. Closed-source static binary, Muse Spark 1.2 model, parallel persistent sub-agents with worktree isolation. The biggest controversy is pricing: Standard at $1.25/$4.25 per M tokens, or Contributor at $0.10/$0.20 — 20x cheaper, but your code enters Meta's training pipeline.
Self-hosted inference servers fall into three layers: execution engine (llama.cpp), serving engine (vLLM, SGLang), and model management platform (Ollama, Xinference, Triton). Picking the right layer matters more than picking the right tool — ask where your bottleneck is before deciding where to add complexity.
Xinference wraps vLLM, SGLang, llama.cpp, Transformers, and MLX under a single management layer, using a Web UI and OpenAI-compatible API to manage LLMs, embedding, rerank, speech, and image models — suited for self-hosted deployments that need multiple model types to coexist. But the management layer's parsing logic also creates a larger attack surface than pure serving engines (CVE-2026-61539 is a case study).
Agent Platform uses a Cloudflare-first architecture: local `npm run dev` runs Node-based simulations, while production maps to Workers + Workers Assets + D1 + KV + R2 + Vectorize + Queues + Workflows + Durable Objects + Workers AI. The Runtime interfaces stay the same (InMemory → Cloudflare implementations), so upper layers migrate without noticing. Deployment requires only `wrangler login` → create resources → fill in IDs → `wrangler secret put` → `wrangler deploy`. CI/CD watches the main branch and runs typecheck + build + dry-run + migration + deploy.
Evaluation is Agent Platform's quality immune system: instead of collecting statistics only after a run, it enforces checks throughout Pre-run, In-run, and Post-run execution. Seven eval categories cover Flow → Step → Skill → Artifact → Evidence → Policy → Regression. A Skill release must pass five gates—Trigger, Functional, Policy, Regression, and Human Review—and any failure blocks it. The Learning Loop moves from Run signals through Proposal, Human Review, Sandbox Eval, Quality Gate, and Publish, under one strict rule: agents propose, humans review, and eval gates decide whether a change can ship.
Flow Runtime is the heart of Agent Platform: a Flow becomes immutable when published, each Run is bound to a specific version and preset, Steps move through a DAG according to edge conditions, every boundary saves a checkpoint, and resume/retry-step preserves the complete trace history.
Observability is a first-class capability, not logging added after the fact: a structured trace connects FlowRun→StepRun→SkillInvocation→ProviderCall→ToolInvocation→GuardResult→EvidenceItem→ArtifactVersion. The Evidence Store traces every claim back to its source, excerpt, citation, confidence, and conflicts. Artifact versioning supports approve/reject/regenerate without deleting history. Context Snapshots allocate token budgets by category and record automatic compression when a block exceeds its budget. Procedural, episodic, and semantic memory can be written only through proposals reviewed by a human.
Agent Platform turns AI agents from a blank chat window into a structured workflow platform whose behavior can be defined, versioned, observed, verified, and improved. Its built-in Deep Research seed flow demonstrates the complete feedback loop.
The Policy Engine acts as the Agent Platform's constitution and enforcement layer: policies are versioned and bound to flows and presets; four guard layers enforce rules at step boundaries; budgets cap cost, tokens, runtime, iterations, and tool calls; external writes require human approval; loop detection trips circuit breakers; and escalation records provide an auditable trail. Rules are configuration-driven, so adding one means changing JSON rather than hard-coded logic.
The Provider Router is Agent Platform's model and tool gateway: it unifies 30+ providers, MCP tool discovery, step-local permission control, fallback chains with RRF fusion, and an OpenAI-compatible Proxy that existing SDKs can use without code changes. It is configuration-driven rather than hard-coded, with provider-health-aware routing.
A Skill is a versioned, installable, and auditable capability package. Its dual-file architecture separates metadata from instructions, explicit binding replaces model-driven routing, and every invocation is recorded. The Learning Loop turns run signals into proposals, sandbox evaluations, human review, and publication while enforcing the principle: agents propose, humans review, and evals serve as the gate.
Groundlane is an open-source TypeScript remote MCP server (v0.1.0) giving AI agents web_search, web_fetch, and web_extract through a single stable contract, with auth, provider routing, and resource limits kept at the operator boundary.
Hands-on parameter choices and response structures for web_search (ten adapters, RRF merge, dual-provider default), web_fetch (format/render strategies, finalUrl provenance), and web_extract (CSS selector determinism, no implicit LLM step), with verifiable error boundaries.
A four-dimension comparison (determinism, replaceability, identity boundary, operational cost) between Groundlane's controlled remote MCP contract and traditional local approaches (WebFetch, stealth_fetch, puppeteer, requests), with verifiable scenario recommendations.
Based on the in-site groundlane skill (mcp__groundlane__*) and usage-modes rules, this part describes reproducible steps for reference verification and digest data collection — without assuming unimplemented features or using deprecated stealth_fetch.
A reproducible checklist of the most common operational pitfalls: truncated results from fixed caps, selector errors tied to DOM stability, render-mode cost/determinism tradeoffs, version-change verification (v0.1.0 preview), and the non-negotiable security boundaries (URL policy, auth, concurrency, budget).
US-stock LLM agents have attracted nearly 100,000 GitHub stars, yet no Taiwan-stock project has even passed 10. I consolidated three side projects into a Taiwan-stock research agent where every conclusion must first survive a backtest; this article explains why.
Five analysts fan out in parallel within one superstep, so latency is max rather than sum; backtesting and reflection stand before synthesis, restricting the LLM to explaining evidence that already exists.
Only two roles call an LLM; every other analyst remains fully programmatic. Each call follows an Anthropic API → local Claude CLI → rules-based degradation chain, and cost accounting trusts only provider-reported values—unknown cost is never treated as $0.
This project has one core rule: every LLM conclusion must first pass a historical backtest of the same signals. When expectancy is negative, synthesis cannot issue an optimistic verdict. Each of the four traps that make backtests lie has a programmatic countermeasure.
I do not measure whether the agent ‘feels accurate.’ I freeze parameters in walk-forward OOS tests, record a hash of every input in run cards, and keep the honest 5/10 = 50% golden-eval baseline so the agent has to admit that it is not accurate yet.
Numbers are the easiest part of an LLM report to hallucinate. I therefore put every trusted number into a SHA-256-addressed evidence manifest and let the LLM cite only {{fact.id}} placeholders. If it writes a bare number, the entire output is discarded and replaced with a deterministic template.
A research request first becomes a ResearchPlan that requires human approval. External documents must be fetched in full, and verbatim quotes must be verified before they can enter a report. Quant review is always append-only, and free-text feedback never flows back into a prompt. This is the complete M5 Copilot loop.
Three frozen Pydantic contracts weld the boundary between a research artifact and order-placement authority shut: content addressing, eight hard gates, and paper-only execution, while the agent never touches credentials.
The full deployment path for a Python agent, from local uv run to Docker to a public API on Cloudflare Containers: the Worker enforces authentication, the Container runs FastAPI, secrets never enter the image, and the service sleeps automatically after 10 idle minutes—the right way for a side project to save money.
Ably manages global realtime connections, channels, presence, and short-window recovery; applications still own idempotency, durable business state, token capabilities, and offline resynchronization.
An agent should execute one task with a short-lived, audience- and permission-restricted credential while preserving user and agent identities, execution-time authorization, confirmation, and audit lineage.
Agent execution must constrain kernels, filesystems, processes, networks, credentials, and tool authorization; sandbox escape is only one path, and an overpowered API token is often more direct.
Linode is now the compute foundation of Akamai Cloud Computing; VMs, LKE, storage, and databases retain regional and network boundaries, so the Akamai brand does not imply complete integration.
Algolia packages indexing, search-as-you-type, facets, and UI components as a hosted service; it ships quickly, but data synchronization, relevance, and usage costs remain your responsibility.
Kafka is a distributed log ordered by partition and retained by policy. Consumer groups divide work through offsets, while exactly-once processing holds only inside boundaries covered by Kafka transactions.
Pulsar separates serving from storage: stateless brokers handle connections while BookKeeper stores ledgers and subscription cursors. Elasticity and multi-tenancy come with more operational components.
Appwrite combines Auth, TablesDB, Storage, Functions, Realtime, and Messaging behind consistent APIs; Cloud and self-hosted products resemble each other but have different operational ownership.
assistant-ui separates Agent Chat into headless React primitives, a conversation runtime, and backend adapters, so the UI does not have to bind directly to one model SDK's message state.
App Runner packages build, deployment, TLS, load balancing, and autoscaling as a web service, trading orchestration control for a simpler platform with explicit VPC, instance, and health boundaries.
Fargate removes container-host operations, but task definitions, ECS services, VPCs, IAM, scaling, deployment, and observability remain your system.
Lambda fits short-lived, event-driven, bursty work; its design center is invocation, retries, idempotency, and downstream capacity—not merely smaller containers.
SQS is a pull-based durable queue and SNS is a push-based topic. Reliable fan-out commonly connects one SNS topic to multiple SQS queues rather than sharing one queue across services.
App Service manages web runtimes, TLS, deployment, and scaling, while capacity, cost, and isolation live in the shared App Service Plan rather than one app.
Azure Container Apps hides Kubernetes while exposing HTTP/TCP ingress, revisions, KEDA scaling, jobs, and Dapr; replica concurrency, event idempotency, VNet design, and identity remain yours.
Better Auth unifies login, sessions, providers, and plugins; applications still own resource authorization, revocation latency, and policy for agent actions.
Better Auth trades a managed identity platform for an in-app library and your own database; that gives you control, but migrations, security updates, and incident response become your responsibility.
Bright Data splits web data access into four layers: proxies preserve control, Web Unlocker returns unblocked content, Browser API hosts interactive browsers, and Web Scraper APIs or Datasets deliver structured data.
CapRover wraps Docker Swarm, Nginx, and captain-definition in a simpler PaaS; stateless apps scale, while local persistent apps remain pinned to one node.
Clerk's real value is an integrated identity lifecycle, not a sign-in box; resource authorization, tenant isolation, and business-data consistency remain your application's responsibility.
Durable Objects map a name or ID to a globally unique, single-threaded actor with private SQLite storage. They fit per-room, per-user, per-tenant, and per-run coordination boundaries; the real design question is where the object key belongs.
Cloudflare Queues is the message queue beside Workers: producers enqueue slow work, consumers process it with batching, ack/retry, delays, and DLQs. It is good for single-step background jobs; durable multi-step state belongs in Workflows.
CodeQL builds a code database with language extractors, then queries syntax, types, calls, control flow, and data flow; its depth depends on models and carries extraction and query-maintenance costs.
Convex combines typed backend functions, a transactional document database, and reactive query subscriptions; correctness depends on separating deterministic mutations from side-effecting actions.
Coolify controls Docker, proxies, and resources on your servers over SSH; deployment gets easier, but OS, security, capacity, data backup, and recovery remain yours.
CopilotKit is more than a chat box. Its React components, AG-UI events, shared state, and interrupt flows connect an agent's execution to an existing product interface.
CoreWeave is more than rented GPUs: it combines Kubernetes, GPU networking, storage, and inference into AI infrastructure, while platform engineering and capacity governance remain yours.
Crusoe offers both Infrastructure Cloud and Managed AI: GPU VMs and clusters provide control, while serverless and dedicated inference provide higher abstractions with different responsibilities.
DeepSeek Harness (dsh) is DeepSeek's official open-source coding agent framework, released as a v0.1 developer preview on 2026-08-13, accumulating 184,000+ stars in 9 days. Its core is the Cordis plugin kernel — model adapters, tools, agent loop, and UI are all swappable plugins. Four runtime modes, with the ability to use Claude Code and Codex as sub-agents. Web UI first, no native CLI.
The new Deno Deploy runs application revisions on Deno 2; understand it through timelines, contexts, databases, and telemetry rather than Deploy Classic assumptions.
DigitalOcean App Platform composes Services, Workers, Jobs, Static Sites, and Functions into an App, with an App Spec as the reviewable deployment contract.
DigitalOcean covers common product architectures with Droplets, DOKS, Managed Databases, and App Platform; simplicity comes from a smaller surface, not from eliminating OS, network, backup, or HA design.
Django combines data models, migrations, authentication, admin, forms, and security defaults into one system; using it well still requires understanding QuerySets, middleware, async boundaries, and production settings.
Dokku combines a Git receiver, buildpacks or Dockerfiles, process models, Nginx, and plugins for a single-host Heroku workflow; simplicity comes from narrow orchestration scope.
Dokploy supports single-container Applications and Compose or Stack, while treating one host, independent remote servers, and a Swarm cluster as distinct topologies.
DuckDB is an in-process columnar OLAP database for Parquet, CSV, and DataFrames, not a conventional multi-user OLTP server for web applications.
Elasticsearch and OpenSearch both build text analysis, BM25, aggregations, and vector search on Lucene, but licensing, governance, hybrid-search APIs, and managed ecosystems have followed separate paths since the 2021 fork.
Elysia connects runtime schemas, TypeScript inference, OpenAPI, and Eden clients into one contract pipeline, but Bun-first performance, plugin scope, and cross-runtime compatibility still require separate verification.
Fastify is more than benchmarks: plugin scopes, hooks, decorators, and compiled JSON Schema build composable Node.js APIs with explicit request and response contracts.
Firebase moves quickly because client SDKs directly access managed Auth, Firestore, and Storage; the real backend contract lives in data models, Security Rules, Functions, and cost limits.
Fly.io places fast-starting Machines in chosen regions and connects them through Fly Proxy and private 6PN; cross-region state consistency remains your hard problem.
gitleaks scans files or Git patches with rules, regexes, entropy, and allowlists; after a finding, revoke and rotate first rather than merely deleting a file or rewriting history.
Model Armor can inspect prompt injection, jailbreaks, sensitive data, malicious URLs, and unsafe content at runtime; it is a probabilistic detector, not an authorization or sandbox boundary.
Cloud Run is more than an HTTP container platform: choose request-serving, run-to-completion, or always-on pull work first, then design concurrency, identity, and scaling.
GKE manages the Kubernetes control plane and Autopilot manages most node infrastructure, while workloads, policy, networking, upgrade compatibility, and cost governance remain yours.
A GraphQL schema defines available capabilities; GraphQL Code Generator combines it with actual queries, mutations, and fragments to emit precise results, variables, and typed documents.
gRPC generates cross-language stubs from Protobuf services. A Connect server can support gRPC, gRPC-Web, and the Connect protocol together, avoiding a translating proxy for browsers.
Hatchet unifies regular tasks, DAGs, and durable tasks behind a Postgres-backed control plane. Durable tasks checkpoint at waits and child tasks, then replay deterministic orchestration code on recovery.
Hetzner Cloud offers lean IaaS through servers, networks, volumes, load balancers, and firewalls; its price advantage is real only after patches, HA, backups, egress, and on-call are counted.
Hono RPC exports a route's `typeof AppType` so `hc` can infer inputs, response bodies, and status codes. The shared artifact is a TypeScript type, not an independent wire schema.
Inngest makes steps the persistence boundary for ordinary TypeScript, Python, and Go functions. Recovery re-executes the function while memoized steps avoid repeating completed side effects.
Kamal deploys immutable images from an operator over SSH and switches traffic through kamal-proxy; it is not a scheduler and does not operate hosts or data.
Koyeb groups Services in Apps, runs revisions as Instances in selected regions, and integrates global routing, autoscaling, private discovery, and CPU or GPU compute.
Kubernetes is fundamentally API objects, controllers, and reconciliation loops—not YAML; it manages workload lifecycles without solving application state, data consistency, or organizational governance.
Kysely derives query results from database types while preserving SQL and escape hatches, but teams must still keep migrations, the live schema, and generated types aligned.
Lambda Cloud provides on-demand GPU VMs and 1-Click Clusters; it offers direct AI compute environments rather than automatically solving training, serving, and MLOps.
Liveblocks packages rooms, presence, conflict-free storage, comments, and notifications as managed product primitives; adoption still requires alignment with existing auth, canonical databases, and data lifecycle.
MongoDB fits aggregate-oriented data and evolving documents; the hard decisions are embedding, transaction boundaries, indexes, and shard keys.
MySQL offers a mature ecosystem, InnoDB transactions, and predictable operations, but teams must still own indexes, isolation, replication lag, and migrations.
Core NATS is storage-free, at-most-once pub/sub. JetStream adds streams, consumers, acknowledgments, retention, and replay. They share subjects but expose fundamentally different reliability contracts.
Nebius combines GPU VMs and clusters, Kubernetes, Slurm, storage, and Serverless AI; choose the responsibility layer before comparing hardware and price.
Neon is serverless PostgreSQL; Turso Cloud currently follows the libSQL and SQLite-compatible path. Their compatibility boundaries are fundamentally different.
NestJS is valuable not for decorators alone, but for Modules, Providers, DI, and a predictable pipeline across HTTP, GraphQL, WebSocket, and microservice architectures.
Netlify centers on atomic deploys and previews, then adds Functions, Edge Functions, Blobs, and Database; each runtime and state layer has distinct consistency and limits.
ngrok is an agent-initiated reverse proxy and ingress, not a VPN for the whole machine; public endpoints still need explicit authentication, traffic policy, and data boundaries.
Nhost uses PostgreSQL as the source of truth, Hasura to generate GraphQL, and connects Auth claims, role permissions, Storage, and Functions into one platform.
OMP 2 is no longer a Pi fork. The entire codebase has been rewritten from scratch in Rust, with ~41 crates covering a custom bash engine, GPU-accelerated GUI, embedded CPython 3.14t, gRPC transport, and Kokoro-82M TTS. Currently in pre-release with no stable version yet.
openapi-typescript converts OpenAPI 3.0 and 3.1 into pure TypeScript types; openapi-fetch then infers methods, literal paths, parameters, and response unions from that schema.
Opencode 2 is a major rewrite led by Anomaly (Dax Raad). Runtime migrated from Bun to Node.js (memory issues), desktop from Tauri to Electron (WebKit perf and Node integration), v1 API intentionally incompatible. New: multi-tab parallel sessions, persistent backend service, HTTP API + SDK. Currently beta, stable estimated ~September 2026. ~200K stars.
OpenStack combines Keystone, Nova, Neutron, Glance, Placement, Cinder, and other services into multi-tenant IaaS; adopting it means staffing a cloud platform team, not finishing an installation.
OCI is a full hyperscale cloud; architecture starts with tenancy and compartment IAM, region/AD/fault domains, and VCNs before selecting Compute, OKE, databases, and storage.
oRPC supports implementation-first and contract-first APIs, offers an RPC client, and can expose the same router through OpenAPI 3.1.1 HTTP endpoints.
OVHcloud combines Public Cloud, OpenStack APIs, Managed Kubernetes, vRack, and dedicated or private cloud; that flexibility also creates more networking and responsibility boundaries.
Oxlint has grown from a fast ESLint companion into a standalone linter with type-aware rules and JavaScript plugins. Migration depends on rule, framework-file, and plugin compatibility—not only a 50–100x benchmark.
Pagefind scans static HTML after an Astro build and ships its index with a WebAssembly search runtime; the browser fetches only the index chunks required by a query, so no search server is needed.
PartyKit concentrates WebSocket coordination in room-keyed stateful servers for multiplayer and presence, while durable documents, authorization, hibernation, and platform ownership still need explicit design.
Pi v0.84.0 (2026-08-06) promotes the AgentHarness v2 API to stable. Lane-based v4 Session model makes operations durable and interruptible. CBOR replaces JSON, Unix sockets replace HTTP. Earendil Inc. (Armin Ronacher's PBC) behind it has secured initial funding. 95.4K stars, still MIT, still minimal.
PocketBase packages SQLite, collections, Auth, file storage, SSE realtime, and an admin UI into a small executable; deployment is easy, but single-host and pre-v1 compatibility limits matter.
Promptfoo plugins generate risk probes, strategies transform attacks, targets execute the system, and graders judge outcomes; useful red teams exercise the full agent application rather than only a foundation model.
Protobuf defines binary messages with stable field numbers; Buf adds modules, linting, remote plugins, generation, and breaking-change checks to govern those schemas.
Proxmox VE integrates VMs, containers, clusters, HA, storage, and backup; it simplifies virtualization management while hardware, quorum, networks, capacity, and DR remain yours.
Pulumi lets general-purpose programs register cloud resources for a deployment engine, providers, and stack state to preview and update; greater language power demands stronger abstraction discipline.
RabbitMQ's strength is routing through exchanges, bindings, and queues. For replicated work, default to quorum queues and combine publisher confirms, manual acknowledgments, and idempotent consumers.
Railway is not merely one-click deployment; it puts container services, environments, variables, and private networking into one operable application project.
Ray Serve is a distributed serving layer on Ray. Deployments and handles compose Python service graphs, while replicas, CPU/GPU scheduling, autoscaling, and model multiplexing handle orchestration; it complements rather than replaces vLLM or SGLang.
Redis Streams stores replayable entries with `XADD`; consumer groups add a Pending Entries List and `XACK`. It is more durable than Pub/Sub, but it does not automatically become Kafka.
Redpanda reimplements a Kafka-compatible event log with C++/Seastar, thread-per-core execution, and a Raft group per partition. Client compatibility is broad, but operational and edge semantics still require testing.
Render's value exceeds turning a repository into a URL: distinct service types model public HTTP, private listeners, queue workers, cron, data stores, and Blueprint infrastructure.
Renovate is more than an update-PR bot: packageRules, grouping, schedules, minimum release age, and automerge policy determine update speed, review noise, and supply-chain exposure.
Replicate abstracts GPUs behind versioned models, predictions, Cog, and deployments; integrators still own version pinning, async workflows, webhook verification, data persistence, and spending limits.
Restate journals operations and results, then re-executes handlers while skipping completed work. Virtual Objects and Workflows add keyed state, single-writer semantics, and long-lived coordination.
RunPod Pods fit interactive and persistent GPU work, while Serverless fits queued or load-balanced inference; choosing incorrectly mixes persistence, cold starts, and retry semantics.
Scaleway now spans compute, Kapsule, serverless, databases, storage, AI, and IAM rather than only low-cost VMs; maturity and integration still require per-region verification.
Scrapy separates crawling into the Engine, Scheduler, Downloader, Spider, Item Pipeline, and middleware; it fits high-volume, rule-driven HTTP crawling where you need control over scheduling, throttling, retries, and storage.
Selenium drives real browsers through standardized WebDriver sessions, making it useful for cross-browser workflows, existing test assets, and remote Grid capacity; it can render JavaScript applications, but it does not guarantee bypassing CAPTCHAs or other anti-automation controls.
Semgrep lets teams express SAST policy with source-like patterns and taint rules; rule quality depends on positive and negative tests, framework modeling, and exception lifecycle.
SSE sends text/event-stream over ordinary HTTP, with browser reconnection and Last-Event-ID; simple transport is not durable unless the server retains events behind that cursor.
SGLang is an inference engine for generative models. RadixAttention reuses KV cache across shared prefixes, while OpenAI-compatible APIs, structured output, and multi-GPU parallelism support production LLM serving; it is not a complete product backend.
Sigstore provides identity-bound signing, short-lived certificates, and transparency logs; SLSA describes trustworthy build provenance. They protect only when admission verifies identity, issuer, digest, and build expectations.
Snyk maps code, open-source, container, and IaC findings to projects, remediation paths, and developer workflows; successful adoption depends on baselines, ownership, and executable policy.
Socket.dev goes beyond CVEs by analyzing install scripts, obfuscation, network and shell access, and ownership changes when packages enter a dependency diff.
Socket.IO is an event protocol and runtime over WebSocket or long-polling, not a native WebSocket compatibility layer; ordering, arrival, recovery, and horizontal scaling need separate designs.
Speakeasy records OpenAPI, Overlays, targets, and generator versions in `.speakeasy/workflow.yaml`, enabling local or CI generation, compilation, and publishing of multi-language SDKs.
SST v3 composes cloud resources through TypeScript, high-level app components, Pulumi and Terraform providers, and resource linking; it is application-first IaC, not a hosted PaaS.
Stainless uses OpenAPI plus its configuration to generate multi-language SDKs, docs, CLIs, and MCP servers. Its value is a continuous preview, publishing, and upgrade pipeline rather than one-off codegen.
Stytch is an API-first managed identity platform: choose the Consumer or B2B model, converge authentication factors into sessions, then enforce organization and RBAC boundaries on the server.
Teleport is a protocol-aware infrastructure access platform: its Auth Service signs short-lived credentials, while Proxies and Agents mediate SSH, Kubernetes, database, and app access with audit evidence.
Terraform compares provider schemas, configuration, state, and real APIs to create a plan and apply it; controlled state and change workflow matter more than HCL itself.
Triton Inference Server serves TensorRT, ONNX, PyTorch, and other models through consistent HTTP and gRPC APIs. Its defining tools are the model repository, dynamic batching, instance groups, and ensembles—not LLM-specific KV-cache scheduling.
tRPC lets a client reference the server router type without a separate schema or code generation. Version 11 also has an official, alpha-stage OpenAPI 3.1 generator.
ts-rest describes methods, paths, status codes, and schemas in a shared contract, providing end-to-end server and client types without a code-generation step.
Twingate uses clients, connectors, a controller, and relays to narrow user authorization to specific resources; it is managed ZTNA rather than a general peer-to-peer overlay.
TypeScript 7 rewrites the compiler and language service in Go. The order-of-magnitude gains come from native execution and shared-memory parallelism, while old APIs and compiler options define the migration cost.
Typesense is a search server centered on instant, typo-tolerant keyword search. Collection schemas, field weights, facets and sorting are enough to build site search, with a choice between self-hosting and Typesense Cloud; Chinese fields need locale: zh, and domain terminology may require custom segmentation.
Vercel binds framework build output, previews, CDN caching, and Functions into deployments; deep integration adds speed while defining runtime, locality, cost, and portability boundaries.
Vite 8 replaces the esbuild-for-development and Rollup-for-production split with Rolldown. Speed is the visible result; consistent bundler semantics across development and production are the deeper change.
Vitest's advantage is not merely a familiar Jest-style API. Tests share Vite transforms, aliases, and plugins with the application; Browser Mode adds real-browser confidence but does not replace full E2E testing.
Vultr spans VMs, bare metal, GPUs, VKE, databases, and storage; breadth and regional choice help, but product availability alone does not create an integrated architecture.
WebSocket supplies a duplex message transport, not auth renewal, schemas, acknowledgements, replay, rooms, or backpressure policy; those layers determine production correctness.
WireGuard is a small, explicit layer-3 encrypted tunnel that binds public keys, peers, and AllowedIPs, but it does not supply identity, device management, or a policy control plane.
WorkOS lets a B2B SaaS add SAML/OIDC, SCIM, and audit exports around one organization identity model; application authorization and data governance remain your responsibility.
Yjs uses shared types and commutative, associative, idempotent binary updates to converge concurrent edits; it does not prescribe transport or include authorization, persistence, or domain conflict resolution.
ZeroTier places devices on a managed virtual L2/L3 network, attempts peer-to-peer transport, and uses a controller to publish membership and policy; it resembles software-defined networking more than a single tunnel.
zizmor performs domain-specific static analysis on workflow and action YAML for template injection, broad permissions, artifact credential leaks, and unpinned uses; it does not analyze called shell scripts.
Zodios uses a central Zod endpoint definition for Axios client types, runtime validation, and aliases, with optional Express and OpenAPI packages.
Scrapy owns crawl flow and data models, Zyte API handles fetching, browsers, and anti-bot infrastructure, and Scrapy Cloud adds deployment, scheduling, and output; each layer can be adopted independently.
The primary criterion has not changed: it is still adoption — and AI makes it matter more, not less, because more users means more training data means higher agent accuracy. The five criteria this series collects (machine-readable docs, types, whether the source is in your repo, data shape, machine-callability) are for breaking ties when adoption is comparable, or for costing out what picking the less popular option will charge you.
The AI SDK splits an AI message into a parts array — text, reasoning, source-url, tool-* — each an independent typed fragment (introduced in v5, unchanged since). That data structure dictates how modern AI conversation UIs are written: render by switching on part.type, handing each fragment to its component. This post unpacks the design logic of the parts model, useChat's streaming behavior, and how it became the foundation for component libraries like AI Elements.
Drizzle ORM is a SQL-first TypeScript ORM — its query builder reads like SQL, so queries written by agents are auditable in diffs. Zero dependencies, ~7.4 KB gzipped, native support for edge databases like Cloudflare D1, Neon, and Turso. Still at version 0.45.2 with no 1.0, yet weekly downloads have reached 16.9 million — surpassing Prisma's 13.8 million.
llms.txt is a convention proposed by Jeremy Howard on 2024-09-03 (the spec is now at v2): a Markdown index at your site root written for LLMs. Hand-tested across six frontend docs sites: TanStack, shadcn, Zustand, AI SDK, and Next.js all ship it; React Router is the lone 404. The companion llms-full.txt (full-text version) is live at Anthropic, Cloudflare, and others. This post covers the spec, who uses it, and why it has started to influence library selection.
Component distribution used to offer two roads: npm packages (black-box dependencies) or manual copy-paste. The shadcn registry standardizes a third — components described as JSON with embedded source and dependencies, installed by CLI straight into your repo as your own code. Anyone can host a registry (AI Elements is one), and the official MCP server lets AI agents browse and install components directly.
Supabase isn't just an open-source Firebase alternative — its core design builds Auth, Storage, and Realtime entirely on PostgreSQL schemas and WAL. The result: everything is queryable with SQL, pgvector works out of the box, and AI agents can operate the entire platform by writing SQL. 108k GitHub stars, Apache 2.0, free tier with 500 MB database.
Self-hosting an agent that runs 24/7 means opening something on your own network that must be reachable from outside and must never sit on the public internet. This post takes apart what each Tailscale mechanism actually solves: the tailnet for reachability, subnet routers for private resources, tags plus ACLs for the permission boundary, and seconds-fast policy propagation plus Tailnet Lock for revocation. Pricing checked 2026-08: Personal is free, up to 6 users, unlimited user devices, 50 tagged resources included.
TanStack Router (1.0 in December 2023, ~20M weekly downloads) makes paths, params, and search params compile-time inferred: navigating to a nonexistent route is a type error, not a runtime 404. This post unpacks its three core designs — type safety, first-class search params, and Query-integrated loaders — and why AI agents writing code amplifies their value.
Temporal is a durable execution platform (Server 1.31.2, Python SDK temporalio 1.31.0, MIT, verified 2026-08). What separates it from BullMQ / Celery isn't scale but the guarantee: a queue guarantees a message gets consumed, Temporal guarantees a multi-call process runs to completion. The price is that Workflow code must be deterministic — and LLM calls are inherently non-deterministic. This post covers how to resolve that tension and when the constraint isn't worth it.
Trigger.dev is an Apache 2.0 durable task platform (v4.5.12, checked 2026-08) that uses CRIU to snapshot entire Node.js processes for pause and resume. Unlike Temporal's replay model, it never re-executes your orchestration code and imposes no determinism constraint — LLM calls go directly in the task. The tradeoff: snapshots can't preserve TCP connections (you reconnect manually), and checkpointing is cloud-only — self-hosted deployments don't get it.
WebMCP lets a page register its own functions as agent-callable tools via document.modelContext.registerTool(), replacing the agent's guess-the-button DOM scraping. Chrome opened an origin trial in 149 and estimates stable in 157; Edge followed in 150. But WebKit has formally opposed it ('an agent acting on a user's behalf is, in effect, assistive technology... the site should not single it out for different treatment') and Mozilla filed neutral. This post covers both APIs, where the security gates sit, and whether to invest now with one and a half engines behind it.
On 109 posts that genuinely contain Mainland vocabulary, zhtw-mcp scored 29.4% precision at 85.2% recall; twlint scored 21.2% / 82.5% — but 195 of twlint's error-level findings are legitimate Traditional characters misread as Simplified (干→幹 60 times, 只→隻 15), so --fix corrupts the text. The most useful result was not a winner: zhtw-mcp found five Mainland terms my own list had missed, and correctly declined to flag one it wrongly included (審計). These tools calibrate your wordlist; they do not replace it.
Zod's 224M weekly downloads (checked August 2026) put it far beyond 'form validation library': API boundaries, environment variables, route search params, LLM tool schemas and structured output all run on the same schemas. The core mechanism is one definition, two payoffs — runtime validation and static types derived from a single source. Zod 4 (on npm July 2025) is faster, slimmer, and easier on tsc.
Aider is a terminal AI pair programmer dating back to 2023 (Python, Apache-2.0, ~48.3k stars), designed against the grain of today's autonomous agents: you control context by hand with /add, every edit becomes its own atomic git commit, and architect/editor mode splits planning from editing across two models. But note the maintenance cadence: the latest PyPI release is 0.86.2 from 2026-02, the last commit was 2026-05, and the site still recommends Claude 3.7 Sonnet and o1.
Amp spun out of Sourcegraph in December 2025 as Amp Frontier Corporation, and its npm package moved from @sourcegraph/amp to @ampcode/cli. Its defining trait is deletion: the editor extension, Amp Tab, TODO lists, Fork, custom commands, and public threads have all been removed. Monthly subscriptions only arrived on 2026-07-18 (Megawatt $20, Gigawatt $200); before that it was pay-as-you-go only. The current focus is orbs — remote machines that keep working after you close your laptop.
Copilot CLI went GA on 2026-02-25 and is included in every Copilot plan, Free included. Its differentiator isn't the agent — it's the GitHub integration: a built-in GitHub MCP server that works on issues and PRs, org policies inherited automatically, and an `&` prefix that hands work to the cloud coding agent. Billing runs on GitHub AI Credits (1 credit = $0.01): Pro $10/mo includes $15, Pro+ $39 includes $70, Max $100 includes $200.
omp is a fork of Pi, but it is not just a plugin layer stacked on top: it adds roughly 80,000 lines of Rust, pulling grep, shell, AST, and PTY in-process. Built-in tools go from Pi's 7 to 31, plus 14 LSP ops, 28 DAP ops, and 60+ providers. One codebase, two opposite bets.
TanStack Router (19.7M weekly downloads) + Query (55.8M) + Zustand (44.5M) as the core, with Vite, react-hook-form + Zod (224M), Tailwind + shadcn, and Vitest + Playwright — the current default stack for serious SPAs. The AI era adds three new selection criteria: does the docs site ship llms.txt (all of TanStack does; React Router doesn't), can type safety act as an agent guardrail, and does the source code live in your repo where an agent can read it.
AI Elements is Vercel's React component library for the AI SDK ecosystem — the registry currently holds 48 components covering Conversation, Reasoning, Sources, Tool, and the rest of the AI-interface vocabulary. It follows the shadcn model: npx ai-elements@latest copies the source into your project, fully editable, mapped one-to-one onto useChat's message parts.
ArduPilot's ModeReason enum is the exhaustive list of on-board autonomous decisions: of 56 values, 43 are the aircraft deciding for itself, 21 of those because it detected something dangerous, and exactly one — SOARING_THERMAL_DETECTED — because it found an opportunity. As for end-to-end, PX4 mainline's mc_nn_control has a 10 KB tensor arena and a Kconfig default of n; ArduPilot mainline has none.
Thermal camera prices jump in steps because ECCN 6A003.b.4.b splits control on 111,000 focal-plane elements: 384×288 clears it by 408 pixels, 640×512 is three times over, nothing common sits between, and FLIR prices the Boson 640 at 2.04–2.31× the 320. The Note 3.b carve-out then limits not resolution but focal length — you may have a thermal camera, just not a telephoto one.
The public evidence of a production ramp isn't in the factory but in the government e-procurement system: the fire service's 88 thermal drone sets were priced centrally, six fire departments' first tenders drew no qualifying bidder, all seven awards I pulled equal the budget to the dollar, and the bidder pool is about six firms. A control group added afterwards — aerial ladder trucks, at 0.54 failed-to-awarded versus the drones' 0.33 — refutes this post's original first conclusion: failed tenders are the norm in Taiwanese fire-service procurement.
Grepping all 9,199 lines of Skybrush's open-source light-show firmware for neighbour, collision and swarm turns up nothing: no aircraft knows another exists, and the entire content two hundred of them synchronise is one GPS time-of-week integer plus a millisecond offset, with collision avoidance settled on the ground in the choreography software. Chapter 7 of Taiwan's drone cybersecurity spec — the swarm chapter — leaves the 'drone' column a dash down all twelve items and tests switches and routers instead.
The same 5 kg aircraft on the same 2 kg pack needs 512 W to hover for 41 minutes as a multirotor, or 128 W to cruise for 164 minutes and 197 km as a fixed wing — and that range is independent of cruise speed. A VTOL's cost is not the energy burned in transition (2.4%) but that it carries both a rotor system and a wing, worth about a quarter of the range; Taiwan builds something at every rung from 40-minute electric multirotors to a 6-hour piston helicopter.
Hover power scales with takeoff weight to the 1.5 power while battery energy scales linearly, and that one exponent gap makes added battery hit diminishing returns fast — the optimum battery fraction solves to two-thirds of takeoff weight, independent of rotor diameter, rotor count, efficiency and energy density. What actually caps endurance is payload, not the regulatory weight thresholds: 60 minutes needs a 314 Wh/kg cell, and the best high-rate cell today is 242 Wh/kg.
ExpressLRS derives its hop sequence by running the bind phrase through MD5 into a UID and feeding that to a linear congruential generator — fully reproducible, and I ported it to Python and matched the original C bit for bit — while the link itself has no encryption at all, only a 14-bit CRC. Taiwan's LP0002 then turns channel count into a power ceiling: 75 or more hopping channels at 2.4 GHz allows 1 W, fewer allows 0.125 W.
Analogue FPV video in Taiwan has two separate problems: LP0002's 5.8 GHz window is only 125 MHz wide while the market's standard channel table spans 300 MHz, leaving eighteen of the forty classic channels inside the window once transmit width is counted. The harder one is that §4.10.1.1 recognises only frequency-hopping transmitters at 5.8 GHz, and analogue video is fixed-frequency — it doesn't violate a clause so much as fail to match any clause in the document.
Flying a drone to 28 m in SITL and switching on the simulator's built-in GPS jamming, the flight controller declared EKF failure about seven seconds later, switched to LAND, landed and disarmed — it neither flew away nor crashed. Reading PX4's source then shows that of the 12 gates in EKF2_GPS_CHECK, bit 11, jamming detection, is off by default: the estimator catches jamming on its own, while spoofing can only be reported by the receiver.
After cloning and building both, three things differ from the stereotype: ArduPilot's EKF3 header credits the derivation to PX4/ecl, so the hardest layer is shared; PX4's last year of commits comes from company domains (380 from Auterion alone) while ArduPilot's comes from personal addresses with one contributor at 37%; and what really decides the choice is not performance but BSD-3 versus GPLv3, and which layer you need to modify.
Electronic warfare has one structural limitation: it needs a signal to attack. Fiber-optic control emits no radio, satellite links bypass ground jammers, and AI terminal guidance needs no link at all for the final leg — three methods systematically defeating jamming, which is why defense is shifting toward interception. Taiwan carries an extra layer: a Control Yuan investigation documents the Ministry of National Defense revising its drone response SOP three times in two months, from "may shoot down" to "flare warning only, first shot requires the Minister's authorization" and back to "shoot down with 7.62mm or smaller." That is not a technology problem.
Only four drone occurrences have entered Taiwan's official aviation safety statistics — because the threshold is 'substantial damage to a drone over 25 kg.' A hobbyist crash never enters the count. The two published investigation reports are the same model, the same manufacturer, and the same agency, and both probable causes were hardware failures: main rotor servo electrical failure in one, a fractured tail rotor pitch link in the other. In both, the flight control computer and the operator were explicitly cleared.
The three most important lines on a drone spec sheet are exactly the three lines spec sheets don't print. Taiwan's Drone Cybersecurity Testing Specification defines a product 'series' as units whose flight control, communications, and satellite positioning chip modules are all identical — regulation decides whether two drones are the same drone by those three modules, not by looks or endurance. And the weight field isn't a marketing number either: 250 g, 1 kg, 2 kg, 15 kg, and 25 kg are five separate legal thresholds.
The EU has had a workable path since the end of 2020 — the Specific category grants an operational authorisation based on risk assessment, with U-space Regulation (EU) 2021/664 rolling out on top. The US Part 108 rule was still at OIRA and unpublished as of July 2026. Taiwan doesn't have the framework at all: its regulations offer 'extended visual line of sight' (900m, 400ft, observer required), while true BVLOS runs on per-activity permits valid for three months.
The 2016 consumer drone bubble left specific wreckage: 3D Robotics stopped making hardware, GoPro recalled all 2,500 Karma units six weeks after launch and cut 15% of staff, Parrot cut 35% of its drone workforce, and Lily Robotics collapsed after taking $34M in pre-orders. In 2023 even Skydio — $570M raised — exited consumer, and three years later it is valued at $4.4 billion. This wave runs on a completely different engine, but three things are exactly the same.
The global drone market is roughly US$69B in 2026 (IDTechEx). China holds about 80% of it (CSIS) and DJI over 70% of multi-rotor. The FCC put every foreign-made drone on its Covered List in December 2025; Taiwan's drone output jumped from NT$5.0B to NT$12.9B in one year, and Q1 2026 exports already beat all of 2025. This piece breaks down the five-layer supply chain, the four demand blocks, and the two ceilings holding back scale.
Northeastern tested 17,260 Android apps and found zero activating the microphone. In May 2026 the FTC ruled that Cox Media Group — the company that claimed to be listening — collected no voice data at all and was reselling data-broker email lists, settling for $930,000. The real pipelines are off-site event feedback, lookalike spillover, contact-graph uploads, and location brokers.
Of the 267 companies the Ministry of Economic Affairs counted, 164 are in northern Taiwan. But geography is not division of labor — Thunder Tiger's published bill of materials shows motors, batteries, frames, and propellers sourced locally, while flight control, comms/GPS, and camera modules go to US, European, and Japanese partners. Exports were only 23% of 2025's NT$12.9B output, and 88.1% of export value sits in the 2–7 kg weight band per Ministry of Finance statistics.
Koboyo claims close to 90,000 free hand-drawn SVG icons (the count oscillates: 92,967 → 87,954 → 90,150), but its sitemap only lists about 17,930 icon pages, and its license page explicitly forbids building an icon library or canvas app with them. There are actually three routes to a hand-drawn look: collect a library, bend existing geometry programmatically (sketchyicons turns every straight run in Lucide into a quadratic Bézier, seeded by icon name for byte-for-byte reproducibility), or generate with AI. This piece compares seven libraries on scale and license, unpacks the algorithms behind sketchyicons and tldraw, and surveys the icon search tools now shipping MCP servers.
Take apart the feed ranking of ten platforms and they're all solving the same problem: how to trade off between newest, best, and letting new content be seen. What actually decides your answer isn't how clever the algorithm is, but whether your content is oversupplied or scarce — big platforms rank to filter content out, small communities want every post to be seen.
Most teams don't need five databases. PostgreSQL's extension ecosystem covers caching, queues, full-text search, and vector search — but the real decision isn't 'can it do it' but 'where does ops cost cross performance needs.'
It's really a two-way choice now: @playwright/mcp (cross-browser, accessibility tree, token-cheap) versus chrome-devtools-mcp (Chrome's official server, performance and memory diagnostics). @modelcontextprotocol/server-puppeteer has been archived and is no longer a candidate. The dividing line is no longer abstraction level — it's 'drive the page' versus 'diagnose Chrome'.
chrome-devtools-mcp, maintained by the Chrome team, packages DevTools capability as an MCP server: performance traces and insights, Lighthouse audits, heap snapshots, extension management — none of which @playwright/mcp exposes. It runs on Puppeteer, so interactions auto-wait; the costs are Chrome-only support and usage statistics reported to Google by default.
@playwright/mcp defaults to an accessibility tree (browser_snapshot) instead of screenshots, cutting token consumption sharply. Combined with Playwright's native auto-wait it's a sensible starting point for AI agents doing web automation — but note it now runs headed by default, keeps a persistent profile by default, and gates advanced tool groups behind --caps.
server-puppeteer is the Puppeteer wrapper in the official MCP servers monorepo — seven lean tools built around screenshots and evaluate. It has since been archived (moved to servers-archived, no longer published), so it is not a choice for new projects; if you want Puppeteer lineage in an MCP server today, look at the Chrome team's chrome-devtools-mcp.
AI agents running tests are non-reproducible; hand-written Playwright is hard to maintain. Four tools that emerged in 2024-2025 each tackle this dilemma with very different design philosophies.
A Go read-only scanner open-sourced by Perplexity in May 2026 (v0.1.1, zero non-stdlib dependencies). It inventories npm/PyPI/Go/RubyGems/Composer/MCP/editor and browser extensions into NDJSON, matches against a custom exposure catalog, and answers the question 'which machines in my fleet are currently affected' the moment a supply chain incident hits. It deliberately never invokes any package manager and is not an EDR.
When mobile Chrome keeps redirecting back to the login page after sign-in, the culprit isn't always OAuth or broken frontend state. In this case, the root cause was that the HTTP entry point for app-dev.daodao.so wasn't issuing a 301 redirect to HTTPS, so /auth/me requests sent with an http origin didn't include the auth_token cookie.
Antigravity CLI is a terminal agent Google announced at I/O on May 19, 2026. Written in Go (versus Gemini CLI's Node.js), its binary is called agy, and it shares the same agent harness as the desktop Antigravity 2.0. It is also Gemini CLI's successor — the personal-tier Gemini CLI service ends on June 18, 2026.
Rewriting tool descriptions from soft suggestions to hard rules (whitelist + consequence explanation) eliminated the LLM's incorrect tool selection; adding skip_signal=True fixed vector store double-indexing.
/loop is Claude Code's native cron feature — set schedules in plain English and let Claude monitor, auto-fix PRs, and run recurring tasks in the background. Session-scoped and expires after 7 days; for cross-session scheduling, use Routines or Desktop scheduled tasks.
Routines is Claude Code's cloud automation system (formerly Cloud Scheduled Tasks). Beyond cron scheduling, you can trigger runs via API endpoint or GitHub events — scan issues, review PRs, run checks, open PRs — all while your computer is off.
Two answers stand out for remotely accessing your home Mac in 2026: Cloudflare Tunnel if you need browser-based access with no client install, and Tailscale if you just want something simple for personal use. This post compares both, covers ZeroTier, Pangolin, NetBird, and other alternatives, and explains why Cloudflare's remotely-managed tunnel makes setup significantly easier in 2026.
Warp evolved from a Rust-powered modern terminal into an AI Agent-integrated development environment (ADE), open-sourced under AGPL in April 2026, with over 700,000 developer users.
DeerFlow is ByteDance's open-source Super Agent Harness built on Python 3.12 + LangGraph. It orchestrates long-running tasks through sandboxes, long-term memory, sub-agents, skills, and a messaging gateway. It hit #1 on GitHub Trending in February 2026, now surpassing 63,000 stars, with support for Telegram/Slack/Feishu, Claude Code integration, and multiple search backends.
NotebookLM has no official API. This extension works by combining three techniques: reverse-engineered Google batchexecute RPC calls, DOM scraping, and cross-tab message passing.
The main backend runs on a remote HTTPS server, so the auth_token cookie is scoped to that domain. The browser never sends it to the local AI backend, causing the API to treat every request as unauthenticated.
env.AI is not just run(). It also exposes toMarkdown (document-to-Markdown conversion), autorag (managed RAG), gateway (external provider proxy), and models (metadata lookup). Understanding these four method groups is what unlocks Cloudflare as a full AI platform inside Workers.
Better Agent Terminal (BAT) is an Electron desktop app that unifies multiple project workspaces, terminals, and Claude Code Agents into a single window — solving the everyday pain of exploding iTerm tabs and the lack of a proper GUI container for agents. MIT License, available on macOS, Windows, and Linux.
Claude Code only reads CLAUDE.md; Codex only reads AGENTS.md. Teams using both end up maintaining two identical files. Fix: make CLAUDE.md a symlink pointing to AGENTS.md — one source of truth.
Skill paths are almost always runtime-specific. AGENTS.md is the reliable way to share rules across agents. Put personal reusable capabilities in each agent's supported global directory; put project workflows inside the repo.
code-review-graph uses Tree-sitter to parse your codebase and build a persistent knowledge graph, tracks the blast radius of changes, and feeds only truly relevant context to the AI — claiming an average 8.2x reduction in token usage.
GitBook is a Git-based documentation platform with Markdown editing, version control, and multi-user collaboration. Ideal for technical docs, API references, and internal knowledge bases. The free plan is sufficient for individuals and small teams.
The NVIDIA DGX Spark is powered by the GB10 Grace Blackwell Superchip, 128 GB of unified memory, and delivers 1 petaFLOP of FP4 compute — starting at around $3,999 USD. It lets developers run 200B-parameter models locally and fine-tune 70B models, making it the most accessible NVIDIA AI development platform available today.
A breakdown of nine major documentation platforms — their positioning, pros, cons, and ideal use cases. Decision logic: open-source projects → Docusaurus/VitePress, API docs → Mintlify/ReadMe, internal enterprise → Confluence, fastest to launch → GitBook.
Claude Code is Anthropic's agentic coding tool that runs in the terminal, IDEs, Slack, GitHub, and on the web. Its core extension system has six layers: CLAUDE.md (persistent context), Skills (on-demand workflows), Hooks (deterministic automation), Subagents (isolated delegation), MCP (external tool connections), and Agent Teams (multi-agent collaboration).
Codex CLI is OpenAI's open source terminal coding agent (Rust, Apache-2.0, ~106.6k stars) with MCP, subagents, image input, code review, and Skills. The model line is now GPT-5.6 Sol / Terra / Luna, and the desktop app, CLI, and IDE extension share one config.toml.
Gemini CLI is Google's open source terminal AI agent (Apache 2.0, ~106.6k stars). It once offered 60 requests per minute and 1,000 per day for free, with a 1M context window. The individual tier stopped serving on 2026/6/18 and Antigravity CLI took over. The project isn't shut down — the repo is still maintained — but it now serves only Gemini Code Assist Standard/Enterprise licenses and paid API keys.
OpenCode is an open-source AI coding agent written in TypeScript (MIT, ~198K GitHub stars, repo at anomalyco/opencode) with a built-in TUI, 75+ LLM providers, LSP integration, a Vim-style editor, SQLite session management, and a desktop app. Free, no subscription, local or cloud models.
Pi is a minimalist coding agent by Mario Zechner (TypeScript, MIT, ~93K stars) with just 4 core tools and a very short system prompt — everything else you add yourself via Extensions, Skills, and Prompt Templates. It deliberately omits MCP, sub-agents, plan mode, and permission popups. The repo is now earendil-works/pi and the npm scope is @earendil-works.
When processing requests, Claude Code randomly displays one of 185 built-in verbs (like Thinking, Brewing, Clauding), then picks one of 8 completion verbs with elapsed time. You can customize these via spinnerVerbs in settings.json, using either replace or append mode. All data in this post is verified directly from cli.js source code.
gstack is Garry Tan's open-source Claude Code skills toolkit. Its 20 specialized skills transform a solo developer into an entire engineering team — automating everything from product planning and design review to code review, QA, and deployment.
The original Claude Code troubleshooting collection has been split into orders 33-35: installation & login, runtime problems, and config diagnosis. This page is their index.
Standard Playwright gets blocked by Cloudflare. Both playwright-extra + stealth and nodriver can bypass it. The final step is wrapping the solution into an MCP server so AI agents can use it automatically.
Agent Teams lets multiple full Claude Code sessions work as one team: a team lead assigns work while teammates each run their own context window, coordinating through point-to-point messaging and a shared task list. This post covers the three key differences from sub-agents, the trade-off between teammateMode display modes, and why token cost scales linearly with team size.
Anthropic's official Claude Code best practices boil down to one constraint: manage the context window. This post reorganizes their guidance into a working loop — explore, plan mode, implement with a runnable check, verify, commit — plus prompt techniques, when to /clear vs rewind, and the five failure patterns they call out.
Channels are a special kind of MCP server that push CI failures, monitoring alerts, and Telegram messages directly into a running Claude Code session — and Claude can answer back through the same channel via a reply tool. This post breaks down the channel contract, two-way replies, security gates, and install requirements.
Checkpointing is not git commits: Claude Code snapshots your files before every user prompt, keeps the 100 most recent per session, and deletes them after 30 days. This piece breaks down the five rewind menu options, the tracking boundaries (bash, subagents, symlinks), and how checkpoints divide labor with git.
Claude Code gains browser control through the Claude in Chrome extension: read console logs and DOM state, click, type, upload files, record GIFs, and operate sites you're already signed into. The official prerequisites list Chrome, Edge, and Chromium-based browsers such as Brave, Arc, Vivaldi, and Opera, but WSL is not supported.
Put Claude Code into GitHub Actions with anthropics/claude-code-action: /install-github-app sets everything up in one command, @claude in a PR or issue comment gets bugs fixed, branches pushed, and PR creation links returned; Bedrock/Vertex/Foundry backends switch via one input with OIDC and no stored keys; the GitLab CI/CD integration (beta) mirrors it as a single .gitlab-ci.yml job where every change flows through a merge request.
Every Claude Code session starts with a clean context window. Three memory mechanisms carry knowledge across sessions: CLAUDE.md files loaded every session, .claude/rules/ files that load conditionally via paths frontmatter, and auto memory Claude writes itself. All CLAUDE.md layers are concatenated into context — not inherited by override. This guide covers layer behavior, @path imports, monorepo strategies with nested CLAUDE.md, and sharing one instruction file across tools via @AGENTS.md.
Claude Code loads the system prompt, MEMORY.md, CLAUDE.md, MCP tool names, and skill descriptions before you type your first word. This post breaks down the startup context, what each of six extension features costs, and how to control auto-compaction with /compact, /autocompact, and autoCompactWindow.
Claude Code's built-in sandboxed Bash restricts every command at the OS level: writes are limited to the working directory plus session temp, while reads default to the entire machine; network traffic goes through a proxy allowlist that starts with zero domains. The switches live in the /sandbox panel and sandbox.enabled — there is no --sandbox flag. This post also compares sandbox runtime, dev containers, Docker, VMs, and Claude Code on the web to show when each heavier isolation tier earns its setup cost.
claude -p turns Claude Code from an interactive terminal session into a command you can embed in scripts and CI: pipe data in, get structured JSON out with --output-format json, and skip most auto-discovery with --bare. This post focuses on CLI usage, then covers the four signals that mean it's time to switch to the Python or TypeScript Agent SDK.
Claude Code connects to external tools via MCP (Model Context Protocol), with manual configuration split across three scopes: team-shared .mcp.json, personal local/user entries in ~/.claude.json, and enterprise managed config — not settings.json. This post covers claude mcp add/login flows, the transport landscape (SSE is deprecated), and tool search lazy loading.
Plugins add distribution, not new capabilities: they collect skills, agents, hooks, and MCP settings scattered across .claude/ into one manifest-backed directory that marketplaces can install, update, and version-pin. This post covers plugin structure, the minimal build flow, publishing a marketplace, and dependency version constraints.
Remote Control turns claude.ai/code or the Claude mobile app into a remote for your local Claude Code session: code still runs on your own machine, with MCP servers and local tools fully available, while transcript sync passes through Anthropic servers. This post covers startup, reconnection, push notifications, file delivery, and the security boundary.
Claude Code reads settings from five levels — managed settings, CLI flags, project local, shared project, and user — where plain values are overridden by higher levels while list keys like permissions.allow merge across scopes. This guide covers each file's role, the allow/deny/ask rule syntax, and how to verify your settings with /status and claude doctor.
A single @Claude in Slack turns a bug report into a cloud-run Claude Code session. But there are now two paths: Pro/Max stays on the original Claude Code in Slack (each session runs under an individual account), while new or migrating Team/Enterprise setups should look at Claude Tag (shared org identity, admin-configured access and spend). Check your plan before setting anything up.
Sub-agents are specialized assistants that work in their own context window: a single Markdown file defines their system prompt, tools, and model. Claude delegates automatically based on the description field, or you can @-mention to force one. This post breaks down the frontmatter schema, background execution and nested spawning, permission inheritance rules, and when not to use them.
In a climbing RAG system, 'recommend the next route' (progression) and 'recommend a similar route' (similarity) were conflated by a single hasSimilarRouteIntent() function, causing recommendation quality to collapse. The fix is a two-stage intent classification with a Regex Fast Path + LLM Fallback.
The RAG system's extractRouteReference() used a for...return pattern that grabbed only the first match — so when a user provided five completed routes, only one was used. The fix evolves through three layers: rule-based multi-entity extraction, user profile aggregation, and embedding centroid.
Query: 'I just sent Beauty in the Mirror 5.11b — recommend routes of similar difficulty.' The results came back full of routes with similar-sounding names, not similar grades. Root cause: dense embeddings compress multiple attributes into a single vector, and the rarity of the route name drowns out the grade signal. The fix: three layers of defense — metadata pre-filtering, query rewriting, and score fusion.
Biome does the work of ESLint + Prettier in a single tool, running 10–20x faster with far less configuration. DaoDao uses it across an entire monorepo — lint and format in one pass.
AEO (Answer Engine Optimization) is a content strategy aimed at AI search engines like Perplexity, ChatGPT Search, and Google AI Overview. The core idea is to make your content the easiest source for AI to cite — not just another link in the results page.
SEO is more than keywords. Structured data (JSON-LD), Open Graph, hreflang, and robots.txt are the technical optimizations that actually help search engines understand your content. This guide walks through a complete implementation using an Astro blog as the example.
BullMQ is the most mature job queue in the Node.js ecosystem, backed by Redis, with support for priorities, retries, scheduling, and delayed jobs. DaoDao uses it to handle notification delivery and practice auto-completion scheduling.
Celery is Python's go-to distributed task queue, using Redis or RabbitMQ as a broker to offload long-running work to the background. DaoDao's AI service uses it to handle async tasks like LLM feedback generation.
Global skills live in ~/.claude/skills/, but they go missing in new sessions or the Desktop App? The problem usually isn't a missing file — it's that the skill descriptions aren't being loaded into context. This post clarifies the CLI vs Desktop App differences, the role of settings.json, and the most reliable fix.
ClickHouse is a column-oriented OLAP database that scans hundreds of millions of rows in seconds. DaoDao uses it to record user behavior events for the AI recommendation engine's feature engineering, letting PostgreSQL focus on transactional data.
D1 is Cloudflare's serverless SQLite database that binds directly to Workers, supports full SQL (JOINs, transactions), and handles automatic backups. It's well-suited for small-to-medium relational data needs — NobodyClimb uses it as its primary database.
KV is Cloudflare's globally distributed key-value store. Reads are served from the nearest edge node with extremely low latency. It's ideal for caching, feature flags, and ephemeral data — but writes are eventually consistent.
R2 is Cloudflare's object storage service — S3-compatible API, zero egress fees, and native Workers binding. Stop worrying about bandwidth bills for media-heavy applications.
Cloudflare Workers uses V8 Isolates instead of containers — no cold starts, global edge deployment, and direct access to D1, R2, KV, and AI via Bindings. Great for APIs, SSR, and lightweight backends; not suited for CPU-heavy work.
Docker lets you bundle your application together with its environment, eliminating the 'works on my machine' problem. Combined with multi-stage builds and Compose, it's an essential tool for modern backend deployment.
Expo turns React Native development from 'environment setup hell' into a state where you can just start writing logic. Expo Router brings file-based routing that dramatically lowers the barrier for web developers making the switch. Both DaoDao and NobodyClimb use it to ship across iOS and Android.
Express is the most mature Web framework for Node.js, with a rich middleware ecosystem and abundant learning resources. Paired with TypeScript and a clear layered architecture, it remains a justifiable choice in 2026.
FastAPI is a modern Python web framework built on type hints — it auto-generates OpenAPI docs, supports native async, and delivers performance close to Node.js. It's the top choice for AI/ML services and the most worthwhile framework to learn in the Python backend ecosystem.
GitHub Actions is the lowest-friction CI/CD tool available today, ideal for small-to-medium projects. The key to monorepos is using path filters so only affected apps trigger a build.
Hono is a web framework designed specifically for edge runtimes like Cloudflare Workers, Deno, and Bun. It's an order of magnitude lighter than Express, natively supports Web Standard APIs, and is the go-to choice for edge environments.
Next.js 15 + React 19's App Router shifts rendering responsibility from the client to the server. use cache ties caching logic directly to data functions instead of scattering it across fetch options. Both DaoDao and NobodyClimb chose this stack for very practical reasons.
@opennextjs/cloudflare enables Next.js App Router deployments on Cloudflare Workers — dynamic SSR runs in a Worker, static assets are served from Cloudflare Assets. Zero server management, but with clear feature limitations.
PM2 keeps your Node.js app running on a server — auto-restarts on crash, supports cluster mode to max out CPU cores, and handles log management. Nearly every Node.js app deployed on a VM or VPS needs it.
Prisma's schema-first design gives you versioned migrations, full TypeScript types on every query, and intuitive relation handling. The tradeoff is a learning curve and the inherent limits of any ORM abstraction — but for most TypeScript projects, it's a worthwhile deal.
React Hook Form handles form performance, Zod defines the validation schema — together they eliminate nearly all form boilerplate. Share a single Zod schema across a monorepo and you get one source of truth for both frontend and backend validation.
Redis is an in-memory key-value store that's blazingly fast. DaoDao uses it to handle three responsibilities at once — API caching, session storage, and BullMQ job queues — all from a single Redis instance.
shadcn/ui is not an npm package — it copies component source code directly into your project, giving you full ownership. DaoDao uses it to build packages/ui, a shared component library used across three Next.js apps.
TailwindCSS's core value is solving CSS's global namespace pollution and dead code problems. Utility classes keep styles co-located with components, and unused classes are automatically purged at build time — production CSS bundles typically come in at just a few dozen KB. Both DaoDao and NobodyClimb use it for web styling.
Tamagui is a UI framework built for React Native with a complete design token system, theme support, and compile-time optimization that moves style computation to build time. NobodyClimb chose it over NativeWind primarily because its cross-platform token system is more robust.
Managing API data with useState + useEffect means reinventing the wheel — and doing it worse. TanStack Query handles caching, background updates, and loading/error states so you can focus on UI logic.
Turborepo solves monorepo build speed problems; pnpm workspaces solves dependency sharing. Together they are the best choice for JS/TS monorepos today.
TypeScript types only exist at compile time — they vanish at runtime. Zod lets you validate external data at runtime while inferring TypeScript types from the same schema. One definition, two jobs done.
No Provider, no reducer — global state in just a few lines. NobodyClimb uses it for auth and UI state, paired with TanStack Query for server state.
Use OpenSpec to break requirements into engineering tasks, Claude Code to implement them, hooks to auto-format and protect, local review before committing, three AI reviewers running in parallel on PR, and auto-deploy after merge. This entire workflow lets one person maintain quality across six sub-projects.
Hooks are Claude Code's event system. They trigger shell commands, HTTP requests, MCP tools, or LLM evaluations automatically before/after tool execution, when a prompt is submitted, or when a task ends. Use them to block dangerous operations, run automated reviews, inject context, or write audit logs.
A Skill is an SOP written for AI. Define the steps in a Markdown file and Claude follows them. No coding required, no frameworks to learn — just write down what an experienced person would do.
Stuck mid-debug and can't fix it right now? Use /file-bug-issue to package the error analysis, reproduction steps, and attempted fixes from your conversation into a well-structured GitHub issue. Pair it with a Remote Agent to let AI automatically take over the fix.
Using Claude Code's Scheduled Remote Agent, automatically scan GitHub issues every 2 hours, implement features, open PRs, and address review feedback — no human intervention required. Humans only write issues and click merge. Pair it with the custom /publish-tasks skill to push OpenSpec engineering tasks directly to GitHub issues.
Hooks are automated safety nets (blocking bad commits), Skills are interactive workflows (running checks + auto-fixing), and instruction files (CLAUDE.md / AGENTS.md) are behavioral guidelines. Each layer operates independently, but together they enable an AI agent to automatically run lint, typecheck, and build checks before every commit.
Three main classification systems dominate: Conventional Comments (label-based), Google's severity prefixes (Nit/Optional/FYI), and SonarQube's four quadrants (Bug/Vulnerability/Code Smell/Hotspot). AI review tools have each developed their own taxonomies, but the core dimensions consistently converge on four areas: correctness, security, performance, and maintainability.
Upgraded action-maker from hardcoded mock data to live Cloudflare Workers AI generation. The architecture splits into Worker (AI only), Server (data storage), and Frontend (orchestration). Hit two gotchas along the way: Qwen3's thinking block and the Workers AI response format.
When reviewing vulnerability scan results for a Node.js Docker image, you can't just look at package names. First distinguish between project dependencies and the packages bundled with npm inside the base image — otherwise you'll fix the wrong thing.
Vulnerability scanning isn't just about generating reports — it helps you discover known risks in your system before they become incidents. This post uses Trivy as a hands-on example to explain what scanners actually look for, how to read the results, and how to get started.
Wrap a local Python script into an MCP Server using FastMCP so Claude Code can call it directly — no more manually running pipelines.
The MCP tool was returning a description field that caused 1,033 job listings to exceed the token limit. The fix: exclude description by default and add pagination.
docker restart does not recreate the container, so changes to volumes in docker-compose.yml only take effect after running docker-compose down && up.
Claude Code has five permission modes: default (confirm each step), acceptEdits (auto-accept edits), plan (read-only planning), auto (background AI classifier review), and bypassPermissions (YOLO, skip everything). Switch with Shift+Tab or configure via settings.json. Auto mode is the sweet spot — no step-by-step confirmations, but with safety guardrails.
Service names aren't resolvable across Compose projects — you need to add a network alias so nginx can find the container.
A hands-on log of installing Superpowers (packaged by DwainTR) for Copilot CLI on a local machine — including the diagnostic process when skills didn't appear after installation, the fix, and practical tips.
Cross-project DNS resolution requires container_name or a network alias — and only aliases support horizontal scaling.
A brief error during nginx restart caused Cloudflare to mark the origin as unhealthy and stop forwarding requests, returning 502 on its own. The key clues: localhost hits to the origin return 200, and nginx access logs are completely empty. Just wait for Cloudflare to automatically re-check the origin — it recovers on its own.
A monolithic nginx.conf becomes unwieldy as services grow. Splitting it into per-service files under conf.d/ via include is the standard solution.
When nginx uses the `set $variable` pattern for dynamic upstreams, the DNS cache expires every 30 seconds — the first request after expiry hits a 502 because no IP is available. Upgrading to nginx 1.27.3 and switching to an upstream block with the resolve parameter fixes this: DNS updates happen asynchronously in the background.
Once SSH config is set up, scp works directly with aliases — no need to type out the full IP every time
Ghostty is a fast, native, general-purpose terminal emulator. cmux is a terminal built on top of Ghostty, specifically designed for AI coding agents. They're not competitors — they operate at different layers.
Cloudflare Custom Error Pages require a paid plan. On the Free Plan, use a Worker with inline HTML to intercept 5xx responses instead.
Use includeIf + SSH Host aliases to let Git automatically switch accounts based on directory path — no more manual switching.
Even when a route has prerender = true, Cloudflare Workers' Rollup bundler still attempts to bundle native modules, causing the build to fail. The fix is to move any native module work into a postbuild script.
Astro scoped CSS appends a scope hash to each selector, but elements rendered by <Content /> don't receive that hash — causing all prose styles to silently break.
After finishing a debug session, just say 'write this up as a post' — Claude Code extracts content from the conversation, applies a template, generates frontmatter, and commits it to the repo. No extra writing required.
In wrangler.jsonc, use custom_domain: true in routes with only the hostname as the pattern — no /* wildcard
Next.js + Expo frontend, Node.js + Python dual backend, PostgreSQL + Redis core — plus a social notification system and LLM recommendation engine. Here's how DaoDao builds a learning community platform with a modern tech stack.
A climbing community platform where the web app, mobile app, and AI Q&A all run on Cloudflare — no dedicated servers.
A dynamically composable RAG pipeline built on Cloudflare Workers AI (gemma-3-12b-it + bge-m3): 14 base steps + 6 LangGraph-specific nodes, with three strategy graphs (Baseline / Agentic / Plan-Execute) selected at runtime.
Switching templates means replacing the entire project foundation. Figure out what you actually need first, then choose between AstroPaper, Cactus, or AstroWind.
Astro + the full Cloudflare suite — static-first, edge-computed, zero maintenance cost