类的骨架（crew.py:159）：

# crew.py:159
class Crew(FlowTrackable, BaseModel):
    """Represents a group of agents, defining how they should collaborate
    and the tasks they should perform."""

    entity_type: Literal["crew"] = "crew"          # 实体类型标记
    __hash__ = object.__hash__                      # 用对象身份做 hash

    # —— 私有属性（用户不可传，框架运行时填）——
    _rpm_controller: RPMController = PrivateAttr()
    _memory: Memory | MemoryScope | MemorySlice | None = PrivateAttr(default=None)
    _train: bool | None = PrivateAttr(default=False)
    _inputs: dict[str, Any] | None = PrivateAttr(default=None)
    _kickoff_event_id: str | None = PrivateAttr(default=None)

    # —— 公开字段（用户可传）——
    name: str | None = Field(default="crew")
    tasks: list[Task] = Field(default_factory=list)
    agents: Annotated[list[BaseAgent], BeforeValidator(_resolve_agents)] = Field(default_factory=list)
    process: Process = Field(default=Process.sequential)
    ...                                             # 后面几十个字段今天逐类看

身份相关字段（crew.py:198 起）与两个计算属性：

# crew.py:198
entity_type: Literal["crew"] = "crew"      # 固定为 "crew"，序列化/事件里用它区分实体
name: str | None = Field(default="crew")   # 团队名，日志/记忆命名空间会用到
id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)   # 随机 UUID，frozen 不可改

# crew.py:857  计算属性：内容指纹（不是随机的，由成员内容决定）
@property
def key(self) -> str:
    source = [agent.key for agent in self.agents] + [task.key for task in self.tasks]
    return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()

# crew.py:864  安全指纹（来自 security_config）
@property
def fingerprint(self) -> Fingerprint:
    return self.security_config.fingerprint

没有它们仨就没有 crew（crew.py:220）：

# crew.py:220
tasks: list[Task] = Field(default_factory=list)
agents: Annotated[
    list[BaseAgent],
    BeforeValidator(_resolve_agents),      # 传进来先过一道"解析"
] = Field(default_factory=list)
process: Process = Field(default=Process.sequential)   # 默认顺序流程

初学最懵的就是这堆 LLM 字段（crew.py:248 起，节选）：

# crew.py:248
manager_llm: Annotated[str | BaseLLM | None, BeforeValidator(_validate_llm_ref), ...] = \
    Field(description="Language model that will run the agent.", default=None)
manager_agent: Annotated[BaseAgent | None, BeforeValidator(_resolve_agent)] = \
    Field(description="Custom agent that will be used as manager.", default=None)
function_calling_llm: Annotated[str | LLM | None, ...] = Field(
    default=None,
    deprecated="function_calling_llm is deprecated ...")      # 已弃用
# crew.py:322
planning_llm: Annotated[str | BaseLLM | None, ...] = Field(
    default=None,
    description="Language model that will run the AgentPlanner if planning is True.")
chat_llm: Annotated[str | BaseLLM | None, ...] = Field(
    default=None, description="LLM used to handle chatting with the crew.")

一堆布尔/配置开关，其中 memory 最有意思（crew.py:225）：

# crew.py:218
cache: bool = Field(default=True)                    # 工具结果缓存，默认开
verbose: bool = Field(default=False)                 # 详细日志
# crew.py:225  memory 不是简单 bool！
memory: Annotated[
    bool
    | Annotated[Memory | MemoryScope | MemorySlice, Field(discriminator="memory_kind")]
    | None,
    BeforeValidator(_ensure_memory_kind),
] = Field(default=False, description=(
    "Enable crew memory. Pass True for default Memory(), "
    "or a Memory/MemoryScope/MemorySlice instance for custom configuration."))
# crew.py:300
max_rpm: int | None = Field(default=None)            # 每分钟最大请求数（限流）
# crew.py:318
planning: bool | None = Field(default=False,
    description="Plan the crew execution and add the plan to the crew.")

让你在执行的关键点"插一脚"（crew.py:270 起）：

# crew.py:270
step_callback: SerializableCallable | None = Field(default=None,
    description="Callback to be executed after each step for all agents execution.")
task_callback: SerializableCallable | None = Field(default=None,
    description="Callback to be executed after each task for every agents execution.")
before_kickoff_callbacks: list[SerializableCallable] = Field(default_factory=list,
    description="List of callbacks to be executed before crew kickoff. "
                "It may be used to adjust inputs before the crew is executed.")
after_kickoff_callbacks: list[SerializableCallable] = Field(default_factory=list,
    description="List of callbacks to be executed after crew kickoff. "
                "It may be used to adjust the output of the crew.")

# crew.py:397  校验器：把 None 从回调列表里过滤掉
@field_validator("before_kickoff_callbacks", "after_kickoff_callbacks", mode="before")
@classmethod
def _drop_unresolvable_callbacks(cls, value: Any) -> Any:
    if isinstance(value, list):
        return [v for v in value if v is not None]
    return value

私有属性（用户不可传）与几个关键 @model_validator：

# crew.py:603  实例化后：填私有属性、建限流器
@model_validator(mode="after")
def set_private_attrs(self) -> Crew:
    if not getattr(self, "_cache_handler", None):
        self._cache_handler = CacheHandler()
    ...
    self._logger = Logger(verbose=self.verbose)
    self._rpm_controller = RPMController(max_rpm=self.max_rpm, logger=self._logger)
    return self

# crew.py:696  层级流程必须有 manager
@model_validator(mode="after")
def check_manager_llm(self) -> Self:
    if self.process == Process.hierarchical:
        if not self.manager_llm and not self.manager_agent:
            raise PydanticCustomError("missing_manager_llm_or_manager_agent",
                "Attribute `manager_llm` or `manager_agent` is required "
                "when using hierarchical process.", {})
        if (self.manager_agent is not None) and (self.agents.count(self.manager_agent) > 0):
            raise PydanticCustomError("manager_agent_in_agents",
                "Manager agent should not be included in agents list.", {})
    return self

# crew.py:741  顺序流程每个 task 必须绑定 agent
@model_validator(mode="after")
def validate_tasks(self) -> Self:
    if self.process == Process.sequential:
        for task in self.tasks:
            if task.agent is None:
                raise PydanticCustomError("missing_agent_in_task",
                    "Sequential process error: Agent is missing in the task ...", {})
    return self