The Open Source Lie: What Every AI Agent Stack Actually Costs in 2026

The bait is the license

The license is free. The production path is not.

Every major “open source” agent framework in 2026 follows the same playbook. Ship an MIT or Apache 2.0 repo to seed adoption. The repo gets developers, GitHub stars, integration tutorials, blog posts. Then the moment the developer is ready to ship to production, the vendor hands them a bill. The bill is for the hosted control plane, the trace dashboard, the deployment runtime, the managed vector store, the per-seat dashboard, the per-call runtime, the per-trace observability. The license is free. The lock is the cloud.

We pulled the actual published pricing for ten named competitors. We read the official pricing pages. We noted the URL for every line item. Then we compared the stack against Ten Trillion Triangles TPipe, which prices the same surface as a flat per-organization fee with the full feature set on every tier.

The math is uglier than the marketing says.

The verified price table

Every line item below is pulled from the vendor’s own published pricing page. We cite the URL for every claim. Where the price is pay-as-you-go or custom, we say so. Where the SaaS is a separate SKU from the open source repo, we note the split.

LangChain stack — LangSmith, LangGraph Platform, LangChain

LangChain, Inc. sells the framework as MIT-licensed code on GitHub. The production path is a stack of paid SKUs.

SKU	Price	Source
LangSmith Developer	Free, 1 seat, 5K traces/month, 50 Fleet runs/month	langchain.com/pricing
LangSmith Plus	$39 per seat per month, 10K traces included, $0.50 per 1K extra traces, $5 per 1K at 400-day retention	langchain.com/pricing
LangSmith Sandboxes	$0.0576 per vCPU-hour, $0.0185 per GiB-hour, billed per second	langchain.com/pricing
LangSmith Fleet runs	$0.05 per Fleet run after the 500/month included on Plus	langchain.com/pricing
LangGraph Platform Production	$0.0036 per minute uptime on Production, $0.0007 on Development	langchain.com/pricing
LangGraph Platform Deployment runs	$0.005 per deployment run after 1 free Dev deployment on Plus	langchain.com/pricing
LangSmith Engine (LCUs)	$1.50 per LCU	langchain.com/pricing
LangSmith Enterprise	Custom, hybrid or self-hosted in your VPC	langchain.com/pricing

For a 10-engineer team on LangSmith Plus for three years, the per-seat line alone is $14,040. Deployment runs, sandboxes, and LLM tokens stack on top. Source: langchain.com/pricing. LangGraph Platform is generally available only on Plus and Enterprise. Source: langchain.com/blog/langgraph-platform-ga.

CrewAI

CrewAI publishes two tiers on the official pricing page: Basic (free) and Enterprise (custom). The Basic tier is a hosted visual editor with 50 workflow executions per month. Source: crewai.com/pricing.

Third-party resellers and a public Reddit thread document intermediate paid tiers that do not appear on the official page: Professional at $25 per month, Professional Plus at $99 per month, and Pro at $1,000 per month with 2,000 monthly executions, 5 live deployed crews, and senior support. Sources: lindy.ai, zenml.io, r/crewai.

A r/crewai thread from January 2025 reported that production deployments require the Enterprise edition. Third-party sources peg meaningful enterprise automation (30,000+ monthly executions) at $75,000 to $90,000 per year. Sources: checkthat.ai, r/crewai. We cite the third-party numbers as estimates. The official page only shows Basic and Enterprise.

LlamaIndex / LlamaParse / LlamaCloud

The LlamaIndex framework on GitHub is MIT-licensed. LlamaParse, the production document parser, is a commercial SaaS.

Tier	Price	Credits	Users	Source
Free	$0 per month	10K	1	llamaindex.ai/pricing
Starter	$50 per month	40K	5	llamaindex.ai/pricing
Pro	$500 per month	400K	10	llamaindex.ai/pricing
Enterprise	Custom	Custom	Custom, with VPC, SSO, dedicated CSM	llamaindex.ai/pricing

Parse jobs are limited to 5 concurrent on Free and Starter, 20 on Pro, 100 on Enterprise. Indexes are limited to 5 on Free, 50 on Starter, 100 on Pro, custom on Enterprise. SOC 2, HIPAA, GDPR on all paid tiers. VPC and SSO require Enterprise. Source: llamaindex.ai/pricing.

A three-year Pro commitment runs $18,000. A three-year Starter runs $1,800. Enterprise is quoted per deal and typically starts at $50,000 per year and climbs with index count and data volume.

Haystack by deepset

Haystack on GitHub is Apache 2.0. The deepset AI Platform (formerly deepset Cloud, rebranded to Haystack Enterprise Platform in December 2025) is the production SaaS.

Tier	Price	Source
Studio (Free)	$0, 1 user, 1 workspace, 100 pipeline hours, 50 files (10 MB max)	deepset.ai/pricing
Enterprise	Custom, unlimited users/workspaces/files, dedicated infra, private Slack	deepset.ai/pricing
Haystack Enterprise Starter	Mid-tier, pricing based on company size	deepset.ai/blog/introducing-haystack-enterprise

The Enterprise tier requires contacting sales. The published pricing page does not list a number. Source: deepset.ai/pricing, deepset.ai/blog/introducing-haystack-enterprise-platform.

Letta (formerly MemGPT)

Letta’s framework is open source. The Letta API Platform is a paid hosted runtime for stateful agents.

Tier	Price	Source
Letta Code Free	$0, limited agents, BYOK	docs.letta.com/letta-code/pricing
Letta API Plan	$20 per month base, $0.10 per active agent per month, $0.00015 per second tool execution, pay-as-you-go LLM usage	docs.letta.com/guides/build-with-letta/pricing
Letta Enterprise	Custom, volume pricing, SAML/OIDC SSO, dedicated support	docs.letta.com/guides/build-with-letta/pricing

Letta pioneered the MemGPT memory model. The team was first to ship a production memory agent framework. The credit pricing is fine for prototyping. At 100 active agents and heavy tool use, the bill climbs fast. Source: docs.letta.com/guides/build-with-letta/pricing.

Microsoft: Copilot Studio, M365 Copilot, Azure AI Foundry Agent Service

Microsoft sells agents in three layers, and the bills stack.

SKU	Price	Source
Microsoft 365 Copilot	$30 per user per month, annual	microsoft.com/microsoft-365-copilot/pricing
Microsoft Copilot Studio tenant license	$200 per pack per month for 25,000 Copilot Credits	microsoft.com/microsoft-365-copilot/pricing/copilot-studio
Microsoft Copilot Studio message-based	$0.01 per message (standard usage tier)	microsoft.com (via Lindy.ai compilation)
Foundry Agent Service native agents	No additional charge for prompts/workflows, model tokens billed separately	azure.microsoft.com/pricing/details/foundry-agent-service
Foundry hosted agents	Billed per underlying container vCPU/GiB-hour	azure.microsoft.com/pricing/details/foundry-agent-service
Foundry Memory	Short-term and long-term memory billed per 1,000 items stored and per 1,000 retrievals	azure.microsoft.com/pricing/details/foundry-agent-service
Foundry File Search Storage	$0.11 per GB per day (1 GB free)	azure.microsoft.com/pricing/details/foundry-agent-service
Foundry Code Interpreter	$0.033 per session	azure.microsoft.com/pricing/details/foundry-agent-service
Foundry Web Search	$14 per 1,000 transactions	azure.microsoft.com/pricing/details/foundry-agent-service
Foundry Custom Search	$14 per 1,000 transactions	azure.microsoft.com/pricing/details/foundry-agent-service

For a 10-engineer team running autonomous agents on Copilot Studio with one credit pack each, the Studio line is $24,000 per year before model tokens and Azure compute. M365 Copilot for the team is $3,600 per year. Foundry Agent Service consumption stacks on top with per-GB, per-session, and per-1,000-transaction charges for every tool the agent calls.

Sources: microsoft.com/microsoft-365-copilot/pricing/copilot-studio, azure.microsoft.com/pricing/details/foundry-agent-service.

Google: ADK and Vertex AI Agent Engine

The Agent Development Kit (ADK) is open source under Apache 2.0. The Vertex AI Agent Engine is the production runtime. Pricing follows the Cloud Run model.

Resource	Price (us-central1)	Source
ADK	Free, Apache 2.0	github.com/google/adk-python
Vertex AI Agent Engine	vCPU-hour and GiB-hour, billed per second, 30-second minimum (no minimum as of 2026)	cloud.google.com/products/gemini-enterprise-agent-platform/pricing
n1-standard-8	$0.437 per hour	cloud.google.com/products/gemini-enterprise-agent-platform/pricing
n2-standard-8	$0.447 per hour	cloud.google.com/products/gemini-enterprise-agent-platform/pricing
L4 GPU	$0.644 per hour	cloud.google.com/products/gemini-enterprise-agent-platform/pricing
H100 80GB	$9.797 per hour, plus $1.469 per hour management fee	cloud.google.com/products/gemini-enterprise-agent-platform/pricing

For a production deployment running 4 vCPUs and 16 GiB of memory continuously, the compute bill alone runs $4,000 to $8,000 per month before Gemini model tokens. Add data storage, Cloud Logging, and the Gen AI Eval costs (input $0.00003 per 1K characters, output $0.00009 per 1K) and the bill climbs fast.

Source: cloud.google.com/products/gemini-enterprise-agent-platform/pricing.

OpenAI Agents SDK

The OpenAI Agents SDK is free, MIT-licensed, and runs in your code. The cost is on the model side and on the ChatGPT workspace side.

SKU	Price	Source
OpenAI Agents SDK	Free, MIT	developers.openai.com/api/docs/guides/agents
ChatGPT Plus	$20 per user per month	openai.com/chatgpt/pricing
ChatGPT Business	$25 per user per month	help.openai.com
ChatGPT Enterprise	Custom, ~$60 per user per month sales-quoted (third-party)	stackcyber.com, inference.net, backplain.com
GPT-5.4 API	$2.50 per 1M tokens (input)	openai.com/api/pricing
GPT-4-class frontier model	Higher per-token rates	openai.com/api/pricing

Third-party trackers report ChatGPT Enterprise at approximately $60 per user per month, sales-quoted and not publicly listed. Source: inference.net, backplain.com.

Ten engineers on ChatGPT Enterprise for three years runs $21,600 in seat fees, plus API token usage on top. SDK is free. The lock is the OpenAI model and the ChatGPT workspace.

AutoGen and the new Microsoft Agent Framework

AutoGen v0.4 and the new Microsoft Agent Framework (announced October 2025, converging Semantic Kernel and AutoGen into one SDK) are MIT-licensed open source. Production deployment runs on Azure AI Foundry Agent Service. The Agent Framework itself is free. The cost is the underlying Azure compute, model tokens, and Foundry tool calls.

SKU	Price	Source
AutoGen v0.4	MIT, free	github.com/microsoft/autogen
Microsoft Agent Framework	MIT, free	learn.microsoft.com/en-us/agent-framework/overview
Foundry Agent Service hosted agents	Per-container vCPU/GiB-hour	azure.microsoft.com/pricing/details/foundry-agent-service

Source: github.com/microsoft/autogen, learn.microsoft.com/en-us/agent-framework/overview, azure.microsoft.com/en-us/blog/introducing-microsoft-agent-framework.

Strands, Koog, A2A — the truly free stack

Three frameworks in this space actually deliver open source without the SaaS lock.

Framework	License	Hosted Offering	Source
Strands Agents (AWS)	Apache 2.0	None, you pay for AWS Bedrock tokens and infra	github.com/strands-agents
Koog (JetBrains)	Apache 2.0	None	github.com/JetBrains/koog
A2A Protocol (Google → Linux Foundation)	Apache 2.0	None, protocol only	linuxfoundation.org/projects/a2a

A2A is a protocol, not a framework. It is a wire format for inter-agent communication. You cannot build a product on A2A alone. You build a product on LangChain or Ten Trillion Triangles TPipe, and your agents talk A2A when they need to talk to agents on a different framework. Strands and Koog are frameworks, but neither ships a hosted runtime, observability dashboard, or vector store. You bring your own. Source: aws.amazon.com/blogs/opensource/introducing-strands-agents-an-open-source-ai-agents-sdk, jetbrains.com/koog, linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project.

What self-hosting actually costs

The open source repos are free. Self-hosting them is not free. The hidden bill comes from the LLM API, the vector database, the orchestration runtime, and the engineer-months you spend building the missing pieces.

For a 10-engineer team running production agents on the “fully open” path, here is the realistic cost stack, drawn from current 2026 rates. These are estimates, not quotes.

LLM API tokens. A 10-engineer team running production agents typically burns 50M to 500M tokens per month, mixed input and output. The model choice drives the bill more than the framework choice. At 200M tokens per month with a 70/30 input/output mix:

• GPT-5.5 at $5 input / $30 output per million tokens: $30,000 per year.
• Claude Opus 4.6 at $5 / $25: $26,400 per year.
• Claude Sonnet 4.6 at $3 / $15: $15,840 per year.
• GPT-4o at $2.50 / $10: $11,400 per year.
• Qwen 3 30B-A3B via API at $0.08 / $0.28: $336 per year.
• Self-hosted Qwen 3 30B on local Ollama: $0 per token, plus $50 to $200 per month in electricity.

A frontier team pays 60 to 100 times the bill of an open-source team on the same workload. The 200M-tokens-per-month figure is a mid-range estimate. At 500M tokens per month, the frontier tier lands at $75,000 to $190,000 per year and the open tier lands at $840 to $2,400 per year. The LLM cost is in the model choice, not the framework.

Vector database. Pinecone Standard is $0.096 per GB-month for storage, plus query charges. A production deployment with 10GB of embedded data runs $30 to $100 per month. Self-hosted Qdrant, Weaviate, or Milvus on the same data costs $200 to $500 per month in compute. Either way, this is rounding error compared to the LLM bill.

Compute for the framework runtime. LangGraph, AutoGen, Strands, Koog, and Ten Trillion Triangles TPipe all run on commodity compute. A 4-vCPU, 16 GiB production node runs $150 to $400 per month on AWS, GCP, or Hetzner. Self-hosted LangChain without LangGraph Platform, or self-hosted TPipe on a single JVM, are in the same cost band. The framework runtime is not where the money goes.

The hidden cost: engineer-months. The open source frameworks ship the framework, not the platform. To match the TPipe feature set, you need to build or integrate the following:

• Persistent memory across agent restarts (ContextBank equivalent): 1 to 2 engineer-months
• Token governance with hard caps and kill-switch behavior: 1 to 2 engineer-months
• Multi-agent orchestration with voting and handoff (Manifold equivalent): 2 to 3 engineer-months
• P2P agent discovery and routing (DistributionGrid equivalent): 2 to 4 engineer-months
• Real-time trace dashboard (TraceServer equivalent): 1 to 2 engineer-months
• MCP integration for tool calling: 0.5 to 1 engineer-month
• Multi-language tool execution with AST validation (PCP equivalent): 1 to 2 engineer-months

Total: 8 to 16 engineer-months to reach feature parity with TPipe. At a fully-loaded engineering cost of $20,000 per month, that is $160,000 to $320,000 in one-time build cost, plus 1 to 2 engineers per year to maintain the platform going forward. The “free” open source path costs more than Manifold for the first year for any team that values its engineering capacity.

This is the trap. The open source license is free. The build is not.

Ten Trillion Triangles TPipe — the all-included model

Ten Trillion Triangles TPipe ships the full feature set on every tier. No feature gates. No per-seat fees. No per-call charges. No per-trace billing. The commercial tiers differ in license terms and support level, not in capabilities. The same TPipe binary runs in every tier. The contract is the only thing that changes.

Tier	Price	License	Use Case
Pipe	Free	AGPL-3.0	Open-source projects, FOSS, AGPL-compliant derivatives
Pipeline (Indie / Startup)	Free below $1M annual revenue	Commercial	Closed-source products, internal tools, distribution, below $1M revenue; also FOSS projects using TPipe as a dependency, regardless of revenue
Manifold	$7,500 per year	Commercial	Closed-source products above $1M revenue, priority email support
Substrate	From $35,000 per year	Enterprise	Custom SLA, dedicated CSE, private fork, DPA/MSA, 4hr response, 1hr P1, plus negotiable custom terms

How the four tiers actually work

The four tiers are not a feature ladder. The four tiers are four different contracts on the same product. Pick the one that matches your legal posture. Everything you can do in Substrate, you can do in Pipe, with the right license.

Pipe (AGPL-3.0) — the open source build. Pipe is the source you can read, fork, modify, and self-host under AGPL-3.0. The full TPipe feature set ships in Pipe: Manifold, Junction, DistributionGrid, ContextBank, KillSwitch, TraceServer, PCP, MCP, Tuner, every container type, every provider integration, Chain-of-Draft, Reasoning Pipes, GraalVM Native Image compilation. No feature is held back. No capability is hidden behind a paywall.

The AGPL constraint is straightforward. If you distribute a service that uses TPipe, or you release a modified version, you must publish the modifications under AGPL terms. The AGPL closes the network-server loophole that standard GPL leaves open. If you operate a service that users interact with over a network and that service is built on a modified TPipe, the source of the modifications must be available to those users.

Pipe is the right tier for FOSS projects that depend on TPipe, for research labs and universities, for personal projects and side experiments, for any team that wants to read every line of code that runs in production. Pipe is also the right tier for teams evaluating TPipe before they commit. You can build a working prototype under AGPL, prove the architecture, and decide later whether to convert to a commercial tier before you ship closed source.

Pipeline (Indie / Startup) — the asymmetric bet. Pipeline is the free closed-source commercial license, available to any legal entity with $1M or less in annual revenue. Below the revenue cap, you can ship a closed-source product that uses TPipe, run an internal tool that uses TPipe, or distribute a service that uses TPipe. The source stays closed. The license is commercial, not copyleft. Attribution is required. The noncompete clause applies.

Pipeline has two pathways, and the second one is the one most people miss.

Pathway 1: closed-source commercial use below $1M revenue. This is the headline use case. A 5-person startup with $400K in ARR can build their AI product on TPipe, ship it closed source, distribute it as a paid SaaS, and pay nothing to Ten Trillion Triangles. The $1M cap is measured per legal entity, per GAAP. If the entity is below the cap, the license is free. If the entity crosses the cap, the 30-day conversion window opens.

Pathway 2: FOSS exception, no revenue cap. The Startup License 1.0 includes an explicit FOSS carve-out. Any project that uses TPipe as a dependency, that is itself licensed under an OSI-approved open-source license, qualifies for the free Startup License regardless of the project’s revenue, the project’s backers, or the project’s commercial success. An OSI-licensed project that depends on TPipe pays nothing. Forever. The FOSS exception exists because the framework’s adoption in the open-source ecosystem is more valuable than any license fee it could extract.

Section 3 of the Startup License 1.0 (the FOSS Exception) waives the revenue cap for projects that meet all three conditions: (a) the project’s complete source code is publicly available under an OSI-approved license and is buildable from that source by a third party, (b) TPipe is used as a dependency rather than as a standalone product or under a different license name, and (c) the project does not compete with TPipe. The noncompete still applies. Section 3 itself states that a FOSS project providing LLM orchestration or multi-agent pipeline functionality as a competing product is not eligible for the exception and must obtain a Commercial Agreement. Attribution applies. Source: ten-trillion-triangles.com/licenses/LICENSE.TPipe-Startup.md.

What the Startup License prohibits. The noncompete clause: a Pipeline licensee cannot offer a product or service that provides LLM orchestration, multi-agent pipeline orchestration, or any functionality that overlaps with TPipe’s core purpose, regardless of interface, language, platform, or whether the product is free or paid. Using TPipe internally to build your own product is fine. Using TPipe to build a competing agent framework, a competing orchestration layer, or a competing substrate is not. The licensee also cannot redistribute TPipe as a standalone product under a different name.

What the Startup License does not prohibit. Reselling products and services that use TPipe. Charging money for AI applications built on TPipe. Building internal tools that use TPipe. Distributing TPipe as part of a larger product. Sublicensing to customers who deploy on their own infrastructure. The license is permissive on commercial use and restrictive on direct competition with TPipe itself.

Manifold — closed source above the line. Manifold is the $7,500 per year tier for legal entities with more than $1M in annual revenue. The license terms are commercial. The full TPipe feature set is included. Priority email support is included, with a 48-hour SLA. The fee is per organization, not per user, not per agent, not per trace, not per call. Ten Trillion Triangles LLC bills annual. The customer contacts Ten Trillion Triangles, an invoice is issued, the customer pays through whatever payment method the customer uses, and on receipt of payment Ten Trillion Triangles issues a commercial license, a proof of purchase, and a written confirmation of valid allowed usage through a specified date.

Manifold is the right tier for a venture-backed startup that has crossed Series A, a profitable mid-market company, a public company that wants the license terms clean, or any organization that has outgrown the Startup License’s revenue cap. The price is rounding error on the engineering budget. The license is the point. The support is the bonus.

Substrate — enterprise, with everything on the table. Substrate is the enterprise tier, starting at $35,000 per year. The published Substrate line includes a 4-hour SLA response, 1-hour P1 response, a dedicated Customer Success Engineer, 20 hours per quarter of custom development, a private fork option, DPA and MSA legal terms, an annual executive review, and priority roadmap access.

The published line is the floor of what Substrate can include. The actual Substrate contract is the contract the customer and Ten Trillion Triangles agree to. If a customer needs a contractual commitment that is not on the published list, the contract can include it. If a customer needs a feature that does not exist in the public roadmap, the contract can commission it. If a customer needs deployment, support, or licensing terms that are unique to their environment, the contract can scope it.

Substrate is the right tier for a Fortune 500 deployment, a regulated industry buyer (financial services, healthcare, government), a defense or intelligence customer with export-control requirements, a multi-region deployment with data-residency constraints, a customer whose legal team needs unusual indemnification language, or a customer whose engineering team needs long-term committed support. The relationship is the product. The software is the substrate.

Beyond the Substrate line — what enterprise really buys you

The published Substrate line is the floor. The actual Substrate contract is the contract the customer and Ten Trillion Triangles agree to. If a customer can articulate the constraint, Ten Trillion Triangles can build the contract.

Custom licensing terms. The published Manifold and Substrate agreements are templates, not the only options. A customer who needs a per-region license, a per-data-center license, a per-CPU-socket license, a per-seat license that includes reseller rights, an OEM license that lets the customer embed TPipe in a hardware appliance, a license that survives a corporate acquisition, or a license that transfers to a successor entity. All of these are within the range of what a Substrate contract can include. If the customer needs a license structure that is not on the published list, the legal team will work with the customer’s legal team to draft one.

Custom hardware support. TPipe runs on JVM by default, on GraalVM Native Image for the edge. The JVM target runs on any x86_64 or ARM64 server with a JDK 17+ runtime. The GraalVM target compiles to a single static or shared library that runs on iOS, Android, embedded Linux, RTOS targets, and a long list of bare-metal deployments. The default supported platforms are documented in the docs. A Substrate customer who needs a deployment on a specific hardware target (an Nvidia Jetson, an Apple Silicon cluster, a confidential-computing enclave on AMD SEV-SNP, a RISC-V board, a classified-network air-gapped rack) can scope it into the contract. The build pipeline supports the target. The maintenance commitment is what gets negotiated.

Custom engineering work. The published Substrate line includes 20 hours per quarter of custom development. That is the floor. A Substrate customer who needs a dedicated engineering team for the duration of the contract, who needs a feature on a specific date, who needs a port to a custom runtime, who needs integration with a proprietary model gateway, who needs a custom security review, or who needs any other engineering commitment that is not on the published list can scope it into the contract. The Ten Trillion Triangles engineering team is small, focused, and shipping. The team that ships the framework is the team that takes the enterprise engagement. No offshore handoff. No tier-1 / tier-2 separation. The people who write the code are the people who answer the ticket.

NDA and confidentiality support. Every commercial conversation with Ten Trillion Triangles is covered by a mutual NDA on request. The standard NDA ships in 24 hours. Custom NDA terms, including counsel-drafted indemnification language, unusual IP assignment clauses, and customer-mandated security review addenda, are part of the standard Substrate contracting process. The team has signed NDAs with Fortune 100 customers, defense primes, healthcare networks, and financial services incumbents. The contracting path is built.

Bespoke deployment models. TPipe runs on a single JVM, on a cluster of JVMs, on GraalVM Native Image for edge, on a Kubernetes operator, on bare metal, on a confidential-computing enclave, on an air-gapped network, on a customer-managed cloud, on a sovereign cloud, on a hybrid spanning two or more of the above. A Substrate customer who needs a deployment model that is not on the default list (a sovereign-cloud-only deployment, a STIG-hardened image, a FedRAMP-aligned build, a HIPAA-aligned BAA, an ITAR-controlled distribution channel, a customer-controlled key management service) can scope it. The deployment is a contract, not a configuration.

Custom SLA terms. The published Substrate SLA is 4-hour response, 1-hour P1. A Substrate customer who needs tighter terms (15-minute P1, named on-call rotation, regional redundancy with RTO and RPO commitments, monthly availability reporting, third-party audit rights) can scope it. The SLA is a contract, not a marketing number.

Custom roadmap commitments. A Substrate customer who needs a specific feature delivered on a specific date, who needs a deprecation commitment on a specific API, who needs long-term API stability for a regulatory submission, or who needs priority review of a feature request can scope it. Roadmap influence is part of the Substrate relationship.

If you can articulate the constraint, we can build the contract. The published line is what fits the median Substrate customer. The actual Substrate contract is what fits the specific customer. A 5-person regulated fintech with a single production deployment, a 50-person federal contractor with a STIG-hardened build, and a 500-person global pharma with a multi-region SOC2 deployment all fit in the Substrate tier. The contract is the difference.

The license transition path

The license is not static. Teams grow. Revenue crosses the cap. The transition is built.

Below $1M revenue, you are on Pipeline (Indie / Startup). The license is commercial. You can ship closed source. The noncompete applies. The FOSS exception applies for OSI-licensed dependents. Attribution is required. The contract is the Startup License 1.0.

The day you cross $1M revenue, the 30-day conversion window opens. You have 30 days from the end of the fiscal year in which your revenue exceeded the cap to do one of two things: (a) enter a Commercial Agreement with Ten Trillion Triangles LLC at the Manifold or Substrate tier, or (b) switch to AGPL-3.0 by releasing your TPipe modifications under AGPL terms. The 30-day window is measured in calendar days, not business days.

If neither happens within 30 days, the license converts to AGPL-3.0 retroactively. The conversion is back-dated to the date you exceeded $1M. Any closed-source deployment you operated between the cap-cross date and the conversion date was operating under an invalid license. The AGPL terms apply for the entire period. The retroactive conversion is a contractual remedy, not a punishment. The customer has a clear path to compliance: buy Manifold, buy Substrate, or open the source.

Revenue is self-reported. The Startup License 1.0 is enforced on the honor system. The licensee reports their annual revenue to Ten Trillion Triangles on request. Misrepresentation is material breach of the license. The contractual remedy for misrepresentation is 2x the Manifold fee for the period of misrepresentation. The audit right is reserved. The 2x penalty is the upper bound. Most audits result in a clean conversion to Manifold. The penalty exists to discourage the worst case, not to police the median.

The conversion is not a cliff. A team that crosses $1M is not forced into Substrate. The team can convert to Manifold at $7,500 per year and stay there. The team can convert to Substrate at $35,000 per year and get the enterprise relationship. The team can convert to a custom Substrate contract at a higher annual figure and get the bespoke terms. The team can convert to AGPL and open the source. The team can also, in edge cases, negotiate a custom commercial agreement at a price between Manifold and Substrate. The published tiers are the standard menu. The contract is the actual product.

Practical playbook for the conversion. Most teams that cross $1M convert to Manifold within the 30-day window. The conversion is one email and one credit-card form. The team keeps building on the same TPipe binary, the same docs, the same API surface. The license is the only thing that changes. For teams that need more than Manifold, the conversation with sales is a 30-minute call. The Substrate contract is drafted in parallel. Most Substrate contracts close in 30 to 60 days from the first sales conversation. The contract is not the bottleneck. The customer’s internal procurement process is the bottleneck.

The license is permanent, not subscription. A Manifold or Substrate license is annual. The license does not auto-renew at a higher tier. The customer can downgrade to Pipeline (if revenue drops below $1M), downgrade to Manifold (if they no longer need the Substrate relationship), or terminate at the end of the term. The contract is renewed annually, not auto-renewed at the same price. Pricing is reviewed annually. The customer can request a pricing review at any time. The relationship is long, the contract is short.

The full TPipe feature set, included in every tier

The same product ships in Pipe, Pipeline, Manifold, and Substrate. The capability is not gated by the contract. The contract gates the right to ship closed source and the right to demand a certain level of support. The code is the same.

Containers and orchestration.

• Manifold: multi-agent orchestration with manager/worker/memory patterns
• Junction: voting, handoff, and decision routing between agents
• Connector: conditional pipeline branching
• Splitter: parallel execution across multiple agents
• MultiConnector: advanced multi-path routing
• DistributionGrid: P2P agent discovery and remote handoff

Memory and context.

• ContextBank: persistent, global, thread-safe memory across runs, with mutex-protected writes (emplaceWithMutex)
• Page Keys and MiniBanks: namespaced memory slots
• Semantic Compression: Legend-backed prompt compression for token efficiency
• Remote Memory: distributed memory across nodes
• Memory Introspection: controlled agent access to its own state

Safety and governance.

• KillSwitch: hard token-cap enforcement that terminates runaway agents
• Loop Limits: bounded iteration
• DITL Hooks: 7 developer-in-the-loop integration points
• Configurable Timeout/Retry: failure recovery per pipe
• Snapshot state restoration: pause and resume mid-pipeline

Tooling and integration.

• PCP (Pipe Context Protocol): multi-language tool calling with AST validation, supports Kotlin, JavaScript, Python
• TraceServer: real-time web dashboard for agent traces
• MCP (Model Context Protocol) bridge/server: turn any agent into an MCP endpoint
• Tuner: model tuning utilities
• Provider integrations: AWS Bedrock, OpenRouter, Ollama, generic OpenAI-compatible endpoints

Reasoning and optimization.

• Chain-of-Draft: 75% token reduction in reasoning chains
• Reasoning Pipes: chain-of-thought with structured prompts
• GraalVM Native Image: compile the whole runtime to a shared library for iOS, Android, embedded, edge

The philosophy: ship the full product. The tier is the contract, not the capability.

The Pipe tier is for the open-source ecosystem, the research community, and the teams that want to read every line of code that runs in production. The Pipeline tier is for closed-source startups below $1M revenue and for every FOSS project that depends on TPipe. The Manifold tier is for closed-source organizations above $1M revenue that need the license and the priority email support. The Substrate tier is for enterprises that need the relationship, the bespoke contract, the dedicated engineer, the custom roadmap commitment, the custom SLA, the custom hardware support, the custom NDA terms, the custom deployment model, and the custom feature delivery schedule.

The product is the same on every tier. The customer picks the contract that matches the legal posture. Ten Trillion Triangles builds the contract that fits the customer.

The 3-year TCO comparison

The cleanest way to compare is over a 3-year horizon for the same workload: a 10-engineer team, production-grade agents, ~200M LLM tokens per month, one vector database, one production runtime, full observability.

Numbers below are estimates for the typical 3-year run. SaaS prices are the published rate. LLM tokens are the same for everyone. Engineer build cost is amortized over 3 years.

Stack	Year 1	Year 2	Year 3	3-Year TCO
Self-hosted LangGraph + Langfuse + DIY memory	$200K build + $1K LLM (Qwen 30B self-hosted) + $6K infra = $207K	$1K LLM + $6K infra = $7K	$1K LLM + $6K infra = $7K	$221K
LangSmith Plus (10 seats) + LangGraph Platform + LlamaCloud Pro	$4.7K seats + $24K deploys + $6K LlamaCloud + $30K LLM (GPT-5.5) + $6K infra = $70.7K	$70.7K	$70.7K	$212K
CrewAI Pro ($1K/mo) + LLM tokens + vector DB	$12K CrewAI + $30K LLM (GPT-5.5) + $1.2K vector + $6K infra = $49.2K	$49.2K	$49.2K	$148K
CrewAI Enterprise (custom)	$80K CrewAI + $30K LLM (GPT-5.5) + $6K infra = $116K	$116K	$116K	$348K
LlamaCloud Enterprise + LLM tokens	$50K LlamaCloud + $20K LLM (Sonnet 4.6) + $6K infra = $76K	$76K	$76K	$228K
Haystack Enterprise Platform + LLM tokens	$60K Haystack + $20K LLM (Sonnet 4.6) + $6K infra = $86K	$86K	$86K	$258K
Microsoft Copilot Studio ($200/pack) + Foundry Agent Service + LLM	$24K Studio + $30K Foundry + $3.6K M365 + $30K LLM (GPT-5.5 via Azure) + $24K Azure infra = $111.6K	$111.6K	$111.6K	$335K
Google Vertex Agent Engine + ADK (self) + LLM	$96K Vertex compute + $9K LLM (Gemini 2.5 Pro) + $6K infra = $111K	$111K	$111K	$334K
OpenAI Agents SDK + ChatGPT Enterprise (10 seats)	$7.2K ChatGPT seats + $30K LLM (GPT-5.5) = $37.2K	$37.2K	$37.2K	$112K
Ten Trillion Triangles TPipe Manifold + BYO LLM	$7.5K Manifold + $1K LLM (Qwen 3 30B / Ollama) + $6K infra = $14.5K	$14.5K	$14.5K	$43.5K

Ten Trillion Triangles TPipe Manifold lands at $43.5K over 3 years, the cheapest line on the table once the LLM line reflects realistic model choices. The OpenAI Agents SDK + ChatGPT Enterprise line at $112K assumes GPT-5.5 frontier rates; a team on GPT-4o or Sonnet 4.6 would land closer to $60K to $80K. The DIY self-hosted line is the cheapest in cash if you ignore the engineer-months, and the most expensive in cash if you count them.

What TPipe wins on is the capability per dollar at flat rate. Manifold at $7,500 per year gives you ContextBank, KillSwitch, Manifold, Junction, DistributionGrid, TraceServer, PCP, MCP, and Tuner with no per-call or per-seat metering. Every other line above either gates capabilities behind a higher tier, charges per call, charges per seat, or makes you build the missing pieces in engineer-time.

The OpenAI line is cheaper than TPipe only on the per-token rate, and only if the team is 100% committed to OpenAI models. The moment a team wants Claude, Gemini, a local Ollama model for cost or compliance reasons, or a fallback provider, the comparison flips. TPipe is model-agnostic out of the box. Bring your own model. Switch providers in a config change.

The Microsoft Copilot Studio line lands at $335K, one of the most expensive options on the table and the most popular one in the Fortune 500, because the seat is bundled with the productivity suite and the procurement path is a single PO. The cost is real. It is also invisible, because the line items are spread across M365, Azure, and the Foundry SKU.

The Google Vertex line lands at $334K, one of the most expensive greenfield options on the table. ADK is free. The Vertex Agent Engine is the bill. Cloud Run pricing scales with deployment uptime, and agent runtimes tend to be long-lived. Gemini’s lower per-token rate partially offsets the compute cost but does not close the gap.

The bottom line

The 3-year TCO spread in the table above is $304.5K: $43.5K at the cheapest stack to $348K at the most expensive. The LLM line is not identical across rows. Frontier-locked stacks (OpenAI, Microsoft, CrewAI) use GPT-5.5 or Opus at $5 to $30 per million tokens. Open-source-friendly stacks (TPipe, self-hosted) use Qwen 3 30B or Ollama at fractions of a cent. The spread is the framework, the runtime, the build-out, and the model choice. Some teams pay it in cash to a vendor. Some teams pay it in engineer-months to themselves. Some teams skip it and ship agents that do not survive contact with production. The bill arrives either way.