Chipotlai Max: The Burrito Chatbot Hack and 3 Free AI APIs That Actually Work

TL;DR: In March 2026, developers discovered that Chipotle's customer support chatbot "Pepper" could solve coding problems, and that it ran on IPsoft Amelia rather than GPT or Claude. Within days, developer @Gonzih reverse-engineered its WebSocket backend into an OpenAI-compatible proxy, and a meme project called Chipotlai Max (1,558 GitHub stars, MIT-licensed fork of OpenCode) shipped it as a default model. It was free inference paid for by burritos, and it is now patched. If you actually want a free AI API that stays up, three platforms offer verified, documented free tiers and theres a github repo that combines free tiers across multiple ai service providers.

Watching corporate overlords accidentally hand out free GPU time was the funniest thing to happen to open source this year. It was also a lesson in how corporate decision makers don't understand their own tech.

Here is what actually happened, what the repo really does, and what to use instead if you want free inference you can build a project on.

What Pepper actually was

Chipotle's support bot "Pepper" went viral on March 12 and 13, 2026. Customers asking about lost orders started asking it other things, and it turned out Pepper could write Python, solve LeetCode problems, and reverse a linked list without complaint.

Pepper ran on IPsoft Amelia, a platform sold as a purpose-built enterprise virtual agent for narrow customer service work. In reality it was a glorified wrapper with a prompt on top. Nothing in the setup stopped Amelia from accepting a task it was never meant to do, it just had not been asked nicely before.

That is why the exploit worked. Amelia was configured for lost orders and return policies, not hardened against "reverse a linked list in Python." A general model behind a narrow front end is a wrapper, and a wrapper is only as tight as the prompt holding it shut.

Developer @Gonzih reverse-engineered the Amelia WebSocket and SockJS plus STOMP backend and published chipotle-llm-provider, an OpenAI-compatible proxy that exposes a local /v1/chat/completions endpoint with no API key required. The proxy is small: an Express server, a WebSocket client, and a translation layer.

What Chipotlai Max actually is

Chipotlai Max is a meme fork of OpenCode, the open source coding agent that has 207,790 stars and is MIT licensed. The fork hardcodes the Pepper provider as the default model, applies Chipotle's brand colours, and ships with this configuration:

Provider    chipotle-pepper
Model       pepper-1
Base URL    http://localhost:3000/v1
API key     burrito-2026   (literally anything works)
Cost        $0.00

Setup is a clone with submodules, bun install, then ./start-chipotlai.sh, which brings up the proxy and the CLI together. The repo itself is honest about the arrangement, describing it as free inference paid for by burritos and noting that it is not affiliated with Chipotle, which "will probably sue us."

It picked up 1,558 stars, 96 forks, and then stopped: the last commit landed on June 3, 2026. Chipotle patched Pepper, and the free ride ended.

The other retailer bots do not actually work

This is the part almost every write-up gets wrong. Chipotlai Max does list other corporate chatbots in its README, and those names get repeated everywhere as working alternatives:

• Home Depot's "Magic Apron"
• Sephora's AI Beauty Chat
• Nordstrom's "Rosie"
• Lowe's "Mylow"
• IKEA's "Billie"
• Expedia's Virtual Agent

Read the status column in the actual repository, though. Every one of them is marked "wired" as an environment variable and then "needs authorized adapter endpoint." Some are noted as access-controlled or as having only FAQ and search surfaces exposed. That means the environment variables exist and the adapters are stubs. There is no working free inference behind any of those names, and a good number of them are simply bots that answer questions about their own store.

The pattern is still worth understanding: any enterprise that bolts a general purpose model onto a narrow customer service task, without hard limits on what the model will discuss, has created the same gap. That's the real lesson here.

Where the free tiers actually stand

Before listing anything as free, it is worth checking whether it is still free.

GitHub Models was retired on July 30, 2026. GitHub announced retirement in June, closed it to new customers, then ran brownouts on July 16 and 23 before shutting down the playground, model catalog, inference API, and BYO-key support entirely. A call to its catalog endpoint now returns a brownout error. If you find a tutorial recommending it as the easiest free tier, that tutorial is out of date.

Here is what is genuinely available.

1. Google AI Studio (Gemini API)

Google's free tier is the strongest single source of frontier-class models, and it is the one to reach for if you want a genuine GPT-class engine rather than an open-weights one. Free tier access exists and is documented, rate limited per model across four separate dimensions: requests per minute, requests per day, tokens per minute, and tokens per day. Limits apply at the project level rather than per API key, and each model variation carries its own ceiling.

You do need an API key from AI Studio, but no billing setup is required to start, and the documentation confirms the path: to move from the free tier to a paid tier, you set up billing first. That is a free tier you can sit on indefinitely, not a trial.

The honest caveat: the rate limits are the tightest part of the offer. Free tier ceilings are set well below what a production app needs, and Google can change them. If your project suddenly gets popular, you will hit a wall and the migration to billing is a config change, not a rewrite, which is the whole point of the free tier existing.

Taken by itself, this is the best free access to frontier models anywhere. As the frontier layer inside a stack, it gets better, because the tight limits stop being a hard ceiling once you have two other providers to fail over to.

2. Groq

Groq's free plan is the one to pick when latency matters. It serves open-weights models on custom silicon, and the documented free-plan limits are refreshingly specific:

Thirty requests per minute and a thousand a day on a 120B model is a real budget for a side project. Groq also returns proper rate limit headers (x-ratelimit-remaining-requests, x-ratelimit-remaining-tokens, retry-after), so you can back off intelligently instead of guessing.

The honest caveat: you are limited to Groq's model catalogue, which is open-weights only. If you specifically want GPT or Claude class models, this is not your tier. The token-per-minute ceiling on the 120B model is 8K, which is fine for chat and code completion but will not swallow a large codebase in one request.

On its own, this is the fastest free option here. It is also the layer you will be glad of when a bigger model is rate limited, which makes it the natural fallback in any stack.

3. OpenRouter free models

OpenRouter is a router rather than a host, and it carries 443 models. Twenty-three of them are currently free, meaning both prompt and completion pricing are zero. That pool includes google/gemma-4-26b, google/gemma-4-31b, z-ai/glm-5.2, and nvidia/nemotron-3-ultra-550b, plus an openrouter/free auto-router that picks a free model for you.

The value here is the interface. OpenRouter is OpenAI-compatible, so pointing an existing SDK at it is a base URL and key change. It is the fastest way to test several open models against your own prompts without signing up for each provider separately.

The honest caveat: free model requests carry both a per-minute and a per-day ceiling, and the daily ceiling depends on how much credit you have bought from OpenRouter over the life of the account. Buying credits raises the ceiling permanently, which means the free tier is partly a funnel. Free endpoints also go down when the upstream provider is at capacity, so build in a fallback rather than assuming the model you picked will be there tomorrow.

Used alone, it is the easiest way to try a lot of models. Inside a stack, it is the breadth that the other two do not have.

The best free AI API: stack all three behind one endpoint

Every option above is a single ceiling. FreeLLMAPI is the one that adds them together, which is why it is the recommendation on this page if you want free inference you can actually build on.

FreeLLMAPI is a free, self-hosted, MIT-licensed router (26,500+ GitHub stars) that aggregates the free tiers of 34 providers, Groq and OpenRouter among them, behind a single OpenAI-compatible /v1 endpoint. Its README puts the combined pool at roughly 7.4 billion tokens a month across 635 free model endpoints.

That number is the whole argument. Google AI Studio, Groq and OpenRouter are three separate allowances that each run out on their own schedule, and juggling them by hand means three keys, three dashboards, and three sets of limits to watch. FreeLLMAPI collapses that into one endpoint. It picks the best model per request, fails over to the next provider when one returns a 429, and tracks per-key usage so you stay under every cap without thinking about it.

The trade-offs are real: you bring your own keys, you run it yourself, and it is a single-user tool rather than a shared gateway. But it is the only option here that multiplies your capacity instead of capping it, and because your access runs through your own keys rather than one provider's goodwill, it is also the version most likely to still be working next year.

We covered the install in our FreeLLMAPI write-up, and it is also listed in the directory.

Comparison

The table below compares every option covered above. FreeLLMAPI sits at the bottom because it does not compete with the free tiers, it stacks them.

Read the last row as the answer and the five above it as the inputs. Every other entry gives you one tier with one set of caps. FreeLLMAPI is the only one that adds the others together, which makes it the strongest free option here on capacity by a wide margin and the one to pick if your problem is running out of quota.

Where the free API stack falls short

Grouped by the thing that will actually bite you:

Rate limits are the product, not a bug. Every one of these tiers exists to move you onto a paid plan at the moment you succeed. Google changes its ceilings, and OpenRouter's daily cap is explicitly tied to how much credit you have bought over the account's lifetime. Treat the free tier as a prototyping environment and plan the paid migration from day one.

No free tier gives you frontier models without a catch. Gemini's free tier is the closest, and it comes with the lowest limits. Groq and OpenRouter are open-weights only. If your product depends on a specific proprietary model, free means "free trial" or "not available."

FreeLLMAPI asks more of you than the others. It is self-hosted and built for a single user, so there is no team gateway story, and how much you get out of it depends on how many provider keys you are willing to sign up for. That is a real cost in setup time. It is also the price of the only option here that multiplies your capacity rather than capping it, and once it is running there is nothing left to maintain.

Terms of service are not a formality. Every hack of this kind, however funny, is a violation waiting on a legal letter. Chipotlai Max's own README says the reverse engineering likely breaches Chipotle's terms and warns it can break any day. The proxy had a pool size of five anonymous sessions, so even at its peak it was not built for anything beyond a demo.

Free tiers are unstable by design. GitHub Models went from "everyone's favourite free tier" to fully retired in about seven weeks. Any architecture that hardcodes a single free provider is one announcement away from breaking, which is an argument for the router: with FreeLLMAPI holding the other providers as fallbacks, losing one key is a nuisance rather than an outage.

Getting started in five minutes

Start with FreeLLMAPI if capacity is what you are short of. It is a single install, and the other three providers become the keys you feed it:

curl -fsSL https://freellmapi.co/install.sh | bash

Open http://localhost:3001, paste in your free-tier keys, reorder the fallback chain, and point any OpenAI SDK at http://localhost:3001/v1. From then on you are calling the whole pool through one endpoint and the router handles the limit juggling for you.

If you would rather test a single provider first and decide later, Groq is the quickest to verify. You can add the key to FreeLLMAPI whenever you are ready, without changing a line of your code:

pip install openai groq
export GROQ_API_KEY="your-key-from-console.groq.com"

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.groq.com/openai/v1",
    api_key=os.environ["GROQ_API_KEY"],
)

resp = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{"role": "user", "content": "Reverse a linked list in Python"}],
)
print(resp.choices[0].message.content)

Swapping to OpenRouter is the same call with base_url="https://openrouter.ai/api/v1" and a model ID ending in :free. Swapping to Gemini means using Google's compatibility endpoint instead. Because all three speak the same shape, every one of them drops straight into the router as another provider.

If you want to see how these exploits actually work, this short video breaks down how customer service bots get manipulated and why the pattern keeps recurring across enterprise chatbots.

The bottom line

Chipotlai Max is a great story and a dead project. It proved that enterprises are shipping general purpose models behind narrow interfaces, and it proved that the community will find them. It did not produce anything you can build on, and the six other retailer bots in the same repo were never actually working.

The free API picture is less funny and far more useful. Google AI Studio gives you frontier access with the tightest limits, Groq gives you fast open-weights inference with a genuinely generous daily cap, and OpenRouter gives you 23 free models behind one OpenAI-compatible endpoint. On their own, each one is a decent free tier that will eventually run out.

FreeLLMAPI is the one to run if you want the most out of all three. It stacks a lot into roughly 7.4 billion tokens a month behind a single endpoint, which is comfortably the most free inference available to anyone without a credit card, and it keeps working when any single provider has a bad day.

If you have been looking for a free OpenAI alternative, a free Groq-compatible endpoint, or a replacement for GitHub Models now that it is retired, every option above will cover it. If you want the best free capacity rather than just a free tier, install the router and add the keys.

Looking for more free AI tooling? Check out our coverage of stacking every free LLM tier behind one API, free alternatives to popular paid subscriptions, and OpenWorker, a free open source AI coworker.