Vintraa for developers

Bring your agent.Keep your architecture.

Connect a deployed agent, prove its real behaviour in an isolated customer test, and publish the exact release your customers will run.

Read the public API Download OpenAPI JSON

Framework-neutral
Immutable releases
Human-reviewed publication

release.pipelinepublishable

Inspect

Inspect a deployed service or contract and review the compatibility report.

POST /publishers/{publisherId}/agent-import-inspections

Register

Declare Free or publisher-managed Payment required, then freeze the reviewed manifest and commercial disclosure as an immutable semantic release.

POST /publishers/{publisherId}/agents

Exercise

Create an isolated test installation and run at least one real adapter action.

POST /publishers/{publisherId}/agents/{publisherAgentId}/versions/{versionId}/test-installations/{testInstallationId}/runs

Declare billing owner

For Payment required agents, set customerBillingOwner to publisher and use an external_* pricing model. Your service owns customer checkout and entitlement; Vintraa never collects that payment.

Manifest pricing.model

Submit

Run conformance, then submit the exact tested version to human review.

POST /publishers/{publisherId}/agents/{publisherAgentId}/versions/{versionId}/submit

Runtime, permissions, pricing, and customer surface stay bound to one reviewed version.

Optional SDKs

Verified requests and durable replay, without rebuilding the protocol.

Use the SDK that matches your service, or implement the same public HTTPS/OpenAPI contract directly. SDK use does not grant certification or special authorization.

Follow the SDK onboarding guide

TypeScript@zyntrialabs/vintraa-agent-sdk

npm install @zyntrialabs/vintraa-agent-sdk

Express adapter included; the core remains framework-neutral. Use RedisIdempotencyStore with node-redis in multi-process production.

Pythonvintraa-agent

python -m pip install 'vintraa-agent[fastapi,redis]'

FastAPI is an optional extra; importing the core does not install a server. Use AsyncRedisIdempotencyStore with redis.asyncio in production.

Release path

From a running service to a reviewed release.

Vintraa discovers contracts, but discovery is never approval. You review the normalized manifest, test the executable adapter, and submit the same frozen version. Create your publisher profile and activate its membership in the Publisher Console before using these release operations. If the agent requires payment, complete the publisher-managed billing declaration. Vintraa does not collect customer payment; the publisher owns checkout, receipts, refunds, tax, support, and entitlement.

1 · Authenticatecurl + jq

# Requires curl and jq. Use an existing verified Vintraa account.
export VINTRAA_API="https://api-vintraa.zyntrialabs.com"
export VINTRAA_EMAIL="[email protected]"
read -r -s -p "Vintraa password: " VINTRAA_PASSWORD; echo

VINTRAA_TOKEN="$(curl --fail-with-body --silent --show-error \
  --request POST "$VINTRAA_API/auth/login" \
  --header 'Content-Type: application/json' \
  --data "$(jq -nc \
    --arg email "$VINTRAA_EMAIL" \
    --arg password "$VINTRAA_PASSWORD" \
    '{email: $email, password: $password}')" \
  | jq -er '.accessToken')"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $VINTRAA_TOKEN" \
  "$VINTRAA_API/publishers/mine" | jq

First create and verify an account in Vintraa. This signs in, keeps the JWT only in your current shell, and lists your publisher accounts. A new account receives an empty JSON array. Do not commit the token.

2 · InspectBearer token required

# Continue in the same shell after signing in.
export VINTRAA_PUBLISHER_ID="replace-with-your-publisher-id"

curl --fail-with-body --silent --show-error \
  --request POST \
  --header "Authorization: Bearer $VINTRAA_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"sourceType":"AUTO","source":"https://agent.example.com"}' \
  "$VINTRAA_API/publishers/$VINTRAA_PUBLISHER_ID/agent-import-inspections" | jq

Expected: a normalized manifest, detected protocol facts, compatibility, and warnings. Inspection is not approval, and manifests must never contain credentials.

Integration choices

Runtime and interface are separate decisions.

Supported end to end

Signed HTTPS

vintraa-http-v1

Keep your service and framework. Accept the versioned invocation envelope and verify each Ed25519 signature.

Supported with conditions

OpenAPI, A2A, or MCP

reviewed public contracts

Vintraa can import exact, explicitly reviewed read-only operations without credential passthrough. Discovery alone is not approval.

Independent choice

Customer experience

embedded · external · API-only · native

Select the customer surface separately from the runtime. Consult the support registry for the stage-level status of each mode.

Protocol guides

Build the exact subset Vintraa can publish today.

OpenAPI, A2A, and MCP imports are intentionally bounded to reviewed, unauthenticated, read-only behavior. Each guide includes the source contract, inspection request, normalized binding, sandbox input, and rejection conditions.

Implementation guide

OpenAPI operation

openapi-operation-v1

Use an OpenAPI 3.x document to expose one or more public, read-only HTTPS GET operations. Vintraa freezes each reviewed path, method, and parameter list into the release.

Read guide Implementation guide

A2A JSON-RPC skill

a2a-jsonrpc-v1

Use an A2A Agent Card to expose an exact reviewed JSON-RPC skill. Vintraa currently publishes only unauthenticated skills that a publisher has explicitly confirmed are read-only.

Read guide Implementation guide

MCP Streamable HTTP tool

mcp-streamable-http-v1

Use a public MCP Streamable HTTP endpoint to expose an exact reviewed tool. Vintraa currently publishes only tools declared read-only and non-destructive, with no server credentials.

Read guide

Runtime verification

Use the signing keys for your environment.

Both SDKs default to the production signing-key registry. Configure the registry explicitly for staging. Publishing API configuration does not change runtime signature verification. Trust only the registry for your environment; never disable verification or combine staging and production keys.

Staging

API: https://vintraa-be-staging.up.railway.app

Signing-key registry: https://vintraa-be-staging.up.railway.app/public/runtime-signing-keys

TypeScript and Python configuration

TypeScript

import { HostedPublicKeyProvider } from "@zyntrialabs/vintraa-agent-sdk";

const publicKeys = new HostedPublicKeyProvider({
  url: "https://vintraa-be-staging.up.railway.app/public/runtime-signing-keys",
});
// Pass publicKeys to your Vintraa runtime adapter.

Python

from vintraa_agent import HostedPublicKeyProvider

public_keys = HostedPublicKeyProvider(
    url="https://vintraa-be-staging.up.railway.app/public/runtime-signing-keys",
)
# Pass public_keys to your Vintraa runtime adapter.

Production

API: https://api-vintraa.zyntrialabs.com

Signing-key registry: https://api-vintraa.zyntrialabs.com/public/runtime-signing-keys

TypeScript and Python configuration

TypeScript

import { HostedPublicKeyProvider } from "@zyntrialabs/vintraa-agent-sdk";

const publicKeys = new HostedPublicKeyProvider({
  url: "https://api-vintraa.zyntrialabs.com/public/runtime-signing-keys",
});
// Pass publicKeys to your Vintraa runtime adapter.

Python

from vintraa_agent import HostedPublicKeyProvider

public_keys = HostedPublicKeyProvider(
    url="https://api-vintraa.zyntrialabs.com/public/runtime-signing-keys",
)
# Pass public_keys to your Vintraa runtime adapter.

If an incoming key ID is unknown, refresh the configured registry once and reject the call if the key remains absent. Never trust a key URL from the incoming request.

Your agent’s launch key is separate from Vintraa’s runtime signing keys. To change a launch key or launch URL after submission, choose Create new version under the existing agent, inspect the updated build, test it and submit the new candidate. Finish any existing draft first. The earlier release and its review stay unchanged.

Customer launch environments

Give sandbox its own destination.

Provide a production app URL in customerExperience.launchUrl and a production runtime URL in runtime.endpoint. Add separate sandbox URLs in the optional root x-vintraa.com-environments extension. The same UI may be deployed twice, but its sandbox database, storage, secrets, payment providers and messaging integrations must be isolated from live systems.

If a sandbox URL is omitted, Vintraa uses the production URL for that destination and displays a shared-environment warning. A different URL alone does not prove isolation. Use synthetic data and never describe a shared database as an isolated sandbox. If a configured sandbox destination fails, Vintraa does not fall back to production.

External apps must exchange the one-time launch code on their server, read context.environment (sandbox or production), show a persistent visible environment banner, and bind the session to that environment. Embedded apps receive the same value in the verified vintraa.experience.init context. Treat form fields, query parameters and local storage only as untrusted hints. Reject a mismatch between the verified environment and the app deployment.

Signed runtime calls carry context.installation.environment. Verify the signature before choosing data stores or credentials. A sandbox launch never gains live permissions when the customer later activates the installation. Production requires activation and the usual review, permission and billing checks. Vintraa simulates its platform message capabilities and does not bill its usage events in sandbox; publishers must independently use test modes for their own integrations and billing.

Include both launch origins in customerExperience.allowedOrigins and verify ownership of every hosted origin. Changes to either URL require a new frozen release and review. Sandbox runtimeEndpoint is currently supported for vintraa-http-v1; other adapters retain their reviewed runtime. The external launch exchange uses the release's existing reviewed client-authentication key.

Vintraa staging/production API deployments and an agent's sandbox/production execution mode are different settings. Use only the signing-key registry for the Vintraa deployment making the call. A sandbox launch on Vintraa production still uses Vintraa's production signing registry. Do not combine staging and production trust stores.

# Relevant fields in a complete publisher release manifest v2
runtime:
  adapter: vintraa-http-v1
  endpoint: https://app.example.com/v1/invocations
customerExperience:
  mode: external
  launchUrl: https://app.example.com/launch
  allowedOrigins:
    - https://app.example.com
    - https://sandbox.example.com
x-vintraa.com-environments:
  sandbox:
    launchUrl: https://sandbox.example.com/launch
    runtimeEndpoint: https://sandbox.example.com/v1/invocations
# Keep the required external client-authentication extension and other manifest fields.

Trust boundary

The browser never chooses what gets trusted.

Vintraa resolves the frozen release, endpoint, workspace, installation, role, and granted permissions on the server. Every customer action stays scoped, metered, idempotent, and auditable.

Signed contextTenant and installation identity are platform-owned.
Bounded executionOnly declared, reviewed actions can run.
Release evidencePrivate tests and conformance attach to the submitted version.

Canonical resources

Build against the public contract.

Interactive reference/public#/OpenAPI JSON/openapi-public.jsonSupport registrycontract 2026-08-06Runtime signing keysEd25519 public keysMarkdown guideAPI 2026-10-16.1Agent-readable summary/llms.txt