designat.ing — Documentation

Overview

designat.ing provides two API endpoints, both unlocked by a single API key:

raw.designat.ing/v1 — Direct OpenAI-compatible completions. Pure model access, zero orchestration overhead. Use this when you need raw inference speed.
api.designat.ing/v1 — Intelligent inference with a full agentic runtime. Every request runs inside a containerised environment with persistent memory, tool calling, workflow orchestration, knowledge retrieval, guardrails, and multi-step reasoning. All included free with every plan.

Both endpoints share the same authentication, the same model catalog (22,298+ open-source models), and the same billing account. Switch between them by changing only the base URL.

Quick Start

Raw inference

# Set your API key
export OPENROUTING_API_KEY="sk-or-..."

# List available models
curl https://raw.designat.ing/v1/models \
  -H "Authorization: Bearer $OPENROUTING_API_KEY"

# Chat completion
curl https://raw.designat.ing/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Pro",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Intelligent inference

# Create an agent
curl -X POST https://api.designat.ing/v1/agents \
  -H "Authorization: Bearer $OPENROUTING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Assistant",
    "model": "Qwen/Qwen3-235B-A22B",
    "system_prompt": "You are a helpful assistant."
  }'

# Chat with the agent (autonomous tool-calling loop)
curl -X POST https://api.designat.ing/v1/agents/{agent_id}/chat \
  -H "Authorization: Bearer $OPENROUTING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "What is the weather in London?"
  }'

Python SDK

# Raw inference — drop-in OpenAI replacement
from openai import OpenAI

client = OpenAI(
    base_url="https://raw.designat.ing/v1",
    api_key="sk-or-..."
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Pro",
    messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)

Authentication

All requests require an Authorization: Bearer sk-or-... header. API keys are created in the dashboard at designat.ing/login. Keys work across both endpoints — raw and intelligent.

Authorization: Bearer sk-or-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Error Codes

Code	HTTP	Description
missing_key	401	Authorization header not provided
invalid_key	401	API key not found or revoked
rate_limit	429	Concurrency limit exceeded for your tier
model_not_found	404	Requested model ID does not exist
insufficient_quota	403	Token allowance exhausted for billing period
internal_error	500	Server error — retry after a few seconds

Raw Inference API — raw.designat.ing

The raw API provides direct, high-speed model access with zero orchestration. It is fully OpenAI-compatible — drop-in replacement for the OpenAI SDK by changing only the base URL. Every request goes straight to the model and back. No containers, no memory, no tool loops. Maximum speed, minimum latency.

POST /v1/chat/completions

Create a chat completion. Supports streaming, tool calling, JSON mode, structured output, and all standard OpenAI parameters.

POSThttps://raw.designat.ing/v1/chat/completions

OpenAI-compatible chat completions endpoint

Request Body

Parameter	Type	Required	Description
model	string	Yes	Model ID (e.g. `deepseek-ai/DeepSeek-V4-Pro`)
messages	array	Yes	Array of message objects with role and content
max_tokens	integer	No	Maximum tokens to generate
temperature	number	No	Sampling temperature (0-2). Default: 1
top_p	number	No	Nucleus sampling threshold. Default: 1
stream	boolean	No	Stream tokens via SSE. Default: false
tools	array	No	Function/tool definitions for tool calling
tool_choice	string/object	No	`auto`, `none`, `required`, or specific tool
response_format	object	No	`{"type":"json_object"}` or JSON schema for structured output
seed	integer	No	Deterministic sampling seed
logprobs	boolean	No	Return log probabilities. Default: false

Example

curl https://raw.designat.ing/v1/chat/completions \
  -H "Authorization: Bearer sk-or-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-235B-A22B",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain quantum entanglement in 50 words"}
    ],
    "max_tokens": 200,
    "temperature": 0.7,
    "stream": false
  }'

GET /v1/models

List all available models. Returns model ID, context length, features, and model class.

GEThttps://raw.designat.ing/v1/models

List all 22,298+ models available on the platform

curl https://raw.designat.ing/v1/models \
  -H "Authorization: Bearer sk-or-..."

# Response (truncated)
{
  "data": [
    {
      "id": "deepseek-ai/DeepSeek-V4-Pro",
      "context_length": 262144,
      "model_class": "deepseek4-1.6t",
      "concurrency_cost": 4,
      "features": {"tool_use": true},
      "owned_by": "Feather",
      "available_on_current_plan": true
    }
  ]
}

POST /v1/embeddings

POSThttps://raw.designat.ing/v1/embeddings

Generate embeddings for text input

curl https://raw.designat.ing/v1/embeddings \
  -H "Authorization: Bearer sk-or-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-Embedding-8B",
    "input": "Hello world"
  }'

Model Parameters

Each model object in /v1/models includes:

id — Model identifier used in API calls
context_length — Maximum context window in tokens
concurrency_cost — Number of concurrency slots consumed (larger models cost more)
features.tool_use — Whether the model supports parallel tool calling
model_class — Architecture family (e.g. deepseek4-1.6t, qwen3-235b, glm51-754b)
available_on_current_plan — Whether your tier can access this model

Intelligent Inference API — api.designat.ing

The intelligent API wraps every request in a full agentic runtime. When you send a message, the platform does not just generate text — it enters an autonomous loop: the model plans, calls tools, reads results, reasons about what it found, and iterates until the task is complete. All of this happens inside a containerised environment with persistent memory, knowledge retrieval, guardrails, and observability.

Every intelligent endpoint is included free with your plan. There are no additional charges for agents, memory, knowledge bases, or workflows — they all consume tokens from your plan allowance.

Agents

An agent is a persistent entity with its own system prompt, model, tools, knowledge bases, and memory. Create it once, then chat with it repeatedly across sessions. The agent remembers previous conversations via warm memory.

POST/v1/agents

Create a new agent

curl -X POST https://api.designat.ing/v1/agents \
  -H "Authorization: Bearer sk-or-..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Research Assistant",
    "model": "Qwen/Qwen3-235B-A22B",
    "system_prompt": "You are a research assistant. Use tools to find information. Always cite sources.",
    "knowledge_base_ids": ["kb_abc123"],
    "mcp_server_ids": ["mcp_def456"],
    "guardrail_ids": ["gr_no_pii"]
  }'

# Response
{
  "id": "agent_x9f2k",
  "name": "Research Assistant",
  "model": "Qwen/Qwen3-235B-A22B",
  "created_at": "2026-06-16T06:00:00Z"
}

GET/v1/agents

List all agents

GET/v1/agents/{agent_id}

Get agent details

DELETE/v1/agents/{agent_id}

Delete an agent

Agent Chat

Send a message to an agent. The agent enters an autonomous loop — calling tools, reading outputs, reasoning — until the task is complete. Each chat request may trigger multiple model calls internally. The response includes the final answer plus a trace of all tool calls made.

POST/v1/agents/{agent_id}/chat

Send a message to an agent (autonomous multi-step execution)

curl -X POST https://api.designat.ing/v1/agents/agent_x9f2k/chat \
  -H "Authorization: Bearer sk-or-..." \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Find the latest revenue figures for Tesla and compare with analyst estimates",
    "stream": false
  }'

# Response
{
  "agent_id": "agent_x9f2k",
  "response": "Based on the search results, Tesla Q1 2026 revenue was...",
  "tool_calls": [
    {"tool": "web_search", "input": {"query": "Tesla Q1 2026 revenue"}, "output": "..."},
    {"tool": "web_search", "input": {"query": "Tesla Q1 2026 analyst estimates"}, "output": "..."}
  ],
  "tokens_used": 3847,
  "steps": 3
}

Supports streaming via "stream": true which returns SSE events for each tool call and reasoning step.

Memory

Three-tier memory system that persists across sessions. The agent automatically manages what goes where — no manual curation required.

Hot memory — The active conversation window. Everything the agent is currently working on stays in context.
Warm memory — Auto-extracted facts, entities, and relationships persisted across sessions. The agent remembers your preferences, past decisions, and project context without re-explanation.
Cold memory — Archived knowledge retrieved on demand via semantic search from vector stores.

GET/v1/agents/{agent_id}/memory

List all memories for an agent

POST/v1/agents/{agent_id}/memory

Add a memory manually

POST/v1/agents/{agent_id}/memory/query

Semantic search across agent memories

GET/v1/agents/{agent_id}/memory/stats

Memory usage statistics per tier

DELETE/v1/agents/{agent_id}/memory/{memory_id}

Delete a specific memory

Knowledge Bases

Upload documents (PDF, markdown, code, databases, URLs) and the platform auto-chunks, embeds, and indexes everything. At inference time, agents retrieve semantically relevant context and inject it into their prompt. Hybrid search combines dense vector similarity with keyword matching. Unlimited knowledge bases per account.

POST/v1/knowledge-bases

Create a knowledge base

GET/v1/knowledge-bases

List all knowledge bases

POST/v1/knowledge-bases/{kb_id}/documents

Upload documents to a knowledge base

POST/v1/knowledge-bases/{kb_id}/query

Semantic search within a knowledge base

DELETE/v1/knowledge-bases/{kb_id}

Delete a knowledge base

Knowledge Graph

As conversations happen, the platform automatically extracts entities and relationships — people, organisations, concepts, events — and constructs a knowledge graph. Agents query this graph to find connected information that pure vector search would miss. The graph grows and refines itself over time.

POST/v5/kg/entities

List or search entities in the knowledge graph

POST/v5/kg/relations

List or search relations between entities

POST/v5/kg/search

Combined entity + relation search

POST/v5/kg/auto-build

Trigger automatic graph construction from agent conversations

GET/v5/kg/stats

Graph statistics (entity count, relation count, etc.)

MCP Servers

Connect to external tools and data sources via the Model Context Protocol. 9,973 pre-built MCP servers are available — file systems, SQL databases, REST APIs, browsers, code execution sandboxes, cloud services, and more. Your agent calls them as tools during execution.

GET/v1/mcp-servers

List available MCP servers

POST/v1/mcp-servers

GET/v1/mcp-servers/{mcp_id}

Get MCP server details and available tools

DELETE/v1/mcp-servers/{mcp_id}

Remove an MCP server

Workflows

Define DAG (directed acyclic graph) pipelines that chain agents together. Each node is an agent with its own tools, memory, and knowledge. Workflows support branching on conditions, parallel execution, and error recovery with retry and fallback. Trigger on schedule (cron) or on events (webhook, message queue).

POST/v1/workflows

Create a workflow

GET/v1/workflows

List all workflows

GET/v1/workflows/{workflow_id}

Get workflow definition

POST/v1/workflows/{workflow_id}/run

Execute a workflow

GET/v1/workflows/{workflow_id}/runs

List workflow execution history

curl -X POST https://api.designat.ing/v1/workflows \
  -H "Authorization: Bearer sk-or-..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Research Pipeline",
    "nodes": [
      {"id": "research", "agent_id": "agent_research"},
      {"id": "validate", "agent_id": "agent_validator"},
      {"id": "write", "agent_id": "agent_writer"}
    ],
    "edges": [
      {"from": "research", "to": "validate"},
      {"from": "validate", "to": "write", "condition": "passed"},
      {"from": "validate", "to": "research", "condition": "failed"}
    ],
    "schedule": "0 9 * * 1"
  }'

Skills

Installable prompt-and-tool templates that give agents new capabilities instantly. A skill packages a system prompt, tool definitions, MCP connections, and example interactions into one unit. Browse 6,000+ community skills or build your own.

GET/v1/skills

List available skills

GET/v1/skills/{skill_id}

Get skill details

Guardrails

Seven layers of safety and compliance applied at inference time inside the runtime:

Input filtering — Block prompt injections, jailbreaks, and malicious instructions
Output validation — Scan completions for policy violations
PII redaction — Detect and mask personal data
Topic restriction — Confine agents to approved subject areas
Toxicity detection — Filter harmful content
Instruction-injection defence — Prevent tool outputs from hijacking agent behaviour
Custom rules — Define your own allow/deny patterns per agent

POST/v5/guardrails/check

Run guardrail checks on text

GET/v5/guardrails/rules

List all guardrail rules

POST/v5/guardrails/rules

Create a custom guardrail rule

GET/v5/guardrails/logs

View guardrail audit logs

Multi-Agent

Swarm orchestration with supervisor pattern. A coordinator agent receives the request, breaks it into subtasks, and delegates to specialist agents. Each specialist has its own system prompt, tools, memory, and knowledge. Results merge back into a single coherent response.

POST/v5/agents/spawn

Spawn a sub-agent from a parent agent

GET/v5/agents/spawns

List active sub-agents

GET/v5/agents/spawns/{spawn_id}

Get sub-agent status and results

Scheduler

Cron and event-driven triggers. Schedule an agent to run on a recurring basis, or trigger a workflow when a webhook fires. No external cron service needed.

POST/v5/schedule

Create a scheduled task (cron or event-driven)

GET/v5/schedule

List all scheduled tasks

DELETE/v5/schedule/{name}

Cancel a scheduled task

Observability

Full execution traces for every request. Eight integrated tools:

Distributed traces — Follow a request across agents, tools, and MCP servers
Metrics — Latency, token usage, tool call counts
Logs — Structured logging for every runtime event
Error tracking — Automatic capture, grouping, and alerting
Latency profiling — Identify bottlenecks in agent loops
Token accounting — Per-agent, per-tool, per-request breakdown
Cost attribution — Map token spend back to agents and workflows
Audit logs — Immutable record of every action for compliance

GET/v5/observability/metrics

System and request metrics

GET/v5/observability/errors

Error tracking and grouping

GET/v5/observability/usage

Token usage and cost attribution

GET/v5/observability/snapshot

Current system state snapshot

Rate Limits

Rate limits are based on concurrency slots, not requests per minute. Each model has a concurrency_cost — larger models consume more slots. Your tier determines how many concurrent requests you can run.

Tier	Concurrent Slots	Tokens/mo
Basic	4	20B
Plus	4	50B
Pro	6	100B
Pro+	10	250B
Ultra	20	500B
Enterprise	25	1T

Tools API

Create, manage, and invoke custom tools that agents can call during conversations.

POST/v1/tools

Create a custom tool

GET/v1/tools

List all tools

GET/v1/tools/{tool_id}

Get tool details

DELETE/v1/tools/{tool_id}

Delete a tool

POST/v5/tools/generate

Auto-generate a tool from description

POST/v5/tools/generate-from-url

Generate tool from API docs URL

GET/v5/tools/generated

List generated tools

POST/v5/tools/prefilter

Pre-filter tools for relevance

Pipelines API

Multi-step processing pipelines for chained operations.

POST/v5/pipelines

Create a pipeline

GET/v5/pipelines

List pipelines

GET/v5/pipelines/{name}

Get pipeline details

POST/v5/pipelines/{name}/run

Execute a pipeline

GET/v5/pipelines/{name}/runs

List execution history

Templates API

Prompt templates with variables, A/B variants, and analytics.

POST/v5/templates

Create a template

GET/v5/templates

List templates

GET/v5/templates/{name}

Get template

POST/v5/templates/{name}/render

Render with variables

POST/v5/templates/{name}/variant

Create A/B variant

GET/v5/templates/analytics

Template analytics

Plugins API

Discover, install, and invoke plugins from the marketplace.

GET/v5/plugins/search

Search marketplace

GET/v5/plugins/list

List installed plugins

GET/v5/plugins/categories

List categories

POST/v5/plugins/register

POST/v5/plugins/ingest

Ingest from URL

POST/v5/plugins/invoke/{plugin_id}

Invoke a plugin

GET/v5/plugins/find-for-task

Find plugins for a task

MCP Catalog API

Browse and install MCP servers.

GET/v5/mcp/search

Search MCP catalog

GET/v5/mcp/categories

List categories

GET/v5/mcp/stats

Catalog stats

POST/v5/mcp/register

POST/v5/mcp/ingest

Ingest from URL

Hubs API

Search community hubs for skills, tools, knowledge, and workflows.

GET/v5/hubs/skills/search

Search skills hub

GET/v5/hubs/skills/top

Top-rated skills

GET/v5/hubs/tools/search

Search tools hub

GET/v5/hubs/tools/categories

Tool categories

GET/v5/hubs/knowledge/search

Search knowledge hub

GET/v5/hubs/knowledge/papers

Search papers

GET/v5/hubs/knowledge/books

Search books

GET/v5/hubs/workflows/search

Search workflows hub

GET/v5/hubs/workflows/live

Live community workflows

Memory API (Fine-Grained)

Fine-grained memory: recall, search, consolidation, archival, temporal.

GET/v5/memory/stats/{agent_id}

Memory statistics

GET/v5/memory/recall/{agent_id}

Recall all memories

GET/v5/memory/recall/{agent_id}/recent

Recent memories

POST/v5/memory/recall/{agent_id}/search

Semantic search memories

GET/v5/memory/core/{agent_id}

Core memories

GET/v5/memory/context/{agent_id}

Working context

GET/v5/memory/archival/{agent_id}

Archival memories

POST/v5/memory/archival/{agent_id}/search

Search archival

POST/v5/memory/promote

Promote archival to core

POST/v5/memory/consolidate/{agent_id}

Consolidate memories

POST/v5/memory/temporal-search

Search by time range

Facts & Extraction API

Extract structured facts from text.

POST/v5/facts/extract

Extract facts from text

POST/v5/facts/extract-turn

Extract from conversation turn

POST/v5/facts/extract-and-store

Extract and store in memory

POST/v5/facts/batch-extract

Batch extract

Intent Classification API

Classify user intent for routing.

POST/v5/intent/classify

Classify message intent

Summarization API

Summarize conversations and agent memory.

POST/v5/summarize/messages

Summarize messages

POST/v5/summarize/agent/{agent_id}

Summarize agent history

Tree of Thought API

Multi-step reasoning with decomposition.

POST/v5/tot/quick

Quick ToT reasoning

POST/v5/tot/reason

Full ToT with branches

Tool Generation API

Auto-generate tools from descriptions or API docs.

POST/v5/tools/generate

Generate from description

POST/v5/tools/generate-from-url

Generate from URL

GET/v5/tools/generated

List generated tools

GET/v5/tools/generated/{name}

Get generated tool

Crypto Payments API

Accept crypto payments via CoinPayments.

POST/v5/crypto/create-invoice

Create crypto invoice

GET/v5/crypto/invoice/{invoice_id}

Check invoice status

POST/v5/crypto/webhook

CoinPayments IPN webhook

Events API

Event sourcing for audit and replay.

GET/v5/events

Query event stream

GET/v5/events/stats

Event statistics

GET/v5/events/health

Event store health

POST/v5/events/replay/{entity_type}/{entity_id}

Replay events for entity

Rate Limits API

Configure per-key rate limits.

GET/v5/rate-limits/tiers

Rate limits per tier

POST/v5/rate-limits/configure

Configure custom limits

GET/v5/rate-limits/config/{api_key}

Get key config

POST/v5/rate-limits/check

Check if rate limited

POST/v5/rate-limits/increment

Increment counter

Billing API

GET/v1/usage

Get token usage for current billing period

GET/v1/subscription/me

Get current subscription details

POST/v1/billing/checkout

Create a checkout session for plan upgrade