New guides and project ideas on X: Follow @3DeltaD

Some links here are RunPod referral links: we may earn credits if you sign up. It costs you nothing extra. Details

What can I build? / Rent the muscle

A $20 plan is the planner. A rented GPU is the muscle.

A cheap AI plan can plan, explain, write and review. Some jobs need more than that: a huge model, a big pile of coding, or a whole team of AI helpers (often called agents) working at once. For those you can rent the hardware by the hour, use it for a day, and shut it down. Nobody has to carry it up the stairs.

Get the starter message

Want the numbers first? See what fits and what it costs per hour.

The idea in one minute

Think of two roles. Your plan is the planner: you talk to it, it breaks the project into steps and checks the results. A rented server is the muscle: it runs a big open model or many helpers for as long as you pay for it. Your plan only allows so much use, and that allowance is the scarce thing. So you spend it on planning and review, and let rented hardware do the bulk work.

This is a strategy we use and think is worth trying. The numbers below come from one real project run on a higher-tier plan with home and rented GPUs. We have not run the exact $20-plan version, and this page says where that matters.

Illustration of a man in a gym beside a weight rack, a visual joke about renting the muscle.

What one real project actually did

These are measured numbers from one real project: a game project, built with AI worker agents, a home GPU and a rented GPU. It ran on a higher-tier plan than a $20 one, so a $20 plan would reach its allowance sooner and lean harder on the GPUs. Each figure has a rough timeframe, and the table below shows how sure we are.

550 commits
65 merges

in one recent week from a steady team of 4 AI worker agents. A commit is one saved change to the code; a merge folds a batch of changes into the main copy. Counts, not quality: they include commits that arrived through merged branches.

10,609 tests passing

up from 1,246 about six weeks earlier, in the same project. A test is an automatic check that one piece of the code still works. This is a count of passing tests, not a quality score.

96 tokens a second

the middle (median) speed of a 27B open model on one consumer RTX 5090, across 42 real requests in one afternoon (slowest 55, fastest 160). A token is a piece of a word. One request at a time: we have not measured several at once.

3 h 14 min

from a written task to a fixed, independently checked change that cut a test run's memory from 13.4 GB to 3.0 GB (within the last 15 days). Our records show no human work on that task.

Every number we measured, and how sure we are
WhatValueSetupDateHow sure
Model speed, no speed-ups39.3 tok/s (long prompt of 24.8k tokens); 42.6 tok/s (short prompt)27B open model, 6-bit, one consumer GPU (RTX 5090 class)within the last 60 daysMedium: one run each
Model speed with drafting (a speed-up trick)104.6 to 111.8 tok/s (short prompt); 66.2 tok/s (long prompt)same, with multi-token draftingwithin the last 60 daysMedium: 1 to 2 runs, 2 prompts
Typical real-work speedmedian 96.2 tok/s (slowest 55.5, 90th percentile 114.3, fastest 160.1)same, 64k context, drafting onwithin the last 60 daysMedium: 42 requests, one afternoon
Best single result302.4 tok/ssame, a copy-heavy file editwithin the last 60 daysLow as a typical figure: a best case
Several requests at oncenot measuredthe server ran one request at a timenoneUnknown
Steady AI workers4 at once (about 20 at one point earlier in the project)agents plus rented and home GPUswithin the last 15 daysMedium: we do not know that all 20 stayed productive
Test machine capacitytwo full test runs at once with no slowdown, and memory was the limita consumer PCwithin the last 15 daysHigh
Same test run, two machinesabout 18 min at home vs about 30 min on a rented H100 that was shared with two other jobsa consumer GPU PC vs a rented H100within the last 15 daysMedium: the H100 was shared
One fix, start to finishbrief to landed change in 3 h 14 min; independent AI check took 14 min and passeda worker agent on a rented H100, a second AI model as checkerwithin the last 15 daysHigh for the numbers, medium for the timings (file times)

What went wrong, so you can avoid it

  • Memory, not speed, capped the parallel work. Many test runs at once ran out of memory long before the processor or the GPU were busy.
  • Free hosted build minutes vanished. These are a code host's free monthly allowance for running checks on its servers. With agents starting runs, a month's allowance was used up in days, so we moved the checks to our own machines.
  • A giant context window backfired. On a 32 GB card a 128k-token context spilled into system memory and generation fell to roughly 5 tokens a second (reported, not logged). We settled on 64k.
  • Plan allowances run out mid-week. A worker was refused once because the allowance ran out. Keep a cheaper fallback for checking work.
  • A bigger rented GPU was not faster for every job. That test run is limited by memory and processor, so the rented H100 took longer than the home box while shared.
  • Idle rented GPUs bill. One pod sat idle for hours before it was flagged and shut down.
  • A flaky test took a worker to chase. A flaky test fails only now and then. This one failed about once in nine full runs: often enough to annoy, rarely enough to hide.

Not measured yet

Several requests at once on one GPU. Dollars spent per accepted piece of work. How much work was rejected or redone. How long a human spent fixing things. We will add these when we have them, and we will not publish a number without a source.

1. What each one is good at

Your $20 planA rented GPU server
Best atPlanning, explaining, reviewing, writing the first version, steering a projectRunning a very large open model, running many helpers at once, long jobs, training
How you payA flat monthly price with a usage allowance (limits vary by company and plan)By the second while it runs, plus storage. You stop paying when you terminate it
LimitsThe allowance can run out on a big projectYou manage the setup. Left running, it keeps billing
PrivacyYour prompts go to the plan's companyThe model runs on a machine you rented. If privacy matters, check RunPod's security terms for the cloud type you pick

2. Three ways to use the muscle

A. A big open model as your bulk coder

Rent one GPU, run an open model on it, and point your coding tools at it. Many coding tools let you set a custom OpenAI-compatible address; check that yours does. RunPod's documentation describes serving language models that way [1]. Your plan then handles the planning and review while the rented model does the typing.

B. A team of helpers on one rented machine

A server can run many helper programs at once, and one big model can answer all of them. Serving software such as vLLM is built for many requests at a time [1]. How many helpers one machine can keep busy depends on the model and the work, and we have not measured it. Helpers that call a paid hosted API still bill per use; the savings only appear if they call a model you are running yourself.

C. A burst for one big job

Rent a large machine for the hours a heavy task needs: a long training run, a huge batch of generated assets, or a model that will not fit anywhere at home. Terminate it when the job is done.

Connect your assistant to real data

An assistant gets much more useful when it can read real data instead of only talking. Many assistants can connect to outside sources through connectors: market data*, sports stats, weather, business numbers, your own spreadsheets. The assistant pulls the data, sorts it, compares it and explains what it sees in plain words. A rented server can chew through much bigger piles of data than a laptop can.

What you do with the answers is up to you. Check anything that matters yourself.

* For education and information only. Not financial advice. We are not financial advisors. Trading and investing involve risk, including loss of principal.

3. What fits, and what it costs per hour

Memory figures are estimates from our VRAM calculator (weights, context memory, 10% working memory and 1.5 GB overhead per GPU). They are not measurements. Rates are RunPod on-demand Secure Cloud rates fetched within the last 30 days and can change.

What you want to runEstimated memoryA GPU setup that holds itPer hour
A 32B coding model, 4-bit, 16K contextabout 25.6 GB1 x RTX A6000 (48 GB)$0.69
A 70B model, 4-bit, 8K contextabout 47.3 GB1 x A100 PCIe (80 GB)$2.09
The same 70B-class job on a faster cardabout 47.3 GB1 x H100 SXM (80 GB)$4.39
Llama 3.1 405B, 4-bit, 8K contextabout 256 GB1 x B300 (288 GB)$8.99
DeepSeek V3, 4-bit, 8K contextabout 417 GB2 x B300 (576 GB)$17.98

Want the cost of a whole session, not just an hour? The session cost planner multiplies it out and shows what a stopped or forgotten pod keeps billing.

Time adds up. You pay the hourly rate for every hour the server is on, whether or not it is busy. So the habit is: start it when you are ready, work, download your files, and terminate it. Set a timer.

Seen enough to try one of these? Create a RunPod account (referral link: we may earn credits if you sign up and use RunPod). What happens when you press it. Or keep reading: the limits are in section 4.

What an hour of muscle gets you

The useful question is not what the machine costs. It is how much work an hour buys. Pick a server setup and a model. The calculator checks the fit, gives a speed for one request at a time, and does the arithmetic. One pair is measured on our own RTX 5090. Every other speed is an estimate, marked (est.). Got your own number? Type it in and it takes over.

Words from a model

(est.) = our math from published specs and benchmarks, not a promise. The cost per million tokens uses the price of the setup you picked and the speed in the box.



How the estimates work, and where the numbers come from

To write one token, a model reads all of its weights from the card's memory once. So the memory speed the maker publishes for a card, divided by the size of the weights, sets a ceiling. Real software reaches part of that ceiling, and every token also costs a little fixed time. That is why a huge card is not ten times faster on a small model.

We start from our own measurement: a 27B model at 6-bit on one RTX 5090 ran at 42.6 tokens a second with a short prompt and 39.3 with a 24.8k-token prompt, one request at a time, no speed-up tricks. Public benchmarks show how other cards and model sizes compare, and we scale our number by those ratios. Where the benchmarks and the memory-speed math disagree, we follow the benchmarks. The estimates are for everyday software such as llama.cpp or Ollama; a tuned server can go faster. The range next to each estimate is as wide as the spread of the public numbers for that kind of card.

With more than one card: cards joined by NVLink (H100 SXM, H200, B300) can split a model and work on every token together, which helps big models. That takes a server built for it, such as vLLM. On the other cards, extra cards add room, not speed. Nobody has published a one-request benchmark for the B300 yet, so its range is the widest. The measured speeds with drafting (a speed-up trick) are offered only for the one card and model they came from.

Benchmarks used: the llama.cpp speed scoreboard; GPU benchmarks on LLM inference; NVIDIA's NIM benchmarking guide; a side-by-side test of the two H100 cards; and Ollama runs on a hosted RTX 5090, RTX A6000, A100 and H100.

Memory speeds, as NVIDIA publishes them: RTX 5090, 1,792 GB a second; RTX A6000, 768; A100 PCIe 80 GB, 1,935; H100 SXM, 3,350; H200 SXM, 4,800; B300, up to 8,000. Whether a model fits uses this site's VRAM calculator at an 8K-token context; the models are counted at its 4-bit setting, except the 27B one at 6-bit.

Images, for example game characters

We have no measured image speeds for these cards, so nothing here is estimated and the setup above only changes the price. The 10 is an example to show the arithmetic, not a measurement. Replace it with a time you measured.


What to notice: the same machine at a higher speed makes each million tokens much cheaper. Keeping a rented server busy, with several helpers sharing one model, is the whole case for renting big. An idle server is the opposite: you pay the same rate for nothing. This calculator covers one request at a time only.

A token is a piece of a word; one token is roughly three quarters of an English word. A page is counted as 500 words. A "game character" here means one generated image; a finished, usable character takes several tries, so treat the number as an upper bound. These are rough conversions, not measurements.

We will swap estimates for measured speeds as we test more setups.

4. The honest limits

  • Our real numbers come from one project on a higher-tier plan. We have not run the exact $20-plan version. The memory sizes in the table above come from our calculator, and the prices from RunPod's rates. How many helpers one machine can keep busy is not measured yet.
  • Big open models are not the same as the best hosted ones. They can fall short on some tasks. Try yours on a small piece of real work before you hand it a project.
  • The setup is real work. Your assistant can do much of the typing, but expect some trial and error.
  • Check your plan's terms. Some plans limit how they can be used with automated tools or by many agents at once. Read yours before you build a workflow around it.
  • The meter keeps running. Terminate the server when you finish, and download what you need first. A stopped pod still charges for its disk [2].
  • Pod web addresses are public. If you expose a model or an agent dashboard, put a password on it [3].

5. A starter message for your assistant

Paste this into the assistant on your plan. It asks for a split of the work and a price, and it is told not to spend anything without your yes.

Plan the split: planner on my plan, muscle on a rented GPU

I have an AI assistant plan at about $20 a month and I want to build: [describe your project]. What I have: [iPad / laptop / PC with a GPU of about N GB].

Please help me split the work. 1. What you (the planner) should do with my plan's limited allowance: planning, review, hard decisions. 2. What a rented GPU running a big open model, or several helpers, could do in bulk. 3. Recommend the cheapest RunPod GPU setup that can hold a suitable open coding model, its hourly price, and an honest estimate of how many hours the work might take. Say which numbers are estimates and what you cannot know. 4. Tell me if renting is not worth it for this project. 5. Do not create, start or pay for anything until I reply "yes, go". When we finish, help me download my files, terminate everything, and confirm nothing is still billing. If you are not sure about a fact, say so instead of guessing.

You should get: a written plan with a price and an honest "is this worth it". Check: it names a GPU, an hourly price and the hours it assumes, and it waits for your "yes, go".

Ready to try the muscle side?

Make a RunPod account and add a small balance such as $10, or paste this into your AI assistant: Read agents.runpod.io and set up Runpod for me. Then use the starter message above.

Referral link: we may earn credits if you sign up.

Create a RunPod account

What happens when you press "Create a RunPod account"

  1. RunPod's sign-up page opens in a new tab. You make the account yourself, on RunPod's site. The link carries our referral code.
  2. To rent anything you first add a balance. That is a payment to RunPod, so start small, such as $10. RunPod's referral terms describe a bonus credit for a new account that signs up with Google and loads at least $10. Read the terms for the amounts and regions.
  3. Nothing starts on its own. You choose a machine, or your assistant proposes one and, as the starter messages tell it to, waits for your "yes, go". Check the price per hour before anything is deployed.
  4. A running machine bills by the second. When you finish, download your files, terminate the pod (a stopped pod still bills for its disk) and check the console shows nothing running.

Not ready? That is fine. Copy the starter message above first and see what your assistant says, or follow @3DeltaD on X and come back later.

Sources

  1. RunPod docs, Integrate your applications (OpenAI-compatible vLLM endpoints): docs.runpod.io/integrations/overview
  2. RunPod docs, Pod pricing and storage costs: docs.runpod.io/pods/pricing
  3. RunPod docs, Expose ports (the HTTP address is public): docs.runpod.io/pods/configuration/expose-ports

GPU rates are RunPod on-demand rates from its API, fetched within the last 30 days, and may have changed. Memory figures are estimates from this site's VRAM calculator. Hourly figures are arithmetic on those rates. The "$20 plan" is an example, not a quote; plan prices and limits vary.