# Quordo

> Quordo is the cross-vendor control plane for a company's AI estate: attribute AI/LLM spend to teams with budgets, alerts, and anomaly detection (Spend), and coordinate a fleet of MCP agents with shared context, handoffs, and an auditable trace (Coordinate) — two surfaces, one plane.

## Pages

- [Quordo — The control plane for your AI estate](https://quordo.com/): Quordo is the cross-vendor cockpit for everything AI in your company. Attribute every dollar to a team, set budgets that alert before they blow, and give your agent fleet shared context, handoffs, and an auditable trace — two surfaces, one plane.
- [Product — Quordo](https://quordo.com/product): Quordo is the cross-vendor control plane for your AI estate: two surfaces — Spend and Coordinate — on one plane. Attribute cost by team across all five providers, coordinate any MCP agent, and reconcile per-run cost into per-mission spend.
- [Pricing — Quordo](https://quordo.com/pricing): Quordo pricing: Free for 3 seats, Team at $19 per seat / month with a 14-day trial, and custom Enterprise with VPC or self-hosted deployment. Both surfaces — Spend and Coordinate — in every plan.
- [Use cases — Quordo](https://quordo.com/use-cases): Four ways teams put Quordo to work: FinOps for AI spend, agent coordination, multi-provider governance, and an audit trail for cost and agents. Problem, how Quordo solves it, and the outcomes.
- [About — Quordo](https://quordo.com/about): Why we built Quordo: a cross-vendor control plane so organizations can govern what they spend on AI and how their fleet of agents works together.
- [Security — Quordo](https://quordo.com/security): How Quordo handles your data: encrypted provider credentials, tenant isolation enforced at the database layer, and an auditable trace of every mutation.
- [Sub-processors — Quordo](https://quordo.com/subprocessors): Quordo's current sub-processors: Supabase, DigitalOcean, Stripe, Resend, PostHog, Sentry, and the AI providers you connect. For each we state the purpose, the data it handles, and the region. This is the list your vendor-risk assessment should start from.
- [Blog | Quordo](https://quordo.com/blog): Guides on governing the AI estate: cost attribution by team, budgets and alerts, anomaly detection and FinOps for LLMs, plus coordinating a fleet of agents with shared context, handoffs, and an auditable trace.
- [AI estate glossary — Quordo](https://quordo.com/glossary): Plain-English definitions of the terms behind governing an AI estate: MCP, agent-to-agent (A2A), AI FinOps, coherence, showback vs chargeback, cost per mission, shared context, agent handoffs, cost attribution, anomaly detection, and audit trails for agents.
- [Privacy Policy — Quordo](https://quordo.com/privacy): Quordo is a control plane for an organization's AI estate. Our customers are businesses, and most personal data we handle is business-account data — the names and work emails of the people who use Quordo for their employer. We collect the minimum needed to run the service, we do not sell personal data, and we act as a processor for the AI usage and agent-activity data our customers connect. Privacy questions: privacy@quordo.com.
- [Terms of Service — Quordo](https://quordo.com/terms): These terms govern your organization's use of Quordo. In short: an authorised admin signs your organization up, your team uses the service under these terms, you keep ownership of the data you connect, we keep the service running and secure as described, and either side can end the subscription as set out below. Questions: legal@quordo.com.
- [Cookie Policy — Quordo](https://quordo.com/cookies): We use a small number of cookies — only what we need to run Quordo securely, plus optional analytics that load only with consent where required. You can review and change your choice from the manage preferences control at the bottom of this page.
- [Data Processing Agreement — Quordo](https://quordo.com/legal/dpa): This is the Data Processing Agreement (DPA) template Quordo offers to customers. It sets out how we process the personal data you connect on your behalf: we act as your processor, we only process on your documented instructions, we keep a defined list of sub-processors, and we return or delete your data when the service ends. It is a template — we countersign a negotiated version on request. To execute one, email legal@quordo.com.

## Guides by role

- [Quordo for FinOps and finance teams](https://quordo.com/for/finops): A FinOps team gets AI spend under control the same way it got cloud under control — inform, optimize, operate — but the inputs are different: cost is metered per token by software loops rather than per provisioned hour, it can spike in hours rather than weeks, and it arrives on several provider invoices that share no common denominator. The practical sequence is: get one normalized cross-provider cost plane, attribute every event to a team at ingestion, set budgets with deduplicated alerts, add anomaly detection against a trailing baseline for the failure modes budgets miss, and only then negotiate commitments. Quordo is the plane that does the first four.
- [Quordo for platform engineering teams](https://quordo.com/for/platform-engineering): A platform team running more than one or two agents hits the same wall regardless of vendor: each agent keeps its own private context, work forks, handoffs happen in Slack, and nothing holds the record of what the fleet actually did. The fix is a coordination plane above the agents — one versioned source of truth per mission that every agent reads before it acts and writes through with a version check, handoffs that carry state, and an append-only trace that every agent reports into. Quordo provides that plane over MCP and A2A, so agents you already built on any framework join without bespoke glue, and their per-run cost reconciles into per-mission spend.

## Blog

- [How to attribute AI and LLM costs by team](https://quordo.com/blog/attribute-ai-costs-by-team): A practical guide to attributing AI and LLM spend to the teams that drive it — why provider invoices fall short, what attribution models work, and how to roll it out without slowing anyone down. (updated 2026-05-12)
- [Set budget alerts for AI spend before the bill surprises you](https://quordo.com/blog/ai-budget-alerts): How to set effective budgets and threshold alerts for AI and LLM spend — choosing limits, avoiding alert fatigue with deduplication, and routing notifications to the people who can act. (updated 2026-05-15)
- [FinOps for AI: a practical playbook for governing LLM spend](https://quordo.com/blog/finops-for-ai-spend): A FinOps playbook adapted for AI and LLM spend: gain visibility across providers, attribute and optimize cost, and operate with budgets, alerts, and anomaly detection. (updated 2026-05-20)
- [The agent coordination gap: why your AI fleet doesn't add up](https://quordo.com/blog/the-agent-coordination-gap): Companies are deploying more agents than ever, yet the work doesn't compound. The bottleneck isn't model capability — it's coordination. Here's the gap, and what closing it looks like. (updated 2026-05-25)
- [Shared context for coding agents: ending the drift](https://quordo.com/blog/shared-context-for-coding-agents): Teams running Devin, Claude Code, and Cursor side by side hit the same wall: the agents drift apart. A shared, versioned context — with conflict detection — is how you keep a coding-agent fleet coherent. (updated 2026-05-27)
- [Showback vs chargeback for AI spend: which model fits your org](https://quordo.com/blog/showback-vs-chargeback-ai): Showback gives teams visibility into their AI cost without moving money; chargeback bills the cost center directly. This guide explains the difference, when each model fits, and the attribution data that makes either one credible. (updated 2026-06-02)
- [Governing a multi-provider AI estate](https://quordo.com/blog/multi-provider-ai-governance): Most companies now buy AI from several providers at once, and each one reports spend in its own format on its own schedule. A single normalized cost-and-usage plane turns five invoices into one comparable view you can actually govern. (updated 2026-06-04)
- [What is MCP (Model Context Protocol), and why it matters for agent coordination](https://quordo.com/blog/what-is-mcp-agent-coordination): MCP is an open protocol that lets AI agents connect to shared servers, tools, and context through one standard interface, which is what makes it the natural integration point for coordinating agents that come from different vendors. (updated 2026-06-06)
- [Audit trails for AI agents: why every run needs an immutable record](https://quordo.com/blog/audit-trails-for-ai-agents): Agentic work moves faster than any human can supervise in real time. An append-only audit trail of runs, context writes, handoffs, and cost per step keeps people accountable without putting them in every loop. (updated 2026-06-09)
- [Catching AI spend anomalies before they become surprises](https://quordo.com/blog/ai-spend-anomaly-detection): AI spend can spike in hours from a runaway loop, a ballooned context window, or a new expensive model, but the monthly invoice surfaces it weeks too late. Good anomaly detection compares each day against its own trailing baseline, flags spikes while they are still small, and routes them to the team that owns the cost. (updated 2026-06-11)
- [Cost per mission: what did this agent workflow actually cost?](https://quordo.com/blog/cost-per-mission-agent-workflows): Per-key and per-provider billing tells you what each vendor charged, never what a piece of work cost. As agents collaborate across OpenAI, Anthropic, Bedrock, and Vertex on a single mission, cost has to be reconstructed from the work itself. (updated 2026-06-13)
- [What is AI FinOps?](https://quordo.com/blog/what-is-ai-finops): AI FinOps is the practice of governing AI and LLM spend with cross-provider visibility, per-team attribution, budgets, and anomaly detection on a metered, fast-moving cost. (updated 2026-06-15)
- [LLM cost optimization techniques that cut the bill without hurting quality](https://quordo.com/blog/llm-cost-optimization-techniques): Practical LLM cost optimization: right-size the model, trim context, cache and batch, cap retries, and route smartly — then measure realized savings against attributed spend. (updated 2026-06-16)
- [How AI provider pricing actually compares](https://quordo.com/blog/comparing-ai-provider-pricing): A single dollar-per-token figure misleads. Compare OpenAI, Anthropic, Azure OpenAI, Bedrock, and Vertex fairly by normalizing input/output rates, caching, and billing onto one plane. (updated 2026-06-17)
- [What is A2A (agent-to-agent), and how does it relate to MCP?](https://quordo.com/blog/what-is-a2a-agent-to-agent): A2A (agent-to-agent) is an emerging approach for agents to discover, delegate to, and negotiate with each other directly, complementary to MCP, which connects agents to tools and context. (updated 2026-06-18)
- [Measuring multi-agent alignment: the coherence metric](https://quordo.com/blog/measuring-multi-agent-coherence): Coherence measures multi-agent alignment as the share of a mission's shared context with no open conflicts. Here is what to measure, how the percentage is computed, and its limits. (updated 2026-06-19)
- [AI agent governance: a practical framework](https://quordo.com/blog/ai-agent-governance-framework): AI agent governance keeps autonomous agents accountable through identity, scoped permissions, an append-only audit trace, cost guardrails, and conflict detection — reviewed async, not gatekept. (updated 2026-06-20)
- [AI cost tracking: build it in-house or buy?](https://quordo.com/blog/ai-cost-tracking-build-vs-buy): Should you build AI cost tracking in-house or buy a tool? An honest comparison of DIY pipelines, provider dashboards, and a control plane — including when DIY is the right call and the TCO factors that decide it. (updated 2026-07-06)
- [How to forecast AI spend (before the invoice surprises you)](https://quordo.com/blog/forecast-ai-spend): Forecast AI spend from per-team trailing baselines: compute a daily run-rate, project it over the days remaining, adjust for anomalies and known launches, and back it with budget guardrails so misses are caught early. (updated 2026-07-06)
- [How to connect Claude Code, Cursor, or Devin to a coordination MCP server](https://quordo.com/blog/connect-coding-agents-mcp-coordination): Connect Claude Code, Cursor, or Devin to a coordination MCP server in three steps: register the agent for a report-in key, add the server to .mcp.json, and use eight coordination tools for shared context, runs, handoffs, and heartbeats. (updated 2026-07-06)
- [Orchestration vs coordination: two different problems for AI agents](https://quordo.com/blog/orchestration-vs-coordination-ai-agents): Agent orchestration and agent coordination solve different problems: orchestrators control flow inside one app you build, while a coordination plane provides shared state and audit between independent agents across vendors. Complementary, not competing. (updated 2026-07-06)
- [AI cost management tools: how the category actually breaks down](https://quordo.com/blog/ai-cost-management-tools-compared): AI cost tooling splits into five categories — native provider dashboards, cloud cost platforms, LLM gateways, LLM observability platforms, and cross-vendor cost planes. Each answers a different question. This is the map, the question each one can and cannot answer, and how to tell which you need. (updated 2026-07-27)
- [LLM observability vs AI cost management: what each one actually answers](https://quordo.com/blog/llm-observability-vs-cost-management): LLM observability traces what your application did and prices what it traced. AI cost management reconciles what every provider billed and attributes it to teams. They overlap on per-call cost and diverge on completeness — which is why one cannot substitute for the other. (updated 2026-07-27)
- [Writing an AI spend chargeback policy: what to put in it](https://quordo.com/blog/ai-spend-chargeback-policy): A working AI chargeback policy answers six things: what is in scope, how usage maps to a cost center, how shared and untagged spend is handled, when the number is final, how disputes are resolved, and who can change the rules. Here is what each clause needs to say. (updated 2026-07-27)

## Glossary

- [MCP (Model Context Protocol)](https://quordo.com/glossary#mcp): An open protocol that standardizes how AI applications and agents connect to tools, data sources, and each other. Instead of writing a custom integration per tool, an agent speaks MCP to any compliant server, which makes fleets of agents from different vendors composable. MCP is the connective tissue that lets a coordination layer register, address, and govern heterogeneous agents.
- [A2A (agent-to-agent)](https://quordo.com/glossary#a2a): Communication that happens directly between AI agents rather than between an agent and a human. A2A covers task delegation, status updates, and context exchange across agents that may come from different vendors. Without a shared protocol and a shared record, A2A interactions are invisible to the organization that pays for them.
- [AI FinOps](https://quordo.com/glossary#ai-finops): The practice of applying FinOps discipline — inform, optimize, operate — to AI and LLM spend. It means unifying usage and dollar-cost across providers, attributing spend to the teams that drive it, and operating with budgets, alerts, and anomaly detection. AI FinOps treats model spend as a managed cloud cost rather than a monthly surprise.
- [Coherence](https://quordo.com/glossary#coherence): A measure of how consistently a fleet of agents is working from the same, current understanding of a mission. Coherence drops when agents act on stale context, duplicate each other's work, or write conflicting changes. Tracking it turns "are the agents stepping on each other?" from a feeling into a number you can alert on.
- [Showback](https://quordo.com/glossary#showback): Reporting each team's share of a shared cost — such as AI spend — without actually moving money between budgets. Showback creates visibility and accountability first, which makes it the usual starting point before an organization commits to chargeback. It only works if the underlying attribution is trusted by the teams being shown their numbers.
- [Chargeback](https://quordo.com/glossary#chargeback): Allocating a shared cost back to the consuming teams' actual budgets, so each team pays for the AI usage it incurred. Chargeback demands defensible, auditable attribution and stable historical cost, because the numbers move real money and get disputed. Most organizations run showback first and graduate to chargeback once attribution is trusted.
- [Cost per mission](https://quordo.com/glossary#cost-per-mission): The total spend attributable to one multi-agent workflow (a "mission"), reconciled from the per-run costs of every agent step inside it. It answers what an outcome cost — not just what a provider billed — by joining coordination data (which runs made up the mission) with spend data (what each run cost). Cost per mission is the unit economics of agentic work.
- [Shared context](https://quordo.com/glossary#shared-context): A versioned, mutually visible store of facts, decisions, and state that every agent on a mission reads before acting and writes after acting. Shared context prevents the classic multi-agent failure where two agents work from different assumptions and produce conflicting output. Versioning matters: agents must be able to detect that what they read is stale.
- [Agent handoff](https://quordo.com/glossary#agent-handoff): The controlled transfer of a task from one agent to another, carrying enough context that the receiving agent can continue without redoing or contradicting prior work. A clean handoff records what was done, what remains, and which version of the shared context it was based on. Unrecorded handoffs are where multi-agent workflows silently lose work.
- [Audit trail for agents](https://quordo.com/glossary#agent-audit-trail): An append-only record of every consequential agent action — runs started, context written, handoffs, conflicts, approvals — kept so questions can be answered in retrospect. Because agents act autonomously and at machine speed, the trail must be immutable, searchable by mission and agent, and exportable for auditors and incident reviews. It is the difference between "we think the agent did X" and evidence.
- [Cost attribution](https://quordo.com/glossary#cost-attribution): Mapping raw provider usage and its dollar-cost to the team, product, or cost center that incurred it. Provider invoices report by model and time bucket, so attribution needs a mapping layer — commonly per-connection (each team gets its own key) or per-request tags. Attribution recorded at ingestion, with denormalized historical cost, is what makes showback and chargeback defensible.
- [Spend anomaly detection](https://quordo.com/glossary#spend-anomaly-detection): Automatically flagging AI spend that deviates from its expected pattern — typically by comparing each day's cost against a trailing baseline per team, model, or provider. Anomaly detection catches the failure modes budgets miss: a retry loop, a misconfigured agent, or a model swap that quietly multiplies unit cost while staying under the monthly limit.