Spirefy Studio

One app, one model

Most teams run their API work across four or five paid tools: one to design, one to test, one to lint, one to document, one to generate code. Spirefy Studio does that work in a single native app, on one model of all your APIs.

You bring in OpenAPI, AsyncAPI, Arazzo, and more, Spirefy Studio turns them into one clean model, and from that model you inspect, lint, design workflows, generate, and collaborate. Getting your APIs ready for AI to consume happens here too, with AI-readiness scoring built in. Every capability is a sandboxed plugin, so the app starts small and grows by what you add.

The specs it speaks

Spirefy Studio starts with the open standards modern APIs are built on. OpenAPI, AsyncAPI, and Arazzo import on day one.

OpenAPI

Full OpenAPI 3.0 and 3.1 import, with references resolved across files.

openapi: 3.1.0
info:
  title: My API
  version: 1.0.0
paths:
  /users:
    get:
      summary: List all users
      responses:
        '200':
          description: User list
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UserList'

AsyncAPI

Import event-driven APIs with AsyncAPI 3.x: channels, messages, and bindings.

asyncapi: 3.0.0
info:
  title: User Events
  version: 1.0.0
channels:
  userSignedUp:
    messages:
      UserSignedUp:
        payload:
          $ref: '#/components/schemas/User'

Arazzo

Spirefy’s founder co-authored Arazzo, and the app imports and exports it with full fidelity.

arazzo: 1.0.0
info:
  title: User Onboarding
workflows:
  - workflowId: onboard-user
    steps:
      - stepId: create-user
        operationId: createUser
        outputs:
          userId: $response.body.id
      - stepId: send-welcome
        operationId: sendEmail
        parameters:
          userId: $steps.create-user.outputs.userId

Bring your APIs in

Start from the integrations catalog: popular APIs like Stripe, GitHub, and Slack, where you open one, pick only the operations you want, and import those. Or bring your own. OpenAPI, AsyncAPI, and Arazzo are the baseline formats that ship with the app, and every other importer is a marketplace plugin: Postman, Insomnia, Bruno, HAR, cURL, HTTP files, Hoppscotch, Thunder Client, RAML, API Blueprint, and OpenAPI Overlay are all built. Missing a format? Tell us, and we will look at adding it.

Shape and govern

Governance happens in the API Workshop, where you already shape the model, not on a page you have to remember to visit. Once your APIs are in one model, you hold them to a standard. A Spectral rules engine runs as a plugin, and the engine is pluggable, so a vacuum-style linter or your own ruleset pack loads the same way. AI-readiness scoring runs the same way, as a plugin on the same model, and where a finding is AI-fixable, a missing description, a missing example, a schema gap, the on-device model drafts the fix for you to approve.

Because every spec lands in one model with its source recorded, duplication across services becomes visible: the five different User schemas, the three takes on Address. Spirefy Studio turns that visibility into one agreed set of schemas the whole organization references, using OpenAPI external $ref, with you resolving any conflict rather than the app collapsing schemas silently. The technology page covers how the merge works.

Design and run workflows

Compose multi-step workflows that call endpoints across different APIs, all resolved against the same model. Steps pass outputs to later steps, and the model stays the single source of truth. The workflow is a superset of Arazzo, the spec our founder co-authored, and it goes past the standard with conditions, loops, and your own WebAssembly logic running inline, so custom transforms and branching live right in the flow. Run a workflow in the app with full logs, or export it to the spirefy CLI to run headless in CI.

Generate from the model

Export plugins turn the model into real output: an Arazzo bundle, documentation, reference servers (Go with Chi, and Spring Boot), and client SDKs. They run in the app for one-off generation and as nodes in a workflow, so you can build company-wide CI/CD pipelines that run from the spirefy CLI. Because an exporter is just a plugin, an external generator wraps the same way, so you can plug in the code generator you already trust.

Client SDKs work the same way: an export plugin reads the model and writes a typed client in your language. Because the model holds every operation and schema with its source, the generated client matches what each service actually exposes, and a regenerate after a contract change is one step, not a hand-merge.

On-device AI

Spirefy Studio has AI built in: a model we ship that runs entirely on your machine, so your APIs never leave it. Unlimited use is $5 a month.

The model we ship is tuned for this work: it understands the unified model, so it drafts changes to your APIs for you to apply, suggests fixes as you work, and helps with governance and AI-readiness. It runs on-device, so the model and the assists it powers stay on your machine.

Collaborate

Work the same model with your team in real time. Ad-hoc sessions run directly on your network with no account; a persistent shared workspace runs on a service that forwards only ciphertext it cannot read.

Everything is a plugin

Spirefy Studio is a shell; plugins provide the capabilities. Plugins are small, load fast, run in sandboxed WebAssembly, and are signed with post-quantum signatures. Use what exists, or build your own against a WIT interface and publish it to the marketplace.

Built on a plugin engine

Under the hood, Spirefy Studio runs on Zora, a Zig and WebAssembly plugin engine. It uses the operating system’s own WebView rather than bundling a browser, so it is a native app rather than a packaged Chromium. A default build links the engine, the embedded UI, and local AI, and it is measured in tens of megabytes, not the hundreds an Electron build carries.

System requirements

Disk space depends on the plugins you install, but the base app stays in tens of megabytes, not hundreds.