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.
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.
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.
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.
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.
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.
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.
Microsoft merged Semantic Kernel and its own AutoGen into Microsoft Agent Framework, which hit 1.0 GA on 2026-04-02 for .NET and Python (Go is still public preview). The absorbed autogen-agentchat has not shipped since 2025-09-30. But AG2, the fork on the original authors' side, never merged — it shipped 1.0.2 six days ago, and `pip install autogen` gets you AG2, not Microsoft. This post covers MAF's abstractions, the migration clock, and how to read the tangle of names.
LlamaIndex (51,775 GitHub stars, MIT, verified 2026-08-21) has moved its center of gravity from indexing to Workflows: the standalone llama-index-workflows package pulls 2.81M weekly PyPI downloads, more than the 1.97M of the llama-index umbrella package itself. This post covers the core abstractions, the trade-off against hand-rolling a pipeline, and a hands-on test of its defaults on Traditional Chinese text — at the same chunk_size=1024, English fits 4,645 characters and Traditional Chinese only 1,332. Plus one fact you need before choosing: the TypeScript port is archived and unmaintained.
Exa turns every indexed web page into an embedding and retrieves by vector similarity instead of keyword matching. Official pricing as checked on 2026-08-21: $7 / 1k requests for /search (first 10 results included), $1 / 1k pages for /contents, $12–15 / 1k for the deep tiers, with $20 in free credits for new accounts. This blog's CLAUDE.md puts Exa first among cloud fetch tools, 16 of its 38 skills reference it directly, and only four existing posts mention it in passing — with zero dedicated posts. This is that post.
Modal is a per-second-billed serverless GPU platform that also treats agent sandboxes as a first-class primitive (company-reported: over 1 billion sandboxes launched, more than a third of revenue). The selection question isn't how convenient it is — it's your GPU utilization. Verified 2026-08-21: Modal's A100 80GB works out to $2.50/hr against RunPod's $1.59/hr for the same card, so above 64% utilization renting your own is cheaper. But on the same day, H100 SXM is $3.95/hr on Modal against $3.99 on Lambda — on that card the premium is gone.
This site covers MCP thoroughly but has never written about the layer underneath it: when your agent acts for ten thousand end users reading their own Gmail, whose database holds those refresh tokens, who rotates them, who revokes them. Composio is currently the most complete answer — MIT-licensed SDKs, a commercial hosted execution and OAuth layer. It claims 1,000+ toolkits; the managed-auth page actually lists 121 with a Composio OAuth app and 96 that require your own credentials. New pricing effective 2026-08-15: 100K free tool calls, $29/mo Pro. This post takes the authorization model down to an operational level and draws the line between wiring up MCP servers yourself and buying an integration platform.
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.
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.
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.
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.
CrewAI (GitHub 57.4k stars, MIT, PyPI 11.6M weekly downloads) defines agents by role, goal, and backstory, then groups them into crews for collaboration. Unlike LangGraph's graph-first and MAF's workflow-first approach, CrewAI is team-first — you don't draw nodes and edges, you describe who's on the team and what each person does. It fully removed its LangChain dependency in late 2024 and is now a standalone framework. The commercial side splits into the open-source package and AMP, a managed platform adding visual building, deployment, tracing, and compliance.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Zodios uses a central Zod endpoint definition for Axios client types, runtime validation, and aliases, with optional Express and OpenAPI packages.
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.
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.
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.
Speakeasy records OpenAPI, Overlays, targets, and generator versions in `.speakeasy/workflow.yaml`, enabling local or CI generation, compilation, and publishing of multi-language SDKs.
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.
Protobuf defines binary messages with stable field numbers; Buf adds modules, linting, remote plugins, generation, and breaking-change checks to govern those schemas.
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.
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.
Better Auth unifies login, sessions, providers, and plugins; applications still own resource authorization, revocation latency, and policy for agent actions.
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.
Lambda fits short-lived, event-driven, bursty work; its design center is invocation, retries, idempotency, and downstream capacity—not merely smaller containers.
Fargate removes container-host operations, but task definitions, ECS services, VPCs, IAM, scaling, deployment, and observability remain your system.
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.
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.
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.
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.
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.
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.
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.
Nebius combines GPU VMs and clusters, Kubernetes, Slurm, storage, and Serverless AI; choose the responsibility layer before comparing hardware and price.
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.
Replicate abstracts GPUs behind versioned models, predictions, Cog, and deployments; integrators still own version pinning, async workflows, webhook verification, data persistence, and spending limits.
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.
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.
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.
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.
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.
OVHcloud combines Public Cloud, OpenStack APIs, Managed Kubernetes, vRack, and dedicated or private cloud; that flexibility also creates more networking and responsibility boundaries.
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.
Proxmox VE integrates VMs, containers, clusters, HA, storage, and backup; it simplifies virtualization management while hardware, quorum, networks, capacity, and DR remain yours.
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.
Vercel binds framework build output, previews, CDN caching, and Functions into deployments; deep integration adds speed while defining runtime, locality, cost, and portability boundaries.
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.
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.
Railway is not merely one-click deployment; it puts container services, environments, variables, and private networking into one operable application project.
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.
Koyeb groups Services in Apps, runs revisions as Instances in selected regions, and integrates global routing, autoscaling, private discovery, and CPU or GPU compute.
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.
Coolify controls Docker, proxies, and resources on your servers over SSH; deployment gets easier, but OS, security, capacity, data backup, and recovery remain yours.
Dokploy supports single-container Applications and Compose or Stack, while treating one host, independent remote servers, and a Swarm cluster as distinct topologies.
CapRover wraps Docker Swarm, Nginx, and captain-definition in a simpler PaaS; stateless apps scale, while local persistent apps remain pinned to one node.
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.
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.
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.
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.
Convex combines typed backend functions, a transactional document database, and reactive query subscriptions; correctness depends on separating deterministic mutations from side-effecting actions.
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.
Nhost uses PostgreSQL as the source of truth, Hasura to generate GraphQL, and connects Auth claims, role permissions, Storage, and Functions into one platform.
Kubernetes is fundamentally API objects, controllers, and reconciliation loops—not YAML; it manages workload lifecycles without solving application state, data consistency, or organizational governance.
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.
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.
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.
NestJS is valuable not for decorators alone, but for Modules, Providers, DI, and a predictable pipeline across HTTP, GraphQL, WebSocket, and microservice architectures.
Fastify is more than benchmarks: plugin scopes, hooks, decorators, and compiled JSON Schema build composable Node.js APIs with explicit request and response contracts.
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.
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.
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.
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.
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.
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.
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.
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.
WebSocket supplies a duplex message transport, not auth renewal, schemas, acknowledgements, replay, rooms, or backpressure policy; those layers determine production correctness.
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.
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.
Ably manages global realtime connections, channels, presence, and short-window recovery; applications still own idempotency, durable business state, token capabilities, and offline resynchronization.
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.
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.
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.
Socket.dev goes beyond CVEs by analyzing install scripts, obfuscation, network and shell access, and ownership changes when packages enter a dependency diff.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
MySQL offers a mature ecosystem, InnoDB transactions, and predictable operations, but teams must still own indexes, isolation, replication lag, and migrations.
MongoDB fits aggregate-oriented data and evolving documents; the hard decisions are embedding, transaction boundaries, indexes, and shard keys.
DuckDB is an in-process columnar OLAP database for Parquet, CSV, and DataFrames, not a conventional multi-user OLTP server for web applications.
Neon is serverless PostgreSQL; Turso Cloud currently follows the libSQL and SQLite-compatible path. Their compatibility boundaries are fundamentally different.
Agent Plugins 1.0 is a packaging format that bundles Agent Skills (markdown instructions) and MCP server configs into a single directory, loadable by ChatGPT, Cursor, GitHub Copilot, Kiro, and VS Code. It's not a new protocol — it's the wrapper above protocols. Vercel initiated it, OpenAI/AWS/Microsoft/Cursor co-authored it, and Google joined on launch day. Anthropic isn't on the governance board, but MCP is a core primitive of the spec.
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).
Plugin Extensions, announced at DevDay 2026 (Sep 29), let a plugin put a home in the ChatGPT sidebar, a panel beside the conversation, and a viewer for its file types — up to three entrypoints per MCP App. A plugin is now Skill + MCP + external services + UI, which adds a new product question: which capabilities should ship as a plugin an agent can install?