Agent

The Agent and what it is built from: its model settings, subagents, permissions, skills, secrets and redaction.

Guides: What an agent is, Configuring the agent, Secrets, Guardrails, Skills and Subagents.

class Agent(
    *,
    model: str,
    instructions: str | None = None,
    provider: str = 'mistral',
    name: str = 'default_agent',
    max_iterations: int | None = None,
    first_output_timeout_seconds: float | None = None,
    builtins: Builtins | None = None,
    permission_mode: PermissionMode = 'auto',
    permission_policy: PermissionPolicy | None = None,
    auto_compact_threshold: int | None = None,
    description: str | None = None,
    reasoning_effort: Literal['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] | None = None,
    temperature: float | None = None,
    output_type: type[BaseModel] | None = None,
    subagents: Sequence[Subagent] = (),
    subagent_policy: SubagentPolicy | None = None,
    tool_errors: Literal['hide', 'show', 'raise'] = 'hide',
    tools: Sequence[PythonTool[..., Any] | ClientTool[..., Any] | Callable[..., Any]] | None = None,
    environment: Sandbox | None = None,
    connectors: Sequence[Connector | AllConnectors] | None = None,
    mcps: dict[str, RemoteMCP] | None = None,
    skills: Sequence[LocalSkillBundle | RegistrySkill | SandboxWorkspaceSkills | AllRegistrySkills] | None = None,
    hooks: Sequence[Hook] | None = None,
    guardrails: Sequence[Hook] | None = None,
    secrets: Mapping[str, MistralSecret] | None = None,
    redaction: redaction.Redaction | None = None,
)

class Agent(
    *,
    model: str,
    instructions: str | None = None,
    provider: str = 'mistral',
    name: str = 'default_agent',
    max_iterations: int | None = None,
    first_output_timeout_seconds: float | None = None,
    builtins: Builtins | None = None,
    permission_mode: PermissionMode = 'auto',
    permission_policy: PermissionPolicy | None = None,
    auto_compact_threshold: int | None = None,
    description: str | None = None,
    reasoning_effort: Literal['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] | None = None,
    temperature: float | None = None,
    output_type: type[BaseModel] | None = None,
    subagents: Sequence[Subagent] = (),
    subagent_policy: SubagentPolicy | None = None,
    tool_errors: Literal['hide', 'show', 'raise'] = 'hide',
    tools: Sequence[PythonTool[..., Any] | ClientTool[..., Any] | Callable[..., Any]] | None = None,
    environment: Sandbox | None = None,
    connectors: Sequence[Connector | AllConnectors] | None = None,
    mcps: dict[str, RemoteMCP] | None = None,
    skills: Sequence[LocalSkillBundle | RegistrySkill | SandboxWorkspaceSkills | AllRegistrySkills] | None = None,
    hooks: Sequence[Hook] | None = None,
    guardrails: Sequence[Hook] | None = None,
    secrets: Mapping[str, MistralSecret] | None = None,
    redaction: redaction.Redaction | None = None,
)

An agent: a model and its instructions, with the tools, sandbox, connectors, MCP servers, skills, hooks and subagents it can use.

Agent.run() runs one turn in a new session, Agent.start_session() starts a session for many turns, and Agent.session(session_id) binds a handle to a session that exists. Agent.load_from() reaches an agent you deployed.

async def run(
    content: str | Sequence[TextContentBlock | ImageContentBlock | Mapping[str, Any]],
    *,
    output_type: type[BaseModel] | None = None,
    on_approval: ApprovalHandler | None = None,
    on_sign_in: Callable[[OpenSignIn], SignInAnswer | Awaitable[SignInAnswer]] | None = None,
    on_client_tool: Callable[[ClientToolCall], Any] | ClientToolAnswers | None = None,
    on_event: Callable[[Event], Awaitable[None] | None] | None = None,
    idempotency_key: str | None = None,
    timeout: float | None = None,
) -> TurnState[Any] | Busy

async def run(
    content: str | Sequence[TextContentBlock | ImageContentBlock | Mapping[str, Any]],
    *,
    output_type: type[BaseModel] | None = None,
    on_approval: ApprovalHandler | None = None,
    on_sign_in: Callable[[OpenSignIn], SignInAnswer | Awaitable[SignInAnswer]] | None = None,
    on_client_tool: Callable[[ClientToolCall], Any] | ClientToolAnswers | None = None,
    on_event: Callable[[Event], Awaitable[None] | None] | None = None,
    idempotency_key: str | None = None,
    timeout: float | None = None,
) -> TurnState[Any] | Busy

Start a session, run one turn in it, and return the turn's record.

The record is a value, never raised: Completed, Blocked, Interrupted, Failed, Running, or UnknownOutcome for an outcome added after your SDK version. With output_type=T, it is a TurnState[T]. Its session_id and turn_id reach the session and the turn again, as in agent.session(state.session_id).

On a deployed agent, output_type only parses the answer, and the model gets the deployed agent's format. output is InvalidOutput when the answer does not validate, and None when the turn ended early.

A callback with no handler for it, or one whose handler returns KeepCallbackOpen(), makes the run return Blocked. Answer it with agent.session(state.session_id).turn(state.turn_id).answer(cb.id, ...). An approval or sign-in handler that raises makes the run raise its error. An approval handler that returns anything else, None included, raises SdkError. A sign-in handler that returns None, KeepCallbackOpen(), or an answer that leaves a source out raises SdkError. A client tool answer that cannot be sent raises ClientToolAnswerError. In each case the callback stays open and the turn keeps running. A client tool answer or on_client_tool handler that raises follows the agent's tool_errors: by default the model reads that the call failed and the run goes on. With "raise", the run raises the error and the call stays open: the turn stays blocked on it, and the session takes no new turn, until the callback times out (one hour by default).

def override(*, model: testing.ScriptedModel) -> Self

def override(*, model: testing.ScriptedModel) -> Self

Return a copy of this agent that sends its model calls to model. This agent is unchanged.

Call it on a local agent: on a deployed agent, it raises SdkError.

async def start_session(
    *,
    history: Sequence[HistoryImportEntry] | None = None,
    session_inputs: Mapping[str, SessionInput] | None = None,
    agent: SessionAgentCustomization | Mapping[str, object] | None = None,
    idempotency_key: str | None = None,
    on_approval: ApprovalHandler | None = None,
    on_sign_in: Callable[[OpenSignIn], SignInAnswer | Awaitable[SignInAnswer]] | None = None,
    on_client_tool: Callable[[ClientToolCall], Any] | ClientToolAnswers | None = None,
) -> Session

async def start_session(
    *,
    history: Sequence[HistoryImportEntry] | None = None,
    session_inputs: Mapping[str, SessionInput] | None = None,
    agent: SessionAgentCustomization | Mapping[str, object] | None = None,
    idempotency_key: str | None = None,
    on_approval: ApprovalHandler | None = None,
    on_sign_in: Callable[[OpenSignIn], SignInAnswer | Awaitable[SignInAnswer]] | None = None,
    on_client_tool: Callable[[ClientToolCall], Any] | ClientToolAnswers | None = None,
) -> Session

Start a session and return its handle.

A local session runs in this process until its event loop shuts down, and its handle binds again only inside that event loop. A session of a deployed agent is kept by Mistral, and its handle binds again from any process.

A second call with the same idempotency_key and the same options returns the same session, even once it is running a turn or has ended. The same key with other session_inputs or agent, or from an agent with other settings such as permission_mode, raises agents.SessionIdempotencyConflictError; another history is not checked, and returns the first session. Generate the key once per request, for example as a UUID, and reuse it only on that request's retries.

The handlers stay in this process: they are not part of the start, so the same idempotency_key takes other ones. An answer to a stub that is not a tool of this agent, of its guardrails and hooks, or of its subagents raises SdkError before the start.

The handle keeps this agent's output_type: session.run(), turn.get() and turn.result() parse a Completed output with it when given none.

def session(
    session_id: str,
    *,
    on_approval: ApprovalHandler | None = None,
    on_sign_in: Callable[[OpenSignIn], SignInAnswer | Awaitable[SignInAnswer]] | None = None,
    on_client_tool: Callable[[ClientToolCall], Any] | ClientToolAnswers | None = None,
) -> Session

def session(
    session_id: str,
    *,
    on_approval: ApprovalHandler | None = None,
    on_sign_in: Callable[[OpenSignIn], SignInAnswer | Awaitable[SignInAnswer]] | None = None,
    on_client_tool: Callable[[ClientToolCall], Any] | ClientToolAnswers | None = None,
) -> Session

Return the handle of one of this agent's sessions by its ID. Sends no request.

For a deployed agent, an ID that is not a UUID raises SdkError at once. An unknown ID binds too: the first request through the handle raises SessionNotFoundError. The handle keeps this agent's output_type, as start_session()'s does. An answer to a stub that is not a tool of this agent, of its guardrails and hooks, or of its subagents raises SdkError here.

In an async with agents.local_runtime(journal_factory=...) block, a local session that an earlier process saved there reopens on the handle's first request, and keeps running in this process until the block exits. It must be a session of this agent: one with other tools, hooks, MCP servers, connectors or sandbox raises SessionConfigMismatchError, and one that another process holds open raises SessionInUseError.

@classmethod
def load_from(
    *,
    agent_name: str | None = None,
    agent_id: str | None = None,
    server_url: str | None = None,
    api_key: str | None = None,
    client: Client | None = None,
) -> Agent

@classmethod
def load_from(
    *,
    agent_name: str | None = None,
    agent_id: str | None = None,
    server_url: str | None = None,
    api_key: str | None = None,
    client: Client | None = None,
) -> Agent

Build a lazy handle to a deployed agent, by its name or its ID.

Pass exactly one of agent_name or agent_id, of an agent deployed with Studio, self-hosted or Mistral-managed. To continue a session, bind a handle to it with .session(session_id).

Without client, server_url and api_key build one with no shared connection pool: each session then opens its own, which closes with the session and serves the event loop that opened it. Pass either client or them, not both.

class Builtins(
    *,
    skills: bool = True,
    subagents: bool = True,
    programmatic_tool_calling: bool | ProgrammaticToolCallingConfig = True,
    background_processes: bool | None = None,
)

class Builtins(
    *,
    skills: bool = True,
    subagents: bool = True,
    programmatic_tool_calling: bool | ProgrammaticToolCallingConfig = True,
    background_processes: bool | None = None,
)

Built-in features of the agent. Everything is on by default; set a field to False to opt out.

File and shell tools are not here: they come from the sandbox access level.

@classmethod
def none() -> Self

@classmethod
def none() -> Self

No built-in features. With the default NoSandbox, the model sees only your tools.

A sandbox still gives the file and shell tools its access level allows.

class ProgrammaticToolCallingConfig(*, sleep: bool = True)

class ProgrammaticToolCallingConfig(*, sleep: bool = True)

Options of programmatic tool calling. Passing them turns the feature on.

class SessionAgentCustomization(
    *,
    additional_instructions: str = '',
    model: str | None = None,
    reasoning_effort: Literal['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] | None = None,
)

class SessionAgentCustomization(
    *,
    additional_instructions: str = '',
    model: str | None = None,
    reasoning_effort: Literal['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] | None = None,
)

Per-session overrides of an agent's settings: the agent= of Agent.start_session.

additional_instructions append to the agent's instructions; model and reasoning_effort override its completion defaults. A field left out keeps the agent's value; None for model or reasoning_effort and unknown keys raise a validation error. agent= also takes the same keys as a dict.

class Subagent(
    *,
    name: str,
    description: str,
    instructions: str,
    model: str | None = None,
    provider: str | None = None,
    reasoning_effort: Literal['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] | None = None,
    temperature: float | None = None,
    max_iterations: int | None = None,
    first_output_timeout_seconds: float | None = None,
    auto_compact_threshold: int | None = None,
    tools: Sequence[PythonTool[..., Any] | ClientTool[..., Any] | Callable[..., Any]] | None = None,
    hooks: Sequence[Hook] | None = None,
    mcps: Mapping[str, RemoteMCP] | None = None,
    connectors: Sequence[Connector | AllConnectors] | None = None,
    skills: Sequence[LocalSkillBundle | RegistrySkill] | None = None,
    subagents: Sequence[Subagent] | None = None,
    builtins: Builtins | None = None,
    sandbox_access: Literal['none', 'files', 'full'] | None = None,
)

class Subagent(
    *,
    name: str,
    description: str,
    instructions: str,
    model: str | None = None,
    provider: str | None = None,
    reasoning_effort: Literal['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] | None = None,
    temperature: float | None = None,
    max_iterations: int | None = None,
    first_output_timeout_seconds: float | None = None,
    auto_compact_threshold: int | None = None,
    tools: Sequence[PythonTool[..., Any] | ClientTool[..., Any] | Callable[..., Any]] | None = None,
    hooks: Sequence[Hook] | None = None,
    mcps: Mapping[str, RemoteMCP] | None = None,
    connectors: Sequence[Connector | AllConnectors] | None = None,
    skills: Sequence[LocalSkillBundle | RegistrySkill] | None = None,
    subagents: Sequence[Subagent] | None = None,
    builtins: Builtins | None = None,
    sandbox_access: Literal['none', 'files', 'full'] | None = None,
)

A child agent that its parent starts with the agents.spawn tool.

A subagent runs in its own session, below its parent's, as the user who started the root session. It uses the parent's value for every field you leave as None. A field you set replaces the parent's value, and an empty list gives the subagent none: nothing is merged.

model, reasoning_effort and temperature follow the same rules as on agents.Agent. provider needs model too. The parent's output_type never reaches a subagent: its result is its final answer.

A subagent always runs under the root agent's permission policy and mode. To make it stricter, give it fewer tools.

A subagent can have tools and hooks that its parent does not have. Their functions run where the parent's run. Tool names are shared by the whole tree, so two different functions cannot have the same name anywhere in it.

Connectors: connectors=[] gives the subagent none. A list takes the same items as Agent(connectors=...): agents.connector(...) gives it exactly those connectors, and agents.all_connectors(...) gives it every connector the user can use.

builtins is the one field that merges: each field you set in agents.Builtins(...) replaces the parent's value, and each field you leave out keeps it. For example, agents.Builtins(skills=False) turns off only skills. Turning off programmatic_tool_calling also needs subagents=False. A subagent that sets its own skills or subagents needs that built-in on. sandbox_access sets the subagent's access to the sandbox the whole tree shares; a tree with no sandbox takes only "none".

skills takes local bundles and registry skills. On a sandbox that holds files, a subagent's own skills are written into it when the subagent starts. agents.all_registry_skills() is for the root agent only: a subagent that leaves skills unset uses the root's skills.

To add a tool to the parent's, pass the parent's list and the child's extended list:

BASE = [lookup, search]
agent = agents.Agent(
    model="mistral-large-4",
    tools=BASE,
    subagents=[
        agents.Subagent(
            name="deployer",
            description="Deploys a reviewed build.",
            instructions="Deploy only what you are asked to deploy.",
            tools=[*BASE, deploy],
        )
    ],
)

BASE = [lookup, search]
agent = agents.Agent(
    model="mistral-large-4",
    tools=BASE,
    subagents=[
        agents.Subagent(
            name="deployer",
            description="Deploys a reviewed build.",
            instructions="Deploy only what you are asked to deploy.",
            tools=[*BASE, deploy],
        )
    ],
)

class SubagentPolicy(
    *,
    concurrent_child_turn_limit: int = 10,
    max_depth: int = 2,
    idle_message_starts: Literal['direct_children', 'none'] = 'direct_children',
)

class SubagentPolicy(
    *,
    concurrent_child_turn_limit: int = 10,
    max_depth: int = 2,
    idle_message_starts: Literal['direct_children', 'none'] = 'direct_children',
)

Limits on the subagents of one session tree: the root session and every subagent below it.

Pass it as Agent(subagent_policy=...). The root agent's policy applies to every subagent below it, and a subagent cannot raise it. An agent that has subagents and no policy gets the defaults below.

PermissionMode = Literal['auto', 'ask', 'deny']

PermissionMode = Literal['auto', 'ask', 'deny']

Which tool calls need an approval: "auto" runs every call that the agent's permission_policy allows (every call without one), "ask" opens an approval for each call, and "deny" refuses them.

class PermissionPolicy(
    *,
    default: Literal['allow', 'deny', 'ask'],
    rules: tuple[PermissionRule, ...] = (),
)

class PermissionPolicy(
    *,
    default: Literal['allow', 'deny', 'ask'],
    rules: tuple[PermissionRule, ...] = (),
)

Ordered permission rules and the fallback for calls that match no rule.

class PermissionRule(
    *,
    tools: tuple[str, ...],
    decision: Literal['allow', 'deny', 'ask'],
    allowlist: tuple[str, ...] = (),
    denylist: tuple[str, ...] = (),
    sensitive: tuple[str, ...] = (),
)

class PermissionRule(
    *,
    tools: tuple[str, ...],
    decision: Literal['allow', 'deny', 'ask'],
    allowlist: tuple[str, ...] = (),
    denylist: tuple[str, ...] = (),
    sensitive: tuple[str, ...] = (),
)

Whether calls of the tools that match tools run, ask for an approval or are refused.

A policy applies the first rule whose tools match the call's stable tool ID, such as client.deploy_service, not the name the model sees; a call that matches no rule gets the policy's default. In the rule that applies:

1. A denylist pattern matches: deny.
2. A sensitive pattern matches: ask.
3. allowlist is not empty: allow if a pattern matches, otherwise ask.
4. Otherwise: the rule's decision.

Patterns are case-sensitive globs that match the whole text. Argument patterns match the call's arguments as JSON with sorted keys, with or without a space after : and ,, such as '*"environment": "production"*'. A tools pattern with no namespace and no wildcard, such as deploy_service, matches no tool, so it raises ValueError.

class RegistrySkill(*, id: UUID, version: int | None = None)

class RegistrySkill(*, id: UUID, version: int | None = None)

One skill from your workspace's AI Registry, by ID and optional version.

class AllRegistrySkills()

class AllRegistrySkills()

Every skill of your workspace's AI Registry, as of the root session's start.

agents.all_registry_skills() returns it.

def agents.all_registry_skills() -> AllRegistrySkills

def agents.all_registry_skills() -> AllRegistrySkills

Give the agent every skill of your workspace's AI Registry.

A deployed agent gets the skills that the user who starts the session can use. A local session uses your Mistral API key. The versions are fixed when the session starts, and each skill downloads the first time the agent uses it. A RegistrySkill in the same list keeps its own version.

class SandboxWorkspaceSkills(
    *,
    root: str | None = None,
    dirs: tuple[str, ...] = ('.agents/skills', '.vibe/skills'),
)

class SandboxWorkspaceSkills(
    *,
    root: str | None = None,
    dirs: tuple[str, ...] = ('.agents/skills', '.vibe/skills'),
)

Serve the skills already in the sandbox, such as those of a repository a sandbox hook cloned.

The SDK looks for them once, after the sandbox hooks ran and before the first turn. A skill is a folder with a SKILL.md under one of dirs, in root or in a repository directly below it.

class LocalSkillBundle(*, files: list[LocalSkillFile] = [])

class LocalSkillBundle(*, files: list[LocalSkillFile] = [])

A skill that the agent carries with it: the files of a skill folder on your machine.

Build one with LocalSkillBundle.from_directory(path).

@classmethod
def from_directory(path: str | Path) -> Self

@classmethod
def from_directory(path: str | Path) -> Self

Bundle a skill directory: its SKILL.md and every asset beside it.

class LocalSkillFile(*, path: str, content_base64: str, executable: bool = False)

class LocalSkillFile(*, path: str, content_base64: str, executable: bool = False)

One file of a LocalSkillBundle.

class MistralSecret(*, ref: str | None = None, worker_env: bool = False)

class MistralSecret(*, ref: str | None = None, worker_env: bool = False)

A secret of the Mistral Secret Manager.

Build it with MistralSecret.workspace(NAME), or leave the reference out with MistralSecret() and bind it at deploy time with agents deploy --secret-binding NAME=secret:workspace:..., which also overrides a reference. worker_env=True also sets the secret as an environment variable where your Python tools run, so they can read it; without it, the secret reaches only the destinations that name it.

@classmethod
def workspace(name: str, *, worker_env: bool = False) -> Self

@classmethod
def workspace(name: str, *, worker_env: bool = False) -> Self

The workspace secret name of the Secret Manager.

type Redaction = (
    redaction.RedactionPolicy
    | list[redaction.RedactionPolicy]
    | tuple[redaction.RedactionPolicy, ...]
)

type Redaction = (
    redaction.RedactionPolicy
    | list[redaction.RedactionPolicy]
    | tuple[redaction.RedactionPolicy, ...]
)

What Agent(redaction=...) takes: one RedactionPolicy or a list of them, applied in order. [] turns redaction off.

type RedactionPolicy = (
    OperationDataTransformer
    | Callable[[str, OperationDataValue], OperationDataValue | None]
)

type RedactionPolicy = (
    OperationDataTransformer
    | Callable[[str, OperationDataValue], OperationDataValue | None]
)

One way the agent's traces mask secrets and personal data: a redaction policy or a (key, value) function.

OperationDataTransformer is what a redaction policy is, such as RegexRedactionPolicy: an object whose transform method returns the value to record, or None to drop it. OperationDataValue is a trace field's value: a string, a number, a boolean, bytes, None, or a list or a mapping of these.

class RegexRedactionPolicy(
    patterns: Sequence[Pattern[str]] = redaction.DEFAULT_PII_SECRET_PATTERNS,
    *,
    safe_keys: frozenset[str] = redaction.DEFAULT_SAFE_ATTRIBUTE_KEYS,
    safe_key_patterns: Sequence[Pattern[str]] = redaction.DEFAULT_TOKEN_PATTERNS,
    redacted_value: str = '[REDACTED]',
)

class RegexRedactionPolicy(
    patterns: Sequence[Pattern[str]] = redaction.DEFAULT_PII_SECRET_PATTERNS,
    *,
    safe_keys: frozenset[str] = redaction.DEFAULT_SAFE_ATTRIBUTE_KEYS,
    safe_key_patterns: Sequence[Pattern[str]] = redaction.DEFAULT_TOKEN_PATTERNS,
    redacted_value: str = '[REDACTED]',
)

Replaces the matches of patterns, such as API keys, email addresses and card numbers, with [REDACTED] in the agent's traces. The values of safe keys are scanned with safe_key_patterns only.

class AttributeRedactionPolicy(
    *,
    sensitive_keys: frozenset[str] = redaction.DEFAULT_SENSITIVE_ATTRIBUTE_KEYS,
    safe_keys: frozenset[str] = redaction.DEFAULT_SAFE_ATTRIBUTE_KEYS,
    sensitive_fragments: frozenset[str] = redaction.DEFAULT_SENSITIVE_ATTRIBUTE_FRAGMENTS,
    token_patterns: Sequence[Pattern[str]] = redaction.DEFAULT_TOKEN_PATTERNS,
    redact_non_primitive: bool = True,
    redacted_value: str = '[REDACTED]',
)

class AttributeRedactionPolicy(
    *,
    sensitive_keys: frozenset[str] = redaction.DEFAULT_SENSITIVE_ATTRIBUTE_KEYS,
    safe_keys: frozenset[str] = redaction.DEFAULT_SAFE_ATTRIBUTE_KEYS,
    sensitive_fragments: frozenset[str] = redaction.DEFAULT_SENSITIVE_ATTRIBUTE_FRAGMENTS,
    token_patterns: Sequence[Pattern[str]] = redaction.DEFAULT_TOKEN_PATTERNS,
    redact_non_primitive: bool = True,
    redacted_value: str = '[REDACTED]',
)

Redacts the values of sensitive trace fields whole, such as messages and tool arguments, and replaces tokens in the values it keeps.

class CallbackRedactionPolicy(
    mask_function: redaction.AttributeMaskCallback,
    *,
    recursive: bool = False,
)

class CallbackRedactionPolicy(
    mask_function: redaction.AttributeMaskCallback,
    *,
    recursive: bool = False,
)

Redacts with your function: it gets each field's key and value and returns the value to keep, or None to drop the field.

With recursive=True, the function gets each leaf of a structured value, such as the text of every message, with the field's name as key. Returning None then drops that leaf only.

type AttributeMaskCallback = Callable[[str, OperationDataValue], OperationDataValue | None]

type AttributeMaskCallback = Callable[[str, OperationDataValue], OperationDataValue | None]

A redaction function: it gets a field's key and value and returns the value to keep, or None to drop the field.