Goose is an open-source, on-machine AI agent originally from Block and now stewarded by the Linux Foundation's Agentic AI Foundation. It's a general-purpose agent — not just for code — that installs, executes, edits, and tests. It works with 15+ model providers (Anthropic, OpenAI, Gemini, Bedrock, Ollama, and more) and connects to 70+ extensions over the Model Context Protocol.

Can I run Goose on a server?

Yes. Goose's whole job is to act on a machine — run shell commands, edit files, drive tools — so an always-on box lets it work without tying up your laptop. jurniti runs Goose on a dedicated Firecracker microVM with an in-browser terminal and a persistent home, so your recipes and extensions are always there.

Do I need my own API key for Goose?

Yes. jurniti is bring-your-own-key. Run `goose configure` to set up any provider — including a local model via Ollama — and your key lives only in your VM. Traffic goes straight to the provider, and jurniti never sees your tokens or marks up usage.

Why does Goose belong on a microVM instead of my laptop?

Because Goose is an on-machine agent that runs real commands and connects to 70+ tools. On your laptop, a wrong move or a poisoned extension has the run of your files. On jurniti, Goose gets root inside its own Firecracker microVM with its own kernel and a KVM boundary, so the blast radius is one disposable box you can rebuild in seconds.

How much does it cost to host Goose?

Plans start at $25/mo ($250/year — two months free), and every plan has a 30-day money-back guarantee. Goose runs comfortably on Starter (1 vCPU / 2 GiB) for most work. Your model spend is separate and never marked up, because you bring your own key.

Is this an official Goose product?

No. jurniti is independent managed hosting for the open-source Goose agent. We install the upstream binary at first boot — no fork — so you run the real Goose and pick your own provider, extensions, and version.

Goose AI Agent Hosting on a Real microVM

Most "AI coding agent" hosting misses what Goose actually is. Goose isn't a code-suggestion box — it's a general-purpose agent that installs software, runs commands, drives 70+ tools over MCP, and tests its own work. That's enormously useful and exactly the workload you don't want loose on your laptop. Here's the fix: run Goose on its own always-on Firecracker microVM. Give it root there, wire up all the extensions you want, and a bad move stays contained to a box you can rebuild — booting in about 124ms.

What Goose is

Goose is an open, on-machine AI agent — desktop app, CLI, and API — originally built by Block and now stewarded by the Linux Foundation's Agentic AI Foundation, the same neutral home as MCP and AGENTS.md. It goes beyond suggestions: it installs, executes, edits, and tests. It works with 15+ providers (Anthropic, OpenAI, Gemini, Bedrock, Ollama, and more) and connects to 70+ extensions over the Model Context Protocol — databases, browsers, GitHub, Google Drive, and whatever else you wire in.

Because Goose is general-purpose, people point it at research, automation, data work, and SRE chores, not just code. All of that wants a box that's always on and holds your setup.

Why a real microVM for Goose

Goose acts. It runs shell commands, edits files, and reaches out through dozens of extensions — and an extension is just more code you didn't review. On your laptop, all of that has the run of your home directory. A shared container isn't the boundary you want either: it shares the host kernel, with 200-plus known weaknesses in the stack.

jurniti gives Goose its own Firecracker microVM — its own kernel, a KVM hardware boundary, one tenant per box. The same isolation serverless platforms use. Give Goose root inside its own VM and a runaway command, a misbehaving extension, or a prompt-injection attack stays contained to that box. Reprovision and you're clean in seconds.

You keep your model relationship. jurniti's BYOK is architectural: run goose configure, point it at any provider (or a local Ollama model), and the key lives only in your VM. Traffic leaves straight for the provider, jurniti is never in the path, and no token is marked up.

Most Goose work runs comfortably on Starter (1 vCPU / 2 GiB) — step up only if your extensions or local models are memory-heavy. And it's reversible: a 30-day money-back guarantee, workspace kept 7 days after cancellation.

Run Goose in 3 steps

By hand this is a VPS, the install script, provider setup, extension config, a systemd unit, and patching for as long as you run it. jurniti runs the box; you keep the agent.

1. Pick a plan and pay

Starter is enough for Goose. Check out, and the provision chain runs automatically the moment payment confirms.

2. Your microVM boots with Goose ready

A fresh Ubuntu microVM boots with the Goose binary pre-installed and on your PATH. You get an in-browser terminal — nothing to SSH into. Configure a provider and go:

goose configure        # pick any provider, paste your key
goose

3. Put it to work

Hand Goose a task, wire up the extensions you need, and let it run. Your recipes and config live on the persistent home, so they survive every restart.

Give Goose its own microVM

What people run Goose for

On-machine automation. Install, run, edit, test — chores that need a real shell, kept off your laptop.
MCP-heavy workflows. Connect 70+ extensions to one agent without polluting your own environment.
SRE and ops tasks. A general-purpose agent on an always-on box is a tireless junior operator.
Local models. Run an Ollama model on a bigger plan and keep inference inside your own VM.

Snapshot a configured agent into a template and fork it for the next job — your recipes and extensions, never your credentials.

jurniti vs a laptop vs a DIY VPS

	jurniti	Your laptop	DIY VPS
Always on	Yes	No — it sleeps	Yes
Isolation for an on-machine agent	Firecracker microVM (KVM)	Your whole machine	Shared kernel
Provider keys	Yours, never leave the VM	Yours	Yours
Extension blast radius	One disposable microVM	Your whole machine	Your whole server
Setup	Automatic · 124ms boot	Local install	Manual
Refund	30-day money-back	n/a	None

Pricing

Starter is $25/mo ($250/year, two months free) and runs Goose for most work. Pro is $49/mo and Max $99/mo for heavier extensions, local models, or a custom TLS subdomain. Every plan includes the 30-day money-back guarantee, and your model spend is separate and never marked up.

Running a different agent? See the guides for OpenCode, Claude Code, and Grok Build, or compare plans on the pricing page.