Mulholland — Phantom

The nouns and verbs of your business.

Get the foundation right, everything else follows. That's why we don't start with prompts — we start with your business. Every noun (Customer, Order, Lease), every verb (Approve, Reorder, Send), every rule that connects them, written down once. The model is the instruction. The same one every agent reasons over, every screen renders, every action checks against. Deterministic, by design.

Object typesCustomer, Order, Lease, SKU, Shipment, Work Order. The nouns of your business.
Propertiesorder_id, total_amount, ship_date, margin, lead_time. Typed fields on every object.
RelationshipsCustomer placed Order. Order contains SKU. Lease belongs to Property.
Action typesReorder a SKU. Approve a claim. Send a quote. The verbs of your business — what anyone, human or agent, is allowed to do.
InterfacesShared capabilities across object types. If a Customer can be invoiced, so can a Vendor — same contract, no rewrite.

Where the work actually gets done.

Every action your business permits has a skill behind it — the actual logic that runs when an agent reorders a SKU or approves a claim. Could be Claude. Could be a deterministic model you trained. Could be twelve lines of Python. We pick what works, and swap it the second something better shows up.

BindingsEach skill fulfills a typed action — same contract, multiple implementations competing for the slot.
Eval harnessTest cases, pass/fail criteria, side-by-side comparison. New model? Run it through. If it wins, it ships.
TelemetryCost, latency, drift — measured per skill, per binding, in production.
GuardrailsInputs and outputs validated. Fallback behavior the moment a skill degrades.

Everything that happened, available to query.

Three years of orders. The override your operator made last Tuesday. The churn signal flagged in March. Ontology is the schema; memory is what fills it in — append-only, replayable, queryable by anyone with the right permissions. Year one, you have a schema. Year two, you have a moat.

Append-onlyProvenance-tagged on the way in. Replayable on the way out. Nothing is overwritten.
QueryableOperators read the same model the agent does. Auditors get a different query, not a separate report.
OwnedThe runtime is rented. The memory is yours. Postgres on your project, kept beyond the contract.

How agents reach the outside world.

When a skill needs to hit Shopify, fetch a contract, or send an email, it calls a tool. Typed inputs, typed outputs, permissions enforced before anything happens. Shopify isn't a tool — the typed reader-and-writer pair we built against Shopify is. We catalog by what a tool does, not by who made it.

ReadersPull information in — ERP queries, inventory lookups, contract retrieval.
WritersAct on the world — create an invoice, send a notification, place a reorder.
SearchersFind across external sources or internal knowledge.
ComputersLocal work that doesn't touch the outside — execute code, parse a PDF, run an optimization.
Memory toolsHow Phantom reads and writes its own memory layer.

Where the product actually lives.

Models get cheaper every quarter. Reasoning gets better every month. The hard part isn't the smart parts — it's deciding what each agent sees, what it's allowed to do, when it can act, and what happens when something breaks. That's the harness.

ContextWhat an agent sees at any given moment. What it does not.
PermissionsRow-level security on reads. Approval gates on writes. Per-client scope, always.
Autonomy ladderObserve → diagnose → recommend → draft → execute-with-approval → execute. The client controls the pace; the system earns each rung.
CoordinationRetries, failures, multi-agent handoffs — governed in one place, not scattered across skills.
AuditEvery action replayable. Every memory write traceable. Compliance queries the same model operators use.

The other parts of the system.

Phantom is the OS. Marzy is the conductor. Atlas, Arroyo, and Basin sit underneath.

Marzy Atlas Arroyo Basin