And very briefly, as I promised, I want to show you what it looks like if we restart everything.
And now we go through and we put all on one worker as false, what does this mean exactly?
So we are going to, of course, have the same message, the same hosted, uh, the same host that we
start running on localhost at 551.
And we use the same tools, the same instructions, we make the same agents.
Our agent code isn't touched, but now it's going to be managed differently.
We're now going to run this and we're going to be following this line right here.
And this is actually going to create three different runtimes that I'm calling worker one, worker two,
and worker and just worker for the third one.
Uh, the judges one.
And we're going to start each of these three, uh, gRPC worker runtimes.
And then player one, we're going to register with worker one, player two with worker two.
And the judge uh, with just the one that's just called worker.
And so that is happening.
And so what's the difference here.
What we're saying is that instead of having, instead of having our three agents running in a remote
worker on on our remote host, we now have three workers, and the three workers are each running one
of our agents.
So they're now in different runtimes.
They're all on the same host.
But you could imagine that this is now they're completely separate.
This is something where things are interacting between runtimes.
And so now we send the same go message.
And presumably very similar messages are now crossing the ether.
One agent is calling Gpt4 on many for the pros, one agent for the cons.
And then as a result of that they will come back to the to the judge.
And the judge has come I will we see pretty similar looking pros.
The community and support is a new one.
I think scalability is now put first the cons, um, limited customization that seems to slightly fly
in the face of flexibility I guess our agents disagree.
Uh, performance variability, cost considerations and ethical and content control.
Okay.
Uh, but nonetheless, the recommendation is to proceed.
That is the view of even even when we distribute across multiple workers, it does still maintain that
viewpoint.
Uh, so there we go.
That the example I wanted to show you, I know we've gone through it quickly, but it's just to get
that sense that the powerful thing about this is that without changing your, your, your code with
the same definitions of your classes, these can be running in different configurations and different
kinds of runtimes.
And basically, uh, the what Autogen is doing is it's handling message calling across process boundaries
as transparently as if these were just simply classes with, with, uh, with methods calling each other
directly in Python code, that abstraction is what it's doing.
And when you think about a future when potentially there could be, uh, millions or maybe even Billions
of agents interacting all over the place.
What Microsoft is doing is putting their stake in the ground for this.
This is a sort of playpen.
This is a world where agents can live and interact.
You just put your agent code within this wrapper, this agent wrapper, you make your versions of message,
uh, the that that you declare the way that we have.
And then your agents can interact with each other, no matter where they are in the world, and no matter
what programming language they're written in.
And with that, that brings us to the end of day four.
It means we're getting on to day five.
And in the spirit of the other things we've done this week, the project is going to be some something
that's more a sort of an idea.
It's more something to tease out some thinking, to give you some some insights.
It's not as much of a kind of commercial banger, perhaps, as the prior week, which is really great,
but I think it will intrigue you in new ways.
And a lot of what we've been doing with Autogen is about stretching what you think might be possible,
and that will be the plan for tomorrow.
And I can't wait to show it to you.