Pricing

Dual-Track, Developer-Friendly Pricing

Start free with the full core engine. Scale solo productivity with MCP Pro & Max. Move to per-project pricing for infrastructure-scale teams.

Prices shown in USD. Billed in ZAR at the current exchange rate.

MCP Dev-Tool Track — flat monthly

Community

Free

Full core engine for solo developers.

  • 100+ MCP tools
  • Local ONNX embeddings (zero API calls, works air-gapped)
  • Hybrid search — vector + BM25 + reciprocal rank fusion
  • Knowledge graphs with 8 entity types and 5 graph tools
  • Context branching, snapshots, timeline replay
  • Memory consolidation + half-life decay
  • RAG indexing for files and directories
  • Skill library — search & retrieve
  • One file per agent (portable .avdb)
  • Bug reports via GitHub Issues (no SLA)
Get Started
Most Popular

MCP Pro

$19/mo

Individual power users — testing, baselines, skill publishing.

  • Everything in Community, plus:
  • Agent testing suite — YAML scenarios with IR metrics (precision, recall, F1)
  • Baselines & regression checks
  • Side-by-side agent benchmarking
  • Skill library publishing (publish, deprecate, sync, ingest)
  • Email support (24h response)

MCP Max

$39/mo

Small teams — shared memory, conflict detection, workflows.

  • Everything in MCP Pro, plus:
  • Team memory — FULL / PROTECTED / ISOLATED sharing modes
  • Cross-agent conflict detection (regex negation patterns, severity levels)
  • Team-wide search, dispatch, and feed
  • Team workflows, personas, and consolidation
  • Email support (24h response)

Infrastructure Track — per-project

Team

$49/project/mo

A single hosted phorvec instance for your whole team.

  • Everything in MCP Max, plus:
  • Centrally hosted deployment — one phorvec instance for the whole team
  • Shared team sync — every developer's MCP client reads/writes the same memory state
  • Single license per project (no per-individual seats to manage)
  • Priority email support (next business day)
  • Quarterly product roadmap input

Enterprise

Custom

Multi-agent inference, fleet operations, and embedded deployment.

  • Everything in Team, plus:
  • Multi-agent inference:
  • Cross-agent insight discovery (DRE) — find connections between agents
  • Geometric failure recovery — agents reroute away from failure embeddings
  • Compute governance — typed token budgets and per-agent allocation
  • Fleet operations:
  • Agent health monitoring (6 EMA metrics, fleet view)
  • Fleet-wide intervention orchestration
  • Org-wide pattern sharing and retention sweeps
  • Security & compliance:
  • Append-only JSONL audit trail with correlation IDs and structured error chains
  • Secret detection (reject / redact policies)
  • RBAC + API key auth
  • Storage repair & integrity verification
  • Deployment rights:
  • Air-gapped operation with offline-verifiable license files
  • Embedded deployment (drones, vehicles, robots, edge devices)
  • OEM redistribution bundled with your hardware
  • Support:
  • SLA-backed support (1h / 4h / 24h tiers)
  • Onboarding & integration engineering
Contact Sales

Detailed Feature Comparison

FeatureCommunityMCP ProMCP MaxTeamEnterprise
Core Engine
100+ MCP tools
Vector storage + hybrid search
Knowledge graphs with entity extraction
Context branching, snapshots, timeline
Memory consolidation + half-life decay
RAG indexing (file & directory)
Vector quantization (Float32/Int8/Binary)
Local ONNX embeddings (no API calls)
Secret detection at write time
Agent Testing & Skills
Agent testing suite (YAML scenarios)
Baselines & regression checks
Agent benchmarking
Skill library (publish, sync, ingest)
Multi-Agent Collaboration
Team memory (FULL/PROTECTED/ISOLATED)
Conflict detection across agents
Cross-agent search and dispatch
Team workflows
Team personas & skills
Licensing & Deployment
Local install (per-developer binary)
Centrally hosted instance (whole team)
Shared team sync (one memory state)
Per-individual licensing
Per-project licensing (whole team covered)
Air-gapped operation (no API calls)
Offline-verifiable license files
Embedded deployment rights (OEM)
Multi-Agent Inference
Cross-agent insight discovery (DRE)
Geometric failure recovery
Compute governance (energy ledger)
Agent health & fleet monitoring
Org-wide pattern sharing
Retention management & sweeps
Security & Operations
Audit log readable via security_audit tool
RBAC + API key auth
Storage integrity verification
Storage repair (offline rebuild)
Support
Community support (GitHub Issues)
Email support (24h response)
Priority email support (next business day)
SLA-backed support (1h / 4h / 24h)
Dedicated account manager

Frequently Asked Questions

Everything you need to know about phorvec licensing and pricing.

The Community tier is free forever — download the binary, install your MCP client, done. It includes the full core engine: vector storage, hybrid search, knowledge graphs, context management, memory consolidation, RAG indexing, the skill library (search & retrieve), and the bulk of the 100+ MCP tools. No account or registration required for the free download.

Phorvec uses dual-track pricing. The MCP Dev-Tool track (Community, MCP Pro, MCP Max) is flat monthly pricing for individual developers and small teams. The Infrastructure track (Team, Enterprise) is per-project pricing for organizations running phorvec across multiple production deployments.

MCP Pro ($19/mo) unlocks individual power-user features: agent testing suites with YAML scenarios, baselines, regression checks, agent benchmarking, and skill-library publishing (publish, deprecate, sync, ingest). Community already includes skill search & retrieval — Pro adds the ability to publish back.

MCP Max ($39/mo) unlocks full team coordination: team memory with FULL, PROTECTED, and ISOLATED sharing modes, cross-agent conflict detection (regex-based negation, severity levels, no LLM overhead), cross-agent search, team feed/dispatch/workflows, and team personas with skill tagging.

Move to Team ($49/project/mo) when you want a single centrally hosted phorvec instance that your whole team connects to, instead of every developer running their own local binary. Team includes shared team sync — every team member reads and writes the same memory state in real time, with no drift between developer machines. One license covers the project; you pay per project instead of per individual.

Enterprise adds fleet-scale operations and the deployment rights regulated/embedded customers need. Fleet intelligence: Divergent Recombination Engine (cross-agent insight discovery), geometric failure recovery, compute governance via the energy ledger, agent health monitoring across 6 EMA-tracked metrics, and org-wide pattern sharing. Security & ops: append-only JSONL audit trails with correlation IDs and structured error chains, secret detection, RBAC, storage repair. Plus a separate commercial license that grants air-gapped operation with offline-verifiable license files, embedded deployment in drones/vehicles/robots/edge devices, OEM redistribution, and perpetual air-gapped fallback after subscription end. SLA-backed support (1h / 4h / 24h tiers) and onboarding & integration engineering round it out.

A project is a directory where phorvec stores agent data — identified by a nexus.json file. If you have a monorepo, that's one project. If you have separate repos for separate services, each is a project. The MCP Dev-Tool tiers (Community / MCP Pro / MCP Max) bill per individual; Team and Enterprise bill per project.

The MCP Dev-Tool track (Pro/Max) is flat monthly because it's individual tooling. The Infrastructure track (Team/Enterprise) is per-project because the value scales with how many agent systems you run, not how many humans are on your team — adding a new developer costs nothing.

Yes. Community and paid tiers all use local ONNX Runtime for embeddings — no API calls, no data leaves your machine. Agent knowledge transfers via .vlbrain bundles (signed, file-based) without any network connectivity. For commercial air-gapped deployments (defence, automotive, industrial), the Enterprise commercial license grants the offline-verifiable License File V1 format with host binding (VIN, device serial, hostname) and a perpetual fallback after subscription end.

Phorvec works with any MCP-compatible client — Claude Code, Cursor, Windsurf, Cline, and more. The server supports stdio (default), SSE, and HTTP with bearer-token authentication, so any client that speaks one of those transports can connect.

Download a pre-built binary for your platform from phorvec.com/download. There's a binary for macOS (Intel + Apple Silicon), Linux x64, and Windows x64. We don't ship via pip, cargo, brew, or any other package manager — the binaries are signed (Ed25519) and a SHA-256 manifest is published alongside each release so you can verify integrity. Drop the binary on your PATH, point your MCP client at it, and you're running.

No. Phorvec is closed-source, distributed only as a signed binary. The entire MCP server (100+ tools, including DRE, geometric failure recovery, energy ledger, and the rest) ships as a compiled binary with no source disclosure. Binaries are tier-separated at build time — paid features physically aren't present in lower-tier binaries.

Prices are displayed in USD for international clarity, but payments are processed in South African Rand (ZAR) at the prevailing exchange rate at the time of purchase. Your bank may apply a small currency conversion fee.

Yes. All paid tiers are available at a 20% discount when billed annually. Contact us for Enterprise annual pricing.

Unlike Pinecone, Weaviate, or Qdrant, phorvec is purpose-built for AI agent memory — not general-purpose vector search. It's local-first, one-file-per-agent, and includes agent-specific features like team memory, conflict detection, knowledge synthesis, audit trails, and compute governance that general vector DBs don't offer.