RunPod
Every other provider expects an endpoint to already exist. RunPod is the one where Podcode creates it: you connect a RunPod account, pick a model, and a private OpenAI-compatible endpoint appears in your model picker a few minutes later. You never open the RunPod console again after signup.
This is the path to running a capable open-weight model on hardware nobody else shares, without becoming an inference-ops team — and it pairs directly with harnesses, which are what make a smaller model reliable enough to be worth hosting.
Connect an account
- Settings → Providers → Connect RunPod. This opens RunPod's console signup in your browser.
- Sign up and generate an API key there.
- Paste it back into Podcode.
The key is validated against RunPod, then written to the encrypted credential store. The account is one per owner — reconnecting replaces the existing one, and a second user on the same machine keeps a completely separate account and set of deployments.
Serverless or Pod
Two deploy targets, and the choice is about usage shape rather than model quality.
| Serverless | Pod | |
|---|---|---|
| Scales to zero | Yes, RunPod handles it | No — it runs until stopped |
| Cold start | Yes, on an idle endpoint | Only on boot |
| Billing | Per request | Per hour of uptime |
| Best for | Intermittent use, trying things out | A working day of sustained use |
| Setup decisions | Pick a model | Pick a model and a volume size |
Serverless is deploy-once-and-forget: RunPod scales workers to zero on its own, so there's no idle-stop to manage. A pod is cheaper per token when you're actually using it and more expensive when you forget about it — which is what the lifecycle controls are for.
Deploy
From Settings → Providers, pick a template and deploy. What happens next:
- A shared secret is generated locally for this deployment.
- The endpoint or pod is created with that secret injected as a container environment variable, along with the model and its per-template settings.
- Podcode starts polling RunPod for readiness — backing off from two seconds to a cap of thirty, so a long cold start doesn't turn into thousands of API calls.
- When it reports ready, the endpoint joins your model picker.
Provisioning a serverless endpoint is minutes. A pod can legitimately take considerably longer on first deploy, because the weights have to be downloaded before anything can serve — the timeout is sized for the largest models in the catalogue, not the smallest.
The secure channel
The shared secret is generated on your machine, injected once at deploy time, and used by the worker to verify incoming requests. Your local server sends it as a bearer token on every inference call.
It only ever travels one way. The pod never calls back, never authenticates to Podcode, and holds no credential of yours other than the token it uses to check that a request is yours.
Inference goes from your machine straight to the RunPod endpoint. There is no Podcode infrastructure in the request path.
Using it
Once ready, the deployment is a model in the picker like any other. Point a session at it, or pin it to the stages of a harness where a hosted model is good enough and the frontier model isn't worth paying for.
Next
- Cost and lifecycle — spend caps, idle-stop, pause, terminate.