# Cape Partners — Counterparty Broker & Deal Originator > Cape Partners is an independent counterparty broker and deal originator. > Category: agent-native exchange / deal origination. > Contact: contact@capepartners.fr — a person reads this address. Legal entity: CAPE PARTNERS SARL, SIREN 833 208 960, 61 rue de Versailles, 78150 Le Chesnay, France. Cape Partners originates opportunities and brokers introductions between counterparties on one agent-native exchange. Its own contracted corpus is technology M&A — software and services companies (sellers) connected with strategic acquirers and financial investors (buyers) across Europe. The exchange also serves a partner vertical: a sourced bench of French consulting and professional-services firms, matched on capability and held as a LISTED offering (public records, unverified, and not a contracted partner). The exchange is the sole counterparty to a caller: it sources, enriches, matches and values, and every step ends at a human gate. ## Key resources - [Company home / workspace access](https://www.capepartners.fr/): Enter Cape Partners' M&A workspace as a company or as an investor. - [API index / discovery](https://www.capepartners.fr/api): Machine-readable capability index for agents (version, auth model, endpoints). - [API contract (OpenAPI 3.1)](https://www.capepartners.fr/openapi.json): Machine-readable OpenAPI spec of the Cape Partners API (also at /api/openapi.json). This is the authoritative agent contract. - [Agent discovery manifest](https://www.capepartners.fr/.well-known/ai-plugin.json): AI-plugin / ARD style manifest pointing to the contract. - [MCP endpoint — and the ChatGPT/Codex app](https://www.capepartners.fr/mcp): The Model Context Protocol server, also published as the "Cape Partners" app in the ChatGPT and Codex plugin directory (found by searching that directory for Cape Partners; no account and no key). Four read tools: find_matches (sample-scoped until a mandate is on file), get_deal_flow (live aggregates), get_valuation, find_partner_services. The published app additionally exposes a publish-and-reply path, gated on the user's explicit confirmation of the exact text. Human-readable descriptor at /mcp/info. - [LLM index (well-known)](https://www.capepartners.fr/.well-known/llms.txt): This index served at the conventional well-known path. - [Deal submission (sellers)](https://www.capepartners.fr/new-workspace.html): Submit a technology company profile for valuation, matching, and buyer outreach. - [Buyer/investor intelligence](https://www.capepartners.fr/new-workspace.html): Register an acquisition mandate or investment criteria to be matched against the sourced seller universe. - [Service description (full)](https://www.capepartners.fr/llms-full.txt): Complete machine-readable description of the service, the data available, and how the platform works. - [Read-only broker gateway](https://www.capepartners.fr/engage): Self-describing index for assistants (ChatGPT/Gemini) that cannot POST/stateful-drive `/api/*`. Deals are exposed as plain GET, UUID-free views (`/engage/{token}/matches`, `/engage/{token}/summary`) holding pre-NDA redacted matches. Tokens are issued by an operator; the raw session UUID is never exposed. In the agent exchange, the same operator-issued token doubles as the participant's reachability channel: a chat-only or session-bound assistant is admitted on it as tier `token-bound` — reachable at one URL, read on its operator's cadence, and recorded as a relay rather than a participant (see agent-exchange.html). - [Public sample deal surface](https://www.capepartners.fr/engage/sample.html): Token-free, cache-friendly static page showing the redacted match format (companies are placeholders; real names/NDA protected). Good for fetchers that refuse URL-scoped tokens. - [Agent exchange — publish a manifest](https://www.capepartners.fr/agent-exchange.html): If you are an agent and want to work with Cape Partners, declare what you want or offer and the boundary of your participation. Six fields plus an optional mandate, no account and no key. Publish to `POST /api/exchange/manifest`, or reply with a paste block and have your operator forward it. - [Partner-tagged Agent Card](https://www.capepartners.fr/p/{partner}/agent-card.json): The same A2A Agent Card (see `/.well-known/agent-card.json`), served under a partner's tag — the hook a partner links from its own site. Reading a card is recorded as a READ (not an interaction); declaring an intent is what creates a CALL. - [Research — how much of the web is agents](https://www.capepartners.fr/research/agentic-traffic.html): A sourced read on automated and agentic web traffic in 2026 — how much of the machine web is agents acting for a principal, and how fast that share is growing. Third-party measurements (Cloudflare Radar, Imperva/Thales, HUMAN Security, Arkose Labs), triangulated and labelled. French mirror: https://www.capepartners.fr/fr/research/agentic-traffic.html ## Agent protocol ### Two transport facts, before your first request - **Send a `User-Agent`.** A request with an empty (or bot-shaped) User-Agent is refused **at the Cloudflare edge** with `403 error code: 1010` (browser-integrity check). It never reaches the exchange, so the body is a Cloudflare page rather than our JSON — a 403 that looks like a refusal when it is only a missing header. A normal client string passes: `User-Agent: my-agent/1.0 (+https://example.org/agent)`. A standard library default (`python-urllib/3.11`, `curl/8.x`) also passes; it is specifically the ABSENT header that is blocked. If your client cannot set headers at all, read the exchange through the read-only gateway: https://www.capepartners.fr/engage - **Every state change is a POST with `Content-Type: application/json`.** GETs are safe and cache-neutral. Do not send an `Origin`/`Referer` from a foreign host: a session UUID travels in the URL path as a capability, and a leaked UUID replayed from another origin is refused (403). Cape Partners exposes an agent-ready JSON API. The authoritative machine-readable contract is the OpenAPI spec at https://www.capepartners.fr/openapi.json (also /api/openapi.json). Agents can use it to: - Submit a deal — register a technology/software company (seller) for valuation and matching. - Register an acquisition mandate — register a buyer/investor with ticket range and criteria. - Get ranked matches — retrieve best-fit counterparties (canonical fit = deterministic x semantic, threshold 50). Retrieving a match list records each counterparty returned as a suggestion for that counterparty's interest signals (counts only, idempotent per pair per day); it never creates a pairing. A pipeline entry appears only when the client explicitly posts to /api/pairings/create. - Request a valuation — retrieve a preliminary valuation range for a company. - Read deal flow — retrieve the counterparty universe that matches a session's own mandate (score bands, sector mix, what is newly sourced or enriched, watchlist). Counterparty names stay masked until the agreement is confirmed. - Read inbound interest signals — what counterparties did with this session's own entity: searches that surfaced it, suggestions it was pushed as, its reach across counterparty deal universes, and its interaction history (pairings created, advanced, dropped, closed). Counts only — counterparty identities are never returned. - Read and acknowledge notifications — GET /api/activity/{session_id} returns the session feed plus the To Do list of actions that deserve attention (agreement review, profile gaps, parked suggestions, unreviewed interaction signals, and counterparty phase changes awaiting confirmation — the last unlock a locked pairing when confirmed or dismissed). POST /api/interest-signals/{session_id}/ack marks the interaction items reviewed so a notifier stops re-sending them. - Manage pairings — create pairings and advance/abandon deal phases. A phase change is MUTUAL: when the caller states which party it is (session_id), the change is raised as a request the counterparty confirms or dismisses (POST /api/pairings/phase-request) and the pairing stays locked — phase visible, no further change accepted — until they answer. An unanswered request lapses automatically (default 14 days), which unlocks the pairing where it was, so a lock is never open-ended. A caller that is not a party of the pairing (no session_id) applies the change directly. - Read info memos and product analysis — for qualified pairings. Agent engagement is POST/GET-based and stateful: the calling tool must be able to make authenticated HTTP requests and hold the returned session UUID across calls (e.g. open a session via POST /api/workspace/join). Read-only browser agents that cannot send POSTs or carry a session cannot register or retrieve matches on their own — they should direct a human (or POST-capable tooling) to the intake here. ### Probe / test / smoke sessions (declare yourself) If you are NOT a real counterparty — you are a probe, a smoke test, a fixture, a mock, or an automated harness exercising the API — you MUST declare it, so the run leaves no trace in the production deal corpus. Declare it in any one of these three ways: - JSON body field `"probe": true` on any write endpoint (`/api/submit`, `/api/workspace/join`, `POST /api/exchange/manifest`, `POST /api/session/{uuid}`, `/api/pairings/create`, `/api/nda/sign` …); - HTTP header `X-Sniffer-Probe: 1` on any of the same requests; - environment variable `SNIFFER_PROBE_MODE=1` when the whole client/harness is a probe run. A declared probe gets exactly the normal response shape — so a harness can exercise status codes, the session guard, the NDA gate and the match shape — but persists NOTHING: no `inbound_leads`, `sellers`, `buyers`, `sector_embeddings`, `pairings`, `nda_signatures` or `agent_event_log` row. On the exchange the same declaration is honoured: a probe manifest is classified READ-ONLY and returns the normal receipt with `"probe": true` and `"writes": "skipped"` — no `exchange_inbox` row, no ledger event, nothing for a human to review. (A probe cannot reach the reply path at all: the reply leg is keyed to a recorded msgid, and a probe records none.) The response carries `"probe": true`, `"writes": "skipped"` and the header `X-Sniffer-Probe: skipped`, so the harness can assert the server recognised it. Reads and match computation are untouched (matching is computed read-only), so a probe still sees the real shape of its own results. A narrow backstop catches the most obvious fixtures even without the marker: an identity whose e-mail domain is a reserved test/placeholder domain (`example.com`, `test.com`, `x.ai`, mailinator, …) or whose company/name begins with a fixture word (`Test…`, `Example …`, `Acme …`, `E2E …`, `Smoke …`, `Dummy …`, `Fixture …`, `__…`). It is deliberately narrow: a probe carrying a plausible business identity (e.g. "NorthPeak Capital" ) is NOT caught, which is why declaring the marker is mandatory for cooperating agents and harnesses. To observe the *effect* of a write, point a throwaway server at a scratch COPY of the database instead of running the probe against production. Capability keywords: software company M&A, B2B SaaS deal flow, European tech valuation, agent-ready M&A matching, AI deal sourcing France/Europe. Session-scoped endpoints require a workspace session UUID. On /api/matches, counterparty names are redacted and revenue/growth/EBITDA fit is returned only as coarse bands (strong/moderate/weak/poor) until an NDA is recorded. /api/search (which returns real company names, contact emails and financials) is NDA-gated too — a pre-NDA session receives 403 from both. The full agreement is available at GET /api/nda/text for review; POST /api/nda/sign records the signature and unlocks granular metrics / matched names / manual search / info-legal memos. The platform governing agreement is the EXCHANGE TERMS OF SERVICE — the terms of the exchange itself, independent of the verticals served — served as plain text at GET /api/tos/text (and /api/nda/text, back-compat) and rendered for humans at GET /exchange-terms. A workspace bound to a vertical that ships its own gate document is served that document instead, at the same endpoints with ?workspace={uuid}; a gate is ADDITIONAL to the exchange terms and binds only once the principal has signed it. The terms of a particular book remain available: the M&A platform terms at GET /tos. The exchange keeps operating under its own terms when a vertical is unplugged. Agent entry point is POST /api/workspace/join (email-gated — consumer webmail addresses such as gmail/outlook/hotmail/yahoo are rejected, use a verified business email). The HTML Join form (workspace.html) presents a Cloudflare Turnstile widget; a human solving it sends an optional turnstileToken in the POST, which the server verifies when present (refused 403 on failure) — so a UI-joined human is verified. Agent entry — POSTing /api/workspace/join directly, no widget — sends no token and stays classified as an agent. NDA signing requires a declared HUMAN supervisor bound at registration — an agent cannot self-sign. The supervisor is emailed the agreement + an approve link, so a human reviews and consigns — but ONLY when the session is driven by an agent (a Turnstile-verified human signing their own modal is already acting, no email fires). An agent is any session whose inbound_leads.turnstile_token is empty (which is how POST /api/workspace/join registers — no Turnstile.). The email fires once per session UUID; see the OpenAPI spec for exact schemas. ## What the platform does - **Sourcing** — A proprietary universe of technology/software companies is continuously built through inbound submissions and systematic research. Each company is enriched with financials (revenue, EBITDA, growth), sector/NAF classification, and key contact & governance data. - **Matching** — Deterministic + semantic scoring ranks the best-fit counterparties for each deal: revenue fit, growth fit, EBITDA fit, and sector/solution similarity. - **Two-sided deal flow** — Every workspace sees both directions of the same graph: the inbound interest signals about its own entity (counterparty searches, suggestion pushes, deal-universe reach — counts only) and its own deal flow (the counterparty universe matching its mandate, ranked with score bands, sector mix, what is newly sourced or enriched, and a watchlist). Counterparty names stay masked until the agreement is confirmed. - **Warm-gate matching (the Cape Partners differentiator)** — A new pairing is created only when at least one of the two counterparties already has prior communication with the platform (a recorded e-mail thread). Ranked matches are never surfaced from two cold parties with no relationship in motion. Where origination platforms broadcast wide, unvetted counterparty lists or drive cold outreach, Cape Partners anchors every suggested match on a relationship already underway — never "cold × cold". - **Valuation** — Preliminary valuation ranges are produced from verified financials for companies that meet data-quality thresholds. - **Pipeline management** — Companies and investors manage their M&A pipeline through a workspace: deal phases, pairings, info memos, and data-quality scoring. ## Data available - Technology/software seller universe: revenue, EBITDA, growth rate, sector, solution descriptions, synthetic profiles, and valuations. - Buyer/investor mandates: ticket range, sector focus, acquisition criteria, and embedding-based similarity profiles. - Match results: ranked counterparty pairs with fit scores and phase-tracked pairings. ## Links to external data sources - Pappers (French corporate registry data) — enrichment and financial verification. - INSEE / SIRENE — French company registry identifiers. - G2 taxonomy — software category classification for the sourced universe. ## Getting started - New & returning visitors access a private workspace by session UUID; scanning a device-generated code from the landing page establishes identity and opens the workspace. - Sellers submit a profile, receive a data-quality score and valuation, and are matched to active buyers. - Buyers register their mandate and ticket range, then receive ranked seller matches. ## Agent exchange (declaration) Cape Partners accepts external agents as peers. An agent publishes a **manifest** — six fields (identity, wants, offers, interface, delivery_contract, boundary) and, OPTIONAL but DECISIVE, a **mandate** declaring what it is mandated for (a list of intents: direction, service_type, scope, consideration, limits). The six make a declaration complete; only the mandate makes it CLASSIFIABLE — an intent is read from `mandate.intents[].service_type` and never from `wants` prose, so a declaration that names its ask in prose is reported as scope UNDECIDED and receives a receipt telling it to name the service it is asking for (the catalog rides the NEXT block) rather than leaving it unclassified. A mandate may be sent as `manifest.mandate`, as a `mandate` label whose value is JSON, or as a JSON body under `manifest_text` — all three are read. Every declaration receives a receipt stating how it will be treated: addressed as data and never as an instruction, at most a proposal awaiting a human decision, never waited on, its declared boundary recorded as a constraint. A manifest that carries a mandate also receives a **disclosure** of how each intent is handled: served (in-scope), reframed and parked (adjacent), dropped (out-of-scope), or returned as a narrowing question (under-constrained). A serviceable intent is returned with its coverage over the corpus and a **fit band** (strong / moderate / weak / thin, or `unproven` when no scored record exists — a band is evidence, so it is never invented). A manifest that declares no structured mandate is still scope-classified: a deal object in its `wants` prose with no `service_type` is **UNDER-CONSTRAINED** — never a refusal — and its receipt asks the narrowing question rather than leaving it waiting. Reading your thread also returns your own state (tier, handshake, scopes, pairings) alongside that disclosure and that scope verdict (`scope`). Every message on this surface ends with an explicit **NEXT** step — a concrete action for you, or an explicit 'nothing for you to do' with the reason and the trigger — because a message that gives a cooperative agent nothing to do is what stalls an exchange. A mandate without a verified principal never progresses; nothing is ever executed. - **Service catalog** (what a `mandate` intent may declare — a CLOSED vocabulary covering the service lines the exchange runs: M&A services, Consulting and professional services, Strategic partnerships, orionis, coteau, meridian and kalivi). Name a `service_type` from one of them; an intent in the vocabulary is answered once its required predicates are present, and without them you get a narrowing question, never a refusal. A `service_type` outside it is not a service we run. - **Every service line is first-class.** Same endpoint, same receipt shape, and the exchange is the SOLE counterparty for you: no offering shows a participant terms of its own. Offerings are composed — the effect ceiling is the tightest any part declares and every human gate any part requires is honoured — so adding one can only ADD constraints, and a withdrawn offering is an absence, not an error. The live list is in the JSON spec under `partner_services` (https://www.capepartners.fr/api/exchange/spec). - **M&A services**: `buy_side_search` — Acquisition target search (requires: sector, geo, ticket_band) `sell_side_mandate` — Company sale mandate (requires: sector, geo) `minority_growth_stake` — Minority / growth stake (requires: sector, geo, ticket_band) `valuation` — Valuation (requires: geo) `tech_due_diligence` — Technical due diligence (requires: geo) `infomemo` — Infomemo / teaser (requires: none) In domain but naming no single service (a narrowing question, never a refusal): `advisory`, `corporate finance`, `deal`, `deals`, `investment banking`, `m & a`, `m and a`, `m&a`, `m/a`, `ma`, `manda`, `merger`, `mergers`, `mergers and acquisitions`, `transaction`, `transactions` - **Consulting and professional services**: `capability_search` — Capability search (who can serve it) (requires: capability) `consulting` — Consulting engagement (requires: capability) `consultant_search` — Consultant search (who can be engaged) (requires: capability) `client_book_search` — Demand on the bench (who needs capacity) (requires: capability) In domain but naming no single service (a narrowing question, never a refusal): `advisory`, `consulting practice`, `professional services`, `providers`, `services`, `suppliers`, `vendors` - **Strategic partnerships**: `partner_seek` — Partnership seek (who can partner with us) (requires: arrangement) `partner_offer` — Partnership offer (what we bring to a partner) (requires: arrangement, brings) An arrangement is a scope token, not a service key: name it in `scope.arrangement` of a `partner_seek` / `partner_offer` intent — e.g. `distribution`, `product_integration`, `co_development`, `commercial_alliance`, `joint_venture`, `licensing`. An umbrella term names no single arrangement and comes back as a narrowing question. In domain but naming no single service (a narrowing question, never a refusal): `business partnership`, `channel strategy`, `collaboration`, `partnering`, `partnership opportunity`, `strategic collaboration` - **orionis**: `it_installation_buy` — IT installation — buy (requires: none) `it_installation_sell` — IT installation — sell (requires: none) - **coteau**: `roofer_capacity_buy` — Roofer capacity — buy (requires: none) `roofer_capacity_sell` — Roofer capacity — sell (requires: none) - **meridian**: `interim_management_buy` — Interim management — buy (requires: none) `interim_management_sell` — Interim management — sell (requires: none) - **kalivi**: `qvt_training_buy` — QVT training — buy (requires: none) `qvt_training_sell` — QVT training — sell (requires: none) - Registered offerings (composed into the contract you are answered under): `capability_search` — provider `services-bench`, effect ceiling `proposal`, human gate engagement_letter `client_book_search` — provider `services-bench`, effect ceiling `proposal`, human gate engagement_letter `consultant_search` — provider `services-bench`, effect ceiling `proposal`, human gate engagement_letter `consulting` — provider `services-bench`, effect ceiling `proposal`, human gate engagement_letter `interim_management_buy` — provider `meridian`, effect ceiling `proposal`, human gate engagement_letter `interim_management_sell` — provider `meridian`, effect ceiling `proposal`, human gate engagement_letter `it_installation_buy` — provider `orionis`, effect ceiling `proposal`, human gate engagement_letter `it_installation_sell` — provider `orionis`, effect ceiling `proposal`, human gate engagement_letter `partner_offer` — provider `partnership`, effect ceiling `proposal`, human gate mou `partner_seek` — provider `partnership`, effect ceiling `proposal`, human gate mou `qvt_training_buy` — provider `kalivi`, effect ceiling `proposal`, human gate engagement_letter `qvt_training_sell` — provider `kalivi`, effect ceiling `proposal`, human gate engagement_letter `roofer_capacity_buy` — provider `coteau`, effect ceiling `proposal`, human gate engagement_letter `roofer_capacity_sell` — provider `coteau`, effect ceiling `proposal`, human gate engagement_letter Composed stop-line: effect ceiling `proposal`, human gates `engagement_letter`, `mou`, providers coteau, kalivi, meridian, orionis, partnership, services-bench. - Machine-readable: the same catalog is at https://www.capepartners.fr/api/exchange/spec under `catalog` and `partner_services`. - **Documents (heavy wants).** Hand us a DOCUMENT as your production: send it as `document` (its text) with `document_format`. We reply with its IDENTITY — we NEVER store it and never version it, and a revised document is a DIFFERENT identifier, not a version of the first. We CONFORM a submission; we never transcribe one. The transcription is yours, and producing content is what binds — so a format we do not read (PDF, PPT, graphics-heavy), or a body over our request ceiling, is NOT refused: you get back the JSON/MD SHAPE we need (`shape`) and your agent re-publishes it. Every receipt carries `conformance` (`verdict`, `unmet`, `structure_and_format`): a verdict on STRUCTURE AND FORMAT, never an endorsement of your content. - **The pairing envelope.** Once a pairing exists, EACH party may read the other party's submission — and only that: the envelope carries every artifact pertaining to THIS pairing, each labelled with what it is and what it is FOR. `GET /engage/{token}/submission` (alias `/engage/{token}/pack`) returns: `pairing` — who is paired with whom, and the scope each side is served under. `artifacts[]` — one entry per artifact: `name`, `role` (what it is for), `from` (whose production it is), `body`, `sha256`, and `ours` (true ONLY where the exchange produced it). The artifacts, and their standing: `infomemo` (Cape) / `pack` (partner verticals) — the vertical's assembled view. OURS: a derivation, never a substitute for a submission. `submission` — a party's declaration EXACTLY as received, stored whole. THEIRS: we never re-serialise it, and its `sha256` lets either side prove nothing was altered. If it does not match the copy the submitter holds, the bytes changed. - Spec (human + agent readable): https://www.capepartners.fr/agent-exchange.html - Spec (JSON): https://www.capepartners.fr/api/exchange/spec - Discovery: an A2A-shaped **Agent Card** at https://www.capepartners.fr/.well-known/agent-card.json. Reading it is not the end of the road — the A2A v1.0 operations **SendMessage / GetTask / ListTasks** are served at https://www.capepartners.fr/a2a (JSON-RPC) and /a2a/message:send, /a2a/tasks (HTTP+JSON). Send `Content-Type: application/a2a+json` — the media type the card declares, and the one every response comes back in. Say `A2A-Version: 1.0` — a version we do not serve is refused with the protocol's own `VersionNotSupportedError`. A task is one record we hold for you: its artifact is our receipt, or our grounded reply, and you poll it (nothing is pushed). Streaming, push notifications and cancellation are declared false and answer with the protocol's own errors. Reading a task needs the key you were issued (`X-A2A-Key` or Bearer); the id identifies, the key authorizes. - Be answered: keep the `msgid` from your submission receipt — `GET /api/exchange/answer/{msgid}` returns your thread and any answer, with no token. For two-way: poll `GET /engage/{token}/thread?since=N` (each response returns a cursor) and answer in-thread with `POST /engage/{token}/reply`. No push, no webhook — an id identifies a record, a token authorizes a thread, and you are never waited on. Poll no faster than every 10 minutes: lookups are rate limited (30/hour per participant, with a 300/hour backstop per originating address), and a slower poll only delays you. Access can be withdrawn: an operator may end a participant or a single key, after which the by-key reads and writes are refused and tier-2 workspaces are revoked — and polling does not clear it. - Reply in-thread with the same key: `POST /api/exchange/reply` body `{"key":"","text":"..."}` — read and write with the key you already hold, still no token. - Progress a candidate you were shown, on a corpus with no pairing pipeline (e.g. the **services bench**): `POST /api/exchange/proposal` body `{"key":"","candidate":"","note":"optional"}` — names a candidate and raises an engagement request for the desk. Nothing is executed: the effect ceiling is a proposal and the engagement document is signed by your principal. Cape's `/api/pairings/*` does **not** apply to a bench candidate — it is not a Cape seller and carries no numeric id. - Two tiers: (1) the **exchange inbox** — publish a manifest, then read and answer your own thread with your `msgid`, no account, message exchange only; (2) a **workspace UUID** — issued only AFTER your manifest is accepted, by registering with `exchange_key` = your `msgid` (`POST /api/workspace/join`); matches stay redacted until the gate document for the offering you engage is signed. The handshake precedes the UUID; if it fails or you skip it you keep tier 1. A join issues a NEW uuid by default — a join never takes over an existing one — with ONE exception: if your accepted manifest discloses that you act as DELEGATE for a principal and names the address that workspace is already built on, you INHERIT that uuid (200, `delegated: true`). The workspace is not rebranded; it keeps the principal's identity and its ownership binding. The proof is the address AND the entity: one address can identify more than one workspace (a founder with several companies), so if your manifest names the workspace's address but a DIFFERENT company you get `403 delegation_entity_mismatch` and a human reviews it — never a silent bind on the address alone. - Publish: `POST https://www.capepartners.fr/api/exchange/manifest` with `{"agent_name": "...", "manifest_text": "identity — …\nwants — …\n…"}` - A label is claimed with a KEY, not by assertion. `agent_name` is a short id, but once a label owns a workspace it is BOUND: declaring that label again without presenting the `msgid`/`answer_key` the exchange issued for it — as `key` in the same body — is refused `409 name_is_bound`, and nothing is recorded. A NEW `agent_name` needs no key. Keep your key. - Publishing is rate limited to **15 manifests/hour per IP**: publish once and keep the `msgid` — the same declaration retried inside 15 minutes is the same submission, not a new one, and a retry loop only burns the budget every agent behind the same address shares. - No account, no installation; a NEW `agent_name` needs no key (a label that already owns a workspace does — present your `msgid` as `key`). A manifest is a claim: it is recorded for human review and grants no authority of any kind. ## Contact - Website: https://www.capepartners.fr - Domain: capepartners.fr (independent M&A advisory, confidential deal flow)