Ship AI Products. Not AI Infrastructure.

Composable skills, configurable agents, sandboxed workspaces, and an MCP-native architecture you can build on. Define your AI capabilities in JSON, expose them via API and MCP, and let the platform handle the rest.

Read the Docs Start Building 
$ curl -X POST https://api.revelry.ai/v2/skills/extract-invoice-data/run \
  -H "Authorization: Bearer $REVELRY_API_KEY" \
  -d '{"inputs": {"document_content": "..."}}'

Four Primitives. Infinite Composition.

Skill Agent Workflow Kit

Skills

Atomic AI capabilities. A skill is a prompt — optionally paired with a model config, tools, and data sources. Compose sub-skills. Two invocation modes: deterministic (runs in order, pre-LLM) or dynamic (LLM decides when to call). Every skill is also an MCP tool.

Agents

A configured chat session — persona, memory, skills, tools, and data sources. Or no configuration at all: the default agent gives you everything in scope. Create agents through the chat interface in plain English or define them in JSON.

Workflows

Multi-step pipelines. Define a DAG of agents with explicit input/output mapping between nodes. Deterministic orchestration for processes that need to run the same way every time.

Kits

Ship it. Install a kit and get an entire AI capability stack — agents, skills, workflows, data collections, and tools. Versioned, installable, shareable. Think npm packages for AI agents.

Everything Is JSON. Everything Is Composable.

skill.json

{
  "schema_version": "1.0",
  "type": "skill",
  "slug": "extract-invoice-data",
  "name": "Extract Invoice Data",
  "description": "Extracts line items, totals, and vendor info",
  "instructions": {
    "system": "You are a document extraction specialist...",
    "variables": [
      {
        "id": "uuid",
        "name": "document_content",
        "type": "document"
      }
    ]
  },
  "model": {
    "provider": "openai",
    "model_id": "gpt-4o",
    "temperature": 0.2,
    "max_tokens": 4096
  },
  "tools": [
    { "name": "web_search", "ref": "builtin://web_search" }
  ],
  "data_sources": [
    { "type": "collection", "ref": "kit://collections/vendor-database" }
  ],
  "output": {
    "artifact_type": "kit://types/invoice-extract",
    "format": "structured"
  }
}

agent.json

{
  "schema_version": "1.0",
  "type": "agent",
  "slug": "contract-reviewer",
  "name": "Contract Review Agent",
  "description": "Reviews contracts for risk and compliance",
  "persona": {
    "system": "You are an experienced contract analyst..."
  },
  "memory": { "enabled": true },
  "model": {
    "provider": "anthropic",
    "model_id": "claude-sonnet-4-6",
    "temperature": 1.0,
    "max_tokens": 16000
  },
  "skills": [
    {
      "ref": "kit://skills/extract-key-terms.json",
      "invocation": "deterministic"
    },
    {
      "ref": "kit://skills/flag-risk-clauses.json",
      "invocation": "dynamic"
    }
  ],
  "tools": [
    { "name": "web_search", "ref": "builtin://web_search" }
  ],
  "data_sources": [
    { "type": "collection", "ref": "kit://collections/legal-templates" }
  ],
  "workspace": { "enabled": false }
}

Four JSON specs. Each one useful standalone. Each one composable with the others. All of it versionable and installable as a kit.

What You'd Build With This

The primitives are flexible. Here's what developers are using them for.

Document Processing Pipelines

Combine extraction, classification, and validation skills into an agent. Feed it contracts, invoices, or applications — get structured data back via API.

3 skills + 1 agent → API endpoint

Coding Agents That Ship PRs

Point a workspace agent at a GitHub repo. It reads issues, writes code, runs tests, and opens pull requests. You review and merge.

coding workspace → git tools → PR

Knowledge-Grounded Support Agents

Connect your docs and FAQs as collections. Deploy an agent via MCP that your product can call directly. Responses grounded in your actual content, not hallucinations.

collections + agent → MCP server

Multi-Step Analysis Workflows

Chain domain-specific agents: intake → analysis → report generation. Each agent uses the right model for its task. Input from one feeds the next.

workflow DAG → 3 agents → artifact output

MCP-Native. Both Directions.

As a Server

Your agents and skills are MCP tools. Any MCP-compatible client — Claude, Cursor, your own apps — can call them directly.

list_skills

get_skill

run_skill

create_skill

update_skill

As a Client

Your agents consume external MCP servers. Connect GitHub, databases, internal tools — anything with an MCP interface. Your agents use them as tool calls.

MCP-native

Your AI infrastructure becomes a platform, not a product. Build features in Revelry, expose them everywhere.

Agents That Ship Code

Isolated sandbox environments. Four profiles. Your agent controls the sandbox via MCP tool calls — all reasoning stays in your agent's loop.

Profile What It Does
coding git clone → implement → commit → push → create PR
document Upload docs → transform → output files
data_analysis Run Python, analyze data, generate charts with pandas, matplotlib, and more
general General-purpose sandbox — build, test, run in any language

Built for AI Workloads

  • Sandboxes spin up in milliseconds — run thousands concurrently
  • Stateful Python kernel — variables, DataFrames, and imports persist across tool calls
  • Long-running processes up to 24 hours per session
  • Custom environments — install packages, upload data, configure runtimes
  • Fully isolated — agents interact freely without risking your host systems

Your Agent Controls Everything

All reasoning stays in your agent's tool loop. The sandbox executes commands — your agent decides what to run:

shell_exec file_read file_write git_status git_commit git_push code_execute

REST API. Predictable. Well-Documented.

request

POST /api/v2/skills/extract-invoice-data/run
Authorization: Bearer $REVELRY_API_KEY
Content-Type: application/json

{
  "inputs": {
    "document_content": "Invoice #4821..."
  }
}

response

{
  "status": "completed",
  "skill": "extract-invoice-data",
  "model": "gpt-4o",
  "credits_used": 3,
  "output": {
    "vendor": "Acme Supply Co",
    "total": 12450.00,
    "line_items": [...]
  }
}
POST  /api/v2/skills/:id/run       # Run a skill
GET   /api/v2/skills               # List available skills
GET   /api/v2/agents               # List agents
POST  /api/v2/workflows/:id/run    # Trigger a workflow run
Full API reference →

Built-In Retrieval. Multiple Sources. Zero Plumbing.

Connect data sources, create collections, reference them from any skill or agent. Chunking, embedding, vector storage, and retrieval are handled by the platform — you just point to the collection in your spec.

PDF / DOCX / XLSX Google Drive SharePoint Web Scraping Vector DBs Custom Collections

Use the Right Model for the Job

Claude, GPT-4, Gemini, Mistral, Groq — switch per skill, per agent, per task. No vendor lock-in. Bring your own keys.

analysis skill

"provider": "anthropic"
"model_id": "claude-opus-4-6"

content skill

"provider": "openai"
"model_id": "gpt-4o"

triage skill

"provider": "groq"
"model_id": "llama-3.3-70b"

Join the Developer Beta

We're opening the platform to developers who want to build AI-native applications. Early access, direct line to the engineering team, and input on the API and SDK roadmap.

$ curl -X POST https://api.revelry.ai/v2/skills/get-beta-access/run \
  -H "Content-Type: application/json" \
  -d '{"inputs": {"role": "developer", "intent": "build"}}'

{
  "status": "accepted",
  "next_step": "Email dev@revelry.ai",
  "message": "Tell us what you want to build. We'll get you in."
}

dev@revelry.ai

FAQ

You can — and we use them under the hood. But a raw LLM call is a prompt and a response. To build a real product you still need: retrieval over your data, tool orchestration, execution sandboxes, multi-step workflows, persistence, auth, audit trails, and a way to swap models without rewriting your app. That's what Revelry is. You write the skill spec, we run the infrastructure. You stay model-agnostic and ship faster.

JSON specs, the REST API, or just describe what you need in the chat interface. The platform builds the skill for you.

Yes. Skills invoke sub-skills. Agents spawn sub-agent chats. Maximum depth: 5. All orchestrated via Elixir's OTP supervision tree.

REST API today. SDKs coming. MCP is the integration protocol — any MCP client works out of the box.

Managed VPC deployments are available today on the Transform plan. We're actively exploring an open-core license for self-hosted deployments — if that's interesting to you, we want to talk. Reach out.

Elixir, running on the Phoenix framework. We chose it for its concurrency model, fault tolerance, and ability to handle long-running AI workloads without the overhead of thread-per-request architectures. It's why sandboxes spin up fast and thousands of agents can run concurrently without the platform sweating.

Beta developers get a direct line to our engineering team. Email dev@revelry.ai — you'll hear back from someone who writes code, not someone who reads a script.

Stop Building Infrastructure. Start Building Features.

The platform, the models, the execution environment — it's all here. Tell us what you want to build.

dev@revelry.ai Read the Docs