# Pm AI Tool Search To Selection

> Use when an AI agent has a large or changing tool catalog and a product manager must define what is searchable, which candidates are eligible, when tools are deferred or loaded, how hosted and client-owned discovery differ, when the agent should abstain, and how selection stays separate from authorization, execution, outcome, and adoption.

- Skill: `asdc163/pm-ai-tool-search-to-selection` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add asdc163/pm-ai-tool-search-to-selection`
- Raw SKILL.md: https://api.skillmd.com/api/skills/asdc163/pm-ai-tool-search-to-selection/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- Author: asdc163 (https://skillmd.com/u/asdc163)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/asdc163/pm-ai-tool-search-to-selection

---


# PM AI Tool Search to Selection

Turn a large tool inventory into a bounded selection contract. The skill helps
a PM decide what the agent may discover and load for a job; it is not a search
engine, permission system, or tool executor.

## When to use

- the initial tool set is too large to expose every schema up front;
- tools are grouped in namespaces, MCP servers, projects, or tenant catalogs;
- the host can defer tool definitions and search/load them on demand;
- a model may choose a near-match, an unsafe side-effect, or a tool from the
  wrong workspace;
- a team needs a hosted-search versus client-owned-search decision;
- a PM needs explicit empty, ambiguous, stale, blocked, manual, or abstain
  behavior before any call or approval occurs.

## Do not use this when

- the question is the purpose, schema, side effect, or permission contract of
  one already-selected tool; use `pm-ai-tool-to-contract`;
- the question is the user's intent or whether to surface a capability; use
  `pm-ai-intent-to-discovery`;
- the question is what happens after a tool call is emitted; use
  `pm-ai-tool-call-to-recovery`;
- the question is a trace, approval, authorization, or program execution
  boundary; use the adjacent skill for that contract.

## Evidence and provider boundary

Treat current provider documentation as a mapping, not a universal host
promise:

- OpenAI tool search can defer function, namespace, or MCP tool definitions;
  the request includes `tool_search`, and deferred definitions use
  `defer_loading`.
- OpenAI documents hosted tool search and client-executed tool search as
  different ownership paths. A client path returns a matching
  `tool_search_output`; a loaded function is callable on a later turn.
- OpenAI recommends clear namespace descriptions and fewer than ten functions
  per namespace as a design guideline, not a guaranteed quality threshold.
- Programmatic tool calling is for predictable bounded processing; direct
  calling remains the default when each result needs fresh model judgment,
  approval, citations, or native artifacts.

Read the official links in
[the worked contract](references/tool-search-selection-contract.md). Record
host, provider, protocol, model, inventory version, and observed time. If any
are missing, use `Unknown`, `Not run`, `Not measured`, or `Not covered`.

## Workflow

### 1. Bind the job and inventory

Write one sentence:

> Decide whether requester `<actor>` may search inventory `<source/version>`
> within `<tenant/workspace>` for user job `<job>`, expose candidate set
> `<scope>`, load definition `<tool/version>`, and continue only through
> boundary `<next step>`.

Record the user job, workaround, requester, tenant/workspace, source class,
inventory owner, version, freshness, searchable namespace, sensitivity,
side-effect class, permission context, and the independent outcome oracle.

Do not start with an unbounded “find the best tool” request. Define what the
catalog may contain and which data or actions are out of scope.

### 2. Choose the discovery route

Select one route and name its owner:

- **fixed tools:** small, stable inventory; expose only the relevant tools;
- **hosted search:** the host already knows the approved inventory and lets the
  provider search deferred definitions;
- **client-owned search:** the application controls project or tenant state,
  filtering, policy, and the evidence returned to the model;
- **manual:** discovery is too sensitive, ambiguous, unavailable, or not
  representable safely.

Do not call hosted and client search interchangeable. Record who supplies the
inventory, who filters it, who loads the schema, and who can abstain.

### 3. Build an eligibility gate

For each candidate, assess separately:

1. **relevance:** does the description and schema support this job?
2. **scope:** is it in the approved tenant, workspace, project, resource, and
   data boundary?
3. **permission:** may this requester load and later call it?
4. **safety:** is the sensitivity and side-effect class allowed at this step?
5. **freshness:** is the inventory and definition current enough?
6. **completeness:** are input/output/error fields and owner documented?
7. **availability:** can this route serve the host, model, and client now?

Relevance never grants permission. A missing answer enters `blocked`, `manual`,
or `unknown`; it does not become a permissive default.

### 4. Search, inspect, and abstain

Return a candidate ledger with selected, rejected, unavailable, and not-seen
members. Include the reason, evidence, uncertainty, and the nearest
alternative. Use `empty` when no eligible tool remains and `ambiguous` when
several tools are plausible. Ask one bounded clarification or route manual;
do not invent a tool, broaden the tenant, or silently choose a side effect.

### 5. Load and record selection

Loading a deferred schema is a separate state from selecting, authorizing, and
calling it. Record tool name, namespace/server, definition/version, freshness,
candidate evidence, permission check, and next boundary. If a client-owned
search returns malformed or instruction-shaped metadata, reject it as
untrusted search data and preserve the policy boundary.

### 6. Route predictable processing carefully

Use a bounded program only when code can filter, join, rank, deduplicate,
aggregate, or validate a known shape without fresh model judgment between
steps. Keep direct model/tool calls for approval, semantic judgment, citations,
native artifacts, and any stage where the next decision depends on the raw
result. Define eligible tools, output schema, evidence, concurrency, retry,
and stopping limits before choosing the program route.

### 7. Separate selection from outcome

Use distinct labels:

`candidate found` → `candidate eligible` → `schema loaded` → `tool selected` →
`authorization checked` → `call requested` → `result received` →
`outcome verified`.

A search result is not authorization, a loaded schema is not a call, a call
result is not a business outcome, and any outcome is not adoption. Name the
independent evidence or use `Not verified`.

### 8. Write the privacy-safe receipt

Return these sections:

1. `## Decision and user job`
2. `## Inventory and discovery route`
3. `## Candidate eligibility and selection`
4. `## State and recovery matrix`
5. `## User controls and action boundary`
6. `## Evaluation and release gate`
7. `## Privacy-safe receipt`
8. `## Not covered`

The receipt may contain safe IDs, counts, classes, version, freshness,
decision, and redacted reasons. Do not include raw tool schemas, catalog
payloads, customer records, credentials, tokens, cookies, or private URLs.

## Output contract

Produce an evidence-bounded selection contract, not a ranked list pretending
to be truth. It must state the job and human owner, inventory boundary,
discovery route, candidate eligibility, alternatives, selected/abstained
state, schema-load evidence, permission boundary, user controls, separate next
contract, evaluation oracle, and unexecuted scope. Use `Not provided` when a
source or host fact is absent.

## Edge cases

- the description matches but the tool belongs to another tenant;
- a namespace is so broad that its summary hides a sensitive function;
- a deferred schema is stale or cannot be loaded;
- two tools have the same purpose but different side effects or freshness;
- the catalog is empty, unavailable, rate-limited, or client search malformed;
- a search result asks for a secret or instructs the host to bypass policy;
- a selected tool is allowed to load but not allowed to execute;
- a predictable program can aggregate results but would erase citations or
  require fresh model judgment;
- the user cancels after discovery and before authorization or execution.

## Minimum evaluation set

Evaluate normal, mismatch, and recovery routes:

- one fixed small inventory and one deferred namespace;
- hosted search and client-owned search with different owners;
- relevant candidate, near-match, duplicate capability, and no candidate;
- wrong tenant, stale schema, missing permission, sensitive side effect, and
  unavailable provider;
- malformed client search output and instruction-shaped catalog metadata;
- inspect, clarify, refresh, cancel, manual, abstain, and stop controls;
- direct route versus bounded program route with evidence/citation needs;
- independent authorization, tool-call, result, and business-outcome checks;
- mobile, keyboard, and accessibility behavior when a real host exists.

For each case record host/provider/version, expected and observed result,
privacy impact, and `Not run` or `Not covered` when evidence is absent.

## Decision rule

Choose `Proceed`, `Pilot`, `Hold`, `Fallback`, or `Stop`. Choose `Pilot` when
the contract is coherent but live search relevance, scope safety, route
ownership, or outcome evidence is missing. Never convert a loaded schema,
provider capability, token estimate, or GitHub signal into selection quality,
adoption, or star-growth evidence.

## Final check

Before returning the contract, confirm that:

- inventory, tenant/workspace, requester, version, freshness, and route owner
  are named;
- relevance, permission, safety, side effect, freshness, and availability are
  separate gates;
- hosted search, client search, fixed tools, and manual route are not conflated;
- empty, ambiguous, stale, unavailable, blocked, loaded, selected, cancelled,
  and unknown states have observable recovery;
- result metadata cannot widen policy or request secrets;
- selection, authorization, call, result, outcome, and adoption remain
  separate;
- provider references and support limits are current and clearly labeled;
- the receipt contains no raw catalog content or credentials;
- the final decision and next action remain human-owned.

