# Create Chat Completion
Source: https://docs.subconscious.dev/api-reference/chat-completions
api-reference/openapi.json POST /chat/completions
Generates a model response for the given conversation. This endpoint is fully compatible with the OpenAI Chat Completions API.
# Create inference key
Source: https://docs.subconscious.dev/api-reference/create-inference-key
api-reference/platform.json POST /api/v1/management/api-keys
Mint an inference key with a management key
# Delete inference key
Source: https://docs.subconscious.dev/api-reference/delete-inference-key
api-reference/platform.json DELETE /api/v1/management/api-keys/{keyPrefix}
Revoke an inference key by its prefix
# List inference keys
Source: https://docs.subconscious.dev/api-reference/list-inference-keys
api-reference/platform.json GET /api/v1/management/api-keys
List inference keys for the management key's organization
# Create Message
Source: https://docs.subconscious.dev/api-reference/messages
api-reference/openapi.json POST /messages
Generates a model response for the given conversation. This endpoint is fully compatible with the Anthropic Messages API, so you can use the Anthropic SDK by pointing its base URL at Subconscious.
# Get usage
Source: https://docs.subconscious.dev/api-reference/usage
api-reference/platform.json GET /api/v1/usage
Read today's organization usage with an inference key
# Management API keys
Source: https://docs.subconscious.dev/features/management-api-keys
Provision and manage inference keys programmatically
Management API keys let you automate API-key lifecycle for your organization: mint inference keys from your own provisioning flow and delete them by prefix.
A management key cannot run inference. It only authorizes the management endpoints below. Request and response schemas are in the API reference: [create an inference key](/api-reference/create-inference-key), [list inference keys](/api-reference/list-inference-keys), and [delete an inference key](/api-reference/delete-inference-key).
## Create a management key
Organization admins can create management keys on the [API keys](https://platform.subconscious.dev/api-keys) page. Management keys are visible to organization admins only and are excluded from your inference-key limit.
The full secret is shown once at creation time. Store it in your secret manager; we cannot recover it. A management secret has the form `sk-mgmt-{prefix}.{token}`. `{prefix}` is 8 hex characters, and delete calls use that prefix.
## Authentication
Management endpoints accept the key via `X-API-Key` or `Authorization: Bearer`:
```bash theme={null}
curl https://platform.subconscious.dev/api/v1/management/api-keys \
-H "Authorization: Bearer sk-mgmt-..."
```
All endpoints are scoped to the organization the management key belongs to.
## Create an inference key
`POST /api/v1/management/api-keys`
```bash theme={null}
curl https://platform.subconscious.dev/api/v1/management/api-keys \
-H "Authorization: Bearer sk-mgmt-..." \
-H "Content-Type: application/json" \
-d '{"name": "tenant-42"}'
```
Response:
```json theme={null}
{
"apiKey": {
"id": "5f0c...",
"name": "tenant-42",
"key": "sk-gw-...",
"keyPrefix": "a1b2c3d4",
"createdAt": "2026-09-30T21:40:00.000Z"
}
}
```
`key` is the inference secret. Return it to your tenant or feed it straight into your runtime. It is shown once; the delete endpoint uses `keyPrefix` so you never need the full secret again.
## List inference keys
`GET /api/v1/management/api-keys`
Returns the organization's inference keys, newest first: id, name, prefix, whether the key is active, created time, and last-used time. Inactive keys are included. Hidden keys and management keys are omitted. Secrets are not included.
## Delete an inference key
`DELETE /api/v1/management/api-keys/{keyPrefix}`
```bash theme={null}
curl -X DELETE https://platform.subconscious.dev/api/v1/management/api-keys/a1b2c3d4 \
-H "Authorization: Bearer sk-mgmt-..."
```
Revokes the key at the gateway and deactivates it. Requests presented with a deleted key fail immediately. Returns 404 when no active key matches the prefix.
# Streaming
Source: https://docs.subconscious.dev/features/streaming
Stream responses token by token in real time
Streaming delivers tokens as they're generated, which enables responsive UIs and real-time output. Subconscious streams using whichever wire format you call: the OpenAI format emits Server-Sent Events (SSE) with `ChatCompletionChunk` objects, and the Anthropic Messages format emits the Anthropic event protocol (`message_start`, `content_block_delta`, `message_stop`).
## Basic Streaming
Set `stream=True` (or use `client.messages.stream(...)` with the Anthropic SDK) to receive a stream of chunks instead of waiting for the full response:
```python Python (OpenAI) theme={null}
from openai import OpenAI
client = OpenAI(
api_key="your-api-key",
base_url="https://api.subconscious.dev/v1",
)
stream = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "Explain how neural networks learn."}],
stream=True,
)
for chunk in stream:
content = chunk.choices[0].delta.content
if content:
print(content, end="", flush=True)
print()
```
```typescript Node.js (OpenAI) theme={null}
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "your-api-key",
baseURL: "https://api.subconscious.dev/v1",
});
const stream = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [{ role: "user", content: "Explain how neural networks learn." }],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) process.stdout.write(content);
}
console.log();
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
client = Anthropic(
auth_token="your-api-key",
base_url="https://api.subconscious.dev",
)
with client.messages.stream(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain how neural networks learn."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
print()
```
```typescript Node.js (Anthropic) theme={null}
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
authToken: "your-api-key",
baseURL: "https://api.subconscious.dev",
});
const stream = client.messages.stream({
model: "subconscious/glm-5.3-marathon",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain how neural networks learn." }],
});
for await (const event of stream) {
if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
process.stdout.write(event.delta.text);
}
}
console.log();
```
```bash cURL (Chat Completions) theme={null}
curl https://api.subconscious.dev/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"messages": [{"role": "user", "content": "Explain how neural networks learn."}],
"stream": true
}'
```
```bash cURL (Messages) theme={null}
curl https://api.subconscious.dev/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Explain how neural networks learn."}],
"stream": true
}'
```
## SSE Format
### Chat Completions
Each event in the stream is a `data:` line containing a JSON `ChatCompletionChunk` object:
```
data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","model":"subconscious/glm-5.3-marathon","choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}
data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","model":"subconscious/glm-5.3-marathon","choices":[{"index":0,"delta":{"content":" world"},"finish_reason":null}]}
data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","model":"subconscious/glm-5.3-marathon","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}
data: [DONE]
```
The final chunk has `finish_reason: "stop"` and is followed by `data: [DONE]`.
### Messages
The Messages endpoint emits the Anthropic event protocol. Each SSE message has an `event:` type and a `data:` JSON payload, progressing through `message_start`, one or more content blocks (`content_block_start` → `content_block_delta` → `content_block_stop`), then `message_delta` and `message_stop`:
```
event: message_start
data: {"type":"message_start","message":{"id":"msg_abc123","type":"message","role":"assistant","content":[],"model":"subconscious/glm-5.3-marathon","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":12,"output_tokens":0,"cache_read_input_tokens":0}}}
event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}
event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" world"}}
event: content_block_stop
data: {"type":"content_block_stop","index":0}
event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":18}}
event: message_stop
data: {"type":"message_stop"}
```
Unlike the Chat Completions format, there is no `data: [DONE]` sentinel — the stream ends with `message_stop`.
## Error Handling
Errors during streaming are delivered as SSE events. Both SDKs raise exceptions automatically:
```python Python (OpenAI) theme={null}
from openai import APIError
try:
stream = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "Hello"}],
stream=True,
)
for chunk in stream:
content = chunk.choices[0].delta.content
if content:
print(content, end="", flush=True)
except APIError as e:
print(f"API error: {e.status_code} - {e.message}")
```
```typescript Node.js (OpenAI) theme={null}
import OpenAI from "openai";
try {
const stream = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [{ role: "user", content: "Hello" }],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) process.stdout.write(content);
}
} catch (error) {
if (error instanceof OpenAI.APIError) {
console.error(`API error: ${error.status} - ${error.message}`);
}
}
```
```python Python (Anthropic) theme={null}
from anthropic import APIError
try:
with client.messages.stream(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello"}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
except APIError as e:
print(f"API error: {e.status_code} - {e.message}")
```
```typescript Node.js (Anthropic) theme={null}
import Anthropic from "@anthropic-ai/sdk";
try {
const stream = client.messages.stream({
model: "subconscious/glm-5.3-marathon",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello" }],
});
for await (const event of stream) {
if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
process.stdout.write(event.delta.text);
}
}
} catch (error) {
if (error instanceof Anthropic.APIError) {
console.error(`API error: ${error.status} - ${error.message}`);
}
}
```
## Usage Statistics
For the Chat Completions format, include `stream_options` to receive token usage in the final chunk. For the Messages format, usage is built in: `input_tokens` arrives on `message_start` and `output_tokens` on `message_delta`.
```python Python (OpenAI) theme={null}
stream = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "Hello"}],
stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.usage:
print(f"Input: {chunk.usage.prompt_tokens}, Output: {chunk.usage.completion_tokens}")
elif chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
```
```python Python (Anthropic) theme={null}
with client.messages.stream(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello"}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final = stream.get_final_message()
print(f"\nInput: {final.usage.input_tokens}, Output: {final.usage.output_tokens}")
```
For Chat Completions, usage data is included in the final chunk of the stream.
# Subconscious Cache
Source: https://docs.subconscious.dev/features/subconscious-cache
(Advanced) Disable auto compaction and trigger the subconscious cache manually.
Normally, our TIMRUN inference runtime has two features enabled by default to improve agent performance and ability.
1. Auto Compaction -> compact the message list at runtime.
2. Subconscious Cache -> Maintain both the prefix and the suffix around the pruned messages.
This guide will walk you through how to disable auto compaction, so that you can use the subconscious cache explicitly.
## How It Works
To hit the subconscious cache, the cached tokens and new inputs need to satisfy two criteria:
1. The cached chain can be precisely split into three sections `A, B, C`
2. Section `B` is pruned.
3. The new input chain can be precisely split into three sections `A, C, D`, such that `A` and `C` match the prefix `A` and suffix `C` in the cache and `len(C) > threshold`. We usually set `threshold = 8` tokens to avoid matching the suffix of chat templates.
## Manually Triggering Subconscious Cache
Subconscious API enables auto-compaction by default. Under the auto-compaction mode, developers can send any message list to the LLM API and the inference system will detect prunable messages. Message pruning in the auto compaction mode will automatically hit the subconscious cache.
If you want to manually hit subconscious by controlling the context by yourself instead of auto-compaction, simply disable auto compaction in the chat kwards. The `chat_template_kwargs` extension is accepted on both the Completions and Messages endpoints.
```python Python (OpenAI) theme={null}
from openai import OpenAI
client = OpenAI(
api_key="your-api-key",
base_url="https://api.subconscious.dev/v1",
)
response = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "What is 127 * 849 + 3621?"}],
extra_body={
"chat_template_kwargs": {"enable_auto_compaction": False},
},
)
print(response.choices[0].message.content)
```
```typescript Node.js (OpenAI) theme={null}
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "your-api-key",
baseURL: "https://api.subconscious.dev/v1",
});
const response = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [{ role: "user", content: "What is 127 * 849 + 3621?" }],
// @ts-expect-error Subconscious extension
chat_template_kwargs: { enable_auto_compaction: false },
});
console.log(response.choices[0].message.content);
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
client = Anthropic(
auth_token="your-api-key",
base_url="https://api.subconscious.dev",
)
message = client.messages.create(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
messages=[{"role": "user", "content": "What is 127 * 849 + 3621?"}],
extra_body={
"chat_template_kwargs": {"enable_auto_compaction": False},
},
)
print(message.content[0].text)
```
```typescript Node.js (Anthropic) theme={null}
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
authToken: "your-api-key",
baseURL: "https://api.subconscious.dev",
});
const message = await client.messages.create({
model: "subconscious/glm-5.3-marathon",
max_tokens: 1024,
messages: [{ role: "user", content: "What is 127 * 849 + 3621?" }],
// @ts-expect-error Subconscious extension
chat_template_kwargs: { enable_auto_compaction: false },
});
console.log(message.content[0].text);
```
```bash cURL (Chat Completions) theme={null}
curl https://api.subconscious.dev/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"messages": [{"role": "user", "content": "What is 127 * 849 + 3621?"}],
"chat_template_kwargs": {"enable_auto_compaction": false}
}'
```
```bash cURL (Messages) theme={null}
curl https://api.subconscious.dev/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "What is 127 * 849 + 3621?"}],
"chat_template_kwargs": {"enable_auto_compaction": false}
}'
```
## When to Turn Off Auto Compaction
If you turn off auto compaction, you need to manually construct inputs that can hit the subconscious cache. Just make sure you only prune **one** continuous token sequence from the message list. If there is no context pruning, the new input will simply hit prefix cache. If more than one chunks are pruned, we cannot find suffix tokens satisfying the subconscious rules.
**Use Auto Compaction for:**
* Programming tasks, where assistant-tool-user messages keeps growing in a message list
* Browser automation, where dead end exploration is easily pruned
* Workflow automation, where stale tool calls pile up quickly
* Multi-turn conversation, where rigid context pruning rule cannot handle arbitrary user inputs
**Skip auto compaction for:**
* ReACT multi-modal reasoning: Subconscious cache works perfectly when you only keep latest turns / images in the message list
* Other applications where you need to carefully control context engineering.
# Thinking Mode
Source: https://docs.subconscious.dev/features/thinking
Enable step-by-step reasoning for complex tasks
Thinking mode enables the model to reason step by step before producing its final answer. This provides higher quality outputs for complex tasks like math, logic, code generation, and multi-step analysis.
Closed models usually **hide** their reasoning, returning only a summary or nothing at all. Because Subconscious serves **open models**, the model's reasoning is **completely visible**. You get the full, unaltered chain of thought, giving you total transparency for debugging, auditing, and trust.
## How It Works
When thinking mode is enabled, the model generates internal reasoning tokens (wrapped in `` tags) before the final response. These reasoning tokens help the model work through complex problems but are included in your output token usage.
## Enabling Thinking Mode
Each wire format controls thinking with its own syntax.
With the **OpenAI** format,
pass the Subconscious extension `chat_template_kwargs` with `enable_thinking: true` via the
`extra_body` parameter.
With the **Anthropic** format, use the native `thinking` parameter
(`{"type": "enabled", "budget_tokens": ...}`):
```python Python (OpenAI) theme={null}
from openai import OpenAI
client = OpenAI(
api_key="your-api-key",
base_url="https://api.subconscious.dev/v1",
)
response = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "What is 127 * 849 + 3621?"}],
extra_body={
"chat_template_kwargs": {"enable_thinking": True},
},
)
print(response.choices[0].message.content)
```
```typescript Node.js (OpenAI) theme={null}
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "your-api-key",
baseURL: "https://api.subconscious.dev/v1",
});
const response = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [{ role: "user", content: "What is 127 * 849 + 3621?" }],
// @ts-expect-error Subconscious extension
chat_template_kwargs: { enable_thinking: true },
});
console.log(response.choices[0].message.content);
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
client = Anthropic(
auth_token="your-api-key",
base_url="https://api.subconscious.dev",
)
message = client.messages.create(
model="subconscious/glm-5.3-marathon",
max_tokens=2048,
thinking={"type": "enabled", "budget_tokens": 2000},
messages=[{"role": "user", "content": "What is 127 * 849 + 3621?"}],
)
for block in message.content:
if block.type == "thinking":
print("[thinking]", block.thinking)
elif block.type == "text":
print(block.text)
```
```typescript Node.js (Anthropic) theme={null}
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
authToken: "your-api-key",
baseURL: "https://api.subconscious.dev",
});
const message = await client.messages.create({
model: "subconscious/glm-5.3-marathon",
max_tokens: 2048,
thinking: { type: "enabled", budget_tokens: 2000 },
messages: [{ role: "user", content: "What is 127 * 849 + 3621?" }],
});
for (const block of message.content) {
if (block.type === "thinking") console.log("[thinking]", block.thinking);
else if (block.type === "text") console.log(block.text);
}
```
```bash cURL (Chat Completions) theme={null}
curl https://api.subconscious.dev/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"messages": [{"role": "user", "content": "What is 127 * 849 + 3621?"}],
"chat_template_kwargs": {"enable_thinking": true}
}'
```
```bash cURL (Messages) theme={null}
curl https://api.subconscious.dev/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"max_tokens": 2048,
"thinking": {"type": "enabled", "budget_tokens": 2000},
"messages": [{"role": "user", "content": "What is 127 * 849 + 3621?"}]
}'
```
Both controls enable the same underlying feature. The OpenAI format toggles it with the
`enable_thinking` extension; the Anthropic format uses the native `thinking` config and also
lets you cap reasoning with `budget_tokens`.
## Response Format
With the **OpenAI** format, the model's response includes reasoning wrapped in `` tags
followed by the final answer:
```
Let me calculate this step by step.
127 * 849 = 127 * 800 + 127 * 49
127 * 800 = 101,600
127 * 49 = 6,223
101,600 + 6,223 = 107,823
107,823 + 3,621 = 111,444
The answer is **111,444**.
```
With the **Anthropic** format, the reasoning is returned as a separate `thinking` content block
before the `text` block, rather than inline tags:
```json theme={null}
{
"content": [
{"type": "thinking", "thinking": "Let me calculate this step by step...", "signature": ""},
{"type": "text", "text": "The answer is **111,444**."}
]
}
```
## Streaming with Thinking
Thinking mode works with streaming. The reasoning tokens stream first, followed by the final answer:
```python Python (OpenAI) theme={null}
stream = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "Solve: If 3x + 7 = 22, what is x?"}],
stream=True,
extra_body={
"chat_template_kwargs": {"enable_thinking": True},
},
)
for chunk in stream:
content = chunk.choices[0].delta.content
if content:
print(content, end="", flush=True)
```
```python Python (Anthropic) theme={null}
with client.messages.stream(
model="subconscious/glm-5.3-marathon",
max_tokens=2048,
thinking={"type": "enabled", "budget_tokens": 2000},
messages=[{"role": "user", "content": "Solve: If 3x + 7 = 22, what is x?"}],
) as stream:
for event in stream:
if event.type == "content_block_delta":
if event.delta.type == "thinking_delta":
print(event.delta.thinking, end="", flush=True)
elif event.delta.type == "text_delta":
print(event.delta.text, end="", flush=True)
```
## When to Use Thinking Mode
**Use thinking mode for:**
* Math and arithmetic problems
* Logic puzzles and reasoning tasks
* Complex code generation
* Multi-step analysis
* Tasks requiring planning or strategy
**Skip thinking mode for:**
* Simple Q\&A
* Creative writing
* Translation
* Summarization
* Tasks where speed matters more than accuracy
Thinking tokens count toward your output token usage. For simple tasks, leaving thinking mode off will be faster and more cost-effective.
# Overview
Source: https://docs.subconscious.dev/on-prem/api-gateway/overview
The customer-facing control point for coding-agent traffic
The **API Gateway** is the customer-facing entry point for coding-agent traffic. Coding agents call the API Gateway as their customer-hosted endpoint. The gateway authenticates requests, applies access policy and limits, records usage, and routes the request to OrangeLine. It runs in your AWS, GCP, or Azure account and gives administrators a single place to manage access, routing, usage, context pruning visualization, and day-two operations.
It handles things like:
* End-user API requests from coding agents and SDK clients.
* Load balancing.
* OpenAI- and Anthropic-compatible gateway endpoints.
* Model routing to OrangeLine.
* User and API key management.
* Access controls, limits, and usage tracking.
* Context pruning visualization and intelligence.
* Runtime observability, readiness, and operational dashboards.
```mermaid theme={null}
flowchart LR
agents["Coding agents"]
subgraph customer["Customer Cloud"]
direction LR
gateway["API Gateway
(auth, limits, model routing)"]
orangeline["OrangeLine GPUs"]
gateway --> orangeline
end
agents --> gateway
style customer fill:#eef7ff,stroke:#4ea3ff,stroke-width:1px,color:#17324d
```
# Setup
Source: https://docs.subconscious.dev/on-prem/api-gateway/setup
Admin setup for dashboard access, routes, credentials, and pilot readiness
After the Subconscious Inference System is deployed, your Subconscious FDE will walk through API Gateway admin setup with your customer admin.
## Admin setup
Your FDE and customer admin work through this flow together:
1. **Confirm dashboard access**: sign in, verify the customer organization, and confirm the approved URL, DNS, TLS, and network path are working.
2. **Confirm prerequisites**: make sure the API Gateway is deployed, OrangeLine workers are reachable, required credentials are available, and first admins and pilot users are identified.
3. **Configure credentials and routes**: add only the credentials needed for routes, then create the initial model route to OrangeLine.
4. **Send a test request**: use an admin test key and a small prompt to confirm authentication, model access, routing, response behavior, and usage recording.
5. **Configure pilot users**: create or share the pilot API key pattern, confirm model slugs, and point the first coding agents at the customer API Gateway endpoint.
6. **Confirm day-two ownership**: align on user management, usage metering, logging, monitoring, support escalation, and handoff.
After the initial setup, administrators usually operate a few recurring workflows.
### User management
* Invite administrators and pilot users.
* Reset passwords and manage roles.
* Grant or revoke model access.
* Keep user and team ownership clear during rollout.
### Usage metering
* Create and revoke API keys.
* Configure organization-level and API-key-level limits.
* Review usage by date range, model, key, or organization.
* Adjust limits after pilot feedback or capacity changes.
### Logging
* Review gateway service logs, router logs, route health logs, and audit logs for admin actions.
* Keep sensitive prompts, completions, secrets, and API keys out of shared logs.
* Prepare customer-approved support bundles or diagnostic summaries when needed.
### Monitoring
* Monitor gateway availability, request rate, latency, error rate, and route health.
* Review authentication failures, authorization failures, and rate-limit events.
* Pair gateway metrics with OrangeLine metrics such as GPU utilization, queue depth, and token throughput.
## Admin handoff checklist
* Customer admins can sign in.
* Admin users and pilot users are configured.
* Initial API keys are created and stored.
* Initial OrangeLine routes are active and healthy.
* Model access is granted.
* Limits are configured.
* Test request succeeds.
* Coding-agent setup is validated for at least one pilot user.
* Usage is visible.
* Monitoring and logging ownership is confirmed.
* Support and escalation process is understood.
# Configurations
Source: https://docs.subconscious.dev/on-prem/deployments/configurations
Where OrangeLine GPUs run relative to a BYOC API Gateway
This page is for the **full inference system**. The API Gateway always runs in your AWS, GCP, or Azure account via Ryvn. The remaining choice is where OrangeLine GPUs run, and how you watch and update the stack.
For OrangeLine-only, there is no gateway placement to configure: pull a new image tag when you want an update. See [Methods](/on-prem/deployments/methods).
## Gateway and GPU placement
The gateway sits close to your identity, networking, and observability stack. OrangeLine can run next to it or on any other GPU host that can run the Docker image. GPUs do not have to be in the same hyperscaler as the gateway.
### Same cloud as the gateway
OrangeLine GPUs in the same AWS, GCP, or Azure account as the gateway.
Best when you already have approved GPU capacity, want simpler private networking, and want inference traffic to stay inside one cloud boundary.
### Somewhere else
OrangeLine on another hyperscaler, a NeoCloud (Nebius, Lambda, CoreWeave, and others), an inference platform (Together AI, Baseten, Modal), your own local cluster, or bare metal. The gateway calls those workers as model routes.
Best when the gateway cloud does not have the GPUs you want, you already operate GPUs elsewhere, or you want to compare GPU homes without moving the gateway.
If you have GPUs we have not named, we can work with that.
## Secrets
Secrets follow customer policy. Common ones include gateway admin credentials, API key material, model-provider credentials, database and cache credentials, observability export credentials, registry access for OrangeLine, and TLS references.
On the gateway environment, secrets stay in your cloud (for example a cloud secret manager synced into the cluster). OrangeLine hosts that are not in that account keep their own registry and runtime credentials.
## Monitoring and logging
Map gateway availability, request rate, latency, error rate, and route health into the stack you already run (Datadog, CloudWatch, Grafana, and similar). Pair that with OrangeLine GPU utilization, queue depth, and token throughput.
Keep prompts, completions, secrets, and API keys out of shared logs. Define retention, redaction, and what you are willing to share for support before production.
Ryvn shows installation status and logs for the gateway environment. You do not have to send production inference data to Ryvn. See [Ryvn](/on-prem/ryvn/overview).
## Upgrades
### Gateway (Ryvn)
1. Subconscious publishes a gateway release.
2. You review release notes and evidence.
3. Ryvn applies the update according to approvals, maintenance windows, and release channels.
4. Health checks gate the rollout. Rollback is a first-class operation.
Do not maintain a parallel Helm process for the gateway.
### OrangeLine
On same-cloud GPUs that Ryvn also deploys, follow the same approval flow. On other GPU hosts, pull a new OrangeLine image tag and roll the workers, then confirm gateway routes still succeed.
# Methods
Source: https://docs.subconscious.dev/on-prem/deployments/methods
Full inference system via Ryvn, or OrangeLine only as a Docker container
There are two ways to run Subconscious in your infrastructure.
## Full inference system
The API Gateway plus OrangeLine, operated as one system. This is the recommended production path.
* Ryvn deploys the **API Gateway** into your **AWS, GCP, or Azure** account. That is the only supported way to run our gateway.
* **OrangeLine** runs on GPUs anywhere you can run a Docker container. Those GPUs do not have to be in the same hyperscaler as the gateway.
* Attach that compute to the gateway as model routes, whether the GPUs are in the same cloud account, on a NeoCloud or inference platform, or on your own local cluster or bare metal.
This path includes API keys, routing, usage, and **context pruning visualization and intelligence**.
Examples of OrangeLine GPU homes: AWS, GCP, Azure, Nebius, Lambda, CoreWeave, Together AI, Baseten, Modal, other NeoClouds, a local cluster, or bare metal. If you have GPUs we have not named, we can work with that.
See [Ryvn](/on-prem/ryvn/overview) and [Configurations](/on-prem/deployments/configurations).
### Walkthrough
1. Your FDE confirms AWS, GCP, or Azure as the gateway account, plus where OrangeLine GPUs will run.
2. Ryvn stands up the gateway environment in that account. A Ryvn Agent in the cluster pulls desired state over outbound HTTPS.
3. The API Gateway installation comes up. You set approval, maintenance-window, and release-channel policy.
4. OrangeLine is deployed on the chosen GPUs (same cloud, another provider, local cluster, or bare metal).
5. You add model routes on the gateway that point at those workers.
6. You validate dashboard access, a test request, and at least one coding agent.
7. Handoff covers day-two ownership, monitoring, and how updates are approved.
## OrangeLine only
The simpler path: we issue **registry credentials** for the OrangeLine image, and you run that container on any GPU cloud, local cluster, or bare-metal host.
Use this for trials, or if you already have a gateway. There is no Ryvn install and no Subconscious API Gateway.
OrangeLine still serves models. **You will not get context pruning visualization and intelligence** without our gateway.
See [OrangeLine](/on-prem/inference-runtime/overview).
### Walkthrough
1. Your FDE entitles your org and issues registry credentials for the OrangeLine image.
2. You pull the image and run it on your GPUs, wherever they live.
3. You point your own gateway or clients at the OrangeLine endpoint.
4. When you want keys, routing, usage, and pruning visualization, move to the full inference system.
## Choosing
Choose the **full inference system** when engineers will call a Subconscious-hosted endpoint and you want gateway features in your cloud.
Choose **OrangeLine only** when you are trialing the runtime, or you already operate a gateway and only need the GPU container.
Do not apply the gateway Helm chart yourself. The supported gateway path is Ryvn BYOC in AWS, GCP, or Azure.
## Related pages
* [How it works](/on-prem/how-it-works)
* [OrangeLine](/on-prem/inference-runtime/overview)
* [API Gateway setup](/on-prem/api-gateway/setup)
# FAQ
Source: https://docs.subconscious.dev/on-prem/faq
Common questions about the Subconscious Inference System
## Why use this over Claude Code or Codex?
Closed hosted tools can send prompts, code, and engineering context outside your trust boundary. The Subconscious Inference System gives your team frontier-level coding-agent intelligence while keeping API Gateway traffic, OrangeLine execution, and deployment policy inside infrastructure you control.
See [Compliance](/on-prem/trust-center/compliance).
## Why use Subconscious instead of hosting the models ourselves?
You can rent GPUs and host open models yourself, but serving coding-agent workloads efficiently is the hard part. Subconscious provides the API Gateway, OrangeLine, upgrades, and support. OrangeLine is designed to serve teams of engineers with roughly half the GPUs compared with off-the-shelf runtimes like vLLM.
See [How it works](/on-prem/how-it-works).
## What are the two ways to run it?
**Full inference system:** Ryvn deploys the API Gateway into your AWS, GCP, or Azure account. OrangeLine runs on GPUs anywhere you can run a Docker container and attaches to the gateway. This path includes context pruning visualization and intelligence.
**OrangeLine only:** we issue registry credentials and you run the container on your GPUs. Use this for trials or if you already have a gateway. You will not get context pruning visualization and intelligence without our gateway.
See [Methods](/on-prem/deployments/methods).
## How does this fit into our security review?
For the full system, the API Gateway runs in your AWS, GCP, or Azure account. A customer-installed Ryvn Agent pulls updates over outbound HTTPS. Subconscious does not need inbound access. You approve production changes through Ryvn approvals and your change-management process.
OrangeLine-only is a thinner review: you run our container on your GPUs; we are an image vendor, not the operator of your gateway.
See [Compliance](/on-prem/trust-center/compliance).
## Where does it run?
The API Gateway runs in your AWS, GCP, or Azure account. OrangeLine GPUs can be in that same account, on a NeoCloud or inference platform, on your own local cluster, or on bare metal. They do not have to match the gateway's cloud.
See [Configurations](/on-prem/deployments/configurations).
## What data does Subconscious access?
By default, production prompts, completions, source code, API keys, gateway logs, OrangeLine logs, and operational data stay in your environment. You may choose to share selected diagnostics for support.
See [Compliance](/on-prem/trust-center/compliance).
## How are upgrades delivered?
Gateway updates go through Ryvn: you review the release, then approvals, maintenance windows, and release channels decide when the agent applies it. OrangeLine on other GPU hosts is a new image tag.
See [Ryvn](/on-prem/ryvn/overview) and [Configurations](/on-prem/deployments/configurations).
## Can we control when updates are deployed?
Yes. Production gateway updates are customer-approved. Use Ryvn deployment approvals and maintenance windows.
See [Methods](/on-prem/deployments/methods) and [Compliance](/on-prem/trust-center/compliance).
## Do you support vulnerability scanning?
Subconscious can provide release evidence such as scan results, SBOMs, image digests, checksums, and release notes. You can also scan artifacts and running components with your own tools.
See [Compliance](/on-prem/trust-center/compliance).
## Do we need to bring our own GPUs?
Usually yes, or you use a GPU cloud or platform. We can help you source capacity. OrangeLine runs anywhere you can run a GPU Docker container.
See [OrangeLine](/on-prem/inference-runtime/overview).
## If a new model comes out, can we deploy it?
Yes, if OrangeLine supports the architecture and you have GPU capacity. You may need more GPUs or to replace an existing route.
See [Customer success](/on-prem/integration-journey/customer-success).
## Which coding agents are supported?
The API Gateway exposes OpenAI- and Anthropic-compatible endpoints, so teams can connect Claude Code, Cursor, Codex, OpenCode, Pi, and internal tools that speak those APIs.
See [API Gateway setup](/on-prem/api-gateway/setup).
## What happens if the deployment has an incident?
You own incident response for the gateway and OrangeLine in your environment. Subconscious supports investigation when you ask, using access or diagnostics you approve.
See [Customer success](/on-prem/integration-journey/customer-success).
# How it works
Source: https://docs.subconscious.dev/on-prem/how-it-works
The API Gateway, OrangeLine, and Ryvn behind the Subconscious Inference System
The Subconscious Inference System has three pieces:
* The **API Gateway**, which handles agent traffic, authentication, routing, API keys, usage, and context pruning visualization and intelligence.
* **OrangeLine**, the GPU inference runtime that runs TIMRUN.
* **Ryvn**, the deployment platform that installs and updates the gateway in your AWS, GCP, or Azure account.
See [Methods](/on-prem/deployments/methods) for the two ways to run it: the full inference system, or OrangeLine only.
```mermaid theme={null}
flowchart TD
codingAgents["Coding agents"]
subgraph ryvn["Ryvn"]
hub["Dashboard and control plane"]
end
subgraph customerCloud["Customer AWS, GCP, or Azure"]
agent["Ryvn Agent, egress-only"]
gateway["API Gateway"]
agent --> gateway
end
orangelineSame["OrangeLine on same-cloud GPUs"]
orangelineOther["OrangeLine on any GPU cloud, local cluster, or bare metal"]
hub -->|"desired state"| agent
codingAgents --> gateway
gateway --> orangelineSame
gateway --> orangelineOther
style ryvn fill:#fff3e8,stroke:#ff5c28,stroke-width:1px,color:#5f2411
style customerCloud fill:#eef7ff,stroke:#4ea3ff,stroke-width:1px,color:#17324d
```
## Full inference system
Ryvn deploys the API Gateway into your AWS, GCP, or Azure account. OrangeLine runs on GPUs anywhere you can run a Docker container, including the same cloud, a NeoCloud, an inference platform, your own local cluster, or bare metal. Those workers attach to the gateway as model routes. GPUs do not have to be in the same hyperscaler as the gateway.
This is the path that includes gateway features such as API keys, routing, usage, and **context pruning visualization and intelligence**.
## OrangeLine only
For trials, or if you already have a gateway, we issue registry credentials for the OrangeLine image. You run that container on any GPU host. There is no Ryvn install and no Subconscious API Gateway. OrangeLine still serves models. You will not get context pruning visualization and intelligence without our gateway.
## API Gateway
The **API Gateway** is the customer-facing entry point for coding-agent traffic. It runs in your AWS, GCP, or Azure account and handles:
* End-user API requests from coding agents and SDK clients.
* Load balancing.
* OpenAI- and Anthropic-compatible endpoints.
* Model routing to OrangeLine.
* User and API key management.
* Access controls, limits, and usage tracking.
* Context pruning visualization and intelligence.
* Operational dashboards.
See [API Gateway](/on-prem/api-gateway/overview).
## OrangeLine
**OrangeLine** is the GPU inference runtime. It runs TIMRUN on GPUs you provide and is tuned for coding-agent workloads: model execution, cache behavior, batching, and GPU utilization.
It is a Docker container. Run it anywhere you can pull and run a GPU image. Examples include AWS, GCP, Azure, Nebius, Lambda, CoreWeave, Together AI, Baseten, Modal, other NeoClouds, your own local cluster, and bare metal. If you have GPUs we have not named, we can work with that.
See [OrangeLine](/on-prem/inference-runtime/overview).
## Ryvn
**Ryvn** is the deployment platform for the full inference system. It provisions or connects the gateway environment in your AWS, GCP, or Azure account, deploys the gateway as an installation, and keeps it updated. A [Ryvn Agent](https://ryvn.ai/docs/guides/ryvn-agent) in that cluster pulls desired state over outbound HTTPS. Subconscious does not need inbound access to your VPC.
Ryvn is not required on every GPU host. An OrangeLine worker on a NeoCloud, local cluster, or other provider is a worker the gateway calls, not a second Ryvn environment.
See [Ryvn](/on-prem/ryvn/overview) and [How Ryvn works](https://ryvn.ai/docs/how-ryvn-works).
# OrangeLine
Source: https://docs.subconscious.dev/on-prem/inference-runtime/overview
GPU inference runtime you can run anywhere a Docker container will start
**OrangeLine** is the GPU inference runtime for the Subconscious Inference System. It runs TIMRUN on GPUs you provide and is tuned for coding-agent workloads: model execution, cache behavior, batching, and GPU utilization.
It is a Docker container. Run it anywhere you can pull and run a GPU image.
## Where it can run
OrangeLine is not limited to a short vendor list. Run it on the GPUs you already have.
Examples:
* Hyperscalers: AWS, GCP, Azure.
* NeoClouds: Nebius, Lambda, CoreWeave, and others.
* Inference platforms: Together AI, Baseten, Modal.
* Your own local cluster or bare metal.
If you have GPUs we have not named, we can work with that.
## Behind our gateway
In the full inference system, OrangeLine attaches to the API Gateway as model routes. The gateway stays in your AWS, GCP, or Azure account via Ryvn. The GPUs can be in that same account or somewhere else. Traffic from coding agents still enters through the gateway, which is where you get API keys, routing, usage, and **context pruning visualization and intelligence**.
See [Methods](/on-prem/deployments/methods) and [Configurations](/on-prem/deployments/configurations).
## Standalone
For trials, or if you already have a gateway, we issue registry credentials and you deploy the container yourself. No Ryvn. No Subconscious API Gateway.
OrangeLine still serves models. You will not get context pruning visualization and intelligence unless you deploy our gateway.
## Related pages
* [How it works](/on-prem/how-it-works)
* [API Gateway](/on-prem/api-gateway/overview)
# Customer success
Source: https://docs.subconscious.dev/on-prem/integration-journey/customer-success
Support, upgrades, reviews, and expansion after onboarding
Customer success starts after the initial deployment is working and pilot users are connected. The goal is to keep the system healthy, make upgrades predictable, improve cost-performance over time, and help adoption grow.
## Support model
After onboarding, the customer support channel remains open and the assigned Subconscious FDE remains the primary point of contact.
Support commonly includes:
* Deployment and configuration questions.
* Operational troubleshooting.
* Upgrade and patch coordination.
* Performance reviews.
* New model or route configuration.
* Guidance for expanding coding-agent adoption.
* Help interpreting logs, metrics, deployment status, and usage patterns.
Support access to the customer environment is not required by default. When access is needed, it should be customer-approved, scoped, logged, time-bound, and revoked when the support task is complete. See [Compliance](/on-prem/trust-center/compliance).
## Upgrades and patches
For the full inference system, gateway updates go through Ryvn. You review the release, then approvals, maintenance windows, and release channels decide when the agent applies it. OrangeLine on other GPU hosts is a new image tag.
OrangeLine-only updates are image pulls. Moving to our gateway later is what unlocks context pruning visualization and intelligence.
See [Ryvn](/on-prem/ryvn/overview) and [Configurations](/on-prem/deployments/configurations).
## Operational reviews
Review topics may include:
* Usage trends by model, team, key, or time period.
* Cost and GPU utilization.
* Latency, throughput, and error rates.
* Route health and model performance.
* User adoption and pilot feedback.
* Support history and recurring operational issues.
* Expansion opportunities and new model needs.
These reviews can be lightweight monthly digests, quarterly meetings, or customer-specific check-ins depending on the deployment size and rollout stage.
## Expanding adoption
Most customers start with a small pilot group before broad rollout. Expansion usually happens after the team validates model quality, reliability, limits, observability, and support workflows.
Expansion planning usually includes:
* Adding more pilot teams.
* Creating new API keys or key ownership patterns.
* Adjusting limits based on real usage.
* Adding or tuning model routes.
* Scaling OrangeLine with more GPUs behind the API Gateway.
* Updating internal setup instructions for coding agents.
* Sharing training material with additional engineering teams.
## Incident support
The customer owns incident response in its environment. Subconscious supports investigation and remediation when requested.
During an incident, support may include:
* Reviewing deployment status, route health, logs, metrics, and recent changes.
* Helping identify whether the issue is API Gateway, route, OrangeLine, network, capacity, credential, or client related.
* Coordinating patch or rollback guidance.
* Helping prepare a diagnostic summary.
Any logs, screenshots, traces, or access shared with Subconscious should follow the customer's approval and redaction process.
# Evaluation
Source: https://docs.subconscious.dev/on-prem/integration-journey/evaluation
Discovery, ROI, security review, and optional trials
Evaluation helps your team decide whether the Subconscious Inference System is the right customer-hosted path before implementation starts.
The goal is to align on:
* **Business value**: cost, productivity, and expected adoption.
* **Technical fit**: cloud, GPU location, networking, and coding-agent requirements.
* **Mode**: full inference system vs OrangeLine only.
* **Security review**: data boundary, vendor assessment, and compliance fit.
* **Proof points**: what must be validated before deployment.
## Discovery
Discovery starts with your engineering workflows and coding-agent usage.
Key topics:
* Engineering team size and expected adoption.
* Current coding-agent usage and preferred tools.
* Target model quality, latency, and throughput expectations.
* Workload patterns and anticipated token volume.
* Existing cloud, Kubernetes, GPU, and networking constraints.
* Whether you need our API Gateway or already have one.
* Security, compliance, data residency, and vendor review requirements.
* Success criteria and evaluation timeline.
**Output**: a clear evaluation path, who needs to participate, and which [method](/on-prem/deployments/methods) is most likely to fit.
## ROI exercise
The ROI exercise compares customer-hosted Subconscious against frontier hosted APIs, generic self-hosted GPU options, and unmanaged open-model serving.
Useful inputs:
* Expected number of engineers and pilot users.
* Agent usage patterns and expected daily or monthly token volume.
* Target model families and quality expectations.
* Current hosted API spend or internal GPU cost assumptions.
* Latency and throughput targets for interactive coding workflows.
* Required control over data, networking, infrastructure, and deployment cadence.
**Output**: a shared view of expected savings, GPU needs, reliability goals, and what the pilot or deployment must prove.
## Security review
Security review usually runs alongside commercial and technical evaluation.
**Key question**: Does the customer-hosted model fit your data, IP, security, and compliance requirements?
Subconscious can support review with:
* Security architecture overview.
* Data-flow and data-retention summary.
* API Gateway, OrangeLine, and Ryvn boundary.
* Access control and support access model.
* Vulnerability management and patching process.
* Release evidence, SBOMs, vulnerability reports, or related supply-chain materials where available.
* Shared responsibility guidance.
For the detailed security position, see [Compliance](/on-prem/trust-center/compliance). For deployment mechanics, see [Methods](/on-prem/deployments/methods) and [Ryvn](/on-prem/ryvn/overview).
## Optional model comparison trial
Some customers evaluate model quality before committing to a full customer-hosted deployment. OrangeLine-only is often enough for this step.
Typical shape:
1. Select 1-4 engineers or a small pilot group.
2. Choose representative coding-agent workflows.
3. Point local coding agents at open models hosted on-demand.
* [OpenRouter](https://openrouter.ai/)
* [Subconscious Cloud API](/ways-to-use/cloud-api)
* A NeoCloud or GPU platform, or an OrangeLine container on your GPUs
4. Compare model quality, compatibility, latency, and workflow fit.
5. Capture gaps or configuration requirements before deployment planning.
**Security note**: Cloud hosted trials are separate from customer-hosted production deployments and should be evaluated under their own data-handling assumptions.
## Optional load-test trial
A load-test trial validates whether Subconscious can serve the target engineering capacity with acceptable latency, throughput, and reliability.
Typical shape:
1. Agree on traffic assumptions or benchmark tasks.
2. Provision GPU capacity (any host that can run OrangeLine).
3. Run throughput and latency tests on representative workloads.
4. Compare results against success criteria from discovery.
5. Decide whether to proceed to deployment planning.
**Success criteria**: against target engineering capacity, there is acceptable latency for coding-agent workflows and stable throughput under expected load.
## Contracts and onboarding planning
If we agree there is a fit, we move forward with contract negotiation and onboarding planning. After that, customers move into [Onboarding](/on-prem/integration-journey/onboarding).
# Onboarding
Source: https://docs.subconscious.dev/on-prem/integration-journey/onboarding
From kickoff to pilot users on the Subconscious Inference System
Onboarding turns the evaluation plan into a working customer-hosted deployment. A Subconscious FDE works with your technical champion to choose a mode, stand up the stack, connect pilot users, and hand off day-two operations.
Use [Methods](/on-prem/deployments/methods), [Configurations](/on-prem/deployments/configurations), and [API Gateway setup](/on-prem/api-gateway/setup) for the mechanics.
## Summary
* **Kickoff to first pilot use**: usually about **1-2 weeks**, assuming customer technical resources are available.
* **Technical champion effort**: usually less than **8 hours** of focused configuration time when the environment is ready.
* **Admin training**: usually less than **1 hour**.
* **Broader team training**: usually less than **1 hour**.
* **Communication channel**: Dedicated Slack channel.
* **Onsite support**: available when it helps accelerate setup.
Strict change management, private registries, custom networking, or new GPU procurement can extend the timeline. OrangeLine-only trials are usually shorter.
## Stakeholders
* **Subconscious**: CEO and assigned FDE.
* **Customer executive sponsor**: Owns business value, rollout priority, and commercial alignment.
* **Customer technical champion**: Drives deployment planning, environment readiness, and technical coordination.
* **Core admin team**: Manages API Gateway access, API keys, routes, limits, monitoring, and day-two operations.
## 1. Kickoff
Kickoff aligns the people, communication channels, and success criteria before deployment work begins.
* **Ceremony**: 30 min meeting or async.
* **Purpose**:
* Establish communication channels, expectations, and executive sponsorship.
* Confirm implementation timeline and success criteria from evaluation.
* **What happens**:
* A dedicated Slack channel or customer-approved support channel is created.
* A Subconscious FDE becomes the primary onboarding point of contact.
* The customer identifies the technical champion, admin team, security reviewers, and pilot sponsor.
* The team confirms success criteria, timeline, and responsibilities.
## 2. Deployment planning
* **Ceremony**: 60 min meeting plus async follow-up.
* **Purpose**: Choose the mode and the GPU home.
* **Topics to define**:
* Full inference system vs OrangeLine only.
* For the full system: AWS, GCP, or Azure as the gateway account; Ryvn environment, approvals, and maintenance windows.
* OrangeLine GPU location: same cloud, NeoCloud, inference platform, local cluster, or bare metal.
* Endpoint strategy, DNS, TLS, and network path to workers.
* Observability, logging, alerting, and support access expectations.
See [Methods](/on-prem/deployments/methods) and [Ryvn](/on-prem/ryvn/overview).
## 3. Deploy
* **Ceremony**: 30-60 min meeting plus async follow-up.
* **Full inference system**: Ryvn deploys the API Gateway. OrangeLine is stood up on the chosen GPUs and attached as model routes.
* **OrangeLine only**: pull the image with the credentials we issue and run it on your GPUs.
* **Customer responsibilities**: provision or approve GPU and (for the full system) cloud-account access; approve the Ryvn Agent install when using the gateway.
* **Subconscious responsibilities**: guide the install, validate health, and prepare admins for setup.
See [Configurations](/on-prem/deployments/configurations).
## 4. API Gateway setup and admin training
Skip this step for OrangeLine-only. For the full system, see [API Gateway setup](/on-prem/api-gateway/setup).
* **Ceremony**: 30-60 min meeting plus async follow-up.
* **What gets configured and taught**: admin users, API keys, model routes to OrangeLine, limits, test requests, usage, monitoring, and upgrade expectations.
## 5. Coding agent integration and team training
* **Ceremony**: One 30 min live training session, with optional recording and written setup material.
* **Purpose**: Point coding agents at the customer endpoint (our gateway, or OrangeLine directly if you brought your own).
* **Topics**: base URL, keys, model slugs, OpenAI- and Anthropic-compatible configuration, limits, and support.
Rollout usually starts with a small pilot group.
## 6. Handoff
* **Ceremony**: 30 min meeting with stakeholders for sign-off.
* **Sign-off checklist**:
* The chosen mode is running and a test request succeeds.
* For the full system: admins can operate the API Gateway; keys, routes, and limits work; at least one coding agent is connected.
* Monitoring and logging ownership is clear.
* Support and escalation paths are understood.
* Upgrade and rollback expectations are documented, including the pruning-visualization caveat for OrangeLine-only.
After handoff, the relationship continues through [Customer success](/on-prem/integration-journey/customer-success).
# Overview
Source: https://docs.subconscious.dev/on-prem/integration-journey/overview
How evaluation, onboarding, and long-term support work
This guide explains the path from first evaluation to production use of the Subconscious Inference System.
## Typical phases
* **[Evaluation](/on-prem/integration-journey/evaluation)**: Align on use cases, security posture, ROI, expected usage, proof points, and whether you need the full inference system or OrangeLine only.
* **Timeline**: 2-4 weeks.
* **Ceremonies**: 2-4 meetings.
* **[Onboarding](/on-prem/integration-journey/onboarding)**: Plan deployment, stand up the chosen mode, configure the API Gateway when using the full system, and connect pilot users.
* **Timeline**: 1-2 weeks.
* **Ceremonies**: kickoff, deployment planning, deployment/setup, team training, and handoff.
* **[Customer success](/on-prem/integration-journey/customer-success)**: Keep the support channel open for upgrades, patches, performance reviews, and rollout guidance.
## Stakeholders
### Your side
* **Executive sponsor**: Confirms business value, pilot success criteria, rollout priority, and expansion goals.
* **Technical lead**: Owns deployment coordination across cloud, Kubernetes, networking, GPU capacity, API Gateway setup, and day-two operations.
* **Security or compliance reviewer**: Reviews the data boundary, support access model, software supply-chain evidence, and vendor risk and compliance posture.
* **Core evaluation team**: Tests coding-agent workflows, validates model quality, confirms tool compatibility, and provides pilot feedback.
### Our side
* **Subconscious executive sponsor**: Our CEO, responsible for executive alignment, commercial context, and escalation when needed.
* **Subconscious FDE**: Leads evaluation, deployment planning, setup, training, and handoff.
* **Subconscious engineering**: Supports architecture review, performance tuning, troubleshooting, upgrades, and release planning.
# Overview
Source: https://docs.subconscious.dev/on-prem/overview
What is the Subconscious Inference System, what are the benefits, and who is it for
The **Subconscious Inference System** is a GPU orchestration platform designed to serve coding agents with industry-leading efficiency.
The API Gateway runs in your AWS, GCP, or Azure account via Ryvn. **OrangeLine**, the inference runtime, runs on GPUs anywhere you can run a Docker container, including the same cloud, a NeoCloud, your own local cluster, or bare metal. For trials or if you already have a gateway, you can run OrangeLine alone.
Prompts, completions, keys, logs, and operational data stay in your environment unless you choose to share them.
Engineers use OpenAI- and Anthropic-compatible endpoints from tools such as Cursor, Claude Code, OpenCode, and internal agents.
Subconscious FDEs help plan, deploy, configure, and support the system with your platform and security teams.
## Benefits
* **Protect data and IP**: Tools like Claude Code or Codex can ship prompts, code, and engineering context outside your trust boundary. The Subconscious Inference System keeps coding-agent inference in infrastructure you control.
* **Own your intelligence economics**: Rent GPUs, choose the model, and serve your own coding intelligence instead of depending on closed APIs with high or unpredictable costs.
* **Cut GPU spend for agent workloads**: OrangeLine is designed to serve teams of engineers with roughly half the GPUs compared with off-the-shelf inference runtimes like vLLM.
* **Frontier-level intelligence**: Open models like GLM 5.2 now match leading closed models on coding-agent performance, making owned deployment a practical option.
* **Reduce platform engineering burden**: Subconscious deploys and updates the API Gateway with Ryvn, and helps you run OrangeLine on the GPUs you already have.
See the [Subconscious pricing page](https://www.subconscious.dev/pricing) for the ROI calculator and savings model.
## Who it is for
The Subconscious Inference System is for enterprises that want frontier-level coding agents without giving up control over data, IP, cost, or reliability.
It is usually a fit when:
* You have 50+ software engineers using or evaluating coding agents.
* Security or IP requirements make hosted tools hard to approve.
* You want predictable costs and owned GPU capacity.
* You do not want to build and maintain a full self-hosting stack yourself.
Start with [How it works](/on-prem/how-it-works) and [Methods](/on-prem/deployments/methods).
# Overview
Source: https://docs.subconscious.dev/on-prem/ryvn/overview
Ryvn deploys and updates the API Gateway in your AWS, GCP, or Azure account
**Ryvn** is the deployment platform for the full Subconscious Inference System. It deploys the API Gateway into your AWS, GCP, or Azure account so inference traffic, keys, and logs stay in infrastructure you control, while Subconscious keeps a consistent way to ship and update the gateway.
Ryvn is not used for OrangeLine-only trials. GPU workers on a NeoCloud, local cluster, or bare metal are containers the gateway calls; they are not a second Ryvn environment.
For Ryvn's own product model, start with [How Ryvn works](https://ryvn.ai/docs/how-ryvn-works).
## What Ryvn deploys
A Ryvn **environment** is the isolated plane in your cloud account (VPC, Kubernetes, networking, TLS). A **service** is the deployable unit. A **service installation** is that service running in an environment, with its own config, scaling, and rollout.
For Subconscious, that means:
* The API Gateway installation in your AWS, GCP, or Azure environment.
* OrangeLine in that same environment only when you choose to run GPUs next to the gateway.
See [Environments](https://ryvn.ai/docs/guides/environments) and [Installations](https://ryvn.ai/docs/guides/installations).
## Ryvn Agent
Each environment runs a [Ryvn Agent](https://ryvn.ai/docs/guides/ryvn-agent): a Kubernetes operator that pulls desired state from Ryvn over outbound HTTPS. There is no inbound path into your VPC. The agent reconciles deployments, health checks, and rollbacks in-cluster.
You keep cloud-account ownership, IAM, networking, and production change management. Subconscious publishes releases; the agent applies them according to the policy on that environment.
## Approvals, windows, and channels
Customer control of production cadence uses Ryvn's built-in controls, not a separate Helm process:
* [Deployment approvals](https://ryvn.ai/docs/guides/deployment-approvals) so a change waits for review before it applies.
* [Maintenance windows](https://ryvn.ai/docs/configure/maintenance-windows) to bound when updates may run.
* [Release channels](https://ryvn.ai/docs/configure/release-channels) to pin or promote gateway versions.
Failed rollouts keep existing replicas. Rollback is a first-class operation.
## Observability
Ryvn shows installation status, logs, and basic metrics in its dashboard. You can keep Datadog, CloudWatch, Grafana, or whatever you already run. Subconscious does not require you to send prompts, completions, or production logs to Ryvn.
## Related pages
* [Methods](/on-prem/deployments/methods): full system vs OrangeLine only.
* [Configurations](/on-prem/deployments/configurations): where OrangeLine GPUs run relative to the gateway.
* [Compliance](/on-prem/trust-center/compliance): data boundary and support access.
# Compliance
Source: https://docs.subconscious.dev/on-prem/trust-center/compliance
Security review packet for the customer-hosted Subconscious Inference System
This page describes the deployment of the complete Subconscious Gateway product: the gateway with cache-aware router, the admin dashboard, and **OrangeLine (the inference runtime)**. Customers deploying the inference runtime alone follow a simpler procedure, noted at the end of [Deployment](#deployment).
Prepared for security, compliance, platform, and engineering teams.
## Customer-hosted architecture
Subconscious deploys into infrastructure you own. Every production component runs inside a VPC you control, on the hyperscaler you already use. Your VPC standards define the security and compliance boundary.
The Gateway product has two components.
**API Gateway.** The entry point for agent traffic. Includes the cache-aware router, the admin dashboard, authentication, API key management, and usage controls.
**Inference runtime.** The GPU-backed execution layer, deployed as a Docker image on GPU compute you provision.
The gateway and admin dashboard are delivered through [Ryvn](/on-prem/ryvn/overview), a deployment platform built for customer-cloud software. A small [Ryvn Agent](https://ryvn.ai/docs/guides/ryvn-agent) runs in your cluster and pulls approved releases over outbound HTTPS. It accepts no inbound connections. The inference runtime ships as a Docker image and runs on GPU compute you provision, whether on-premises, in a hyperscaler, or in a neocloud. [Deployment](#deployment) covers both paths. See also [How Ryvn works](https://ryvn.ai/docs/how-ryvn-works).
Subconscious never accesses customer data. The only information that leaves your environment is opt-in operational telemetry ([Telemetry](#telemetry)).
## Data flow
No customer data leaves your cloud environment. Prompts, completions, inference requests and responses, API keys, user records, and application logs remain inside your VPC at all times.
Three flows cross the boundary, all outbound-initiated.
**Releases.** The Ryvn agent pulls signed gateway releases from the Subconscious release channel, automatically or after your approval. The inference runtime image is pulled from the Subconscious container registry on your schedule.
**Deployment status.** The agent reports heartbeat and task status to the Ryvn control plane so deployments can be tracked. This is operational metadata only.
**Telemetry, opt-in.** Operational metrics and logs, if you enable them. Never customer or user data.
## Shared responsibility
Subconscious delivers stable, scalable, rigorously tested software. You provide the infrastructure it runs on and keep that infrastructure available.
Tell us which framework governs your review and we will provide a control-by-control mapping.
| Area | Subconscious | Customer |
| - | - | - |
| Software quality | Delivers stable, scalable, rigorously tested software for the gateway, admin dashboard, and inference runtime. | Validates releases against internal requirements before rollout. |
| Vulnerability management | Scans every release for vulnerabilities and malware. Remediates severe vulnerabilities within customer-agreed SLA. | Scans the deployed environment under its own security program. Applies patched releases. |
| Data | Never accesses customer data. Receives opt-in operational telemetry only. | Owns all prompts, completions, keys, user records, and application data, including storage, backup, and retention. |
| Monitoring | Monitors system health through opt-in telemetry when enabled. | Monitors the deployed environment. Owns alerting and incident response when telemetry not opted-in. |
| Infrastructure | Provides provisioning packaging (terraform, helm, etc.), sizing guidance, deployment support. | Provisions and operates the cloud account, cluster, and GPU compute. Keeps the account in good standing, including billing and quotas. |
## Software supply-chain controls
Subconscious software runs in your environment, so the relevant risk category is software supply chain.
* A software bill of materials accompanies every release.
* Vulnerability and malware scans run against the SBOM on every deploy.
* Severe vulnerabilities are remediated within customer-agreed SLA.
* Release artifacts are signed and scanned before publication to your release channel.
* Material security issues trigger direct customer notification and a published advisory with the remediation path.
* You may scan release artifacts and deployed components with your own tooling before approving deployment.
You remain responsible for scanning and monitoring the deployed environment under your own security program. Subconscious assists with interpretation, remediation planning, and patch coordination.
## Release and update process
All Subconscious software is version controlled. Every release passes through a defined procedure that verifies compliance and confirms the build has no critical vulnerabilities. The full product team follows this procedure for every release.
Before a release reaches any customer environment, Subconscious deploys and tests it on its own infrastructure. Only then is it published to the release channel your environment subscribes to.
### Update modes
For the gateway and admin dashboard, you select how releases enter your environment. The setting is enforced by Ryvn at the environment level. Inference runtime updates are new Docker images, pulled and deployed on your own schedule.
**Automatic.** Your environment subscribes to the release channel and deploys new releases as they are published, within any maintenance window you set.
**On approval.** Each release generates a preview showing the exact manifest diff that will be applied. A reviewer on your team approves it from the Ryvn dashboard, with an optional reason recorded in the audit trail. Nothing changes until approval.
In both modes you can review release notes before deployment, schedule maintenance windows, and roll back to a prior version. When approval is required, rollbacks and force deploys generate their own previews and wait for approval too. Subconscious cannot push a change into your environment outside the policy you select.
## Support access
Subconscious provides 24/7 support through a dedicated member of our team.
Subconscious requires no persistent access to your cloud environment. When access is needed to resolve an issue, you grant it under your own policy: approved by you, scoped to the task, logged by you, time-bound, and revoked on completion.
Typical access models include live screen-share sessions you drive, temporary credentials you issue, break-glass access for urgent issues, and diagnostics you export from your own tooling. When telemetry is enabled, most issues can be diagnosed from metrics and logs without any access grant.
Any material shared during support is initiated by you, limited to the issue under investigation, and redacted where appropriate.
## Telemetry
Telemetry is the set of operational signals Subconscious can observe about the running software. It exists so our team can confirm the system is healthy, catch degradation before you notice it, and resolve support requests without asking for access.
Telemetry is off unless you turn it on. Subconscious recommends enabling it.
### What is collected
| Category | What is collected |
| - | - |
| Queue and load | Request queue depth, in-flight request counts, and throughput per runtime replica. |
| Latency | Time-to-first-token and end-to-end request timing, as aggregated distributions. |
| Health | Liveness and readiness events, restarts, GPU memory pressure, and cache hit rates from the router. |
| Errors | Error codes, counts, and stack traces from the gateway and runtime. |
| Version | Running version of each component, so support can match behavior to a known release. |
### What is never collected
Telemetry never includes prompts, completions, source code, API keys, secrets, user identities, request bodies, or any other customer or user data. Metrics are aggregated counts and timings. Logs are limited to gateway and runtime events.
### How it leaves your environment
Telemetry is collected inside your environment and forwarded over outbound HTTPS. No inbound connection is opened.
### Your controls
* Enable or disable metric collection and log collection independently.
* Turn telemetry off at any time through your deployment settings, with no involvement from Subconscious.
## Deployment
Deployment has two parts. The gateway and admin dashboard are deployed into your cloud environment through Ryvn. The inference runtime ships as a Docker image and runs on GPU compute you provision, on-premises, in a hyperscaler, or in a neocloud.
Ryvn is a deployment platform for running vendor software in customer clouds. It has been used to deploy into regulated environments across healthcare, finance, defense, and the Fortune 100. Its trust center is at [trust.ryvn.ai](https://trust.ryvn.ai).
### How the Ryvn agent works
A single Kubernetes operator, the [Ryvn Agent](https://ryvn.ai/docs/guides/ryvn-agent), runs in your cluster. It establishes outbound HTTPS connections to the Ryvn control plane and polls for pending tasks. It never accepts inbound connections, so no ingress rules, port forwarding, or public endpoints are required.
The agent runs unprivileged: non-root, read-only root filesystem, all Linux capabilities dropped. It holds no persistent state. Communication uses mutual TLS with scoped, auto-refreshing tokens. Secrets are encrypted per environment before transmission and decrypted in memory only. Every task the agent runs is recorded in an audit trail visible to your team.
### Prerequisites
* An AWS, Google Cloud, or Azure account, or an existing Kubernetes cluster you operate, for the gateway and admin dashboard.
* GPU compute from any provider for the inference runtime. Compute in the same cloud and region as the gateway is preferred and simplifies deployment.
* Outbound HTTPS from the cluster to the Ryvn control plane and to the Subconscious container registry.
* A named approver on your team if you choose the on-approval update mode.
### Deployment steps
**1. Kickoff and security review**
Subconscious and your team walk through this packet and agree on cloud provider, region, GPU compute provider, update mode, and telemetry settings. Subconscious provides sizing recommendations based on your expected agent traffic.
**2. Create the environment**
Subconscious creates a dedicated environment for you in Ryvn and invites your approver. Your approver receives scoped access: they can view the environment, review deployment previews, and approve. They cannot modify services or trigger deployments.
**3. Provision or connect gateway infrastructure**
Choose one path.
*Ryvn provisions.* You grant scoped permissions through the Ryvn dashboard. Ryvn creates a VPC with your chosen CIDR, or uses your existing VPC and private subnets, then provisions a Kubernetes cluster, networking, load balancers, and IAM roles in your account. Provisioning typically completes in 15 to 20 minutes.
*Existing cluster.* You download the agent manifest from the Ryvn dashboard, apply it with kubectl, and install the agent Helm chart. Ryvn creates no network or cluster infrastructure and leaves ingress, DNS, and certificates under your control.
**4. Set approval and observability policy**
In the environment settings, enable or disable the approval requirement to match your chosen update mode, and enable or disable metric and log collection. These settings can be changed at any time.
**5. Deploy the gateway and admin dashboard**
Subconscious publishes the release to your environment's release channel. If approval is required, your approver reviews the rendered manifest diff and approves. The agent applies the release. Health checks gate traffic until every replica reports ready.
**6. Provision GPU compute and deploy the inference runtime**
You provision GPU compute with the provider of your choice. Subconscious provides the runtime Docker image, the launch configuration, and the recommended instance types.
*Same cloud and region as the gateway.* You launch GPU instances, pull the runtime image, and start the containers with the configuration provided. The gateway reaches the runtime over your private network.
*Other provider.* For on-premises hardware, a neocloud, or a managed compute platform such as Together AI or Modal, Subconscious and your team work through that provider's deployment procedure together.
**7. Configure and validate**
Your team registers the runtime endpoints in the admin dashboard, creates API keys and routes, and points internal agents at the gateway. Subconscious and your team run performance validation against representative traffic and confirm cache hit rates, latency, and throughput meet targets.
**8. Roll out**
Release the endpoint to your engineering users. Gateway updates arrive through the release channel under the update mode you selected. Runtime updates are new Docker images you pull on your own schedule.
See [Methods](/on-prem/deployments/methods) for the product-mode chooser and [Ryvn](/on-prem/ryvn/overview) for how we use Ryvn for the gateway.
### Inference runtime only
Customers who want the inference runtime without the gateway and admin dashboard skip Ryvn entirely. Complete step 1, then step 6 on your GPU compute, and point your existing routing layer at the runtime endpoint.
## FAQ
### Does Subconscious process or store our data?
No. Inference requests, prompts, completions, logs, keys, and operational data remain in your environment. Nothing is shared unless you choose to share specific material during support.
### Does Subconscious or Ryvn require access to our cloud account?
No inbound access is required by either. The Ryvn agent connects outbound only and holds Kubernetes permissions within your cluster. Any support access from Subconscious is approved by you, scoped, logged, time-bound, and revoked after use.
### Who controls updates?
You do. Subconscious publishes releases to your release channel. You either enable automatic deployment or review each release preview and approve it. Approval is enforced at the environment level and cannot be bypassed by a force deploy or rollback.
### Is telemetry enabled by default?
No. Telemetry is opt-in. It carries operational metrics and logs only, never customer or user data. [Telemetry](#telemetry) lists exactly what is collected and how to control it.
# Subconscious
Source: https://docs.subconscious.dev/overview
Subconscious is an AI lab that makes language models dramatically more capable with our inference runtime TIMRUN and complementary post-trained TIM family of models. Our API is compatible with both the OpenAI Completions and Anthropic Messages APIs, so you can get started with our API with three lines of code with the SDK you already use.
## Quick Look
```python Python (OpenAI) theme={null}
from openai import OpenAI
client = OpenAI(
api_key="your-api-key", # Step 1: add your API key
base_url="https://api.subconscious.dev/v1", # Step 2: point to our api
)
response = client.chat.completions.create(
model="subconscious/glm-5.3-marathon", # Step 3: set the model. You're all set!
messages=[{"role": "user", "content": "What is the capital of France?"}],
)
print(response.choices[0].message.content)
```
```typescript Node.js (OpenAI) theme={null}
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "your-api-key",
baseURL: "https://api.subconscious.dev/v1",
});
const response = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [{ role: "user", content: "What is the capital of France?" }],
});
console.log(response.choices[0].message.content);
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
client = Anthropic(
auth_token="your-api-key",
base_url="https://api.subconscious.dev",
)
message = client.messages.create(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
messages=[{"role": "user", "content": "What is the capital of France?"}],
)
print(message.content[0].text)
```
```typescript Node.js (Anthropic) theme={null}
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
authToken: "your-api-key",
baseURL: "https://api.subconscious.dev",
});
const message = await client.messages.create({
model: "subconscious/glm-5.3-marathon",
max_tokens: 1024,
messages: [{ role: "user", content: "What is the capital of France?" }],
});
console.log(message.content[0].text);
```
```bash cURL (Chat Completions) theme={null}
curl https://api.subconscious.dev/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"messages": [{"role": "user", "content": "What is the capital of France?"}]
}'
```
```bash cURL (Messages) theme={null}
curl https://api.subconscious.dev/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "What is the capital of France?"}]
}'
```
To try this yourself, grab an API key on our [platform](https://subconscious.dev).
## Available Models
See [Pricing](https://www.subconscious.dev/pricing) for the full list of available models and current per-token rates.
## Get started
Make your first API call in under 5 minutes
Full endpoint documentation
### AI Readable
* [subconscious.dev/llms.txt](https://docs.subconscious.dev/llms.txt): Documentation index with links
* [subconscious.dev/llms-full.txt](https://docs.subconscious.dev/llms-full.txt): Complete documentation in one file
# Quickstart
Source: https://docs.subconscious.dev/quickstart
Make your first API call
## 1. Create an Account
[Sign up on the platform](https://subconscious.dev/platform) and generate an API key from your dashboard.
## 2. Try the Playground
Before writing code, try the [Playground](https://www.subconscious.dev/playground) to test prompts interactively.
## 3. Install an SDK
Subconscious is compatible with both the OpenAI and Anthropic SDKs — use whichever you
prefer. Install it for your language:
```bash Python (OpenAI) theme={null}
pip install openai
```
```bash Node.js (OpenAI) theme={null}
npm install openai
```
```bash Python (Anthropic) theme={null}
pip install anthropic
```
```bash Node.js (Anthropic) theme={null}
npm install @anthropic-ai/sdk
```
## 4. Make Your First Request
Set your API key and base URL, then create a chat completion:
```python Python (OpenAI) theme={null}
from openai import OpenAI
client = OpenAI(
api_key="your-api-key",
base_url="https://api.subconscious.dev/v1",
)
response = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain quantum computing in three sentences."},
],
)
print(response.choices[0].message.content)
```
```typescript Node.js (OpenAI) theme={null}
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "your-api-key",
baseURL: "https://api.subconscious.dev/v1",
});
const response = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "Explain quantum computing in three sentences." },
],
});
console.log(response.choices[0].message.content);
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
client = Anthropic(
auth_token="your-api-key",
base_url="https://api.subconscious.dev",
)
message = client.messages.create(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
system="You are a helpful assistant.",
messages=[
{"role": "user", "content": "Explain quantum computing in three sentences."},
],
)
print(message.content[0].text)
```
```typescript Node.js (Anthropic) theme={null}
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
authToken: "your-api-key",
baseURL: "https://api.subconscious.dev",
});
const message = await client.messages.create({
model: "subconscious/glm-5.3-marathon",
max_tokens: 1024,
system: "You are a helpful assistant.",
messages: [
{ role: "user", content: "Explain quantum computing in three sentences." },
],
});
console.log(message.content[0].text);
```
```bash cURL (Chat Completions) theme={null}
curl https://api.subconscious.dev/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"messages": [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain quantum computing in three sentences."}
]
}'
```
```bash cURL (Messages) theme={null}
curl https://api.subconscious.dev/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "subconscious/glm-5.3-marathon",
"max_tokens": 1024,
"system": "You are a helpful assistant.",
"messages": [
{"role": "user", "content": "Explain quantum computing in three sentences."}
]
}'
```
### Using an agents SDK
Want to use an SDK build for handling agents? Try one of these:
```python OpenAI Agents theme={null}
from openai import AsyncOpenAI
from agents import (
Agent,
Runner,
OpenAIChatCompletionsModel,
set_tracing_disabled,
)
API_KEY = "your-api-key"
MODEL = "subconscious/glm-5.3-marathon"
def run_openai_agent():
client = AsyncOpenAI(
api_key=API_KEY,
base_url="https://api.subconscious.dev/v1",
)
# Tracing would otherwise try to reach OpenAI's backend.
set_tracing_disabled(True)
# Pass an explicit Chat Completions model bound to our client. A bare
# model string would route through the MultiProvider, which treats the
# "subconscious/" segment as a provider prefix and fails.
agent = Agent(
name="Assistant",
instructions="You are a helpful assistant.",
model=OpenAIChatCompletionsModel(model=MODEL, openai_client=client),
)
result = Runner.run_sync(agent, "What is the capital of France?")
print("OpenAI Agents SDK response:")
print(result.final_output)
run_openai_agent()
```
```python Claude Agent SDK theme={null}
# The SDK reads its endpoint/credentials from env vars and drives the Claude
# Code CLI under the hood (so Node.js + the CLI must be installed). Set these
# before importing/using the SDK so the spawned CLI inherits them.
import asyncio
import os
from claude_agent_sdk import query, ClaudeAgentOptions
API_KEY = "your-api-key"
os.environ["ANTHROPIC_BASE_URL"] = "https://api.subconscious.dev"
os.environ["ANTHROPIC_AUTH_TOKEN"] = API_KEY
MODEL = "subconscious/glm-5.3-marathon"
async def run_claude_agent():
print("Claude Agent SDK response:")
options = ClaudeAgentOptions(model=MODEL)
async for message in query(
prompt="What is the capital of France?",
options=options,
):
print(message)
asyncio.run(run_claude_agent())
```
```python LangChain theme={null}
# Dependencies: langchain, langchain-openai, langchain-anthropic
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
API_KEY = "your-api-key"
MODEL = "subconscious/glm-5.3-marathon"
PROMPT = {"messages": [{"role": "user", "content": "What is the capital of France?"}]}
# ---------------------------------------------------------------------------
# OpenAI chat completions format
# ---------------------------------------------------------------------------
openai_model = ChatOpenAI(
model=MODEL,
api_key=API_KEY,
base_url="https://api.subconscious.dev/v1",
)
openai_agent = create_agent(openai_model, tools=[])
print("OpenAI format:")
print(openai_agent.invoke(PROMPT)["messages"][-1].content)
# ---------------------------------------------------------------------------
# Anthropic messages format
# ---------------------------------------------------------------------------
anthropic_model = ChatAnthropic(
model=MODEL,
base_url="https://api.subconscious.dev",
api_key="unused", # auth goes through the Bearer header below
default_headers={"Authorization": f"Bearer {API_KEY}"},
)
anthropic_agent = create_agent(anthropic_model, tools=[])
print("\nAnthropic format:")
print(anthropic_agent.invoke(PROMPT)["messages"][-1].content)
```
```typescript Vercel AI SDK theme={null}
// Dependencies: ai, @ai-sdk/openai-compatible
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";
const API_KEY = "your-api-key";
const MODEL = "subconscious/glm-5.3-marathon";
const subconscious = createOpenAICompatible({
name: "subconscious",
apiKey: API_KEY,
baseURL: "https://api.subconscious.dev/v1",
});
const { text } = await generateText({
model: subconscious.chatModel(MODEL),
system: "You are a helpful assistant.",
prompt: "What is the capital of France?",
});
console.log(text);
```
## 5. Try Streaming
You can stream responses token by token for real-time output:
```python Python (OpenAI) theme={null}
stream = client.chat.completions.create(
model="subconscious/glm-5.3-marathon",
messages=[{"role": "user", "content": "Write a haiku about programming."}],
stream=True,
)
for chunk in stream:
content = chunk.choices[0].delta.content
if content:
print(content, end="", flush=True)
```
```typescript Node.js (OpenAI) theme={null}
const stream = await client.chat.completions.create({
model: "subconscious/glm-5.3-marathon",
messages: [{ role: "user", content: "Write a haiku about programming." }],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) process.stdout.write(content);
}
```
```python Python (Anthropic) theme={null}
with client.messages.stream(
model="subconscious/glm-5.3-marathon",
max_tokens=1024,
messages=[{"role": "user", "content": "Write a haiku about programming."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
```
```typescript Node.js (Anthropic) theme={null}
const stream = client.messages.stream({
model: "subconscious/glm-5.3-marathon",
max_tokens: 1024,
messages: [{ role: "user", content: "Write a haiku about programming." }],
});
for await (const event of stream) {
if (
event.type === "content_block_delta" &&
event.delta.type === "text_delta"
) {
process.stdout.write(event.delta.text);
}
}
```
See [Streaming](/features/streaming) for more details.
## Next Steps
Real-time token-by-token output
Enable step-by-step reasoning
Full endpoint documentation
# Learn More
Source: https://docs.subconscious.dev/resources/learn-more
Explore more about our work and our team
* [Blog](https://www.subconscious.dev/blog?ref=docs): Read more from the team on our recent releases.
* [Research](https://www.subconscious.dev/research?ref=docs): Read the technical report for our release and experiment with TIM.
* **Alpha**: Alpha is Hongyin's dog. She's the best of us.
![Alpha, Hongyin's dog]()
# API
Source: https://docs.subconscious.dev/ways-to-use/cloud-api
The standard Subconscious inference endpoint
The Subconscious Cloud API is the fastest way to access our inference infrastructure. All requests go through `api.subconscious.dev`, our managed gateway that handles authentication, rate limiting, and routing.
## How It Works
Use the standard OpenAI or Anthropic SDK with no custom libraries needed
Low-latency access from anywhere
We handle scaling, reliability, and uptime
## API Keys
API keys are created and managed from your [Subconscious dashboard](https://subconscious.dev/platform/api-keys).
```python Python (OpenAI) theme={null}
from openai import OpenAI
client = OpenAI(
api_key="your-api-key", # From your dashboard
base_url="https://api.subconscious.dev/v1",
)
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
client = Anthropic(
auth_token="your-api-key", # From your dashboard
base_url="https://api.subconscious.dev",
)
```
## Billing
Usage is billed per token. See [Pricing](https://www.subconscious.dev/pricing) for current rates.
* Credits are added from your dashboard
* Usage is deducted automatically per request
* Auto-pay is available for uninterrupted service
* Usage dashboards show real-time consumption
# Dedicated Endpoints
Source: https://docs.subconscious.dev/ways-to-use/dedicated
Reserved compute with guaranteed capacity
Dedicated endpoints give your organization reserved inference capacity with guaranteed throughput, custom rate limits, and stricter isolation.
Reserved capacity with no noisy neighbors
Higher token and request limits tailored to your workload
Dedicated compute for regulated environments
## What You Get
* **Reserved GPU capacity** so your requests always have compute available, with no queuing behind other customers.
* **Custom rate limits** with token-per-minute and request-per-minute limits configured to your needs.
* **SLA guarantees** including uptime and latency commitments for production workloads.
* **Priority support** with direct access to our engineering team.
## How It Works
Dedicated endpoints use the same OpenAI- and Anthropic-compatible API, so your code doesn't change. We provision isolated compute for your organization and configure your API keys to route to dedicated infrastructure.
```python Python (OpenAI) theme={null}
from openai import OpenAI
# Same API, same SDK, just higher limits and dedicated compute
client = OpenAI(
api_key="your-api-key",
base_url="https://api.subconscious.dev/v1",
)
```
```python Python (Anthropic) theme={null}
from anthropic import Anthropic
# Same API, same SDK, just higher limits and dedicated compute
client = Anthropic(
auth_token="your-api-key",
base_url="https://api.subconscious.dev",
)
```
## Pricing
Dedicated endpoint pricing is based on reserved capacity and varies by workload. [Fill out our contact form](https://www.subconscious.dev/product/coding-agents/contact) for a quote.
Fill out our contact form to discuss your dedicated endpoint needs.
# On-prem and customer cloud
Source: https://docs.subconscious.dev/ways-to-use/on-prem
Deploy Subconscious inference in your own infrastructure
For organizations with strict data residency, compliance, or network isolation requirements, Subconscious runs in infrastructure you control.
There are two ways to do that. Start with the [On-prem overview](/on-prem/overview) for architecture, methods, and compliance.
Prompts, completions, keys, and logs stay in your environment unless you choose to share them.
API Gateway in your AWS, GCP, or Azure account, with OrangeLine on GPUs you choose.
Our team works directly with your infrastructure and security teams.
How the API Gateway, OrangeLine, and Ryvn fit together, and when to run OrangeLine alone.
## Full inference system
Ryvn deploys the API Gateway into your AWS, GCP, or Azure account. OrangeLine runs on GPUs anywhere you can run a Docker container and attaches to the gateway. This is the path that includes context pruning visualization and intelligence.
GPU examples: the same hyperscaler, NeoClouds such as Nebius, Lambda, or CoreWeave, platforms such as Together AI, Baseten, or Modal, your own local cluster, or bare metal. If you have GPUs we have not named, we can work with that.
## OrangeLine only
For trials, or if you already have a gateway, we issue registry credentials for the OrangeLine image. You run it on any GPU host. You will not get context pruning visualization and intelligence without our gateway.
## What's included
* **OrangeLine** on your GPUs, running TIMRUN.
* **OpenAI- and Anthropic-compatible API** when you deploy our gateway, with the same API you already use.
* **Monitoring** you already run, plus Ryvn status for the gateway environment.
* **Ongoing support** for updates, patches, and engineering help.
Fill out our contact form to scope your deployment.
# Privacy and security
Source: https://docs.subconscious.dev/ways-to-use/privacy
How we handle and protect your data
Security is foundational to how we build Subconscious. We treat your prompts, completions, and workflows with the highest level of care.
## Your query data is not retained
We do not store, log, or retain the content of your inference requests or responses. Prompts and completions are processed transiently to serve your request and are never persisted.
The only usage data we retain is the token-accounting metadata required to operate and bill the service: your input tokens, your output tokens, and your cached tokens.
This metadata records *how much* you used, never *what* you sent or received. We have no record of the substance of your queries, and your data is never used to train or improve models.
## Security
All API traffic is encrypted using industry-standard TLS.
API keys are issued per organization, required for every request, and revocable at any time.
Internal access to production systems is restricted to authorized personnel.
We build on a small set of established, security-conscious infrastructure providers.
## Privacy
We collect only the personal data needed to provide and support the service, such as account identity, contact details, and basic technical and usage data. You retain rights over your personal data, including access, correction, and erasure. For full details, see our [Privacy Policy](https://www.subconscious.dev/privacy) and [Security](https://www.subconscious.dev/security) pages.
## Enterprise
For organizations with additional requirements, we offer:
* **Dedicated endpoints** with isolated compute and no shared infrastructure. See [Dedicated Endpoints](/ways-to-use/dedicated).
* **On-prem deployment** to run inference in your own cloud or data center. See [On-prem](/ways-to-use/on-prem) or the [on-prem guide](/on-prem/overview).
* **Custom security reviews** with your security team.
## Contact
Found a vulnerability or have a question about our practices? Reach us at [security@subconscious.dev](mailto:security@subconscious.dev) (security) or [privacy@subconscious.dev](mailto:privacy@subconscious.dev) (privacy).