Developer Portal

Welcome to the Fivo Developer Portal. Here you'll find setup manuals, API guides, and integration schemas for routing prompts, learning programming taste, and masking sensitive client data.

1-Line Quickstart

Integrating Fivo into your active code base is as simple as updating your client's `base_url` or `baseURL` pointer. Point your existing API calls at Fivo and configure your custom API key.

# Install official OpenAI client: pip install openai
import openai

client = openai.OpenAI(
    api_key="ps_live_your_key_here",  # Fivo Workspace key prefix
    base_url="https://api.fivo.live/v1"  # Point directly to Fivo Gateway!
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",  # Optimized next-gen model class
    messages=[{"role": "user", "content": "Optimize this binary search algorithm..."}]
)

print(response.choices[0].message.content)

// Install official OpenAI client: npm install openai
const { OpenAI } = require('openai');

const openai = new OpenAI({
  apiKey: 'ps_live_your_key_here',
  baseURL: 'https://api.fivo.live/v1' // Point directly to Fivo Gateway!
});

async function run() {
  const response = await openai.chat.completions.create({
    model: 'deepseek-v4-pro',
    messages: [{ role: 'user', content: 'Optimize this binary search algorithm...' }],
  });
  console.log(response.choices[0].message.content);
}

run();

curl -X POST https://api.fivo.live/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "x-fivo-api-key: ps_live_your_key_here" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [{"role": "user", "content": "Optimize this binary search algorithm..."}]
  }'

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/sashabaranov/go-openai"
)

func main() {
	config := openai.DefaultConfig("ps_live_your_key_here")
	config.BaseURL = "https://api.fivo.live/v1"

	client := openai.NewClientWithConfig(config)
	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: "deepseek-v4-pro",
			Messages: []openai.ChatCompletionMessage{
				{
					Role:    openai.ChatMessageRoleUser,
					Content: "Optimize this binary search algorithm...",
				},
			},
		},
	)

	if err != nil {
		log.Fatalf("ChatCompletion error: %v\n", err)
	}

	fmt.Println(resp.Choices[0].Message.Content)
}

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .post("https://api.fivo.live/v1/chat/completions")
        .header("Content-Type", "application/json")
        .header("x-fivo-api-key", "ps_live_your_key_here")
        .json(&json!({
            "model": "deepseek-v4-pro",
            "messages": [{"role": "user", "content": "Optimize this binary search algorithm..."}]
        }))
        .send()
        .await?
        .json::<serde_json::Value>()
        .await?;

    let content = &response["choices"][0]["message"]["content"];
    println!("Response: {}", content);
    Ok(())
}

Fivo Gateway: Intelligent Routing

Fivo Gateway operates as an in-transit secure router sitting directly between your applications and 8+ major next-generation model architectures.

Every incoming prompt is instantly evaluated for semantic caching availability and provider latency baseline. When Fivo detects a repetitive developer workload–”such as structural parsing, automated code analysis, or database query generation–”it serves the response directly from our local memory caching tier in less than 50ms.

This bypasses the model provider entirely, retaining 99%+ quality while reducing expenditures up to 25x.

Next-Gen Model Support

Fivo routes incoming requests dynamically across high-performance next-generation models from major providers, ensuring the lowest latency and optimal cost.

Fivo Connect: Self-Hosted Service

Fivo Connect operates completely inside your secure server or private cloud boundary as a zero-dependency self-hosted service to run a high-throughput proxy local port.

Connect automatically scans your prompt bodies for credit card numbers, passwords, API tokens, patient names (HIPAA PHI), and financial identifiers, replacing them in-flight with **structured placeholders** before payloads reach public LLMs.

Boot and Execution Command

Launch the service on your host environment:

# Grant execution permissions and run
chmod +x fivo-connect-linux
./fivo-connect-linux --config fivo-connect.config.json

✅ FIVO Connect listening on http://localhost:9090

# Launch the service securely via PowerShell
.\fivo-connect-win.exe --config fivo-connect.config.json

✅ FIVO Connect listening on http://localhost:9090

Masking REST API

Interact with the Fivo Connect service programmatically using high-performance HTTP REST endpoints. Obfuscate source code or text via `/api/enhance`, and revert generated LLM responses via `/api/reverse`.

import requests

# Step 1: Mask the sensitive prompt body
payload = {"prompt": "Our secret token is 'API_KEY_123' and database is db_prod"}
mask_res = requests.post("http://localhost:9090/api/enhance", json=payload).json()
print(mask_res["enhanced"]) 
# Output: "Our secret token is '[MASKED_CRED_01]' and database is [MASKED_DB_01]"

# Step 2: Send safe masked prompt to the LLM (represented here)
llm_reply = "We validated [MASKED_CRED_01] connection on database [MASKED_DB_01] successfully."

# Step 3: Revert placeholder values to retrieve real values locally
revert_res = requests.post("http://localhost:9090/api/reverse", json={"text": llm_reply}).json()
print(revert_res["reversed"])
# Output: "We validated 'API_KEY_123' connection on database db_prod successfully."

// Step 1: Obfuscate
const maskRes = await fetch('http://localhost:9090/api/enhance', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ prompt: "Secret key: 'ACC_987654321' belongs to John Doe" })
}).then(r => r.json());

console.log(maskRes.enhanced);
// Output: "Secret key: '[MASKED_KEY_01]' belongs to [MASKED_USER_01]"

// ... Send obfuscated output to LLM and receive answer ...
const llmResponse = "Authorized key [MASKED_KEY_01] for profile [MASKED_USER_01] in-flight.";

// Step 2: Restore real text
const realRes = await fetch('http://localhost:9090/api/reverse', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ text: llmResponse })
}).then(r => r.json());

console.log(realRes.reversed);
// Output: "Authorized key 'ACC_987654321' for profile John Doe in-flight."

Compliance Boundaries & Data Transit

Traditional data masking tools rely on external third-party cloud engines, forcing sensitive source code or customer data to leave your network. Fivo Connect establishes a clean, local protection boundary.

Because Fivo Connect executes **entirely within your self-hosted infrastructure** (VPC, local workstation, or private node), all raw prompt content, passwords, and patient names are intercepted and masked before any external call is initiated. This zero-retention transit layout ensures that raw payloads never reach public AI systems, preserving your existing compliance parameters.

Fivo Mind: Reasoning Architecture

Fivo Mind is the next-generation ground-up reasoning model built directly into the Fivo local-first ecosystem. Designed for deep multi-step verification and self-correction, Fivo Mind provides extreme accuracy on complex programming and mathematical tasks while adhering strictly to zero-leak security principles.

Key Architecture Features

• Reasoning-First Verification: Evaluates logic paths, plans structures, and runs self-checks before returning code or mathematical tokens.
• Zero-Leak VPC Bounds: Inherits Fivo Connect's masking architecture, meaning prompts and intellectual property are parsed locally inside your infrastructure.
• Deep Fivo Tool Integration: Plugs directly into Fivo Gateway for prompt caching.

Join the Waitlist

We are currently selecting team pilots for private alpha integrations. To join the waitlist and gain early access to custom deployments, contact us at hello@fivo.live.

Fivo Mind: Internal Evaluation Benchmarks

During our internal testing cycles, Fivo Mind models demonstrated exceptional accuracy indexes compared to public models, particularly under maximum thinking configurations.

Speed, Latency & Cost Index Comparison

Reasoning verification increases latency but delivers significantly higher solution accuracy. Fivo Mind Pro targets mid-tier reasoning pricing, offering high-performance coding outputs at a lower cost than competitor frontier models.

Fivo CLI Overview

Fivo CLI is an AI coding host with a 10M+ context window, long-running memory, and predictable cost per turn. It remembers your code, conversations, and decisions across sessions without manual context management.

Key Capabilities

• Extended context window for large codebases and long conversations
• Memory store that persists across coding sessions
• Relevant recall brings back important prior work automatically
• Lean output mode keeps terminal output focused and readable
• Safety guard protects against risky actions

Fivo Fuse Overview

Fivo Fuse automatically tunes model runs for better speed, lower memory usage, and simpler setup. It generates optimized configurations so you can run larger workloads on limited hardware.

Key Benefits

• Hardware-aware setup that matches your machine capabilities
• Lower memory pressure for long-context or large-model workloads
• Faster responses with automatic optimization settings
• Reusable configurations across your team

API Reference Definition

Fivo's endpoints follow strict REST API designs. Standard structures for payload exchanges are outlined below.

1. Gateway Route: `/v1/chat/completions`

Acts as a drop-in proxy replacement for OpenAI Chat Completions requests (authenticate using header x-fivo-api-key with your workspace ps_live_ key).

{
  "model": "deepseek-v4-pro | claude-opus-4.8 | gpt-5.5-ultra | gemini-3.5-flash",
  "messages": [
    {
      "role": "system",
      "content": "System prompt..."
    },
    {
      "role": "user",
      "content": "User inquiry prompt..."
    }
  ],
  "temperature": 0.7,
  "max_tokens": 1024
}

2. Fivo Connect: `/api/enhance`

Send text containing raw PHI/PII/sensitive code, receive masked placeholder text.

// POST http://localhost:9090/api/enhance
{
  "prompt": "Sensitive data to mask..."
}

// Returns HTTP 200 OK
{
  "status": "success",
  "enhanced": "Masked data [MASKED_VAR_01] here...",
  "tokens_replaced": 1
}

3. Fivo Connect: `/api/reverse`

Send text containing placeholders, receive the original sensitive values restored locally.

// POST http://localhost:9090/api/reverse
{
  "text": "Response with placeholders [MASKED_VAR_01] to restore..."
}

// Returns HTTP 200 OK
{
  "status": "success",
  "reversed": "Original sensitive response restored successfully...",
  "tokens_restored": 1
}