WEBVTT

00:00.200 --> 00:02.800
And welcome to week five, day four.

00:02.960 --> 00:05.120
We're going to talk more about Autogen core.

00:05.680 --> 00:11.040
You remember Autogen core, the fundamental the bottom layer of the stack for Autogen.

00:11.320 --> 00:13.280
And it's an interaction framework.

00:13.280 --> 00:17.320
It's responsible for worrying about how agents play together.

00:17.360 --> 00:22.360
It doesn't care about how the agents are implemented, although it works well with with agent chat.

00:22.800 --> 00:30.120
It's somewhat analogous to landgraaf, but except rather than focusing on repeatable workflows, it's

00:30.120 --> 00:33.760
focused on the interactions between diverse agents.

00:34.840 --> 00:38.640
And in particular, we talked about two different types of runtime the standalone.

00:38.680 --> 00:39.680
The distributed.

00:40.040 --> 00:45.080
Last time we talked about standalone today we're looking at distributed runtimes.

00:45.120 --> 00:47.560
It's going to be even higher level than last time.

00:47.760 --> 00:49.960
And it's just to give you that flavor.

00:49.960 --> 00:55.480
And I should also point out that Microsoft says that that the distributed runtime is still experimental

00:55.480 --> 00:58.320
and the APIs are liable to change at any point.

00:58.320 --> 00:59.520
So it should be taken in that light.

00:59.520 --> 01:05.280
It's not actually ready for a production system yet, but it's more of an architecture and idea and

01:05.280 --> 01:12.120
an exciting, uh, idea in terms of future possibilities and the distributed runtime itself that we're

01:12.120 --> 01:19.840
going to look at right now, uh, is really it's described as something which handles processes, handles

01:19.840 --> 01:22.960
the messaging across process boundaries.

01:23.120 --> 01:24.240
That's the idea.

01:24.240 --> 01:27.680
It's no longer a single threaded thing running on our machine.

01:27.680 --> 01:32.840
It's something that can run across different processes that might not be Python processes.

01:32.840 --> 01:33.880
They could be anything.

01:34.160 --> 01:39.160
And it consists of two different things, two different components to it.

01:39.360 --> 01:46.080
One of them is called the host service, and that is the sort of container that runs this.

01:46.200 --> 01:51.880
And it connects to a worker runtime or potentially many worker runtimes.

01:51.880 --> 01:58.080
And it handles the delivery and it handles sessions for direct messages, direct messages that are going

01:58.120 --> 02:01.590
to be handled by gRPC if you're familiar with that technology.

02:01.790 --> 02:05.750
Remote procedure calls and it's going to handle the session management around that.

02:05.750 --> 02:11.350
All of the nuts and bolts of the infrastructure around the complicated business of sending a message

02:11.350 --> 02:16.990
remotely from one computer to another, from one process to another, that'll be taken care of by the

02:16.990 --> 02:17.790
framework.

02:18.190 --> 02:23.990
And then the other concept here is a worker runtime, that is the runtime that we'll be able to treat

02:23.990 --> 02:27.270
much as we treated the runtime in the single threaded case.

02:27.390 --> 02:29.870
And it will be able to manage different agents.

02:29.870 --> 02:33.030
It will have different agents that are that are registered with it.

02:33.070 --> 02:36.870
It will advertise the agents it's got to its host servers.

02:36.870 --> 02:43.350
So the host service knows what it's got and it will actually handle, of course executing the code the

02:43.390 --> 02:48.910
worker runtime has the agents, which themselves are delegates for something that that does something,

02:49.550 --> 02:56.630
and that will be handled by the worker runtime so that that's how it fits together.

02:56.630 --> 02:59.950
But it's going to be more concrete when I show it to you, which I'll do right now.
