Stray — Tool Gateway for AI Agents | Apeiron

Stray — the tool catalog for your AI agents, deployed by Apeiron

"An AI agent can reason. But to do real work it needs tools: SEO, contact enrichment, social media, scraping, advertising… and each one wants its own account, key and subscription."

At a glance

• Category: tool gateway for AI agents — "OpenRouter, but for tools instead of models"
• Principle: one URL, one token; the agent calls a catalog of 3,000+ endpoints and your own APIs without ever holding a key
• Billing: per call, from a cent, on a prepaid balance; your own keys are never metered
• Deployment: self-hosted (Python server, PostgreSQL), inside your infrastructure
• Base: the open-source Stray project (Apache 2.0 with additional terms), deployed, integrated and customised by Apeiron

Why Stray

The tools an agent needs for real work sit behind subscriptions nobody buys for a single use, behind sign-up forms, or behind no public API at all. The result: keys everywhere — in .env files, Slack messages, developers' laptops — and agents that stall at the first authentication step.

Stray flips the problem. The agent builds the real request to the upstream API and sends it through the proxy, and Stray:

• finds the tool and checks the caller is allowed to use it;
• injects the key server-side — the agent never sees it;
• relays the answer verbatim, without modelling the upstream API;
• bills or logs the call, exactly once.

For a team this means one place where keys, budgets and call history live, and agents (Claude Code, Codex, Cursor, Claude.ai) that connect with a single sentence.

The catalog: tools grouped by job, with their starting price per call. Tools marked "free with your account" use your own key.

Ask for the task, not the tool

You don't need to know which vendor sells backlink data, or to have an account with them. The agent searches for what it wants to do, reads the price, calls.

stray catalog search "backlinks for a domain"     # search by the job
stray catalog get hunter.people.email.find        # parameters, price, example response
stray call hunter.people.email.find --query domain=reddit.com --query full_name="Alexis Ohanian"
stray balance                                     # what the call cost

When several providers cover the same capability, Stray shows them side by side with prices: the choice is yours. For some capabilities, routed endpoints (stray.<capability>) let Stray pick the provider — always naming the one that answered and returning its raw response.

A routed endpoint: Stray picks the best provider and tries the next if the first fails. Your own keys always go first.

A tool's page: price, a command to copy for the agent, parameters and an example response.

How it works

Every call follows the same path, and the path is deliberately short.

Agents and teams on the left, upstream providers on the right: in the middle, a server that resolves, authorises, reserves, relays and settles.

1. Resolve the tool — by host and URL prefix, or by name.
2. Authorise — member role, daily caps, deny rules.
3. Reserve a hold — the call's maximum price is set aside from the balance.
4. Relay and inject the key — the request goes to the provider, byte for byte.
5. Settle or release — the real cost is charged, or the hold is returned if the call fails.

Two architecture rules make it dependable: a call holds no database connection while it waits for the provider, and the hold is settled or released exactly once, including on timeout, cancellation and exceptions.

A faithful relay, not yet another API

Stray changes only three things: transport headers, its own control headers (token, organisation), and the injected key. Everything else passes through untouched. That is what lets it survive providers changing their APIs: we don't model the API, we relay it.

Who supplies the key?

This is the heart of both the economics and the governance. For each call, Stray tries four rungs in order:

Your own key always wins, is never metered and is never routed elsewhere.

An endpoint Stray has no published price for is refused, never served free: you are asked to connect your own key.

Billing you can audit

Money is handled like an accounting system: integer micro-dollars, never floats, and only five entries — grant, topup, reserve, settle, release.

A call reserves a hold; a billable 2xx settles it, a failure releases it. There is no refund entry: a correction is a grant.

• 4xx and 5xx responses are not billed; a 200 is, even when the verdict is negative.
• New verified accounts get $1 of free credit, once, when they create an eligible team.
• Manual or automatic top-ups through Stripe, and a read-only reconciliation to check the ledger.
• Caps (per member, per day, per call) protect the budget when an agent runs away.

Your tools, your keys — in the same catalog

The catalog covers what you don't have. For what you already have, Stray hosts your own tools: every agent on the team can call them, the key never leaves the server, and they are never billed.

The catalog (Stray's keys, billed per call) and your tools (your keys, never billed).

Three kinds of personal tools:

• Endpoints: an upstream URL and secret bindings — an API key, an OAuth token, several headers if needed.
• CLIs: stripe, gh, vercel… run with the credential injected, locally or on the server.
• Skills: a SKILL.md recipe with its secrets and tools, registered once for the whole team.

The stray upload command scans a project (.env file, skill folders, installed CLIs) and proposes what can be shared, encrypted server-side. A hub tool even lets you publish a tool made of other tools, with its own price.

Connections: add your own key for a provider and its calls stop being billed.

Teams, roles and access

Everything is scoped to an organisation: secrets, tools, skills, balances and logs. Roles are owner, admin, member and viewer, with per-tool access and per-member caps.

The Team page: roles, daily call cap, tool access, API keys and policies.

• Agents as identities: an agent is a machine identity with its own token, limited to specific tools or projects.
• Pinned agents: for an end customer, an agent can be pinned to a customer id — history, archived answers and async ownership stay scoped to that customer.
• Re-billing: an X-Stray-Meta header and usage-by-tag reporting let you pass cost through per customer or project.
• Credential health: optional probes validate keys, refresh OAuth tokens and alert the owner of anything that breaks.

Connect any agent in one sentence

Onboarding is designed for agents themselves: give them one sentence and they read llms.txt, install the CLI, sign in and register the skills.

Getting started: the sentence to paste in the agent's chat, with the team's API key already included.

The agent picker tailors the instructions: Claude Code, Codex, Claude.ai, Cursor, Grok Bot, Hermes Agent or another client.

For Claude Code, Stray also installs as a plugin with no configuration:

/plugin marketplace add apeiron-tech/stray
/plugin install stray@stray

Ready-made skills run on the catalog: finding public buying signals (lead-signals), generating UGC videos (make-ugc), or a memory for Claude Code (jev-memory). On the MCP side, Stray exposes its tools to compatible clients, including a Claude.ai connector.

Business use cases

• Prospecting and enrichment: find a contact, verify an address, enrich a company from a domain — by an agent, with no extra CRM subscription.
• SEO and AI visibility: rankings, keywords, backlinks, and tracking of brand mentions in AI answer engines.
• Social media monitoring: trends, profiles, posts, for an augmented community manager.
• Internal agent platform: one token per agent, budgets per team, an audit log of every call.
• Agents for your customers: customer-pinned agents with usage re-billing.
• Agent MVPs and POCs: validate a use case in weeks without negotiating ten vendor contracts — see our MVP and POC development.

Deployment

Stray is built to be self-hosted: one server, one worker, one database.

Inside your infrastructure: the API, the worker, PostgreSQL, a key-value store and object storage. On the right, what Apeiron takes care of.

• Server: a Python (FastAPI) application with dashboard, API and MCP surface; stray-worker for asynchronous tasks.
• Data: PostgreSQL in production (SQLite in development), a Redis-protocol key-value store, object storage for the answer archive.
• Secrets: encrypted at rest with a Fernet key — back it up with the database, because without it the secrets are unrecoverable.
• Sign-in: email code, GitHub or Google OAuth, depending on configuration.
• Optional: Stripe for top-ups, a transactional email service.

Everything is configured through STRAY_* environment variables, and every setting has a default that works locally.

Security and governance

• No secret in the agent: credentials stay server-side, encrypted; the caller's token is stripped before reaching the provider.
• Your key always wins: never metered, never routed or overflowed to another account.
• Audit log of every call and CLI run, with managed evidence retention.
• SSRF protection on the upstream relay, and architecture layers enforced by import tests.
• A documented security policy: threat model, known limitations and reporting procedure.

Licence and attribution

Stray is an open-source project published by Superdesign under the Apache 2.0 licence with additional terms. Use is free, including commercial use and inside your own organisation — self-hosting your own registry is encouraged. The restriction: don't redistribute the code to third parties as a competing hosted service without written permission. Apeiron provides integration, customisation, deployment and support; the code is on the apeiron-tech/stray repository.

Why choose Stray with Apeiron

• Your keys stay with you: one vault, one log, caps — instead of ten .env files.
• No vendor lock-in: open-source base, faithful relay, open standards (CLI, MCP).
• A team that delivers: Apeiron designs and runs agentic AI, ERP and custom software for clients in France and Tunisia.
• One point of contact: from scoping to operations, with support in French, Arabic and English.

Frequently asked questions

What is Stray?

Stray is a tool gateway for AI agents: "OpenRouter, but for tools". With one URL and one token, an agent calls a catalog of external endpoints (SEO, enrichment, social, advertising, scraping, generated media) and your team's own tools, without ever holding an API key.

Do my agents see my API keys?

No. Stray injects the credential server-side at call time and strips the caller's token before the request reaches the provider. Secrets are encrypted at rest.

How does Stray bill calls?

Catalog calls that use Stray's key are billed per call, from a cent, against a prepaid balance. A call first reserves a maximum amount, then settles the real cost or releases the reservation if it fails. Calls that use your own keys are never billed.

Is Stray open source? Can I host it myself?

Yes. Stray is published under the Apache 2.0 licence with additional terms: free use, including commercial and internal, and self-hosting is encouraged. Only redistribution to third parties as a competing hosted service needs written permission.

Which agents work with Stray?

Claude Code (plugin and skill), Codex, Cursor, Claude.ai (MCP connector), Grok Bot, Hermes Agent, or any agent that can run the stray CLI or call an HTTP API with a token. A single message — "set up stray" followed by your instance URL — is enough to install it.

Can I use my own subscriptions and APIs with Stray?

Yes. You register your endpoints, CLIs or skills, and your keys stay encrypted server-side. Your key always takes priority over Stray's and its calls are never billed. The stray upload command finds what can be shared in a project.

How do I isolate several customers' data?

Everything is scoped by organisation, with four roles and per-tool access. For an end customer, an agent can be pinned to a customer id: history, archived answers and async resources stay limited to that customer, and usage can be re-billed by tag.

How much does a Stray deployment cost?

The software has no per-user licence. The budget depends on infrastructure, the number of teams and agents, and the integration you want; billed catalog calls depend on your usage. We quote after a scoping workshop.

Can Apeiron run a Stray POC?

Yes. We offer a POC on one precise use case — for example a prospecting or SEO-monitoring agent — to measure the gain before rolling out. See our MVP and POC development.

See also

• Cortex One — Self-hosted enterprise AI
• AI agency in Tunisia: agents, RAG and automation
• MVP and POC development
• Our work

Give your agents the right tools

Want agents that can work without multiplying subscriptions and keys? Let's talk about your use cases, your teams and your infrastructure.

• Contact Apeiron: contact@apeiron-tech.com
• Tell us about your project