QVeris — The unified Tool & data interface for AI Agents

One unified interface to use 10,000+ tools for your AI agents.

Official Website：https://qveris.ai

🇺🇸 English · 🇨🇳 简体中文

1. Overview
2. Vision & Positioning
3. Why QVeris
4. Problems QVeris Solves
5. Architecture
6. Execution Flow
7. Quickstart
8. Tool Schema & Execution Model
9. Built-in & Ecosystem Tools
10. Publish Your Own Tools
11. Routing & Optimization
12. Developer Ecosystem & Integrations
13. Use Cases
14. Marketplace & Pricing
15. Security & Governance
16. Comparison
17. Roadmap
18. Contributing
19. Community

QVeris is the Tool Operating System (Tool OS) for AI agents.
It standardizes how LLMs discover and call 10,000+ tools — web search, OCR, PDF parsing, SaaS APIs, internal services, and business actions — through a single schema, a secure sandbox, and a routing engine that selects the best provider.

If LLMs are the brain, QVeris is the hands: safe, reliable, and repeatable.

At a glance:

User → LLM / Agent → QVeris Tool OS → 10,000+ tools / APIs / systems

Vision Become the global infrastructure layer for AI actions — every agent, model, and AI app executes tools through QVeris.

Positioning

• Not another agent framework.
• Not just “plugins”.
• QVeris is the shared tool layer underneath agents, LLMs, and SaaS products.

Think Kubernetes + Zapier + Homebrew, but for tools in AI agent ecosystems.

Without QVeris you rebuild the same infrastructure again and again. With QVeris you plug into a tool fabric that is ready for agents.

OpenAI tools   ≠   LangChain tools   ≠   Zhipu tools   ≠   internal APIs

Each has its own format, auth, and error semantics.

QVeris normalizes everything into a single Tool OS.

Teams repeatedly build:

• API clients & wrappers
• Retry / backoff / rate limiting
• Logging, tracing, metrics
• Permissions & policy enforcement

QVeris centralizes this logic and exposes it through one interface.

Without a dedicated tool layer:

• Tools can touch any network or DB
• No clear boundary for what a model is allowed to do
• Hard to answer “what exactly did the agent execute?”

QVeris provides:

• Sandbox & firewall
• Access policies & RBAC
• Immutable execution logs & replay

                          +-----------------------------+
                          |        LLM / Agent          |
                          |  GPT / Claude / Llama ...   |
                          +--------------+--------------+
                                         |
                                   Tool calls (JSON)
                                         |
     +-----------------------------------v----------------------------------+
     |                          QVeris Tool OS                             |
     |---------------------------------------------------------------------|
     |  Tool Registry  |  Schema   |   Sandbox   | Routing  | Logs & ACLs  |
     +---------+-------+-----------+-------------+----------+-------------+
               |                   |             |
        +------v------+      +-----v-----+ +-----v------+
        | Built-in    |      |  Partner  | |  Custom /  |
        | tools       |      | tools     | | enterprise |
        | (core set)  |      |           | | tools      |
        +-------------+      +-----------+ +-----------+

Key components:

• Tool Registry — metadata, versioning, visibility.
• Schema Layer — universal tool interface for all tools.
• Sandbox — isolated runtime per invocation.
• Routing Engine — chooses providers by latency, reliability, cost, policy.
• Observability & Governance — logs, traces, metrics, access control.

flowchart TB
  %% --- 1. Minimalist Aesthetic Config (CSS) ---
  %% Hide default colors, enforce black & white logic
  linkStyle default stroke:#333,stroke-width:1.5px,fill:none;
  
  %% Node Styles: Pure Black & White
  classDef user fill:#fff,stroke:#000,stroke-width:2px,color:#000,rx:20,ry:20,font-weight:bold;
  classDef component fill:#fff,stroke:#333,stroke-width:1px,color:#333,rx:4,ry:4;
  classDef core fill:#000,stroke:#000,stroke-width:2px,color:#fff,rx:6,ry:6,font-weight:bold;
  classDef tools fill:#f9f9f9,stroke:#ddd,stroke-width:1px,color:#666,rx:2,ry:2,stroke-dasharray: 2 2;
  
  %% Container Style: No border, text only, "Airy" feel
  classDef container fill:none,stroke:none,color:#999,font-size:11px;

  %% --- 2. Node Definitions ---
  U(["👤 User"])
  L["LLM / Agent"]
  Q["⚡ QVeris Tool OS"]

  %% --- 3. Bottom Tool Layer (Forced Grouping) ---
  subgraph ToolLayer ["▼ Tool Ecosystem (10,000+)"]
    direction LR
    %% Invisible links to force horizontal alignment
    T1["Core Tools"] ~~~ T2["SaaS Connectors"] ~~~ T3["Custom Tools"]
  end

  %% --- 4. Connection Logic (The Key to Alignment) ---
  
  %% Main Flow: Straight line down
  U -->|"Request"| L
  L -->|"JSON Call"| Q
  
  %% Alignment Fix: Connect Q only to the MIDDLE node (T2)
  Q -->|"Route & Execute"| T2
  
  %% Auxiliary Lines: Dotted lines to side nodes (visual implication only)
  Q -.-> T1
  Q -.-> T3

  %% --- 5. Apply Styles ---
  class U user;
  class L component;
  class Q core;
  class T1,T2,T3 tools;
  class ToolLayer container;

Behind a single tool_call, QVeris can discover, select and execute from 10,000+ tools across core, partner and user-defined catalogs.

1. Validate tool call against schema
2. Check access policies & RBAC
3. Select provider (routing)
4. Execute in sandbox
5. Collect metrics, logs and traces
6. Return normalized response to the LLM

The fastest way to use QVeris today is via the MCP Server (@qverisai/mcp). It exposes QVeris tools to any MCP-compatible client (Claude Desktop, Cursor, etc).

Using npx:

npx @qverisai/mcp

Or install globally:

npm install -g @qverisai/mcp
qveris-mcp

You’ll need an API key in QVERIS_API_KEY.

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "qveris": {
      "command": "npx",
      "args": ["@qverisai/mcp"],
      "env": {
        "QVERIS_API_KEY": "your-api-key-here"
      }
    }
  }
}

Cursor (Settings → MCP Servers):

{
  "mcpServers": {
    "qveris": {
      "command": "npx",
      "args": ["@qverisai/mcp"],
      "env": {
        "QVERIS_API_KEY": "your-api-key-here"
      }
    }
  }
}

Once connected, your AI assistant can:

1. Discover tools with natural language queries (search_tools).
2. Execute any discovered tool with the right parameters (execute_tool).

QVeris standardizes every tool with a simple JSON schema.

{
  "tool_id": "openweathermap_current_weather",
  "search_id": "2f06d73c-164c-4a20-82a4-20f1afdd49f8",
  "params_to_tool": "{\"city\": \"London\", \"units\": \"metric\"}"
}

{
  "execution_id": "exec-123",
  "tool_id": "openweathermap_current_weather",
  "success": true,
  "result": {
    "data": {
      "temperature": 15.5,
      "humidity": 72,
      "description": "partly cloudy"
    }
  },
  "execution_time": 0.447
}

All tools follow:

• deterministic input/output contracts
• consistent error semantics
• unified logging & tracing.

QVeris provides access to 10,000+ tools via a layered ecosystem:

QVeris is not a closed catalog. Any developer or company can wrap their own APIs as Q-Tools and plug them into the Tool OS.

We support three visibility levels:

Typical publishing flow:

1. Implement your tool using the QVeris schema
2. Run `qveris-cli validate` locally
3. Submit the tool manifest to QVeris
4. Choose visibility: private / org / public
5. (Optional) Security & quality review
6. Tool becomes discoverable & executable via QVeris

Example manifest (simplified):

{
  "name": "acme-crm.create_customer",
  "version": "1.0.0",
  "visibility": "org",
  "input": {
    "email": "string",
    "full_name": "string"
  },
  "output": {
    "id": "string",
    "status": "string"
  }
}

Once published, your tool is:

• discoverable via natural language (search_tools)
• executable via execute_tool
• fully covered by QVeris sandboxing, routing and logging.

QVeris optimizes each call across multiple providers and implementations.

Tool call
  ↓
Filter providers by policy & region
  ↓
Score providers (latency, reliability, cost)
  ↓
Select primary + fallback chain
  ↓
Execute in sandbox, record metrics

As the ecosystem grows, the routing engine scales horizontally — selecting the best option out of 10,000+ tools and endpoints while keeping a single, simple interface.

Use QVeris as the tool backend: your agents simply call QVeris tools via MCP today and via HTTP/SDKs in the future.

Because of the unified schema, adding a new provider is primarily defining a new Q-Tool.

• Multi-tool personal assistants that search, read, summarize, email, schedule, and more.
• Customer-support copilots pulling data from multiple systems.

• CRM bots enriching leads and updating Salesforce / HubSpot.
• Ops bots reconciling data across internal systems.

QVeris provides the guardrails, sandboxing and observability.

• Assistants reading PDFs, searching Arxiv, and generating literature reviews.
• Competitive-intelligence bots monitoring specific topics and sources.

• Portfolio analysis, market monitoring, alerting bots using financial & crypto tools.

The QVeris Marketplace (in development) allows:

• Providers to publish tools
• Developers to monetize capabilities
• Agent builders to discover & plug in tools instantly

QVeris manages billing, execution sandboxing, analytics and abuse control.

Security and governance are first-class concerns in QVeris:

• Sandboxed execution environments
• Network & resource-level policies
• RBAC and per-tool access control
• Immutable audit logs & execution IDs
• Rate limiting & quota enforcement
• Enterprise options: VPC, private regions, on-prem (planned)

Compliance roadmap:

• SOC2
• ISO27001
• Industry-specific add-ons (e.g. finance, healthcare)

QVeris focuses specifically on tool unification + routing + governance + ecosystem, complementing (not replacing) your existing LLM and agent stack.

High-level public roadmap (subject to change):

• MCP Server (@qverisai/mcp) GA
• 50+ core tools
• Routing engine (alpha)

• 200+ curated tools
• Marketplace v0
• HTTP & Python SDKs

• Multi-region compute & residency settings
• Enterprise admin console
• Custom policy engine

• On-prem / VPC deployments
• Compliance certifications
• Visual tool graph editor

For details, see GitHub Issues & Projects.

We welcome contributions of all kinds:

• New tools & provider integrations
• Bug reports & fixes
• SDK examples for different stacks
• Documentation & tutorials
• Feature proposals and design discussions

Suggested flow

1. Fork this repository.
2. Create a feature branch.
3. Add tests where relevant.
4. Open a Pull Request with context & rationale.

A detailed CONTRIBUTING.md will be added as the project matures.

Stay in touch and follow updates:

• 💬 Discord — real-time chat & support

  • https://discord.gg/your-qveris-code

• 🐦 X (Twitter) — product updates & roadmap

  • https://x.com/QVerisAI

• 💼 LinkedIn — company & enterprise news

  • https://www.linkedin.com/company/qveris

• 📚 Docs — guides & API reference (coming soon)

  • https://docs.qveris.ai

• 🧪 SDK Repository — MCP server & examples

  • https://github.com/QVerisAI/SDK

Replace the placeholder URLs with your actual links when ready.

If you believe the world needs a better way for AI to use tools, please star this repo and share it with other builders.

git clone https://github.com/QVerisAI/QVerisAI.git
cd QVerisAI
# start building with the Tool OS