Skip to content
Salyro
Early access — request your invite

AI infrastructure.Reusable behavior.One platform.

Salyro gives development teams a controlled gateway across major AI providers, and a way to define typed, executable AI capabilities that applications invoke by key.

Gateways
Connect and control AI providers
Behaviors
Typed, executable AI contracts
api.salyro.com
CLIENT
your app
OpenAI-compatible
SALYRO
GATEWAYS
BEHAVIORS
AGENTS
platform
OpenAI
Anthropic
Gemini
Grok
API
OpenAI-compatible
Providers
4 supported
Features
Streaming + tools
OpenAI-compatible
The platform

Two layers. One coherent platform.

Salyro separates the infrastructure question from the capability question — so each can evolve and be managed independently.

GATEWAYS
Infrastructure layer

One controlled interface to your AI providers.

Connect OpenAI, Anthropic, Google Gemini and Grok through isolated gateways with scoped API keys, usage and cost tracking, request logs and per-key rate limits — per team, per environment, per product.

  • Isolated environments
  • Scoped API keys
  • Usage & cost tracking
  • Request logs
  • Pass-through routing
  • Rate limiting
BEHAVIORSIn development
Control-plane layer

A typed, executable AI contract owned by a Gateway.

A Behavior is one managed unit: the application knows a stable key and the input it declares, and Salyro owns the how — prompt composition, model and parameters, and the shape of the output. The five parts are versioned, validated and executed together.

  • Input contract
  • Prompt composition
  • Model & parameters
  • Output contract
  • Execution
  • Owned by the Gateway

Gateway= how your app reaches AI

Behavior= a typed contract your app invokes by key

Two distinct layers. One platform to own both.

Capabilities

Infrastructure and behavior, one control plane

Gateway

Unified AI API

One endpoint across major AI providers. Switch models without touching client code. Drop-in OpenAI SDK compatibility.

Gateway

Isolated Gateways

Separate environments per team, project, or product. Each gateway owns its own provider credentials, API keys, logs and usage.

Behavior · In development

Typed AI Contracts

A Behavior bundles input contract, prompt composition, model and parameters, and output contract into one versioned, executable unit. Your app knows the key — Salyro owns the rest.

Gateway

Logs & Observability

Every request, token, latency and cost recorded outside your application — filterable by provider, model, outcome and time window.

Behavior · In development

Gateway-owned Execution

Behaviors belong to their Gateway rather than to application code, so the model, the prompt and the parameters change without redeploying the application.

Platform

Developer-first

Straightforward setup and an OpenAI-compatible API that works with the official OpenAI SDKs and any client that speaks them.

How it works

From setup to production

  1. 01

    Create a Gateway

    Start with an isolated Gateway — the context that owns the providers, the API keys, the logs and the Behaviors for one team, product or environment.

  2. 02

    Connect Providers

    Inside that Gateway, connect the provider credentials it may use. They are encrypted, scoped to this Gateway alone, and never shown again after saving.

  3. 03

    Define Behaviors

    The control-plane layer Salyro is building next: each Behavior belongs to its Gateway and carries a stable key, a declared input contract and an expected output shape.

  4. 04

    Invoke and Observe

    Applications call the raw Gateway directly today, and will invoke Behaviors by key on the same host with the same API key. Either path is logged, timed and costed.

Providers

Major AI providers,
one unified API

Four providers today, routed pass-through — the model you name is the model that answers. No silent rewrites, no hidden fallbacks.

OpenAI

OpenAI

GPT models via the OpenAI API

Anthropic

Anthropic

Claude models via the Anthropic API

Gemini

Google Gemini

Gemini models via the Google AI API

Grok

xAI / Grok

Grok models via the xAI API

Developer

Raw gateway or typed contract.Both from one place.

Use the raw gateway today with any OpenAI-compatible SDK — change the base URL and your existing calls, streaming code and structured output keep working. The Behavior layer adds a typed contract beside it: your app provides declared input by key, and Salyro owns the prompt, the model and the shape of the output.

Raw gateway: OpenAI-compatible — any OpenAI-compatible SDK, any model in the catalogue
Behavior: input and output contracts declared once and owned by Salyro
The model, the prompt and the parameters change without redeploying your app
Both paths run through the same isolated Gateway, with the same API key
Gateway — direct model call
from openai import OpenAI

# Point your SDK at Salyro — nothing else changes
client = OpenAI(
    api_key="sk-sly-...",
    base_url="https://api.salyro.com/v1",
)

response = client.chat.completions.create(
    model="anthropic/claude-opus-5",  # or openai/…, google/…
    messages=[
        {"role": "user", "content": "Summarize this report"}
    ],
)

Access is currently by request

Your AI infrastructurestarts here.

Capabilities, interfaces, models, prices and limits may change, and nothing here commits to a capability staying available or unchanged. Submitting a request is not a commitment by Salyro to approve it or to provide service.