FAQ & Knowledge Base

Fivo operates as an in-transit secure reverse proxy layer positioned between client applications and downstream Large Language Model (LLM) providers. It translates OpenAI, Anthropic, and generic API schemas in real-time, executing optimization (caching, latency optimization, failovers) and compliance masking before payloads exit the user's secure network bounds.

No. Fivo is built on a strict zero-payload persistence framework. Prompts and generation responses are parsed and processed entirely in volatile memory (RAM) and streamed to the caller. Payload data is never committed to persistent disk storage or central logs unless the developer explicitly opts in to a secure local auditing buffer.

Managed cloud gateways are deployed in three geographic regions: United States (US-East), European Union (Frankfurt), and Asia-Pacific (Mumbai). Payloads are routed strictly within the regional boundaries selected at the workspace level, maintaining compliance with local regulations like GDPR or CCPA.

Yes. The Fivo Cell daemon is designed to run 100% locally on a developer's workstation. The Fivo Connect service operates as a self-hosted binary executable on Linux, macOS, or Windows servers inside your private cloud (VPC), allowing complete data masking without external telemetry.

The Gateway evaluates incoming prompt structures against a high-speed, local response cache. If a match is detected, the Gateway immediately serves the response from memory in less than 50ms, bypassing downstream provider APIs completely. This reduces expenditures while retaining quality.

Fivo Gateway monitors downstream provider latency baselines in real-time, routing your queries to the fastest active endpoints. This ensures that response generation remains highly responsive and cost-effective without adding infrastructure overhead.

Fivo Gateway monitors provider status codes, latency thresholds, and connection timeouts. If a model provider returns a 5xx error, drops connection sockets, or triggers rate-limit exceptions, Fivo Gateway automatically redirects active request streams to secondary models specified in your routing policies in <1000ms.

Yes. Fivo translates function calling schemas, tool declarations, and server-sent event (SSE) stream objects. It normalizes inputs and outputs between the OpenAI format and Anthropic format, allowing developers to switch between GPT and Claude models without modifying application-level parsing scripts.

The Fivo Cell CLI (cell) is a lightweight local daemon written in Node.js/Go that tracks developer interactions, accepts, and edits on local workspace directories. It acts as a Model Context Protocol (MCP) server that interfaces directly with IDE code assistants (Cursor, VS Code, Windsurf, Claude Code) to align code generation with local design specifications.

Fivo Cell operates entirely offline on your local workstation. It monitors simple development events, such as accepted edits and formatting adjustments, to build a secure local style profile. It never reads or transmits raw code files, protecting your IP at all times.

You can configure exclusions inside your project's local cell.json file under the exclude_patterns parameter. It supports standard glob layout arrays:

"exclude_patterns": [
  "**/node_modules/**",
  "**/dist/**",
  "**/.git/**"
]

When Claude Desktop connects to Fivo Cell via the Model Context Protocol, the daemon registers context tools. Whenever a code question is submitted, the MCP tool automatically feeds active style preferences as system prompt templates, coercing the output to align with your formatting rules.

No. Your local database and workspace configurations remain strictly on your workstation. Only encrypted style preferences and configuration rules are synchronized with Fivo Cell Cloud. Raw code files, inputs, and logs are never uploaded.

Cell Cloud profile payloads are encrypted on your local machine using industry-standard protocols before transport. Decryption keys remain under your control, transport is protected by secure transmission protocols, and cloud storage uses isolated tenant environments.

New style changes are synchronized across active, authorized IDE terminals within 200ms of adjustments.

Run cell cloud off in your CLI. This terminates active WebSocket loops, clears local cloud keys, and restricts the Cell daemon to a local SQLite-only mode. Run cell purge to wipe all local records.

Fivo Connect is compiled as a self-hosted, high-throughput binary proxy designed to be run within VPC servers, Kubernetes clusters, or local workstation loops. It acts as an entry gate that filters code leaks, PII, and financial identifiers before they hit external networks.

Fivo Connect runs 21 parallel scanning engines covering PII (Social Security Numbers, phone numbers, emails), PHI/HIPAA (Patient names, birth dates, MRNs), Financials (Credit cards, IBANs, bank codes), and sensitive configuration credentials.

When a prompt is processed, Fivo Connect replaces sensitive values with anonymous tokens (e.g. [MASKED_VAR_01]) and stores the replacement maps in-memory with a strict TTL matching the transaction. When the LLM provider streams the response, Connect replaces tokens back in-flight. The lookup table is immediately purged from RAM once the transaction completes.

Define them inside the custom_regex_filters array in fivo-connect.config.json:

"custom_regex_filters": [
  {
    "name": "INTERNAL_DB_NAME",
    "pattern": "db_prod_[a-z0-9]+",
    "placeholder": "[MASKED_PRODUCTION_DB]"
  }
]

Because it is built using zero-copy networking streams and written in low-level compiled code, Fivo Connect handles up to 100,000 concurrent request pipelines per region. It adds less than 3ms of overhead to the transaction lifecycle.

Fivo Mind is our next-generation local reasoning engine designed for deep multi-step verification and self-correction. It runs inside your secure infrastructure bounds to ensure high accuracy on complex programming and mathematical tasks while maintaining zero-leak data privacy.

Fivo Mind performs step-by-step logic verification and self-correction before outputting responses. It parses queries locally and coordinates with Fivo Gateway and Fivo Cell to align outputs with your workspace configurations.

We evaluate Fivo Mind (optimized for developer workstation setups) and Fivo Mind Pro (optimized for self-hosted server deployments). Under internal evaluations, these models demonstrate high accuracy indices on SWE-bench and other programming benchmarks.

Yes. Fivo Mind can coordinate with standard command-line linters and syntax checkers configured in your local environment, ensuring that generated code adheres to local build and style guidelines before completion.

No. In BYOK mode, Fivo does not charge per-token markups on downstream provider fees. You pay the model providers directly using your own keys. Fivo is billed as a flat membership tier based on team seats or routed requests limits.

You can generate, rotate, or revoke ps_live_ API keys directly through the Cell Cloud developer console. Revocations propagate globally across all active gateways within 5 seconds.

Your configurations, key pairs, and style profiles are fully portable. You can download your cell.json and style profile at any time. Because integration requires changing only one URL line, migrating back to direct provider calls takes less than 5 minutes.

Fivo standard developer profiles carry a 99.9% service availability SLA. Enterprise tiers include a 99.95% SLA with custom credits for downtime.

Reach out directly to hello@fivo.live. Free tier users are supported via our public Discord community and GitHub issue trackers.