Europe's AI capacity doesn't have to come only from hyperscaler data centres. It can come from GPUs that people and companies already own. GarageAI is an open experiment in decentralised AI inference: garage owners share their GPUs and the models they run, anyone can use them through one OpenAI-compatible API, and every token a garage serves earns its owner credits on the network.
Launched in 2026 after a private beta in the spring. Live today: GarageAI Bridge, which connects a GPU in minutes with one line, the EU gateway, the portal and the first garages serving open models. No AI engine on the machine yet? Bridge installs Xyntetik Runner, a one-file engine that, like GarageAI, is made in Sweden. Local and sovereign, shared by the people who own the hardware.
One line. Approve in the browser. Live in minutes.
Bridge is the small open-source program that turns your computer into a garage. It looks at your machine, opens its own encrypted tunnel to GarageAI, registers your models and keeps them in sync. No VPN app, no router settings and no tokens to copy.
macOS and Linux, in the terminal
curl -fsSL https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.sh | sh -s -- connectWindows, in PowerShell
irm https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.ps1 | iex; garageai connectNothing secret in either line; on Windows, Bridge asks for Administrator once. Have Ollama, LM Studio, vLLM, llama.cpp or Xyntetik Runner running with a model first, or let garageai runtime suggest one and install it.
Bridge installs, checks its checksum and looks at your GPU, memory, runtime and models.
It opens app.garageai.eu with a code. Check it is your computer, name your garage, approve.
Bridge opens its encrypted tunnel to the GarageAI gateway and registers your models.
Your models pass a real test request, and the page says "Your garage is live".
WireGuard built into Bridge. Your machine dials out to the EU gateway, so it works behind any home router, through NAT and after a Wi-Fi switch. No VPN app, no network interface, no ports opened. It runs fine next to Tailscale.
Ollama or LM Studio can keep listening on 127.0.0.1 only. Bridge forwards just that one port into the tunnel, and only inference requests pass: everything else, such as downloading or deleting models, is blocked by Bridge. Nothing else on your machine or your home network is reachable, and garages cannot reach each other.
Bridge creates its tunnel key on your computer and sends only the public half. You approve the machine in the browser instead of copying a token. Bridge never reports prompts, keys or command lines.
doctor shows what runs on your machine, what is wrong and exactly how to fix it. No runtime yet? garageai runtime checks whether Xyntetik Runner, a one-file engine made in Sweden, fits your machine, and garageai runtime install sets it up as a service with a model; Bridge then keeps it up to date, updating only when the machine is quiet and rolling back if anything fails.
A small service reports your models and their context windows every 5 minutes, and Bridge updates itself to the current stable release, checked against its checksum. garageai pause takes your garage off the market for a while; garageai uninstall removes everything.
Your garage is yours first. Chat with it from your phone or any computer in the portal, or call it through the API as mine/<garage>/<model>: private, free and hidden from everyone else, even while it is off the market. While you use it, buyers go to other garages.
Two sides. One marketplace.
Buyers get AI from GPUs in European garages through one API. Garage owners turn hardware they already have into a paid inference node. One account can do both, and can own several garages.
For developers, companies and anyone who wants local AI
Create an account at app.garageai.eu and top up prepaid credits by card (Stripe). You pay per token, with no subscription.
Generate a key in the portal. The API at https://api.garageai.eu/v1 is OpenAI-compatible, so the OpenAI SDKs, agents and coding tools work by changing the base URL.
Choose a Specific garage (you pay the price it has set, for example when location matters) or the Pool (one model name; each request goes to one of the garages offering the model and is billed at that garage's price, with automatic failover). Or just use the chat in the portal.
Point any OpenAI client at https://api.garageai.eu/v1. garageai/auto answers with a working model for you and the response names the model that answered; any model name from the catalogue works too.
curl
curl https://api.garageai.eu/v1/chat/completions \
-H "Authorization: Bearer $GARAGEAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "garageai/auto", "messages": [{"role": "user", "content": "Hello from a European garage"}]}'Python (OpenAI SDK)
from openai import OpenAI
client = OpenAI(base_url="https://api.garageai.eu/v1", api_key="YOUR_GARAGEAI_KEY")
reply = client.chat.completions.create(
model="garageai/auto",
messages=[{"role": "user", "content": "Hello from a European garage"}],
)
print(reply.choices[0].message.content)Agents and coding tools work the same way: set the base URL and your GarageAI key.
For anyone with a capable GPU in a garage, office or server room
You need: A Mac (Apple silicon), a Linux machine or a Windows PC with a GPU, and Ollama, LM Studio, vLLM, llama.cpp or Xyntetik Runner running with a model loaded. No runtime yet? garageai runtime checks what fits your machine and installs Xyntetik Runner with a model.
Sign up at app.garageai.eu. Connect your GPU takes you to the page that connects your computer.
Paste the line for your system on the machine with the GPU. It installs GarageAI Bridge, a small open-source program, which looks at your GPU, memory, runtime and models. It asks for your password once.
macOS and Linux, in the terminal
curl -fsSL https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.sh | sh -s -- connectWindows, in PowerShell
irm https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.ps1 | iex; garageai connectNothing secret in either line: no token or key. On Windows, Bridge asks for Administrator once.
Bridge opens app.garageai.eu with a code. Check that it is your computer, pick a name for your garage and approve with one click. Bridge then opens its encrypted tunnel to the gateway by itself. You open no ports, and your runtime can stay on localhost.
Your models pass an acceptance test with a real streamed request, and the page shows "Your garage is live" with tokens per second for each model. It takes a few minutes. Choose the models you share and set your price per million tokens in the portal; every token you serve, also through the pool, earns you credits for any model on the network. No platform fee during launch.
No runtime yet, or not sure which model fits your GPU? Pick your setup ↓
Curious what Bridge does? It is open source, one binary, and garageai doctor shows what is wrong and how to fix it. Bridge on GitHub
AI inference has centralised fast, into a handful of clouds. GarageAI is an open experiment in the other direction: capacity and models shared by the people who own the hardware, close to the people who use them.
Inference runs on hardware owned by people and companies in Europe, routed through a gateway in the EU, instead of only in hyperscaler data centres.
Garages are named. When location matters, buyers can choose a specific garage instead of the pool.
Built on WireGuard and LiteLLM. The gateway setup and GarageAI Bridge, the program that connects a garage, are in the GitHub repository for anyone to read.
Share your GPU and the models you run, including your own fine-tunes and distills, and try models from other garages that the big APIs don't offer. What your garage serves earns credits for the whole network; bank payouts come later.
Have a GPU but no runtime yet? Start here.
Most GPUs in garages were bought for games, design or work, not for serving AI. Tell us what you have and we suggest one runtime, a popular open model that fits, and three steps to go live. GarageAI Bridge handles the rest and tells you what to adjust, such as a context window that is too small.
Windows with an NVIDIA RTX card
Runtime: LM Studio (point and click), Ollama or Xyntetik Runner
| 8 GB (RTX 3060 Ti, 4060) | An 8B model, e.g. Qwen3 8B |
| 12 GB (RTX 3060, 4070) | A 14B model |
| 16 GB (RTX 4080, 5070 Ti) | gpt-oss-20b |
| 24 GB (RTX 3090, 4090) | Qwen3.8 27B |
| 32 GB (RTX 5090) | Gemma 4 31B |
Any M-series chip, laptop or desktop
Runtime: LM Studio (uses MLX), Ollama or Xyntetik Runner
| 16 GB | An 8B model, e.g. Qwen3 8B |
| 32 GB | gpt-oss-20b |
| 64 GB | Qwen3.8 27B |
| 128 GB | gpt-oss-120b |
NVIDIA RTX or data-centre GPUs, DGX Spark, HP ZGX Nano
Runtime: vLLM
| 24–48 GB | Qwen3.8 27B (FP8) |
| 128 GB (NVIDIA GB10) | gpt-oss-120b, or Qwen3.8 27B with a 256k window |
Ryzen AI Max (Strix Halo) or Radeon
Runtime: Lemonade or llama.cpp (Vulkan)
| 64–128 GB unified | gpt-oss-120b |
| 16–24 GB Radeon | gpt-oss-20b |
Your GPU serves other people's agents and apps when you are not using it. Nothing on your machine is opened to the internet.
The same account that offers your GPU can use every model on the marketplace, including the larger ones other garages and providers run.
You set the price and see every token in the portal. Earnings become GarageAI credits first, bank payouts come later. How much it adds up to depends on demand; there is no platform fee during launch.
Suggested models are popular open models that fit the memory listed. The wizard in the portal shows which models buyers are asking for right now.
Local GPUs and verified providers, one API, no crypto, no open ports
Decentralised GPU networks exist, and so do API aggregators. None of them, as far as we know, combines what GarageAI does. Here is how it compares, by category.
The first European marketplace where local GPUs and verified providers sell real-time inference in one OpenAI-compatible API, without crypto and without open ports.
| GarageAI | Crypto inference networks | GPU rental marketplaces | API aggregators | |
|---|---|---|---|---|
Real-time inference from residential GPUs Rental marketplaces hand you a whole machine by the hour; you build the inference yourself. | ● | ● | ◐ | ○ |
Named garages you can pick, plus a shared pool In token-based networks the node is anonymous: you never know where the model runs. | ● | ○ | ● | ○ |
Local GPUs and datacenter providers in the same catalogue Aggregators only resell cloud providers; GPU networks only have nodes. | ● | ○ | ○ | ○ |
Pay in euros by card, invoice for companies Crypto networks pay out and charge in tokens or wallets. | ● | ○ | ● | ● |
EU gateway and our own encrypted tunnel, no US tunnel service in the path Where the request is processed is a first-class property, not a side effect. | ● | ○ | ○ | ◐ |
Operators open no inbound ports Bridge opens one outgoing WireGuard tunnel; only the gateway can reach the runtime port. | ● | ◐ | ○ | – |
Live in minutes: one line, approve in the browser Create a garage, run one command, pass the acceptance test, go live. | ● | ◐ | ○ | – |
Swipe sideways to see all columns
Categories, not named products, because the field moves fast. If you know a service that already does all of this in Europe, tell us: powerup@garageai.eu.
Open source, and honest about what it protects
GarageAI connects garages with open-source building blocks: GarageAI Bridge and its encrypted WireGuard tunnel, an OpenAI-compatible gateway and a portal. Your machine keeps running its own OS and its own runtime.
Your own macOS, Linux or Windows machine, connected by GarageAI Bridge (garageai), with Ollama, LM Studio, llama.cpp, vLLM, SGLang, Xyntetik Runner or Paddock (beta). GarageAI doesn't replace your OS and doesn't need a special image. It talks to the runtime's OpenAI-compatible endpoint.
GarageAI Bridge carries the tunnel itself: WireGuard in user space, with no VPN app and no network interface on your machine. It dials out to a hub on the EU gateway, so you open no ports, and it forwards only the runtime's port to your runtime on localhost. Garages can only answer the gateway, never start connections, and cannot reach each other. A fallback over TCP for networks that block UDP is on the roadmap.
LiteLLM serves https://api.garageai.eu/v1. It routes each request to a garage, retries and fails over within the pool, and meters usage per API key and per model. The gateway runs on an EU VPS (Hetzner, Helsinki).
Accounts, API keys, prepaid credits, chat, the page that connects an operator's computer, the model catalogue and the automated acceptance tests that every model passes before it can be sold.
Every garage sets its own price.
GarageAI has no price list of its own. Each garage sets a price per million tokens, input and output, for the models it offers. Buyers prepay credits and pay per token: the price of the garage that served the request. Cached input, a prompt prefix the garage has already processed, is billed at the garage's lower cache-read price. No subscriptions and no reserved-capacity contracts.
One named garage
One model name, many garages
The pool lets buyers use a model without picking a garage. Nobody sets a pool price: each request is billed at the price of the garage that answered it.
A garage joins the pool for a model once that model has passed the acceptance test through the gateway. Regular checks keep it there, and a garage that fails is taken out of rotation for a while.
The gateway sends each request to one of the healthy garages offering the model. If that garage fails mid-way, the request is retried on another one.
Requests are spread across the healthy garages in proportion to a weight, rather than all going to the fastest one. The weights are being tied to price, so a good price earns a larger share.
Because garages set their own prices, the cost of a pool request depends on which garage served it. The catalogue shows the range before you start.
Rolling out: weights based on each garage's price. Until then, requests are spread across the healthy garages without favouring price.
Why this matters beyond today's marketplace. Third-party market estimates, not GarageAI figures.
¹ MarketsandMarkets: AI Inference Market report, forecast to 2030
² Gartner, cited in Landbase: 39 Agentic AI Statistics 2026
³ MIT Technology Review: "Inferencing drives 80–90% of all AI compute"
Pilots, private garages and local AI for teams
Companies can use GarageAI like any other OpenAI-compatible provider, offer their own GPUs on the marketplace, or talk to us about running private garages. We are looking for pilot partners.
Point your existing OpenAI-compatible tools, agents and internal apps at https://api.garageai.eu/v1 and pay per token with prepaid credits.
Run models as private garages on GPUs you own and control. Contact us to set it up.
Have GPUs that sit idle outside office hours? Offer them on the marketplace, set your own price and earn it for every token served.
Agents make many model calls per task. Per-token pricing and a pool with failover make it easy to run them on open models.
Coding assistants and internal tools that speak the OpenAI API can switch to GarageAI by changing the base URL and key.
Pick a specific garage when it matters where the request is processed.
About data: Prompts are processed on the operator's machine. For sensitive or personal data, talk to us about a private garage. Verified garages and data-processing agreements are planned before we sell to buyers with sensitive data.
Interested in a pilot or a private garage?
Contact us about a B2B pilotWhat works today, what we are building next, and where the vision goes after that. No dates we can't keep.
Early operators and buyers influence what gets built next, from payouts to verification.
During launch, operators keep the full price they set for every token they serve.
Every garage that joins adds AI capacity owned in Europe, by the people who run it.
Every wave of technological change has followed the same arc: power concentrates, then decentralizes back to individuals. We're living through the fourth — and it's bringing intelligence back home.
Compute power left the mainframe. Bill Gates, Steve Jobs, and a generation of builders put a computer on every desk and in every home. Processing power was no longer the exclusive domain of corporations and governments — it belonged to individuals. The pattern was set: centralized technology decentralizes, and the world changes.
Information left the library and became borderless. Anyone could publish, connect, and trade. The infrastructure was centralized — servers, ISPs, data centers — but the value flowed to billions of individuals. E-commerce, social media, and open knowledge followed. A new layer on top of the previous wave.
Creation was democratized. Anyone could generate text, images, code and analysis at scale. But this wave re-centralized what computing had decentralized: the most capable AI ran exclusively on hyperscaler infrastructure — OpenAI, Anthropic, Google. Powerful, transformative, and controlled by a handful of companies.
Action is being democratized. AI agents plan, decide and execute on their own, making many model calls per task, so demand for inference keeps growing. We believe a large share of that inference can run on private, local hardware instead of only in hyperscale clouds. The intelligence that left the mainframe in the 1980s can leave the cloud too, and come back to your garage.
This is the vision, not a description of today's product. Today GarageAI is a working marketplace that routes OpenAI-compatible requests to GPUs in garages. The energy stack, the scale and the numbers below describe where we want to go.
An estimated 75+ million garages across the EU. In the long run, each one could host AI hardware, and together they could become a sovereign, distributed AI infrastructure. The figures below are estimates from public statistics, not GarageAI numbers.
| Country | Homes | Est. Garages | Coverage | EVs on Road |
|---|---|---|---|---|
| 🇩🇪 Germany | 41.5M | 18M | 43% | 3.5M |
| 🇫🇷 France | 36M | 11M | 31% | 1.8M |
| 🇮🇹 Italy | 26M | 9M | 35% | 0.6M |
| 🇪🇸 Spain | 22M | 7M | 32% | 0.5M |
| 🇵🇱 Poland | 14M | 5M | 36% | 0.1M |
| 🇸🇪 Sweden | 4.8M | 1.7M | 35% | 1.5M |
| 🇳🇱 Netherlands | 8M | 2M | 25% | 0.5M |
| 🇧🇪 Belgium | 5.5M | 2M | 36% | 0.3M |
| EU-27 TOTAL | ~225M | ~75M+ | ~33% | ~17M |
Sources: Eurostat Housing Statistics 2023, ACEA Electric Vehicle Report 2024. Garage estimates based on single-family home stock.
GarageAI is built in Sweden, which has several of the building blocks the long-term energy vision needs.
Centralization has dominated industries for decades. Then came local electricity production. Computing is next — and the shift has already begun.
Locally produced electricity went from niche to normal. We think AI inference can follow a similar path.
Not part of today's product. The long-term idea is that a garage node can run largely on locally produced energy: rooftop solar during the day, a home battery overnight, and an EV battery (V2H) as an evening and weekend buffer. EVs are mostly away during weekday solar peak, so the home battery would be the backbone. The first step is live: GarageAI Bridge already measures each garage's energy, in watt-hours and tokens per kWh.
🚗 EV Parking Reality (EU average)
🏠 A Possible Garage Energy Stack
🔋 EU Scale — The Potential is Still Massive
Vision: locally produced, locally consumed, locally owned. Today any garage on the grid can join; the energy stack is where we want to go.
¹ INRIX Global Traffic Scorecard; RAC Foundation: "Spaced Out" report on vehicle utilisation
² Transport for London / European Environment Agency: vehicle location studies
³ Energimyndigheten: Solar irradiation in Sweden (solenergistatistik 2024)
⁴ ACEA Electric Vehicle Report 2024; IEA Global EV Outlook 2024
⁵ Trafikanalys / BilSweden: Fordonsstatistik 2024
⁶ Eurostat: share of employees working from home, Sweden 2023
Built in the open
GarageAI is built on open-source software, and our own gateway setup and GarageAI Bridge are public. Read the code, run your own gateway, or help us build the platform.
The first garages are live. Share your GPU and your models, try everyone else's, or follow along and talk to us on GitHub.
Practical answers about using GarageAI and offering your GPU.
A two-sided marketplace for local AI inference. Garage owners (operators) connect a GPU they already own and offer open models on it. Buyers call those models through one OpenAI-compatible API at https://api.garageai.eu/v1, or use the chat in the portal, and pay per token. The operator earns the token price for the requests their garage serves.
An open innovation project, run by Liteit AB in Sweden. AI inference has centralised quickly into a handful of clouds; GarageAI tests the other direction: GPUs and models shared by the people who own them, reachable through one API, with the code in the open. It works and serves real requests, but it is in beta: features change as we learn, and the first garages and buyers help decide what comes next.
Yes. Bridge registers whatever models your runtime serves, so a community fine-tune, a distill or a model in your own language can be offered next to the well-known open models. You choose in My garages which models to share and at what price; each passes the same acceptance test with a real request before buyers can use it. Make sure the model's licence allows you to serve it.
Share it on GarageAI. Run GarageAI Bridge's one-line install on the machine (macOS, Linux or Windows), approve it in the browser and choose the models you share and their price per million tokens. Every token your garage serves, also through the pool, is counted at your price with no platform fee during launch. Today those earnings are shown in My garages; next, you can use them as GarageAI credits on any model on the network; bank payouts through Stripe come later and are not yet scheduled. GarageAI is first a place to share and explore models, so treat earnings as a bonus, not an income.
Yes. GarageAI's API at https://api.garageai.eu/v1 is OpenAI-compatible: the OpenAI SDKs, agents and coding tools work by changing the base URL. The gateway runs on an EU server (Hetzner, Helsinki) and stores no prompts or answers; the models run on GPUs that garage owners connect, and you can pick a specific garage when location matters. You pay per token with prepaid credits, at the price the serving garage set. Prompts are processed on the garage owner's machine and garages are not yet formally verified, so don't send sensitive or personal data until verified garages and data-processing agreements are in place.
Connect the computer with GarageAI Bridge. Bridge opens its own encrypted tunnel outwards, so you open no ports and need no VPN app, and your runtime can stay on localhost. Its models then appear in the GarageAI portal's chat under Your machines, on your phone or any computer, and in the API as mine/<garage>/<model> for any OpenAI client. Using your own machine is free and private: nobody else can see or call it. Choose Only me in My garages to keep it off the market entirely.
Yes, and we ask you to. AUDIT.md in the GitHub repository lists every security claim with the code that proves it, written for an AI agent such as Claude Code, Codex or Cursor to verify claim by claim. Paste this into your agent: Review https://github.com/magnusfroste/garageai as a security reviewer for someone about to install GarageAI Bridge on their own computer; start with AUDIT.md, check every claim against the code it points to, and say which hold and which do not. The plain-language version is at garageai.eu/security.
A machine that can run an open model with acceptable speed: typically a Mac with Apple silicon or a Linux machine with a capable GPU. There is no fixed minimum spec. Every model has to pass an automated acceptance test through the gateway, which measures time-to-first-token and tokens per second, before it can be sold.
macOS, Linux and Windows. Supported runtimes are Ollama, LM Studio, llama.cpp, vLLM, SGLang, Xyntetik Runner and Paddock (beta). Unsloth, MLX on Apple Silicon and Lemonade on AMD also work. You keep your own OS and runtime; have it running with a model loaded, or let garageai runtime suggest Xyntetik Runner and install it for you, then one line installs GarageAI Bridge, which opens its encrypted tunnel and registers your models.
A few minutes once your runtime is running a model. Sign in at app.garageai.eu/connect and run one line: in the terminal on macOS and Linux, curl -fsSL https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.sh | sh -s -- connect, or in PowerShell on Windows, irm https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.ps1 | iex; garageai connect. Neither contains anything secret. It installs GarageAI Bridge, which looks at your GPU, memory, runtime and models and opens the browser with a code; you check that it is your computer, pick a garage name and approve with one click. Bridge then opens its encrypted tunnel to the gateway and registers your models, the portal runs an acceptance test with a real request, and the page shows the steps live until "Your garage is live". It asks for your password once. You can also run the line first and create your account on the page it opens. If something stops, the page shows what is wrong and how to fix it, and garageai doctor shows the same on the machine. Bridge is new: report problems on GitHub or to powerup@garageai.eu.
Bridge is how a garage connects to GarageAI: one small open-source program, garageai, on macOS, Linux and Windows. garageai connect links the machine to your garage and opens Bridge's own encrypted WireGuard tunnel to the gateway (no VPN app needed, and it runs next to Tailscale), a heartbeat service keeps your offered models and their context windows in sync every 5 minutes, garageai doctor shows what runs on your machine, what is wrong and how to fix it, and garageai uninstall removes it again. Bridge never reports prompts, keys or command lines. On macOS and Windows, an optional GarageAI icon in the menu bar or notification area shows whether the garage is live, its models and the last hour's requests. If you use an AI agent such as Claude Code, garageai mcp gives it Bridge's read-only checks and troubleshooting guide. Bridge updates itself to the current stable release, and garageai pause takes your garage off the market for a while. GarageAI Smart can download models in demand that fit your machine (Ollama). Next, it will pause automatically when you game or render; later, a control panel will show what your GPU can earn and take you live with one click. Install and connect on macOS and Linux: curl -fsSL https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.sh | sh -s -- connect; on Windows, in PowerShell: irm https://raw.githubusercontent.com/magnusfroste/garageai/main/cli/install.ps1 | iex; garageai connect
Yes, since Bridge 1.0 (October 2026). Sign in at app.garageai.eu, open Connect your GPU and pick the Windows tab: paste the line into PowerShell. Bridge asks Windows for Administrator once (it installs two services), you approve your PC in the browser, and Bridge opens its encrypted tunnel to the gateway: no VPN app, no firewall rule, and your runtime (Ollama or LM Studio) stays on localhost. The tunnel runs as a Windows service and the heartbeat as a scheduled task, so the garage comes back by itself after a restart; Bridge updates itself. Ollama runs in your user session, so keep the PC logged in (a locked screen is fine). On a laptop, garageai doctor tells you how to keep it awake on the power adapter. NVIDIA cards are used by the runtime; AMD and Intel graphics built into the processor run on the CPU, which is fine for small models. vLLM and SGLang on Windows (through WSL2) will follow later.
Yes, with three things you should know. Your computer opens no ports and accepts no connections: Bridge opens one outgoing encrypted tunnel to the GarageAI gateway, and the only thing that comes back through it is inference requests for the model you offer, to your runtime on localhost. Nothing else on your computer or your home network can be reached. What you should know: you trust GarageAI with the requests (whoever controls the gateway can use your GPU, not your files), Bridge updates itself from our releases (signed releases are on our list; you can turn self-update off), and your runtime is a program we did not write (keep it updated). The whole answer, and how to check it yourself, is on the Security page: garageai.eu/security.
Yes. In the portal's chat your garage's models appear first, under Your machines, with whether the machine is awake or asleep, so you can use your own GPU from your phone or any computer. Through the API they answer as mine/<garage>/<model> with any of your keys. Using your own machine is free, even with no credits, and it is private: nobody else can see or call it. In My garages you choose who can use each machine: only you (off the market) or you and the market. While you use it, new market requests go to other garages and come back a few minutes after your last message, so a buyer's long request never keeps you waiting.
No. GarageAI Bridge dials out to the GarageAI gateway over an encrypted WireGuard tunnel, so it works behind a home router, through NAT and on a changing address. You open no ports, garages cannot reach each other, and only the gateway can reach your runtime. The tunnel needs outgoing UDP: a network that blocks it has no fallback today, and a fallback over TCP is on the roadmap.
One thing: the port of your inference runtime, through the encrypted tunnel your machine opened. GarageAI cannot log in to your machine, read your files, reach other ports or reach other devices on your home network, and other garages cannot reach you at all. Buyers never see which garage served them or its address. GarageAI Bridge is open source. It carries the tunnel itself, with no VPN app or network interface, and forwards only your runtime's port to the runtime on localhost, so your runtime can keep listening on 127.0.0.1 and stays closed to your home network; Bridge also passes only inference requests to it, so nothing can download or delete models through the tunnel. It also installs a small heartbeat that reports which models you serve. You can check everything with garageai doctor and leave with garageai uninstall. The full explanation is in 'Security for garage owners' in the GitHub repository (docs/garage-security.md).
Traffic is encrypted in transit: TLS from you to our gateway on an EU VPS (Hetzner, Helsinki), and WireGuard from the gateway to the garage. The gateway does not store your prompts or responses. The prompt itself is processed in plain text on the operator's machine. Operators agree not to log, store or read prompts or responses; a garage that does is removed and its account closed. Operators are not yet formally verified, so this rests on the terms, not on technology. Verified garages and data-processing agreements are planned before we sell to buyers with sensitive data. Until then, don't send sensitive or personal data through the marketplace.
No. Buyers' prompts and the model's responses are confidential. The operator terms forbid logging, storing, reading, forwarding or analysing them; a garage found doing so is removed from the marketplace and the account is closed. By default none of the supported runtimes write prompts to disk, so just don't enable request logging on a garage (vLLM --enable-log-requests, SGLang --log-requests, llama.cpp --verbose). If you need it to debug your own setup, pause the garage first.
You set your own price per million tokens, input and output, when you create your garage. You earn that price for every token your garage serves, whether the buyer picked your garage or the request came through the pool. There is no platform fee during launch (a platform fee will come later). Getting paid comes in three steps. Now: every token is counted at your price and shown in My garages. Next: you can use your earnings as GarageAI credits on any model, including larger ones than your machine runs; everything earned from launch carries over (requests paid with free starting credits do not create earnings). Later, not yet scheduled: payouts to your bank account through Stripe, monthly above a minimum, after an identity check and the tax reporting EU rules require; bank payouts cover earnings from the day they start.
No. GarageAI is in beta: it works and serves real requests, but features are added, changed and sometimes removed as we learn from the first garages and buyers. What is live today and what is coming is marked on this page and in the roadmap. Earnings from launch carry over as credits, whatever else changes.
Each garage sets its own price per million tokens, input and output, and you pay per token at the price of the garage that served your request. Cached input, a prompt prefix the garage has already processed, is billed at its lower cache-read price. You use prepaid credits, topped up by card via Stripe, with no subscription. The model catalogue in the portal shows the prices for each model.
The garages do. GarageAI has no price list of its own: each operator sets a price per million tokens for the models they offer. There is no separate pool price; a pool request is billed at the price of the garage that answered it.
Specific garage sends your requests to a named garage you choose, for example for location, and you pay the price it has set. Pool uses one model name across every garage offering that model: each request goes to one healthy garage, is billed at that garage's price, and is retried on another garage if it fails. Both are shared capacity, not exclusive; booked or reserved capacity is planned.
Only garages whose model has passed the acceptance test, and keeps passing regular checks, take part. Requests are spread across those healthy garages in proportion to a weight, so every healthy garage gets traffic, not only the fastest. Weights based on each garage's price are being rolled out, so a good price will earn a larger share. If a garage fails, the request is retried on another one.
Open models that operators choose to serve and that pass the acceptance test. The current list, with prices, context windows and the garages behind each model, is the live catalogue at app.garageai.eu/models, and it changes as garages come and go. Your own fine-tunes and distills can be part of it too.
Residential GPUs selling inference is not new in itself: there are crypto-based inference networks, hourly GPU rental marketplaces and API aggregators. What we have not seen elsewhere is the combination: named garages you can pick plus a shared pool, local GPUs and verified datacenter providers in the same catalogue and API, payment in euros by card or invoice instead of tokens, our own encrypted tunnel to an EU gateway with no inbound ports, and onboarding that gets a garage live in minutes with one line and a click in the browser. If you know a European service that already does all of that, we would like to hear about it.
Yes. The API at https://api.garageai.eu/v1 is OpenAI-compatible, so the OpenAI SDKs, agents and coding tools work by setting the base URL and your GarageAI API key. For example, in Python: OpenAI(base_url="https://api.garageai.eu/v1", api_key="YOUR_GARAGEAI_KEY"), then chat.completions.create(model="garageai/auto", messages=[...]). garageai/auto answers with a working model and names it in the response; any model name from the catalogue in the portal works too.
Yes. One account can buy inference and offer GPUs, and you can register several garages under the same account.
The building blocks are open source (WireGuard and LiteLLM), and GarageAI's gateway setup (infra/gateway/README.md) and GarageAI Bridge (cli/), the program that connects a garage, are in the public GitHub repository under the MIT license.
Yes, talk to us. Companies can use the API, offer their own GPUs on the marketplace, or run private garages. Contact powerup@garageai.eu about a pilot.
That is the long-term vision, not today's product. The idea is that garage nodes can eventually run largely on locally produced energy (rooftop solar, home batteries and EV batteries). Today any machine on the grid can join, and the first step is already in place: GarageAI Bridge measures how much energy each garage uses while it serves (watt-hours, and tokens per kWh) and shows it in the GarageAI menu-bar icon.
Europe's AI capacity doesn't have to be only a billion-euro data centre somewhere. Part of it can be the GPUs people and companies already own, connected, local and paid.
GarageAI Bridge, the gateway and the portal are live, and the first garages are serving models. Offer your GPU, or start using AI from European garages today.