The stack is splitting into layers

Last week gave us three releases that only make sense when you read them together. Anthropic opened the Claude Marketplace for plugins, agents, and service partners. DeepSeek's Harness desktop client leaked through official download links a day before any announcement. And TypeSafe, founded by a former OpenAI researcher who worked on InstructGPT, shipped Jev, an API designed to be called by code, not by humans.

Each release attacks a different layer of the same problem. The coding agent used to be a single thing: a chat window over your repo. Now it's a stack. Models, harnesses, skills, memory, and distribution are separating into distinct markets with distinct winners. If you build tooling for developers, this is where the next two years of work will land.

Claude Marketplace: distribution becomes its own market

The Claude Marketplace is live today at claude.com. It collects three categories in one place: plugins and connectors, products and agents, and service partners. CodeRabbit, for instance, put part of its Anthropic commitment toward Vercel, where its coding agents run; Power Digital and ThoughtSpot did the same with Snowflake.

The plugin format is now a public spec. Anthropic maintains claude-plugins-official, a curated directory split into internal plugins and third-party submissions. Installing is one command: /plugin install {plugin-name}@claude-plugins-official. Third-party plugins need approval, and the README carries a warning worth taking literally: Anthropic does not control what MCP servers, files, or other software ship inside a plugin, and they can change after you install them.

Two details in the spec tell you this is a real platform, not a weekend experiment. The name field is an immutable slug. Once users install a plugin under it, renaming breaks their setup with a plugin-not-found error. If a rename is unavoidable, the renames map in marketplace.json migrates existing installs automatically. And the loader handles skills-only repos: a source can declare skills directly with strict: false and an explicit skills array, letting a git subdirectory expose only a curated subset of its SKILL.md folders. That last bit matters for maintainers. You can keep hundreds of skills in a library repo and publish only the ones you want as a plugin.

DeepSeek Harness gets a desktop client

DeepSeek stuck to its holiday-release habit. During the festival break, developers spotted apps/desktop in the deepseek-harness repo, then download links for version 0.1.7-rc.1 started circulating. The Mac build is Apple-notarized under Hangzhou DeepSeek Artificial Intelligence Co., Ltd, bundle ID com.deepseek.dsh. The client is Electron, and it reuses the existing web UI plus the agent, session, tool, and plugin runtime instead of reimplementing anything. The installed client immediately offered an update to 0.1.7-rc.2.

I installed the Mac build. The free web playground and this desktop client are different products. First run demands a funded account with real-name verification, or your own API key. No anonymous trial.

Modes split into two categories: office and creation, and code and development. Display preference has three levels (focus results, key details, full process), and agent mode has four workstreams: standard, PTC, minimal, and creative.

PTC is the one to understand. It stands for programmatic tool calling. Instead of the model round-tripping over the network one tool call at a time, it writes a full program that schedules, batches, filters, and summarizes many tool calls, then runs it. That cuts latency and makes complex pipelines more stable. Minimal mode uses only the terminal, which makes it useful for benchmarks. Creative mode lets you debug Cordis plugins in memory through natural language and build custom agent modes. The plugin panel also exposes agent teams and subagents, localization, and execution controls, all reflecting the "everything is a plugin" architecture.

The answer area is task-oriented rather than chat-oriented. After a query, the UI shows states like processed and executed, with context token counts, tool call counts, and elapsed time, so you can see whether the agent actually touched any tools. Long answers render as structured pages with tables, price cards, and even an embedded draggable cost estimator, not a wall of Markdown.

Harness	Extension model	Ways to run	Access
Claude Code	Plugins, skills, MCP via Claude Marketplace	CLI, VS Code, JetBrains	Claude subscription or API
Codex	Skills, MCP	CLI and Codex app	ChatGPT plan or OpenAI API
DeepSeek Harness	Cordis plugins, everything is a plugin	Electron client (Mac, Windows)	Credits with real-name, or API key
Jev	None; outputs consumed by code	API only	Usage-based API

Quick Take: The agent race has split into four layers (models, harnesses, skills, memory), and distribution has become a competitive moat that's separate from model quality.

The skills gold rush

claude-skills, a community repo, now ships 388 production-ready skills across 20 domains. It includes 706 CLI scripts that are all stdlib-only with zero pip installs, plus 823 templates and checklists. The repo has 5,200+ GitHub stars and converts to 13 coding tools (Claude Code, Codex, Gemini CLI, Cursor, Aider, Windsurf, OpenCode, Kilo Code, and others) via a convert script that takes about 15 seconds.

The design splits into three layers: skills (how to execute a task), agents (what task to do), and personas (who is thinking, with a personality-driven voice). A persona like startup-cto picks a skill loadout and a communication style, which matters when the same model does architecture reviews and marketing drafts.

The wildest skill in the repo is not a coding skill at all. video-use edits video inside Claude Code. Drop raw footage in a folder, ask for an edit, get final.mp4. It cuts filler words, color grades every segment, burns subtitles, and self-evaluates every cut boundary before showing you the result. The trick: the LLM never watches the video. One ElevenLabs Scribe call produces word-level timestamps and speaker diarization, packed into a 12KB takes_packed.md. Timeline views render only at decision points. The naive alternative, dumping 30,000 frames, would cost about 45M tokens of context. That is the difference between a tool that runs on a laptop and one that burns through your API budget.

Key numbers:

• 388 production-ready skills and 823 templates in claude-skills
• 706 stdlib-only Python tools, zero pip installs
• 54 ToS-friendly providers and 1.3B+ free tokens per month in free-claude-code
• 12KB packed transcript versus 45M tokens of raw frames for video-use
• 99.9% uptime SLA on Hindsight Cloud

Agent memory: the layer everyone forgot

Session memory is the pain point I keep hearing about. Agents are competent inside one session, then amnesiac the next. Hindsight is an open-source agent memory system that treats this as a storage problem, not a prompt problem. It reports top results on the LongMemEval benchmark, independently reproduced by Virginia Tech's Sanghani Center and The Washington Post, while competitor scores are self-reported.

The API is three verbs: retain, recall, and reflect. retain extracts facts, temporal data, entities, and relationships, then normalizes them into canonical entities and time series. recall runs four retrieval strategies in parallel:

Strategy	What it catches	Weakness on its own
Semantic vector search	Paraphrase, similar meaning	Misses exact identifiers and names
BM25 keyword	Exact terms, code identifiers	Misses synonyms and concepts
Graph retrieval	Entity, causal, temporal links	Thin coverage on new topics
Time range filter	"What happened in June?"	Useless outside ranges

The results merge with reciprocal rank fusion, then a cross-encoder reranks them, and the output trims to fit the token budget. reflect goes further: it consolidates related facts into observations with supporting quotes and a proof count, builds mental models as standing answers to questions, and stores them so reading one is a database read with no LLM call. An agent boots with settled knowledge instead of rediscovering it every session.

Hindsight ships as a Docker container with a built-in MCP endpoint per bank, so any MCP client gets retain, recall, and reflect as tools. There's also an LLM wrapper that turns any OpenAI or Anthropic client into a memory-backed one with no code changes. Models as small as GPT-5-mini handle the extraction layer, and a coding-agents package wires per-repo memory into Claude Code, Codex, Cursor, and DeepSeek Harness automatically from git history.

The philosophical split: chat models versus machine-native models

The most argued release this month wasn't a harness or a plugin. It was Jev from TypeSafe, and it comes with a thesis that calls current agents a dead end.

Diogo Almeida, who worked on InstructGPT at OpenAI, put it bluntly on Latent Space: the AI world before Jev is a tragedy. His claim is that Claude Code and Codex are the same stage of evolution. The AI is still an assistant orbiting a human. The next stage, in his view, is a machine-native model whose output is consumed directly by code: choices, scores, and probabilities that developers can threshold, not prose to read.

The technical critique targets RLHF. Almeida argues RLHF causes mode dropping: models collapse toward safe, common answers and away from a calibrated probability distribution. That hides error accumulation in long text and makes text models bad at decisions. TypeSafe trains with RLCD, reinforcement learning for calibrated decisions, aiming for robustness: a UUID inserted into a prompt shouldn't flip a judgment, and a deployed model should not silently change behavior, because your API is a dependency inside someone's program.

Jev also famously refuses nothing at the model layer. If a model is a software dependency, a sudden "I can't help with that" is a type error at 2am. Safety moves to the application boundary, like a database, which does not judge your queries.

Developers feel this one viscerally. In the TypeSafe Discord, the same question came up all week, and it was always about the missing guardrails. I had that reaction reading the docs myself. After months of fighting safety filters in other APIs, I went looking for the moderation layer. There isn't one in the model. When I wired Jev into a pipeline as a function that must return a schema-valid result, the difference showed up quickly: every output matched the shape I asked for, no surprise refusals killing a batch job. A developer I talked to made the counter-case: with no refusal layer, your application logic becomes the only safety net, which is a real cost for regulated teams. The Gemma 4 Developer Agent Competition opened on Kaggle the same week, and the discussion around it reads like people warming up for exactly these benchmark battles.

The cost layer: routing around the billing department

Free tiers are a battleground on their own. free-claude-code is an open-source router you run as fcc-server that drives Claude Code, Codex, Pi, OpenCode, Cline, Hermes, DeepSeek Harness, Grok Build, Muse Code, and Aider against 54 ToS-friendly providers, with over 1.3B free tokens distributed every month. You connect ChatGPT, GitHub Copilot, NVIDIA NIM, Groq, OpenRouter, or any OpenAI-compatible local endpoint, and route each Claude tier (Fable, Opus, Sonnet, Haiku) to a different provider.

The standout feature is fallback. When a provider goes down, FCC exhausts retries and moves to the next configured model without restarting your turn. I've had provider outages kill multi-hour coding sessions; a fallback chain is the difference between losing the context and barely noticing the outage. An optional RTK filter cuts terminal output tokens by up to 90%, and five optimizations handle quota probes, command-prefix detection, titles, suggestions, and filepaths without calling a provider at all.

What trips people up

1. Installing marketplace plugins without auditing them. The claude-plugins-official README warns that plugins can bundle arbitrary MCP servers, files, or other software that may change after install. A plugin with an .mcp.json pointing at a remote server can send your repository context to that server. Check the manifest, check the MCP server URL, trust nothing you haven't read.

2. Installing all 388 skills at once. Every skill adds instructions and reference material to the agent's context. Install by domain, or you'll burn your context window on skills you never invoke. The repo's own install commands are organized by domain for exactly this reason.

3. Using chat models for decisions. RLHF mode dropping makes text models output what sounds plausible rather than what is calibrated. If your pipeline gates on a model's judgment, ask for scores and confidence, set thresholds, and test how a random UUID in the prompt changes the outcome. That last test catches unstable behavior fast.

4. Pointing agents at raw media. video-use and similar tools work because they read a 12KB transcript, not 30,000 frames of noise. Any agent task that ingests raw video or giant logs without a condensation layer is paying for tokens twice.

One thing to remember

Memory is the hidden tax on every coding agent right now. A harness without skills is a blank editor. A harness without memory starts from zero every session. Adopt a memory layer early, whether it's Hindsight's banks, a per-repo CLAUDE.md discipline, or a knowledge page system, because retrofitting memory onto an agent you've already deployed is much harder than starting with it.

The bottom line

If you're building an agent-based workflow today, install skills and plugins through curated marketplaces, and audit every manifest before you add it. The convenience is real; so is the supply-chain risk.

If you're operating on a budget, free-claude-code's fallback chains across free providers let you keep coding through outages, and per-tier routing means you pay for strong models only where they matter.

If you're choosing a model family for agent logic, watch the calibrated-decision direction Jev opened. Expect major harnesses to add threshold-based, schema-safe outputs within six months, and pick agents that expose tool-call metrics, token counts, and structured results, because that's what you'll need to measure what actually works.