Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description discloses one important behavioral trait: the operation mutates the instrument 'in place'. It also explains the exclude default. However, it omits other behavioral context such as failure conditions, object requirements, or whether the original data is recoverable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is tightly written with no filler: the purpose verb is front-loaded, and the exclude note earns its place. It is appropriately concise for what it covers.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and a nontrivial MNE operation, the description is incomplete: it doesn't state that ICA must be fitted first, that ica_name/inst_name refer to session objects, or what happens when the objects are incompatible. The output schema existing does not make up for missing prerequisites and side-effect context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must explain the parameters. It does explain 'exclude' well (format and fallback), but says nothing about ica_name or inst_name, leaving two of three parameters to be inferred from their defaults and names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific operation ('Remove ICA components from an instrument in place') with a clear resource and mutation sense. It is distinguishable from siblings like mne_fit_ica and mne_plot_ica_components, though it does not explicitly name any sibling or mention that it applies an already-fitted ICA.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives, and no prerequisites are stated (e.g., that a fitted ICA object must already exist). The only usage-like detail is the exclude fallback, which is parameter behavior rather than tool-selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the behavioral burden. It does so reasonably well by stating that the tool 'Stores the source estimate (stc)' and 'reports the peak activation time,' which discloses the main side effect and output beyond the schema. It does not mention overwriting an existing stc with the same name or computational cost, but the central behavioral contract is explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each carrying distinct information: the operation and inputs, method options, storage/report behavior, and pipeline partners. There is no filler or repetition of schema defaults.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description establishes the pipeline role, method choices, and default result variable, but for a 6-parameter, annotation-free tool it leaves gaps: what snr controls, whether an existing stc is overwritten, and how the result feeds mne_plot_source_estimate are not stated. An agent can invoke it with defaults, but not with full contextual confidence.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only method and stc receive meaningful explanation: method gets its value list, and stc is identified as the stored source estimate. The remaining parameters—snr, cov_name, fwd_name, and evoked_name—are left to name-based inference. With 0% schema description coverage, this is insufficient compensation for the input schema's lack of descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The opening clause 'Estimate cortical sources from an Evoked using a forward model and noise covariance' names a specific verb, object, and data dependencies, clearly distinguishing it from siblings like mne_plot_source_estimate or mne_apply_ica. It also lists the supported methods and the stored result, so the agent knows exactly what the tool acts on.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The final sentence gives an explicit pipeline cue: 'Pair with mne_make_forward + mne_compute_noise_cov,' telling the agent which prerequisites must exist before invocation. It does not list exclusions or alternative tools for the same job, so it stops short of full when/when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It reveals that it averages all conditions by default if no condition is given, and stores under evoked_name. However, it doesn't mention side effects like overwriting existing evoked data or requiring specific prerequisites (e.g., epochs must exist).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short and front-loads the main action. Each sentence earns its place, though the second sentence about parameters could be more detailed without bloating.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists, return values are covered. However, the tool is part of a complex pipeline with many siblings. The description lacks information about data dependencies (e.g., existence of epochs), which is critical for correct invocation. It is minimally complete but leaves gaps in prerequisites.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, and the description only explains the condition parameter. It does not explain epochs_name and evoked_name beyond their defaults, which is insufficient given the lack of schema descriptions. The description adds some value for condition but fails to compensate for the other two parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb ('Average') and resources ('Epochs into an Evoked'), distinguishing it from siblings like mne_make_epochs. It lacks explicit differentiation from other averaging or plotting tools, but the action is specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explains the optional condition parameter but doesn't say when to use this vs alternatives like mne_plot_evoked or mne_make_epochs. The context is implied by the MNE workflow, but no explicit exclusions or alternatives are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden of behavioral disclosure. It lists what the tool reports (versions, runtime directories) which is helpful, but does not mention whether it makes network calls, has side effects, or how long it might take. It does not contradict any annotations since none exist, but it omits some behavioral details that could be useful.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise, only two sentences, and front-loads the key content about what is checked. It includes the 'Call this first' guidance which is crucial. Every word earns its place, and it avoids unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity of the tool (no parameters, no side effects), the description is mostly complete. With an output schema present, return values are likely documented otherwise. The only minor gap is the lack of explicit mention of side effects or permission needs, but for a status-checking tool, this is a minor shortfall.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema is empty with 100% coverage (trivially). There is no parameter information to add, so the description correctly focuses on the tool's purpose and output. No need for parameter details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool checks MNE MCP capabilities including versions of relevant libraries and runtime directories. The verb 'check' plus the resource 'MNE MCP capabilities' makes the purpose specific, and it naturally distinguishes it from sibling tools like mne_session_info or mne_get_config which are likely more focused on session/config details.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The instruction 'Call this first' explicitly tells agents to invoke this tool before any other MNE operations, providing a clear usage context. It also implies the tool is for initial environment verification, setting expectations for when to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Given destructiveHint=true, the description adds useful context beyond the annotation: it stores an MNE Connectivity object, optionally produces a heatmap, and caveats that the heatmap is display-only with complex magnitude. It does not explicitly state that an existing result with the same name is replaced, but the schema's con_name description covers that behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and front-loaded: core function first, then parameter landscape, then behavioral and scoping caveats. Every sentence earns its place, including the dependency note ('Requires mne-connectivity') and the Granger/PAC exclusion.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given high schema coverage and an existing output schema, the description is nearly complete: it captures analysis scope, supported estimators, storage behavior, display caveat, and dependency. A small gap is the lack of an explicit statement that it operates on an existing Epochs object, though the schema's epochs_name parameter supplies that.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3; the description mostly condenses parameter meanings rather than adding new semantics. It helpfully groups parameters into conceptual buckets (bands, pairs, picks, time window, smoothing/cycles), but a knowledgeable agent gains little beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource ('Bivariate across-trial connectivity') and enumerates the key dimensions: bands, ordered channel-name pairs, picks, time window, estimation methods, and smoothing/cycles. It also states a clear exclusion ('Not Granger/PAC'), which helps distinguish it from other analysis tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It clearly scopes the tool to bivariate across-trial connectivity and explicitly excludes Granger/PAC and multivariate indices ('Bivariate connectivity only; multivariate indices have different semantics'). It does not name alternative sibling tools to route to, so it lacks the explicit when-to-use-vs-alternative guidance required for a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must fully carry behavioral disclosure. It clarifies that the baseline is data up to tmax seconds, but it does not disclose whether it stores the result in the session under cov_name, whether it mutates the Epochs object, or what session state is required.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no filler. The core action and the key tmax/default detail are front-loaded, and the second sentence adds a useful downstream purpose without repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The workflow anchor ('needed before building an inverse operator') and the existence of an output schema cover some context. However, the description still leaves important gaps for an agent invoking it in a pipeline, such as requiring an existing Epochs object and explaining how the covariance is stored for later steps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for the missing parameter documentation. It adds meaning for tmax ('data up to tmax seconds, default 0'), but it leaves `name` and `cov_name` semantically undocumented; those are only inferable from their names and defaults.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb ('Compute') and a specific resource ('a noise covariance matrix from the Epochs baseline'), making the primary action and input type obvious. It does not explicitly differentiate itself from related tools like mne_compute_connectivity, but the output and input are specific enough to avoid major confusion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides useful pipeline context: the covariance matrix is needed before building an inverse operator for source localization, so an agent knows when to use it. It does not discuss exclusions or alternatives, but for this tool the alternatives are not obvious and the workflow context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds useful behavioral context beyond annotations: input epochs are unchanged, averaged power is total rather than induced, and the tool returns output names, shape, optional figure paths, and reproducible code. However, annotations flag destructiveHint=true and the description does not explain what may be overwritten or created in the session, leaving that destructive side effect undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and front-loaded, with the core operation stated first and every sentence carrying substantive information. It is slightly dense due to many semicolon-separated clauses, but it contains no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex nested-params tool, the description covers purpose, key parameter groups, a functional caveat, an ITC precondition, return values, and input safety, while the rich input/output schemas fill in remaining details. It omits guidance on destructive session side effects and sibling tool choice, which keeps it just below excellent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With schema description coverage at 0%, the description compensates by naming important parameter groups: explicit freqs, scalar/per-frequency n_cycles, picks, decimation, trial retention (average), ITC, and baseline normalization. It does not cover all nested parameters such as method, baseline_mode, or time_bandwidth, so the compensation is partial.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific operation ('Compute Morlet or multitaper Epochs power') and enumerates key capabilities such as explicit frequencies, n_cycles, picks, decimation, ITC, and baseline normalization. It does not explicitly distinguish itself from the closely related sibling mne_tfr_morlet, so it stops short of full sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides some practical guidance: 'Pass a params JSON object', 'ITC requires average=true', and the caveat that averaged power is total power, not strictly induced power. However, it never states when to choose this tool over mne_tfr_morlet or another alternative, so when-not/alternatives guidance is missing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose that the tool returns an ordered-edge heatmap without forcing symmetry and that it requires the mne-connectivity package. However, it does not mention whether invoking the tool creates named variables, modifies session state, or raises errors when prerequisites are missing, leaving some behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences, each earning its place: the core purpose, method options, output behavior, and the key alternative plus dependency. It is front-loaded with the main purpose and contains no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values are already covered. The description provides the alternative tool and dependency, which helps context. However, the undocumented parameters, especially epochs_name and con_name, leave the definition incomplete for an agent that has no other way to learn their meaning.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, but it only documents the method parameter with example values ('coh', 'plv', 'wpli', 'pli', 'imcoh'). The frequency-band mention hints at fmin/fmax, but con_name and epochs_name are completely unexplained, which is a significant gap for an agent trying to call the tool correctly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool computes spectral connectivity between channels over Epochs in a frequency band and returns an ordered-edge heatmap. It also distinguishes itself from mne_compute_connectivity by noting that the sibling handles multi-band, channel-pair, and estimator parameters. The verb is slightly implicit ('Spectral connectivity' rather than 'Compute spectral connectivity'), but the scope is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly points to mne_compute_connectivity as the alternative for multi-band, channel-pair, and estimator parameters, which tells the agent when this simpler tool is appropriate. It does not fully spell out all 'when not to use' cases, but the guidance is clear and actionable.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses that the operation is 'in place', which is a key behavioral trait beyond the schema. However, with no annotations provided, the description carries the full burden. It doesn't mention whether the operation modifies the original object irreversibly, whether it works on all object types equally, or any side effects like data copy behavior. The 'in place' disclosure is valuable but incomplete.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is concise and front-loads the core action ('Crop') and the resource. It earns its place by stating the time window and the in-place behavior. No wasted words, though it could be slightly more structured with usage context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema and only 3 parameters, the description covers the core operation but leaves gaps: the 'name' parameter is unexplained, and there's no mention of prerequisites (e.g., object must be loaded) or edge cases (e.g., tmin > tmax). The in-place behavior is noted, but for a mutation tool with no annotations, more context about reversibility or object state would be needed for full completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains tmin and tmax as the time window in seconds, which adds meaning to those parameters. However, the 'name' parameter (default 'raw') is not explained at all—it's unclear whether it's a variable name, a file path, or an object identifier. The description doesn't clarify the role of 'name' in the context of cropping.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Crop' and the resource 'Raw/Epochs/Evoked object' with a specific time window [tmin, tmax] seconds. It distinguishes itself from siblings like mne_filter or mne_resample by focusing on time-window cropping, though it doesn't explicitly name a sibling alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for cropping MNE objects to a time range, but it doesn't explicitly state when to use this tool versus alternatives like mne_filter (which also operates on time but filters frequencies) or mne_resample. No exclusions or alternative tool names are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does a lot: it discloses output side effects (saves mean/fold/detail outputs), return shapes per method, non-destructive cropping ('crop a copy'), model configuration facts, and the caveat that reference lines are not significance. It also states the scikit-learn dependency. This is rich behavioral disclosure; only minor details like plot behavior are left implicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but compact, front-loading the core purpose and placing caveats and alternatives at the end. Each clause adds information, but the lack of a clear section/format makes it a slight reading load.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 18-parameter tool with 0% schema description coverage and no annotations, the description is unusually complete, covering outputs, CV behavior, return shapes, and non-destructive cropping. It still leaves a few parameters and the exact plot behavior unexplained, but the existence of an output schema reduces the need to describe return values.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain parameters and largely does: cond_a/cond_b, groups alignment, method output shapes, tmin/tmax, C/class_weight/max_iter, and cv_strategy are all given semantics beyond their names. Some parameters (picks, scoring, shuffle, epochs_name, random_state) are not addressed, so compensation is strong but not complete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly explains the tool performs time-resolved MVPA decoding, training a classifier at each time point to discriminate two conditions with cross-validation. This is a specific verb+resource description, though it does not explicitly contrast with the sibling mne_decoding_group_test, so it stops short of full sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use (two-condition time-resolved decoding) and gives a concrete alternative for hyperparameter tuning ('use nested CV via mne_run_code for tuning'). It does not state when to prefer this over mne_decoding_group_test or list exclusions, so guidance is present but mostly implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the disclosure burden and does so thoroughly: it states the statistical model (sign-flip permutation, symmetric-effects null), the two correction methods, and the outputs ('statistic, corrected p values or cluster p values, mask, H0 and diagnostics'). It also notes that it is group-level, not single-subject or prevalence inference, making behavioral scope clear.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a dense but well-front-loaded block; the first clause states the purpose and every following clause covers a distinct requirement, method option, assumption, or output. It could be restructured with bullets for readability, so it stops short of 5.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a statistically complex tool, the description is complete: it covers prerequisites, forbidden input patterns, supported metrics, correction methods, null-hypothesis assumptions, and stored outputs. The rich input/output schemas cover structured details, so nothing necessary for correct invocation is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already documents every parameter at 100% coverage, so the baseline is 3. The description adds useful cross-parameter semantics: null_value is predeclared and usually 0.5, score_names must be one mean result per independent subject, and matching time grids/methods are supported. This nudges the score above baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb-resource pair: 'Group-level sign-flip inference on mne_decode mean scores, one per independent subject.' It also explicitly excludes what it is not ('Not single-subject label shuffling or population prevalence'), which differentiates it from sibling tools such as mne_decode in one line.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit conditions for use: score_names, unique subject_ids, independent_subjects=true and explicit null_value. It gives a hard negative rule, 'Never pass CV folds or repeated runs as subjects,' and clarifies that this is not single-subject label shuffling or population prevalence, so an agent knows when to avoid it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of explaining behavior. 'Show' implies a read-only summary, but the description does not explicitly state that the session is not modified, what happens for unknown names, or what the output contains beyond a few field examples.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler. The parenthetical list adds useful specificity, though the trailing 'etc.' is vague and slightly weakens the precision.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with one parameter and an output schema, so the description need not explain return values. However, it does not compensate for the missing schema description or provide enough context to distinguish this tool from similar session-inspection siblings, leaving it only minimally adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter 'name' has 0% schema description coverage, so the description must clarify its meaning. It loosely identifies it as a 'named session object', but does not explain what constitutes a valid name, where it comes from, or how it relates to existing session objects.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Show') and resource ('detailed summary of one named session object') and lists relevant fields like channels, sfreq, montage, and bads. It is clear, though it does not explicitly distinguish itself from similar siblings such as mne_session_info or mne_get_info.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given about when to choose this tool over the many session-related siblings, nor are any exclusions or alternative tools mentioned. The only implied usage is 'one named session object', which does not help an agent decide between this and similar inspection tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of behavioral disclosure. It clearly states the transformation and the output shape, but it does not mention whether the Raw variable is modified, how annotations map to event IDs, or what happens if no annotations exist.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence states the operation, inputs, outputs, and target file formats with no wasted words. It is concise and effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no annotations and zero parameter documentation, the description omits key details needed to invoke it correctly, especially parameter meaning and when to choose this over mne_find_events. The output schema may document the return shape, but the usage gap remains significant.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description never explicitly explains raw_name or events_name. The defaults and naming hint at a source variable and an output variable, but the agent must infer this connection.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Convert'), a specific resource ('a Raw object's annotations'), and the concrete outputs ('events array + event_id map'). The parenthetical formats also help differentiate it from sibling mne_find_events, which likely derives events from stimulus channels rather than annotations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this is the right tool when annotations carry event information, especially for EDF/BrainVision/EEGLAB data. However, it never explicitly contrasts it with mne_find_events or states when not to use this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the full behavioral burden. It discloses the in-place mutation, which is important. It also explains parameter semantics (l_freq/h_freq edges, notch frequency, picks). However, it does not mention potential side effects like data being modified irreversibly, or what happens if both l_freq and h_freq are null (likely no-op). It also does not clarify default behavior for picks when null. These gaps reduce transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, dense sentence that leads with the core purpose and then explains the key parameters. Every word contributes value; there is no fluff or redundancy. It is concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is adequate for a straightforward filter operation, but it lacks critical details like the interaction between l_freq and h_freq (e.g., both null), the effect of notch, and the default picks behavior. It also does not mention any prerequisites (e.g., data must be loaded) or error conditions. Given that an output schema exists, return values are not needed, but the incomplete parameter semantics leave some ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains four of the five parameters: l_freq, h_freq, notch, and picks, but omits the 'name' parameter entirely. It also does not clarify the default behavior of null for notch or picks beyond saying picks is optional. While it covers most parameters, the missing 'name' is a notable gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool filters Raw/Epochs/Evoked objects with specific filter types (band-pass, high-pass, low-pass, notch) and that it operates in place. This is a precise verb+resource combination that distinguishes it from other MNE tools like resample or crop.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It implies when to use it (for frequency filtering) but does not explicitly mention alternatives or exclusion criteria. The context of sibling tools makes the purpose clear, but it lacks guidance like 'use mne_resample for temporal resampling' or 'use mne_notch_filter for notch-only'. Still, it gives enough context for an agent to select it appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose a meaningful side effect: results are stored under events_name. However, it does not state whether the Raw object is modified, whether an existing events_name is overwritten, or what happens when no events are found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The entire description is two short sentences with no filler. The core action is front-loaded, and the storage side effect is stated immediately after, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with three optional parameters and an output schema, the description covers the main action and side effect. However, it omits default stim_channel behavior and offers no usage context relative to sibling tools, so an agent might still need to infer important invocation details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It maps all three parameters loosely: raw_name is the Raw object, stim_channel is the channel searched, and events_name is the storage target. Still, it does not explain the behavior when stim_channel is null, leaving a key invocation detail underspecified.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Find'), the exact resource ('stimulus/trigger events'), the location ('stim channel'), and the container ('Raw object'). It also states where results are stored ('events_name'), which clearly distinguishes it from sibling tools like mne_events_from_annotations and mne_load_raw.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to prefer this over alternatives such as mne_events_from_annotations, nor any mention of prerequisites like having a Raw object loaded in the session. The description says what the tool does but not when or when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does well: it discloses the supported methods, the varying n_components semantics, where the result is stored (ica_name), and the scikit-learn dependency. It does not mention side effects or the role of random_state, but the key behavioral details are present.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and front-loaded: purpose first, then parameter semantics, then storage and dependency. Every sentence contributes useful information without redundancy or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the core operational requirements: preprocessing, methods, n_components options, storage name, and dependency. However, it omits the meaning of the 'name' parameter and 'random_state', which are not documented elsewhere given 0% schema coverage, leaving an agent to guess at important invocation details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains method values and defaults, n_components types, and ica_name default, but it does not explain the 'name' parameter (default 'raw') or 'random_state'. This is adequate but incomplete for the 5-parameter schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: 'Fit Independent Component Analysis on a Raw/Epochs object for artifact removal.' This clearly distinguishes it from sibling tools like mne_plot_ica_components or mne_apply_ica, which operate on already-fit ICA results.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear usage context: fit ICA for artifact removal, preferably on a 1 Hz high-pass filtered Raw/Epochs object. It does not explicitly name alternatives or exclusion conditions, but the purpose and preprocessing prerequisite are directly stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It says 'show' which implies read-only, and it states users change parameters via a separate command, implying this tool does not modify anything. However, it doesn't explicitly declare non-destructiveness, nor does it mention what happens when no configuration exists or the output format. Given the zero annotation support, a bit more explicit safety disclosure would have been helpful.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-structured sentence that front-loads the core purpose ('Show the configured default analysis parameters'), then lists the types and the mechanism for changing them. There is no fluff or redundancy; every clause adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 0-parameter tool with an output schema, the description is nearly complete. It explains what the tool returns, why it matters (fallback behavior), and how defaults are changed externally. It doesn't describe the output schema structure, but that's provided separately, and it doesn't mention edge cases like missing configuration, which is a minor gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the description need not explain any. The baseline of 4 applies here because with no parameters there is nothing additional to clarify. The description focuses on the output content, which is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific action ('Show') and resource ('configured default analysis parameters'), enumerates the parameter types, and explains their role as fallback values. This distinguishes it from processing tools like mne_filter or mne_plot_raw, making its purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It says the parameters are those 'that the structured tools fall back to when a parameter is omitted', which tells an agent when to call it (to understand defaults before invoking other tools). It also hints at how to change them via `mne-mcp configure`, implicitly differentiating this read-only inspection from modification. It doesn't explicitly state 'use this instead of X' but that's not necessary given its unique role.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the behavioral burden. The verb 'Show' clearly signals a read-only inspection operation with no mutation or destructive side effects, which is the key behavioral trait an agent needs. It does not mention error behavior or assumptions about session existence, but for a simple getter this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One compact sentence with no filler or redundancy. The action and target are front-loaded, and every word contributes to the meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter, read-only information tool with an output schema present, the description covers the essential scope and return content. It is missing explicit usage differentiation from similar sibling tools, but overall the agent has enough to call it correctly in a straightforward inspection scenario.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema only declares a string parameter named 'name' with 0% description coverage. The phrase 'named session object' adds the essential semantic that 'name' identifies the target session object, which is meaningful beyond the raw schema. It does not specify expected name format or how to discover valid names, but the single-parameter simplicity limits the gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Show') and names the resource ('full channel list and measurement info') plus the scope ('named session object'). It is clear what the tool returns, though it does not explicitly differentiate itself from siblings like mne_session_info or mne_describe.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to prefer this tool over sibling inspection tools such as mne_session_info, mne_describe, or mne_get_config. No exclusions, prerequisites, or alternative-selection conditions are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does reveal the interpolation method and montage requirement, but it does not say whether the in-memory data object is modified, whether original channel data is replaced, or how the 'bad' markers are affected afterward. The reset_bads parameter defaulting to true makes this omission significant.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single compact sentence that front-loads the core action and then adds method and prerequisite details. Every word contributes information, with no filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description identifies the operation and prerequisite but is not enough for an agent to invoke the tool correctly without guessing about object targeting and side effects. Given that annotations are absent and schema coverage is 0%, the description should have explained the two parameters and the mutation behavior; it does neither.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description provides no information about either parameter. The 'name' parameter is especially opaque since its default is merely 'raw' and it is not explained as referring to an MNE object. The description also fails to clarify that 'reset_bads' controls whether the bad-channel list is cleared after interpolation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action and resource: interpolate currently-marked bad channels. It also names the method (spherical splines) and a key precondition (montage). The phrase 'currently-marked' clearly distinguishes this from sibling tools like mne_mark_bad_channels.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this should be used after bad channels have been marked and after a montage is set, but it does not explicitly state when to choose this over alternatives such as rejecting bad segments. It gives a clear prerequisite but no exclusions or alternative routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries the behavioral disclosure burden. It communicates the default directory fallback and optional glob, but it does not mention recursive vs. non-recursive listing, sorting, hidden files, or failure behavior. The core behavior is clear for a simple read-only listing tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences with no filler. The main action, supported file types, default directory, and optional glob are all front-loaded and easy to scan.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema, low complexity, and only two optional parameters, the description covers file types, default paths, and pattern usage well. Minor gaps around recursion and path semantics exist but do not prevent correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description adds meaning by associating 'directory' with the default location and 'pattern' with a glob pattern. However, it does not explain glob syntax, path resolution, or how directory and pattern interact, so the compensation is partial.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Uses a specific verb ('List') and names the exact resource: neurophysiology data files with supported extensions under a directory. It is clearly distinct from sibling processing/plotting tools because it is the only file-listing helper in the set.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides actionable guidance by stating the default directory behavior and the optional glob pattern. It does not explicitly name alternatives or exclusions, but there are no sibling listing tools, so the context is sufficient for an agent to know when to invoke it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description discloses key behaviors: it stores the object under a name, handles format auto-detection, and notes a memory optimization (preload=False for large files). It does not mention return values or side effects, but for a loading tool, this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three efficient sentences, front-loading the core action and then providing key usage nuances. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity, a loading tool with clear parameters, the description covers essential usage. The output schema exists, so return values need not be described. Minor gap: doesn't mention error handling or supported formats explicitly, but auto-detection implies coverage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains the `name` parameter (default 'raw') and `preload` (false for large files), but `path` is only implicitly covered. It adds value beyond the bare schema by explaining when to set preload.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool loads a raw recording from disk and specifies the storage name and preload option. It distinguishes itself from siblings by focusing on the loading step, which is unique among the listed tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It mentions auto-detection of format by extension and hints at usage for large files with preload=False. It does not explicitly mention when to avoid this tool versus others, but the context implies it's the initial step before processing, which is reasonably clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries the full behavioral burden. It discloses time-relative tmin/tmax semantics, default baseline behavior, event_id encoding, SI units for rejection thresholds, the 'reject={} disables configured rejection' behavior, storage under epochs_name, and the warning not to combine reject with reject_eeg. It does not cover event_repeated or reject_by_annotation behavior, but the core side effects are clearly communicated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is stated first, followed by dense, semicolon-packed parameter guidance with no filler or repetition of schema content. Every sentence contributes: units, format preferences, rejection constraints, interaction warnings, and storage behavior.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 14-parameter MNE tool with no annotations, this description covers the commonly needed parameters and key interactions well, and the presence of an output schema excuses detailed return-value explanations. However, nontrivial parameters with defaults—event_repeated, reject_by_annotation, and detrend—plus pipeline prerequisites such as the need for existing events, are left unexplained. It is adequate for typical calls but not fully complete for an agent facing edge cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description compensates substantially: tmin/tmax in seconds, reject_eeg in volts with an example, baseline default and preferred array form, event_id as object or legacy string, and reject/flat channel-type mapping. It leaves some parameters like picks, detrend, event_repeated, and reject_by_annotation to inference from names or enums, so it is strong but not exhaustive.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific construction: 'Segment a Raw object into Epochs around events,' naming the object, operation, and result. This clearly distinguishes it from event-finding, filtering, and averaging siblings without needing to inspect their schemas.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The role in the pipeline is implied by 'Segment a Raw object into Epochs around events,' and it gives format preferences such as 'Prefer JSON event_id={label: code}' and 'legacy strings remain supported.' However, it never names alternative tools or states when to choose this over siblings like mne_find_events or mne_average_evoked, and prerequisites are left implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses that the fsaverage template is downloaded once (~ tens of MB) and that the result is stored under fwd_name. However, it does not mention whether the input object is modified, whether a montage must be pre-set, or any side effects beyond storage. It adds some transparency but leaves gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no extraneous information. Purpose is front-loaded, and the download/storage details are efficiently conveyed. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists, the description need not explain return format. It covers purpose, use case, and storage location. However, it omits prerequisites such as the need for a montage to be set on the object, and whether the object is mutated. These are minor but could affect correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains 'name' as the 'named object' and 'fwd_name' as the storage location. This adds meaning beyond the schema defaults, but it does not elaborate on parameter types, ranges, or the relationship between them. The explanation is minimal but sufficient for basic usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (build), resource (template-head EEG forward model), and context (for the named object's montage). It distinguishes from siblings like mne_apply_inverse or mne_compute_noise_cov by focusing on forward modeling. However, it does not explicitly specify the object type (e.g., evoked, raw) despite the 'name' parameter defaulting to 'evoked'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides a clear use case: 'Use for EEG source localization without an individual MRI.' This implies when to use and suggests alternatives when an MRI is available. It does not list explicit exclusions or alternative tools, but the context is sufficient for an agent to decide appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Since no annotations exist, the description carries the behavioral transparency burden. It does disclose a meaningful behavioral trait: bads are appended by default and overwritten only when replace=true. However, it does not mention side effects on downstream processing, whether the change is session-local, or whether the operation mutates the named object.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise, front-loaded sentences with no filler. The action, example, default behavior, and override option are all communicated efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple three-parameter tool, the description covers most usage needs, and the presence of an output schema makes omitting return-value details acceptable. However, the unexplained 'name' parameter and the lack of any annotation-backed context leave a meaningful gap for fully autonomous invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain parameter meaning. It usefully describes 'bads' as comma-separated channel names and 'replace' as the overwrite switch, but it never explains the 'name' parameter, leaving which object is modified unclear.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific action and resource: 'Mark channels as bad', and clarifies the expected input format with a concrete example ('Fp1,T7'). It does not explicitly differentiate from sibling tools like mne_interpolate_bads, but the operation and resource are otherwise unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance or comparison to alternatives is provided. The description only explains the append-versus-replace behavior, leaving an agent to infer when marking channels as bad is appropriate or how it relates to sibling tools such as interpolation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does disclose that the tool returns PNG path(s), which is useful, but it does not explicitly state that plotting is non-mutating, whether a display backend is required, or other potential side effects. Basic behavior is covered, but deeper behavioral traits are absent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short, front-loaded sentences with no filler. The primary action and output are stated immediately, and every word adds meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is relatively simple with only two optional parameters, and an output schema exists, so return values are covered. However, with no annotations and no parameter guidance, the description is only minimally complete; an agent still cannot confidently determine how to set 'picks' or whether 'name' refers to a workspace variable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain what 'name' or 'picks' mean or how they should be formatted. The reference to an 'Epochs object' hints that 'name' might identify the object, but this is indirect and does not compensate for the undocumented schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Plot') and resource ('ERP image') with a clarifying parenthetical ('epochs × time heatmap'), and it names the output format ('Returns PNG path(s)'). This distinguishes it from sibling plotting tools such as mne_plot_evoked, mne_plot_raw, and mne_plot_topomap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'for an Epochs object' implies a prerequisite and suggests when the tool is applicable, but there is no explicit contrast with alternatives or exclusion criteria. The agent must infer usage rather than being told when to prefer this over mne_plot_evoked or mne_plot_psd.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions the return of a PNG path, which is useful, but it does not disclose any side effects, session state changes, or error conditions. For a plotting tool, side effects are minimal, but it fails to mention that the plot is saved to a file and what happens if the file already exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, with two sentences that are front-loaded with the main purpose and style options, followed by the return value. Every word is useful and there is no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity of the tool (2 params, no required), the description is mostly adequate, but it misses explaining the 'name' parameter and does not clarify that the plot is saved to a file (though it mentions PNG path). The output schema likely indicates the return type, so it doesn't need to explain return values in detail. A bit more context on the 'name' parameter would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain the 'name' parameter at all. It only explains the 'style' parameter through enumeration of values. The 'name' parameter likely refers to the variable name in the session, but this is not stated. The description partially compensates by listing style options, but 'name' remains undefined.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it plots an Evoked response and lists three style options, distinguishing it from siblings like mne_plot_epochs_image and mne_plot_topomap. It is specific about the resource (Evoked) and the action (plot). However, it doesn't explicitly mention that it works on averaged data, which mne_average_evoked suggests.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for plotting Evoked data, and the style options provide some guidance on variations. However, it does not explicitly state when to use this tool over mne_plot_topomap or mne_plot_epochs_image, nor does it mention prerequisites like having an Evoked object in session. The context is clear but not fully elaborated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description alone must convey safety and behavior. It discloses that the tool produces PNG path(s), implying file output, and 'Plot' implies a non-mutating visualization, but it does not explicitly state that it saves PNG files to session storage, whether a fitted ICA object must exist, or that no data is modified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the tool's action and purpose, then output format. No filler or repetition of the tool name.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple (one optional parameter) and an output schema exists, so the description does not need to detail return values. It covers what the tool does and its primary output, though it leaves the session prerequisite (an existing ICA fit) implicit.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% descriptive coverage and the description does not mention the ica_name parameter at all. The parameter name and default 'ica' are inferable, but the description fails to clarify that this is the name of an existing ICA object in the session, which is necessary for non-default usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific action and resource: plotting ICA component scalp topographies, and explicitly states the artifact-identification purpose. This is distinguishable from siblings such as mne_plot_ica_sources, which would plot component time courses rather than topographies.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The stated purpose 'to identify eye/heart/muscle artifacts' tells an agent when this tool is appropriate, and 'scalp topographies' distinguishes it from source/epoch plotting alternatives. However, it does not explicitly name alternative tools or state when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states that it plots and returns a PNG path, but says nothing about side effects (e.g., whether it modifies session state), dependencies on prior steps (e.g., ICA must already be fitted, instrument must be loaded), or potential failure modes. This is a significant gap for a tool that operates on session objects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no fluff, and it front-loads the primary action and return type. However, it is almost too terse, omitting crucial context that could be added without bloating it. Still, it is efficient and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool plots ICA component time courses, which implies a multi-step context (fitting ICA, having a raw/epochs object). The description fails to mention prerequisites, how components are selected (no parameter for that), or whether it plots all components or a subset. While an output schema exists (PNG path), the description does not cover operational requirements, making it incomplete for an agent to call correctly without additional knowledge.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It gives a vague hint that the instrument can be raw or epochs, which maps to inst_name, but does not explain ica_name or clarify acceptable values or formats. The default values are not explained, and the description does not specify how parameters affect the output.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool plots ICA component time courses for an instrument (raw/epochs) and returns a PNG path. This distinguishes it from siblings like mne_plot_ica_components (which would plot component topomaps) and mne_plot_raw (raw signal plots). The verb and resource are explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage after ICA fitting and when time courses are desired, but it does not explicitly state when to prefer this over alternatives, nor does it mention any exclusions or prerequisites. The 'for an instrument (raw/epochs)' hint is the only contextual guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of disclosing side effects and safety. It only mentions that it returns a PNG path, which hints at file creation but does not clarify whether the underlying data is modified, where the file is saved, or any other side effects. This is minimal behavioral disclosure for a tool with zero annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with the core action and output front-loaded. Each clause is relevant, and there is no filler. However, the extreme brevity leaves out important guidance that would count against completeness, though conciseness itself is strong.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 parameters with zero schema descriptions, no annotations, and the need to disambiguate from sibling plotting tools, this description is incomplete. It clarifies the object type and return type, but leaves parameter semantics and operational context entirely unexplained, so an agent would likely struggle to call it correctly on the first try.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% and the tool description adds no explanation for fmax, fmin, name, or picks. An agent must guess the meaning of 'name' and 'picks' and the units of fmin/fmax. The description fails to compensate for the schema's lack of parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states a specific verb ('Plot'), a resource ('power spectral density'), and the valid data types ('Raw/Epochs/Evoked'), plus the return type ('PNG path'). This differentiates it from sibling plotting tools like mne_plot_raw or mne_plot_evoked, which plot time-domain signals.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for frequency-domain visualization by naming the resource, but it does not explicitly state when to choose this tool over alternatives, nor does it mention any exclusions or prerequisites. An agent can infer the primary use case but not the decision boundary with other plotting tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full disclosure burden. It usefully states the return format ('Returns a PNG path'), but says nothing about session dependency (raw data must presumably be loaded via mne_load_raw first), whether the call alters session state, or where the PNG is written. That plotting is read-only is implied but never made explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two terse sentences with the core action front-loaded and no filler; every word earns its place. The tradeoff is that the brevity is achieved by omitting exactly the semantic detail the 0% schema coverage and absent annotations require.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 4-parameter tool with no annotations, 0% schema description coverage, and 40+ siblings, the description is incomplete. An agent lacks parameter semantics, session prerequisites, and sibling routing; only the return value is covered, and the output schema already handles that.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, and it does so only vaguely. 'A window of channels over time' loosely maps to start/duration/n_channels, but the description never states units for start/duration (seconds? samples?), what 'name' refers to (an in-session raw object? a file?), or how n_channels selects which channels to show.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Plot') with a specific resource ('raw signal traces'), and the parenthetical defines the plot's scope as a time-windowed channel view. The word 'raw' implicitly distinguishes it from siblings like mne_plot_evoked and mne_plot_epochs_image, though it never names those alternatives explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given for when to use this tool versus the many other plotting siblings (mne_plot_evoked, mne_plot_epochs_image, mne_plot_psd, mne_plot_topomap, mne_plot_sensors). With 40+ siblings, an agent must infer the selection rule entirely from the single word 'raw', which is thin routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It does disclose an important output behavior by stating 'Returns a PNG path' and lists the two layout kinds. However, it does not mention whether the tool modifies session state, writes a file to disk, requires existing data, or behaves differently between the 2D and 3D modes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is remarkably concise: one sentence for the core action and modes, plus one sentence for the return format. Every word earns its place, and the most identifying information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with three parameters, no annotations, and no schema-level parameter descriptions, the description is incomplete. An agent would not know what 'name' refers to, whether a raw object must already be loaded, or how the returned PNG path should be used. The presence of an output schema does not compensate for missing parameter semantics and usage context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for all three parameters. It gives partial meaning for 'kind' ('topomap' 2D or '3d'), but it does not explain 'name' or 'show_names' at all, even though defaults and no enums leave important ambiguity.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific action ('Plot') and resource ('sensor/electrode layout'), and distinguishes the two display modes ('topomap' 2D or '3d'). It is understandable on its own, though it does not explicitly differentiate itself from the sibling mne_plot_topomap, which could be confused for a similar plotting tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance about when to use this tool versus alternatives such as mne_plot_topomap, mne_plot_evoked, or mne_plot_raw. There is no mention of prerequisites, session/data requirements, or conditions that would make this tool the right choice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses the rendering requirement and the graceful degradation when 3D rendering is unavailable, noting that the estimate is still computed and can be inspected via mne_run_code. It also specifies the output type (PNG) and timing behavior. It doesn't explicitly state side effects (e.g., read-only nature), but the plotting nature is implied.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with no filler. The core purpose is front-loaded, and the prerequisite/fallback information is included without bloat. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the main behavior, hemisphere options, timing, and the PyVista dependency. However, it omits the meaning of stc_name and does not detail the output format (though an output schema exists). For a tool with no annotations and sparse schema, the missing stc_name semantics leave a gap that could confuse an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains the hemi parameter values ('both' / 'lh' / 'rh') and the time parameter's meaning (peak time or given time), but does not clarify the stc_name parameter (likely the workspace variable name). This partial coverage leaves one of three parameters undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Render') and a specific resource ('source estimate (stc)') as a 'cortical activation map (PNG)', and it specifies the timing (peak or given time) and hemisphere options. It clearly distinguishes itself from sibling plotting tools that target epochs, raw, evoked, or ICA data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides context on when to use it (for source estimates) and mentions a prerequisite (PyVista off-screen rendering) plus a fallback (mne_run_code). However, it does not explicitly state when NOT to use it or name alternative tools for similar tasks (e.g., mne_plot_topomap for topographic maps), leaving some routing to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It discloses that the tool returns a PNG path, which implies file creation, but it doesn't mention whether the operation is read-only, where the file is saved, or any side effects on session state. This is partial behavioral disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with no redundant words. The main action is front-loaded, followed by the essential times parameter format, and ends with the return value. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple and an output schema exists, but the description lacks clarity on the 'name' parameter and doesn't mention whether an Evoked must already exist in the session. Defaults make a basic call possible, but an agent may not know how to point to a specific Evoked.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 0%, so the description must compensate. It fully explains the 'times' parameter's valid values ('auto', 'peaks', comma-separated seconds), but the 'name' parameter is not described at all, leaving the agent to infer it refers to an Evoked object in the session.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action (plot scalp topographies) and resource (an Evoked), which clearly distinguishes it from sibling tools like mne_plot_evoked or mne_plot_epochs_image. It also specifies the times argument options, making the tool's scope unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage (when you need topomaps of an Evoked) but gives no explicit guidance on when to choose this over alternative plotting tools, nor does it mention exclusions or prerequisites. The times parameter format is useful but doesn't cover tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It does disclose that resampling happens 'in place', which is a key behavioral trait, but it does not explain side effects, whether the original data is overwritten, what the return value is, or any constraints. This is a significant gap for a mutating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single front-loaded sentence with no filler. It states the action, target, output condition, and mutation mode compactly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter mutation tool with no annotations and no schema descriptions, the description is incomplete. It leaves the 'name' parameter unexplained and does not clarify side effects or return behavior, even though an output schema exists.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, so the description must compensate. It indirectly clarifies 'sfreq' via 'new sampling frequency (Hz)', but it never explains the 'name' parameter, which appears to select which object to resample. The compensation is only partial.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Resample'), names the resource ('Raw/Epochs object'), and states the outcome ('new sampling frequency (Hz)'). It is clearly distinct from siblings like filter or crop, so an agent can tell what this tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The usage context is implied: use this when you need to change the sampling frequency of a Raw/Epochs object. However, it does not explicitly state when not to use it or mention alternatives such as mne_filter for frequency filtering.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states that all loaded objects and figures are cleared and emphasizes that the action is irreversible, giving an agent a strong safety signal. It does not detail hidden side effects, but none are suggested by the scope of the statement.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two compact sentences with no filler: the core action is front-loaded, and 'Irreversible' is a necessary warning that earns its place. The description is optimally sized for a simple stateless utility.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter reset tool with an output schema, the description fully covers the key aspects: what is cleared, the fresh-start outcome, and the irreversible consequence. Nothing essential is missing for an agent to invoke it safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters and 100% coverage, so there is no parameter meaning to add. The description appropriately mentions nothing about parameters. Per the zero-parameter baseline, this is a solid score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Clear') and resource ('all loaded objects and figures from the session'), making the tool's purpose immediately obvious. It is clearly distinguishable from the many analysis and plotting siblings, since it resets session state rather than operating on data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'starting fresh' gives clear contextual guidance for when this tool is appropriate, and 'Irreversible' warns against casual use. There are no similar reset tools among the siblings, so exclusion alternatives are not needed, though explicit 'use when' wording would have been slightly stronger.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full behavioral disclosure and does so well: it reveals the persistent session namespace, pre-bound names, return of the final expression, stdout capture, and PNG saving of matplotlib figures. These are meaningful execution behaviors beyond the minimal schema, and they set accurate expectations for an arbitrary-code tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences with no filler. It leads with the core purpose, then immediately provides the most actionable details (pre-bound names, result semantics), and closes with the usage rule. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter arbitrary-code execution tool with no annotations, the description is remarkably complete: it covers the namespace, the input expectation, the return value, stdout, and figure handling, and it explains when to use the tool relative to the sibling set. An agent has enough context to invoke it correctly without further inference.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must explain the `code` parameter, and it does thoroughly. It tells the agent what kinds of code are valid, what names are already in scope, and what side effects/returns to expect from evaluating that code. This adds substantial meaning over the bare `'code': string` schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Execute arbitrary Python/MNE code in the persistent session namespace.' It clearly distinguishes this from the many structured sibling tools by emphasizing it handles anything they do not cover, and it gives concrete pre-bound names (`mne`, `np`, `pd`, `plt`) and object examples (`raw`, `epochs`).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'Use this for anything the structured tools do not cover,' which gives a clear routing rule relative to the large sibling set. It also compares execution to a notebook cell, implying an exploratory fallback role. However, it does not name specific alternatives or list common cases where a structured sibling should be preferred instead.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full responsibility for behavioral disclosure. It mentions saving and naming rules, but omits overwrite behavior (overwrite defaults to true in the schema), error handling for existing files or unsupported formats, and any potential side effects. The phrase 'Other formats follow the object's .save() support' hints at limits but does not disclose concrete consequences.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is only two sentences, with the core action front-loaded and filename conventions compactly listed. Every sentence contributes information, and there is no filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero annotations and zero schema description coverage, the description alone is insufficient for correct invocation. It covers naming conventions but leaves parameter semantics and overwrite behavior underspecified. The presence of an output schema reduces the need to describe return values, but the main usage gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain the parameters, but it only indirectly addresses filename conventions. It does not clarify what `name` refers to, what `path` should contain beyond a file name, or the meaning and effect of `overwrite`. The naming rules provide some context for constructing paths, but not enough for confident invocation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Save') and the resource ('a session object to disk'), and adds specific MNE filename conventions for Raw, Epochs, and Evoked. It is immediately distinguishable from all sibling tools, none of which are save operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The naming rules imply when this tool is appropriate, but the description does not explicitly state when to use it versus alternatives or mention any excluded object types. It gives file-format context rather than actionable selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It clearly discloses that the tool enumerates current session objects and returns one-line summaries. The phrase 'List' implies a read-only operation, and 'persistent analysis session' adds useful context about state. It does not explicitly state there are no side effects, but the behavior is unambiguous for a simple inspection tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no wasted words. The primary action and scope are front-loaded in the first sentence, and the use case is provided in the second. Every phrase earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a simple zero-parameter inspection tool, and an output schema exists to describe the return structure. The description covers what objects will be listed and the level of detail (one-line summary). Nothing an agent needs to call this tool correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so according to the rubric the baseline is 4. The description adds no parameter-specific meaning because there are none to annotate, which is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('List') with a clear resource ('every object currently held in the persistent analysis session') and enumerates the object types it covers (raw recordings, epochs, evoked, ICA, events, arrays). This differentiates it from sibling tools like mne_plot_raw or mne_average_evoked, which operate on specific data rather than enumerate the session state.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear usage context: 'Use this to see what is loaded before operating on it.' This tells the agent when the tool is appropriate. It does not explicitly mention alternatives or exclusions, but for a session-inspection tool this guidance is sufficient to route an agent appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden, and it does disclose the main effect (setting channel positions) and the default montage behavior. However, it does not mention side effects on session data, channel-name compatibility, or failure modes, leaving only partial transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, front-loaded with the action and examples, then the use-case, then the default behavior. Every sentence adds distinct value with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The core operation, use-case, and default are covered, and an output schema exists so return value details need not be in the description. The unexplained `name` parameter and absence of annotations prevent it from being fully self-sufficient, but it is adequate for a basic call.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains the montage parameter with examples and default behavior, but the `name` parameter is not explained at all, leaving an agent without guidance on what object it refers to.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific action ('Apply... montage') and states the result ('set channel positions'), backed by concrete montage examples. It also gives a use-case ('Needed before topographic plots and interpolation') that helps distinguish it from sibling tools, though it does not explicitly name an alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It clearly indicates when the tool is needed (before topographic plots and interpolation) and explains the behavior when montage is omitted. It lacks explicit when-not-to-use guidance or named alternatives such as mne_set_reference, so it stops short of full routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full behavioral burden. It only states the action and reference options; it does not disclose whether the raw object is mutated in place, whether the operation is reversible, or whether any session state is required. This is a notable transparency gap for a mutating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with the core verb and resource front-loaded, followed by the only necessary details: valid values and an example. There is no filler or redundant restatement.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple two-parameter tool with an output schema, the core invocation details are mostly covered, and return values need not be explained. However, missing side effects and usage context leave an agent to guess about state changes and preprocessing order, so the description is adequate but not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The `ref_channels` parameter is well documented with valid options ('average', 'REST', comma-separated channel names) and an example. However, the `name` parameter is left entirely to inference, and schema description coverage is 0%, so the description only partially compensates for the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and object ('Set the EEG reference') and then enumerates the accepted reference modes with a concrete example. This clearly differentiates it from sibling tools like mne_set_montage, which concern electrode geometry rather than reference selection.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains what values can be supplied but gives no guidance on when this tool should be called (e.g., after loading raw data, before epoching) or when a sibling tool would be preferable. No alternatives, prerequisites, or exclusions are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions that results are 'Stored under tfr_name' and 'Returns PNG path', which are useful, but it does not describe the nature of the TFR object, whether it modifies the Epochs object, or if it requires any prior steps. It lacks details on side effects or prerequisites, so the agent may be unaware of what happens to the data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise paragraph, with the main action and key parameters front-loaded. It is efficient, but the lack of structure (e.g., bullet points) slightly reduces readability. Still, it is appropriately sized for the task.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 5 parameters, no annotations, and an output schema (likely indicating a PNG path), the description is incomplete. It does not mention how the TFR is stored or returned, nor whether the computation is applied to all epochs or requires specific channels. The presence of an output schema might partially cover return values, but the description should clarify the relationship between tfr_name and epoch_name, which is missing. Overall, it's borderline inadequate for a complex MNE tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain all parameters. It only explains 'fmin/fmax = frequency range (Hz), n_freqs = number of frequencies', but fails to explain tfr_name and epochs_name, which are crucial for specifying where to store and which epochs to use. The description partially compensates but is incomplete for the 5 parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'compute' and resource 'Morlet-wavelet time-frequency power on Epochs', and mentions plotting and output as PNG path. It distinguishes from sibling tools like mne_compute_tfr by specifying the Morlet wavelet method and producing a plot. However, it doesn't explicitly contrast with siblings, so not a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives a brief context (compute and plot TFR on epochs), implying it is used for time-frequency analysis, and mentions capturing output as PNG path, which suggests when to use it. But it does not explicitly state when not to use it or name alternative tools, such as mne_compute_tfr, which might be more appropriate for returning data objects instead of plots. The guidance is minimal and left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.