What Is CompanyFabric? One API for Multiple AI Models

Builder brief

Format

guide

Stack

General

Reading time

10 min

Building with AI often starts with one model and quickly turns into several accounts, API formats, billing systems, and keys. A team may want one model for coding, another for fast classification, and a third for difficult reasoning. Switching between them usually creates infrastructure work that has little to do with the product being built.

CompanyFabric is a hosted AI model gateway that places models from multiple providers behind one account and API key. It supports an OpenAI-compatible endpoint, a browser-based chat and playground, coding-tool integrations, usage tracking, prepaid credits, subscriptions, and bring-your-own-key routing.

This guide explains how CompanyFabric works, who it is useful for, and how to make a first API call without locking an application to one model vendor.

What is CompanyFabric?

CompanyFabric is an abstraction and billing layer between an application and AI model providers. Instead of integrating each provider separately, a developer sends requests to CompanyFabric and chooses a model from its catalog.

The platform currently lists models from providers including OpenAI, Anthropic, Google, DeepSeek, xAI, Z.ai, Moonshot AI, Xiaomi, Meta, and Mistral. The catalog and model names change frequently, so treat the live model directory as the source of truth.

The main product surfaces are:

Surface	Best for
Chat and playground	Testing prompts and models without building an interface
Model Council	Comparing several model answers and receiving a synthesized verdict
OpenAI-compatible API	Adding multi-model AI to an application or backend
Coding integrations	Using models in tools such as Claude Code, Cursor, Cline, Continue, and Aider
BYOK	Routing through provider keys you already own

Why use a model gateway?

Direct provider integrations are often the right choice when an application depends on one vendor-specific capability. A gateway becomes useful when a team wants flexibility across providers without maintaining a separate client, key, and cost dashboard for each one.

CompanyFabric can help with:

• testing the same prompt across different models;
• routing simple tasks to lower-cost models;
• using a stronger model only for difficult requests;
• changing models without rewriting the surrounding application;
• giving each service or coding agent its own key and budget;
• viewing usage and cost from one place;
• keeping existing provider contracts through BYOK.

The gateway does not make models interchangeable in every respect. Providers still differ in context limits, tool use, structured output, latency, safety behavior, and model-specific features. The value is a common entry point, not the claim that every model behaves the same.

How the CompanyFabric API works

CompanyFabric exposes an OpenAI-compatible chat completions API. In a typical server application, the developer changes the base URL and uses a CompanyFabric API key.

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.COMPANYFABRIC_API_KEY,
  baseURL: 'https://api.companyfabric.com/v1',
});

const response = await client.chat.completions.create({
  model: 'companyfabric/auto',
  messages: [
    {role: 'user', content: 'Summarize this support conversation in five bullets.'},
  ],
});

console.log(response.choices[0]?.message?.content);

Keep that key on the server. Do not embed it in a React Native, Flutter, iOS, Android, or browser application where users can extract it. Mobile and web clients should call an authenticated backend endpoint that applies permissions, rate limits, and product-specific rules.

The official quickstart also recommends adding a budget cap to the key before using it in an agent or automated workflow.

Exact models and routing modes

A request can name a particular catalog model when the product needs predictable behavior. CompanyFabric also advertises routing aliases such as:

• companyfabric/auto for automatic selection;
• companyfabric/fast when latency matters;
• companyfabric/cheap for cost-sensitive work;
• companyfabric/best for higher-capability routing;
• companyfabric/code for software-development tasks.

These aliases make experimentation easier, but they also change an important assumption: the underlying model may vary. Store the served model, cost, latency, prompt version, and outcome if you need to compare quality over time.

For a high-stakes workflow, use a named model until you have an evaluation suite that proves a routing mode meets your requirements.

Using CompanyFabric without writing code

Developers are not the only users of the platform. The browser-based chat can be used to try a model before integrating it.

The workflow is straightforward:

1. Create an account.
2. Open the CompanyFabric chat.
3. Select a model or an automatic mode.
4. Enter a prompt.
5. Review the response and the displayed cost.
6. Compare another model before choosing one for production.

The platform also offers a Model Council. It sends one question to multiple models, then asks another model to summarize areas of agreement, disagreement, and the most useful answer.

Council-style comparison can be useful for architecture reviews, code review, or decisions where hidden assumptions matter. It should not be treated as proof. Several models can repeat the same mistake, especially when they share similar training data or receive incomplete context.

Using CompanyFabric with Claude Code and other tools

CompanyFabric publishes integrations for coding agents and editors. Its Claude Code guide describes how to point Claude Code at the gateway and select either an Anthropic model or a model from another provider.

The broader pattern is:

1. Create a separate CompanyFabric key for the tool.
2. Set a low budget cap while testing.
3. Configure the tool's base URL and authentication variables.
4. Choose a model appropriate for the task.
5. Review cost and output after every long agent run.

Separate keys improve attribution and revocation. If a CI job, teammate, backend service, and coding agent share one key, it becomes difficult to understand which workflow created a cost spike.

CompanyFabric lists integrations for Claude Code, Cursor, Cline, Continue, Aider, and OpenClaw. Verify each integration's current environment variables and compatibility before changing a production development setup.

How billing and BYOK work

CompanyFabric currently offers several ways to pay for usage:

• monthly plans with a usage allowance;
• prepaid credits shared across models;
• bring your own provider keys;
• a separate pass oriented around the hosted chat and Council.

On its BYOK documentation, CompanyFabric says provider keys stored in its vault are encrypted and that BYOK requests have no added platform fee. Calls for that provider are billed by the provider, while the gateway continues to supply routing and centralized usage visibility.

BYOK changes the billing path, not the security responsibility. Review the provider permissions on every key, rotate it when needed, and remove access when a project ends. Also review CompanyFabric's current security, privacy, and data-processing terms before sending customer or confidential data through the service.

Prices and allowances can change. Use the live pricing page and model catalog rather than copying an old cost estimate into a product plan.

A practical setup for an application

1. Define the AI task

Start with a narrow function such as support-ticket classification, feedback summarization, content moderation assistance, or code explanation. Define an expected input and an output schema.

2. Evaluate two or three models

Build a small set of real examples and score each model for accuracy, latency, cost, and consistency. Do not choose a model from a leaderboard alone.

3. Create a dedicated key

Use one key for the specific environment or service. Add a budget cap and keep the key in a secret manager or protected environment variable.

4. Add a server-side gateway module

Keep provider calls behind one internal interface in your own backend. Even when CompanyFabric already provides a common API, your module should enforce user permissions, quotas, logging, retries, and fallbacks.

5. Capture useful telemetry

Log metadata rather than raw sensitive prompts by default:

• product feature;
• user or tenant identifier;
• requested and served model;
• prompt version;
• latency;
• token usage and cost;
• success, rejection, timeout, or fallback;
• user acceptance or correction.

6. Add a fallback policy

Decide what happens when a model is unavailable, slow, too expensive, or returns invalid structured output. A safe fallback may be another model, a non-AI workflow, a retry queue, or a clear message to the user.

7. Review quality regularly

Models and routing behavior change. Re-run the evaluation set when you switch models, enable automatic routing, or change a prompt that affects customer-facing output.

Where CompanyFabric is most useful

CompanyFabric is a strong candidate for:

• teams comparing several models before committing to one;
• applications that need cost-aware model routing;
• agencies operating multiple client AI projects;
• coding teams that want model choice inside agent tools;
• products that want one balance and usage view across providers;
• developers who already have provider keys but want a common endpoint.

It may be unnecessary for an application that uses one provider, relies heavily on a proprietary provider-specific feature, or must keep every inference call inside infrastructure it directly controls.

Risks and tradeoffs

Adding a gateway creates one more dependency in the request path. Evaluate:

• data retention and privacy terms;
• regional or compliance requirements;
• gateway and provider uptime;
• latency added by routing;
• model-version changes;
• portability of logs and usage data;
• behavior when credits, allowances, or provider keys are unavailable;
• access controls for the dashboard and API keys.

For sensitive products, send a minimal data set, remove unnecessary personal information, and document which subprocessors receive the request.

How to try CompanyFabric

The lowest-friction options are the browser chat and the official API quickstart. CompanyFabric says new accounts receive starter credit and can try its automatic routing mode without adding a card; confirm the current offer during signup.

Use the first session to answer one practical question:

Can we improve quality or reduce cost by choosing a different model without changing our product architecture?

If the answer is yes, add a small evaluation suite and integrate through your backend. If the answer is no, a direct provider integration may remain the simpler system.

Dopebase teams building an AI feature can also explore AI Skills, custom API development, and AI integration services for the application layer around the model call.

FAQ

Is CompanyFabric an AI model?

No. It is a gateway and product layer that provides access to models from multiple companies through a common account and API.

Do I need to rewrite an OpenAI SDK integration?

Usually not entirely. CompanyFabric exposes an OpenAI-compatible endpoint, so a basic integration can use the same SDK with a different base URL, key, and model identifier. Provider-specific features still need testing.

Can I use my own provider API keys?

Yes. CompanyFabric documents a BYOK vault for provider keys. Review its current security terms and restrict each provider key to the smallest practical scope.

Can I limit what an AI agent spends?

CompanyFabric documents per-key budget caps. Use a separate capped key for each autonomous agent, CI workflow, service, or teammate.

Is CompanyFabric only for developers?

No. Its hosted chat and Model Council can be used without building an API integration, while developers can use the same account for applications and coding tools.