RylvoRylvo

Connectors

Connect your HTTP systems.
Keep every call governed.

Turn an existing endpoint into an agent tool, a pre/post-turn state bridge, or a signed outbound event webhook. Test it live, attach it to bots, and trace what happens in production.

3

runtime connector types

7

authentication modes

5

supported HTTP methods

4

lifecycle states

Connectors work with customer-provided HTTP endpoints. They are not a catalog of prebuilt vendor integrations or direct database drivers.

From endpoint to production

A connector is more than a URL.

Define how an agent may use your HTTP service, verify the real exchange, scope it to the right bots, and keep its production behavior visible.

One connector registry, three runtime paths

loaded fresh for every turn

Active only

Conversation turn

A user message enters the governed agent runtime.

ToolModel chooses a scoped function → HTTP call → result returns
State SyncREAD before the turn → context → WRITE collected facts after
EventCompleted decision or tool execution → signed outbound webhook

Your HTTP service

You own the API or webhook consumer; Rylvo governs the exchange.

Encrypted credentials
SSRF guard · no redirects
Traced outcomes
01

Define

Choose Tool, State Sync, or Event; then describe the endpoint, method, timeout, and type-specific behavior.

02

Authenticate

Select one of seven auth modes. Sensitive values are write-only in the UI and encrypted before storage.

03

Save & test

Create the connector, then run a live endpoint test with the saved auth, transforms, timeout, and retry policy.

04

Attach

Scope the connector to the bots and workflow stages that need it. Tool approval requirements travel with it.

05

Activate

Active connectors are loaded from the registry on every turn; State Sync and Event connectors run automatically.

06

Observe

Inspect tests, call outcomes, delivery logs, health signals, dead letters, and connector context inside traces.

Three runtime roles

Call, synchronize, or notify.

Each connector type has a specific place in the turn lifecycle. Choose one job per connector so its behavior stays explicit.

Let the model call your API

Tool connector

Turn an existing HTTP endpoint into a named function the model can choose during a conversation.

GET, POST, PUT, PATCH, or DELETE

Model-facing input schema and simple request/response field maps

Workflow-stage scope, approval gates, idempotency, retries, and circuit breaking

Bring remote context into each turn

State Sync connector

Read state from your HTTP service before a turn and write collected business facts back after it.

Read, write, or bidirectional modes with separate endpoints

Field mapping plus patch or replace writes

Fail-open reads and If-Match optimistic concurrency support

Notify the rest of your stack

Event connector

Send signed outbound webhooks after live workflow decisions and tool executions.

Outbound delivery only—not an inbound webhook receiver

Signed payloads, event IDs, retry policy, and delivery history

Dead-letter inspection, replay, and signing-secret rotation

Authentication & boundaries

Use the auth your endpoint expects.

Seven authentication modes cover public endpoints, internal services, signed requests, and machine-to-machine OAuth—without putting secrets in a prompt.

None

Public or network-protected endpoint

API key

Custom key header

Bearer token

Authorization bearer header

Basic auth

Username and encrypted password

HMAC-SHA256

Timestamped request signature

OAuth2

Client credentials with token caching

Custom headers

Your required header set

Encrypted, write-only secrets

API keys, bearer tokens, passwords, HMAC secrets, and OAuth client secrets are encrypted at rest and masked on read.

Safer outbound networking

Endpoint validation blocks private-address SSRF paths, redirects stay disabled, and responses are capped at 1 MB.

Managed machine tokens

OAuth2 client-credentials tokens are cached; a 401 invalidates the cached token so a retry can obtain a fresh one.

Signed event delivery

Outbound events carry a signing secret independent of endpoint auth, with controlled secret rotation and overlap.

Production operability

See the failure. Limit the blast radius.

A working demo is not enough. Connector operations expose what was sent, what came back, what failed, and what an operator can safely do next.

Test the real request

The saved connector can make a live HTTP test so you can inspect response status, body, headers, and latency before activation.

Bound failure

Timeouts, per-connector rate limits, exponential backoff with jitter, response-size limits, and circuit breakers constrain bad dependencies.

Watch health

Periodic probes and consecutive-failure counts update connector health. Operational status remains an explicit operator decision.

Investigate outcomes

Use call and delivery records, last-test results, success and failure totals, average latency, and canonical traces to find problems.

Replay deliveries

Failed outbound events land in a dead-letter view and can be replayed after the receiving endpoint is repaired.

Roll back configuration

Restore an earlier endpoint, retry, mapping, scope, or type configuration without erasing history. Secrets and health are intentionally separate.

Runtime wiring

The registry remains the source of truth.

Active connectors are loaded fresh on every engine turn. Tool schemas, stage scope, and approval rules arrive together. State Sync and Event connectors run as automatic hooks, never as tools the model can improvise with.

Registryactive connector + bot scope + lifecycle status
Turn loaderfresh configuration, restrictions, and schemas
Agent runtimecallable tools plus automatic sync and event hooks
Canonical traceconnector outcomes alongside the rest of the turn

Plan capacity

Every plan can connect.

Connector count is enforced server-side when a connector is created. Upgrade for a larger registry; the three connector types share the same pool.

Free

1

connector

Lite

15

connectors

Pro

50

connectors

Team

50

connectors

Enterprise

Unlimited

connectors

Need to compare connector capacity with bots, skills, knowledge sources, channels, and other platform limits?

View full pricing

Clear expectations

What Connectors do—and do not do.

The short answers teams need before they design an integration.

Are these native integrations with specific vendors?

No. Rylvo Connectors are governed custom HTTP connectors. Your API, system of record, or webhook consumer must expose a reachable HTTP endpoint. Rylvo does not provision that API or connect directly to a database socket.

Do Event connectors receive inbound webhooks?

No. Event connectors deliver outbound, signed webhooks from Rylvo to your endpoint. The current live engine hooks cover completed workflow decisions and completed tool executions.

How are tool schemas used?

A Tool connector’s input schema describes the function arguments presented to the model. Request and response field maps can reshape payloads. State Sync reads can separately validate returned state against a configured schema. Rylvo does not claim universal JSON Schema validation of every tool request and response.

What happens when I attach a connector to a bot?

Active linked connectors are loaded fresh for each turn. Tool connectors become callable functions with their scope and approval policy. State Sync and Event connectors remain automatic runtime hooks. When an eligible response-composer prompt exists, Rylvo also maintains a connector usage block as a versioned prompt edit.

Can I test before activating?

Yes. Save or create the connector first, then run its live test from the dashboard before changing it to Active. Testing does not activate a connector automatically.

What does connector rollback include?

Version snapshots cover connector configuration such as endpoints, retry policy, type-specific settings, bot and workflow scope, and tags. Credentials, health, metrics, test results, and lifecycle status are deliberately not restored from a configuration version.

Your endpoint. Governed by Rylvo.

Give your agents access without giving up control.

Define one HTTP connector, test the real exchange, attach it to the right bots, and keep its production behavior visible.