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/compat/openai/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/compat/openai/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/compat/openai/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/compat/openai/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/compat/openai/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 Cell: CLI Installation

Fivo Cell is a tiny local daemon designed to learn your coding taste, style preferences, and structure patterns. It runs 100% offline, free forever, with zero dependencies on third-party cloud engines.

Setup the Cell CLI via npm in less than 30 seconds:

# Install Cell globally via npm
npm i -g fivocell

# Initialize Fivo Cell configuration
cell init

# Boot up the offline daemon
cell daemon start

# Query the active daemon states and metrics
cell status

🧠 FIVO Cell Status
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Daemon:        ✅ Running (localhost:9876)
VS Code:       ✅ Installed
Cursor:        ✅ Installed
Windsurf:      ✅ Installed
Claude Code:   ✅ MCP configured (5 tools)
Codex CLI:     ✅ MCP configured
Shell Hook:    ✅ Active
Copilot Sync:  ✅ Active
Modules:       40 loaded
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

# Turn cloud telemetry sync OFF (enforces 100% offline local-only mode)
cell cloud off

# Re-enable cloud aggregate telemetry sync anytime
cell cloud on

# Completely uninstall the global daemon and purge local caches
npm uninstall -g fivocell
rm -rf ~/.fivo/cell

Fivo Cell CLI Commands Reference

Manage your local learning daemon, custom preferences, and synchronization channels using the Fivo Cell CLI utility.

Cell Taste Learning Profile

As you write and edit code, Fivo Cell monitors simple workflow events–”such as diff accepts, edits, and retries–”across your IDE surfaces (VS Code, Cursor, Windsurf, or Claude Code). It learns how you organize and refine AI-generated solutions.

Cell organizes these preferences into a secure local style index stored completely on your workstation. When you invoke AI prompts in any connected tool, Cell dynamically overlays these stylistic preferences onto your outgoing requests in transit.

This guarantees that your unique taste and formatting preferences are maintained consistently across all coding assistants, automatically.

IDE Extensions & MCP Configuration

Fivo Cell exposes standard Model Context Protocol (MCP) integrations to extend your taste profile straight to modern CLI tools.

Claude Desktop Config

Add the Fivo Cell MCP handler by inserting this block into your standard `~/.claude/claude_desktop_config.json` configuration:

{
  "mcpServers": {
    "fivo-cell": {
      "command": "cell",
      "args": ["mcp", "start"]
    }
  }
}

Fivo Cell Cloud: Connection

Fivo Cell Cloud serves as the managed sync engine for your local Fivo Cell daemon. Connect your workstation to sync coding preferences, style templates, and context profiles across all your development machines.

Local Authentication Setup

Follow these 3 simple steps to authenticate your local daemon with the Fivo Cell Cloud:

# Start your local daemon (ensure it is running)
cell run

# Authenticate using your cloud account access token
cell login tokens_cl_prod_abc123

🔓 Authenticated successfully with Fivo Cell Cloud!
Profile: developer@fivo.live
Sync status: Ready

# Stream local developer taste updates to the cloud in real-time
cell watch start

📡 Cell watch started. Monitoring editor files...
🔄 Local SQLite snapshot synced to cloud database.
[Active Session] 14 diff adjustments captured.

Under the Hood: Taste Sync Security

Fivo Cell Cloud synchronizes coding preferences using a zero-knowledge local-first architecture. It compiles abstract style attributes into secure signatures encrypted on your workstation before transfer, ensuring that raw code content is never transmitted.

Cell Cloud 12-Page Dashboard

Once connected, Fivo Cell Cloud provides a comprehensive 12-page web dashboard to manage, visualize, and review your AI memory and coding vibe profiles.

Sync & Telemetry Rules

Fivo Cell Cloud prioritizes local-first privacy. Your workstation's local SQLite database is the primary source of truth, and data is only synced to the cloud if explicitly authorized.

Controlling Telemetry States

Toggle sync behavior directly from your command line:

# Disable all cloud sync telemetry (forces 100% offline local-only SQLite mode)
cell cloud off

# Enable aggregate sync telemetry anytime
cell cloud on

# Force manual snapshot push to cloud companion
cell sync push

Cloud Scaling & Limits

• Encryption: Snapshot transport payloads are encrypted in-transit via TLS 1.3 and stored with AES-256 encryption.
• API Throttling: Free personal accounts are capped at a rate of 60 requests/minute.
• Offline Buffer: If your network disconnects, local Cell buffers snapshot updates and syncs them automatically once connectivity is restored.

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 and Fivo Cell for developer-vibe alignment.

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.

API Reference Definition

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

1. Gateway Route: `/v1/compat/openai/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
}