Why agent is not a chain?

Question

In LangChain there are two concepts:

1. Chain
2. Agent

The proposed flow of using agent is:

prompt = SomePrompt()
llm_chain: Chain = LLMChain(prompt)
tools = [...]
agent: Agent = SomeAgent(llm_chain, tools)
agent_executor: Chain = AgentExecutor(agent)

What is the reason of making Agent as a separate class and not inheriting from Chain class?

Why do we need to wrap llm_chain: Chain inside agent: Agent inside agent_executor: Chain?

The expected architecture is:

class Agent(Chain):
   def _call(self, *args, **kwargs):
      while True:
         action = self.plan()
         if isinstance(action, ActionTool):
            self.run_tool(plan)
         elif isinstance(action, ActionFinish):
            return action.result

   def plan():
      # as it is done in actual implementation of Agent
      pass
          

But I can't understand the reason why did we separate the AgentExecutor and Agent

Answer 1

The answer may be as simple as this quote from the Agents documentation

The core idea of agents is to use a language model to choose a sequence of actions to take. In chains, a sequence of actions is hardcoded (in code). In agents, a language model is used as a reasoning engine to determine which actions to take and in which order. (source)

Answer 2

agent knows how to use chain. it is similar to chain, it still has input variables, memory, prompts, etc all the normal things a chain has. it can be formulated like this:

 agent= tool + chain

But I can't understand the reason why did we separate the AgentExecutor and Agent

The AgentExecutor serves as a wrapper or manager for the agent object. It provides a convenient interface for executing tasks or commands using the agent. The executor may handle additional functionalities such as logging, error handling, or verbosity control. if you visit the source code of agent_executor

    return_intermediate_steps: bool = False
    """Whether to return the agent's trajectory of intermediate steps
    at the end in addition to the final output."""
    max_iterations: Optional[int] = 15
    """The maximum number of steps to take before ending the execution
    loop.
    
    Setting to 'None' could lead to an infinite loop."""
    max_execution_time: Optional[float] = None
    """The maximum amount of wall clock time to spend in the execution
    loop.
    """
    early_stopping_method: str = "force"
    """The method to use for early stopping if the agent never
    returns `AgentFinish`. Either 'force' or 'generate'.

    `"force"` returns a string saying that it stopped because it met a
        time or iteration limit.
    
    `"generate"` calls the agent's LLM Chain one final time to generate
        a final answer based on the previous steps.
    """
    handle_parsing_errors: Union[
        bool, str, Callable[[OutputParserException], str]
    ] = False
    """How to handle errors raised by the agent's output parser.
    Defaults to `False`, which raises the error.
    If `true`, the error will be sent back to the LLM as an observation.
    If a string, the string itself will be sent to the LLM as an observation.
    If a callable function, the function will be called with the exception
     as an argument, and the result of that function will be passed to the agent
      as an observation.
    """

These properties offer configurable options for controlling the behavior of agents. Agent executor runs till there is no more function calls.