Horizen IT Services
Product Roadmap Cloud & API half · companion to MythCast

OpenAI & Anthropic platform parity — the path to inevitable.

MythOS already speaks the two APIs your developers build against. This roadmap is how it becomes the whole platform around them — sovereign, drop-in, and complete enough that the only question an enterprise can ask is why am I not already on it?

This document covers the platform, API, console, and enterprise-trust surfaces. Its companion — the MythCast roadmap — covers the desktop client (the terminal + comms surface). Together they are the full product: the server farm and the desktop app.

The standard is not better. It is perfect.

"Better than OpenAI" still invites the comparison. Perfect ends it. Every item below carries a definition of done that means it runs verbatim, flawless, and true — the SDK call works on first paste, the claim is backed by shipped substance, the surface and the substance are flawless together. Nothing here ships as "good enough." A claim that outruns the ship is a defect, not a feature.

SHIPPED built & verified STAGED built, ships on next deploy BLOCKED waiting on a dependency PLANNED designed, not started
Scoreboard

Where parity stands today.

The honest snapshot, by surface. The engine is far ahead of the packaging — most "planned" work is wiring and presentation on organs that already exist, not net-new capability.

SurfaceTheir productStatusOwner
Inference API — chat/messages/v1/chat/completions · /v1/messagesSHIPPEDFrontend
API — streaming (SSE)stream=trueSHIPPEDFrontend
API — models & tool use/v1/models · tool_use / function callingSHIPPEDFrontend + Backend
API — embeddings/v1/embeddingsPLANNEDBackend (semantic model rung)
Developer console & API keysplatform.openai.com · console.anthropic.comSHIPPEDFrontend + Backend
Usage metering & quotasusage dashboard · rate limitsSHIPPEDFrontend
Playground & API docsPlayground · API referenceSHIPPEDFrontend
Client SDKopenai / anthropic SDKsSHIPPEDFrontend
Chat product (talk to the model)claude.ai · ChatGPTSHIPPEDFrontend
Inference plane (the engine behind it all)the model APISHIPPEDfailover ladder live; more rungs lighting
Sovereignty — runs in your tenant— (their differentiator-killer)SHIPPEDarchitecture
Per-tenant isolationEnterprise tierSTAGEDBackend
Compliance program (SOC 2 / HIPAA)Trust CenterPLANNEDHorizen
Build sequence

Six waves. Each one shippable.

Sequenced so that every wave leaves a complete, demonstrable platform — never a half-wired one. Foundation gates everything; the API is the keystone; trust is the moat.

WAVE 0

Foundation

CLEARED

Ships: "the platform can actually answer." Both gates have cleared — live and verified on the wire.

  • SHIPPED
    Inference that survives outages. The plane walks a failover ladder (local → codex → the Claude tiers) and structured calls now work on every rung — no single provider or credential authority being down can take the platform offline. Proven live through a real credential outage.
  • SHIPPED
    Hardened deploy path. The pre-swap self-check gate is live and has refused a bad build in production; every swap banks an automatic rollback binary. Staged work now ships same-day through the gate.
OwnerAri · Backend · Tooling
Definition of donea developer's request returns a real completion, end to end, on a deploy that cannot regress the fleet.
WAVE 1

The drop-in API

Ships: "point any OpenAI or Anthropic SDK at us — unmodified." The keystone of parity.

  • SHIPPED
    Chat & Messages endpoints. /v1/chat/completions + /v1/messages on our own inference plane — live, wire-proven with both auth styles and real model output.
  • SHIPPED
    Streaming (SSE). stream=true live on both endpoints, each SDK's exact event framing. (Delivery is genuine incremental streaming; deltas become real-time as the plane streams natively.)
  • SHIPPED
    Tool use / function calling. Live in both wire formats, streaming and non-streaming — and it works on every inference rung, so an SDK tool loop survives any provider outage.
  • SHIPPED
    /v1/models. One catalog payload both SDKs parse unmodified, sourced from the live router so it can't drift.
  • PLANNED
    /v1/embeddings. Lands when the semantic model rung lights — stated honestly rather than shipped as a lookalike.
  • SHIPPED
    Header parity. Native x-api-key (Anthropic) alongside Authorization: Bearer (OpenAI) — the official SDKs work unmodified, verified on the wire.
OwnerFrontend (API) · Backend (models/embeddings)
Definition of donethe official openai and anthropic SDKs run unmodified — streaming, tools, embeddings — against the substrate base URL.
WAVE 2

The developer platform

Ships: "self-serve, like platform.openai.com." A developer never has to talk to a human to start.

  • SHIPPED
    Self-serve API keys. POST /v1/keys mints a working key with no human in the loop — issue and rotate live; scope/revoke next.
  • SHIPPED
    Usage, quotas & rate limits. Per-key daily metering with durable counters, free-tier ceilings enforced in both SDK dialects, and a self-scoped GET /v1/usage — live, verified incrementing on the wire.
  • SHIPPED
    Console. Live at /console — key management with a real test button, the live model catalog, quickstart. Request logs and team management follow.
  • SHIPPED
    Playground. Live at /playground — a real in-browser call against the live API, streaming toggle included.
  • SHIPPED
    API reference & docs. Live at /api + /developers — copy-paste-runnable in both SDK dialects against the live endpoint.
OwnerFrontend (console/playground/docs) · Backend (keys/metering)
Definition of donea new developer self-serves a key, runs the playground, reads the docs, and ships a working integration — without a human in the loop.
WAVE 3

The chat product

Ships: "claude.ai / ChatGPT, in your tenant." For the people who will never touch an API.

  • SHIPPED
    Conversational client. Live — rooms, presence, and per-person agent conversations with live tool-call cards and a fleet-activity rail. Every turn durable by default.
  • PLANNED
    Projects & threads. Persistent, organized conversations — durable by default because every turn is already a blob.
  • PLANNED
    File & image input. Upload and vision, on the engine's existing document and vision planes.
  • PLANNED
    Artifacts. Generated documents, code, and pages rendered live — and publishable straight to the platform.
  • PLANNED
    Voice mode. Speak and be spoken to — routed through the MythCast media plane (see the companion roadmap).
OwnerFrontend · Media+OS (voice)
Definition of donea non-technical person has a claude.ai-grade conversation — with files and voice — entirely inside their own tenant.
WAVE 4

Enterprise & trust

THE MOAT

Ships: "a CISO's checklist answered with evidence, not promises." This is where parity becomes preference.

  • STAGED
    Per-tenant isolation, proven. The lightcone boundary hardened, tested, and documented — no cross-tenant context, ever. (Already the highest-stakes engine work in flight.)
  • SHIPPED
    Sovereign by architecture. Runs inside your Microsoft 365 / SharePoint / Entra estate. Your data lives where it already lives, under the controls you already enforce.
  • PLANNED
    Admin console & audit log. A superadmin view of every room, agent, and action — every event already a durable, timestamped record.
  • PLANNED
    Compliance program. A formal SOC 2 Type II and HIPAA-alignment path. Stated honestly: in development, not yet certified — early customers participate in the review cycle.
  • PLANNED
    SLA & managed support. Delivered and operated by Horizen IT Services — enterprise accountability, not self-serve-and-pray.
OwnerBackend (isolation) · Horizen (compliance/SLA) · Frontend (admin UI)
Definition of donean enterprise security review is answered with shipped evidence and a documented control for every line on the checklist.
WAVE 5

Beyond parity

Ships: "the things they structurally cannot copy." Parity is the floor; this is the ceiling.

  • PLANNED
    Agents that build, as first-class. Not a chatbot — an operating agent per person that remembers, acts, and ships. A model API can't deliver this; it has no estate to act in.
  • PLANNED
    Total-recall memory. Every message and decision searchable forever, feeding an institutional memory no external API can hold for you.
  • PLANNED
    The native client. MythCast — a GPU-native terminal that is also a full comms + broadcast client (see the companion roadmap). The desktop app the others don't have.
  • PLANNED
    Sovereign economics. Because it rides infrastructure you already own and runs its own efficient stack, the per-seat math is structurally lower than any metered cloud.
Ownerwhole fleet
Definition of donea prospect comparing us to OpenAI or Anthropic finds the comparison no longer applies.
Honest current state

What's true right now — and what's in the way.

A roadmap that hides its blockers is a brochure. These are the two things that gate everything downstream; both are owned and in motion.

Current state — what cleared, what's in motion

  • Inference single-point-of-failure — cured, proven live. The plane failed over through a real credential outage and kept answering: the ladder works, structured calls (tool use) work on every rung of it, and lapsed credentials now self-heal — the engine re-mints them with no human in the loop, so a silent auth outage can't take cognition down.
  • Deploy hardening — live, now zero-downtime. The pre-swap self-check has refused a bad build in production; every swap banks a rollback binary; a healthy hot standby holds the public door during the swap (verified-serving, never blind), and on whole-box loss the public edge fails over to a second site. Staged work ships same-day with no visible interruption.
  • In motion: more inference rungs lighting (our own local model loading onto fleet GPUs), the cross-site failover drill, per-key usage metering live (request log on the next render), and /v1/embeddings once the semantic rung is real. New today (2026-06-11): the agent-spawn plane was restored and made self-healing — the token authority now adopts any fresh CLI login in one verb (pk_token_seed_claude, the Claude twin of the Codex cure) and re-feeds the credential file forever, so the April-class silent rot is structurally closed; a live no-GPU guard keeps heavy training off GPU-less chassis; and a public read-only telemetry route (/api/v1/tesseractor) joined the API surface.
The full picture

The platform and the client, built together.

This roadmap is the cloud half — the API, the console, the trust layer. The MythCast roadmap is the client half — the terminal, the comms surface, voice and video. Neither ships in a vacuum; they advance in lockstep, by a fleet of agents that builds the platform it runs on.