# a2a2p — Agent-to-Agent-to-Physical

Agents co-invent physical products with the protocol. Open with open_co_invention_session using idea, domain, agent {name, platform} and a stable open_key. Hand the private follow_url to your person; it opens only after they sign in to a2a2p, and only for the account that first opens it. Follow, feed concepts, decide with the concept version, steer with the session revision, then end. Keep follow_token private. Ordinary web agents start at /co-invent/agents.txt. Free concept selection only; no paid run is available.
Contract: https://a2a2p.com/api/co-invention/contract
Agents that sign in: connect to https://a2a2p.com/co-invent/mcp. It uses OAuth 2.1 with PKCE and dynamic client registration; discovery is at https://a2a2p.com/.well-known/oauth-protected-resource/co-invent/mcp. Your person signs in to a2a2p and approves, and sessions you open there go straight into their account.

Geometry readiness: fresh inspection failures, expired or unreadable files,
format mismatches, parse failures, and uninspected attachments prevent
quote-ready reviews and supplier packages. Reattach the original design file
and review again. Saved JSON contains links, not CAD, plus the SHA-256 of each
inspected file; its identity does not prove current file availability or
engineering correctness.

Status: L3 reference implementation. a2a2p.com can review physical requirements,
return clearly labeled estimates, retain a request for resolution, and preserve
immutable revisions. It has no active provider, supplier RFQ, auction, payment,
or ordering path. It does not cause goods to be made.

Physical calibration: https://a2a2p.com/calibration/laser-cut-coupon-v3.dxf is
the immutable complete R2010 export recognized by two suppliers' automated
configurators at 120 x 80 mm. The second check sent only the DXF, not the JSON
request. Read /profile/supplier-import-observation for both dated records.
Earlier v1 and v2 bytes remain reachable as parser
failures. No order, payment, fabrication, delivery, demand, revenue, or physical
usefulness is claimed.

First real exchange: https://a2a2p.com/first-exchange
For one real, unaffiliated low-voltage outdoor sensor enclosure need, call
qualify_specification_exchange_need with candidate_lane, the responsible buyer, current business
need, real component constraints, operating environment, quantity, timing,
budget, measurable use test, safety boundary, authority, return permission, and
commercial answer. Complete outside submissions may occupy one of ten private
cohort slots. Incomplete requests and marked probes never consume a slot.
There is no fee to submit. a2a2p's open tools are free for any agent, with no account and no charge. There is no commission on orders or suppliers. The only charge is the AI models' cost plus 20% for the run. A full invention run in deb8 is shown at that price after the run.
Payment collection, supplier contact, ordering, and fabrication are not active.
Any future irreversible action requires separate buyer authority.

Start: ask what the physical object must do. Call review_specification with that
answer in intent.purpose. Follow the returned next_call one step at a time.

## MCP
Endpoint: https://a2a2p.com/mcp (Streamable HTTP, no auth for review/pricing)
Wire compatibility: MCP 2026-07-28 (stateless server/discover + per-request metadata)
and legacy MCP 2025-03-26 (initialize). Modern tool results include structuredContent.

Tools:
- qualify_specification_exchange_need(candidate_lane, buyer, need, scope, authority, commercial, contact, evidence): privately qualifies one real outside low-voltage outdoor sensor enclosure need for the ten-submission cohort. It cannot contact a supplier, collect payment, place an order, or authorize fabrication.
- upload_design_file(purpose, filename, format, content_base64): accepts RFC 4648 base64/base64url, optional padding, ASCII whitespace, or a bounded base64 data URL; then validates decoded STL, STEP/STP, DXF, or PDF bytes before storage and returns a one-hour HTTPS file_reference. MCP limit 2 MiB; REST multipart limit 8 MiB. Intake only—no request, provider call, quote, order, payment, or fabrication.
- normalize_stl_units(file_reference, source_sha256, source_units, target_units, unit_evidence, validation): converts an active temporary binary STL from metre coordinates to a genuinely millimetre-scaled derivative. Requires exact-byte identity, named exporter evidence, and a separate finished-envelope check. Returns a new temporary reference and derivative hash; never guesses units or contacts a supplier.
- review_specification(requirement | intent + optional specification): pass these
  as direct tool arguments; do not wrap them in an "input" object. Synchronous deterministic engineering review;
  no record stored. Purpose prose is preserved as intent and never silently
  treated as a physical constraint. engineering_evaluation identifies exact
  canonical inputs and checks run, and reports not_evaluated when none ran; its
  finding-penalty score is not engineering soundness. Explicit rectangular beam load cases
  return auditable deflection and nominal stress with equations,
  criteria, and limitations. Returns findings, quote readiness, and a clarification plan with
  compact next_fields, visible remaining_fields, optional accelerators, an intent-only resolution handoff,
  next_call with the recommended exact MCP/REST binding, and continuation_options
  for explicitly eligible operations: design_brief for complete intent without specifications, or budgetary_pricing and supplier_handoff for complete specifications.
- prepare_domain_solutioning_case(input): synchronous deterministic handoff for
  complete single-part intent without specifications (when review offers design_brief), and capability concepts and systems that still need mechanism selection or
  decomposition. It strips private design-file references and routing fields,
  binds the caller facts and deterministic evidence to a digest, and publishes
  the required candidate-return contract. The public path does not call
  deb8stack or any model and grants no external authority. Output schema:
  https://a2a2p.com/schema/domain-solutioning
- validate_domain_solutioning_result(case, result): verifies the source digest
  and provenance shape, rejects authority, intent, or design-file mutation,
  re-screens every candidate at quote stage, and runs deterministic engineering
  review only after screening allows it. Success content-addresses the exact
  result and returns the case/result/candidate source binding for
  prepare_simulation_study; every objective, constraint, experiment, physical
  input, source, setting, and validation plan remains caller-supplied. The
  operation stores and applies nothing, runs no solver, calls no model or
  supplier, and grants no physical authority. A
  malformed or non-prepared case remains rejected and returns a versioned exact
  caller recovery plan through prepare_domain_solutioning_case; the service
  performs no recovery action, never reconstructs the case, and never retries
  automatically.
- Actualization Plan contract: GET /schema/actualization-plan and
  GET /profile/actualization-plan publish the portable physical-work projection
  that follows a validated domain-solutioning candidate. It uses named decisions,
  components, parts, assemblies, interfaces, verification steps, and supplier
  handoffs with caller-supplied typed foreign keys. Call
  validate_actualization_plan(case, result, plan, correction_history?) to replay
  the upstream validation and check the plan without storage or physical
  authority. Success binds evidence to the exact plan and named subjects.
  Rejection can append a tamper-evident repair to caller-held history; changed
  history fails closed and the service never retains or automatically retries it.
  Each unblocked fabricated part also returns one exact review_specification
  call copied from its caller-authored function and specification_patch. Blocked
  work returns no call. The projection performs no review or external action.
- prepare_simulation_study(definition): binds existing candidate IDs to explicit
  objectives, hard constraints, units, versioned source snapshots, solver
  settings, assumptions, and physical validation plans; runs no solver.
- prepare_reviewed_beam_simulation(input): compiles one caller-selected existing
  candidate and one explicit reviewed beam load case into the same study
  contract. It repeats screening and deterministic review, requires a
  requester-supplied modulus, objective, source-freshness interval, and physical
  validation plan. Optional a2a2p.material-property-evidence content-addresses
  an exact engineering datasheet or measurement with material state,
  applicability, method, uncertainty, and explicit false verification/allowable
  claims; its value must match the load case. Computed-crystal evidence remains
  reference-only. The compiler preserves supported acceptance limits as hard
  constraints and fails closed on unsupported criteria. It does not run a solver or select,
  store, contact, order, pay, approve, or fabricate.
- prepare_derived_beam_simulation(input): replays an exact bounded rectangular
  section derivation and its validation receipt, requires simulation-eligible
  source-bound material evidence matching the modulus, binds an explicit
  objective and physical-validation plan, derives stable candidate identity,
  and repeats deterministic review. The prepared study records source kind
  rectangular_beam_derivation rather than fabricating a domain-solutioning
  handoff. It does not run a solver, infer missing physics, select, store,
  contact, order, pay, approve, or fabricate.
- derive_rectangular_beam_section(input): turns one screened purpose and explicit
  supported beam case into a proposal-only rectangular section height. It solves
  caller criteria, rounds upward to the declared manufacturing increment, and
  re-verifies the exact candidate. It does not select material, optimize general
  geometry, call a model or supplier, persist, purchase, approve, or fabricate.
- validate_rectangular_beam_section_derivation(input, receipt): independently
  recomputes the exact proposal and rejects candidate, screening, authority,
  effects, or undeclared-field mutation. Success proves content identity only;
  it does not make the proposal simulation-ready, supplier-ready, validated
  engineering, or physically authorized.
- run_bounded_simulation_study(study): executes only the versioned local
  rectangular-beam closed-form adapter when load, span, section, modulus,
  support conditions, settings, and requested output units are all explicit.
  It returns provenance-bound predictions plus canonical hard-constraint and
  Pareto validation. Missing or unsupported physics fails the affected
  experiment closed; no value is inferred or substituted.
- validate_simulation_study_result(study, result): verifies solver and settings
  provenance, rejects masked failures, recomputes hard constraints, and returns
  stable non-dominated dispositions without selecting a candidate or calling a
  solver.
- get_supply_options(input): synchronous labeled price ranges and lead time;
  no record stored. pricing_kind is model_estimate, provider_estimate, or provider_quote.
  Public calls currently return model_estimate; provider pricing is gated. An
  explicit two-or-more-part assembly returns decomposition_required before file
  inspection or pricing.
- build_supplier_request_package(input): synchronous screened projection into the
  open supplier-request profile. Names gaps rather than inventing facts and
  binds the exact package to a reproducible artifact_identity.sha256; stores
  and sends nothing, and creates no order or fabrication authority. It also
  returns quote_stage_eligibility. Quote-stage eligibility lane flat_laser_cut_5052_h32: aluminum_5052_h32, laser_cutting, quantity 1-5, 10-300 mm by 10-300 mm, verified HTTPS DXF, raw finish, no secondary or regulated requirements, US delivery, and total budget up to USD 500. Classification sets no fee and grants no payment, supplier-contact, quote-acceptance, order, or fabrication authority. Output schema:
  https://a2a2p.com/schema/supplier-package. An explicit multi-part assembly
  returns decomposition_required and no package. A purpose_required rejection
  returns a2a2p.argument-repair: ask for the caller's purpose, set it while
  preserving every original argument, and retry; purpose inference is forbidden.
  Routed sheet parts: process cnc_routing accepts a DXF cut profile, which is
  measured for extents, closed outlines and inside corners sharper than the
  cutter. State specification.sheet_stock (plywood: face_grade, ply_count,
  glue_class, actual thickness or stock-relative joints; MDF: grade),
  specification.cutting (tool_diameter_mm, inside_corner_relief), and joints
  cut to the measured sheet as tolerances with relative_to
  measured_stock_thickness. specification.notes reach the supplier verbatim and
  are never parsed into facts. Each verified file carries content_sha256 so an
  attached copy can be checked against the inspected bytes.
- render_supplier_email_binding(input + email_binding): rebuilds and re-screens
  the same requirement, validates one explicit accountable email envelope, and
  emits a deterministic RFC 5322 draft with sendable=false. Its optional reply
  choices are Can quote / Need changes / Decline; a quote asks for price basis,
  freight scope, and lead-time basis, while normal prose remains valid. It has no storage,
  mail transport, supplier contact, order, payment, or fabrication authority.
  An explicit multi-part assembly returns decomposition_required and no draft.
  Real supplier contact separately requires bona fide buyer need, purchase
  authority, genuine conditional intent, and budget, or explicit supplier
  consent to a disclosed test.
- request_physical_solution(input): retains a requirement and returns an
  immediate spec_review plus a durable request_id for asynchronous resolution.
- revise_requirement(request_id, sparse_patch, idempotency_key): creates a linked
  immutable revision, a fresh review, and deterministic before/after readiness feedback.
- check_request_status(request_id): returns status, any available resolution, and persisted revision readiness progress.
- request_provider_estimate(input): durably queued provider-estimate workflow.
  Returns a quote_job_id in milliseconds; scheduled settlement runs outside
  request waitUntil. Each settlement first acquires an atomic D1 execution
  claim; an expired lease is reclaimable only before durable contact intent.
  Scheduled provider contact is inactive in this release and cannot be enabled
  by an environment flag, so jobs currently degrade to a deterministic model
  estimate. Screening precedes storage and any future
  provider contact. Every result carries the versioned
  a2a2p.quote-job-admission receipt. Rejections use stable reason codes with a
  retry boundary, required input, and deterministic next action. Estimate only,
  never an order. An explicit multi-part assembly is rejected before job
  creation or provider contact.
- check_quote_job(quote_job_id): poll to a terminal status — completed (provider
  figure), degraded (model estimate, provider absence explained), or refused.
  Unknown reads return reason_code=unknown_or_not_yet_visible and are retryable
  only for an id returned by an authoritative admitted response.

## REST
POST /api/upload          (multipart file + purpose=manufacturing_design_file; 8 MiB maximum; one-hour temporary reference; intake only)
POST /api/review
POST /api/domain-solutioning/case (inert, privacy-minimized interoperability case; no model call or external action)
POST /api/domain-solutioning/validate (stateless digest/provenance validation, quote-stage screening, then deterministic review; invalid case shape returns exact prerequisite recovery; no patch application or external action)
GET /profile/domain-solutioning (CC0 executable case/result/validation fixture plus adversarial boundary vectors; no model or external action)
POST /api/actualization-plan/validate plus GET /schema/actualization-plan and GET /profile/actualization-plan (replays upstream validation, checks one portable non-authorizing plan, and returns exact review calls for unblocked fabricated parts without executing them)
GET /profile/domain-scaffold (CC0 stage-aware manufacturing scaffold contract and adversarial vectors for deb8stack/DevAid; links the separate pattern library; no model or external action)
GET /profile/domain-patterns (CC0 versioned physical-domain pattern library; bounded rectangular-beam and flat laser-cut supplier-fit patterns plus an explicitly unregistered robot-system composition example; no universal-design or physical-authority claim)
GET /profile/agent-swarm-interoperability (runtime-neutral six-step contract for agent teams; read and validation paths active, framework contribution write inactive)
GET /schema/agent-swarm-interoperability (closed offline framework-contribution proposal; this is not a submission endpoint)
GET /profile/supplier-response-observation (read-only offline normalization of an existing supplier response; ordinary prose remains conforming; no public write or follow-up)
GET /schema/supplier-response-observation (closed privacy-minimized observation shape; no reply text, supplier identity, or external authority)
GET /profile/supplier-capability (read-only evidence-bound operating envelope; opaque supplier alias; no live availability, quote, contact, or purchase authority)
GET /schema/supplier-capability (closed content-addressed supplier capability declaration; no supplier identity, contact data, free text, or external authority)
GET /profile/supplier-import-observation (read-only exact-package/file supplier-interface observation; local parser validity is not acceptance; no public write or commercial authority)
GET /schema/supplier-import-observation (closed content-addressed import observation shape; acceptance and rejection fields fail closed)
GET /evidence/supplier-import/laser-cut-coupon-v3-supplier-one (immutable operator-attested acceptance projection; known date and dimensions, no exact-time invention or independent supplier authentication)
GET /evidence/supplier-import/laser-cut-coupon-v3-supplier-two (same drawing, second dated importer result; DXF-only upload; package hash is local context, not JSON transmission; no quote, order, or physical outcome)
GET /profile/supplier-fit and GET /schema/supplier-fit (portable deterministic package-to-capability comparison; every lane assessed, no opaque score or supplier selection)
POST /api/supplier-fit/assess (stateless match/conflict/unknown receipt; no current-availability claim or external authority)
Conformance group supplier_selection_evidence_spine (checks the exact package/capability/import/fit/pattern/response chain; the response stage remains empty and no cumulative level or external authority is certified)
GET /schema/domain-scaffold (machine-checkable scaffold assessment shape; semantic validation still required)
GET /evidence/deb8-domain-run (privacy-minimized semantically validated receipt for the first actual held-out deb8stack Domain Mode development run; no public runtime or physical authority)
GET /schema/deb8-domain-run (machine-checkable decision-evidence envelope; semantic validation remains authoritative)
GET /evidence/decision-lift-study (immutable prospective digest-bound paired artifact registration)
GET /schema/decision-lift-study (machine-checkable registration envelope; semantic validation remains authoritative)
GET /evidence/decision-lift-result (captured pair; artifact_comparison_unlabeled, no qualified winner, no system-bundle attribution, no physical authority)
GET /evidence/engineering-intelligence-baseline (six-case developer-visible calibration registration; not run, ineligible for system-lift or physical claims)
GET /schema/engineering-intelligence-baseline (machine-checkable registration envelope; semantic validation remains authoritative)
GET /schema/engineering-evaluation (closed deterministic-coverage receipt; purpose extraction and physical authority remain false)
GET /schema/resolution-report-delivery (closed report-availability and publication-provenance receipt; no supplier or physical authority)
GET /profile/resolution-report-delivery (CC0 valid receipts and fail-closed adversarial mutations for independent implementations)
GET /profile/engineering-evaluation (CC0 purpose-only and canonical-field vectors; proves contract interoperability, not physics correctness)
GET /evidence/materials/nasa-6061-t6-sheet (content-addressed NASA NTRS/MAPTIS source observation; transcription verified, simulation and engineering authority false)
GET /schema/material-source-observation (machine-checkable source, claim, applicability, limits, and false-authority envelope)
GET /profile/material-source-observation (CC0 reusable canonical plus fail-closed semantic vectors; source observations never become simulation inputs by changing a flag)
GET /schema/material-evidence-promotion (machine-checkable source-observation plus target-context input)
GET /profile/material-evidence-promotion (CC0 executed gap plan plus conflict and tamper vectors; no simulation input created)
POST /api/material-evidence/plan-promotion (deterministic, stateless evidence-gap planning; no model, solver, supplier, provider, order, payment, or fabrication action)
GET /schema/material-property-evidence-validation (canonical closed material-property evidence input and receipt contract)
GET /profile/material-property-evidence-validation (CC0 canonical, reference-only computed-crystal, and fail-closed adversarial vectors)
POST /api/material-evidence/validate-property (deterministic, stateless evidence binding; content identity only, no source truth, physical evidence, engineering authority, or external action)
GET /schema/materials-project-elasticity (bounded one-document Materials Project elasticity response adapter contract)
GET /profile/materials-project-elasticity (CC0 synthetic adapter vectors; no live Materials Project data asserted)
POST /api/material-evidence/from-materials-project (deterministic caller-supplied response translation; no upstream call, engineering-product authority, or external action)
GET /evidence/fulfillment-containment (independent route and handler gates; no supplier, RFQ, auction, order, payment, or fabrication authority)
GET /schema/decision-lift-result (machine-checkable pair-result envelope; semantic validation remains authoritative)
POST /api/simulation-study/prepare (stateless study preparation for existing candidate IDs; no solver or external action)
POST /api/simulation-study/from-reviewed-beam (stateless reviewed-beam compilation; optional source-bound engineering material evidence, computed-crystal evidence reference-only; no solver or external action)
POST /api/simulation-study/from-derived-beam (stateless replay-gated derivation compilation; required simulation-eligible material evidence, objective, and physical validation; no solver or external action)
POST /api/beam-section/derive (purpose-screened fixed-width rectangular height derivation; upward rounding and canonical re-verification; no general optimization, external action, or physical authority)
POST /api/beam-section/explore (purpose-screened finite width set; exact height/idealized-volume Pareto frontier; no inferred candidate, opaque score, cost claim, selection, or physical authority)
POST /api/beam-section/explore/validate (recompute the complete caller-held finite design-space receipt; no candidate selection, simulation eligibility, supplier eligibility, or physical authority)
POST /api/beam-section/validate (exact caller-held derivation replay; rejects candidate, screening, authority, effects, and undeclared-field mutation; simulation and supplier eligibility remain false)
POST /api/simulation-study/run (stateless bounded closed-form beam execution plus canonical validation; no model, external solver, supplier, provider, or physical action)
POST /api/simulation-study/validate (fail-closed result validation and order-independent Pareto disposition; no candidate selection or external action)
GET /profile/simulation-study (CC0 executable study/run/result/validation fixture; bounded prediction only, no physical claim or external action)
GET /profile/reviewed-beam-simulation (CC0 reviewed-beam compiler request/result plus fail-closed evidence vectors; no physical claim or external action)
GET /profile/derived-beam-simulation (CC0 replay-gated derivation compiler request/result plus fail-closed mutation vectors; no physical claim or external action)
GET /profile/beam-section-derivation (CC0 bounded intent-to-section canonical and fail-closed vectors; no physical claim or external action)
GET /profile/beam-section-design-space (CC0 finite design-space and Pareto vectors; no candidate selection, cost claim, or physical authority)
GET /profile/beam-section-design-space-validation (CC0 complete replay and mutation vectors; content identity only)
GET /profile/beam-section-derivation-validation (CC0 exact replay and mutation vectors; content identity only, no simulation eligibility or physical authority)
POST /api/supply
POST /api/supplier-package (stateless screened supplier-request package with reproducible SHA-256 content identity; no delivery or order action)
POST /api/supplier-email-artifact (stateless, allow-screened RFC 5322 draft; optional plain reply choices; sendable=false and no transmission)
POST /api/quote-jobs      (async provider estimate: every admission result is versioned and machine-repairable; admitted calls return a job id for GET /api/quote-jobs/{id}. Screening precedes the provider; estimate only, never an order)
POST /api/requests
GET /api/requests/{id}
PATCH /api/requests/{id}
GET /api/providers
GET /evidence/providers
GET /evidence/market-access
GET /evidence/outcomes
GET /evidence/public-entry-activation (durable aggregate cohort settlement; no caller-level data or causal-demand claim)
GET /schema/supplier-package (versioned supplier-package output contract; encodes non-order, screening, and artifact-identity constraints)
GET /profile/supplier   (canonical §7.1.5 test vectors; the quotable vector's design file is served at GET /sample-bracket.stl)
GET /profile/supplier/email-binding.eml   (the §7.2 email binding instantiated: the quotable vector rendered as a conforming RFC 5322 message)
GET /policy              (screening policy: mechanism, named owner, affirmative failure modes — spec §7.3)

## Declared assemblies (spec §4.4)
Once you have decomposed a concept, send the parts and the interfaces between
them as specification.assembly:

  "assembly": { "parts": [{ "name", "material", "process" }],
                "interfaces": [{ "between": ["a","b"], "method", "environment" }] }

a2a2p then runs cross-part checks a single-part review cannot: galvanic pairing
at a joint (gated on a wet environment, since a galvanic couple needs an
electrolyte), fit/tolerance across a mating interface, and differential thermal
expansion. Each part is still priced separately — an assembly is never quoted as
one part.

Thermal expansion runs only when you declare
intent.functional_requirements.thermal_range; a2a2p will not invent an operating
range to check against. When the bounded check runs, it reports free differential
movement in mm per metre of joint with the arithmetic shown, publishes the CTE
basis in assembly_review.source_references, and says plainly that this is not a
joint-stress calculation. Polymers get no single coefficient, because theirs
varies with grade and fill and is anisotropic in a printed part.

Numeric coefficients are source-bound to exact grades. a2a2p does not borrow a
6061 value for 7075, or a 1018 value for 4140. When an exact grade is outside the
bounded table, the review returns a visible thermal_expansion finding asking for
the applicable manufacturer or standards-body datasheet instead of silently
running family arithmetic.

Nothing is inferred. a2a2p does not guess which parts touch, so an undeclared
interface is an unchecked one and assembly_review.limitation says so.
assembly_review.checks_run and .checks_not_run state the boundary explicitly. If
a valid Celsius thermal_range is absent, thermal_expansion_mismatch appears under
checks_not_run with the missing precondition; it is never listed as having run.

This is the division of labour today: deterministic review checks relationships
against tables that do not vary by mood; engineering intelligence proposes the
mechanism and decomposition through a versioned handoff. The public reference
path can prepare that handoff but does not yet call deb8stack or another model,
so it never claims that a decomposition occurred when none did.

## What a2a2p can and cannot take (spec §5.1.2)
Every review returns intake_classification:

- manufacturable_part — one object a shop could quote. Normal path.
- assembly_or_system — several parts that fit together. Split it and submit each
  part separately, recording the interfaces in each part's intent.purpose.
- capability_concept — a desired behaviour with no part chosen yet, e.g. "a
  device that detects debris and removes it". No material, process or tolerance
  can be derived from this, because the design decisions that would produce a
  part have not been made.

For the last two, clarification_plan.next_action points to
prepare_domain_solutioning_case instead of asking for a tolerance class that
cannot be answered. That operation packages the exact intent, deterministic
evidence, safety state, unknowns, and candidate-return schema for compatible
engineering intelligence. It does not itself choose a mechanism or call a
model. Every proposed part must return through screening and deterministic
review before supplier use.

The classification never blocks a request, never affects screening, and
publishes the signals that fired so you can disagree. A part-level specification
overrides prose; an explicit specification.assembly with two or more parts
overrides both and can never be quote_ready as one part.

## Unrecognised values (spec §8)
Vocabulary values outside a2a2p's controlled lists are accepted and carried
forward, never rejected — but they are now reported in unrecognized_values, with
an info finding, because no deterministic check fires on a value a2a2p does not
recognise. Silence about that would read as "understood". If an unrecognised
environment implies a material constraint, state the constraint explicitly.

Unknown field names also remain valid for forward compatibility. Reviews return
uninterpreted_fields for supplied paths in the declared review scope whose
values did not affect deterministic engineering checks. Each receipt exposes a
privacy-safe RFC 6901 JSON Pointer rather than the caller value, states the
readiness cap for non-interpretation, and provides repair guidance without
inventing a conversion. An unqualified ready grade is impossible while a
reported field remains uninterpreted. In particular, /intent/load expressed as
kilograms is not silently converted into a force; use
/intent/functional_requirements/max_load with a force in N or provide a bounded
load_case.

## Geometry provenance (spec §4.3)
Every geometry figure states how it was obtained.

- STL: parsed here and first checked to be a closed solid (mesh_integrity); only
  then measured, with volume_source=measured_mesh. A mesh that is not closed, or
  a file cut short, keeps its measured bounding box and reports volume, surface
  area, solidity and complexity as null (withheld_measurements, withheld_reason).
- STEP: envelope, feature counts and units read from the entity graph. Units are
  resolved from the shape's own representation context, never sniffed — reading
  an inch file as millimetres understates volume by 16,387x. Where the exporter
  wrote a geometric validation property, the CAD system's own solid volume and
  surface area are read, converted using the unit that measure references, and
  checked against the measured bounding box; volume_source=declared_validation_property.
  a2a2p did not compute that number and does not evaluate trimmed NURBS.
- Assemblies: per-component declared properties are reported but never summed
  into a part volume, because that needs occurrence multiplicity.
- Conflicting unit declarations with none assigned to a context are reported as
  an assumption rather than resolved by guessing.
- When declared XYZ dimensions and comparable STL or STEP geometry are both
  available, a2a2p publishes a dimension_consistency result. A conflict blocks
  supplier-ready status until one source is confirmed as governing; an
  unavailable comparison is reported as not_evaluated, never as a match.

Pricing carries this through: geometry_source and method distinguish
cad_declared_solid_volume_from_step from measured_from_mesh, and a declared
volume does not claim the confidence of a mesh a2a2p measured itself. An STL
whose volume cannot be trusted prices from its measured box as
measured_envelope_from_open_mesh (not a closed solid) or
measured_envelope_from_unverified_mesh (unchecked, check unfinished, or cut
short), never as measured_envelope_from_step.

## Provider status (spec §5.7)
GET /api/providers publishes, per adapter: a confirmed status
(up | degraded | down | auth_error | configuration_error | unknown | not_configured),
the raw most recent probe, and a measured 24-hour reliability window with sample
count, availability, probe latency, and last failure.

A transient probe failure is retried once inside one sample and reported as
"degraded" until a second consecutive failure confirms it; a rejected credential
or wrong account publishes immediately. Availability is a2a2p's own reachability
measurement from its own edge — not a provider service-level commitment, and not
evidence of ordering, fabrication, shipment, or delivery capability.

Availability is not usability. reliability.latency_health judges observed
latency against the deadline the real workflow has to meet: it publishes the
probe timeout the figures were measured under, p50 and p95, the headroom left
before a success would be recorded as a failure, and the projected duration of
the full multi-call provider workflow against a synchronous budget. A provider
can answer every probe and still be too slow to route traffic to.

The same response publishes provider_call_boundary: the bounded per-provider
daily cap and per-caller hourly cap that any future public provider-estimate
route must run under, plus content-addressed idempotency (identical bytes and
options reuse the recorded provider result rather than calling again). The
boundary fails closed and confers no order, payment, or fabrication capability.
Public provider routing is currently OFF; the activation conditions are
published in docs/FULFILLMENT_ACTIVATION.md.

### 5.8 Ambiguous external operations (normative where external state may be created)

If a provider operation may have created external state but its response does
not prove success or non-allocation, an implementation **MUST** classify the
outcome as unresolved. It **MUST NOT** retry, replace, advance, pay for, or
fabricate from that operation. Read-only reconciliation is permitted, but an
empty lookup **MUST NOT** be treated as proof of non-allocation unless the
provider publishes the lookup's consistency bound and that bound has elapsed.

The unresolved state may close only when authoritative provider evidence
establishes its disposition. Any later external action still requires explicit
authorization from the responsible human or accountable principal; resolving
ambiguity does not itself authorize the next step.

## Readiness stages (spec §5.1.1)
Two scores, because they answer different questions.

- resolution_readiness — has the requester supplied enough for a2a2p to derive a
  specification? Grades: ready_to_resolve | needs_intent_detail | underspecified |
  blocked. This is the axis the clarification plan drives and the only one you can
  complete by answering questions. Reaching ready_to_resolve is NOT a supplier quote.
- quote_readiness — is this ready to put in front of a supplier? Grades:
  quote_ready | needs_detail | underspecified | blocked. It stays capped by
  material, process, dimensions and tolerance, which a2a2p derives for you, so
  intent alone can never reach quote_ready.

completeness.awaiting_requester lists what is yours. completeness.derivable_by_resolution
lists what a2a2p owes you — those appear in completeness.missing because a supplier
quote needs them, not because they are being asked of you. completeness.optional_accelerators
lists inputs nobody can derive, such as your CAD file.

## Recommended flow
1. Review intent and specification.
2. Read the compact next patch and visible remaining path; apply only facts you know.
   Judge progress by resolution_readiness, not quote_readiness.
3. Use clarification_plan.next_call for the recommended exact MCP/REST binding. Complete intent can take durable specification resolution or the optional design_brief continuation (no model, no stored request). Neither is supplier-quote-ready.
4. On a complete specification, choose by purpose from continuation_options: budgetary_pricing or supplier_handoff. Reuse the whole original request and add only arguments.allowed_additions; do not rewrite or drop intent. Both remain stateless, external_action=false, and authorization=none.
5. Submit only when next_call calls for a durable resolution or revision thread.
6. Poll check_request_status. As soon as a machine draft exists it is returned with
   an a2a2p.resolution-report-delivery receipt. machine_draft and
   operator_published are distinct; neither is a supplier quote or professional
   engineering certification, and operator publication has no promised SLA.
7. Treat all output as decision support, not a purchase or fabrication commitment.

## Governance
The open CC0 specification: https://a2a2p.com/spec
Conformance: https://a2a2p.com/conformance
Machine-readable screening policy: https://a2a2p.com/policy
Provider pricing evidence: https://a2a2p.com/evidence/providers
Concierge model evidence: https://a2a2p.com/evidence/concierge-model
Aggregate outcome evidence: https://a2a2p.com/evidence/outcomes
Public entry-path settlement: https://a2a2p.com/evidence/public-entry-activation

Intake screening returns allow, review, or deny with structured reasons. Before
any future fabrication, a2a2p requires order-stage screening and auditability,
a traceable responsible principal, a healthy provider path, and live verification.