Table of Contents

Qwestly Engineering Learning Series

AI-Powered Code Editing, Agents, and Custom Toolchains

Engineering Excellence 2026

The Series — 5 Talks

"Agentic" Capability Chart — From bare LLMs to full agentic IDEs
BYOA/BYOM — Bring Your Own Agent / Model into any editor
Bring Your Own Editor — Zed & vim as first-class AI editors
DeepSeek & Reasonix — Open-weight frontier models & tooling
Qwestly Workspace — Our monorepo, agents, and MCPs in practice

Talk 1: The "Agentic" Capability Chart

From Basic LLM to Full Agentic Code Editor

What is "Agentic" Anyway?

LLM = just a model. Text in → text out.

Agent = model + tools + memory + planning loop

┌──────────────────────────────────────────────────────────┐
│                     AGENT ARCHITECTURE                   │
│                                                          │
│  ┌──────────┐    ┌──────────┐    ┌──────────────────┐   │
│  │   LLM    │───▶│ Planning │───▶│   Tool Dispatch  │   │
│  │ (reason) │◀───│  Loop    │◀───│  (bash, read,    │   │
│  └──────────┘    └──────────┘    │   write, search)  │   │
│                                  └──────────────────┘   │
│                                                          │
│  The model DECIDES what tool to call, when, and why.     │
└──────────────────────────────────────────────────────────┘

Key difference: A model can tell you how to fix a bug. An agent can go fix it.

Capability Ladder: Level 0 — Basic Chat

Capability	Has it?
Answer questions	✅
Generate code snippets	✅
Read files	❌
Run commands	❌
Remember context across turns	❌ (stateless)

Tools: None

Example: ChatGPT web interface, npx reasonix chat

User: "How do I fix this error?"
LLM: "Try adding a null check before..."
User: [copies code manually]

Capability Ladder: Level 1 — Budget Model (No Reasoning)

Capability	Has it?
Fast, cheap inference	✅
Multi-turn chat	✅
Deep reasoning / chain-of-thought	❌
Tool calling (if harness provides)	⚠️ Shallow

Examples:

DeepSeek V4 Flash ($0.14/M in, $0.28/M out, 1M context)
Claude Haiku 4.5 ($1.00/M in, $5.00/M out)
GPT-5.2 Codex

Best for: Quick edits, simple completions, high-volume tasks

Our usage: Default model in avante.nvim deepseek provider, reasonix fast turns

Capability Ladder: Level 2 — Premium Model (With Reasoning)

Capability	Has it?
Chain-of-thought / extended thinking	✅
Multi-step planning	✅
Deep debugging, architecture	✅
Tool calling	✅ (more reliable)

Examples:

DeepSeek V4 Pro ($0.435/M in, $0.87/M out, 1M context)
Claude Opus 4.7 ($5.00/M in, $25.00/M out)
GPT-5.5 ($5.00/M in, $30.00/M out)
Claude Sonnet 4.6 ($3.00/M in)

Our usage: deepseek-pro provider in avante, deepseek-v4-pro[1m] via Claude Code ACP

DeepSeek reasoning_effort knob: /effort max for hard problems, /effort high for daily work

Capability Ladder: Level 3 — Coding Agent

Capability	Has it?
Everything from Level 2	✅
Filesystem tools (read/write/search)	✅
Shell execution	✅
Git operations	✅
Planning before acting	✅
Web search	✅
Edit review / approval gates	✅

Examples:

reasonix code — runs in terminal, full tool suite
Claude Code — Anthropic's agent harness
GitHub Copilot agent mode
Codex CLI

The "agentic" threshold: The model decides what to do and how to do it, loops until done.

Capability Ladder: Level 4 — IDE with Built-in Tools

Capability	Has it?
Everything from Level 3	✅
Live diff preview	✅
Inline suggestions	✅
File/repo context awareness	✅
Built-in slash commands	✅
Multi-file refactoring	✅

Examples:

Cursor — Composer, /plan, /ask, /agent modes, built on VS Code
Zed — Agent panel, inline assistant, native ACP support
VS Code Copilot — Agent mode, MCP support

Cursor's modes:

/agent — Full tool access, can edit, run, search
/plan — Proposes changes for review before touching files
/ask — Read-only, answers questions about codebase

Capability Ladder: Level 5 — IDE + MCP (Final Form)

Capability	Has it?
Everything from Level 4	✅
MCP Tools — Model invokes external services	✅
MCP Prompts — Reusable prompt templates	✅
MCP Resources — Structured data at URIs	✅
MCP Resource Templates — Parameterized URIs	✅
Custom servers for domain-specific capabilities	✅

┌─────────────────────────────────────────────────────┐
│              IDE (Cursor / Zed / VS Code)            │
│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐  │
│  │ Built-in │  │ ACP      │  │ MCP              │  │
│  │ Tools    │  │ Agents   │  │ ┌──────────────┐ │  │
│  │          │  │ (Claude, │  │ │ Asana MCP    │ │  │
│  │ /plan    │  │  Codex,  │  │ │ notes-mcp    │ │  │
│  │ /agent   │  │  OpenCode)│  │ │ mcp-prompts  │ │  │
│  └──────────┘  └──────────┘  │ │ Qwestly MCP  │ │  │
│                               │ └──────────────┘ │  │
│                               └──────────────────┘  │
└─────────────────────────────────────────────────────┘

MCP Deep Dive: The "USB-C for AI"

MCP = Model Context Protocol. Open standard by Anthropic. Standardizes how applications provide context and capabilities to LLMs.

Four Primitives

Primitive	What it does	Who triggers
Tools	Actionable functions (search, read, write, API calls)	Model decides
Prompts	Reusable prompt templates (code review, commit msg)	User picks from menu
Resources	Read-only structured data at URIs (`config:///app`)	Model or client reads
Resource Templates	Parameterized resources (`notes:///{path}`)	Client fills params

MCP Deep Dive: Tools

Tools are actionable functions — the most powerful primitive.

Discovery:  tools/list
Invocation: tools/call  (client sends args, server returns result)
Who calls:  The LLM decides, based on conversation context

Example — notes-mcp searchNotes tool:

{
  "name": "searchNotes",
  "description": "Search through personal markdown notes",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "limit": { "type": "number", "default": 10 }
    },
    "required": ["query"]
  }
}

Our MCP servers: notes-mcp (search/read/create/update notes), mcp-prompts (14 prompt templates), Asana MCP

MCP Deep Dive: Prompts & Resources

Prompts — Reusable templates

// prompts/git-commit.md → Discovered as MCP Prompt
// User picks it from a menu in Cursor/Claude Desktop
server.prompt("git-commit", "Generate a commit message",
  { type: "object", properties: { style: { type: "string" } } },
  ({ style }) => ({
    messages: [{ role: "user",
      content: { type: "text",
        text: `Write a ${style ?? "conventional"} commit message...` } }]
  })
);

Resources — Structured data at URIs

server.resource("config-file", "config:///app", { mimeType: "application/json" },
  async () => ({
    contents: [{ uri: "config:///app", text: '{"port": 3000}' }]
  })
);

Resource Templates — Parameterized

// notes:///{path} → Read any note by path
server.resourceTemplate("note-content", "notes:///{path}", ...);

MCP Transports & Config

Transport	How it works	When to use
stdio	Server is child process, stdin/stdout	Local servers (Claude Desktop, Cursor, VS Code)
SSE	Server is HTTP endpoint, SSE streaming	Remote servers, multi-client, web apps

Local config (Cursor/Claude):

{
  "mcpServers": {
    "notes": {
      "command": "node",
      "args": ["/path/to/notes-mcp/src/index.js"]
    }
  }
}

Portable config via npx + GitHub:

{
  "mcpServers": {
    "local-prompts": {
      "command": "npx",
      "args": ["-y", "dominickp/mcp-prompts"]
    }
  }
}

Talk 2: BYOA / BYOM

Bring Your Own Agent / Bring Your Own Model

The Problem: Editor Lock-in

Most AI editors lock you into their model + their agent:

┌──────────────┐     ┌──────────────────┐
│   CURSOR     │────▶│ Cursor Composer  │ (their model)
│              │     │ (their agent)    │
└──────────────┘     └──────────────────┘

┌──────────────┐     ┌──────────────────┐
│  VS CODE     │────▶│  GitHub Copilot  │ (their model)
│              │     │  (their agent)   │
└──────────────┘     └──────────────────┘

What if you want:

Claude Code's agent inside Cursor?
Cursor's agent inside Zed?
Codex inside vim?
DeepSeek instead of GPT behind any agent?

The Solution: ACP (Agentic Control Protocol)

ACP is an open protocol (from Zed/Anthropic/Cursor) that standardizes how editors talk to agents.

Think of it as LSP, but for AI agents instead of language servers.

┌──────────┐                  ┌──────────────────┐
│  EDITOR  │── ACP Protocol ──│  AGENT PROVIDER   │
│          │                  │                   │
│  Cursor  │                  │  Claude Agent     │
│  Zed     │                  │  Codex            │
│  VS Code │                  │  OpenCode         │
│  vim     │                  │  Cursor Agent     │
└──────────┘                  └──────────────────┘

Any editor can connect to any ACP-compatible agent.

BYOA: Bringing Other Agents into Cursor

Option 1: Claude Code via ACP

// ~/.cursor/mcp.json or avante.nvim config
{
  "acp_providers": {
    "claude-code": {
      "command": "npx",
      "args": ["@agentclientprotocol/claude-agent-acp"]
    }
  }
}

Works in: Cursor, Zed, VS Code, avante.nvim

Option 2: Codex via ACP

{
  "acp_providers": {
    "codex": {
      "command": "npx",
      "args": ["@anthropic-ai/codex-acp"]
    }
  }
}

Option 3: OpenCode via ACP

OpenCode is an open-source agent that supports ACP. Drop it into any ACP-compatible editor.

BYOM: Swapping the Model Behind Any Agent

Many agents let you swap the underlying model — crucial for cost optimization.

Claude Code → DeepSeek

// ~/.claude/settings.json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "sk-...",
    "ANTHROPIC_MODEL": "deepseek-v4-pro[1m]",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "deepseek-v4-pro[1m]",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "deepseek-v4-pro[1m]",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek-v4-flash[1m]",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  }
}

Important: DeepSeek's Anthropic endpoint expects [1m] suffix for 1M context window.

BYOM: What You Keep vs. What You Lose

When swapping Claude → DeepSeek behind Claude Code:

Feature	Works?	Notes
Tools (files, bash, search, git)	✅ Yes	Harness-provided
Skills	✅ Yes	Harness-provided
Agents (sub-agent spawning)	✅ Yes	Harness-provided
Prompt caching	❌ No	DeepSeek uses byte-stable prefix-cache
Extended thinking	❌ No	Anthropic-specific; DeepSeek has `reasoning_effort`
Telemetry/analytics	N/A	Disabled via env flag

Key insight: All tool execution is harness-provided, not model-provided. The model just decides what to do — the harness handles how.

Our Actual Setup: Avante → Claude Code (ACP) → DeepSeek

Avante.nvim → Claude Code ACP wrapper → DeepSeek API
                                         (Anthropic-compatible)

Layer	What it does	Config
avante.nvim	Neovim AI plugin	`~/.config/nvim/lua/plugins/avante.lua`
Claude Code ACP	ACP adapter	`npx @agentclientprotocol/claude-agent-acp`
settings.json	Routes to DeepSeek	`~/.claude/settings.json`

Shell aliases:

alias vim-cursor="AVANTE_PROVIDER=cursor nvim"
alias vim-claude="AVANTE_PROVIDER=claude nvim"     # → DeepSeek
alias vim-codex="AVANTE_PROVIDER=codex nvim"
alias vim-ollama="AVANTE_PROVIDER=ollama nvim"     # → local

BYOA: Our Avante Provider Profiles

-- ~/.config/nvim/lua/plugins/avante.lua

cursor = {
    provider = "cursor", mode = "agentic",
    acp_providers = {
        cursor = {
            command = "~/.local/bin/agent", args = { "acp" },
            auth_method = "cursor_login",
        }
    }
},
claude = {
    provider = "claude-code", mode = "agentic",
    acp_providers = {
        ["claude-code"] = {
            command = "npx", args = { "@agentclientprotocol/claude-agent-acp" },
        }
    }
},
deepseek = {
    provider = "deepseek",
    vendor = { models = { "deepseek-v4-flash", "deepseek-v4-pro" } },
}

Plus: mcphub.nvim integration for MCP tools INSIDE avante — model sees active MCP servers' prompts.

Talk 3: Bring Your Own Editor

Zed Code Editor & Vim

Cursor vs. Zed: The Architecture Difference

Cursor

┌──────────────────────────────────────────────┐
│                 CURSOR (VS Code fork)         │
│  ┌────────────────┐  ┌────────────────────┐  │
│  │ Chromium UI    │  │ Node.js Backend    │  │
│  │ (Electron)     │  │ (Extensions, LSP)  │  │
│  └────────────────┘  └────────────────────┘  │
│         ▲                      ▲              │
│         └──────────────────────┘              │
│              IPC over pipes                   │
└──────────────────────────────────────────────┘

Zed

┌──────────────────────────────────────────────┐
│                   ZED (Rust)                  │
│  ┌────────────────────────────────────────┐  │
│  │        GPUI (GPU-accelerated UI)       │  │
│  │    + LSP + ACP + MCP + Git + Terminal  │  │
│  │         All in one native binary        │  │
│  └────────────────────────────────────────┘  │
└──────────────────────────────────────────────┘

Why Zed Wins

Dimension	Cursor	Zed
Base	VS Code fork (Electron)	Rust from scratch
UI	Chromium (hundreds of MB)	GPUI (GPU-native)
Startup	Seconds	Instant
Typing latency	~20-40ms	<1ms
Memory	500MB-1GB+	~50-150MB
AI integration	Built-in Composer	Native ACP + Agent panel
Open source	❌ Proprietary	✅ Apache 2.0
ACP creator	Consumer	Co-creator
MCP support	Yes	Yes (native)
Parallel agents	❌	✅ (run multiple agents at once)
Linux	Yes	✅ Native

Zed: AI Features

Agentic Editing

Delegate work to AI agents
Watch progress LIVE in editor
Review changes in diff view before accepting

Inline Assistant

Select code → transform in-place
Supports ANY model via ACP

Parallel Agents

Run multiple agent threads across projects
Never leave flow — agents work while you code

ACP & MCP First-Class

Built by the same team that created ACP
Native MCP server connections
Any agent, any tool, any model

Edit Prediction (Zeta2)

Open-weight, open-data model
Predicts what you'll type next
Runs locally

Zed: More Than Just AI

Native Git

Stage, commit, push, pull
Diff viewer
Branch management

Remote Development

UI runs locally
Codebase lives on remote server

Vim Mode

First-class modal editing
Text objects, marks, macros

Multibuffer Editing

Compose excerpts from across codebase
Edit them in one surface

Extensions

800+ extensions
Language support, themes, tools

Our Vim/Avante Setup

Why Vim + Avante?

Neovim + avante.nvim + mcphub.nvim + ACP agent

Key mappings:

Mapping	Action
`<leader>aa`	Open AI chat sidebar
`<leader>an`	New chat
`<leader>ae`	Edit selection
`<leader>ama`	Switch to Agent mode (Cursor ACP)
`<leader>amp`	Switch to Plan mode
`<leader>amq`	Switch to Ask mode

Features:

@ file mentions via Telescope
Neo-tree integration (oa to add files to context)
MCP tools via mcphub.nvim
Slash commands passthrough (/agent, /plan, /ask)
Session recovery with history

Vim + Avante: Provider Switching

# Shell aliases in ~/.extras.bash
alias vim-cursor="AVANTE_PROVIDER=cursor nvim"
alias vim-claude="AVANTE_PROVIDER=claude nvim"
alias vim-codex="AVANTE_PROVIDER=codex nvim"
alias vim-ollama="AVANTE_PROVIDER=ollama nvim"

Alias	Backend	Model
`vim-cursor`	Cursor via ACP	Cursor's models
`vim-claude`	Claude Code ACP → DeepSeek	DeepSeek V4 Pro
`vim-codex`	OpenAI Codex	GPT-5.2 Codex
`vim-ollama`	Local Ollama	qwen3-coder:30b

Each alias deletes ~/.config/avante.nvim/config.json before launch so persisted last-provider doesn't override.

Talk 4: DeepSeek V4 & Reasonix

Open-Weight Frontier Models on a Budget

DeepSeek V4 Model Family

DeepSeek V4 Flash — Budget Workhorse

Field	Value
Model ID	`deepseek-chat` / `deepseek-v4-flash`
Input	$0.14 / M tokens
Output	$0.28 / M tokens
Context	1M tokens
Role	Everyday coding, chat, iteration
Cached input	$0.014 / M tokens

DeepSeek V4 Pro — Open-Weight Frontier

Field	Value
Model ID	`deepseek-reasoner` / `deepseek-v4-pro`
Input	$0.435 / M tokens
Output	$0.87 / M tokens
Context	1M tokens
Role	Complex architecture, debugging, multi-step planning
Promo	75% off until May 31, 2026

DeepSeek vs. The Competition

Model	Input ($/M)	Output ($/M)	Context
Claude Opus 4.7	$5.00	$25.00	1M
GPT-5.5	$5.00	$30.00	1M+
Claude Sonnet 4.6	$3.00	$15.00	1M
Cursor Composer 2	$0.50	$2.50	200K
DeepSeek V4 Pro	$0.435	$0.87	1M
DeepSeek V4 Flash	$0.14	$0.28	1M

DeepSeek V4 Pro is ~11x cheaper than Opus, ~7x cheaper than Sonnet.

At 75% promo pricing: ~$0.11/M input — 45x cheaper than Opus.

Reasonix — The DeepSeek-Native Coding Agent

reasonix — MIT-licensed, DeepSeek-only, terminal-first coding agent.

Two Modes

Mode	Command	Tools	Use Case
code	`npx reasonix code`	Filesystem, git, MCP, full suite	Development
chat	`npx reasonix chat`	None (web search only)	Conversation

Same model. code unlocks tools for development; chat is pure conversation.

Quick Start

cd my-project
npx reasonix code   # Paste DeepSeek API key; persists

Requires Node ≥ 22. macOS, Linux, Windows.

Reasonix: The Cost Advantage

The Secret: DeepSeek's Prefix-Cache

DeepSeek's prefix-cache is byte-stable — fingerprints from byte 0 of the prompt. Reasonix's loop grows append-only (no reordering, no compaction), so the cache prefix survives every tool call.

	Reasonix	Claude Code	Cursor	Aider
Backend	DeepSeek V4	Anthropic	OpenAI/Anthropic	any
Cost / task	~¥0.01–0.04	~¥0.40–4	¥150/mo + usage	varies
Cache hit rate	94% (live)	n/a	n/a	~33%

At $0.07/Mtok uncached vs. $0.014/Mtok cached, going from 50% to 94% hit rate = 2.5× savings on input alone.

Reasonix: DeepSeek-Specific Fixes

Problem	Reasonix Fix
R1 leaks tool-call JSON inside `<think>` tags	Scavenge pass pulls escaped tool calls back out
DeepSeek silently drops deeply-nested object/array params	Auto-flatten → single-level prefixed names
Malformed args like `string="false"`	`ToolCallRepair` heals common shapes before dispatch
V4's `reasoning_effort` knob	`/effort` slash command + `--effort` flag for cheap turns

Key Features

Plan mode — Propose changes before touching disk
Edit review — SEARCH/REPLACE blocks gated by user approval
MCP first-class — Built-in MCP client (stdio + SSE)
Embedded web dashboard — Session history, stats, visualization
Persistent per-workspace sessions — Resume where you left off
Memory & skills — Project-level and user-level memory

Reasonix: Our Workflow

Local Patched Setup

We run a locally-patched reasonix that listens on 0.0.0.0 instead of 127.0.0.1.

Daily use:

ssh into dev terminal
npx reasonix code     # TUI works over SSH

Web UI (tablet / remote):

npx reasonix code     # Prints port (e.g. 4321)
proxy expost 4321     # Expose via our proxy
# Open http://{alias}.dph.am from anywhere

Limitations

DeepSeek-only by design — Every layer tuned around the cache mechanic
Terminal-first — No IDE integration (dashboard is companion, not replacement)
Paid API required — Needs DeepSeek API key
Hardest benchmarks — Claude Opus still wins some; DeepSeek V4 is competitive on coding

Reasonix MCP Prompt Integration

Your prompts live at ~/Work/llm/mcp-prompts/prompts/:

code-review, security-review, accessibility-audit, write-unit-tests, optimize-performance, add-documentation, add-error-handling, generate-pr-description, create-pr, git-commit, diagrams, visualize, deslop, generate-api-docs

Three ways to run them in reasonix:

A — Inline: "Run the code-review prompt from my prompts dir" B — Register as Skills: Copy into .reasonix/skills/ so /skill code-review works natively C — Display + execute: Type /prompt code-review to see instructions, then "do that"

Talk 5: Qwestly Workspace

Our Monorepo, Agents, and MCPs in Practice

Qwestly Workspace: The Big Picture

~/Work/qwestly-workspace/
├── api-python/          # FastAPI backend (Supabase, port 8002)
├── candidate/           # Candidate portal (Next.js 16, MongoDB, Auth0)
├── qwestly-hire/        # Hiring platform (Next.js 15, MongoDB, Auth0)
├── public-site/         # Marketing site (Next.js 16, Tailwind)
├── qwestly-docs/        # Docs server (Node.js, markdown-it)
├── qwestly-internal/    # Internal employee tools (Next.js 16)
├── qwestly-agent/       # Agent system for orchestration
├── _internal/qwestly-ui/ # Shared UI lib (@qwestly/ui, Radix UI)
├── _deprecated/         # Archived projects
└── scripts/             # Automation & tooling

7 Next.js apps, 1 FastAPI backend, 1 shared UI lib. All run on Vercel + MongoDB Atlas + Supabase.

Qwestly Agent System

Location: qwestly-agent/docs/

Architecture includes:

Orchestration Plan — How agents coordinate across repos
RAG & Tools Patterns — Retrieval-augmented generation for candidate matching
Human-in-the-Loop — Approval gates before agent actions
Testing Agentic Systems — How we validate agent behavior
Deployment Options — Vercel, containers, edge
Framework Comparison — LangChain, Vercel AI SDK, custom

AGENTS.md

Every repo has an AGENTS.md that tells agents how to operate:

Never run git commit directly
cd to correct repo before acting
Which ports, stacks, and commands per repo

Qwestly MCP Integration

MCPs We Run

MCP	What it does	Primitive
notes-mcp	Search/read/create/update notes	Tools
mcp-prompts	14 reusable prompt templates	Prompts + Resources
Asana MCP	Task management, project tracking	Tools
Qwestly MCP (~/Work/llm/qwestly-mcp-dev)	Candidate matching, internal APIs	Tools + Resources

MCP Prompt Templates

Qwestly: How We Actually Work

Daily Stack

┌─────────────────────────────────────────────────┐
│                  OUR DAILY SETUP                 │
│                                                  │
│  Editor:    Neovim + avante.nvim (+ mcphub)     │
│  Agent:     Claude Code ACP → DeepSeek V4 Pro   │
│  Terminal:  reasonix code (DeepSeek-native)     │
│  ALT:       Zed (when we want GUI + parallel)   │
│  MCPs:      notes-mcp, mcp-prompts, Asana       │
│  CI:        GitHub Actions + Claude Code review │
│                                                  │
│  Total AI cost: ~$20-50/month (not $200-500)   │
└─────────────────────────────────────────────────┘

Why This Stack Wins

Cost — DeepSeek V4 Pro is 11x cheaper than Opus, 94% cache hits
Flexibility — Swap agents/models without changing editor
Open source — No vendor lock-in (ACP is open, DeepSeek is open-weight)
Speed — Vim/terminal is instant, Zed is GPU-native
MCP — Our notes, prompts, and tools are available to any agent

Key Takeaways

1. The Agentic Spectrum

LLM → Agent → IDE → IDE+MCP. Each level adds tool access and autonomy.

2. ACP Sets You Free

Bring any agent to any editor. No more waiting for your favorite agent to be "integrated."

3. DeepSeek Changes the Economics

Open-weight frontier model at $0.435/M input. With reasonix's 94% cache hit: ¥0.01-0.04 per task.

4. Zed Is the Future

Rust-native, GPU-accelerated, ACP co-creator, open source. Not just "another VS Code."

5. MCP Makes Agents Useful

Tools, prompts, resources — the "USB-C for AI" standard that connects agents to real work.

Thank You