u/javaeeeee

TL;DR: On a Strix Halo laptop (Radeon 8060S, 128 GB unified), MTP takes Qwen3.8-27B Q8_0 from 7.1 to 21.9 tok/s. The julianmb/q38rocm FP4 fork gives 26.7 tok/s.

Setup: LlamaStash driving stock llama.cpp b10503 (5112b9738) for ROCm and Vulkan, and the q38rocm fork (server build 246) for ROCmFP4, all built from git today. Greedy, 256 max tokens, wall-clock tok/s from the API usage numbers, best of 2 reps, on AC power. Everything launched through my tool LlamaStash (v0.2.0) so the flags are reproducible.

Qwen3.8-27B decode tok/s (code prompt / prose prompt):

Build and model	MTP off	MTP on	Draft acceptance
ROCm + Q8_0 (29 GB)	7.1	21.9 (draft 5)	73%
Vulkan + Q8_0 (29 GB)	7.4	21.3 (draft 5)	73%
ROCmFP4 FAST (14.6 GB)	12.5	26.7 (draft 6)	86%

Draft length sweep, code prompt tok/s:

draft n	2	3	4	5	6	7	8
Q8_0	15.4	18.4	19.1	21.9	21.2	21.8	20.5
FP4	-	23.3	24.9	25.0	26.7	25.6	-

Observations:

• MTP really makes a difference 2.5x to 3.1x on Q8_0, 2.1x on ROCmFP4, at 73-95% draft acceptance. The model verifies every token, so quality does not change on stock llama.cpp.
• Draft length of 5 works best. The backend default is 3; 5 was best for Q8_0 and 6 for FP4.
• FP4 is a double win if you can live with the quant. Half the memory (29 to 14.6 GB), 1.8x faster raw decode without MTP, and 26.7 tok/s with MTP, which is 3.8x my stock Q8_0 baseline.
• Engine choice barely matters for decode at this size. ROCm, Vulkan and the rocWMMA build all land within about 3%. Vulkan does lose roughly half its prompt processing throughput though, so ROCm stays my default.
• Stuff that did not help: KV cache q8_0 (helps at draft 3, slightly worse at 5), flash attention off (minus 5%).
• One caveat on the ROCmFP4 fork: completion lengths drifted a little across draft settings (152-158 tokens for the same prompt) while stock llama.cpp was stable at 164, so the fork's speculative path is not strictly greedy-identical yet.

LlamsStash defaults were used for all runs. The only flags set were to enable disable MTP ( --spec-type draft-mtp), set draft length (--spec-draft-n-max N) and the --fit-ctx 16384 flag was used to ensure the GPU layers were fully utilized.

The below are the default flags that was applied. Some sent by LlamaStash and others are llamacpp defaults.

Flag	Value	Set by
--host	127.0.0.1	LlamaStash (loopback policy)
--port	41100	LlamaStash (auto-assigned)
-m	<model>.gguf absolute path	LlamaStash (resolves the name ref)
--mmproj	mmproj-F16.gguf	LlamaStash (auto-paired sidecar; Q8_0 rows only, FP4 has none)
--jinja	on	LlamaStash (chat template handling)
--spec-type	draft-mtp	LlamaStash (translated from --mtp on)
--spec-draft-n-max	5 (Q8_0) / 6 (FP4 best) / omitted on default rows	LlamaStash (--mtp-draft-n); llama.cpp default 3 when omitted
--fit-ctx	16384	LlamaStash (ctx knob = auto, fit hint)
--cache-type-k / -v	f16 (q8_0 on kvq8 variant rows)	llama.cpp default except for kvq8 runs
--flash-attn	on (off on the fa-off variant row only)	llama.cpp default except for fa-off runs
--n_ctx (final)	262144 per slot (native 256K)	llama.cpp fitter
--n_parallel	4, kv_unified true	llama.cpp (auto)
--n_gpu_layers	all (-1)	llama.cpp fitter (llamastash knob was auto)
--cache-type-k/v (final)	f16 / f16	llama.cpp default
--n_threads	16 (of 32 logical)	llama.cpp default
--n_batch / --n_ubatch	server defaults, not overridden	llama.cpp
spec internals (fork only)	n_min=0, p_min=0.75, backend_sampling=1	llama.cpp (q38rocm fork defaults)
draft context (fork only)	all GPU layers, f16 KV	llama.cpp (fork)

Google Stitch is one of the most interesting experiments to emerge from Google Labs in recent years. It is an AI-native design canvas that lets anyone-designers, developers, product managers, founders, or complete beginners-turn natural-language descriptions, sketches, screenshots, or even spoken ideas into high-fidelity user interfaces for web and mobile applications. What makes it distinctive is not merely that it generates screens. It aims to change the starting point of design itself: instead of beginning with boxes and wires, you begin with intent, mood, business goals, and the feeling you want users to have. Google calls this “vibe design.”

This article draws on official Google announcements, hands-on walkthroughs from experienced practitioners, detailed tutorials, and video demonstrations available on YouTube. It walks through the tool’s evolution, core capabilities, practical workflows for both mobile and web projects, prompt strategies, prototyping, design-system management with DESIGN.md, export paths into development, and realistic limitations. The goal is to give you a readable, actionable understanding so you can open stitch.withgoogle.com and start producing useful designs quickly.

What Google Stitch Actually Is

Stitch lives entirely in the browser at stitch.withgoogle.com. You sign in with a Google account and land on an infinite, AI-native canvas. There is no software to install. Under the hood it is powered by successive generations of Google’s Gemini models. Early versions used Gemini 2.5 Flash for speed and Gemini 2.5 Pro for higher-fidelity results and image understanding. Later updates brought stronger reasoning and better contextual awareness.

The tool accepts several kinds of input: plain-English prompts, uploaded images or sketches, voice commands, and, more recently, design-system rules expressed in a special markdown format called DESIGN.md. From those inputs it produces structured UI layouts-complete with proper hierarchy, components that behave like real interface elements, and, in many cases, clean HTML and CSS (often Tailwind-based) that can be exported. Screens can be connected into interactive prototypes that you can click through. Multiple design directions can live side by side on the same canvas so you can explore alternatives without losing earlier work.

Importantly, Stitch is still an experiment under Google Labs. Features evolve, and usage is governed by a credit-based quota that can vary by account, model, and generation mode. Because Google may change these limits, users should check the current quota displayed inside Stitch rather than rely on a fixed monthly figure. For individuals and small teams doing early ideation and rapid prototyping, the current free access is generous. For high-volume production work it is best treated as a powerful first draft generator rather than a complete replacement for traditional design tools.

A Short History of the Tool

Stitch was introduced around Google I/O 2025 as a way to turn simple prompts and images into complex UI designs and frontend code in minutes. The early version already supported both mobile and web targets, theme editing, variant generation, and export to Figma or code. Users could choose between a faster standard mode and a higher-fidelity experimental mode that accepted image inputs.

Later in 2025 the platform gained stronger Gemini models and the ability to stitch multiple screens into clickable prototypes. The biggest leap came in March 2026 with a complete redesign into an AI-native infinite canvas, the formal introduction of “vibe design,” a design agent that reasons across the whole project, an agent manager for parallel explorations, voice interaction powered by Gemini Live-style capabilities, and deeper support for design systems via DESIGN.md. These changes shifted Stitch from a screen generator into a more continuous design environment where ideas can grow from rough intent all the way to interactive flows without constantly switching tools.

Subsequent refinements have focused on direct editing of text and images inside the canvas, better multi-screen consistency, and open-sourcing the DESIGN.md specification so the same rules can travel outside Stitch into other AI coding agents.

Core Concepts That Shape How You Work

Three ideas are especially important.

First is vibe design. Instead of specifying exact pixel values or component lists up front, you describe the business objective, the emotional tone you want users to feel, and any inspiring references. “Premium and minimalist, like a well-designed fintech dashboard that makes complex data feel calm and trustworthy” is often more productive than a long list of widgets. The AI then proposes multiple visual directions that capture that vibe. You explore, select, and refine.

Second is the AI-native canvas. It is infinite and multimodal. You can drop in images, text notes, code snippets, or competitor screenshots; the design agent treats them as context. Multiple screens and variants sit side by side. An agent manager helps you keep track of parallel ideas. Voice lets you speak directly to the canvas-“show me three different navigation treatments” or “make this feel more energetic without becoming playful”-and receive real-time updates and critiques.

Third is the bridge to production. Designs are not just pictures. You can export HTML/CSS, send structured results into Figma with editable layers and Auto Layout, or hand them to other Google tools and external coding agents. DESIGN.md files capture tokens and rationale so consistency can travel with the work.

Getting Started in Minutes

Open a modern browser, go to stitch.withgoogle.com, and sign in with any Google account. You land on the canvas. No waitlist or credit card is required. Privacy settings allow you to control whether your data contributes to model training; many users disable that option.

Create a new project. You will see the infinite canvas, a prompt or chat area, mode selectors (often including faster and higher-reasoning options), and controls for voice, image upload, and export. Early projects benefit from starting in an exploratory or “ideate” style mode. You can switch later for polish.

Before writing your first prompt, decide whether the target is mobile, web, or a mixed set of screens. Stitch handles both, though many practitioners report stronger initial results on mobile interfaces where constraints are tighter and patterns are more standardized. Web layouts, especially complex marketing pages or dense dashboards, often need more iteration.

Crafting Effective Prompts and Starting with Vibe

The quality of the first output depends heavily on how clearly you communicate intent. A useful mental model is to zoom out then zoom in. Begin with context: what the product is, who the users are, and what success looks like for this screen or flow. Then describe the goal of the particular interface, the desired hierarchy, key components, visual direction, constraints (accessibility, one-handed use, dark mode preference, etc.), and any explicit output expectations.

For a mobile personal-finance dashboard you might write something like: “Design a mobile home screen for a personal finance app aimed at young professionals who check spending several times a day. The screen should let users quickly grasp today’s total spending, top categories, and whether they are under or over budget. Use a clean, calm, minimal visual language with neutral backgrounds and soft accent colors. Sticky header with month, large readable total, horizontal category cards, and a short list of recent transactions. Prioritize glanceability and one-handed use. Follow modern iOS-style spacing and accessibility principles.”

For a web SaaS landing page the prompt might emphasize conversion goals, social proof, and brand personality: “Create a modern SaaS landing page for a project-management tool called Trackflow aimed at remote teams. Clean professional look with a dark navy hero, white content sections, and blue accent buttons. Include a strong hero with headline, subheadline and primary CTA; a features grid; three-tier pricing; testimonials; and a simple footer. The overall vibe should feel trustworthy, efficient, and calm.”

After the initial generation, refinement happens conversationally. Select a screen and ask for targeted changes: “Shift the hero to a subtle gradient from deep navy to purple and make the primary button coral.” Or “Add a fourth feature card focused on file sharing and give every card a soft shadow and rounded corners.” Multi-select lets you apply a theme change across several screens at once, which helps maintain consistency.

Voice accelerates early exploration. Activate the microphone and speak natural requests. The agent can interview you about goals, offer critiques on contrast or hierarchy, and generate alternatives in real time. This mode is especially useful when you are still discovering the right direction and do not yet want to type precise specifications.

Image input expands the options. Upload a rough sketch, a competitor screenshot, or an existing design and instruct the tool to reinterpret it-“Keep the overall structure but restyle it for a calm fintech brand with plenty of white space and trustworthy blues.” Results vary with the clarity of the source image; clean references work better than messy photos.

Designing Mobile Applications End to End

Mobile work often starts with a core flow rather than a single screen. A typical sequence for a fitness or habit-tracking app might begin with an onboarding series: welcome, goal selection, preference setup, and first-home dashboard. Prompt for the entire flow or generate the first screen and then ask the system to produce logical next screens.

Once several screens exist, use the prototyping features. Select screens, define connections (button taps leading to the next view), and hit Play. You can walk through the flow as a user would. The system can also suggest or auto-generate missing intermediate screens based on context. Direct editing lets you fix copy, swap placeholder images, or adjust spacing without a full regeneration.

For consistency across a mobile app, introduce a DESIGN.md file early. This markdown document combines machine-readable tokens (colors, typography scales, spacing, component defaults) with human-readable rationale. You can extract a starting system by pasting a public URL of a site whose visual language you admire; Stitch analyzes colors, fonts, and component styles. You can also write or edit the file yourself. Once present, subsequent generations respect the rules more closely, reducing visual drift. Because the format has been open-sourced, the same file can later guide coding agents outside Stitch.

Accessibility should be checked throughout. Ask explicitly for WCAG-minded contrast, readable type sizes, and sufficient touch targets. The AI is helpful but not perfect; human review remains essential.

Designing Web Applications and Multi-Page Experiences

Web projects benefit from the same canvas but often involve more horizontal space, denser information, and marketing-oriented sections. Landing pages, dashboards, settings areas, and multi-step forms are all within scope. Start with a strong hero and primary conversion goal, then expand outward to supporting sections.

Because web layouts can be more variable, iterative refinement is usually deeper. Generate a first version, then systematically address hierarchy, responsive considerations (even if the primary output is desktop), and visual rhythm. Multi-screen generation helps when you need a marketing site plus an authenticated dashboard that shares the same design language.

DESIGN.md is particularly valuable here. After extracting or defining tokens, you can generate additional pages-“settings page that matches the existing system,” “pricing comparison that uses the same card treatment”-and the results stay more coherent. When the visual system feels solid, export becomes the bridge to development.

From Static Designs to Interactive Prototypes and Code

Once screens exist, connecting them into flows is straightforward. Define the logical user journey, stitch the screens together, and preview. Automatic next-screen generation can fill gaps. This turns an early design exploration into something stakeholders can click through and give feedback on within minutes rather than days.

Export options include viewing and copying HTML/CSS (frequently Tailwind), downloading assets, pasting into Figma with structured layers and Auto Layout, or sending the work into other Google tools such as AI Studio for further development. MCP server and SDK integrations allow deeper connections to external coding environments. DESIGN.md can travel with the export so downstream AI agents inherit the same visual rules.

Many practitioners treat Stitch as the zero-to-one phase: rapid generation of direction and structure. They then move the strongest candidates into Figma for precise polish, component libraries, and collaboration, or into code for functional implementation. The AI output is rarely production-perfect, but it is often a strong starting point that saves hours of blank-canvas work.

Practical Tips That Improve Results

Be specific about users and goals. Vague prompts produce generic interfaces. Mention constraints early (dark mode, accessibility, mobile-first, brand references). Use multi-select and theme commands to keep families of screens consistent. Generate variants rather than overwriting a single direction so you can compare. Combine text, image, and voice rather than relying on only one modality. Review every output for hierarchy, contrast, and real-world usability; the AI can miss edge cases or cultural nuances.

For complex products, break the work into focused sessions rather than trying to generate an entire application in one marathon prompt. Keep DESIGN.md updated as decisions solidify. When you hit usage limits, prioritize high-value generations and refinements.

Realistic Limitations and How to Work Around Them

Outputs can still feel generic or require substantial editing for production polish. Multi-screen consistency sometimes drifts and needs manual correction. Complex interactions, sophisticated animations, and highly custom component behaviors are outside the current sweet spot. Accessibility is improved by explicit prompting but should never be assumed perfect. Collaboration features are limited compared with dedicated design platforms; the tool is primarily single-user oriented at present. Because it remains a Labs experiment, feature availability and quotas can change.

The practical response is to treat Stitch as an exceptionally fast ideation and early-prototyping partner. Use it to explore many directions quickly, lock a strong visual system with DESIGN.md, produce clickable demos for feedback, then move into specialized tools for final craft and implementation.

Putting It All Together: Example Workflows

Imagine building a mobile habit-tracking app. Sign in, create a project, and write a vibe-oriented prompt describing the calm, encouraging tone and the core daily check-in experience. Generate the home screen and onboarding flow. Refine colors and hierarchy with follow-ups and voice. Extract or write a DESIGN.md for the soft accent palette and typography. Connect the screens into a prototype and play through the first-week user journey. Export the strongest screens to Figma for final adjustments and to code for a functional prototype.

For a web SaaS product the flow is similar but begins with a conversion-focused landing page, expands to pricing and feature detail pages, then adds an authenticated dashboard that reuses the same system. URL extraction from an admired competitor can seed the design tokens. Parallel variants on the canvas let stakeholders choose a direction before deeper investment.

In both cases the time from blank canvas to something demonstrable is measured in minutes to hours rather than days, provided you invest in clear communication with the AI and systematic refinement.

Looking Ahead

Google continues to invest in the canvas, the design agent, voice interaction, and the open DESIGN.md format. Integration with broader development tooling is likely to deepen. The underlying idea-that design can begin with intent and feeling rather than low-level geometry-is powerful and is already influencing how many teams approach early product work.

Stitch will not replace skilled designers or careful engineering. It can, however, dramatically lower the cost of exploring possibilities, communicating ideas, and producing first drafts that are already structured and exportable. For anyone who has ever stared at a blank artboard or struggled to turn a product brief into something visual, that is a meaningful shift.

The best way to understand the tool is to use it. Open stitch.withgoogle.com, describe something you care about building, and iterate. The combination of natural language, multimodal input, an intelligent canvas, and a path into real prototypes and code makes Google Stitch one of the more practical AI design experiments available today.

Sources and Further Reading

• Official Google materials and announcements form the foundation:
  • Stitch product page: https://stitch.withgoogle.com/
  • “Introducing ‘vibe design’ with Stitch,” Google blog, March 2026: https://blog.google/innovation-and-ai/models-and-research/google-labs/stitch-ai-ui-design/
  • Original introduction, Google Developers Blog: https://developers.googleblog.com/stitch-a-new-way-to-design-uis/
  • DESIGN.md open-sourcing announcement: https://blog.google/innovation-and-ai/models-and-research/google-labs/stitch-design-md/
  • DESIGN.md specification repository: https://github.com/google-labs-code/design.md
• Detailed independent guides and walkthroughs:
  • NxCode / NxCode Team / Google Stitch Complete Guide: Vibe Design, Voice Canvas & Free AI UI Tool (2026)
  • NxCode / NxCode Team / Google Stitch Tutorial: Design Your First App in 5 Minutes (2026)
  • MindStudio / MindStudio Team / What Is Vibe Design? Google Stitch's AI-Native Canvas Explained
  • MindStudio / MindStudio Team / How to Use Google Stitch to Build a Website Design System in Minutes
  • Redwerk / Konstantin Klyagin / Google Stitch AI: The Truth about Vibe Design
  • UX Pilot AI / Khanh Linh Le / Google Stitch AI Walkthrough: Comparison, Features, Alternatives and Pricing
  • UX Planet / Nick Babich / Google Stitch for UI Design
• Selected YouTube tutorials that demonstrate live workflows (search titles or visit the links for the full videos):
  • “Google Stitch Tutorial: How to Design a Mobile App with AI in Minutes” (Blog With Ben): https://www.youtube.com/watch?v=gOmw6gH2b28
  • “Google Stitch 2.0 Tutorial: From Sketch to Code with Gemini 3.0” (Teacher’s Tech): https://www.youtube.com/watch?v=QGZ24YhbZT8
  • “Vibe Design First THEN Build Apps Full Google Stitch Tutorial” (Wanderloots): https://www.youtube.com/watch?v=sjL61D3oybY
  • Additional hands-on demos covering updates, voice, and export are readily available by searching “Google Stitch tutorial” or “Google Stitch vibe design” on YouTube.

These sources collectively provide the authoritative foundation for the practices and capabilities described above. Features and limits continue to evolve, so checking the official site and recent Google Labs updates remains the best way to stay current.

In the fast-moving world of agentic AI code development, where autonomous systems plan, write, test, and iterate on software with minimal human hand-holding, a single Markdown file has quietly become one of the most discussed pieces of project infrastructure. That file is AGENTS.md. As of late July 2026, more than 60,000 open-source repositories include one.

Tooling vendors from Cursor and GitHub Copilot to OpenAI Codex, Aider, Windsurf, and others treat it as a first-class citizen. Industry guides call it the most practical upgrade a team can make. Yet a rigorous ETH Zurich study published earlier this year found that many of these files actually reduce task success rates while raising inference costs. So the question is no longer merely whether AGENTS.md exists. It is whether it remains essential, what its precise role has become, and how developers should position it in the broader agentic stack.

This article examines the current state of AGENTS.md through official documentation, empirical research, practitioner guides, YouTube tutorials, and real-world usage patterns. The goal is a clear-eyed view of its value in summer 2026 rather than another round of uncritical endorsement.

AGENTS.md began as a pragmatic response to fragmentation. In the mid-2020s, every major coding agent introduced its own configuration convention. Cursor had .cursorrules. Claude Code preferred CLAUDE.md. GitHub Copilot used instructions.md or similar. Continue.dev, Aider, and others each had their variants. Teams that experimented with multiple tools found themselves maintaining near-duplicate rule sets that drifted apart over time. The result was inconsistency, wasted tokens, and agents that repeatedly re-learned the same project conventions.

The community response crystallized around a simple open format: a plain Markdown file named AGENTS.md placed at the repository root. Think of it as a README written for agents rather than humans. The official site at agents.md describes it as “a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project.” It deliberately stays separate from the human-facing README so that detailed build steps, testing commands, style constraints, and safety boundaries do not clutter the documentation that contributors actually read.

OpenAI helped pioneer the format for its Codex agent. In December 2025 the specification was donated to the Agentic AI Foundation, a directed fund under the Linux Foundation, alongside Anthropic’s Model Context Protocol and other contributions. By early 2026 adoption had already surpassed 20,000 repositories; by mid-year the figure stood above 60,000 non-fork, non-archived projects according to GitHub code search. The GitHub repository for the format itself has accumulated more than 23,000 stars.

The practical appeal is straightforward. Most supporting coding agents automatically discover applicable AGENTS.md files and incorporate their instructions into the working context. The exact placement and precedence rules vary by tool. Under the official convention, nested files can provide subproject-specific guidance, with the closest applicable file taking precedence.

In monorepos, nested AGENTS.md files can live inside subdirectories; the closest file to the code being edited takes precedence. This hierarchical design lets teams define global conventions at the root while overriding them for specific packages. Agents can even be asked to scaffold an initial version, though as we will see later, that practice carries significant risks.

What typically goes into an AGENTS.md? Popular sections include setup and build commands with full flags, exact package-manager and runtime versions, testing instructions, coding conventions illustrated by examples rather than prose, git and PR guidelines, and explicit “never do” boundaries such as refusing to commit secrets or touch certain directories.

The official examples emphasize executable commands early-“Install deps: pnpm install,” “Run tests: pnpm test”-because agents reference them repeatedly during a task. Code-style rules work better when shown through contrasting good and bad snippets. Security and permission constraints benefit from a three-tier structure: always, ask first, and never.

YouTube creators have produced numerous practical walkthroughs. NeuralNine’s January 2026 video “How I Write My AGENTS.md Files - Best Practices” demonstrates a Django project using the uv package manager. The root file lists commands such as “uv run manage.py runserver,” shows type-hint examples, and sets safety rules against destructive git operations. A subdirectory file then selectively disables type hints while inheriting the rest.

The video stresses that examples outperform abstract descriptions and that agents still sometimes ignore rules when given contradictory chat instructions. Other tutorials from Net Ninja (focused on OpenAI Codex), Prompt Engineering, and The Code City walk through creation in Cursor, migration from older rule files, and monorepo patterns. A recurring theme across these videos is that AGENTS.md reduces the need to restate the same context in every prompt, shortening setup time from tens of minutes to seconds.

Support is broad but not universal. Confirmed tools include Cursor, GitHub Copilot agent mode, Aider, OpenHands, Windsurf, Amp, Jules, Factory, RooCode, Codex, Gemini CLI (with configuration), and Zed. Claude Code continues to prefer CLAUDE.md; the common workaround is a symlink so that both names resolve to the same content. Some teams maintain both an AGENTS.md for portability and tool-specific overrides.

GitHub also supports a related but distinct feature: custom-agent definition files stored in .github/agents/, such as docs-agent.md or security-agent.md. These files use frontmatter and instructions to define specialist Copilot personas. GitHub’s analysis of more than 2,500 such files found that effective custom agents tend to have a clear role, executable commands, concrete examples, stack details, and explicit boundaries. These custom-agent files should not be confused with the repository-level AGENTS.md format, although many of the writing principles overlap. An analysis of more than 2,500 such files by the GitHub team found that the strongest performers define a clear persona, list executable commands early, include concrete code examples, specify the tech stack with versions, and set explicit boundaries.

Up to this point the story looks like an unambiguous success. Then the empirical research arrived.

In February 2026, an ETH Zurich and LogicStar.ai team released “Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?”, with a revised version published in June. Across established SWE-bench tasks and a new collection of issues from repositories containing developer-written context files, the researchers found that context files did not generally improve task success and increased inference costs by more than 20 percent on average. Results varied by setting, model, agent, and whether the guidance was generated or developer-written.

SWE-bench Lite provided 300 tasks from popular repositories. A new benchmark they created, AGENTbench, contained 138 real-world issues drawn from 12 niche Python repositories that already contained developer-written context files. They compared three conditions: no context file, an LLM-generated context file produced according to agent vendors’ own recommendations, and the original developer-written file.

The results challenged the prevailing advice. LLM-generated context files reduced task success rates by roughly 3 percent on average and increased inference costs by more than 20 percent. Agents also took 2.45 to 3.92 additional steps. Developer-written files performed better, delivering a modest average improvement of about 4 percent on AGENTbench, yet they still raised costs by up to 19 percent and encouraged more extensive exploration-more file traversal, more testing, more reasoning tokens.

When the researchers stripped all other documentation from the repositories and then added LLM-generated files, performance improved by 2.7 percent. The implication is clear: most auto-generated content is redundant with information the agent can already discover by reading the codebase. Handing the model the same information twice adds noise and cost without adding signal.

The study further observed that agents generally respect the instructions they receive. When a context file mentioned the uv package manager, agents used it far more frequently. The problem was not disobedience; it was that many of the instructions themselves made the task harder by imposing unnecessary requirements or by encouraging over-exploration.

Architectural overviews and broad style guides proved especially ineffective. The authors concluded that human-written context files should contain only minimal, non-inferable details-custom build commands, highly specific tooling choices, hard constraints that the agent cannot discover independently-and that LLM-generated files should be avoided in most cases.

These findings have been widely discussed. InfoQ, MarkTechPost, Upsun, and Addy Osmani’s blog all summarized the paper under headlines that ranged from measured to skeptical. One Upsun post carried the title “The research is in: your AGENTS.md is probably too long.” YouTube videos such as “Why Your AGENTS.md Rules Are Being Ignored and how to fix it” tested the files empirically and found that only a minority of models strictly enforced the rules; the rest treated them as soft hints.

The ETH Zurich study was the first major controlled evaluation and remains one of the most influential investigations. Subsequent research has produced mixed results. A July 2026 ablation study across Claude Code and Codex found no measurable correctness benefit from context-file strategy in its tested repositories, while separate June research reported improvements from guidance that had been iteratively tuned using repository-specific probes. Together, these studies suggest that the presence of a context file alone matters less than its content, generation method, target agent, and evaluation process.

Practitioner guides published after the study, including Augment Code’s detailed “How to Build Your AGENTS.md (2026)” and Matt Pocock’s “A Complete Guide To AGENTS.md,” absorbed the lesson. They now emphasize restraint: keep the file short, focus on non-discoverable facts, prefer progressive disclosure through linked documentation rather than stuffing everything into the root file, and treat AGENTS.md as living documentation that must be updated in the same pull request as the change it describes.

So what is the current role of AGENTS.md in summer 2026? It is no longer the automatic best practice it was marketed as in late 2025. It has become a specialized instrument whose value depends entirely on how it is written and maintained. In well-curated form it still provides a reliable, tool-agnostic way to inject project-specific operational knowledge that agents cannot reliably infer.

It remains the lowest-friction standard for teams that switch between multiple agents or that want a single source of truth for build commands, package-manager preferences, and hard safety boundaries. In monorepos the nested-file design continues to solve a real coordination problem. And for specialist agents inside GitHub Copilot the format has evolved into a lightweight way to define personas with clear scopes.

At the same time, the file has competition. Agent skills, MCP servers, hooks, plan files, and more sophisticated memory systems are taking over some of the responsibilities once assigned to a monolithic context file. Progressive disclosure-pointing the agent at a docs/TYPESCRIPT.md or a testing guide only when needed-preserves the instruction budget better than loading hundreds of rules on every request. Some teams now treat AGENTS.md as a thin index rather than a complete manual. Others have moved critical constraints into tool-enforced mechanisms or evaluation harnesses that sit outside the prompt entirely.

The practical position that emerges from the research and the practitioner literature is therefore nuanced. AGENTS.md is still useful and, for many workflows, still essential-but only when it is short, human-curated, and limited to information the agent cannot discover on its own. Auto-generated files produced by /init-style commands are usually a net negative. Long files that restate the README, describe the entire architecture, or accumulate every past correction become sources of cost and confusion. The ideal file in 2026 is closer to a tightly focused operating manual than to comprehensive documentation.

Writing one well remains a skill. Start with the absolute minimum: a one-sentence project description, the package manager if it is not the default, and the non-standard commands the agent will need repeatedly. Add concrete examples of preferred patterns and the three-tier boundary list. Use nested files or linked documents for everything else. After each significant change, ask the agent itself to propose an update to the relevant section, then review the proposal carefully. Treat the file as part of the code rather than as an afterthought. Measure the impact: if agents start taking more steps or producing lower-quality patches, the file has probably grown too large.

Looking ahead, the format is likely to remain relevant precisely because it is simple and open. As agentic systems grow more capable of long-running, multi-agent workflows, the need for a predictable place to encode durable project knowledge does not disappear; it becomes more important. Yet the ETH Zurich results have already shifted the culture from “just add an AGENTS.md” to “add a carefully constrained AGENTS.md.” That shift is healthy. In an environment where every extra token costs money and every unnecessary instruction can derail a trajectory, restraint is a feature.

For teams that already rely on agentic coding, the summer-2026 recommendation is therefore not to abandon AGENTS.md but to audit it. Strip the redundant overviews. Keep the non-inferable commands and hard constraints. Prefer progressive disclosure. And remember that the file is only as good as the discipline that maintains it. When used that way, AGENTS.md continues to earn its place as one of the quiet pieces of infrastructure that make agentic AI code development more reliable, more consistent, and ultimately more productive.

The conversation is far from over. New memory architectures, better automatic context selection, and tighter integration with evaluation loops will continue to reshape how project knowledge is supplied to agents. For now, though, the humble Markdown file at the root of the repository remains a practical, if imperfect, tool whose current role is clearer than it has ever been: useful when lean, costly when bloated, and still worth the careful attention of any team serious about agentic development.

Sources

• Official site and specification: https://AGENTS.md/
• GitHub repository: https://github.com/agentsmd/`AGENTS.md`
• ETH Zurich study (arXiv): https://arxiv.org/html/2602.11988v1 and https://arxiv.org/abs/2602.11988
• Shepard, Asa, and Jeannie Albrecht. “Probe-and-Refine Tuning of Repository Guidance for Coding Agents.” arXiv preprint arXiv:2606.20512, June 2026: https://arxiv.org/abs/2606.20512
• InfoQ summary of the study: New Research Reassesses the Value of AGENTS.md Files for AI Coding
• Augment Code guide (2026): How to Build Your AGENTS.md (2026): The Context File That Makes AI Coding Agents Actually Work
• Cobus Greyling Medium article: https://cobusgreyling.medium.com/what-is-agents-md-2846b586b116
• GitHub Copilot analysis of 2,500+ files: https://github.blog/ai-and-ml/github-copilot/how-to-write-a-great-agents-md-lessons-from-over-2500-repositories/
• Matt Pocock complete guide: https://www.aihero.dev/a-complete-guide-to-agents-md
• Upsun “less is more” post: The research is in: your AGENTS.md is probably too long
• Addy Osmani on avoiding /init: Stop Using /init for AGENTS.md
• NeuralNine YouTube best-practices video: https://www.youtube.com/watch?v=6w88NVf2_lY
• Net Ninja OpenAI Codex tutorial on AGENTS.md: https://www.youtube.com/watch?v=NlNuoH5PPl4
• Prompt Engineering explanation video: https://www.youtube.com/watch?v=XDP94mYMCzA
• Additional practitioner and review sources from 2026 include codersera.com, betterclaw.io, and various YouTube walkthroughs such as those by The Code City and Adam Gardner on rule enforcement.

In the middle of 2026, the idea of a personal AI supercomputer has moved from science-fiction marketing to something you can order on Amazon, set on a desk, and use to run models that once required rack after rack of data-center hardware. Privacy concerns, rising cloud inference costs, latency for interactive agents, and the simple desire to keep sensitive data on-premises have driven demand for machines that can load 70-billion-parameter (or larger) models entirely in local memory and generate responses at usable speeds without ever calling an external API.

Two architectural approaches dominate the new wave of desktop AI workstations. The first centers on unified-memory systems that treat a large pool of fast LPDDR5X as shared resource for CPU, GPU, and neural processing units. NVIDIA’s GB10 Grace-Blackwell Superchip (the heart of the DGX Spark family) and AMD’s Ryzen AI Max+ 395 “Strix Halo” both exemplify this design. The second approach stays closer to traditional workstation practice: high-core-count x86 processors paired with discrete professional GPUs such as the NVIDIA RTX PRO 6000 Blackwell, offering massive dedicated VRAM, expandability, and the mature CUDA software stack.

Both categories became commercially available across late 2025 and the first half of 2026 (although shipment dates and regional availability varied considerably by vendor), joined by configurable towers from specialists and an expanding roster of compact systems from smaller vendors that sell directly through Amazon and their own stores. Later in the year the next leap-NVIDIA GB300-based deskside systems with hundreds of gigabytes of coherent memory capable of trillion-parameter inference-is scheduled to arrive from HP, Dell, ASUS, and others.

This article surveys the machines that reached the market or were firmly announced in 2026, examines real-world AI benchmarks where available, notes pricing and availability (including Amazon listings for smaller brands), and considers practical trade-offs for developers, creators, researchers, and enterprise teams.

The Technological Shift That Made It Possible

Until roughly 2024-2025, running a 70B-class dense model locally usually meant either quantizing aggressively, splitting across multiple consumer GPUs, or accepting glacial token rates. Memory bandwidth and capacity were the bottlenecks. Unified-memory architectures change the equation. On a GB10 or Strix Halo system the same 128 GB pool serves both general computation and the model weights plus KV cache. Bandwidth in the 250-273 GB/s range is lower than a discrete high-end GPU’s GDDR7, yet the sheer capacity lets models that simply would not fit on a 32 GB card load at all.

Independent measurements collected in mid-2026 illustrate the practical outcome. In representative single-user tests, optimized 70B-class models often generate roughly 3-6 tokens per second on GB10 and Strix Halo systems. Results vary substantially with the exact model, quantization, runtime, context length and prompt-processing workload.

Mixture-of-experts models with fewer active parameters can run substantially faster. Higher-bandwidth Apple silicon configurations pull ahead on the same models, while pure discrete-GPU towers with 32-96 GB of dedicated VRAM excel at throughput once the model fits and at training or fine-tuning workloads that benefit from higher floating-point performance.

NPU TOPS numbers (50 on the Ryzen AI Max, higher marketing figures elsewhere) matter more for always-on agentic features and smaller models than for large-language-model decode speed. For the latter, memory capacity and bandwidth remain decisive.

NVIDIA GB10 / DGX Spark Class: Compact CUDA Supercomputers

NVIDIA’s DGX Spark platform, based on the GB10 Grace-Blackwell Superchip, pairs a 20-core Arm CPU (10 Cortex-X925 + 10 Cortex-A725) with a Blackwell GPU containing 6,144 CUDA cores and 192 fifth-generation Tensor cores. The package delivers up to 1 petaFLOP of sparse FP4 AI performance and 128 GB of LPDDR5X unified memory at roughly 273 GB/s. Systems ship with NVIDIA’s DGX OS (Ubuntu-based) and the full CUDA software stack, making them immediately familiar to developers already working in the NVIDIA ecosystem.

Partner machines appeared throughout late 2025 and 2026. The ASUS Ascent GX10 stands out for accessibility: a compact 150 × 150 × 51 mm chassis weighing about 1.5 kg, available on Amazon in 1 TB and 4 TB storage configurations. Street prices have fluctuated; mid-2026 listings commonly sat near $3,900-$4,700 depending on storage, with occasional discounts bringing the 1 TB model closer to $3,100-$3,900.

Dell’s Pro Max with GB10, MSI’s EdgeXpert, HP’s ZGX Nano, Lenovo’s ThinkStation PGX variants, Acer, and Gigabyte offerings share the same silicon and therefore essentially identical compute characteristics. Differences appear in chassis design, networking (many include high-speed Ethernet or ConnectX-7 200 GbE ports for clustering), storage options, warranty, and enterprise support.

In practice these boxes run models up to roughly 200 billion parameters in mixture-of-experts form or 70B dense at Q4/Q8 with usable interactive speeds. Community and lab results show strong batching efficiency on smaller models and solid performance for agentic workloads, fine-tuning of mid-sized models, and local RAG pipelines. Clustering multiple units via high-speed networking has been demonstrated for larger MoE inference.

Power draw stays modest (around 140 W class under load for the core platform), and the systems run quietly enough for desk use. The main limitations are the Linux-centric DGX OS (Windows support is limited or absent on pure GB10 boxes), soldered memory, and the fact that absolute token throughput on dense 70B models trails higher-bandwidth discrete GPUs or Apple’s top silicon when the model fits.

AMD Ryzen AI Max+ 395 “Strix Halo” Systems: Windows-Friendly Value

AMD’s answer is the Ryzen AI Max+ 395, a 16-core/32-thread Zen 5 processor with 40 RDNA 3.5 compute units (Radeon 8060S) and an XDNA 2 NPU rated around 50 TOPS, for a platform total often quoted near 126 TOPS. Unified LPDDR5X memory reaches 128 GB (with later PRO 495 variants demonstrated at 192 GB). Up to 96 GB can be allocated as variable graphics memory. Bandwidth sits near 256 GB/s.

The crucial practical advantages are native Windows 11 support, x86 compatibility, and significantly lower entry prices. Multiple mini-PC and small-form-factor systems reached the market in 2026.

Beelink’s GTR9 Pro has drawn particular attention. Configured with the Ryzen AI Max+ 395, 128 GB memory, dual 10 GbE, dual USB4, dual M.2 slots, and a vapor-chamber cooler, it sells near $1,800-$2,000 and appears regularly on Amazon and the manufacturer’s store. Independent reviews report roughly 5 tokens per second on 70B dense models and much higher rates on 30B MoE or optimized 120B MoE workloads. Dual 10 GbE makes it attractive for networked model serving.

GMKtec’s EVO-X2 and later EVO-X3 variants, Minisforum MS-S1 Max, Framework Desktop (with modular design and upcoming 192 GB PRO 495 options), HP Z2 Mini G1a, Corsair AI Workstation, and MSI PRO MAX EDGE AI+ offer similar core compute in different chassis and I/O packages. Framework emphasizes repairability and Linux friendliness; HP emphasizes enterprise certification and the validated AMD Ryzen AI Halo software stack with ROCm and pre-installed frameworks.

AMD has published guidance on clustering multiple Strix Halo nodes for larger mixture-of-experts inference, extending the reach of these relatively inexpensive boxes. Token rates on dense 70B models are competitive with GB10 systems at similar bandwidth; MoE models can feel snappier. The software ecosystem (ROCm) continues to mature but still trails CUDA in breadth for some advanced training and agent frameworks.

Traditional and Hybrid Towers: Discrete GPU Power and Expandability

Not every AI workload fits neatly into a 128 GB unified pool. Training, multi-user inference, high-precision image and video generation, and workloads that benefit from massive dedicated bandwidth still favor discrete GPUs.

Lenovo’s ThinkStation P4, announced in May 2026 and shipping from June in selected markets, pairs up to an AMD Ryzen 9 PRO 9965X3D (16 cores, 3D V-Cache, 5.5 GHz) with an NVIDIA RTX PRO 6000 Blackwell Workstation Edition GPU carrying 96 GB of GDDR7 ECC memory. The combination is rated up to 4,000 TOPS of AI performance. System memory reaches 256 GB DDR5, storage supports multiple M.2 and 3.5-inch drives, and the 30-liter chassis includes advanced thermal design with liquid cooling options for the higher-power CPUs.

Slimbook’s Nexus series, launched in July 2026 by the Spanish Linux-friendly builder, offers two configurable platforms. The Nexus Ryzen AI starts around €1,995 and supports AMD Ryzen 9 processors, up to 128 GB DDR5, and dual NVIDIA RTX Blackwell 6000 cards depending on motherboard. The higher-end Nexus Threadripper AI begins near €3,880 and scales to Threadripper PRO 9995WX (up to 96 cores), 512 GB DDR5 RDIMM, dual professional GPUs, and 2,500 W power supplies. Aluminum chassis, air or AIO liquid cooling, and extensive storage options make them genuine workstations rather than sealed mini systems.

Custom and boutique builders (Puget Systems, BOXX, Lambda, various Amazon and Newegg sellers) continue to offer towers built around GeForce RTX 5090 (32 GB GDDR7) or professional Blackwell cards. A typical high-end single-GPU build in mid-2026 lands in the $5,000-$7,000 range before case and cooling, delivering excellent throughput once models fit in VRAM and superior performance for generative image/video and fine-tuning.

These systems trade compactness and low power for expandability, higher sustained floating-point performance, and the ability to add more GPUs or storage later. They remain the practical choice when 128 GB of unified memory is insufficient or when CUDA software maturity is non-negotiable.

Enterprise Deskside Supercomputers on the Horizon

At the extreme end, HP’s ZGX Fury GB300, Dell Pro Max with GB300, ASUS ExpertCenter Pro ET900N G3, and related systems based on NVIDIA’s GB300 Grace Blackwell Ultra Desktop Superchip are scheduled for later 2026. These deskside machines target up to roughly 748-784 GB of coherent memory and up to 20 petaFLOPS of FP4 performance, enabling local inference and fine-tuning of models approaching one trillion parameters. Pricing is expected to start in the high five figures and climb well into six figures for fully configured units-firmly enterprise territory.

HP has indicated Windows support is planned for these platforms, addressing a common enterprise requirement. The systems are positioned for teams that need always-on frontier agents, multi-user inference, or regulated environments where data cannot leave the premises.

Benchmarks in Context

Absolute numbers vary with quantization, framework (llama.cpp, vLLM, Ollama, TensorRT-LLM, ROCm equivalents, Apple MLX), context length, and batch size. Available testing broadly suggests the following patterns, although direct comparisons remain difficult because benchmark configurations differ:

• Memory capacity determines which models load. Rough Q4 footprints run 0.55-0.6 GB per billion parameters plus overhead for KV cache; Q8 roughly doubles that.
• Bandwidth largely sets decode speed for a given model size. 250-273 GB/s systems cluster around a few tokens per second on dense 70B models; higher-bandwidth Apple configurations and discrete high-end GPUs pull ahead when the model fits.
• Mixture-of-experts architectures with low active parameter counts run dramatically faster on the same hardware.
• Discrete professional GPUs still dominate high-precision generation, large-batch training, and multi-GPU scaling.

YouTube channels and independent labs (ServeTheHome, StorageReview, ShortCircuit, Micro Center hardware walk-throughs, and various AI-focused creators) have published hands-on footage of these systems loading 70B-120B models, running agents, and comparing token rates. Viewing recent reviews of the ASUS Ascent GX10, Beelink GTR9 Pro, Framework Desktop, and HP Z2 Mini G1a provides useful qualitative context that raw numbers cannot capture-noise levels, thermal behavior under sustained load, software setup friction, and real interactive feel.

Buying Considerations and the Role of Smaller Vendors

For most individual developers and small teams the decision reduces to three questions: Does the model fit in memory? Is the software stack I need supported? What is the total cost of ownership versus cloud usage?

Budget-conscious buyers often start with a Strix Halo mini-PC in the $1,800-$2,500 range (Beelink, GMKtec, Minisforum). These deliver genuine 70B capability under Windows or Linux at power and noise levels compatible with a home office. CUDA-centric workflows favor a GB10 box near $4,000. Professional creators who also render and simulate may prefer a configurable tower with an RTX PRO 6000 or dual-card options. Enterprises evaluating multi-user or regulated workloads should watch the GB300 deskside systems arriving later in 2026.

Amazon has become a practical channel for the smaller vendors. ASUS Ascent GX10 configurations, Beelink GTR9 Pro, various GMKtec and Minisforum Strix Halo systems, and occasional Slimbook or other European builds appear with varying stock and pricing. Warranty support, return policies, and firmware update practices differ; checking recent buyer reviews and manufacturer direct channels is advisable.

Power, acoustics, and form factor matter more than many first-time buyers expect. A 140 W quiet mini system that sits under a monitor is a different daily experience from a 1,000-plus-watt tower that needs dedicated cooling and power circuits.

Looking Ahead

By late 2026 the RTX Spark platform (Windows-on-Arm systems with up to 128 GB unified memory and RTX-class graphics) is expected from major OEMs, potentially broadening the high-end consumer and creator segment. AMD’s next Halo generation and further memory-bandwidth improvements are already on roadmaps. Software continues to improve: better quantization, speculative decoding, and agent frameworks extract more usable performance from existing silicon.

The larger story is cultural as much as technical. Local AI workstations restore a measure of control and predictability that pure cloud dependence erodes. Whether the use case is private coding agents, domain-specific fine-tuning on proprietary data, always-on personal assistants, or simply experimenting without meter-running costs, 2026 has delivered practical hardware that makes those goals attainable on a single desk.

The machines described here are not perfect. Memory is often soldered, software ecosystems remain uneven, and the highest-capacity systems carry enterprise price tags. Yet for the first time a broad range of users can place genuine large-model capability within arm’s reach, quietly humming under a monitor or beside a keyboard, ready whenever the next idea arrives.

Sources

• Sources

• HP Debuts PCs Built for the Next Wave of Windows PC Experiences Powered by NVIDIA RTX Spark (HP official press release): https://www.hp.com/us-en/newsroom/press-releases/2026/computex.html

• HP Z AI Stations product page (HP official): https://www.hp.com/us-en/workstations/ai-stations.html

• Lenovo Announces the ThinkStation P4, a Flagship Combination of Power and Value for Modern Professionals (Lenovo official press release): https://news.lenovo.com/pressroom/press-releases/thinkstation-p4-flagship-power-value-professionals/

• AI PCs & local-AI supercomputers 2026: shipping now vs coming - VerdictBits

• AI PC benchmark 2026 - local-LLM speed and memory comparison - VerdictBits

• Slimbook Launches Nexus AI Workstation Series - TechPowerUp

• Framework Desktop, whose existing configurations emphasize modularity and repairability, has also previewed a forthcoming Ryzen AI Max+ PRO 495 option with 192 GB of unified memory.

• Digital Citizen

• HP announces the most powerful Windows AI PC ever built - Nvidia GB300 workstation - TechRadar

• MSI launches compact PRO MAX EDGE AI+ desktops - TweakTown

• ASUS Ascent GX10 Review A New NVIDIA GB10 Solution - ServeTheHome

• Beelink GTR9 Pro Review: Fast 120B MoE, Slow Dense 70B - The Desk Brief

• AMD Ryzen AI Halo First Look: Giant Local AI Power in a Pint-Sized Box - PCMag

• Nexus AI Workstation announcement - Slimbook

• Additional independent reviews and benchmark compilations from ServeTheHome, StorageReview, Phoronix, TechRadar, PCMag, and YouTube channels covering hands-on testing of the systems named above throughout 2026

Google’s agentic stack is no longer a collection of loosely related tools. By mid-2026, Google has developed an increasingly coherent full-stack system spanning production services and newer preview capabilities that includes models, open protocols, a purpose-built development kit, a managed enterprise platform, an agent-native data layer, long-running runtimes, evaluation harnesses, and governance controls. The result is everything required to move from a simple tool-using chatbot to fleets of autonomous, multi-day agents that reason, act, collaborate, and improve themselves inside real enterprise environments.

This article walks through that stack in plain language, drawing on official Google Cloud documentation, developer blogs, architecture guides, and recent technical sessions. The goal is practical clarity: what each piece does, why it exists, how the pieces fit together, and what you actually need to build reliable agentic systems.

From Generative AI to Agentic Systems

For several years the dominant pattern was a large language model that answered questions or generated content. An agent changes the contract. An agent receives a goal, plans a sequence of steps, calls tools or other agents, observes results, revises its plan, and continues until the goal is met or it decides it cannot proceed. Memory, state, identity, and external action become first-class concerns.

Google’s response has been deliberate. Rather than bolting agents onto an existing generative-AI platform, the company has re-oriented its entire AI surface around agents. Vertex AI capabilities now live inside the Gemini Enterprise Agent Platform. Data infrastructure has been re-architected as an Agentic Data Cloud. Open protocols for tool use and agent-to-agent communication have been standardized. And a single open-source framework-the Agent Development Kit-has become the recommended way to write the logic that sits at the center of these systems.

The practical outcome is that a developer or architect no longer has to assemble a fragile collection of open-source libraries, custom servers, and ad-hoc memory stores. The stack supplies the pieces, and the pieces are designed to work together.

The Reasoning Core: Gemini Models

Every agent begins with a model that can plan and decide. Google’s Gemini family supplies that core. By 2026 the lineup includes high-capability reasoning models (Gemini 3.x Pro variants) and fast, cost-efficient models optimized for agent loops (Gemini 3.5 Flash and later 3.6 Flash). These models support long context windows, native multimodality, and explicit “thinking” budgets that let an agent allocate more internal computation to harder sub-problems.

In an agentic setting the model is rarely used as a pure text generator. It is given a system instruction that describes its role, a set of available tools described in natural language, conversation history or session state, and the current goal. The model then emits either a final answer or a structured tool call. The surrounding framework executes the call, returns the result, and the loop continues.

Model Garden inside the Gemini Enterprise Agent Platform exposes Google models alongside selected partner and open models. This gives architects the freedom to route simple steps to cheaper or specialized models while reserving the most capable models for complex planning. Model routing itself can be implemented as part of the agent logic or left to platform-level controls.

The Developer Foundation: Agent Development Kit (ADK)

If Gemini is the brain, the Agent Development Kit is the nervous system that turns reasoning into reliable software. ADK is an open-source, multi-language framework (Python, TypeScript, Go, Java, Kotlin) released and actively evolved by Google. It is the same framework that powers agents inside Google’s own products.

At its simplest, an ADK agent is a few lines of code: a name, a model identifier, a natural-language instruction, and a list of tools. Tools can be ordinary Python functions whose docstrings become the description the model sees, built-in utilities such as Google Search or code execution, or remote tools reached through the Model Context Protocol.

ADK quickly scales beyond the single-agent case. Hierarchical multi-agent systems are native: a root agent can transfer control to specialized sub-agents based on the current task. Workflow agents support sequential, parallel, and loop patterns. Graph-based orchestration (emphasized in ADK 2.0) lets developers mix deterministic control flow with adaptive LLM decisions, producing systems whose behavior is both flexible and inspectable.

Context management is treated as a first-class problem. Sessions hold short-term conversational state. Long-term memory can be stored in Memory Bank or external databases. Context management is treated as a first-class problem. Sessions hold short-term conversational state, while long-term memory can be stored in Memory Bank or external databases. ADK provides configurable mechanisms for context filtering, compaction, summarization, scoping, and token monitoring, allowing developers to control what information reaches each agent.

Evaluation is built in. Developers define test cases that include expected trajectories (the sequence of tool calls and intermediate states) as well as final answer quality. The same evaluation harness runs locally during development and can be connected to continuous evaluation on live traffic once the agent is deployed.

Deployment is deliberately flexible. An agent can be run locally, containerized and placed on Cloud Run or GKE, or handed to the managed Agent Runtime on the Gemini Enterprise Agent Platform with a single command. In the managed case the platform supplies authentication, observability, scaling, and security controls without code changes.

The Open Protocols: MCP and A2A

Two open protocols complete the interoperability layer.

Model Context Protocol (MCP) standardizes how an agent discovers and calls tools and data sources. An MCP server exposes resources, tools, and prompts in a consistent format. Google provides managed MCP servers for many of its own services and supports self-hosted or third-party servers. Because the interface is standardized, the same agent code can use internal enterprise APIs, SaaS connectors, or public tools without custom glue for each one. Progressive disclosure patterns-loading only the tool schemas needed for the current step-prevent tool bloat that would otherwise degrade model accuracy.

Agent2Agent (A2A) protocol addresses the complementary problem of agent-to-agent collaboration. Announced with broad industry support, A2A lets agents discover one another’s capabilities via Agent Cards, exchange messages securely, and coordinate long-running tasks across organizational or framework boundaries. It is deliberately complementary to MCP: MCP connects an agent to tools and data; A2A connects agents to other agents. Together they form the horizontal and vertical plumbing of multi-agent systems.

Both protocols are natively supported inside ADK and the Gemini Enterprise Agent Platform, so developers do not have to implement the wire formats themselves.

The Enterprise Platform Layer

The Gemini Enterprise Agent Platform (the evolution of Vertex AI focused on agents) supplies the managed services that turn experimental agents into production systems.

Agent Studio offers a low-code visual canvas for designing agents and sub-agent networks. Agent Development Kit remains the code-first path for complex logic. Agent Garden provides production-ready templates and blueprints for common patterns such as research agents, invoice processing, or multi-agent orchestration.

Agent Runtime is the managed execution environment. It supports sub-second cold starts, multi-day workflows, scalable deployment, and integration with sandboxed code-execution services. Applications can separately use Gemini’s real-time APIs for bidirectional audio and video interactions. Memory Bank automatically curates long-term memory from conversations. Sessions can be linked to existing enterprise records through custom identifiers.

Governance is handled by Agent Identity (cryptographic identities with auditable trails), Agent Registry (a centralized catalog of approved agents, MCP servers, skills, and tools), and Agent Gateway (policy enforcement and protection against prompt injection and data leakage). Observability tools trace every reasoning step and tool call. Simulation and continuous evaluation services let teams test agents against synthetic users and live traffic, then feed failure clusters back into an optimizer that suggests improved instructions.

ADK also supports portable Agent Skills: modular packages of instructions, resources, and domain expertise that agents can load through progressive disclosure. Skills can be stored in source repositories or mounted into managed agents, keeping the primary context lean while making specialized knowledge available when required.

The Data Foundation: Agentic Data Cloud

Agents are only as useful as the data they can reach and understand. Google’s Agentic Data Cloud reorients the traditional data stack around agents rather than human analysts.

Knowledge Catalog acts as a universal context engine. It automatically generates semantic metadata, entity relationships, and ranked retrieval logic across structured, unstructured, and SaaS data. The result is a richer context layer that can improve retrieval relevance and reduce the risk of unsupported answers when it is paired with appropriate grounding and evaluation.

A cross-cloud lakehouse built on open formats such as Apache Iceberg lets agents query data where it already lives-on Google Cloud, other clouds, or on-premises-without forced movement. Data Agent Kit packages MCP tools and IDE plugins so that data engineers can describe desired outcomes in natural language and let agents assemble the necessary pipelines and queries.

Because the same stack owns the TPUs, the models, and the data services, latency and cost characteristics are tightly optimized. Agents can reason over live operational data in AlloyDB or Spanner and analytical data in BigQuery within a single workflow.

Long-Running Agents, State, and Evaluation Harnesses

Many real-world processes span hours or days: employee onboarding, multi-stage procurement, complex research projects, or continuous monitoring. Stateless request-response loops cannot handle them. Google’s stack therefore treats durable state and event-driven resumption as core capabilities.

In ADK a developer defines an explicit state machine whose checkpoints are persisted through a DatabaseSessionService (backed by Cloud SQL in production). Tools advance the state atomically. When the agent must wait for an external event-a signed document, a hardware delivery confirmation, an approval-it can sleep. A webhook later hydrates the session, applies a state delta, and resumes execution from the exact point it left off. Sub-agents can be delegated specialized work while sharing the same durable state.

The managed Agent Runtime extends these patterns with multi-day SLAs, scheduled triggers, and environment hooks that run custom logic before or after tool calls. Token budgets prevent runaway loops. Observability traces the entire multi-day trajectory.

Evaluation harnesses operate at every stage. Local ADK evaluation checks trajectories against expected paths. Platform-level simulation generates synthetic user interactions. Continuous evaluation scores live traffic with multi-turn autoraters. Anomaly and threat detection flag unusual behavior in real time. Together these form the closed-loop system that turns brittle prototypes into reliable production services.

Development Experience: Antigravity, CLI, and Supporting Tools

Google Antigravity functions as the agent-first command center and IDE. Developers can launch, monitor, and orchestrate multiple local or remote agents in parallel, group work into projects, and automate routine tasks with scheduled messages. The Antigravity IDE understands the codebase deeply and can itself be driven by agents that plan, write, and verify code. A lightweight CLI provides terminal-first control for the same workflows.

Agents CLI (part of the broader ADK ecosystem) scaffolds, tests, evaluates, and deploys agents. Pre-built connectors and Application Integration flows give agents secure access to hundreds of enterprise systems without custom code for each integration.

Putting the Stack Together

A typical production architecture begins with an ADK multi-agent system that uses Gemini for reasoning, MCP for tools and data, and A2A for collaboration with external agents. Durable state and Memory Bank keep context across long-running steps. The system is deployed to Agent Runtime, registered in Agent Registry, protected by Agent Gateway and identity controls, and continuously evaluated. Knowledge Catalog and the Agentic Data Cloud ensure the agents operate on governed, semantically rich data. Antigravity and the Agents CLI accelerate the development and iteration loop.

The same components support simpler use cases-single agents, short interactions, or low-code designs in Agent Studio-without forcing developers into unnecessary complexity. The stack is modular by design.

Governance, Security, and Operational Reality

Enterprise adoption hinges on trust. Unique agent identities, policy enforcement at the gateway, sandboxed execution, Model Armor protections, anomaly detection, and full audit trails address the most common concerns. Because agents can act, the principle of least privilege and human-in-the-loop checkpoints remain essential design practices. The platform supplies the mechanisms; architects still decide where to place the guardrails.

Cost control is achieved through model routing, token budgets, scale-to-zero runtimes, and the inherent efficiency of Google’s vertically integrated stack. Observability surfaces the true cost of each reasoning step so that teams can optimize.

Looking Forward

The pieces described here are already in production use across industries. The trajectory is clear: agents will become the primary interface to software and data, multi-agent collaboration will span organizational boundaries, and the quality of an organization’s agentic systems will become a competitive differentiator. Google’s stack lowers the barrier to building those systems while raising the ceiling on what can be achieved safely and at scale.

The practical starting point for most teams is straightforward. Install ADK, write a simple agent that uses a few tools, add durable state and evaluation, deploy it to the managed runtime, and expand outward. The rest of the stack is ready when the requirements demand it.

Everything required to build serious AI agents, multi-agent systems, evaluation harnesses, and autonomous workflows now exists in one coherent set of models, frameworks, protocols, platforms, and data services. The remaining work is thoughtful design, rigorous evaluation, and careful operationalization-the same disciplines that have always separated prototypes from production software.

Sources

• Gemini Enterprise Agent Platform overview: https://cloud.google.com/products/gemini-enterprise-agent-platform
• Introducing Gemini Enterprise Agent Platform: https://cloud.google.com/blog/products/ai-machine-learning/introducing-gemini-enterprise-agent-platform
• Choose agentic AI architecture components: https://docs.cloud.google.com/architecture/choose-agentic-ai-architecture-components
• Agent Development Kit documentation: https://adk.dev/ and https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/adk
• ADK announcement and multi-agent guide: https://developers.googleblog.com/agent-development-kit-easy-to-build-multi-agent-applications/
• Agentic Data Cloud: https://cloud.google.com/data-cloud
• Agent2Agent Protocol announcement: https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
• Long-running agents with ADK: https://developers.googleblog.com/build-long-running-ai-agents-that-pause-resume-and-never-lose-context-with-adk/
• Agent Registry overview: https://docs.cloud.google.com/agent-registry/overview
• Google Antigravity: https://antigravity.google/
• YouTube - Build long-running agents with Google’s Agentic Stack: https://www.youtube.com/watch?v=VGpfnbr7rso
• YouTube - Google’s new AI agent stack from I/O 2026: https://www.youtube.com/watch?v=pg6TOXyiIuo
• Additional ADK and platform technical sessions available on the Google Cloud Tech and Google for Developers YouTube channels.

In the middle of 2026, Rust sits in an interesting place. It is no longer the shiny new language that only systems programmers whispered about at conferences. It has entered the TIOBE Index top 10 for the first time. In the 2025 State of Rust Survey, nearly half of respondents who answered questions about their organizations reported non-trivial organizational use of Rust, although the self-selected survey should not be treated as representative of all companies. Stack Overflow developers still rank it the most admired language, year after year.

Salaries for experienced Rust engineers routinely sit well above those of more common languages. Major pieces of infrastructure at Microsoft, Google, Amazon, Cloudflare, Discord, and even the Linux kernel itself now contain production Rust code.

Yet the same surveys that celebrate admiration also reveal a persistent gap between love and everyday use. Most developers who know Rust do not treat it as their primary language. The talent pool remains smaller than for JavaScript, Python, or Java. Compile times still frustrate people. The learning curve has not disappeared. And for many teams-especially early-stage startups-the velocity cost of Rust still outweighs its safety and performance benefits.

So the real question is not whether Rust is “good.” By almost every technical measure it is excellent. The question is whether it makes sense as the language you reach for most of the time, the one that defines how you think about problems and structure your work. That answer depends heavily on what kind of software you build, the size and maturity of your team, and how much you value long-term correctness over short-term iteration speed.

This article examines the evidence from official surveys, industry case studies, job-market data, and the lived experience of developers who have tried to make Rust their main tool in 2025 and 2026. The goal is a clear-eyed view rather than hype or dismissal.

A brief reminder of what Rust actually is

Rust began as a Mozilla research project aimed at solving the memory-safety problems that plague C and C++ while keeping the performance and control those languages provide. Graydon Hoare started the work around 2006. The first stable release arrived in 2015. The core idea was ownership and borrowing: a compile-time system that tracks who owns data, who can borrow it, and for how long, so that many classes of bugs-including use-after-free errors and data races-are prevented in safe Rust through compile-time checks. Safe references cannot be null, although raw pointers and unsafe code can still introduce memory-safety errors.

Unlike languages that rely on garbage collection, Rust does not pause the program to reclaim memory. Unlike C++, it does not leave the programmer solely responsible for manual management. The result is a language that can match or beat C++ performance in many workloads while offering stronger guarantees. Concurrency is another strong point. The same ownership rules that prevent memory bugs also prevent data races, making it easier to write correct multi-threaded and asynchronous code.

By 2026 the language has matured considerably. Features that once lived only on the nightly channel have stabilized. The compiler produces better error messages. Tooling around Cargo (the package manager and build system) is widely praised. The ecosystem of crates has grown large enough that most common tasks have solid libraries. Yet the fundamental character remains the same: Rust asks more of the programmer up front so that the resulting software is safer and often faster.

The numbers in 2026

Several independent data sources give a consistent picture.

The 2025 State of Rust Survey, published in March 2026 by the Rust Survey Team and based on 7,156 responses, shows clear progress. Nearly half of the organizations represented (48.8 percent) report non-trivial use of Rust, up from 38.7 percent in 2023. Daily usage among respondents hit an all-time high of 55.1 percent. Among organizations already running Rust in production, 84.8 percent said it helped them achieve their goals and 78.5 percent said the adoption was worth the cost. Productivity self-ratings also improved: 56.8 percent of respondents now consider themselves productive Rust writers, up sharply from earlier years.

The same survey still highlights pain points. Slow compilation is the biggest complaint, cited by a large majority as a significant problem. High disk usage from build artifacts, imperfect debugging experiences, and occasional friction with the borrow checker remain common. Hiring intent is rising-31.6 percent of organizations plan to hire Rust developers-but the absolute number of available candidates is still limited compared with more popular languages.

Stack Overflow’s 2025 Developer Survey continues the long-running pattern: Rust is the most admired language at 72 percent. Developers who have used it want to keep using it. Cargo ranks as the most admired cloud development and infrastructure tool. At the same time, overall usage remains far lower than JavaScript, Python, Java, or even Go. Admiration consistently outpaces adoption.

TIOBE data for July 2026 shows Rust entering the top 10 for the first time, with a 1.34 percent share. That is still modest in absolute terms, but the trajectory is upward. RedMonk and GitHub rankings place it lower, reflecting that many repositories still treat Rust as a specialized rather than primary language.

JetBrains data from its 2025 Developer Ecosystem Survey estimates roughly 2.27 million developers have used Rust in the previous twelve months, with about 709,000 identifying it as a primary language. That is meaningful growth, yet it still represents a relatively small fraction of the global developer population. Sixty-five percent of Rust users in one JetBrains-related survey reported using it for side or hobby projects, while only 26 percent used it professionally. A large share of respondents were still learning the language.

Taken together, the numbers describe a language that has moved from experimental to established niche. It is no longer rare in serious production systems, but it is not yet the default choice for most software work.

Where Rust is actually used as primary or near-primary

The strongest adoption stories come from domains where memory safety, performance, and reliability matter more than rapid feature iteration.

Cloudflare’s Pingora proxy, written in Rust and replacing parts of the earlier Nginx-based infrastructure, handles enormous traffic volumes while cutting CPU usage dramatically. Discord rewrote critical services that previously suffered from garbage-collection pauses in Go; the Rust versions delivered large reductions in latency.

Microsoft has incorporated Rust into Windows components and Azure services, and has publicly discussed using it to reduce memory-related vulnerabilities. Google has shipped substantial amounts of Rust in Android and other systems. Amazon uses it in Firecracker and other infrastructure pieces. Meta, Dropbox, and Figma have all reported production use for performance-sensitive parts of their stacks.

The Linux kernel provides one of the clearest signals of long-term seriousness. After years of careful experimentation, kernel maintainers declared in late 2025 that Rust is no longer experimental. Following the 2025 Linux Kernel Maintainers Summit, maintainers concluded that the Rust experiment had succeeded and removed its experimental status. Rust support is now considered a permanent part of the kernel, and several Rust-written drivers and components have entered mainline, although C remains the kernel’s dominant implementation language. That decision carries weight because the kernel community is famously conservative about language choices.

In embedded systems, blockchain, high-performance networking, and security-critical code, Rust has become a realistic primary option. Many new projects in these areas start with Rust rather than treating it as an add-on. Command-line tools and systems utilities also favor it because a single native binary that can often be distributed with few external dependencies-and, on suitable targets, statically linked.

Outside these domains the picture is more mixed. Web backend development is possible and increasingly practical-Axum and Actix Web are mature, Tokio is the standard async runtime, and the surrounding crates ecosystem covers most needs. Yet the experience is still more “assemble your own stack” than the batteries-included feel of Django, Rails, or even Spring. Teams that already know Python or Node often stay with those languages for ordinary CRUD services and only reach for Rust when they hit performance walls. Full-stack web or mobile development remains uncommon as a primary Rust activity.

The job market and compensation

Demand for Rust skills has grown faster than the supply of experienced developers. Job postings mentioning Rust increased noticeably through 2025. Average salaries in the United States for mid-level Rust engineers are frequently reported in the $150,000-$170,000 range, with senior and staff roles climbing well above $200,000 and total compensation at top companies sometimes reaching $300,000 or more. Specialized roles in systems, infrastructure, or Web3 can command even higher figures. These premiums exist largely because the talent pool is constrained.

That scarcity is a double-edged sword. For an individual developer who invests the time to become proficient, the economic return can be strong. For a company trying to staff a team, it creates risk. Several experienced engineers and managers have noted in 2026 that posting a Rust role still yields far fewer applicants than equivalent postings for Python, Java, or even C++. Hiring remains one of the practical barriers to making Rust the primary language across an entire organization.

The learning curve and day-to-day productivity

Almost everyone who has learned Rust agrees that the first months are harder than the first months of most other languages. The ownership and borrowing rules force a different mental model. Programmers coming from garbage-collected languages must unlearn the habit of freely sharing mutable state. Programmers coming from C or C++ must unlearn certain patterns that the borrow checker rejects. Error messages, while improved, can still feel opaque at first.

Once the model clicks, many developers report that they write fewer bugs and spend less time debugging memory and concurrency issues. Productivity self-ratings in the State of Rust Survey have risen over time. Tooling helps: rust-analyzer provides fast feedback inside editors, Cargo makes dependency management pleasant, and Clippy catches a wide range of style and correctness issues.

The arrival of capable large language models has changed the experience further. In 2026 it is common for developers to use AI assistants to explain borrow-checker errors, suggest idiomatic patterns, or generate boilerplate. Several accounts describe writing tens of thousands of lines of Rust more quickly than was realistic a few years earlier. At the same time, experienced Rustaceans warn that AI-generated code can be non-idiomatic or subtly incorrect, so the human still needs to understand the underlying rules. The language has not become “easy,” but the friction of getting started has decreased.

Compile times remain a frequent complaint. Large projects can still take long enough that the edit-compile-test loop feels slower than in Go or interpreted languages. Incremental compilation and better caching have helped, yet the issue has not vanished. Disk space consumed by target directories is another recurring annoyance.

Ecosystem maturity

In 2026 the crate ecosystem is large and generally high quality for systems, networking, and performance-oriented work. For web services the situation is solid but modular. Axum has become a popular default for many new projects because of its type-driven design and integration with the Tower middleware ecosystem. Actix Web remains strong for maximum performance. Database access, authentication, serialization, and observability all have mature options. WebAssembly support is good, and embedded libraries continue to improve.

Gaps still exist relative to more established ecosystems. There is no single dominant full-stack framework with the breadth of Django or Laravel. Scientific computing and data analysis libraries lag behind Python’s. Mobile development is possible but not mainstream. Interoperability with existing C and C++ codebases works well via FFI, which is how many large organizations introduce Rust incrementally rather than rewriting everything at once.

Overall, the ecosystem is mature enough that a competent team can build substantial production systems without constantly inventing missing pieces. It is not yet so mature that a junior developer can spin up a complex application with the same ease as in some other languages.

Comparisons that matter

Against C and C++, Rust offers stronger safety guarantees and often comparable or better performance, at the cost of a steeper learning curve and less historical code. Many teams that previously defaulted to C++ for systems work now seriously consider Rust for new components, especially when security is a priority.

Against Go, Rust generally offers finer control over memory, predictable performance without garbage collection, and compile-time prevention of data races in safe code. Go offers a simpler language, faster compilation, garbage-collected memory management, and often faster onboarding. Teams that value rapid iteration and large existing Go codebases often stay with Go; teams that need the last bit of efficiency or stronger guarantees move pieces to Rust.

Against Python, Java, or JavaScript/TypeScript, the comparison is domain-specific. Those languages remain far more productive for the majority of application development, data work, and web front ends. Rust appears when the performance or safety requirements justify the extra investment.

Practical considerations for making Rust primary

If your work centers on systems software, high-performance networking, embedded devices, security-critical components, or infrastructure where a single efficient binary is valuable, Rust is already a strong primary choice in 2026. The language has proven itself at scale, the community is supportive, and the economic incentives are favorable for individuals.

If your work is primarily product-facing web applications, data analysis, rapid prototyping, or anything where shipping features quickly is the dominant constraint, Rust is usually better treated as a secondary or specialized language. You can still use it for the performance-critical parts while keeping the rest of the system in a higher-velocity language.

Team size and experience matter. A small group of strong engineers who already know Rust can be highly productive. A larger organization with mixed skill levels will face higher training and hiring costs. Early-stage startups often find the velocity trade-off unattractive unless the product itself demands the properties Rust provides.

AI tooling has lowered the barrier, but it has not eliminated the need for genuine understanding. Treating Rust as primary still requires investing in the mental model.

Looking ahead from mid-2026

The trajectory is positive. Enterprise adoption continues to rise. Kernel support is now permanent. Tooling and documentation keep improving. The admiration scores remain high. Nothing suggests that interest is fading. At the same time, Rust is unlikely to displace the most popular languages for general-purpose work in the near term. Its strengths are real and its niche is expanding, but that niche is still a specialized one relative to the full spectrum of software development.

For an individual developer, the decision to make Rust primary is increasingly defensible if the domains you care about align with its strengths. The combination of technical quality, growing production use, and compensation premiums makes the investment attractive. For organizations, the decision remains more contextual: the safety and performance gains are proven, yet the organizational costs of talent and velocity are still material.

Rust in 2026 is no longer an experiment. It is a serious, production-ready language that rewards careful thought and delivers measurable benefits in the right settings. Whether those settings match your daily work is the question only you can answer. The evidence suggests that for a growing number of developers and teams, the answer is increasingly yes-provided they go in with open eyes about the trade-offs that remain.

Sources

• Rust Survey Team / Rust Blog / 2025 State of Rust Survey Results: https://blog.rust-lang.org/2026/03/02/2025-State-Of-Rust-Survey-results/
• Stack Overflow / Stack Overflow 2025 Developer Survey / Technology section: https://survey.stackoverflow.co/2025/technology
• TIOBE / TIOBE Index for July 2026: https://www.tiobe.com/tiobe-index/
• JetBrains / RustRover Blog / The State of Rust Ecosystem 2025: https://blog.jetbrains.com/rust/2026/02/11/state-of-rust-2025/
• The New Stack / Nearly half of all companies now use Rust in production
• Matt Welsh / Medium / Revisiting Rust in 2026
• TechTarget / Why is Rust a critical programming language in 2026?
• Wikipedia / Rust for Linux (and related December 2025 kernel adoption announcements)
• Various authors / rustify rs, rustjobs dev, web3 career / Rust developer salary surveys and guides for 2026
• Rust community / Are We Web Yet?
• Jon Gjengset (interviewed by JetBrains) / YouTube / Rust 2026: $400K Salaries, Java, AI & Why It's Not Everywhere (Yet)
• ForrestKnight / YouTube / Why Everyone's Switching to Rust (And Why You Shouldn't)
• Dreams of Code / YouTube / Why I'm so bullish about Rust in 2026
• Let’s Get Rusty / YouTube / 2026 Will Make or Break Rust

mlx-dspark is an MLX port of DeepSeek's DSpark speculative-decoding drafters (the DeepSpec release), plus z-lab's DFlash, with one lossless verify loop. v0.10.0 adds Qwen3.8-27B via RadixArk's drafter, the first SpecForge/SGLang-packaged head it loads.

Numbers (M4 Pro 48 GB, medians of 3, greedy, output ids identical to plain decoding):

• 8-bit target: 2.45× mean at the auto-picked cap — 3.00× math / 2.38× code / 1.96× chat, 8.3 → 20.3 tok/s (code runs hit 3.18×). Peak ~29 GB.
• 4-bit target: 1.74× at 25.3 tok/s in ~18 GB (same drafter auto-resolves).
• Fun property: 8-bit + drafter (20-27 tok/s) beats plain 4-bit (14.6 tok/s) — 8-bit quality at better-than-4-bit speed.

"Lossless" is checked, not asserted: the target verifies every drafted token, and the Mac app's Race view runs speculative vs plain on the same prompt and diffs the token ids (video is that view).

Everything is pip install mlx-dspark (OpenAI-compatible server + Anthropic Messages API, so it can back Claude Code with a local model), and there's a native Mac app (DMG/Homebrew).

Repo: github.com/ARahim3/mlx-dspark

I'd appreciate any feedback you might have after using it.