There's some basic terminology we should define, just to avoid confusion.
Like: What's the difference between an agent and a server? Or a manager and an agent? Or a server and a service?
Hopefully, the definitions that follow should clear it all up.
A client is a process that sends out requests, and receives responses to those requests. A client usually has a graphical user interface, but sometimes it may not. If it does, the requests it sends out will be as a result of something the user has input, or clicked on. The responses it receives will typically be displayed on the screen.
A server is a process that receives requests from a client, and processes the request in order to send back one or more responses. The data that makes up the response is usually obtained from some source of data like a database, but it could be calculated or cached in memory. Sometimes, the server simply acts as a data router, in which case it's called a ...
A forwarding server receives requests just like a regular server, but does minimal processing of the request. It will forward the request to another server, possibly determined by the content of a field in the request (this is sometimes called data dependent routing; or it may be operating as a load balancer, distributing incoming requests across a number of identical servers. In any case, the responses will not return to the client through the forwarding server - the ultimate server will reply directly to the client.
And sometimes a server may not be able to satisfy a request on its own, but has to enlist the aid of one or more other servers. In this case, it's called a ...
A hybrid server receives incoming requests just like a regular server, but is not able to satisfy those requests entirely on its own. It will send out requests to one or more other servers, and re-package the responses that come back to be sent back to the client.
Note that the reason it's called a hybrid is because it's part server and part client. As far as the original client is concerned, it's a server (and the client, of course, is blissfully unaware of what's going on "behind the scenes"); but as far as its subordinate servers are concerned, it's a client. A chameleon, indeed!
An agent is an object within a server. An agent will handle incoming requests for one service, and one service only. Very often, a server will contain only one agent, and that's why the terms server and agent are sometimes used interchangeably.
There's no reason why a server can't contain multiple agents, however. And it could be that each of those agents handle the same service, or perhaps each different agent could handle a different service. In the latter case, the server would be capable of providing more than one service - this would be unusual, though.
A manager is a proxy for the agent. It's the client's interface with the agent, and shields the client from the distributed nature of the service. Like the agent, it is an object, but this time inside the client. Each agent will have a paired manager, and, unlike the agent, it is common for a client to contain multiple managers. It will certainly contain a different manager for each different service that it needs to send requests to, but will also most likely contain multiple managers for the same service. This is because, in ObjectQ's paradigm, one manager is responsible for handling one request and its associated responses. That means, for example, that to send out two requests to the same service, and then wait for the responses (this is called sending out requests asynchronously), the client must create two managers.
A service is an abstract definition of the data and operations that are available across a number of grouped object classes. It is made concrete by implementation as one or more identical servers containing the agents that process incoming requests.
A service is defined by a Management Information Base, or MIB, which specifies precisely what data elements, and what methods (or actions, in ObjectQ's terminology), are available to prospective clients.