I'm reminded of what Richard Dawkins had to say about the Bicameral Mind book: "either complete rubbish or a work of consummate genius, nothing in between!"
This website is really rough, the writing is dense and the first rule of video club is don't get one of the founders to narrate the video unless your CTO is Morgan Freeman. That said, I think this is just so unbelievably audacious that it's worth a look anyway.
The concept seems to be to take hardware's supply chain model and use it for software development. So instead of having one company figure out your requirements, plan the project and build everything, you use a marketplace. Each part is put up for bidding by any supplier, meaning you get specialisation and competition.
Oh, and the suppliers are actually software agents. And "parts" includes everything from requirements gathering to opcode generation. In essence they want to build their own industrial revolution for software development, from scratch, using (basically) DAOs.
Is that possible? I have no idea. My first instinct (and second, and third) is no. But if it is, it could blow up the entire industry. Rubbish or genius, nothing in between.
> All layers of abstraction are encapsulated into a single scalable system. Since there are no codebases and thus far fewer unintended consequences, Code Valley neatly sidesteps the software complexity trap. We don’t need to search for silver bullets anymore — the Werewolf has been retired to a harmless cottage, no longer able to bother the were-proof residents of the Valley.
I ... can't see how the top level 'pilot' operations don't effectively count as a codebase, just a really weird one.
I really wonder how software verification works in the case of Code Valley, e.g. if you order List.append a b, how do you know it won't return List.append b a?
This could perhaps be a great application for Idris-Style dependent types. For example, you could create an RFP for "List.append" with a few constraints, `len(append(a+b)) == len(a) + len(b)` and so on and then know that the market will create something you can automatically verify to a certain degree.
Hi, I'm one part of the Code Valley team. Happy to answer questions.
Any developer can vet suppliers before they automate an agent to contract them. For example, you could contract the agent you're looking to vet, hit 'build' and be returned a small program to carry out List.append a b. If the program works as you expect, you have then verified (in that instant of time) that the supplier is sound, and can proceed to building your own agent to contract it.
I've been waiting to be automated out of my job for a while now. I also think this is rubbish but great that they are trying. I'm sure it will deliver some value to someone.
Cheers - thanks for giving us the benefit of the doubt. The technology still has a long way to go before it can cater to the end-users of the world, but it is at least at the stage where other developers can join and build their own agents in preparation.
We (the Code Valley team and the emergent coding community) are still hard at work building the UI-designing agents, but you can build a 'Fibonacci calculator' right this moment, if you like.
Only related because you mentioned it, but...I found the bicameral mind book to be an amazing read. I often found myself sitting and thinking for a long time after reading certain paragraphs.
This reminds me a lot of when Joe Firmage[1][2] created Many One as a portal for all mankind (and aliens) to access all Earth information by zooming around a globe. It was plagued with grand vision and hyperbolic prose when in reality it just wanted to be Google Earth with some plugins.
It looks like the guys behind Code Valley have been working on this for a long time with patents[3] dating back to 2003. There's probably some sort of Internet law at work here where the longer an idea has been worked on without traction, the more hyperbolic the prose becomes in order to maintain commitment from the founders.
Holy fuck, that reads like something written by TimeCube Guy.
I guess the real example is this one:
"For example, the compare::bytesequence::lesser agent, when contracted, will design the code that will compare two strings. At first glance, a developer may see that title and assume that the compare::bytesequence::lesser agent will actually compare one given string against another, but in actual fact, the compare::bytesequence::lesser agent will return tailored code that compares two strings."
So, it's template metaprogramming but with confusing terminology? I'm trying to give this a fair shake, but it doesn't make an argument for why this is a useful abstraction layer.
it's like having functions, but with someone to write the function for you. The thing with the market is that you'd know that the code you get is verifiably accurate and thus, your software will have no bugs.
That function might be accurate, but its usage might not be. It's a bold (and possibly incorrect) claim that the software composed of accurate units will not have any bugs.
We don't maintain that this system makes bugs impossible. Rather, the system provides an environment in which bugs are highly unlikely to emerge.
In this system, developers are incentivised with the prospect of direct payment to deliver a correct fragment. If we assume that game theory's rationality will prevail, I'm sure you can see how (in a perfect world), all fragments will be correct. However, we know the world isn't perfect and that there will always be an irrational player who is motivated by things other than direct remuneration... a player who has malicious or duplicitous intent.
There are three pieces of good news regarding how the system deals with these players:
(1) The first is that it is actually a good deal more difficult for a bad actor to actually produce, well... bad (binary) code, compared with current methods. In this system, every agent provides its service by contracting other agents. There is no glue code in between; no opportunity for a developer to 'write' additional (malicious) code. If a developer wanted to create an agent that 'injects' malicious code, he would have to do so by contracting agents to design and 'inject' that code. Then, the developer would have to deploy that agent to the network where it would try and directly compete with other legitimate agents, agents with good reputations and a solid history of successfully completed contracts.
(2) The second piece of good news is that although these irrational players technically can enter the system and build an agent, their time will be extremely short-lived. Because of the recursive nature of the system, it has near-perfect accountability. Malicious players are easily spotted and basically ostracised by the wider compiler community. (Who would want to contract an agent that is known to return faulty/malicious fragments?)
(3) The third piece of good news is that the system itself only becomes more resilient and hostile to bad actors the longer it is operational. 'Honest' players (better yet, efficient players who cleverly optimise their agent's designs) are just as easily identified and even more handsomely rewarded. Remember how an agent achieves its service of compilation? By cleverly contracting other compile-as-a-service agents. Since these 'supplier' agents will return the smaller fragments that make up the larger fragment the agent itself returns, an agent's livelihood is dependent upon the reputation of its suppliers. This means the developer will choose its agent's suppliers very carefully, likely vetting them prior to building the agent itself. Over time, as suppliers become a known and reliable quantity, the ties between client and supplier agents are strengthened and it becomes even more difficult for a bad actor to find any kind of footing.
It is a strange concept indeed to ask someone to trust a binary that has no 'source code' to inspect! But when you know and trust the compiler of that binary, it is a no-brainer.
I'm part of the Code Valley team, and can I just say what a relief it is to see this comment. Most balk at the idea of not having source code to read and verify, but there are other ways to achieve verification, as you have stated.
It's not a problem at all - no need to walk back :).
I mean "someone" as in the author of the template (to use your phrasing), yes.
> What are the specific limitations of agents? What can they do?
What each agent does, not matter where they sit in the network layers, is the same; they request information from their clients, they make some decisions and then they contract other agents. In this system, everything is a (compiling) supplier. A developer creates an agent to build on and inherit the knowledge of its suppliers, adding a little knowledge himself in the process, and ensuring that his agent returns compiled code.
Have you had a chance to check out this video (https://www.youtube.com/watch?v=qTl-V58cG1w)? It sheds a bit more light on how the service an agent performs is that agent doing its own part in a distributed compiler.
A developer can only build an agent if its suppliers exist, and if the compile-time interface protocols have been defined. Are they the sorts of limitations you meant?
> How are they written?
This system bootstrapped itself (and achieved PoC at the same time) back in 2013. Agents are built by agents. There is a special agent that sits on top of this hierarchy of agents that is designed to specifically capture a developer's requirements for their agent (what it should ask its client, what decisions it should make, and who it should contract) and translate these requirements to contracts to agents which will ultimately build that developer his agent. (The recursion is a killer sometimes, isn't it?)
This special agent that sits on top of the hierarchy is called the 'Agent-builder' and will feel to a developer like an IDE or visual programming language (designed specifically to design agents).
"Code Valley envisions a world where all software projects are designed and built using a collective effort of developers across the globe, by automatically pulling in their expertise anew for every project"
Errr, yeah sure - if npm allowed you to 'write' in any language you wanted (or even create your own), and if each function you called was also its own compiler.
That video feels like a viral ad for some new comedy TV show aimed at developers. You just "select features" then a "network of developer bots" contract out recursively until they contract developer bots to build individual bytes. Then they "join bytes together" into "one long string of bytes".
This has to be a scam, a joke, performance art -- something like that.
Edit: After reading the website more in depth, I am not sure anymore. I get the sinking feeling it's one of those situations where someone has an idea that might in some way make sort of sense but not really, but they somehow have a circle of support that funds or helps them do "stuff". Maybe even picking up some true believers as investors?
For instance, I was contacted about an opportunity to work on a firewall "that uses soundwaves for data so it's hacker proof". They claimed they could break AES at will (hence the need for sound-encrypted data). They had lots of promo materials built, and had spent years on the idea. Had a sales guy/evangelist getting people interested. Even had prototype hardware.
Errr... I can, but it will not be the 'source code' that you likely had in mind :).
I'll take what I said in another comment in this thread:
"This system bootstrapped itself (and achieved PoC at the same time) back in 2013. Agents are built by agents. There is a special agent that sits on top of this hierarchy of agents that is designed to specifically capture a developer's requirements for their agent (what it should ask its client, what decisions it should make, and who it should contract) and translate these requirements to contracts to agents which will ultimately build that developer his agent. (The recursion is a killer sometimes, isn't it?)
This special agent that sits on top of the hierarchy is called the 'Agent-builder' and will feel to a developer like an IDE or visual programming language (designed specifically to design agents)."
Out of curiosity, have you signed up to try your hand at building a few agents? I can personally guarantee you an invite, and once you have those login details, you will be able to see an interactive example expression of an agent. This expression is the closest thing this system has to the 'source code' you are referring to.
No, I have not. And I will aggressively defend my ignorance! I'm reasonably well-versed in, like, computers and stuff. So if I can't understand the idea with screenshots and examples, it doesn't invalidate the concept, but it is a bit...odd.
Anyway, I can give it a try if I have time, but surely you can provide a more concrete example than this. For example, what does the "string reversal" agent look like?
Yeah, a visual programming environment tailored specifically to 'capture' a developer's requirements for their agent; what it will ask its client, what decisions it will make, and who it will contract as a result.
> Do you have any examples of anything "complex" being written with this?
You could argue that an agent itself is a complex thing being created using this technology :). A developer expresses their requirements using that visual domain-specific programming 'language' that you saw, and then these requirements are translated to contracts to agents that will end up building the developer his agent. (Recursion... it's a killer sometimes.)
But for an example that you can actually relate to, here (https://www.youtube.com/watch?v=U6jtCVOQiuA) is a cut-down version of our corporate website (with back-end server) being built as a single program by contracting about 8 agents from the behaviour layer (the 'domain-specific' layer of the network). Please note that this example uses our old interface so it looks a little rough compared to the current interface.
(These agents exist in the previous iteration of the network, and are now defunct. We are working our way up to these agents in the current public-facing iteration of the network, so that the community of developers can join and build their own agents.)
Have you had a chance to check out the Interactive Tour (http://marketplace.codevalley.com/use-it)? It shows only one side - how to use agents to build software, but once you're familiar with that, you can request an invite to see the other side: how to build your own agents.
This idea is crazy, and if distilled properly, could do a ton. This iteration is most certainly not going to be a part of it. I suspect we are decades to centuries off of this being realized.
Why one decided to make a completely new vocabulary that feels incredibly inaccessible to even the technical audience is beyond me.
If you develop an app based on this network of contractors, how can you be sure they'll always be around to support your app? Do you make a local copy of the foreign app? What if they increase their fees and hold you up for ransom?
This technology allows developers to build agents that compete with each other for client business. If an agent disappears and it was the only one published under its classification and there is a client now without a supplier, that represents tangible demand. How long do you think it would take for another enterprising developer to come in and fill that void?
And you don't need to worry about suppliers increasing their fees and holding you ransom... again, that represents demand: another enterprising developer can come in and fill your need for a more reasonably priced service and undercut the exorbitantly priced supplier (who will likely go out of business quick-smart).
Awesome idea, was thinking about something like that for a long time. Not sure about implementation though. You can define algorithmic problems in a declarative way, but what about the rest, ie. 99% of actual work? Like a website. To verify that a result is good would require a human-level ai.
Instead of a hello world example in a video I would like to see a high-level example for something really complex, like:
"The site you're currently viewing is served by a web-server that was designed and built by this network of
agents in 12 minutes."
ok then, how high level and reusable that code actually is? Show it.
All I see is a form-based code editor with autocomplete + templates.
The underlying model seems very low level: eg. at 2:45, manual input of size in bytes - wtf.
Is that video really supposed to show the power of this thing?
Since there is no compiler, all maximums must be specified at the root client (or injected based on other information by suppliers on the way 'down').
That visual template you saw was actual contracts to agents in the network. As soon as the expression is built, these agents receive contracts and the hive compiler begins forming. Bytes return shortly thereafter.
This technology does still have a long way to go, but it has the potential to do some powerful things. Right now though, we (the Code Valley team and developers who have joined and are joining) are still in the phase of populating the lower layers of the network. We are working our way up... when the behaviour layer (the 'top' layer) is populated with agents, the 'power' you are looking for will be more clear.
I really feel like there is something genuinely interesting here.
However I've read the main page, looked at 3 videos. Tried the demo... I still don't really understand what's going on.
Now, it is 6am and I've been up all night working on a project. But if I'm really trying to understand what's going on and it's not clicking /at all/ then it probably means there's a problem with either the description or the model itself.
I'm part of the Code Valley team. I really appreciate you spending so much time trying to understand the technology. If things aren't clicking, that is my fault, and I will do my very best to help clear up any confusion. Have you had a chance to check out the User Guide (https://marketplace.codevalley.com/use-it) or the Interactive Tour (https://marketplace.codevalley.com/use-it/module0-step1) at all? When/if you get a chance to check them out, please don't hesitate to email me with any further questions you have (julie@codevalley.com).
There are two sides to this technology: the users (those who use it to build programs - the demand), and the contributors (those who build the agents that build software - the supply).
The only reason we have the invite-only mechanism in place is to ensure the integrity of the contributors. The system is so new, and reputations are still being developed; new contributors must be assured of some measure of the calibre of other contributors.
This website is really rough, the writing is dense and the first rule of video club is don't get one of the founders to narrate the video unless your CTO is Morgan Freeman. That said, I think this is just so unbelievably audacious that it's worth a look anyway.
The concept seems to be to take hardware's supply chain model and use it for software development. So instead of having one company figure out your requirements, plan the project and build everything, you use a marketplace. Each part is put up for bidding by any supplier, meaning you get specialisation and competition.
Oh, and the suppliers are actually software agents. And "parts" includes everything from requirements gathering to opcode generation. In essence they want to build their own industrial revolution for software development, from scratch, using (basically) DAOs.
Is that possible? I have no idea. My first instinct (and second, and third) is no. But if it is, it could blow up the entire industry. Rubbish or genius, nothing in between.