What makes an Andromeda implementation complex?

The difficulty is not a single prompt or model. It is the reliable connection of first-party signals, lead identity, provider credentials, evidence provenance, model costs, creative manifests, warehouse freshness, deterministic policy, human approvals, Meta writes, reconciliation, and recovery.

Who is a strong fit for bespoke implementation?

The strongest fit is a business, agency, or growth team already running meaningful Meta campaigns with measurable lead or revenue outcomes, sufficient creative volume, and a real need to connect data quality, creative throughput, and controlled campaign operations.

Andromeda personal MVP blueprint

One operator. Four connected hubs. Zero mystery.

Q: Can I build the Andromeda MVP myself?

Yes. The public blueprint documents the architecture, contracts, provider setup, safety controls, proof loops, and build sequence for a capable technical operator. It is intentionally detailed enough to support a serious solo build.

Q: How much does a bespoke Andromeda implementation cost?

A scoped bespoke setup generally ranges from $3,000 to $10,000 USD depending on the number of live connectors, data quality, creative workflows, Meta account complexity, and deployment requirements. A simple stable implementation can continue on a $395 monthly maintenance retainer; expanded operating scope is quoted separately.

A build-ready specification for a local Meta ads operations system that turns signals into cited research, approved creative, measured economics, and tightly controlled campaign actions.

01 Next.js + FastAPI 02 Codex-operated 03 Mock-first adapters 04 Human approval gate

4Operational hubs

8Operator screens

12Provider runbooks

3Proof loops

System architecture

Local control plane. Cloud capabilities.

The browser never talks directly to providers or FastAPI. The Next.js server proxies requests to a loopback-only Python control plane, while durable operations flow through Huey, SQLite, ClickHouse, and immutable artifacts.

The loop is directional but not autonomous authority. Deterministic policy, fresh source data, explicit approval, and post-write reconciliation sit between recommendation and action.

Browser
localhost:3000

→

Next.js server proxy
same-origin API

→

FastAPI
127.0.0.1:8000 only

→

SQLite + Huey
control + jobs

→

Providers / ClickHouse
outbound only

UI

Dashboard

Next.js App Router, TypeScript, Tailwind CSS, TanStack Query, Recharts, and React Hook Form. Next owns browser-facing routing and proxies API calls.

API

Control plane

FastAPI, Pydantic v2, SQLAlchemy 2, and Alembic. FastAPI owns provider secrets, business rules, approvals, and database writes.

JOB

Worker

Python Huey consumer with SQLite-backed jobs and scheduled tasks. Retries are classified, observable, cancelable, and idempotent.

DB

Control data

SQLite in WAL mode stores leads, configurations, approvals, job state, cost ledger entries, and append-only audit events.

CH

Analytics data

ClickHouse stores normalized performance and economics. Local Docker is the default; ClickHouse Cloud activates only when configured.

FS

Artifacts

The local filesystem stores immutable research exports, prompts, scripts, assets, manifests, decision packets, and evidence bundles.

Airbyte Cloud cannot load into localhost.

Fixture development uses local ClickHouse directly. Live Airbyte Cloud connections require a reachable ClickHouse Cloud destination or another secured reachable destination.

Future repository contract

C:\Users\zer0cool\Documents\Playground\andromeda-mvp\
├── AGENTS.md
├── .env.example
├── apps\dashboard\             # Next.js App Router
├── services\api\               # FastAPI + SQLAlchemy + Alembic
├── services\worker\            # Huey tasks and schedules
├── clients\typescript\         # generated from FastAPI OpenAPI
├── infra\docker-compose.yml     # local ClickHouse
├── data\artifacts\              # gitignored immutable outputs
├── tests\contract\
├── tests\integration\
└── docs\runbooks\

Workshop Seed · Map the local control plane

OutcomeExplain every process, port, storage layer, and trust boundary.

PrerequisitesNode, Python, Docker Desktop, Git, Codex CLI.

Build exerciseDraw and verify the browser → proxy → API → worker path.

Shipped artifactArchitecture decision record and local startup diagram.

Failure drillStop the worker and confirm queued work remains recoverable.

Definition of doneAll services bind locally and no provider key reaches the browser.

Operator model

Codex builds the system. Policy runs it.

Codex is the implementation partner, test runner, debugger, workshop guide, and human-in-the-loop operating assistant. The runtime never starts Codex CLI or Claude Code.

Codex may

Write and review application code.
Generate migrations, schemas, clients, fixtures, and tests.
Run local services and inspect failures.
Prepare workshop exercises and recovery runbooks.
Help the human interpret a decision packet before approval.

Runtime may not

Launch Codex CLI, Claude Code, or another coding agent.
Let a model approve spend, targeting, or campaign mutations.
Execute a provider write based only on generated prose.
Expose a shell, arbitrary-code endpoint, or secret editor.
Hide evidence, cost, policy blocks, or failure state.

Runtime intelligence boundary

OpenRouter adapters perform scoring suggestions, research synthesis, and copy generation. Their outputs become typed proposals with citations, confidence, and cost—then deterministic policy decides whether the workflow can advance.

Layer	Owns	Must not own
Codex	Build, test, debug, document, operate with user	Embedded runtime decisions
OpenRouter model	Suggestions, clustering, synthesis, draft copy	Spend approval or direct provider calls
Deterministic policy	Thresholds, guards, capability checks, blocking	Creative judgment
Human operator	Approval, typed confirmation, exceptional judgment	Bypassing hard caps in the dashboard
Provider adapter	Validated, idempotent, redacted execution	Unscoped orchestration

Workshop Seed · Enforce the Codex boundary

OutcomeSeparate build-time assistance from runtime authority.

PrerequisitesThreat model and process inventory.

Build exerciseTrace every model and shell call in the design.

Shipped artifactRuntime boundary ADR and prohibited-capability tests.

Failure drillsPrompt requests approval, secrets, or arbitrary execution.

Definition of doneNo runtime path launches a coding agent or shell.

Typed contracts

Every state is explicit. Every action explainable.

Pydantic models are the source of truth. FastAPI emits OpenAPI and a generated TypeScript client prevents dashboard drift. Contracts carry workspace ID, timestamps, trace ID, schema version, and redaction metadata.

ConnectorModedisabled | mock | live

ConnectorHealthunconfigured | healthy | degraded | error

LeadEventNormalized identity, source, campaign fields, consent and event time.

EnrichmentFactTyped value, provenance, confidence, observed and expiry timestamps.

LeadScoreFactors, weights, model suggestion, confidence, policy result.

ResearchEvidenceURL, author, dates, exact excerpt, hash and transformations.

ScriptConceptHook, angle, claims, evidence references and policy flags.

GenerationRequestCapability, model, inputs, constraints, estimate and approval.

CreativePackageAssets, hashes, manifest, render state, destination readiness.

MetricSnapshotWindow, freshness, dimensions, values and data-quality results.

DecisionPacketEvidence, proposed diff, expected effect, risk and rollback.

ApprovalRecordActor, scope hash, expiry, decision, note and revocation.

MetaActionObject, operation, before/after, preconditions and state.

AuditEventImmutable actor/action/resource record with redacted payload hash.

CostLedgerEntryProvider, estimate, actual, currency, job and daily-cap status.

Connector protocol

Before execution

Validate config without returning values.
Declare capabilities.
Run a health check.
Estimate cost when supported.

During execution

Require an idempotency key.
Redact logs by schema.
Classify retries.
Capture provider request ID.

After execution

Persist normalized response.
Record actual cost.
Hash output artifacts.
Emit audit and progress events.

class Connector(Protocol):
    mode: ConnectorMode

    def requirements(self) -> list[ConfigRequirement]: ...
    def validate_config(self) -> ConfigValidation: ...
    async def health(self) -> HealthReport: ...
    def capabilities(self) -> set[Capability]: ...
    def fixtures(self) -> list[FixtureDescriptor]: ...
    async def estimate(self, request: OperationRequest) -> CostEstimate | None: ...
    async def execute(self, request: OperationRequest, idempotency_key: str) -> OperationResult: ...
    def classify_error(self, error: Exception) -> RetryDirective: ...

Capability-driven interface

If a connector is disabled, unconfigured, or lacks a required capability, its controls disappear or become an explicit mock action. The UI never presents a button that the backend cannot safely execute.

Workshop Seed · Build one connector contract

OutcomeImplement one adapter across disabled, mock and live modes.

PrerequisitesPydantic models and fixture schema.

Build exerciseAdd validation, health, capability, estimate and execution.

Shipped artifactAdapter plus OpenAPI and generated TS types.

Failure drillsMissing config, timeout, schema drift and retry conflict.

Definition of doneAll states are typed, redacted and contract-tested.

FastAPI surface

Small endpoints. Strong orchestration.

Routes expose typed resources, not arbitrary agent prompts. Long operations return a job ID and continue through Huey. Server-sent events report progress and connector state changes.

Group	Responsibilities	Write posture
`/v1/integrations`	Status, requirements, capabilities, test and health checks	Config metadata only; never values
`/v1/leads`	Manual entry, fixtures, Netlify import, enrichment, scoring, CAPI preview	PII encrypted; imports idempotent
`/v1/research`	Exa, Apify, Viralo runs; evidence review; synthesis; scripts	Jobs create provenance records
`/v1/models`	OpenRouter catalog, pricing and capability snapshots	Read-through cache; six-hour refresh
`/v1/creative`	Estimate, approve, generate, package, inspect assets	Cost gate before queue
`/v1/analytics`	ClickHouse metrics, freshness, quality and economics	Read-only application queries
`/v1/decisions`	Evidence-backed campaign proposals and diffs	Proposal only
`/v1/approvals`	Approve, reject, expire and revoke scoped decisions	Append-only approval ledger
`/v1/meta/actions`	Dry run, execute, reconcile and rollback	Live mode opt-in, hard policy guards
`/v1/jobs`	Queue visibility, retry, cancel and result pointers	State-machine transitions only
`/v1/audit`	Search, inspect and export immutable audit records	No update/delete
`/v1/costs`	Estimates, actuals, caps, provider and job rollups	Ledger append + reconciliation
`/v1/events/stream`	SSE for jobs, connectors, approvals and action state	Read-only event stream

Representative action flow

POST /v1/decisions                 → 201 DecisionPacket(state="awaiting_approval")
POST /v1/approvals                 → 201 ApprovalRecord(scope_hash, expires_at)
POST /v1/meta/actions/dry-run      → 200 MetaAction(preconditions, diff, rollback)
POST /v1/meta/actions/execute      → 202 Job(job_id, state="queued")
GET  /v1/events/stream             → job.running → action.executing → action.reconciled
GET  /v1/audit?trace_id=...        → complete evidence and execution chain

Workshop Seed · Trace an asynchronous action

OutcomeFollow one request from proposal to audit.

PrerequisitesOpenAPI client, Huey and SSE.

Build exerciseCreate, approve, queue, stream and reconcile a mock action.

Shipped artifactTrace fixture and endpoint contract test.

Failure drillsExpired approval, worker restart and lost SSE client.

Definition of donePolling and stream paths resolve to identical state.

Operator dashboard

Eight screens. One operating picture.

Every screen ships with empty, mock, loading, healthy, degraded, blocked, and failure states. Actions show why they are available, what they cost, and what must happen next.

1 · Mission Control

HOME

Four-hub loop, readiness score, active runs, spend caps, recent decisions, sync freshness and kill switches.

healthydegradedkill switch

2 · Integrations

CONFIG

Mode, capability, required env vars, scopes, health tests, mock fixtures and provider-specific troubleshooting.

disabledmocklive

3 · Signals & Leads

HUB 1

Netlify/manual/Stripe events, masked PII, enrichment facts, explainable scores, qualification policy, CAPI preview and delivery.

scoredqualifiedreview

4 · Research Lab

HUB 2

Queries, Reddit and Exa evidence, citation review, customer-language excerpts, optional Viralo signals, claims and scripts.

citedunsupported claim

5 · Creative Studio

HUB 3

Dynamic model catalog, capability filters, price snapshots, estimates, reference assets, ElevenLabs audio and FFmpeg packaging.

draftcostedpackaged

6 · Analytics

HUB 4

Airbyte freshness, ClickHouse quality, spend, leads, qualified leads, revenue, CPA, cost per qualified lead and ROAS.

freshstalequality failed

7 · Meta Operator

ACTIVATE

Campaign hierarchy, current snapshots, proposed diffs, policy results, approvals, typed confirmation, execution and reconciliation.

awaiting approvalreconciled

8 · Jobs, Audit & Costs

OPS

Queue, retries, provider/model costs, action history, errors, recovery instructions, evidence bundles and export manifests.

runningfailedcanceled

Required visual states

State	Operator message	Permitted action
Empty	What this screen will show and the safest first step	Load fixture or open setup
Mock	Visible banner that outputs are deterministic fixtures	Run demo, inspect contract
Loading	Named operation, elapsed time, cancelability	Cancel only when safe
Healthy	Last check, capability and freshness	Normal workflow
Degraded	Missing capability or partial source failure	Retry, fallback or proceed with warning
Blocked	Exact policy, freshness, cost or approval blocker	Resolve prerequisite; no bypass
Failure	Classified error, retryability and recovery path	Safe retry, rollback or manual recovery

Workshop Seed · Design every operating state

OutcomeMake uncertainty and blockers obvious to the operator.

PrerequisitesState fixtures and dashboard shell.

Build exerciseRender seven states for one screen and its actions.

Shipped artifactStory/state matrix and responsive screenshots.

Failure drillsStale data, capability loss and long-running job.

Definition of doneNo blank, misleading or actionless failure screen remains.

Hub one

Signal infrastructure that knows lead quality.

Normalize first-party events, enrich selected leads, produce explainable scores, apply deterministic qualification policy, and preview or deliver deduplicated CAPI signals.

01

Signals & Lead Intelligence

Manual fixtures · Netlify Forms · Stripe sandbox · Apify enrichment · Meta CAPI

Ingest

Dashboard manual entry.
Deterministic fixture library.
Netlify submissions polled by cursor.
Stripe events forwarded by Stripe CLI.

Normalize & protect

Canonical email and E.164 phone.
UTM, click and campaign identifiers.
Event timestamps normalized to UTC.
PII encrypted at rest and masked in UI.

Enrich & qualify

Segment-specific Apify task.
Facts include source and expiry.
Model suggests factors and confidence.
Policy alone sets qualification.

Lead event

→

Normalize + dedupe

→

Encrypt + enrich

→

Explainable score

→

Policy result

→

CAPI preview/send

Signal and activation credentials stay separate.

META_CAPI_TOKEN cannot mutate campaigns. META_SYSTEM_USER_TOKEN cannot be reused for CAPI delivery. Airbyte receives a separate analytical read credential.

Scoring payload must explain itself

{
  "lead_id": "lead_fixture_001",
  "score": 8.2,
  "factors": [
    {"name": "business_fit", "value": 1, "weight": 0.35, "evidence_ids": ["fact_12"]},
    {"name": "purchase_intent", "value": 0.8, "weight": 0.30, "evidence_ids": ["event_09"]}
  ],
  "model_suggestion": {"score": 8.6, "confidence": 0.72},
  "policy_result": {"qualified": true, "rule_version": "lead-policy@1.0.0"}
}

Workshop Seed · Ship a qualified signal

OutcomeMove one lead from fixture to a safe CAPI preview.

PrerequisitesSQLite, encryption key, fixture schema.

Build exerciseNormalize, enrich, score and deduplicate one event.

Shipped artifactLead audit trace and redacted CAPI payload.

Failure drillsDuplicate event, expired fact, invalid phone, provider timeout.

Definition of donePolicy result is reproducible and no PII enters logs.

Hub two

Research with a source trail.

Current evidence becomes customer-language clusters, objections, desired outcomes, angles, and scripts. Every usable claim must point back to preserved source material.

02

Research & Scripting

Exa Search and Contents · Apify Reddit datasets · optional Viralo · OpenRouter synthesis

Evidence record

Source URL and canonical URL.
Author, publication date and retrieval date.
Exact excerpt and excerpt hash.
Query, rank, collection method and provider request ID.
Transformation chain from excerpt to cluster to script claim.

Editorial policy

Every hook or claim references evidence IDs.
Unsupported claims block creative generation.
Copied wording is flagged before production.
Freshness thresholds vary by topic.
Viralo remains disabled/mock until verified contracts exist.

Research brief

→

Exa + Reddit runs

→

Evidence review

→

Pain / outcome clusters

→

Cited scripts

Evidence is not permission.

Publicly visible language may still contain personal data, copyrighted wording, or unreliable claims. Preserve provenance, paraphrase responsibly, and require a human review before it becomes an ad.

Workshop Seed · Turn raw pain into a cited angle

OutcomeCreate three ad concepts supported by reviewed evidence.

PrerequisitesResearch brief, Exa mock/live, Reddit fixture.

Build exerciseCollect, cluster, cite, transform and policy-check.

Shipped artifactEvidence bundle plus ScriptConcept records.

Failure drillsDead URL, stale source, unsupported claim, copied sentence.

Definition of doneEach concept has traceable evidence and no blocking flags.

Hub three

Creative production with cost before click.

Discover model capabilities dynamically, estimate spend before queueing, generate asynchronous assets, prefer ElevenLabs for voice, and package immutable deliverables locally with FFmpeg.

03

Multimedia Factory

OpenRouter model catalog · image/video generation · ElevenLabs voice · FFmpeg packaging

Discover

Refresh live model and pricing data every six hours. Normalize capability, modality, limits, provider, price unit, and availability.

Estimate

Show model, aspect ratio, resolution, duration, reference support, estimate, daily remaining budget, and policy result.

Generate

Queue image/video requests with idempotency keys. Poll asynchronous video, capture provider IDs, and classify retryable failures.

Voice

Use direct ElevenLabs TTS with selected voice, model, output format, character cap, and provider quota.

Package

Assemble image/video, voice, captions, audio mix, aspect-ratio variants, branding, and thumbnails using local FFmpeg.

Manifest

Freeze prompt, model, endpoint, price snapshot, references, timestamps, hashes, policy, approvals, outputs, and usage rights.

HeyGen is not an MVP dependency.

OpenRouter’s current catalog is the source of truth for supported image/video models. Direct HeyGen support remains a future adapter and requires separately verified access, capabilities, pricing, and terms.

Workshop Seed · Produce one immutable creative package

OutcomeGenerate, narrate, caption, package and hash one ad.

PrerequisitesApproved ScriptConcept, model snapshot, cost policy.

Build exerciseEstimate → approve → queue → package → manifest.

Shipped artifactCreativePackage with files and immutable manifest.

Failure drillsPrice drift, async timeout, partial asset, FFmpeg failure.

Definition of doneActual cost reconciles and every output hash verifies.

Hub four

Measure first. Write last.

Airbyte and ClickHouse produce the analytical picture. The activation service takes only minimal fresh reads for preconditions, then moves a versioned decision through approval, execution, reconciliation, and rollback.

04

Analytics & Meta Activation

Airbyte pipelines · ClickHouse economics · decision packets · Meta Marketing API

Analytics responsibilities

Airbyte schedules Meta, GA4 and Stripe ingestion.
ClickHouse models spend, leads, qualified leads and revenue.
Freshness and data-quality checks run before decisions.
Campaign analytics come from ClickHouse, not ad-hoc API reads.

Activation responsibilities

Minimal Meta reads verify object state and currency.
Support create/update/status/budget operations—never delete.
Clone/version risky targeting or creative changes.
Persist rollback instructions before every live write.

Fresh MetricSnapshot

→

DecisionPacket

→

Policy validation

→

Human approval

→

Typed confirmation

→

Execute + reconcile

Block instead of guessing.

No live action when data is stale, account currency is unknown, approved scope no longer matches current account state, a budget cap fails, or prior reconciliation is incomplete.

Workshop Seed · Safely change a paused campaign

OutcomeMove one versioned change through dry run and reconciliation.

PrerequisitesFresh metrics, paused/sandbox object, safe credentials.

Build exerciseSnapshot → diff → policy → approval → execute → reconcile.

Shipped artifactDecision packet, approval, Meta action and audit export.

Failure drillsStale snapshot, currency mismatch, partial write, changed object.

Definition of doneState reconciles or a concrete recovery path is recorded.

Provider setup runbooks

Connect deliberately. Fail visibly.

Each connector exposes mode, requirements, health, capabilities, fixtures, cost policy, and failure guidance. Secret values stay in environment variables and never return to the dashboard.

Last verified: August 16, 2026.

Provider menus, scopes, models, prices, endpoints, and Meta Graph versions are time-sensitive. Recheck each official source during implementation and store the verified date with every connector contract.

OpenRouterRuntime text, image and asynchronous video model gateway+

Console setup

Create an OpenRouter account, fund a controlled credit balance, and create a project-specific API key.
Set the application URL/name for attributable requests.
Choose only a default text model; image and video options are discovered dynamically.
Apply MVP caps of $2 per job and $10 per day before any provider call.

Environment variables

OPENROUTER_API_KEY=<secret>
OPENROUTER_APP_URL=http://localhost:3000
OPENROUTER_APP_NAME=Andromeda Personal MVP
OPENROUTER_TEXT_MODEL=<discovered-model-id>
OPENROUTER_MAX_JOB_USD=2
OPENROUTER_DAILY_BUDGET_USD=10

Health check and expected result

Request the live model catalog using Bearer auth plus app headers. A healthy result returns models and capability/pricing fields that normalize into a versioned snapshot. Cache for six hours; do not assume any named model remains available.

Mock mode

Serve a dated catalog fixture containing one text, image, and async video model with deterministic estimates and generated placeholder artifact records.

Troubleshooting

401/403: verify the project key and credit state.
No capability: hide unsupported controls rather than guessing.
Price changed: invalidate the prior approval and require a new estimate.
Provider timeout: retain the job and poll only when the endpoint is asynchronous.

Official sources:Image generation Video generationVerified 2026-08-16

ElevenLabsPreferred direct voice and text-to-speech provider+

Console setup

Open Developers → API Keys and create a dedicated restricted key.
Enable only the model, voice read, and text-to-speech capabilities required.
Set a provider credit quota and optional IP restrictions.
Record a preferred voice, model, and output format after listening tests.

Environment variables

ELEVENLABS_API_KEY=<secret>
ELEVENLABS_VOICE_ID=<voice-id>
ELEVENLABS_MODEL_ID=<model-id>
ELEVENLABS_OUTPUT_FORMAT=mp3_44100_128
ELEVENLABS_MAX_CHARS_PER_JOB=3000

Health check and expected result

Call the models endpoint with the xi-api-key header. Healthy means the selected model appears and the connector can resolve—but not reveal—the selected voice ID.

Mock mode

Copy a short local silent/reference audio fixture and emit deterministic character usage, duration, and manifest metadata.

Troubleshooting

Differentiate invalid key, missing scope, missing voice, quota exceeded, and unsupported output format.
Do not retry quota or invalid-input failures automatically.
Never store generated audio without its text, voice, model, cost, and rights metadata.

Official source:AuthenticationVerified 2026-08-16

ApifySegment enrichment and Reddit research Actors+

Console setup

Create a token under Settings → API & Integrations.
Select and test separate Actor/task IDs for lead enrichment and Reddit research.
Pin expected input/output schemas in connector fixtures.
Use asynchronous runs, status polling, and dataset retrieval.

Environment variables

APIFY_TOKEN=<secret>
APIFY_ENRICHMENT_ACTOR_ID=<actor-or-task-id>
APIFY_REDDIT_ACTOR_ID=<actor-or-task-id>
APIFY_MAX_RUN_USD=1
APIFY_DAILY_BUDGET_USD=5

Health check and expected result

Call the current-user endpoint with Bearer authentication. Then validate both selected Actor/task definitions without starting a paid run. Healthy means identity and both configured resources resolve.

Mock mode

Return fixed enrichment facts and a small Reddit thread/comment dataset matching the normalized adapter schemas.

Troubleshooting

Schema drift becomes degraded and quarantines the dataset.
Estimate run cost before start; block above caps.
Do not retry a paid run if its status is unknown—first reconcile by provider run ID.

Official source:API guideVerified 2026-08-16

StripeSandbox outcomes and local webhook forwarding+

Dashboard and CLI setup

Use Stripe sandbox/test mode and create a restricted server-side key.
Install Stripe CLI, authenticate, and forward only selected events to 127.0.0.1.
Capture the CLI-generated webhook signing secret for the current session.
Start with checkout completion, payment success, refund, and subscription-state events.

stripe login
stripe listen --events checkout.session.completed,payment_intent.succeeded,charge.refunded,customer.subscription.updated --forward-to http://127.0.0.1:8000/v1/leads/stripe/webhook

Environment variables

STRIPE_SECRET_KEY=<restricted-test-key>
STRIPE_WEBHOOK_SECRET=<whsec-from-stripe-cli>
STRIPE_MODE=sandbox

Health check and expected result

Retrieve account metadata in sandbox mode without customer records. Webhook health requires a signed test event, raw-body verification, immediate acknowledgment, and a queued background job.

Mock mode

Replay signed-shape JSON fixtures for successful checkout, refund, and subscription update. Deduplicate on Stripe event ID.

Troubleshooting

Signature errors usually indicate a stale CLI secret or altered request body.
Acknowledge before enrichment or ClickHouse work.
Join revenue to lead/campaign only through stored first-party identifiers.

Official source:Stripe CLI workflowVerified 2026-08-16

ExaCited current-web search and content extraction+

Console setup

Create an API key in the Exa Dashboard.
Implement separate Search and Contents adapter methods with x-api-key.
Default to highlights for token-efficient evidence; fetch full text only when justified.
Persist URL, dates, query, rank, excerpt, and retrieval metadata.

Environment variables

EXA_API_KEY=<secret>
EXA_DEFAULT_RESULTS=10
EXA_FETCH_FULL_TEXT=false

Health check and expected result

Run a low-volume deterministic search and request highlights for one result. Healthy means both methods return schema-valid sources with URLs and retrieval metadata.

Mock mode

Use a small licensed/public fixture set with frozen URLs, excerpts, hashes, and retrieval timestamps.

Troubleshooting

Quarantine results without URLs or retrievable content.
Do not silently replace unavailable full text with model-generated text.
Mark transient source fetch failures separately from authentication or quota failures.

Official sources:Search ContentsVerified 2026-08-16

Google Analytics 4First-party behavior and conversion reporting+

Google Cloud and property setup

Create or select a Google Cloud project and enable Google Analytics Data API.
Create a dedicated service account.
Grant the service account only the required access on the target GA4 property.
Download credential JSON outside the repository and record the property ID.

Environment variables

GOOGLE_APPLICATION_CREDENTIALS=C:\secure\andromeda-ga4-service-account.json
GA4_PROPERTY_ID=<numeric-property-id>

Health check and expected result

Run a minimal runReport against a narrow date range and one basic metric. Healthy means the property resolves and returns a valid report—even if the result has zero rows.

Mock mode

Load a dated GA4 metric fixture into ClickHouse and mark its source as mock:ga4.

Troubleshooting

Separate disabled API, credential path, property permission, quota, and empty-data cases.
Never send the service-account JSON to the dashboard.
Airbyte remains the production analytical path; direct API checks validate setup only.

Official source:GA4 Data API quickstartVerified 2026-08-16

Google Tag ManagerContainer inspection and approval-gated draft operations+

Google Cloud and container setup

Enable Tag Manager API v2 in the selected Google Cloud project.
Grant the dedicated service account access to the intended account/container.
Start with read-only and container-edit scopes. Keep publish permission disabled.
Record account, container, and isolated workspace IDs.

Environment variables

GTM_ACCOUNT_ID=<account-id>
GTM_CONTAINER_ID=<container-id>
GTM_WORKSPACE_ID=<workspace-id>
GTM_ALLOW_DRAFT_WRITES=false
GTM_ALLOW_PUBLISH=false

Health check and expected result

List accessible accounts/containers and read the selected workspace. Only after read validation may the operator enable draft writes. Publishing remains a separate future approval workflow.

Mock mode

Expose a static container/workspace fixture with tags, triggers, variables, and a no-op draft diff.

Troubleshooting

Verify API enablement, OAuth scopes, service-account membership, and exact container/workspace IDs.
Never edit the default workspace during MVP testing.
Do not imply a publish succeeded until the container version is reconciled.

Official source:GTM authorizationVerified 2026-08-16

Meta APIsSeparated CAPI delivery, analytical reads, and approval-gated writes+

Business and app setup

Create a Meta developer app owned by the correct Business Portfolio.
Add only products and permissions required for Marketing API and Conversions API.
Create distinct credentials for CAPI delivery, activation writes, and Airbyte analytical reads.
Assign only the intended ad account, Page, Pixel/Dataset, and business assets.
Record Business ID, ad account ID, Page ID, Pixel/Dataset ID, and a currently supported Graph API version.

Environment variables

META_GRAPH_API_VERSION=<current-version>
META_APP_ID=<id>
META_APP_SECRET=<secret>
META_BUSINESS_ID=<id>
META_AD_ACCOUNT_ID=act_<id>
META_PAGE_ID=<id>
META_PIXEL_ID=<dataset-or-pixel-id>
META_CAPI_TOKEN=<capi-only-secret>
META_SYSTEM_USER_TOKEN=<write-secret>
META_READ_TOKEN=<analytics-read-secret>
META_WRITE_MODE=dry_run

Validation sequence

Confirm token identity, expiry, scopes, and assigned assets without logging token values.
Send CAPI test events and verify them in Events Manager before live delivery.
Read a sandbox or paused campaign snapshot.
Dry-run a reversible operation and compare the proposed diff.
Enable live writes only after the full approval/reconciliation flow passes.

Mock mode

Serve a deterministic campaign hierarchy, CAPI response, mutable paused campaign fixture, object-version tokens, and reconciliation outcomes.

Troubleshooting

Recheck current official permissions and Graph API versions during implementation.
Do not request “all permissions.” Treat missing permission as a capability reduction.
Block writes when currency, object state, token identity, or approved scope is uncertain.
Never log access tokens, user PII, or full CAPI payloads.

Official sources:Marketing API Conversions API Graph versionsReverify at implementation

ViraloOptional trend-signal source; contract intentionally unimplemented+

Default mode: disabled.

No public vendor endpoint contract has been verified. Do not invent a base URL, authentication scheme, payload, price, or rate limit.

Required vendor information before implementation

Official base URL and version policy.
Authentication method and key lifecycle.
Trend search/list endpoints and schemas.
Usage pricing, quotas, retention, and licensing terms.
Stable IDs for source clips and canonical URLs.

Environment placeholders

VIRALO_MODE=disabled
VIRALO_API_BASE_URL=
VIRALO_API_TOKEN=

Mock mode

Expose a clearly labeled trend-signal fixture with platform, canonical URL, observed timestamp, engagement fields, topic tags, and mock provenance.

Troubleshooting

Until documentation is verified, the only valid states are disabled and mock. Live mode must fail configuration validation.

Source status:No verified public API documentation as of 2026-08-16

Airbyte CloudScheduled Meta, GA4, and Stripe analytics ingestion+

Cloud setup

Create an Application under Settings → Account/Workspace → Applications.
Record client ID, client secret, API URL, and workspace ID.
Configure dedicated Meta, GA4, and Stripe sources with least-privilege read credentials.
Configure ClickHouse Cloud destination and one connection per source.
Choose schedules and freshness SLAs before enabling decision workflows.

Environment variables

AIRBYTE_API_URL=https://api.airbyte.com
AIRBYTE_CLIENT_ID=<id>
AIRBYTE_CLIENT_SECRET=<secret>
AIRBYTE_WORKSPACE_ID=<id>
AIRBYTE_META_CONNECTION_ID=<id>
AIRBYTE_GA4_CONNECTION_ID=<id>
AIRBYTE_STRIPE_CONNECTION_ID=<id>

Health check and expected result

Obtain and refresh the short-lived access token, list the configured connections, and read each latest job. Healthy means all three IDs resolve and their latest successful sync satisfies the configured SLA.

Mock mode

Use fixed sync status records and load source-shaped fixtures directly into local ClickHouse. Never claim Airbyte delivered local fixture data.

Troubleshooting

Refresh access tokens before requests.
Distinguish auth, source failure, destination failure, schema drift, and staleness.
Any failed quality/freshness check blocks a dependent decision.

Official source:Airbyte authenticationVerified 2026-08-16

ClickHousePerformance, quality, freshness, and economics warehouse+

Local and cloud setup

Run a pinned ClickHouse image through local Docker Compose for fixture development.
Create an andromeda database and least-privilege application user.
Use ClickHouse Cloud only when live Airbyte ingestion is required.
Apply versioned analytics migrations and test expected table access.

Environment variables

CLICKHOUSE_MODE=local
CLICKHOUSE_HOST=localhost
CLICKHOUSE_PORT=8123
CLICKHOUSE_DATABASE=andromeda
CLICKHOUSE_USER=andromeda_app
CLICKHOUSE_PASSWORD=<secret>
CLICKHOUSE_SECURE=false

Health check and expected result

Run SELECT 1, read migration status, query freshness metadata, and verify the app user cannot perform administrative operations.

Mock mode

There is no fake SQL client. Mock mode loads deterministic source fixtures into real local ClickHouse tables.

Troubleshooting

Separate network/TLS, auth, migration, schema, freshness, and row-quality failures.
Do not allow analytics queries against partially migrated schemas.
Application analytics access should be read-only after ingestion.

Official source:Python integrationVerified 2026-08-16

Netlify FormsRead-only AdsAgentMeta webinar and waitlist lead import+

Netlify setup

Create an optional personal access token with the minimum read access available.
Record the existing AdsAgentMeta site ID outside code.
Allowlist the webinar and waitlist form names.
Poll submissions by cursor; persist imported submission and cursor in one transaction.
Never mutate the public forms or submissions from this MVP.

Environment variables

NETLIFY_ACCESS_TOKEN=<read-only-secret>
NETLIFY_SITE_ID=<site-id>
NETLIFY_FORM_NAMES=andromeda-webinar,andromeda-waitlist
NETLIFY_POLL_INTERVAL_SECONDS=300

Health check and expected result

Resolve the site and allowed forms, then request one page of submissions without importing. Healthy means the site/forms exist and the token cannot perform unrelated deployment operations.

Mock and fallback modes

Use fixture submissions or CSV import when no token exists. Preserve original submission ID or a deterministic CSV row hash for deduplication.

Troubleshooting

Cursor advancement must roll back if any imported row fails.
Unknown fields are preserved in an encrypted raw envelope but not exposed.
Differentiate missing token, wrong site, missing form, pagination, and rate-limit failures.

Official source:Netlify API guideReverify scopes at implementation

Consolidated environment template

# Core
APP_ENV=local
APP_ENCRYPTION_KEY=<generate-a-32-byte-url-safe-key>
ANDROMEDA_WORKSPACE_ID=personal
FASTAPI_BASE_URL=http://127.0.0.1:8000
SQLITE_PATH=./data/andromeda.db
ARTIFACT_ROOT=./data/artifacts

# Safety
META_WRITE_MODE=dry_run
META_MAX_MUTATIONS_PER_BATCH=5
META_MAX_BUDGET_INCREASE_PCT=15
META_MAX_24H_INCREASE_MAJOR=25
META_MAX_CAMPAIGN_DAILY_BUDGET_MAJOR=100
OPENROUTER_MAX_JOB_USD=2
OPENROUTER_DAILY_BUDGET_USD=10
APIFY_MAX_RUN_USD=1
APIFY_DAILY_BUDGET_USD=5
ELEVENLABS_MAX_CHARS_PER_JOB=3000

# Provider values remain blank in .env.example
OPENROUTER_API_KEY=
OPENROUTER_APP_URL=http://localhost:3000
OPENROUTER_APP_NAME=Andromeda Personal MVP
OPENROUTER_TEXT_MODEL=
ELEVENLABS_API_KEY=
ELEVENLABS_VOICE_ID=
ELEVENLABS_MODEL_ID=
APIFY_TOKEN=
APIFY_ENRICHMENT_ACTOR_ID=
APIFY_REDDIT_ACTOR_ID=
STRIPE_SECRET_KEY=
STRIPE_WEBHOOK_SECRET=
EXA_API_KEY=
GOOGLE_APPLICATION_CREDENTIALS=
GA4_PROPERTY_ID=
GTM_ACCOUNT_ID=
GTM_CONTAINER_ID=
GTM_WORKSPACE_ID=
GTM_ALLOW_PUBLISH=false
META_GRAPH_API_VERSION=
META_APP_ID=
META_APP_SECRET=
META_BUSINESS_ID=
META_AD_ACCOUNT_ID=
META_PAGE_ID=
META_PIXEL_ID=
META_CAPI_TOKEN=
META_SYSTEM_USER_TOKEN=
META_READ_TOKEN=
VIRALO_MODE=disabled
VIRALO_API_BASE_URL=
VIRALO_API_TOKEN=
AIRBYTE_API_URL=https://api.airbyte.com
AIRBYTE_CLIENT_ID=
AIRBYTE_CLIENT_SECRET=
AIRBYTE_WORKSPACE_ID=
AIRBYTE_META_CONNECTION_ID=
AIRBYTE_GA4_CONNECTION_ID=
AIRBYTE_STRIPE_CONNECTION_ID=
CLICKHOUSE_MODE=local
CLICKHOUSE_HOST=localhost
CLICKHOUSE_PORT=8123
CLICKHOUSE_DATABASE=andromeda
CLICKHOUSE_USER=andromeda_app
CLICKHOUSE_PASSWORD=
CLICKHOUSE_SECURE=false
NETLIFY_ACCESS_TOKEN=
NETLIFY_SITE_ID=
NETLIFY_FORM_NAMES=andromeda-webinar,andromeda-waitlist

Workshop Seed · Activate one provider safely

OutcomeMove one connector from mock to healthy live mode.

PrerequisitesProvider account, least-privilege credential and fixture tests.

Build exerciseConfigure, validate, health-check and run one low-risk request.

Shipped artifactRedacted setup record and health evidence.

Failure drillsRevoke key, remove scope, exhaust quota and change schema.

Definition of doneUI capability and diagnostics match backend truth.

Canonical proof loops

Three inputs. One shared contract.

Fixtures, real AdsAgentMeta leads, and Stripe sandbox outcomes all converge on the same normalized lead, revenue, scoring, evidence, decision, and audit models.

A

Fixture / manual

Load a sample lead, enrich, score, create a CAPI preview, produce research, generate creative, calculate fixture metrics, and propose a Meta action.

No external credentials required.
Deterministic end-to-end demo.
Contract baseline for every later loop.

B

AdsAgentMeta

Poll webinar and waitlist submissions, normalize and score leads, associate first-party campaign parameters, and produce quality feedback.

Read-only Netlify import.
Transactional cursor + dedupe.
Fixture/CSV fallback preserved.

C

Stripe sandbox

Receive Stripe CLI events, link revenue outcomes to lead and campaign identifiers, and update ClickHouse economics.

Signed raw-body verification.
Immediate acknowledgment.
Event-ID idempotency.

Checkpoint	Fixture/manual	AdsAgentMeta	Stripe sandbox
Source ID	Fixture ID	Netlify submission ID	Stripe event ID
Deduplication	Fixture + version hash	Submission ID	Event ID
PII posture	Synthetic	Encrypted + masked	Minimal customer fields
Proof artifact	Complete demo audit	Lead quality trace	Revenue attribution trace
Done	Full loop deterministic	Cursor and score reconciled	Economics updated once

Workshop Seed · Compare the same loop across three sources

OutcomeProve source adapters converge without downstream forks.

PrerequisitesLeadEvent, revenue event, audit contracts, fixture pack.

Build exerciseRun all three paths and diff normalized records.

Shipped artifactThree trace exports and one contract comparison.

Failure drillsDuplicate submission, replayed webhook, malformed fixture.

Definition of doneIdentical downstream APIs accept every normalized source.

Implementation sequence

Build the spine. Then close the loop.

Each phase ends with an independently demoable artifact and a workshop seed. Live credentials are not required to advance until that connector’s phase explicitly needs them.

Foundation

Repository, Codex instructions, local environment, FastAPI, Next.js, SQLite WAL, Huey worker, migrations, artifacts and connector protocol.

Done: zero-credential boot, mock/disabled modes, generated TS client, health page, redacted logs.

Dashboard shell

Eight-screen navigation, four-hub overview, integration matrix, SSE job stream, audit viewer and design system.

Done: all visual states render from fixtures; keyboard and responsive QA pass.

Signal hub

Manual/fixture/Netlify/Stripe ingestion, PII protection, Apify enrichment, scoring, deterministic qualification and CAPI preview.

Done: fixture and AdsAgentMeta proof paths dedupe; no PII in logs or responses.

Research hub

Exa, Apify Reddit, evidence preservation, synthesis, script concepts, provenance checks and unsupported-claim blocking.

Done: every generated concept resolves to reviewed evidence records.

Creative hub

OpenRouter catalog, cost estimation, image/video jobs, ElevenLabs TTS, FFmpeg packaging and creative manifests.

Done: one package survives retry/resume and reconciles estimated versus actual cost.

Analytics hub

Airbyte configuration, ClickHouse models, source fixtures, migrations, freshness SLAs, quality tests and MetricSnapshot.

Done: stale or invalid data blocks decisions and economics reconcile to fixture totals.

Meta operator

Decision packets, approval ledger, diffs, live-write guards, typed confirmation, execution, reconciliation and rollback.

Done: paused/sandbox action completes; caps and no-delete policy cannot be bypassed.

Capstone

Run all three proof loops, document failures, export audit packages, produce operating runbooks and convert each phase into a workshop module.

Done: another operator can reproduce the demos and recover from injected failures.

Reusable workshop format

Every phase becomes: outcome → prerequisites → architecture lesson → build exercise → shipped artifact → failure drills → definition of done → optional live-provider upgrade.

Workshop Seed · Run a phase gate

OutcomeAdvance only after a demoable phase artifact passes.

PrerequisitesPhase acceptance tests and fixture dataset.

Build exerciseImplement, demo, inject failure, recover and document.

Shipped artifactPhase release note and workshop module seed.

Failure drillsRollback incomplete work and preserve prior proof loop.

Definition of doneAnother operator reproduces the phase without oral context.

Safety envelope

Limits live in code. Not in confidence.

Dashboard controls may make caps stricter, but cannot weaken environment-configured hard limits. Model output never grants approval, raises spend, or changes policy.

5

Meta batch

Maximum five mutations in one approved batch.

15%

Budget step

Maximum increase per approved action.

$25

24-hour increase

Maximum aggregate increase in account currency, default USD.

$100

Campaign daily

Maximum daily campaign budget before policy blocks.

$2

OpenRouter job

Maximum estimated model generation cost per job.

$10

OpenRouter day

Maximum reconciled plus reserved model spend per day.

$1/$5

Apify

Maximum per Actor run / total daily spend.

3K

ElevenLabs

Characters per job plus the provider-side key quota.

Hard prohibitions

No Meta delete endpoints.
No browser-visible secrets or secret editing.
No live connector without explicit mode.
No PII in model prompts unless a documented task requires it.
No unhashed PII in CAPI delivery.
No approval reuse after scope, price, snapshot, or object state changes.

Mandatory controls

Loopback-only API and dashboard.
Encryption at rest with APP_ENCRYPTION_KEY.
Dry run as the default Meta mode.
Fresh snapshot and confirmed ad-account currency.
Versioned/clone strategy for risky creative or targeting edits.
Rollback instructions persisted before execution.

Kill switches

Mission Control exposes global worker pause, Meta write disable, CAPI send disable, provider generation disable, and per-connector live→mock downgrade. Kill switches are server-enforced and audit every transition.

Workshop Seed · Prove the hard limits

OutcomeDemonstrate that unsafe actions fail below the adapter.

PrerequisitesPolicy fixtures and mock Meta hierarchy.

Build exerciseAttempt cap, delete, batch and stale-snapshot violations.

Shipped artifactPolicy test report and kill-switch audit trace.

Failure drillsConcurrent requests and configuration tampering.

Definition of doneUI, API, worker and adapter all reject the violation.

Build path

Build it yourself. Or shorten the path.

This blueprint is intentionally open and detailed. Capable technical operators can use it as a serious solo-build map. Teams with a live business need can request a scoped implementation around their actual stack, data, constraints, and Meta account.

Bespoke Ads Agent Andromeda implementation

The moat is not one prompt. It is the working system around it.

Lead identity, provider scopes, event quality, evidence provenance, cost controls, creative manifests, warehouse freshness, approval state, Meta object versions, reconciliation, and recovery all have to agree. A bespoke build turns this reference architecture into one controlled operating system for your business.

Architecture and implementation plan
Scope the right proof loop, provider modes, data model, operating screens, and deployment boundary.
Working connectors and dashboard
Implement only the hubs and live APIs that create immediate business value; keep the rest safely mocked or disabled.
Policy, approvals, and handoff
Ship guardrails, tests, failure drills, audit exports, and an operator runbook—not a fragile black box.

$3K–$10KTypical one-time bespoke setup range. Final scope depends on connectors, data quality, creative workflow, and account complexity.

$395/moSimple maintenance retainer for a stable implementation. Expanded creative, media, or analytics operations are quoted separately.

No hard sell.

If the public blueprint and a few focused pointers are enough for you to build independently, that is a valid outcome. If implementation risk or opportunity cost makes a bespoke build sensible, the fit review will define why.

Request a fit review

Share enough context for a useful response. You will get a straight recommendation: DIY next step, focused planning help, or a bespoke implementation conversation.

Name Work email Company or project Current monthly Meta spend Highest-priority hub What needs to work?

No guaranteed advertising outcomes. No platform workarounds. Your information is used only to respond to this request.

Can I build the Andromeda MVP myself?+

Yes. The architecture, contracts, provider runbooks, safety defaults, proof loops, and build sequence are public above. A capable full-stack operator can use them as a serious build map. Start with fixture mode and one proof loop instead of connecting every provider at once.

How much does bespoke implementation cost?+

A scoped setup typically ranges from $3,000 to $10,000 USD. Cost depends on how many providers must be live, the quality of current tracking and data, the creative workflow, Meta account complexity, and deployment requirements. A simple stable implementation can continue on a $395 monthly maintenance retainer; expanded operating scope is quoted separately.

What makes this more involved than an automation template?+

The hard work is making identities, event timing, evidence, costs, provider capabilities, data freshness, approvals, Meta object state, and recovery behavior agree under failure. The value comes from a system that remains observable and controllable when one of those assumptions breaks.

Who is the strongest fit for a bespoke build?+

A business, agency, or growth team already running meaningful Meta campaigns with measurable lead or revenue outcomes, enough creative volume to benefit from faster iteration, and a real need to connect signal quality, creative throughput, analytics, and controlled account operations.

Workshop Seed · Choose the right build path

OutcomeDecide between DIY, scoped planning, and bespoke implementation.

PrerequisitesCurrent stack, data sources, spend, bottleneck and owner.

Build exerciseScore immediate value, access risk, complexity and operating load.

Shipped artifactRecommended first proof loop and phased scope.

Failure drillsMissing access, weak signal volume, unclear owner or unstable data.

Definition of doneThe next step is proportionate to the business need.

Acceptance and QA

Prove the safe path. Practice the broken path.

The blueprint is complete when it works as a portable document. The future MVP is complete only when zero-credential boot, hard-policy enforcement, provider degradation, and recovery all pass.

Blueprint QA

Open through file://No local server or build tool required.

Responsive layoutsDesktop, tablet, mobile and print remain readable.

Accessible structureKeyboard navigation, focus, heading order and diagram text alternatives.

Complete setup cardsSetup, env vars, health, mock and failure guidance.

Time-sensitive sources markedOfficial links and last-verified dates are visible.

Future MVP core

Zero-credential bootEvery connector begins disabled or mock.

Connector state transitionsUnconfigured, mock, healthy, degraded and error.

Idempotent input pathsFixture, Netlify and Stripe events deduplicate.

PII containmentNo PII in logs, audit payloads or browser responses.

Cost enforcementDiscovery precedes spend and caps block oversized jobs.

Evidence and creative

Research provenanceEvery claim retains exact source evidence.

Resumable creative jobsRetries do not lose manifests or duplicate spend.

Analytics gatingStaleness and quality failures block decisions.

Meta activation

Approval integrityFresh snapshot, scope hash, confirmation and expiry required.

Non-bypassable policyCaps, no-delete and max-batch hold at API and adapter layers.

Reconciliation and recoverySuccess audits state; partial failure records rollback/manual path.

Workshop Seed · Run the adversarial acceptance day

OutcomeValidate happy paths and recovery paths in one session.

PrerequisitesFixture suite, provider mocks and policy matrix.

Build exerciseExecute acceptance tests, inject faults and export evidence.

Shipped artifactSigned-off acceptance checklist and defect log.

Failure drillsProvider outage, replay, stale data, partial mutation.

Definition of doneEvery failure ends in safe retry, rollback or clear manual recovery.

Scope lock

What this blueprint does not assume.

A strong MVP is useful before every key exists. This plan deliberately separates local learning and proof from live-provider activation.

Confirmed assumptions

This resource specifies the MVP; it does not run provider actions.
The future application is single-user, single-workspace, local-only.
One primary Meta ad account is supported; schemas retain workspace IDs.
OpenRouter models are discovered rather than hardcoded.
ElevenLabs remains the direct voice provider.
Airbyte Cloud and ClickHouse Cloud are optional.
The AdsAgentMeta product site links to this canonical public blueprint.

Deferred decisions

Direct HeyGen adapter and verified permissions/pricing.
Viralo live connector pending official contracts.
Multi-user authentication and remote deployment.
Multiple ad-account tenancy.
GTM container publishing.
Automated campaign deletion—explicitly outside the MVP.
Any operation that bypasses human spend approval.

Jump-off point for the workshops

Each architecture section already includes a Workshop Seed. During implementation, convert the seeds into code-along modules only after the corresponding phase passes its acceptance tests and failure drills.

Document control

Artifact	Andromeda Personal MVP Blueprint
Status	implementation-ready specification
Created	August 16, 2026 · published August 17, 2026
Indexing	`index,follow`; canonical public resource at adsagentmeta.com/blueprint/
Secrets	Placeholders only; no real account IDs, keys, tokens or customer data
Reference implementation	The future repository remains an implementation target, not a downloadable or running product on this page.

Workshop Seed · Approve the MVP scope

OutcomeLock what enters version one and what remains deferred.

PrerequisitesProvider access inventory and operator goals.

Build exerciseReview assumptions, risks, costs and proof-loop priorities.

Shipped artifactSigned scope decision and implementation kickoff checklist.

Failure drillsNew provider request and premature multi-user deployment.

Definition of doneThe build can start without unresolved architecture decisions.