julie_lovisa
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.
> 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.)
* Conceptual vs actual expression of an agent that will compile code that clears a string - https://www.youtube.com/watch?v=MlwjHQQgNRQ (voiceover)
* Actual expression of an agent that will compile code that computes an exponentiation result - https://www.youtube.com/watch?v=Fmwcs1fu6wM (no voiceover)
* Actual expression of an agent that will compile code that adds a bit to a bit array - https://www.youtube.com/watch?v=RCg8cOZyADE (voiceover)
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.
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).
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.
You can build it to run on Linux (https://marketplace.codevalley.com/pilot.html#linux-fibonacc...), or to run in a browser (https://marketplace.codevalley.com/pilot.html#browser-fibona...). You will need to pay a few satoshis (to the agents you will be contracting), and if you don't have a bitcoin wallet, just shoot me an email ([email protected]) and I'll foot the 50c for you :).
edit: added clarification
The User side of things does not require a login. You can learn more about how to use the technology in the User Guide (https://marketplace.codevalley.com/use-it) and in the Interactive Tour (https://marketplace.codevalley.com/use-it/module0-step1). If you pick that up pretty quickly, you can request an invite to join the other side and become an agent builder (https://marketplace.codevalley.com/signup).
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.
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).