Sample code located at https://github.com/taswar/CohereCommandAPlusDemo

Enterprise AI teams have a familiar problem. You need multilingual support because your users are in Germany, Japan, and Brazil. You need document understanding because half your data lives in scanned PDFs and screenshots. You need tool calling because your agents have to actually do things, not just talk about them. And you need reasoning across long contexts because business decisions rarely fit in 4K tokens.

Historically, that meant stitching together three or four models. One for translation. One for OCR. One for reasoning. Something in the middle to orchestrate all of it. That is a lot of moving parts to keep in production.

Cohere Command A+ in Microsoft Foundry is designed to collapse that stack.

Announced as a Direct from Azure model, Command A+ is Cohere’s latest open enterprise model — and their first mixture-of-experts (MoE) architecture. It brings together reasoning, long-context understanding, tool use, multilingual support, and multimodal input in a single model.

Honestly, this is the sort of release that matters more than the benchmark numbers suggest.

What Makes Command A+ Different

Three things are worth understanding before you evaluate this model.

It is a Mixture-of-Experts Model

218 billion total parameters. 25 billion active per token. That is roughly 11.5% activation.

If you have not worked with MoE architectures before, the short version: instead of every token going through every parameter, the model routes each token to a subset of “expert” sub-networks. You get the knowledge coverage of a large model at the inference cost of a much smaller one.

For enterprise workloads, this matters. Cohere lists hardware requirements of 1× B200 or 2× H100 at W4A4 quantization. That is a genuinely deployable footprint for a model with this level of capability.

It Speaks 48 Languages

Not “supports” — actually speaks. All official EU languages included. If you are building for a global enterprise, that is a compliance requirement in many places, not a nice-to-have.

It Handles Text and Images Together

Command A+ accepts text and image inputs. That opens up document processing scenarios where the useful information lives in charts, tables, screenshots, or scanned records — not just plain text.

The Full Spec Sheet

cohere_foundry_spec_table

cohere_foundry_spec_table

Where This Model Actually Fits

Cohere positions Command A+ for four workload types. Each one lines up with a real problem developers deal with in production.

1. Enterprise Agents

Agents that reason, plan, and call tools across multi-step workflows. Command A+ handles all four capabilities — reasoning, planning, tool use, and long context — in one model. If you are building agentic systems today with three different models glued together, this is worth evaluating as a consolidation play.

2. Knowledge Assistants and RAG

RAG applications over internal documents, policies, contracts, and knowledge bases. The 128K context window means you can fit a lot of retrieved chunks into a single call without aggressive truncation. Combined with multilingual support, this is well suited to global enterprises where the same knowledge base needs to answer questions in multiple languages.

3. Document Analysis Workflows

Summarising reports, extracting terms from contracts, comparing policies, analysing research papers. The multimodal input means it handles documents that mix text with charts, tables, and images — the kind of enterprise content where “just OCR it and pass to an LLM” produces bad results.

4. Multilingual Applications

Global customer support. Regional compliance reporting. Cross-market analytics. Command A+ was designed with 48-language coverage as a first-class feature, not a translation layer bolted on afterward.

That is a pretty focused positioning. This is not a general-purpose chatbot model — it is an enterprise agent and document processing model.

Enough Theory. Let’s Actually Call It from C#

Here is a working .NET console app that calls Command A+ through Azure AI Foundry. I am using the Azure AI Inference SDK with DefaultAzureCredential for Entra ID auth — no API keys in code.

Prerequisites

Set your environment variables:

Program.cs — Contract Analysis Example

Rather than a “tell me a joke” demo, let’s do something that actually shows what Command A+ is good at. Here is a service that analyses a business contract and returns a structured summary — the kind of workflow you might drop into a document management pipeline.

Expected Output

Command A+ should return something like:

That is structured, actionable output — the kind of thing you can pipe directly into a downstream review workflow or store as document metadata.

Multilingual Example — Same Prompt, Different Language

One of the more interesting things about Command A+ is that you can run the same structured prompt with content in any of 48 languages and get consistent output structure back. Here is the same analysis pattern with a German contract excerpt:

Sample output of Multilingual

You get the same JSON structure back, with German-language terms parsed correctly and the analysis delivered in English. That is genuinely useful for global enterprises where legal teams work in local languages but reporting rolls up centrally.

Why Run It on Microsoft Foundry Instead of Cohere Direct?

Cohere offers Command A+ through their own API and on Hugging Face under Apache 2.0. So why bother with Foundry?

If you are already in Azure, Foundry gives you a few things you cannot easily replicate elsewhere:

  • Entra ID authentication — no API keys in source, no separate credential management
  • Enterprise governance — data residency, compliance, audit logging built into the platform
  • Side-by-side model evaluation — compare Command A+ against Kimi K2.7 Code, Claude Opus 4.8, or GPT-4o on the same dataset without setting up multiple SDKs
  • Unified billing — one Azure invoice covers all models, not one bill per vendor
  • Foundry Agent Service and RAG pipelines — plug Command A+ directly into Foundry’s agentic infrastructure

For an enterprise team already invested in Azure, Foundry is the easier operational choice. For solo experimentation or non-Azure deployments, direct API or self-hosting on Hugging Face makes sense too.

Final Thoughts

Command A+ is not the flashiest model announcement of the year. It is not going to top general-purpose benchmarks. But it is genuinely positioned for a class of enterprise problems that have been underserved: multilingual agentic workflows over multimodal documents at reasonable cost.

If your team is building enterprise agents, RAG applications, or document analysis pipelines — especially with multilingual requirements — this is worth evaluating alongside your existing models. At $0.80 input / $3.20 output per million tokens, it is priced to compete for real production workloads.

The MoE architecture is also worth watching more broadly. Expect more of the frontier lab releases over the next 12 months to go this route. Command A+ is an early mainstream option to build intuition against.

If your team already builds RAG over internal documents, ships multilingual applications, or runs agentic workflows in production — this is one worth wiring into your evaluation harness. 🙂

Resources


Related posts:

  1. Kimi K2.7 Code is Now Available in Microsoft Foundry
  2. Claude Opus 4.8 is now available in Microsoft Foundry
  3. GPT-5.5 Now in Microsoft Foundry (GA): Build Reliable Agents for Real Enterprise Work
  4. Grok 4.3 in Microsoft Foundry: A Practical C# Guide for Developers