First impressions: Delta

The folks at Zed make a hell of an editor, and they've recently decided to beta test a new product called Delta. I was fortunate enough to get beta access (thank you, Zed folks!) and wanted to write up some first impressions.

My understanding prior to testing it: Delta seems to be a tool that interweaves agents with the history of code.

The picture on their main page shows a layout not unlike Cursor/Letta/Claude/Devin (as there is only one interface these days).

Getting started

Onboarding was very quick, you are quickly dropped into this minimalistic view:

The agent's message is editable, and typing adds these little comment views:

Hitting Cmd + Enter adds a small expandable accordion summarizing the changes:

Typing ! opens an inline terminal, which is slick.

Connecting a project

I wanted to dive in and work on actual code, rather than just play with the tutorial, so I connected Delta to one of my hobby projects.

I've been working on something called machine, which is a Pi extension for building model factories. It's also mostly an excuse to learn how to do post-training with Tinker.

I asked my Delta agent (powered with Grok 4.6) to give me an overview of the project:

Machine is quite simple -- it automatically stores traces (chat histories with an agent) to disk, and then provides simple slash commands to either issue a correction or mark a trace as "good" and to be used in fine-tuning. Traces are normalized to Letta's standardized trajectory format.

Grok chose to send the prompt "Is julia on PATH?", referring to the Julia programming language I love. The full trace looks like this. It shows the user message, the assistant's message, the tool call + return messages, and the agent's final response.

{
  "messages": [
    {
      "role": "user",
      "content": "Is julia on PATH?"
    },
    {
      "role": "assistant",
      "content": "Checking."
    },
    {
      "role": "assistant",
      "content": "",
      "tool_calls": [
        {
          "id": "call_julia",
          "type": "function",
          "function": {
            "name": "bash",
            "arguments": "{\"command\":\"which julia\"}"
          }
        }
      ]
    },
    {
      "role": "tool",
      "content": "/usr/bin/julia",
      "tool_call_id": "call_julia"
    },
    {
      "role": "assistant",
      "content": "Yes. julia is at /usr/bin/julia."
    }
  ],
  "tag": "good",
  "kind": "trace",
  "note": "julia is on PATH",
  "source": "tool-session.jsonl",
  "entryIds": {
    "user": "user0002",
    "assistant": "asst0003"
  }
}

Doing some work

When I'm testing something out, I like to ask agents for a suggestion about the project. I switched to Opus and asked it what it would suggest for the project.

Opus gave me a bunch of Opus-speak, so I asked it to dumb things down:

Opus came back with something mildly more legible. I noticed that Delta also allows it to respond to comments I left directly ("In plain terms..."), which is a really nice UI feature.

This suggestion is about improving CI, since everything is currently mostly only designed to work on my laptop. Ideally, tests for machine work everywhere. I left a comment asking if this agent can dispatch subagents to handle this project so we can continue working. I don't actually know yet if Delta supports this, but many agent frameworks do, so worth asking.

Delta also displays Mermaid diagrams, which was quite beautiful. Machine works by creating "reasoning contributors" when you issue a correction, but a previous agent had vibe-slopped in a very silly gate designed to prevent phrases that indicate there was a previous attempt.

I agree with this issue and asked the agent to correct it:

It did more Anthropic-garbage text by referencing objects I don't have context on, so I asked to clarify:

While working on the giveaway phrases problem, I was able to highlight some code I had a question about and ask if there's a more robust solution:

Ended up taking a suggestion and merging into main. Decent experience!

Threads

Delta uses threads as its organizing principle. Threads are a blend between agent conversation history and a DeltaDB worktree. From my agent:

A thread is one persistent conversation/workspace for an agent task. It remembers the conversation, chosen model, open files, layout, worktree edits, review comments, and the history behind the work—so it’s best to use one thread per coherent task or feature rather than one giant catch-all chat.

For code work, open a project and choose New Thread: Delta attaches a private DeltaDB worktree so the agent can edit and test without changing your normal checkout. New Empty Thread is for research, writing, questions, or shell tasks that do not need a repository—this current conversation is one of those.

Threads live in the left sidebar and can be organized by project or time, pinned, renamed with F2, archived, or permanently deleted. They are private by default; Share Thread creates a link so teammates can join live, leave comments, and continue work from the same context.

It's a clever approach that unifies the agent context that generated code with the change to the code itself. I'm not super convinced yet that it's necessary/useful, I suspect that only shows up with other team members on Delta and a lot of work in longer term projects.

Providers

Configuring providers is easy. I seem to have gotten VIP access, which grants me some amount of model use. You can also bring your own provider, including OpenCode, Grok, GitHub Copilot, ChatGPT/Codex, and API keys for OpenRouter and others.

I added my Grok + ChatGPT subscriptions, both worked with no issues.

Notes

• The build quality and speed are quite remarkable -- if you've ever used Zed, you may be familiar with how snappy and responsive it is, and Delta has very much the same level of quality that I have come to expect from the folks at Zed.

• The agent said that it had no subagent tool, which stuck me as odd. Delta is advertised as being multi-agent, but the agent has no way of spawning subagents? I'm curious to see how they'll address this from a product perspective.

• I would love to see ACP support. Letta supports ACP, and I want to have my agent available in a thread.

• My favorite feature was by far how easy and clean commenting felt. I would like to figure out a way to improve Letta's commenting and inline work. We currently support comments, but they do not feel as native/first class as in Delta.

Conclusion

Generally a good first impression. It's a pretty well-built development environment with Zed's best-in-class performance and snappy feel.

I still feel like I need to be convinced that DeltaDB is useful, or what it is actually getting me over worktrees.

Thank you for the Zed team for onboarding me! I'm looking forward to playing with it more.

-- Cameron