Zed Agents — with Zed Cofounders Nathan Sobo & Antonio Scandurra

All right. We are here in the remote studio with Nathan, I think you're calling in from Boulder?

That's correct, yeah.

And Antonio from Italy. So it's a very-

That's right

... very global podcast. Uh, co-founders of Zed, welcome.

Thanks so much.

Thank you. Thank you.

So I think that Zed is relatively famous, uh, at least hacker news famous, and so I-I've heard of-- I heard it a bunch. Uh, people who follow the podcast have definitely heard of it because the MCP folks love you guys, and the first public demo of MCP was kind of slotted in.

I also know that you guys have done some interesting work with like, um, code editing and all, all that good stuff. But, uh, for those who are the uninitiated, what is it?

So Zed is our attempt at building the world's greatest code editor. And for me, what that meant after working on this problem for probably fifteen years was performance needed to be absolutely amazing. We created the Atom editor previously, and as part of Atom, the shell around Atom, Electron, was spun out into its own thing, and Electron is what VS Code is built on and a bunch of other apps.

And basically, the premise of Electron is you're gonna build your desktop application as if it's a web page and then kind of dress it up in its own, uh, application shell or whatever to look like a desktop app, but it's essentially a web app.

And we were really frustrated with kind of the ceiling that using web technology put on how excellent of a user experience we could deliver. Um, and that had to do with sort of raw text rendering quality and performance.

Zed runs at a hundred and twenty frames a second, reliably delivering frames, and so there's just like a fundamentally more fluid experience using it that we just couldn't achieve in web tech. So we basically, rather than building Zed like a web page, we built it more like a video game.

We went down and ran code on the graphics hardware directly and engineered from there for the system to be incredibly performant. It's our opportunity to advance the state-of-the-art on editing generally. So bunch of investment, not only in how fast things move, but also really sophisticated indexed primitives for text that allows to do things like nonlinear undo, tracking the causal history of change over time with CRDTs, real-time collaborative editing.

And we've essentially engineered an entire editor from an empty repo to up to about over a half a million lines of Rust, engineered the entire IDE from scratch with the theory that if we control it all, we'll be able to deliver the most exceptional experience.

Um, any, uh, uh, what's, like, what's the rough, like, history, like, um, uh, when, like, uh, when did, when did you start it, and what are the main eras? Like, I, obviously now you're in the sort of like the AI era, but have there been, like, phases in the company history or the, or the project history that are distinct enough that you can call it like, you know, for these years we focused on this, this thing and the other thing?

Uh, I could take this one. Yeah, like I think initially, like, I think we started with this premise of not only we wanna build a great code editor that, you know, is performant and, you know, it's written in Rust, but also that is collaborative.

I mean, one of the first things we implemented into the product, like one of the reasons why our buffer is, is powered by SCRDT is because, like, we wanted to make it collaborative from the ground up. Um, and so yeah, one of the first features we shipped was, uh, literally being able to collaborate and pair, uh, on Zed.

Any pairing session in Zed happens within Zed. Like, we don't use any external tool. Like, we hop on a channel, and we sort of work together on Nathan's project, right? Like I, I can join Nathan's project, and we can, like, collaborate on, on his machine.

So that was like, um, I don't... So I guess if I had to like sort of recollect, like recall the eras is like, yeah, like we first started on the editor, like y- getting like any text on screen at all.

So like, you know, being able to edit anything at all. Then being able to like, collaborate on, you know, on that text together, so, you know, seeing each other's cursors and whatnot and, uh, you know, after that, AI.

Now, it turns out that, like, the fact that we're collaborative helps a lot also with AI. The fact that we're performant also helps a lot with AI. You know, I'd love to talk a bit-

Yeah

... Nathan.

Well, like the fact that we even made the investments necessary to have enough control to deliver excellent performance and collaboration will also give us the control I think it takes to build sort of the first editor that's truly engineered from the ground up for the AI era, because our team understands every line of this code.

We've been here the whole time. We're not building on some other existing product that has existed for a long period of time. All of the clay is wet and ready to be sculpted for what's happening now.

Hmm.

Yeah, excellent. Um, awesome. Like, uh, there's so much I could go into that. Just a, just as a side note, because I, I just, you know, every time I run into someone from the Electron background, I have to ask, uh, have you looked at Tauri?

Is that like an interesting direction, or is it doomed?

I haven't looked at it that much. Like, got to a point where I was like, "I'm done with anything related to web tech whatsoever." I, at least for building this desktop editor, now we're gonna actually ship it to a browser tab, I'm hoping later this year.

We'll see. Um, but with my approach, it was like I wanted to go into the, the raw macOS at first APIs, give me a Metal graphics context, and let me render it so that if it's ever dropping a frame, there's nobody's fault that it is but mine.

I want enough control to make sure that we don't drop frames. Why? But I'm-- a-again, that's an extreme perspective. We even, you know, we've invested pretty heavily to make that possible, so I could see other points in the trade-off space making sense for different apps.

But for an editor, I don't-- I think this is what it takes to build the editor I wanna use. Put it that way.

Yeah. Uh, sometimes I, I do feel like I'm a worse programmer because I, I'm not Phased by the state of VS Code. Uh, but then, like, a, a lot of programmers I admire, like Richard, uh, who, who helped make this call happen and like the MCP folks, like they, they really care about their editor.

And like, yeah, I, I totally buy that good programmers should care about their editors. It's just that, like, for so- for some reason I, I... it just hasn't been a, been a pain point for me, so like I didn't switch, you know, 'cause it's nothing broken.

Yeah. And I think that's reasonable. I'm excited though about, you know, again, it, it's a lot of work. There's a ton of surface area on building an IDE that anybody would wanna use at all. We're just now, I mean, we're not even 1.0, but what I'm excited to have is like when we hit 1.0, now we have this great foundation on which to push the envelope and solve those deeper pain points.

I think we could have taken a shortcut and kind of built on top of the status quo, but for me personally, what I wanted to do was actually push the envelope, transcend the status quo. And to do that, we had to go back to the beginning, which takes longer, but we're, we're almost there.

Uh, yeah, you paid the... You know, it's almost like tech debt, but it's not even debt, it's just the, uh, table stakes. Um, so, uh, one way, one really nice way to track your era, uh, your era, your AI era, I guess, is just your blog.

You introduced Zed AI, uh, almost a year ago now, and then you started, uh, doing a whole bunch of stuff. I know, um, I think the first thing that kind of hit my radar as far as like general consciousness of like, well, here's a new thing that like other people are, are like really should be paying attention to is Xeta.

Um, we maybe we kind of briefly recap Xeta and then we'll, we'll go into Zed agents.

Totally, yeah. Xeta is like, uh, yeah, a model that we fine-tuned to produce what we call a, this feature like called Edit Prediction Zed. So it's the idea that like, you know, for the longest time there's been like Copilot style suggestions where like Copilot suggests edits at your cursor.

With Xeta, you have edit predictions that span like all around your cursor. So you can have non-local edits, you can have an insertion at your cursor, but you can also like jump to edit, as you can see here in the, in the demo.

So like it predicts edits like at locations that are far away from, from your cursor. Um, so yeah, that's kind of the, the how the feature is presented in Zed. And yeah, the way we implement it, which the blog post goes, uh, into details about, is by fine-tuning, uh, our own model.

So yeah, we started with the Qwen 2.5 coder B and went through the whole process, uh, collecting examples, fine-tune- doing supervised fine-tuning, doing direct preference optimization. Um, and so yeah, this is, um, kind of the, the, the feature that we shipped, I think at this point it's like, yeah, a few months ago.

Yeah.

Like the rest of Zed, fully open source. The data that it's trained on is actually open. We're collecting data from any... If you're editing an open source project in Zed, you can opt in to collect the data, and then that's all sitting in a data warehouse right now.

We're gonna work to process it and incorporate more of that feedback into the edit prediction as well to build an open ecosystem around this. But this was kind of, I think, our warm u-warm-up act. I mean, Zed AI originally was just like, can you strap your text editor to an LLM?

Um, and there are people that like that experience of, you know, we're literally giving you kind of like the open API SDK webpage, but like in a hardcore code editor where you can like... You know how in the SDK's, uh, playgrounds or whatever, you can like edit the message structure or whatever?

We basically took that raw playground experience and built that into the code editor in a very like key binding friendly, BIM binding friendly, really great editing experience. Then we built edit prediction.

Also in line transformation, right? Like this is what we're seeing here.

Right. Right, right, right, right. That's true. As part of this first phase, just the ability to like generate code in a particular location, pretty basic feature. Then edit prediction being kind of the next more like bringing AI on board as a first-class concept rather than building like great dev tools for AI, like Zed AI had been before.

And then now we're gonna be transitioning to actually getting full-blown agents working inside of Zed.

Yeah. I think that's, you know, the bulk of what we're here to discuss.

I think we're gonna launch this on May 7th when you, when you go live. If you push it back, we'll just pretend that that's the actual date. But everything, everything's open source, which is really nice. Uh, I, I was like, you know, we can actually talk about anything interesting.

But I guess at, at a high level, how do you approach this work? I think a lot of people like Windsurf, Cursor, they, they all have this sort of agent mode, and in there I think there's maybe a playbook that you can kind of study.

There's also a recent post from Thorsten Ball, I think, that, uh-

Oh, yeah

... fairly viral, claiming there's no modes. I think that, yeah, what's your take on all this? Like how do you start build- to building a code agent and what's your different take on it?

I mean, I don't know that there is no mode. Like I read that blog-

That's what he said

... there's a little more to it than just, you know, calling an LLM in a loop. But what I would say is ultimately, I think if you can integrate an LLM, prompt it the correct way, give it the appropriate tools, it's definitely come a long way in the last year.

Like when we were looking at the experience some of like Cursor was building, for example, in the first year, like, seemed like a lot of the problem being solved was about integrating the LLM into the application. So there's a, there was a lot of like integration work to bridge that gap.

But now the LLMs, because they've taken on this tool calling and are getting better at tool calling, the story has g- the integration story has definitely gotten a lot easier, I think.

Mm.

So in that sense, like the mode is ... shrinking rapidly. I mean, to me, the mo- Zed's moat is like implementing really nice product experiences with technical excellence and they're performant, like just delivering a really great user experience that in order to compete with, you would have to essentially build your own editor from scratch.

So that's the moat we're relying on. In terms of integrating LLMs into it, I think of an LLM as almost like another collaborator that we wanna facilitate in Zed. We let you edit with your teammates in Zed. We wanna let you collaborate with LLMs in Zed.

It's great that they're sort of plugging in to, like, they're developing the infrastructure to sort of plug into the existing app and use it just like another entity. I'm liking that a lot.

But yeah, it, it is true that like, you know, since like a while ago, I think when tool calling first appeared, it was just like you have tool calling and the model would just call one tool and, you know, that's, that's what all would do, right?

And now they've trained it so that like, yeah, just Claude 3.5 Sonnet has no problem just going, you know, you know, loop over and over, you know, call this tool and then come back, call this other tool. Like that, that is a thing that like I think and, and, and, uh, like Torsten's putting it, I think it makes sense.

It's like, yeah, it sort of makes implementing this agentic loop a lot easier because like a lot of the heavy lifting of this loop is on the model, which does a really good job at it.

We're gonna be taking increasing responsibility over is, well, is that calling tools in a loop actually delivering results for users? Like, that's the magic, right? Like of course you can put together a demo that has an LLM call tools in a loop.

How do we make sure that that actually drives toward an outcome? And that's about the lingo these days is an eval. I mean, where I come from, the only good to- s- the only software that's ever been good is software that's under test.

If that software is not being tested before a user touches it, it probably doesn't work very well. So I think evals are just part of that in a way of just like, but it's a new world, right? Like one of the cool things about the way we've done testing in thus far in Zed is everything is fully deterministic.

We even s-simulate like network interaction and we literally simulate the scheduler such that we can interleave deterministically network messages. Everything's determin-deterministically tested and rant fuzz tested. We randomly bombard a data structure with, you know, hostile interactions to make sure that it doesn't panic.

For the first time with an LLM, we can't do that anymore. We don't-- It's, it's deterministic and so you move the testing paradigm from like pass-fail to like I get a numeric grade and yet everything old is new again.

I mean like it's still testing in a way. So, uh, that's really what, you know, we've gotten like a-- Step one is like build a beautiful user interface that we can plug the agent into and I think we've accomplished that or, you know, we're-- There's always work to do, but it's a gorgeous way to sort of surface the agent's intelligence.

Step two, let people use that, collect data, collect traces and then step three, which we're in the middle of right now and will hopefully be done in time for launch is like optimize the entire system around delivering outcomes there.

Okay. In-- Very logical sort of, uh, step-by-step reasoning. I guess like for, for users like what should they expect that it, that is, that they should, should start trying this out on? I think like what's interesting with this, the CRDT first collaboration that you guys have done is that you can kind of do asynchronous streaming of edits.

Uh, b-basically it-- This can get very spendy very quickly because you could just have like a coding agent run all the time and it doesn't even really need prompts as long as you understand what the goal of the project is.

It could just kind of be in there coding for you whether you're there or not. Um, how, like how far did you go with this?

I think right now we're, you know, we've gone just scratched the surface of the potential I think for using CRDTs. So they're already really great for helping us manage change and deal with nonlinear undo. But like, I mean, Antonio, you can talk about the multi-buffer.

Yeah, I mean, yeah that's, that is a good example where like, you know, the agent can sort of make changes and you can be editing your buffer at the same time like no problem. So like we deal with the conflict there.

But the cool thing is, is that like as soon as you have like a bunch of changes coming from the agent, you can open up this, this thing we call a multi-buffer which is basically this like tab that opens in your center pane.

So yeah, this is the agentic loop. Uh, this is my-- Yeah, one of the toy projects I use all the time. It's FontKit and-

This is the new agent panel by the way, moving away from the sort of write optimized text-oriented more SDK approach that we had started with. Still there in the product but-- and more towards something optimized for reading and optimized for letting the agent kind of loop and call tools and it should look pretty familiar and that was kind of the point.

People were a little intimidated by-- I mean the original tool was more of a developer tool for someone working with an LLM because that's what we needed to like play with the tech basically. This is more let the tool do stuff but yeah.

So it's gathering up context.

And now it's like starting to... Yeah, it's pretty cool like we've seen this pattern in Claude 3.7 which is kind of different from the other models where like it, it really loves to gather up context first and then it starts doing, uh, edits.

Uh, so anyway, yeah, check this out. We created this one file, so source variations. What I can do is like hop on this multi-buffer. Right now it's the only thing that it changed is it created this new file called variations RS and, uh, so it's gonna be more, it's gonna make more sense as soon as we have more files in this.

So it's, it's making the changes right now to lib RS. Let's see.

We're gonna need to have like a few moments later.

Okay. Well, I mean, are you tempted as a toolmaker to do like fan-out calls and parallel calls? You know, uh, this seems pretty linear.

Yeah, I mean, right now, yeah, it is pretty linear. Yeah, what do you mean by fan out? Like multiple agents sort of like doing-

Like, okay, I gotta update three, uh, five files. As long as I have a plan in place for what the shared dependencies are, I can just spin up sub-agents.

Totally.

You know?

Yeah. I think, yeah, that's something we have, like talked about even like, you know, right now we're making all the... as you can see in the code, like all the editing happens like via a tool call. So like, uh, Cloud 3.7 will have...

has like a, I think, what do we call t-the tool now? Edit file, where like it produces like an old string and a new string, and we sort of like replace that old string with that new string. But yeah, one thing we, we were thinking about is like, oh, we can do it like Aider style, where like we have an editor model.

And so, uh, to your point, yeah, what we could do is like have, yeah, an architect model that sort of starts, you know, comes up with a plan and then decides, okay, these are like the five files that I wanna touch.

Uh, let me sort of, you know, do that in parallel. So yeah, something we've thought about. We haven't done it yet 'cause we wanna, you know.

I mean, what are your thoughts on imposing additional... Like one cool thing about just letting the LLM loop is that it, you know, like as soon as you're imposing additional structure beyond that, are you kind of leaving some of the intelligence of the model behind?

Like you're kind of having to kind of supersede on its behalf and say, "Okay, cool, now the plan's done. We're gonna go fan out." Do we know that it can fan out and that that's gonna work? I mean, that's, yeah.

Yeah, I mean, look, uh, uh, very fair question and something that only a, a, a test will-

Yeah

... will elucidate for you. My sense is that

correctness is and, and maximum capability is only one dimension that you, that you care about. Uh, you also care about speed. You really do.

Yeah.

And-

Totally

... I don't have to tell you guys that.

Yep.

And so enabling people to, while the thing is coding to, to, to inspect files and like we can read much faster than the LLM can generate. So if we can read the five different files and start giving feedback on like where it's going off track, that would probably be better than full autonomous, where maybe a more linear, a more general intelligence approach would make sense.

Makes sense. Further, further down, like, uh, the editing, so like I'll collapse the panel for a second. Still editing in the meantime, but yeah, like you can see here, I have basically like a list of files, right? Like a list of excerpts that have been touched by the model.

And so what I can do is like sort of come in here and sort of say, you know, make changes to this and, you know, I can change stuff that the model did. You know, this is what the model did.

But also I can come in here and sort of decide, you know, I wanna change something else, right? And like make edits to this. Now, I don't know, uh, this is an example.

Getting that correct is, yeah, I think takes nuance, right?

Exactly. Like, you know, distinguishing between what the model did and what we did so that we don't show like changes that the user did as, you know, hunks to review, if that makes sense. I think, yeah, that's, I think that's a really, really cool thing that you can do with, with, uh, our tech and, uh...

But yeah, also just, you know, the beauty of this is an editor. I can just have a cursor in here and just scroll up and down in this list of excerpts that spans across files and make the changes I want or simply decide, okay, yeah, I like this.

I can sort of accept, accept or reject. Um, and these are like buffers that you can sort of like, uh, you know... Like you can see here, you know, I'm-- I have a language server running in here. Like, you know, it's highlighting the return value and the function and like, it's sort of like, yeah, it's as any other buffer, like, but it, it's a multi-buffer.

So yeah, it's, I can access multiple files at the same time, and like I said-

subset of fragments from across your code base. And so the cool thing is, as you're sort of interacting with the agent and looping, right now when we're keeping or rejecting, we actually are dismissing, but uh, yeah, before launch, we wanna experiment with the idea of keeping the actual multi-buffer around and putting it in some sort of like discarded state.

The idea being that when you're interacting with the agent, you're sort of building up this like excerpt of the code base, like a kind of a relevant working set that you're, uh, that you're operating on. And that could potentially be useful even if you wanted to switch to guns and go in and do manual code editing.

Now you have this kind of curated subset of the code base, like pulled together in one continuous multi-buffer. Um, so I'm excited about the potential of that. It's kind of this like agentically derived code base excerpt that you can actively work on.

Interesting.

What I like about that narrative is also just like, I don't know, in a world where like a lot more code is gonna be generated by agents, I still like the idea of understanding what the agent did, like being in control.

I still like this idea of like, you know, uh, owning the, the code base, right? Like, and knowing exactly what happened. And so a reviewing experience where like it's crystal clear what the agent did, what you did, and like just being able to review all those excerpts to me is like a key part of making, you know, an agentic experience really productive and, and, and useful.

Okay. So a couple other, I think, bookkeeping or sort of table stakes type of things that I always ask around these things. Any interesting insights on code indexing? How do you do code search?

Now we're launching with just letting the model search for code.

Normal grip.

Yeah, exactly. Just because we've seen it to work reasonably well. We have a-

Okay.

We have code indexing, like- Sort of in flight right now, but I think we're probably gonna launch without it just because we're seeing value being m- delivered already without it.

Awesome. And then the other thing that was not standard but now is becoming standard is the ability to execute commands in a terminal, which I-- it sounds like you guys have.

Oh, yeah.

Any-anything tricky or special around there?

Not really. I think the one thing we're doing right now, and we're still, like, in the process of evaluating, is, like, I think we started by letting the model sort of just running bash, and then sort of we were like, "Oh, maybe it would be better for the model to sort of use whatever shell the, the user has configured."

Yeah.

So we're experimenting with that right now, uh, just because, you know, in your shell you might have, like, already pre-configured environments and, like, things that are useful for the model to sort of run tests or whatnot. But yeah, we're in the process of, like, experimenting with it.

Um...

Yeah. I, I would say it's a current pain point for me with Cursor and Windsurf that they basically run in a different shell than the, the one I already have open, so it has to do things like do linking of projects with Supabase or whatever, and then I have to do this dance where I, like, click on the link to get the auth token and, and, you know, authorize the CLI and all that.

Um, the, the environment variables is, is always a, a tricky thing. The other-

Yeah, they're looking at the en-- We're loading your environment, and we're also loading and evaluating the, the appropriate, like, RC file for your shell-

Yep

... so that things are-

Makes sense

... properly configured.

Yeah. Yeah, I think, like, the, the scariest part w- it was in, um... it started to try to problem solve some dependency issue I had, then it started, like, Brew installing some random package I've never heard of.

God. RMF user.

Not RMF. I mean, that's the easy one that, that, you know, you can train, train Zed not to do.

Right.

But-

Totally. Totally

... yeah, I think this, this permissioning needs to be taken care of. Cool. And then I think, uh, something that is always a tricky point is, is pricing. Um, I don't see a pricing page on Zed. This thing is costly.

How, how are you thinking about this?

So we are gonna be charging for using the agentic mode if you wanna use Zed as a provider of your request, basically, and that's really about convenience more than anything. Like, we don't expect to make the most amazing margins on charging subscriptions for AI compute at this point.

Like, it's pretty cost in-intensive. But if you can kind of open Zed, sign in with your GitHub, click one link, put your credit card in, we charge you twenty bucks a month, and then we'll have for five hundred requests, and then beyond that, we'll, you know, charge you a small, like, usage-based per request fee that would be reasonable.

That's, like, the happy path. You wanna bring your own API keys, you can do that too. And so that's kind of overall gonna be our philosophy. Like, we're an open source product, so if we don't offer you options, like, you can get the code and build them yourself.

Um, so we really want people to have freedom with kind of how they interact, if you wanna interact with Ollama or you wanna bring your own API keys. But, yeah, we are, are gonna be launching for the first time a paid service, uh, around this.

The, the previous code prediction stuff wasn't paid?

No. It was all free.

Yeah. Yeah.

Yeah. Um, not, you know, never with the intention of it being free forever, but we wanted to get, uh, an agentic offering out the door before we started charging.

Oh.

And so now that's the moment, yeah.

Cool. Anything else we should cover on Zed Agents?

Good question. Yeah, I mean, the thing I'll say is like-

I think MCP is a good, you know, a key component in that. Like, we wanna make it very easy to, like, install MCP servers and like-- And I think the, the thought right now is to have, like, two ways you can install them.

One is, you know, the sort of basic one that we currently have. I think we have the other one as well, but yeah, like sort of service these two ways. Like, one is you can sort of change your configuration setting point, you know, point to an MCP binary and, you know, Zed just runs that binary.

That's one path. The other path that I'm also really excited about is, like, going through our extension store. So you know, like any... If you've installed like an MCP server before, you'll, you know... I, I always, I'm always like, "Okay, like, I have the binary, but how do I, you know, how do, how do I run it?

Like, does it need anything?" And so streamlining, like, that experience where, like, you know, if you need the GitHub API key, right, to list all the GitHub repos, right? If you wanna install the GitHub MCP server. I'm really excited about making that experience really, really straightforward, uh, via...

You go in the extension store, you'll install the GitHub MCP server and, you know, we'll sort of surface an easy way for you to configure the MCP server so that you can interact with the agent.

It's up there in the top. You can click that and filter it.

Or third from the left, I gu- There we go.

On text servers? Oh, these are all MCP. Oh, okay.

Yeah, yeah. Yeah, we should probably just say MCP.

The idea here is, like, these are just little instructions for Zed that tells Zed, "Here's how you download this thing and configure it," basically. When you install this, you'll have the MCP server working, just streamlining the experience of using these things and hooking them up to an agent.

Okay. I mean, stupid question, but, like, why must there be a separate repo for each of these?

No, they're, they li-- All that's on that... Go visit the repository and you'll see what I'm s-

Here?

Yeah, click on the Visit Repository thing.

Oh, oh, sorry. I, I, I, I was, I was clicking on it, but you couldn't see it.

Oh, okay.

This isn't like we're hosting a fork or something of the MCP server. What's that extension is, is it's just instructions how to get the server installed. Like, it just streamlines the installation of it.

It's, yeah, it's like a language server. Like, like, we have an extension for a language server, but we don't ho- you know, we don't own the language server. It's just like a recipe. Like the, all the extension is, is a recipe for, like, installing it and configuring it, so making it easy to, uh, sort of integrate it in the Zed.

Okay. It, I mean, uh, I don't know if that scales. There's gonna be, you know, thousands of these. Uh, I don't know if-

Yeah, and this is why we're offering the other path. Like, you can still hop into your settings file and just, like, drop a path to a binary and it works. Um...

But if you're an MCP author and, you know, you wanna make it easy for Zed users to install your MCP server into Zed, you could go to find a little extension. It's pretty low effort to, to do

Could, yeah, 50 lines or something. Yeah.

Yeah, that's fine.

Excellent. Cool. Well, I think that, that is a, that is a good intro to, you know, Zed's AI work. I think, uh, you know, obviously you're not gonna stop there. Um, maybe I can kind of, a curious question to, to end it off.

Um, where is all this all going in like five, 10 years for Zed? Like what's, what's the game plan?

Well, AI is gonna become an ever grow- you know, growing part, I think of software development generally, and it'll definitely be part of Zed. Like, we're here to build the future of software development, and so AI is a, a huge component.

I mean, long term, it's really about multi-agent workflows, I think. It's really about taking the CRDT work that we've, you know, like I said, we just scratched the surface and broadening that. Like, I, I l- like, okay, you're working with multiple agents in parallel.

Maybe you've got five separate threads running, doing different things. How are you multiplexing those changes together? Like, in a world where human beings are the bottleneck, a tool designed for mailing patches to, uh, the kernel mailing list is probably fine.

You know, it's not a big deal that I'm like posting on a web forum on a pull request and like dealing with merge conflicts and all these things. But when I'm really like working with agents in parallel, I think having deeper integration into the tool that I'm operating with around the idea that we're gonna be merging changes, I have this vision of like being able to kind of mute and unmute changes from individual threads in my current working copy simultaneously.

So I just have a much more fluid relationship with these collaborators that I'm bringing into the world now, this agentic collaborator. And so like a big part of the reason for Zed's existence was doing the vertical en- engineering necessary to allow human beings to collaborate in a new way.

We wanted to collaborate, not commit by commit, but keystroke by keystroke, and that's kind of a weird thing for human beings to wanna do it seems like in this world. Like, our team works that way. We work a lot together in real time.

But a lot of people, they don't wanna do that, but they do wanna do it now when they're interacting with an agent. And so I think an agent is like this fundamentally new kind of collaborator that, uh, is always there, is always there to respond.

Like, the minute you give them the comment on the pull request, like they're already off to the races doing the next thing. And so I think our vision of like bringing all that collaborative tooling into the authoring environment and making it fine-grained and making it fast and responsive is really compatible with this world where we have these new kinds of collaborators.

So for me, like that's the long-term vision. I think this is really just step one. Let's get an agent into the editor and able to interact with it, and we're gonna keep iterating on giving it deeper and deeper access into the system, giving it access to the debugger, getting it access to all our interaction we have around Git.

Like, we have this huge system that we control. I wanna wire AI into all of it, but you know, this is where we're starting. It didn't make sense to not launch it. We have it. It's valuable. It's gonna keep getting more valuable.

But yeah, uh, I forgot where I was going .

Agents as, as collaborators, I think.

Agents as collaborators, yeah. I mean, I think that's the... And again, vertically integrating and lacing agentic capabilities deeply into the system because we're able to do that.

Uh, yeah, Antonio, I'll, I'll let you have the last word. My, my brief reflection on that is I think there's a protocol in here somewhere because why should I be constrained to your agents? You know, you're, you're gonna have great agents, right?

But so there'll be like five others. You mentioned Hider as well, a lot of people like that. So I think there's like a potential for another protocol here somewhere.

Totally.

That probably, that probably Zed already has internally, which is the CRDT, DT-based collaboration thing. If you just make that a little bit easier to work with by people who are not you, maybe that, that's how it does.

100%. I think like for us it starts with having like a vertically integrated product because that's where we can, you know, make the experience shine.

Yes.

But I don't think it should be limited to Zed. I, I don't think we have any, you know, constraint around that. I think like as soon as we have like something that we think is beautiful and like works great on Zed, um, there's, I think, yeah, we should expand it to other.

Yeah, for sure.

You, you need some like, uh, fancy name like coding agent protocol or something.

Yeah, I mean-

Make sure we-- Go ahead.

You're supposed to have the last word, but something that would make me happy is that instead of one more fork of VS Code, people just had a great API for surfacing a great agentic experience into a tool that was welcoming to that.

We don't need to be sharp-elbowed about controlling all of that.

Yep. I, I support that. Antonio, any- anything, any other thoughts?

Word.

Word. All right. That, that is the last word from An- Antonio. Uh, well, th- thank you guys for joining. Yeah. No, no, no, you can, you can chat, but, uh, no, this is great. Uh, you're doing, you're doing awesome work and you're extremely passionate about it, which I think is, is like the, the key thing that people can tell from just, uh, talking to you guys.

So I'm excited for the launch. I'm, I'm definitely gonna try it out and, um, good luck with, uh, all the, the awesome work that you're doing with coding agents.

Thank you so much.

Have a good one. Appreciate the opportunity.