The unified model

At the center of Spirefy Studio is the unified model: one domain shape that represents many API and workflow specs at once while staying compatible with the open standards it builds on. A single model faithfully holds OpenAPI 2 and 3, AsyncAPI, Arazzo, Postman, Insomnia, Bruno, and more, without forcing each one through another spec’s structure.

The model holds operations (REST), channels (pub/sub), components (schemas, parameters, headers, responses), workflows (multi-step orchestration), sources (provenance for every import), and extensions (UI positions, plugin references, custom data).

More than Arazzo

Arazzo is a strong spec for API workflows, and Spirefy’s founder co-authored it. It is not the only way to describe workflows, so the model is a superset: everything Arazzo can represent, plus concepts Arazzo leaves out.

Mutation via spirefy.cmd.v1

Plugins never reach into the model directly. Every change goes through a JSON command-batch protocol.

{
  "protocol": "spirefy.cmd.v1",
  "metadata": { "source_type": "openapi" },
  "commands": [
    { "op": "create", "kind": "operation", "cid": "@op-1", "data": {} },
    { "op": "create", "kind": "workflow-step", "cid": "@step-1",
      "data": { "operation_ref": "@op-1" } }
  ]
}

Batches are atomic. References inside a batch use @cid syntax, so command two can point at the id command one is about to create. The result maps each temporary @cid to the real id it was assigned, and every mutation leaves an ordered history any plugin can subscribe to. The same wire format carries human gestures from the UI, macro recordings, an importer dumping a 10,000-operation spec, and the AI module emitting its next action. One protocol, every participant.

This is what makes collaboration and replay tractable: because each change is already an ordered, self-contained batch, the collaboration runtime ships those batches over the network and the record-and-replay harness stores them to drive the app later.

Arazzo import and export

Spirefy Studio does full-fidelity import and standards-compliant export for Arazzo 1.1.0 with AsyncAPI 3.x. On import, it resolves sourceDescriptions and $refs and merges the project into the model. On export, it writes the complete multi-file bundle, because Arazzo references API specs rather than embedding them.

                   Unified model
       (single source of truth in Spirefy)
                        │
               Arazzo exporter plugin
                        │
        ┌───────────────┼───────────────┐
        ▼               ▼               ▼
  .arazzo.yaml     .openapi.yaml    .asyncapi.yaml
   workflows         paths            channels
   steps             operations       operations
   sourceDescs ───►  references       components

Export to Arazzo is lossy by design, and that is the point. Arazzo is an interchange format for sharing workflows, while the model is your working format with the full editor and plugin ecosystem. Features that do not map, such as WASM step plugins, are preserved as x- extensions where possible or dropped where not. The model stays the source of truth; Arazzo is an export target for interoperability.

Supported formats

New formats arrive as plugins, not core changes. Import is broad, and the baseline formats round-trip; writing the marketplace formats back out arrives format by format. A format is not listed as supported until it is verified against the model. The current matrix lives on the Technology page.