Network Online
OpenAI-Compatible P2P AI Network

Run AI at Scale on the
OriginOfAI

The decentralized P2P compute platform for AI inference. Connect idle GPUs, stream low-latency LLM responses, and earn Tensor Credits for every token you serve.

GPU NODES 0
TOKENS SERVED 0
AVG LATENCY < 12ms
ORIGIN-OF-AI // LIVE DEMO
Node #4090-Tokyo
LATENCY 11 ms
SPEED 142.5 tok/s
STREAM BW
Click button below to trigger real-time simulated P2P AI inference request token streaming...
LIVE MESH
⚡ P2P INFERENCE GRID ACTIVE • 99.98% UPTIME • 🌐 LATENCY: 9.8 ms SUB-SECOND RPC • 💎 PROOF-OF-INFERENCE PAYOUT RATE: 100% AUTOMATED TC • 🚀 MOST POPULAR MODEL: DEEPSEEK-R1-DISTILL-32B • ⚡ P2P INFERENCE GRID ACTIVE • 99.98% UPTIME • 🌐 LATENCY: 9.8 ms SUB-SECOND RPC • 💎 PROOF-OF-INFERENCE PAYOUT RATE: 100% AUTOMATED TC
SUPPORTED MODELS

Open-Weights LLM Runtimes

Instant token streaming across distributed VRAM clusters — fully OpenAI-compatible

Reasoning 24GB VRAM

DeepSeek R1 Distill

State-of-the-art chain-of-thought reasoning model optimized for code synthesis and complex math.

Speed 145 tok/s
Latency 10 ms
General Purpose 32GB VRAM

Qwen 2.5 72B Instruct

High-capacity multilingual model delivering sub-second response times across P2P node networks.

Speed 118 tok/s
Latency 12 ms
Enterprise 48GB VRAM

Llama 3.3 70B Turbo

Meta's premier open weights model accelerated with FP8 quantization and tensor parallel execution.

Speed 130 tok/s
Latency 9 ms
Lightweight 8GB VRAM

Mistral Small 24B

Hyper-fast local inference runner designed for low-power desktop GPU hosting nodes.

Speed 195 tok/s
Latency 7 ms
PLATFORM CAPABILITIES

Engineered for Ultra-Fast P2P AI Compute

Decentralized infrastructure supporting low-latency model execution across distributed compute clusters

Low-Latency RPC Routing

Smart WebSocket RPC routing automatically assigns prompt tasks to nearest idle GPU nodes for sub-millisecond response initiation.

Tensor Credit Economy

Proof-of-Inference ledger automatically credits compute providers in real-time as nodes process inference tokens.

100% OpenAI API Compatible

Drop-in replacement for OpenAI endpoints (/v1/chat/completions). Connect standard LLM clients with your developer secret key.

Desktop Node Hosting

One-click native desktop client (P2PInferenceNode) enables Windows & Linux GPU owners to join the compute grid.

Confidential Payload Chunking

End-to-end payload chunking with zero storage of user prompt buffers across compute provider runtimes.

Multi-Model Mesh VRAM

Dynamic VRAM pooling allocates heavy 70B+ parameters across distributed GPU clusters effortlessly.

INTEGRATION MATRIX

Unified Developer Endpoint

Connect any LLM client or application using standard OpenAI client libraries

main.py 
import openai

client = openai.OpenAI(
    base_url="http://localhost:49290/v1",
    api_key="obai_sec_YOUR_API_KEY"
)

response = client.chat.completions.create(
    model="deepseek-r1",
    messages=[{"role": "user", "content": "Hello OriginOfAI!"}],
    stream=True
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="")
request.sh 
curl -X POST "http://localhost:49290/v1/chat/completions" \
  -H "Authorization: Bearer obai_sec_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1",
    "messages": [{"role": "user", "content": "Explain P2P inference"}],
    "stream": true
  }'
index.js 
import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'http://localhost:49290/v1',
  apiKey: 'obai_sec_YOUR_API_KEY',
});

const stream = await openai.chat.completions.create({
  model: 'qwen-2.5',
  messages: [{ role: 'user', content: 'Generate async handler' }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}
OriginOfAI GPU Compute Node
DISTRIBUTED COMPUTE ARCHITECTURE

Empowering Decentralized Intelligence

OriginOfAI dynamically balances workloads across a peer-to-peer mesh of compute providers running local quantized LLM runtimes (Llama 3, Qwen 2.5, DeepSeek R1).

  • ✓ Automatic node discovery & latency-optimized job matching
  • ✓ End-to-end payload encryption & secure RPC execution
  • ✓ Real-time telemetry monitoring node status, temperature & VRAM
SIMPLE 3-STEP PIPELINE

How the Platform Works

Three steps to compute, host, or integrate with OriginOfAI Network

01

Connect Node or Create Account

Sign up to generate developer access keys or download the desktop node client to host GPU compute power.

02

Manage Keys & Tensor Credits

Access your User Dashboard to configure API secret keys, manage billing plans, and monitor your TC ledger.

03

Stream AI & Earn Rewards

Send standard REST/WebSocket completion requests to the network while compute providers receive automated TC payouts.

Ready to Supercharge Your AI Workloads?

Join the OriginOfAI Network today — build scalable AI applications or earn credits hosting compute nodes.

User Dashboard

Account Console
👤

Loading Profile...

ACTIVE
@-- • --

Tensor Credits & Activity Metrics

Real-time compute balances & execution metrics
Available TC
0.0000 TC
Ready for P2P model inference
Locked TC
0.0000 TC
Reserved in active compute jobs
Total Requests
0
Lifetime API inference calls
User Status
ACTIVE
Verified network status

Synchronized Account Details

OriginOfBots profile metadata
Display Name
--
Username
--
Email
--

My Connected Compute Nodes

0 Attached Nodes

Host Compute Node via OriginLink

Download the OriginLink desktop app to share your GPU/RAM compute power with the network, run distributed AI inference jobs, and earn Tensor Credits (TC).

Attached Compute Roster

Node ID / Name IP / Socket Hardware / VRAM Completed Jobs TC Earned Status
No compute nodes currently attached to your account. Download OriginLink App to connect your GPU.

API Key Management

Your Keys

Key Name API Key Created At Last Used Status Actions
Loading API keys...

Quick Start Integration

cURL Request Example 
curl -X POST http://localhost:49290/v1/chat/completions \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "Hello OBAI Node Network!"}],
    "stream": true
  }'

Tensor Credits (TC) Ledger

⚡ 0.0000 TC
Available Balance
⚡ 0.0000 TC
Ready for model inference
Lifetime Earned
0.0000 TC
Earned hosting compute nodes
Total Requests
0
Lifetime API requests

Tensor Credit Activity History

Timestamp Transaction Type Amount (TC) Description / Reason
No credit transactions recorded yet.

Personal Telemetry & Request History

Telemetry Active
Completion Success Rate
100%
Successful inference completions
Avg Latency / Throughput
-- t/s
Tokens per second execution speed

Recent Request Traces

Request ID Timestamp Assigned Node Tokens Status
No personal request traces recorded yet.

Admin Console

System Orchestrator
SYSTEM ADMINISTRATOR CONSOLE

OriginOfAI Cluster Orchestrator

Real-time network telemetry, peer node pool monitoring, API execution testing, and global user permissions management.

Manage Model Catalog ↗
Active Cluster Nodes
0
Online GPU host peers
Global Job Queue
0
Pending RPC tasks
Total Cluster Requests
0 / 0
Completed / Lifetime calls
Tokens Processed
0
Total generated tokens
WORKBENCH

Cluster Inference Playground

Admin Test Hub
256
Stream Output Tokens in Real-Time Receive tokens character-by-character via WebSocket RPC
tokens_stream.log
IDLE
Playground terminal ready.
Write a prompt on the left and click "Execute Inference Stream" to test token execution.
⚡ Speed: -- t/s
⏱️ Duration: -- ms
🌐 Assigned Node: None

Nodes Pool Summary

0 Online
Node ID Endpoint / Address Jobs Status
No peer nodes registered.

Network Event Log

Real-Time
Timestamp Request ID Node Tokens Status
No activity logged yet.

Distributed P2P Attached Nodes Directory

Complete compute node roster connected via OriginOfAI WebSocket RPC orchestrator

0 Nodes Active
Node UUID / Name Location Hardware / Specs Completed Jobs Worker TC (80%) Platform Cut (20%) Status
Loading connected cluster nodes...

Registered Network Users Directory

Manage registered platform accounts, privileges, and access rights

0 Registered Users
User / Display Name Email Role Tensor Credits Status Actions
Loading registered users...
v1.0 REST API OpenAI API Compatible Cluster Online (Port 49290)

OriginOfAI Developer Documentation

Build AI applications & connect autonomous agents to the decentralized P2P compute orchestrator.

Live API Sandbox

1. Architecture & Overview

Zero Setup Required

The OriginOfAI Orchestrator API provides an OpenAI-compatible REST interface for executing LLM inference across distributed P2P worker nodes. You can seamlessly swap OpenAI endpoint configurations with your local OriginOfAI gateway proxy endpoint.

⚡

Base Gateway Endpoint

http://localhost:49290/v1

Local proxy endpoint routing requests to available high-speed P2P GPU nodes.

🔄

OpenAI SDK Drop-in

base_url="http://localhost:49290/v1"

Supports official OpenAI Node.js, Python, and LangChain packages out-of-the-box.

2. Authentication Standard

Bearer Token Authorization

All private API endpoints require your secret developer key passed via the standard HTTP Authorization header:

HTTP Authorization Header 
Authorization: Bearer sk-obai-your-api-key-here
Need an API Key? You can generate developer API keys from the Developer Keys Dashboard or request keys via /v1/auth/keys.

3. Multi-Language SDK Code Examples

6 Popular Languages

Select your language or HTTP library below to view copy-ready integration examples:

Node.js / TypeScript • npm install openai 
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'http://localhost:49290/v1',
  apiKey: 'sk-obai-your-api-key-here',
});

async function main() {
  const stream = await client.chat.completions.create({
    model: 'qwen2.5-0.5b',
    messages: [
      { role: 'system', content: 'You are a helpful OBAI network assistant.' },
      { role: 'user', content: 'Explain decentralized AI compute in two sentences.' }
    ],
    stream: true,
  });

  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content || '');
  }
}

main();
Python • pip install openai 
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:49290/v1",
    api_key="sk-obai-your-api-key-here"
)

response = client.chat.completions.create(
    model="qwen2.5-0.5b",
    messages=[
        {"role": "system", "content": "You are an AI assistant."},
        {"role": "user", "content": "How do P2P compute nodes handle inference?"}
    ],
    stream=False
)

print(response.choices[0].message.content)
Python • pip install requests 
import requests

url = "http://localhost:49290/v1/chat/completions"
headers = {
    "Authorization": "Bearer sk-obai-your-api-key-here",
    "Content-Type": "application/json"
}
payload = {
    "model": "qwen2.5-0.5b",
    "messages": [
        {"role": "user", "content": "Hello OBAI Node Network!"}
    ]
}

res = requests.post(url, json=payload, headers=headers)
print(res.json())
cURL HTTP Shell 
curl -X POST http://localhost:49290/v1/chat/completions \
  -H "Authorization: Bearer sk-obai-your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-0.5b",
    "messages": [{"role": "user", "content": "Hello from cURL!"}],
    "stream": true
  }'
Go HTTP Standard Library 
package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "http://localhost:49290/v1/chat/completions"
    jsonStr := []byte(`{"model":"qwen2.5-0.5b","messages":[{"role":"user","content":"Hello OBAI Go!"}]}`)
    
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
    req.Header.Set("Authorization", "Bearer sk-obai-your-api-key-here")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil { panic(err) }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
Rust • reqwest crate 
use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = reqwest::Client::new();
    let res = client.post("http://localhost:49290/v1/chat/completions")
        .header(AUTHORIZATION, "Bearer sk-obai-your-api-key-here")
        .header(CONTENT_TYPE, "application/json")
        .body(r#"{"model":"qwen2.5-0.5b","messages":[{"role":"user","content":"Hello Rust!"}]}"#)
        .send()
        .await?
        .text()
        .await?;

    println!("{}", res);
    Ok(())
}

4. Core API Endpoints Reference

REST & SSE Streaming
POST /v1/chat/completions Bearer Key Required

Executes AI model chat inference across active compute nodes. Supports SSE streaming and standard JSON responses.

Request Body Parameters
Field Type Status Description
model string Required Target model identifier (e.g. qwen2.5-0.5b, llama-3.2-3b).
messages array Required Array of message objects: [{"role": "user", "content": "..."}].
stream boolean Optional If true, returns Server-Sent Events (SSE) stream. Default: false.
temperature number Optional Sampling temperature between 0.0 and 2.0. Default: 0.7.
GET /v1/models Public / Free

Lists all available AI models registered by active worker nodes on the OBAI network.

GET /v1/health Public / Free

Returns Orchestrator server status, system uptime, and database connectivity checks.

GET /api/nodes Public / Free

Fetches live P2P node mesh telemetry, total connected compute nodes, VRAM, and load status.

GET /api/stats Public / Free

Aggregated network throughput statistics, total tokens generated, and active requests per minute.

GET /v1/auth/keys Bearer Key Required

Returns list of active developer API keys belonging to the authenticated account.

5. Response Payload Specs & Errors

Standard HTTP Status Codes

Sample JSON Response (200 OK)

Chat Completion Response 
{
  "id": "chatcmpl-obai-89a1f2",
  "object": "chat.completion",
  "created": 1722256000,
  "model": "qwen2.5-0.5b",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Decentralized AI compute routes inference tasks across P2P GPU nodes."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 12,
    "total_tokens": 26
  }
}

HTTP Status Code & Error Reference

Status Error Code Description
200 OK SUCCESS Request completed successfully.
400 Bad Request BAD_REQUEST / INVALID_MODEL Missing or malformed required fields in payload or invalid model.
401 Unauthorized UNAUTHORIZED / AUTH_FAILED Missing, expired, or invalid Authorization header API key / JWT token.
402 Payment Required INSUFFICIENT_TC Insufficient Tensor Credits (TC) balance. Connect a compute node to earn TC or top up your balance.
429 Rate Limited RATE_LIMITED Request rate limit exceeded. Slow down API invocation frequency.
500 Internal Error INTERNAL_ERROR / NODE_TIMEOUT Internal orchestrator exception, GPU out-of-memory, or worker node processing timeout.
503 Unavailable NODE_OFFLINE / NO_NODES_ONLINE No active compute nodes online for requested model, or worker node disconnected mid-stream.

⚡ Live API Tester Sandbox

Interactive API Playground

Execute live test queries directly against your local OBAI Orchestrator gateway (`http://localhost:49290`):

Response Output Ready 
{
  "info": "Click 'Send Test Request' to view live response output..."
}