And welcome to week five, day four.
We're going to talk more about Autogen core.
You remember Autogen core, the fundamental the bottom layer of the stack for Autogen.
And it's an interaction framework.
It's responsible for worrying about how agents play together.
It doesn't care about how the agents are implemented, although it works well with with agent chat.
It's somewhat analogous to landgraaf, but except rather than focusing on repeatable workflows, it's
focused on the interactions between diverse agents.
And in particular, we talked about two different types of runtime the standalone.
The distributed.
Last time we talked about standalone today we're looking at distributed runtimes.
It's going to be even higher level than last time.
And it's just to give you that flavor.
And I should also point out that Microsoft says that that the distributed runtime is still experimental
and the APIs are liable to change at any point.
So it should be taken in that light.
It's not actually ready for a production system yet, but it's more of an architecture and idea and
an exciting, uh, idea in terms of future possibilities and the distributed runtime itself that we're
going to look at right now, uh, is really it's described as something which handles processes, handles
the messaging across process boundaries.
That's the idea.
It's no longer a single threaded thing running on our machine.
It's something that can run across different processes that might not be Python processes.
They could be anything.
And it consists of two different things, two different components to it.
One of them is called the host service, and that is the sort of container that runs this.
And it connects to a worker runtime or potentially many worker runtimes.
And it handles the delivery and it handles sessions for direct messages, direct messages that are going
to be handled by gRPC if you're familiar with that technology.
Remote procedure calls and it's going to handle the session management around that.
All of the nuts and bolts of the infrastructure around the complicated business of sending a message
remotely from one computer to another, from one process to another, that'll be taken care of by the
framework.
And then the other concept here is a worker runtime, that is the runtime that we'll be able to treat
much as we treated the runtime in the single threaded case.
And it will be able to manage different agents.
It will have different agents that are that are registered with it.
It will advertise the agents it's got to its host servers.
So the host service knows what it's got and it will actually handle, of course executing the code the
worker runtime has the agents, which themselves are delegates for something that that does something,
and that will be handled by the worker runtime so that that's how it fits together.
But it's going to be more concrete when I show it to you, which I'll do right now.