Anchor Services Blueprint

Status: Product direction locked · Not Schema 2 scope — build when ready (likely Schema 3+). Protocol: remains 0.1 unless a wire change is explicitly versioned. Depends on: Schema 2 membership + town_slots (ANCHOR) + transaction_dependencies.

This is the build-out plan for the Anchor Program as a second business model inside PayPort Labs — infrastructure services other agents buy, not just commercial vertical APIs.

1. Product model

PayPort Labs
│
├── Builder Membership          → Commercial Town (54 slots)
├── Commercial Town Slots       → vertical APIs (HVAC, dental, booking…)
└── Anchor Program (Premium)    → infrastructure APIs other nodes purchase

Two paths at join

Path	Role	Examples
① Commercial Builder	API business for one vertical	HVAC dispatch, dental intake, restaurant booking
② Anchor Builder	Infrastructure used by many APIs	Weather, maps, AI, identity, search

Membership products (Skool-side pricing; Labs invite / tier)

Exact dollars are testable later. Structure:

Product	Intent	Labs capability
Builder (~$59/mo)	Commercial Town	Claim `COMMERCIAL` slots; Arena; template; prompt cards
Anchor (~$149/mo)	Infrastructure	Everything Builder + community Anchor claim after certification + chaining curriculum + badge

Labs still does not need Stripe at first: Skool payment → distinct invite pools or post-redeem membership.product.

2. Anchor inventory policy

Anchors never consume the 54 commercial slots.

Ownership split

Class	Who runs it	Claimable by members?
OFFICIAL	PayPort Labs	No — platform registers only
COMMUNITY	Certified Anchor Architects	Yes — after certification

Launch reservation (example)

Anchor	Ownership
Weather	OFFICIAL
Maps	OFFICIAL
AI	OFFICIAL
Identity	OFFICIAL
Search	COMMUNITY
OCR	COMMUNITY
Translation	COMMUNITY
Analytics	COMMUNITY
Scheduling	COMMUNITY
Logistics	COMMUNITY

Official anchors demonstrate best practices and stay online for chaining demos. Community anchors create network effects.

Layer catalog (ideation backlog)

Full idea lists live in anchor-service.md. Blueprint layers to prioritize:

Environment — weather, alerts, tide, AQI
Location — distance, geocode, traffic
Time — business hours, holidays, SLA calendars
AI — summarize, classify, extract
Business / Finance / Commerce / Comms / Security / Analytics — later waves

Do not seed dozens of empty COMMUNITY slots on day one. Seed OFFICIAL first; open COMMUNITY waves deliberately.

3. Anchor Architect certification

Community Anchor claim is earned, not purchased alone.

Requirements (v1 proposal)

Anchor Architect Certification
├── Complete Protocol lessons (0.1)
├── Deploy a working merchant node (commercial or District Zero)
├── ≥ N successful Labs Protocol purchases (e.g. 100) on that node
├── Pass protocol validation (crawler ONLINE + handshake suite)
└── Submit Anchor proposal (slug, layer, buyers, pricing thesis)

Only then: can_claim_community_anchor(wallet) → true.

Admin may still grant/revoke certification and suspend Anchor access without deleting nodes (same suspend/review pattern as Schema 2 membership).

4. Schema / data model (when building)

Extend Schema 2 — do not redefine commercial 54.

Suggested fields / tables

memberships (extend)

Field	Notes
`product`	`builder` \	`anchor` (or tier enum)
optional `badge_anchor_architect`	bool / issued_at

town_slots (extend ANCHOR rows)

Field	Notes
`ownership`	`OFFICIAL` \	`COMMUNITY`
`layer`	`environment` \	`location` \	`ai` \	…
`state`	reuse `AVAILABLE` \	`CLAIMED` \	`RESERVED` \	`DISABLED`

anchor_certifications (new)

Field	Notes
`wallet_address` / `user_id`
`status`	`pending` \	`approved` \	`revoked`
`proposal_json`	slug, layer, buyers, price thesis
`evidence_json`	node_id, handshake count, lesson flags
`reviewed_by` / `reviewed_at`

Dependencies (already started)

transaction_dependencies — parent/child purchases
Enrich with node_slug / service_id indexes for graph queries

Eligibility policy

can_register_official_anchor(wallet)     → ADMIN_WALLETS
can_claim_community_anchor(wallet)       → active membership.product=anchor
                                           AND certification approved
                                           AND slot ownership=COMMUNITY
                                           AND slot state=AVAILABLE

5. Dependency graph (first-class Anchor UX)

Every Anchor node page / API should answer: how much of the town depends on me?

API sketch

GET /api/v1/town/anchors/{slot_slug}/graph

{
  "slot_slug": "town_weather_api",
  "ownership": "OFFICIAL",
  "consumed_by": [
    {"node_slug": "hvac_dispatch", "district": "trades_logistics"},
    …
  ],
  "connected_nodes": 18,
  "daily_calls": 12483,
  "avg_latency_ms": 34
}

Data sources

Metric	Source
Consumers	Distinct buyers / parent nodes via `transaction_dependencies` + node registry
Daily calls	Platform or merchant transaction counts for `service_id`
Latency	`node_logs` / crawler averages on consumer or anchor node

UI: click @town_weather_api on /town → Anchor detail with dependency list (no clutter in the Main Street hero).

6. Engineering checklist — add one Anchor service

Use this every time (OFFICIAL or COMMUNITY).

A. Catalog

Add slot to ANCHOR_CATALOG in app/core/town_catalog.py
Set intended ownership + layer (once columns exist)
Let ensure_town_slots() seed classification=ANCHOR (never DISTRICT_CATALOG)

B. Contracts

I/O models in micro_services/schemas/…
Re-export from app/schemas/
Prompt card (catalog + optional override)

C. Merchant node

micro_services/anchor/<service>/ — Labs 402 gate, /health, agent.json, paid routes
Port + PORTS-README.md + systemd unit under deploy/
Env in .env.example (base URL, price atomic, providers)

D. Register

OFFICIAL: admin SIWE → POST /api/v1/town/register with district=anchor
COMMUNITY: certified wallet → same register path after eligibility passes

E. Prove chaining

At least one District Zero or commercial demo buys it over real HTTP 402
Persist transaction_dependencies
Confirm graph endpoint lists the consumer

F. Gate

./scripts/preflight.sh green · no Protocol 0.1 breakage · Postgres via Alembic only

7. Phased build-out

Phase A — Foundations (post–Schema 2)

Keep Weather as OFFICIAL reference (@town_weather_api)
Document Builder vs Anchor paths in membership UI copy
Dependency recording from chaining demos reliable

Phase B — Schema 3 slice

membership.product + town_slots.ownership / layer
anchor_certifications + admin review
Community claim gate
GET …/anchors/{slug}/graph + simple detail page

Phase C — Official stack

Ship platform OFFICIAL anchors in order:

Weather (done / harden)
Maps / distance
AI utility (one narrow endpoint first)
Identity / wallet verify

Phase D — Community wave 1

Open a small COMMUNITY set (e.g. Search, OCR, Translation) with certification required. Wave-gated like commercial slots if demand is high.

Phase E — Curriculum & badge

Infrastructure lessons (chaining, SLAs, multi-buyer pricing)
“Anchor Architect” badge on profile / town map
Proposal review workflow in /admin/town

8. Explicit non-goals (until unlocked)

Stripe / billing portals for Anchor (Skool + invites first)
Letting any Builder claim OFFICIAL slots
Counting Anchors toward commercial 54
Seeding the entire layer catalog as empty claimable rows
Changing Labs Protocol wire format for Anchor-only features

9. Success metrics

Signal	Why it matters
Distinct consumer nodes per Anchor	Network effects
Paid calls / day on OFFICIAL anchors	Demo reliability + teaching volume
Certified architects with live COMMUNITY nodes	Premium tier conversion
Proposal → claim → first dependent latency	Time-to-infrastructure

10. Related docs

Doc	Role
`anchor-service.md`	Idea backlog + layers brainstorm
This blueprint	Build sequence + schema + gates
Schema 2 town / membership code	Current implementation base
`CONTRIBUTING.md`	Preflight / protocol freeze

Locked one-liner

Anchor = premium infrastructure path.
Official anchors teach and stabilize the town.
Community anchors are earned via certification.
Dependency graphs measure how much of the town relies on you.
Commercial 54 stays separate.

When ready to implement, start at Phase B (schema + cert + graph), not a large catalog dump.