The enterprise AI platform your company controls

Every model your teams need. Every control your company needs.

Broccoli turns your internal knowledge, assistants and APIs into a governed AI experience. Your people get one place to work with the best model for each task — your organization keeps the permissions, the spending limits and the data boundaries.

An animation: a question in the Broccoli chat is answered with the model chosen for that message while each governed step is recorded; coding tools reach the company's models through one LLM Gateway endpoint, where a call over its spending limit is refused before it reaches the provider; and every call lands in the cost ledger by person and model.
The problem

Rolling out AI is easy. Answering for it is not.

Most organizations already have AI in the building. What they usually don't have is a way to say who may use what, over which data, at what cost.

Seats nobody can see into

Individual subscriptions spread across teams, corporate documents pasted into tools the company doesn't administer, and no way to answer which assistant reads which data.

In Broccoli: every assistant carries object-level permissions — who may see it, use it, edit it, share it, administer it.

An invoice with no owner

Consumption grows month over month, finance asks who spent it, and nothing stops one enthusiastic user from burning the quarter's budget in an afternoon.

In Broccoli: one wallet per organization plus a spending policy per person — and a cost ledger that says where it went.

Knowledge that never arrives

The answers live in documents, in spreadsheets and behind internal APIs. A generic chatbot reaches none of them, so people go back to asking a colleague.

In Broccoli: knowledge bases in three scopes, plus internal APIs imported from OpenAPI and tools served over MCP.

What Broccoli is

A platform to build, share, run and control AI assistants.

Models

Choose and orchestrate

Pick the model per message or per scheduled task across OpenAI and Azure OpenAI, Anthropic, Google Gemini, DeepSeek and xAI. Compose specialist assistants into a swarm with a coordinator that delegates.

Knowledge and tools

Connect what you already have

Knowledge bases for the assistant, for a single conversation and for a shared project. Internal systems come in as tools through OpenAPI import and MCP servers.

Permissions

Share under control

Tenants, groups, projects and object-level permissions decide who sees, uses, edits and shares each assistant — including groups that administer without owning.

Operations

Run the operation

Credits, per-user policies, a cost ledger, scheduled tasks with execution history and an admin console with usage and spending metrics.

LLM Gateway

Your coding tools, billed to Broccoli.

Point Claude Code, VS Code or any OpenAI or Anthropic SDK at Broccoli. Your people sign in with one Broccoli token; the provider keys, the credit gate and the spending policy stay on the platform.

Three clients send requests through the Broccoli LLM Gateway: Claude Code over the Anthropic Messages protocol, VS Code with GitHub Copilot over OpenAI Chat Completions, and the OpenAI Python SDK over OpenAI Responses. Each request is checked for the person's Broccoli token, the organization's credit, the person's spending policy and whether the model is enabled, then relayed to the provider with a key the developer never sees. The streamed answer comes back unchanged and every call lands in the cost ledger with its user, model and credits.

One credential per person

The same Broccoli token works for the API and the IDE. Revoke it and every provider is cut off at once.

The provider key never leaves

Developers never see it, so it cannot end up in dotfiles, shell history or screenshots.

Spend attributed and capped

Every call passes the same credit gate and per-user spending policy as the chat. Without credit, the call is refused before it reaches the provider.

Nothing intercepted

Requests and responses are relayed byte for byte. Streaming, tool calls, vision, extended thinking and prompt caching work as they do against the provider.

For administrators

Built for whoever has to answer for it.

Your administrators run your organization from one console: who joins, what each person is allowed to use, and how much they can spend. No ticket to open, no waiting on anyone else.

Users and access

Roles, groups and permissions that survive an audit conversation

Access is decided in three layers — where a person belongs, which groups they are in, and what each individual assistant grants them.

  • Three roles in your organization Owner, Admin and Member. Each person belongs to one organization at a time, so it is always clear which rules apply to them.
  • Groups with four roles Owner, Admin, Contributor and Reader. Groups are how you share assistants and projects with a whole team instead of person by person.
  • Permission per assistant For each assistant you decide who can see it, who can use it, who can edit it, who can share it and who can administer it.
  • Who uses it is not who edits it One group can use an assistant while another keeps it up to date. A team maintains a shared assistant without anyone having to hand over ownership.
  • A plan for each person, like an internal subscription Give each teammate their own spending plan — unlimited, a monthly allowance, a lifetime allowance, or blocked — and change it whenever their role changes.
Broccoli · Admin console — Users
Admin console, Users tab.
Cost governance

Money and permission are two different questions

  • One shared balance per organization Topped up under your contract, with an automatic monthly renewal that brings the balance back to your quota on a day you choose.
  • A policy per person Unlimited, monthly limit, lifetime limit or blocked — set as a default for the organization and overridden individually where needed.
  • Revocable bonuses Raise one person's ceiling for a period or for good, with an expiry frozen at grant time and a revocation that records who revoked it.
Broccoli · Admin console — Credits
Admin console, Credits tab.
Visibility

What was used, by whom, on which model, at what cost

The console answers the questions that come up in a budget review, without anyone exporting a spreadsheet by hand.

  • Charged against real A time series comparing what was billed internally with what the models actually cost.
  • Adoption over time Conversation growth, daily metrics and a ranking of the heaviest consumers.
  • Distribution per model Which models the organization actually reaches for, so the catalogue can be trimmed or extended on evidence.
  • Tool usage record Which tool ran, for which user, in which session, with which assistant and model, plus status, duration and error — stored without raw payloads by design.
Broccoli · Admin console — Overview
Admin console, Overview tab.
Capabilities

What your people get on the other side of the login.

Governance is what you buy. This is what your teams use every day.

Multi-model, per message

OpenAI and Azure OpenAI, Anthropic, Google Gemini, DeepSeek, xAI and a routing model, with a cost multiplier shown at selection time.

Assistants and swarms

Configure a specialist with its own prompt, tools and knowledge — or compose several under a coordinator that delegates, with a default member.

Knowledge in three scopes

Documents attached to an assistant, to a single conversation or to a shared project, kept in separate indexes and combined only where they belong.

Your APIs become tools

Paste an OpenAPI specification and its operations turn into callable tools, with API-key auth, a server override and several APIs per assistant.

MCP servers

Connect remote tool servers per assistant, with no auth, an API key, or OAuth 2.1 including issuer discovery and token storage.

Scheduled work

Once, hourly, daily, weekly, monthly or a validated cron expression — with pause, resume, run now and a full execution history.

Artifacts you can keep

Sandboxed live HTML, editable Excalidraw canvases, Mermaid diagrams, charts and images, all persisted in a gallery you can come back to.

Keeps working while you do something else

Answers appear as they're written, and keep going even if you switch to another chat or close the tab. Come back and pick up where it left off.

A REST API and its schema

Assistants, chats, projects, tools, groups, billing, scheduling and administration over HTTP, with a generated OpenAPI schema and Redoc documentation.

A working tool catalogue

Web search, deep search, web fetch, ArXiv, chart generation, image generation, spreadsheet querying, translation of DOCX and PPTX, and email sending.

Shared projects

A workspace with a standing instruction, a shared knowledge base and its own conversations, with Owner, Admin, Contributor and Reader roles.

Built to be multilingual

The interface and the product speak your team's language, wherever they are.

Identity and security

How people get in, and what they carry with them.

Single sign-on

Your people sign in with the identity provider your organization already uses. New accounts can be created automatically on first sign-in.

Named API tokens

Tokens are issued per user and per organization, named, and given a validity of 30 to 360 days or none at all. Blocking the user revokes them all.

Also: tokens work on the streaming endpoints, so automation gets the same experience as the browser.

Secrets that stay out of prompts

Environment variables belong to a user or to a single assistant, can be marked as secret, and are injected when a tool runs rather than pasted into a conversation.

Roadmap: external key-management integration and automatic rotation are not implemented.

Fit

Where Broccoli is the right answer — and where it isn't.

The real alternative most teams are weighing isn't another platform — it's giving everyone their own AI subscription and hoping that's enough.

Pick Broccoli when

  • Different teams need different assistants working together, not one general-purpose chat window.
  • Someone has to answer for what each person spent, not just for the total invoice.
  • The right answer depends on your own documents and internal APIs, not just what a model already knows.
  • You want assistants your teams can maintain together, not ones tied to whoever signed up first.
  • You don't want your AI tied to one model vendor's roadmap — your provider keys, your model choices.

Look elsewhere when

  • Your people only need one vendor's assistant, used exactly as that vendor ships it.
  • A polished native mobile app is the main way your people will use AI.
  • You need it running today with a credit card — there is no self-service plan.
  • Your procurement already requires certifications and provisioning standards only a handful of vendors publish.
  • Managing individual subscriptions is simpler for you than operating a platform.
FAQ

The questions that come up first.

Which models can we use?

OpenAI and Azure OpenAI, Anthropic, Google Gemini, DeepSeek and xAI, plus a routing model, using your own keys and deployments. The catalogue is administered inside the platform: pricing per million input, output and cached-input tokens, a recommended flag, a description and a temperature per model.

How do we control what people spend?

Your organization holds one wallet. Each person gets a policy — unlimited, a monthly limit, a lifetime limit or blocked — inherited from an organization default and overridable individually, with revocable bonuses on top. Every run checks the wallet and the personal ceiling before it starts, including scheduled tasks, and a refusal tells you which of the two triggered.

How do we buy it?

Through a conversation. There is no self-service checkout: we scope the deployment, the number of organizations and the model access with you, and credits are provisioned administratively. Use the form below and tell us roughly how many people you expect to onboard.

Talk to us

Tell us what you are trying to govern.

We would rather understand the constraint than send a brochure. Write what you have in mind and someone who works on the product answers.

  • A working session over the real product, not a slide deck.
  • A straight answer on what the platform does not do yet.
  • Pricing scoped to your deployment, since there is no self-service plan.

Up to 2,000 characters.