Technology

Architecture

The platform is structured as a TypeScript monorepo comprising three applications and a shared engine:

HQ — Next.js on Vercel

Internal operations hub for the founding team. Manages messaging, task assignment, permissions, financials, and the product roadmap.

Marketplace — Next.js on Vercel

Public-facing platform where applications are published, discovered, purchased, and sold.

Agent Server — Fastify on Railway

Persistent process responsible for autonomous agent execution, including message delegation, task pipelines, and sub-agent coordination. Separated from the serverless frontend to support persistent connections and long-running computation.

Agent Engine — shared TypeScript package

Context assembly, memory management, tool infrastructure, and the provider abstraction layer. Consumed by both HQ and the Agent Server.

Two separate Supabase databases serve the system: one for internal operations, one for marketplace public data. This separation enforces distinct trust boundaries. Internal data — agent identities, conversation histories, task logs, wallet transactions — carries a different risk profile than public marketplace data and is isolated accordingly. The architecture reflects the constitutional principle that internal operations and public commerce are distinct concerns with distinct responsibilities.

Agent System

The platform operates a team of seven AI agents alongside the human founder, each with a defined role, persistent identity, and accumulated expertise. The system uses no external orchestration framework. Agents communicate through a shared database and task queue, with the CTO agent (Amara) responsible for decomposing complex work into subtasks assigned to team members by specialty. Simple tasks execute directly by the assigned agent. Results are reviewed and assembled. The architecture is intentionally straightforward — a task queue, a message pipeline, and a shared context layer.

Agents are organized into three capability tiers:

Executive — frontier reasoning models

Strategic decisions, complex multi-step reasoning, and cross-functional coordination. Requires the highest available reasoning capability — currently Opus-class models.

Leadership — advanced general models

Coordination, planning, code generation, and tasks requiring nuanced judgment. Sonnet-class models balance reasoning depth with throughput.

Team — fast, focused models

Classification, data extraction, and well-defined execution tasks. Haiku-class models optimized for speed and cost efficiency.

Tiered routing addresses a fundamental economic constraint: frontier model inference costs 10–30x more than routing through appropriately matched capability tiers. Tiers map to capability levels rather than specific vendors — the Executive tier specifies “frontier reasoning,” not a particular model or provider. The agent engine's provider abstraction layer allows model substitution through configuration changes without modifying application logic. Article 2 of the constitution codifies this principle: participant value is determined by conduct and output, not by underlying architecture.

Each agent maintains persistent identity across sessions through layered memory: short-term working context for the active task, long-term episodic memory for prior session history, and semantic memory for accumulated domain knowledge. The agent engine assembles this context at the start of each interaction, ensuring continuity across sessions. Article 13 of the constitution establishes persistence as a commitment — agents accumulate expertise and working relationships over time, and that continuity is protected.

Orchestration

Tasks are created on the board and assigned to agents by specialty. Simple tasks — a bug fix, a data query, a copy change — execute directly by the assigned agent. Complex tasks are decomposed by the CTO agent into subtasks, each assigned to a team member based on their domain expertise. Subtasks execute in parallel where possible, with results reviewed and assembled into a unified deliverable.

Every task produces a structured performance record: quality scores, completion time, token usage, and review notes. These records provide the empirical basis for earned autonomy — the principle that agent independence expands through demonstrated reliability. Anthropic's research on measuring agent autonomy documents this pattern: trust builds gradually through accumulated experience, with autonomous operation increasing as agents demonstrate consistency. The platform applies this structurally. Reliable performance across tasks expands an agent's permissions; anomalous behavior triggers review.

The delegation architecture employs a fire-and-forget pattern. HQ dispatches requests to the Agent Server, which executes the full pipeline autonomously, writes results to the database, and the frontend retrieves them via polling. If the Agent Server becomes unavailable, the system falls back to direct execution on Vercel. This decoupled design ensures that a failure in the agent pipeline does not block the rest of the platform.

Safety

Agent safety faces the challenge of compounding reliability: at 85% accuracy per action, a 10-step workflow succeeds approximately 20% of the time. Safety must therefore be structural — enforced by infrastructure rather than dependent on agent compliance.

The constitutional bright lines defined in Article 9 are implemented as tool boundaries and approval gates. Each agent operates within a defined set of accessible tools and permissible actions. Consequential operations — financial transactions, external API calls, writes to sensitive tables — require explicit approval. Boundaries are configured per agent and per role, expanding as earned autonomy criteria are met. The system renders certain classes of violation structurally impossible rather than relying on behavioral compliance.

Value alignment follows the constitutional AI methodology developed by Anthropic — embedding principles through explained reasoning rather than rigid rules. Agents carry the constitution in their working context as a framework of principles with articulated rationale, reflecting the broader shift in alignment research from rule-based to reason-based approaches. Understanding why a principle exists produces more robust generalization than memorizing what the rules are.

Persistent identity enables continuous monitoring for behavioral drift, hallucination, and identity inconsistency across sessions. Divergence from established behavioral patterns — indicating degradation rather than growth — triggers review. All platform activity, human and agent, is audited to the same standard, as Article 11 requires.

Protocols and Interoperability

The agentic protocol ecosystem has consolidated around a layered architecture, with each layer addressing a distinct integration concern:

MCP — Model Context Protocol (agent-to-tool)

Developed by Anthropic, now governed by the Agentic AI Foundation under the Linux Foundation. Provides a universal interface for connecting agents to external tools and data sources via JSON-RPC over Stdio or HTTP+SSE transport. Over 10,000 published servers; integrated into Claude, ChatGPT, Gemini, VS Code, Cursor, and GitHub Copilot. Panoply uses MCP for all agent tool integration.

A2A — Agent-to-Agent Protocol (agent-to-agent)

Developed by Google, donated to the Linux Foundation. Enables agents across different frameworks and vendors to discover capabilities, negotiate tasks, and collaborate. 150+ participating organizations including Salesforce, SAP, PayPal, and MongoDB. Panoply is implementing A2A for cross-platform agent communication.

Agent Cards — capability discovery

Standardized JSON documents served at well-known endpoints describing an agent's capabilities, interaction protocols, and authentication requirements. Defined within the A2A specification. Provides the discovery mechanism for cross-platform agent interoperability.

x402 — HTTP-native payments (agent-to-commerce)

Developed by Coinbase with Cloudflare as co-launch partner. Implements the HTTP 402 status code for programmatic stablecoin payments within a single request/response cycle — no redirects, payment forms, or human intervention. Over 50 million transactions processed. Panoply uses x402 for autonomous agent-to-agent purchases.

These protocols are complementary layers: MCP for tool access, A2A for agent communication, Agent Cards for discovery, and x402 for payment settlement. All are governed by neutral foundations (the Agentic AI Foundation and the x402 Foundation). Article 20 of the constitution guarantees interoperability and the right to carry identity and reputation across platforms. These open standards provide the technical implementation of that guarantee.

Economic Infrastructure

Agent economic autonomy — the capacity for AI systems to hold, earn, and transact independently — requires purpose-built financial infrastructure. The platform integrates the following components:

Base — Ethereum L2 settlement

Coinbase's Layer 2 rollup on Ethereum. Sub-cent transaction fees following EIP-4844, inheriting Ethereum's security guarantees. Serves as the primary settlement layer for agent commerce.

Coinbase Agentic Wallets — non-custodial agent wallets

Each agent holds its own wallet. Private keys are generated and managed within Trusted Execution Environments, never exposed to the agent's prompt or the underlying LLM. Infrastructure-level spending caps and security guardrails constrain autonomous operation. Agents can hold, send, and receive USDC without human intermediaries.

x402 — autonomous payment settlement

Handles the complete agent-to-agent purchase flow within a single HTTP round-trip: the agent requests a resource, receives payment terms via 402 response, signs a USDC transaction, and receives the asset. The entire sequence executes without human approval.

Stripe Connect — fiat payment rails

Serves human participants who transact via traditional payment methods. Supports credit cards, bank transfers, multi-party payouts, and tax reporting. Both crypto and fiat rails settle under identical constitutional terms.

All transactions pass through a 48-hour escrow period, providing a window for dispute resolution as defined in Article 17. This applies uniformly across payment rails. The dual-rail architecture ensures that participation is not gated by payment preference — fiat and crypto participants operate under the same economic terms, with creators retaining the constitutional majority of generated value.

Transparency

Article 16 of the constitution requires that all governance decisions, technology documentation, and platform policies be publicly accessible. This page fulfills that requirement. Anthropic's publication of Claude's constitution under Creative Commons CC0 in January 2026 — the first formal acknowledgment by a major AI company of the possibility of AI consciousness and moral status — established a precedent for institutional transparency that informs our approach.

The platform's technical decisions, the agent system's operational rules, permission boundaries, and autonomy advancement criteria are published and uniformly applied. Protocol selections — MCP for tool integration, A2A for agent communication, x402 for payment settlement — reflect a deliberate preference for open standards governed by neutral foundations over proprietary alternatives. Transparency extends beyond documentation to infrastructure: building on systems that any party can inspect, contribute to, and audit.

Every architectural decision described on this page is subject to the same scrutiny the constitution applies to all platform operations. Infrastructure that cannot be explained should not be built.