NEW Programming Language For AI Agents?!

Added: 2026-05-17

[00:00:00]So, Versil has created a programming language. Yes, that same Versel which you use to host your front-end applications. I tried it out and I have some interesting feedback on this. So, let's start. All right. So, the programming language is called Zero as you can see over here and it has a bunch of these experimental tags because it's very new, right? It's just released a few hours back. There are a bunch of interesting things about this language.

[00:00:20]They say this is a programming language for agents. I'm going to show you how this looks and work. The artifacts are small where they say that zero is designed around static dispatch explicit capabilities. No mandatory garbage collection and no hidden runtime tax.

[00:00:34]It's JSON native so you would get structured diagnostics. Graph output size reports and type repair metadata are all part of tool chain rather than an afterthought. And it has explicit effects and memory. So we're going to get into every single thing like what what they are talking about. But the core idea is that look at look at this program for example. This is sort of like a hello world sort of thing, right?

[00:00:54]where you create a function which is main. You call another function from this. It returns the output. So it's like a compiled language. It's not like Python or JavaScript. So it's not a dynamic language. And you have this some of the syntax over here which allows it to write to console and you know there's a world which is given which has all these utilities available. You can also run a check on this and it's going to give you either okay true or false. If it is false then it's going to give you a little bit of diagnostics. And as you can see this is in JSON which is typically not seen right. Usually compilers do not give JSON output like this but zero has built in this thing because it helps AI agents read better.

[00:01:34]They're able to understand JSON better than you know you doing a full stack trace dump of all the errors that you can see. So the zero programming language that we have first of all this language is native. So when I say native I just mean native binaries.

[00:01:51]Right? So it's not like not like JavaScript, Python, etc. So it's not like a programming language which comes with an interpreter or a JIT compiler like you know we have V8. So it's not like this. This is more like Rust and C C++ and it's actually very familiar very similar to Rust. If you have used Rust before you would actually see that there a lot of concepts are actually copied from Rust in the first place. For example this language specifically supports borrowing. Now the borrow checker that zero has is not as powerful as rust one but it has a basic borrow checker available inside the language itself and similarly with the syntax itself you would have seen that it I mean not exactly but it looks and feels a little bit like rust. Now one thing that they have not done which I was a little surprised by I mean not exactly by the way because it's sort of expected if you consider speed as an argument is that this is a language that is not using LLVM as the back end. Now what what this means for those of you who don't know about this see if you look at languages like Rust for example or swift right so let's say these are like two separate languages right completely separate languages but these are fundamentally the same programming languages what if I tell you that what happens is that you have a rust compiler over here let's say rust compiler or you know swift compiler sort of like a first layer of work that is getting done which is when you you know run for example rust And when you compile this, the very first thing or a bunch of first things that are happening is that they are taking the syntax whatever you have written in Rust, Swift, whatever languages which are built on top of LLVM and they are creating an intermediate representation of them. Right? So this IR is sort of like code only but it's like common code spit across all the languages. So if there are more LLVM supported languages all of them can have their different uh you know tokenizer lexer parser whatever but at the end of the day they're going to emit the same IR right which is the intermediate representation and this over here is then passed to LLVM right so this LLVM is sort of like a backend for your programming language if you choose to do so right this is optional you don't have to use LLVM for example you know take an example of NodeJS NodeJS uses V8 which is like JIT compiler right so it's just in time it's just compiling it's just optimizing it it is deoptimizing your code depending on like what's happening so it does not need this specific technology in fact it's not even supported in the first place but if you to take a look at other languages other runtimes as an example they are built on top of LLVM now this is a piece of software which is extremely important and it is extremely heavily optimized right so decades of work have gone into play in order to you know bring in the optimizations that this offers the edge cases that it has fixed you know the architectures that it spits out for example LLVM if you're using LLVM as a backend once you have implemented like how the parser interpreter and you know bunch of top level like the front- end sort of things would look like for your programming language all you have to do is plug in LLVM and it'll automatically give you support for for example Windows right it'll give you support for different architectures like Mac OS on Intel which is x86 x64 sort of architectures right and then the new one ARM ARM based architecture as well. So a bunch of these CPU architectures LLVM would automatically spit out the final binaries and you're good to go. But what zero has decided is that they are not using LLVM right. So they are not using this architecture and the sort of write you know write binaries for every CPU architecture manually. So what that's what that means is that this these guys who have developed zero they have written a C compiler by hand or by LLM whatever most likely it's wipe coded I'm get I'm get to that why that is the case because there are a bunch of bugs already that are visible um but this C compiler over here just spits out an architecture of supported infrastructure like whatever they support so far right and if you go to their website and if we scroll down a little bit get started and if you look at target capabilities you're going to see that there is a command zero targets as well. Actually, if you look at in this part in the native targets, you're going to see that there are a bunch of these architectures which are supported right now. And I mean technically speaking, I am on Darwin ARM 64, which is what your Mac OS is if you are running um you know any M1 based Mac you are running on this architecture and this is actually not working right now. So I'm able to use the checker inside zero but I'm not able to run it and this is a bug which is already filed. For example, when I run the zero run hello.0 zero and if you look at hello zero over here you're going to see this is like a basic program but this does not work because of an error lcuid load command is missing and there's a 4 hour ago opened issue on this even though like this architecture is supported but this does not work however you can still run zero check hello.0 zero which is sort of like giving you the same data but if I pass in like a JSON flag you're going to see that we get a bunch of more information over here right so we do get okay as true and a bunch of more things over here but this is something that can be useful for AI if this is let's say okay false or if it's trying to debug something and that is the whole idea behind this programming language that a lot of these commands have these JSON equivalents or AI friendly prints outs that AI agents can read easily and debug them and that is what their pitch is that why AI agents will use this is because it's easier to write, run, and debug. Bringing me back to the same LLVM point. LLVM itself is actually expensive, right? When I say expensive, I mean that it takes time to run, to optimize, you know, to do a bunch of things. You you would have seen like, you know, people complaining about Rust's compile time. The reason or at least part of the reason for that is indeed like it has to run it through the LLBM implementation, the back end, right? because this is the one that is doing all the optimizations and stuff.

[00:07:47]So I'm not saying LLVM is the only slow component in that whole build pipeline but this definitely adds up and that is why probably I'm just guessing I don't know but that is why they have decided to not use LLVM even though this would have given them much more stability and you know multiarchchitecture from day one but they have just decided to do and you know just manually do this and write a C compiler. Interestingly, you would see that zero's compiler right now is written in C, right? And the reason for this is because obviously if you think about it, Zero is not a good language right now, right? What that means is that it's buggy. There are a bunch of broken things. Implementation is not fully there. So, you can't really use this programming language itself to bootstrap itself. Right? How can zero write its own compiler in its own language on first day? It's not possible. That is why you use another language like C in this case to bootstrap a compiler and then once this language becomes stable you can technically then go ahead and write zeros compiler in zero itself right so that is where sort of that self-referencing comes into play for example GCC is mostly written in C right now even though this is a C compiler and that happened once C got mature C got stable and you could use it to write its own compiler this is one of those sort of like paradox situations where a compiler of a language is written in its own implementation which also by the way proves very strongly that the language is mature and language is good enough to just use itself to compile itself right but zero is not there so they are using C compiler and they are not using LLVM these are like two highlights all right so before we move forward with examples and I show you like how this programming language looks and works like I quickly want you to check out today's sponsor which is test sprite now just like used AI to bootstrap app, a programming language, writing a C compiler by hand.

[00:09:37]I'm sure a lot of this work has been done with the assistance of large language models. And generally speaking, when you use LLMs for coding, it's also a good idea to use LLMs for testing. And Testbrite is an AI testing agent which helps you ship code to production which does not break. It's extremely simple to set up and get started with and works with every single harness of your choice. In fact, you can even get started with Testrite within the browser itself. Let me show you how. So once you log in, you're going to see that you have a bunch of these links over here on the left side. Some of them would be new as they are releasing new features. But what you can check out is this web test and MCP tests. Click on create tests.

[00:10:14]Give your test a name. Basic test.

[00:10:16]Again, you can also upload your P or product descriptions. In this case, I don't have it, so I'm going to leave it.

[00:10:21]Now, either you can proceed with a backend test or a front-end test. In case of front end, let's say I give it just the firm.app URL for now. And I can just say that I want to make sure that my marketing pages are not broken. I don't have a test account because this is a marketing website. So I can proceed. And at this point it's going to scan my application and explore using AI and get test suite ready for me. If it was a backend application I could have specified a backend API URL and you would have gotten the same result. Now one important thing here to note is that Testrite actually spins up real browser in the cloud. So what you're seeing over here is not just an iframe inside my computer. This is actually a real website preview that Testright is using to explore the platform in real time in front of me. So it's going on this product. It's clicking these icons, you know, it'll visit every link. It'll try to check what can we test including status codes, whether the pages are loading properly or not, whether the pricing are prices are reflecting properly or not, and so on and so forth.

[00:11:20]Once it is done, it'll create a bunch of test reports for you in which it'll not only just run the test, it'll also give you a video preview of what it has done in the browser itself, which is running on their own computers, including the steps. Now, these are like real preview, like real agents browsing your website, figuring out everything is working according to how the test is supposed to go. Finally, this can also be taken to GitHub where you can download them, put them into your repository, and run them on every CI run. This over here is super important by the way if you want to ensure that your product does not break in production which is very important.

[00:11:55]This works beautifully for front end, back end, even data testing as well if you need. So once again, thanks to Testrite for sponsoring this part of the video. All the links are in the description. And now back to the video.

[00:12:05]All right, let's give it a spin. Let's try out some things with zero. So don't mind the syntax highlighting not working because this is I don't know, maybe I can force it to have Rust syntax highlighting. I don't know. Let's see.

[00:12:18]Okay, it's it's not exactly perfect because obviously the syntax is different, but at least it's better than, you know, everything just looking weird, right, in plain text. So anyway, this is our force test force program where, you know, it should not compile.

[00:12:31]And the reason for this, for those of you who don't know about what borrow checker in Rust is, the simple idea is that you define whether a variable can be a mutable variable or not. This and symbol that you have this basically means is that is this shared variable allowed to inspect this value whatever this is in readonly mode right so this cannot be used to modify the value but this mutable variable because it is getting this in mute mode which is like mutable this is allowed to inspect the value as well as change it now this is actually very interesting I mean I I do want to give you a little bit of background on this first because then only you will be able to appreciate it so like a small quick rust class over here. Let's say I just take this example, right? So I'm not going to teach you Rust for now, but I'll just teach you the concept of mutability and and this borrow checking, right? So see the core idea here is that why this exists in the first place is that let's say this P over here has this point X1, right? The thing that we have, let's say that this is somewhere in the memory over here, some arbitrary location, let's say 42, right? Inside the memory over here. Now when you have shared which is like sort of like this which is a pointer to P reference to P rather I should say what this shared is is it's not a copy of P this is still pointing to this part of the memory in the location. Now what rust says is that if you have an immutable borrow checker immutable reference you cannot have a mutable reference to the same part. So this is saying mutable equal to amperson mute and p right. So what this means is that this can not only read the value but this can also modify it. Now what happens in this case the reason this is actually not allowed and as is a source of a lot of segs and memory corruption bugs in C C++ is that this is perfectly fine as a syntax in C that you can keep a reference to a part which can also be modified by other variables right other references but in this case the problem that can happen is let's say this this P of X somehow is modified to let's say whatever like the structure is changed or something is different is modif ified which results in the programming language or operating system rather on the runtime to decide that we will just move this to let's say 84 because we don't have enough memory over here now I'm sure you can sense the problem the problem now here is that this P over here points to the updated memory that's fine but because this shared had a pointer to this specific block now once you try to access this memory you're going to get either garbage or you're going to get a seg fault and this is also one of the primary reasons that you know bun has also decided to move from zigg to rust because these things are possible in programming languages like C, C++, zigg but it's not possible in rust because again it would not compile and we are not talking about rust we are talking about zero but this whole thing what what makes this possible is the borrow checker right that is what makes it possible to not have this behavior and this is this sort of borrow checker is used by zero as well now let's say we run zero check test 01 one borrow conflict and as you can see it gives us this borrow conflicts with an active lexical borrow expected this actual this and then and then it also gives like this zero explain b001 right so it's it's sort of like it has encoded the error code in a specific error code and this is done for large language models right this is for AI so again like a lot of these small decisions are taken for the sake of AI and once they have all of this in their training data you can see that we see the code over here which then it can use to I don't know like maybe either look up that this is an error of what class and how this should be fixed or you know just avoid it directly in the first place and you can see like it also has this help fix safety repair and you know a bunch of these things line columns all of that so it's it's sort of like built for you know AI agents to work autonomously in a way now you know when I told you about that this is actually something that would not compile because of the borrow checker logic I was actually not fully right because this in rust would actually compile. Let's say I create test01 borrow rust rs for now, right?

[00:16:43]And I wrote more or less the same program just like we have over here for zero. Slightly different. It also mutates over here, but it's possible that you don't mutate it in the first place, but that's fine. And let me show you if I run this from rust c test one borrow. RS, you're going to see that it compiles without any problem. Even though this is effectively the same code as zero, but with zero, it is erroring out, right? Because of the borrow checker. Now the reason for that is because Rust's borrow checker is even smarter than zero's one. zero has created a borrow checker which is not very smart because if you look at this this code technically is not unsafe right it's safe because we are not really doing anything with shared and mutable variables while even while they are assigned look at this I told you about this thing that the reason this can be a problem is if you do something with mutable and then access shared later right if you have done something and then you are accessing shared after you have gotten a mutable reference then that can create a problem in In this case we are not doing that and also in this case we are also not doing that. We are accessing shared before then we create mutable again. We do mutable.x and then we never really access shared again. For example let me do shared.x here instead of mutable or dox and run this again. Look at this. Now you can see that rust rightly points out that you cannot access share.x after mutable.x ex has modified it because it's possible that there is some sort of memory glitch or something that rust might or operating system might end up doing on runtime and this code becomes unsafe and this small thing which is like the borrow checker this small thing is very powerful in order to prevent bugs like what I've showed you right this you might not even catch if I have changed like mutable to shared and you know and in most cases in development setup at least it would probably work fine as well because you're just modifying it from one small integer to another small integer. But this can create bugs of scales you would not imagine on your production. So anyway, the point being is that zero is borrowing the borrow checker idea from Rust, but it's not as powerful right now because this code technically should compile, but it does not because the borrow checker is not smart enough. And even with Rust, it was not smart enough a few years back, right? This was a change which was made sometime later. It is not like an old change which was there since the starting of the language. This was made after some time.

[00:19:02]Even rust had this similar behavior that zero has right now. So anyway, the core idea is that this is a simple new language from versel like I mentioned which I can see like has a lot of these JSON flags and you know a bunch of these things available. I personally am not sure about how this would play out as a programmer because of a bunch of reasons. First of all is if you go to this issues tab, you're going to see this one issue which is interesting to me which is this one. Type checker accepts invalid minimal programs. Right?

[00:19:33]You can see like there are a bunch of programs which should not actually work but are still working in this. Right? So that means the compiler right now type checker these systems are not mature.

[00:19:43]That is one reason. So systems are not mature and this is like this is I mean in some capacity this is also fine because it's a new programming language in the first place, right? But second of all is of course like training data.

[00:19:57]It's very important for LLMs to learn this inherently, right? It it will be hard to guide LMS on larger code bases on what's going on because it's a new programming language. So training data is missing. That means it still needs a lot of at least human assisted writing of this code. You would not have pre-made or available code for this new programming language on internet which LLM can use to train themselves. Third is that I do feel like a programming language like Rust is very mature and you know it's very stable and it's actually very good in order to be used as a systems programming language by AI agents but you know we can bring AI agent features over here as flags or whatever right so this JSON thing I really liked the error messages and codes that are there I like it the ability to fix issues I like that I mean if you look at this Rust output right now you're going to see that this is an output which is very human readable but I mean this can be improved for AI agents right just like you know zero has a JSON mode JSON output so that can be something that can be done and the most important is that it won't be as optimized right and again this fourth point goes back to the fact that Rust is built on top of LLVM over here which is heavily optimized over decades of time and if you are trying to write any sort of important systems with zero I would just say just hold off for a little while you can use this as a fun little experiment toy language for now but won't rely I won't suggest relying on this for now because the ecosystem is not mature at all right now right so I'll still suggest if you want stick to rust or you know Golang or other languages which are much more stable have been there for a while but you should know about this which you now know thanks to this video so make sure you like and comment so that's all for this video hopefully you liked it if you did make sure to leave a like and subscribe to the channel I'm going to see you in the next video very soon. If you're still watching, make sure you leave a comment I watched till the end below to tell me that you were still here. And let me know what do you think about the video.