What looks wrong?

We say this article was researched and checked. If it is wrong, we want the counter-example.

Skip to content
Su-Jin Bae

Nov 18, 202616 min read

When a prototype has to become a service, teams leave GitHub Models. They need billing they control, models beyond the catalog, and automation, whether wired up in code or in a workflow builder like Activepieces, with access controls around the model call.

A model host fixes the first two. The third is a separate problem.

What works in the playground still needs a production home.

GitHub Models is a catalog and playground inside GitHub where developers try hosted models, compare outputs side by side, and call them through an API using their GitHub identity. It's built for evaluating a prompt against a model quickly, not as a deployment target.

Why teams leave GitHub Models

Four reasons teams outgrow it

Within the first week, an unattended pipeline hits the free-tier ceiling, and the failure shows up as dropped requests rather than a clear error in your own logs. The rate limits are shaped for experiments.

If your evaluation picks a model GitHub doesn't list, you can't use it there, because the catalog is limited to what GitHub lists.

GitHub also ties identity to accounts, so a job that calls a model under one developer's credentials stops working when that person leaves.

There's no workflow layer. The model call is one step, and retries, approvals, and a record of who triggered what all live somewhere else.

How each option was judged and when it was checked

We asked four questions of every entry. How is it billed? What does it do better than the others? Where does it stop? And who is it for? Each answer comes from the vendor's own documentation, not from third-party reviews.

Read the entries by job: the first three give you model access, while Activepieces, an MIT-licensed core, handles the automation around a model call. They're not substitutes for each other, so the table compares what each one covers rather than ranking them.

Activepieces AI providers configuration showing active keys for Anthropic, Google Gemini, and OpenAI with their project…

Read the limit column first: it shows which of the problems above each option leaves open. The table below sets the four options against the same four questions.

Option Price model Main strength Main limit Who it suits
OpenRouter Pay per token, billed through OpenRouter One API in front of models from many labs Routes model calls only; no workflow layer Teams that want to switch models without rewriting integrations
Microsoft Foundry Azure billing, per use or reserved capacity Fits Azure identity, networking, and governance Needs an Azure footprint and setup Organisations already running on Azure
Hugging Face Inference Providers Pay per request at the rates of the underlying provider Wide access to open-weight models Availability and behaviour vary by provider Teams building on open models
Activepieces Self-hosted or cloud; unlimited flows on every plan, including free Automation, access control, and audit around the model call Not a model host; you bring your own model access Teams whose open problem is the workflow, not the model

Checked 18 November 2026 against each vendor's public documentation.

Which limit hurts most depends on which problem you hit first, and the next section starts with the model-access side.

The fastest way to settle a shortlist is to try one. Activepieces is free to try, no credit card.

OpenRouter unified API

A team gets a single key, a single bill and a single request format instead of a separate integration per provider. That is OpenRouter: one API that fronts many vendors' models.

One single API key card on the left connected by lines to several model provider boxes on the right, with one single…

What it does better than GitHub Models

Trying models and routing live traffic are different jobs. GitHub Models is a catalogue for the first; OpenRouter is built for the second.

One endpoint reaches models from Anthropic, OpenAI, Google, DeepSeek, Mistral and others, so changing models means changing a string, not rewriting a client.

With routing and fallbacks, a request can go to another provider when one errors or rate-limits, so a single vendor's outage doesn't have to become your outage.

OpenRouter pricing per model

OpenRouter lists a per-token price for each model on its site, and the Claude family shows how far those prices spread. According to Straitly's LLM API price index, Haiku 5.5 costs $0.50 per million output tokens, which makes cost a major factor in model choice.

At $10, Sonnet 5.5 costs 20 times Haiku's rate, per Straitly, making Haiku the economically rational default choice. Dev's analysis puts Opus 5.5 at $20, twice Sonnet's, so the cost differential becomes central to model selection decisions.

Fable 5.1, the earlier Fable release, was priced at $50 by Straitly's measure, which was 100 times Haiku's rate.

It plots those four output prices side by side.

Leave a high-volume step such as classifying inbound tickets on Fable instead of Haiku and it costs a hundred times more, and nothing in the invoice flags the mistake.

Because OpenRouter makes switching a one-line change, that lever is easy to pull. It's just as easy to pull in the wrong direction without noticing.

OpenRouter limits and best-fit teams

Because OpenRouter is an intermediary, every request passes through a third party between your application and the model vendor. It doesn't replace the identity, private networking or regional controls of a cloud platform.

Because OpenRouter makes switching a one-line change, that lever is easy to pull. It's just as easy to pull in the wrong direction without noticing.

If a security review asks where prompts travel and who can see them, that extra hop is the first thing it flags.

It suits teams that want many vendors' models behind one key, want to compare costs by model, and have no cloud-tenancy requirement.

After the model responds, OpenRouter has nothing to say about who may trigger the workflow, what gets logged, or how changes are promoted.

Microsoft Foundry platform

The model-side gaps a prototype hits first close on Microsoft Foundry, formerly Azure AI Foundry, the production tier Microsoft builds on the same model catalogue as GitHub Models. The gaps around the workflow stay open.

The upgrade path from GitHub Models

To move a prototype built against GitHub Models to Foundry, you swap an endpoint and credential for a deployment inside an Azure resource.

The prompts and the calling code mostly carry over, so the move is mainly a change of where the model runs and who pays for it.

Foundry adds a set of production controls, per Uptime.

The controls are deployment types, which let you choose how a model is provisioned for your traffic; quota per deployment, so one workload can't consume the capacity another one needs; billing per resource, so spend is attributed to the team or project that incurred it; a 99.9% availability SLA; and ISO 27001 certification.

A server rack with three capacity bars, one per deployment, each with its own quota slot and a billing statement sheet…

If downtime runs beyond the stated threshold, the SLA gives you a contractual remedy, which a free prototyping tier doesn't offer.

Through the certification, a security reviewer can check Microsoft's audit scope instead of taking your word for the platform. Neither of these covers your own workflow code, which is outside Microsoft's scope.

A reviewer who asks about the code around the call rather than the model gets a different answer from Activepieces.

Role-based access, single sign-on, SCIM provisioning, audit logs, log and event streaming, separate environments and git sync all ship in the one product, and the set is identical self-hosted or on cloud.

The core is MIT-licensed, the enterprise directories in the repo's packages/ee/ sit under a separate commercial licence, and MoneyGram, Moneypenny, Alan and FundingSocieties run it in production.

Pricing and quotas per Microsoft's docs

Pick a deployment type and the pricing follows. Some types bill by tokens consumed, others reserve capacity, and the rates differ by model, so Microsoft's pricing page is the source to check before you commit.

Skip the quota step and you find out when a launch-day request is throttled because the quota was never raised. Quota is assigned per deployment and per region.

Billing attaches to the Azure resource, which gives finance a clean line from a cost to its owner. It also means a cost report is only as clear as your resource and subscription layout.

The main limit is Azure setup complexity. Before the first call, someone has to settle the subscription, the resource group, the role assignments and the regional quota.

The prototype took an afternoon. Now it depends on a person with Azure admin rights, and a failed deployment can come from permissions rather than from anything in the model.

Foundry fits organisations that already run an Azure tenant and have people who administer it. For them, the identity, billing and compliance work is largely done, and Foundry slots into it.

A team without that footing pays the setup cost before it gets any of the controls above.

Hugging Face Inference Providers routing API

A team needs one Hugging Face account and token rather than a separate account with each provider. Hugging Face Inference Providers is a single API that routes a request for an open-weight model to one of several third-party inference companies.

One brass key fitting a row of differently shaped, differently coloured doors along a street, a single person holding the…

Open model access

You name a model from the Hugging Face Hub, and the router sends the call to a provider that serves it. You can leave the choice of provider to the router or pin one yourself.

The result is that open-weight models such as Mistral Small 4 or Z.ai GLM 5.3 sit behind the same client code, and changing models is a string change rather than a new integration.

The catch is that the Hub's breadth isn't the same as the providers' coverage. A model can exist on the Hub without any provider currently serving it, so check that a model is actually served before you design a workflow around it.

Activepieces workflow builder showing a Page Audit step using Text AI with OpenAI GPT-4o to create an SEO audit.

The included credit is small. According to Hugging Face's pricing documentation, the Free plan includes $0 of monthly Inference Providers credit. That means a free account can find models but can't run real traffic without a payment method attached.

$2 per month is what the PRO plan includes, and each Team or Enterprise seat gets the same, so growing your team doesn't increase your per-person cost.

Two dollars covers a few experiments, not a production workload, and a seat's credit doesn't stack into a shared pool you can budget against. Past the credit, usage is pay-as-you-go.

Monthly Inference Providers credits by Hugging Face plan: Free $0, PRO $2, Team/Enterprise seat $2.

Included monthly inference credit by Hugging Face plan

Because the credit is nearly flat across plans, upgrading a plan doesn't change your cost model. Your bill is set by call volume and the model you pick, so estimate those before you commit.

The main limit is variability. Availability and latency differ by provider, and the same model can respond at different speeds depending on which one the router picks.

For a batch job that tolerates a slow response, this is a nuisance. For a customer-facing step with a response deadline, an unpinned route is a failure mode: the call that took two seconds yesterday can take longer today with no change on your side.

Pin a provider and the swing shrinks, but you are tied to that provider's uptime.

It suits teams that want to compare open-weight models quickly, avoid managing several provider accounts, and accept pay-as-you-go billing. It suits teams that need a latency guarantee less well, unless they pin a provider and measure it themselves.

Activepieces

Only when your use of GitHub Models was an AI step inside an automation is Activepieces an alternative to it. It's an open-source automation platform with 25,578 GitHub stars, not a model host.

If the failure you are guarding against is a prompt that ran in a playground and then had no controlled path into production, this is the product that addresses it. If the failure is "we need a model endpoint", it doesn't.

When it is the right alternative and when it is not

Take the case where someone wired a GitHub Models call into a script that fires on a webhook, summarizes a ticket, and posts the result somewhere. The model call was never the hard part.

Heatmap visualization of Strands Decider 2B benchmark test results with white and pink dots showing performance distribution.

The hard part is that the script has no access control, no record of who changed it, and no separate staging copy.

That's the problem Activepieces is built for: the flow around the model, where custom RBAC, audit logs, and environments with git sync answer those three gaps.

It's the wrong choice if you need a catalog of models to compare; its 750 integrations connect the apps around the model, not the models themselves, meaning you'd be comparing app partnerships rather than the models directly.

Use OpenRouter, Foundry or Hugging Face for that, and bring the key you get from them into Activepieces afterward.

What it does with a model key

The flow has three parts, in this order:

  1. A trigger.
  2. An AI step that holds your own provider key.
  3. An action.

The model provider sits outside the flow and is called from the AI step.

Look at the illustration below for that layout, and read it for where the key lives: inside the step you own, not in the provider's console and not in a shared script.

Provider management interface showing configured AI API keys for multiple platforms including Gemini, Anthropic, and OpenAI…

Modal dialog for enabling OpenAI as an AI provider in Activepieces Platform Admin, showing API key setup instructions and…

That means a key rotation or a provider swap is an edit to one step, and the audit log records who made it.

Because the provider is a separate dependency, you choose it. Pair a Claude Sonnet 5.5 key for general work with a cheaper model for high-volume steps, and change either without rebuilding the trigger or the action.

What follows from this is the limit: the step is only as available as the provider behind it.

Pricing and limit

Activepieces can be self-hosted or used as a cloud service. Check its pricing page for current plans rather than relying on a figure here, because I can't point to a confirmed one.

What the article does stand behind is that flows aren't metered out of reach: every plan, including free, has unlimited flows, and the core is MIT-licensed.

The limit is the one the layout shows. Activepieces doesn't supply the model. You still need an account with a provider, you still pay that provider's usage, and its outages and rate limits reach your flow.

Activepieces suits teams whose problem is the automation around the model, and who are willing to run or pay for that layer in exchange for control over it.

Activepieces is the better fit for teams whose GitHub Models use was an AI step inside an automation, and who need a controlled path from prototype to production.

The claim it rests on is governance in one product: RBAC, SSO, SCIM, audit logs, log and event streaming, environments and git sync, available self-hosted or on cloud with no cut-down version either way.

If all you need is a model endpoint, GitHub Models does that job and this comparison does not apply, but for the workflow around the model call, which was never the hard part, Activepieces is the better choice.

Frequently asked questions

The pick rule decides most of these questions, so it comes first: choose by the limit you hit first.

  • Outgrew model choice: try OpenRouter.
  • Outgrew controls: Foundry.
  • Need open models: Hugging Face.
  • Need automation around the model: Activepieces.

Each answer below assumes you have read that rule and still need a detail.

Is GitHub Models free to use in 2026?

Free usage exists, but it's rate-limited and meant for experimentation. Put real traffic behind it and requests start failing at the limit, usually during the busiest hour.

Check GitHub's current documentation for the limits and paid options, because they change faster than an article can track.

Can I move from GitHub Models without rewriting my code?

Usually yes for the call itself, with some edits. GitHub Models exposes an OpenAI-style chat interface, and the hosts above offer similar ones. In the common case you change the base URL, the API key and the model identifier.

Later, a model ID turns out not to exist on the new host, or a request parameter is handled differently. Run your existing prompts against the new endpoint and diff the outputs before you cut over.

Which alternative is cheapest for a small team?

It depends on token volume and which model you call, so no host wins in general. Per-token billing with no commitment, which OpenRouter's model uses, keeps fixed cost near zero while usage is low.

Foundry bills through an Azure account, so the real cost includes the account setup around it.

Open models on Hugging Face can be cheap per token, but a model you host yourself adds the cost of keeping a server running. Price your own monthly volume against each rate card before choosing.

Do any of these keep my prompts private?

What matters is where the prompt ends up, not the host's name. OpenRouter routes requests to underlying model providers, and each provider has its own retention and training terms, so check those terms and the routing settings before sending sensitive data.

Foundry runs inside your Azure tenant under Azure's data terms, which lets your security team review them in the usual place.

If you run open weights from Hugging Face on your own infrastructure, the prompt never leaves your network, and you take on the operational work in exchange. If a prompt contains customer data, find the retention terms in writing before the first production call.

Share

Still comparing

The fastest way to settle it is to build something.

Open source under MIT, so you can self-host the same thing later.

Start free Talk to sales