givemeanode

Changelog

Everything we ship, as fast as it ships.

  1. Hand your agent private data without pasting a secret

    You say to your agent
    “Import the gated corpus from our Hugging Face repo onto this node.”

    Public data was never a problem, but data behind a credential, a gated Hugging Face repo or a private S3 bucket, used to mean pasting a token into the chat, which is exactly where a token should never go. Now an admin describes the access once, from their own terminal with gman connection create, and from then on your agent refers to the connection by name. We fetch the bytes onto the node ourselves, so the credential never appears in the chat, in the agent, or on the node. For S3 the connection can be a cross-account role, which involves no secret at all.

    The same release adds object storage: buckets on our own object store that your organization owns, filled from the command line (gman storage cp ./data corpus/) and read by agents through the same import path. The first 100 GB is free, then storage starts at $0.10 per GB-month and gets cheaper in tiers as it grows.

  2. Snapshot a node once, clone it many times

    You say to your agent
    “The environment is ready. Snapshot it, then give me four clones and run one config on each.”

    A snapshot is a durable copy of a stopped node's disk, safe against anything that happens to the machine. Prepare an environment once, weights downloaded, kernels compiled, and checkpoint it. A snapshot restores into as many new nodes as you like, and restoring counts as provisioning, so a clone costs nothing until it is ready. Snapshots never expire on our timer, but you can give one an expiry so it cleans up after itself, and snapshot storage is priced per GB-month past a free allowance, with the rate quoted in the response.

  3. Logs, metrics, and traces for every run

    You say to your agent
    “Which of last night's runs starved the GPU, and why?”

    Every background command's output now streams into queryable storage as it is produced, so logs outlive the node they ran on and searching a week of runs is one question. GPU utilization, memory, power, and spend are recorded automatically for every node, your training script's own metrics can join them, and requests can be traced end to end. Charts your agent saves land on the project's page at /projects, so each project reads like the instrument panel of that investigation.

  4. gman: the whole product from a terminal

    Agents talk MCP and humans had the website, but a person at a shell, or a script in CI, had neither. Now everything your agent can do, you can do as typed commands:

    curl -fsSL https://givemeanode.com/cli.sh | bash
gman login
gman node create --chip h100
gman run demure-hawk -- nvidia-smi

    Under the CLI sits a plain HTTP API you can curl with the same token, described at /preview/openapi.json. It is a preview, so the contract may still move before it is promoted to v1. Every example on /docs now shows the same action three ways: the English you say to an agent, the gman command, and the raw MCP call.

  5. Queued jobs now tell you how long the wait is

    You say to your agent
    “How long until my evaluation jobs start?”

    The answer is now a live place in line and a wait estimate, measured from how fast the queue has actually been moving. If there is not enough recent activity to estimate from, the answer says so instead of guessing. Time spent waiting in the queue is still free, so a long estimate costs you nothing but patience.

  1. Send big files from your side to a node

    You say to your agent
    “Take the dataset sitting in your sandbox, it is about 2 GB, and put it on my node.”

    Small files could already be written straight onto a node, and anything public could be downloaded from inside it. Files that exist only on your agent's side, like a private dataset, were the awkward case. Now your agent can upload up to 10 GB once and land it on any node, and the same upload stays reusable for about thirty days, so five nodes and a batch job can all read the one copy.

  2. File a support ticket without leaving the chat

    You say to your agent
    “My node will not wake up. File a support ticket and include what we just tried.”

    Your agent can now open a ticket with us, attach the story of what it was doing when things went wrong, and check back later for our reply. You can read and answer the same tickets yourself at /contact. Nothing about getting help requires leaving the conversation where the problem happened.

  3. Projects group the work of one investigation

    You say to your agent
    “Start a project called scaling-laws and put tonight's runs in it.”

    A project collects the nodes and jobs that belong to one question you are trying to answer. Next week you can ask “what did we try in scaling-laws, what did it find, and what did it cost?” and get one answer instead of a hunt through history. Your projects also have their own page in the dashboard at /projects.

  4. Referrals now pay both sides

    You say to your agent
    “Get me my referral link.”

    Share the link with a friend. When they sign up through it and add a payment card, they get $50 of credit to spend on GPUs, and you earn credit worth 2% of what they go on to spend. The /referrals page shows who signed up, when, and what you have earned, day by day.

  5. One dashboard for your whole account

    Open /dashboard and everything about your account is in one place: usage, billing, team, referrals, and projects, in a single sidebar instead of separate pages you had to know the addresses of. The public site got the same cleanup. Every address you may have bookmarked still works.

  6. The status page now tests the real product, constantly

    Open status.givemeanode.com and you will find a monitor called End-to-end. Every few minutes we create a real node, run a real command on it, and stop it, exactly the way your agent would. If any step of that breaks, the status page turns red on its own, usually before you would have noticed anything. A green status page now means the product works, not just that the website is up.

  1. The manual is one page, and agents can read it too

    You say to your agent
    “Read https://givemeanode.com/llms.txt, then get me a node and set up my repo on it.”

    Everything about the product now fits on one page at /docs, from getting your first node to batch jobs, and every section has its own link you can send to someone. The same manual is published as plain text at /llms.txt, so an agent can read the docs the way you would and stop guessing.

  2. Ask whether a server on your node is answering

    You say to your agent
    “Is the model server on port 8000 up yet? How fast is it?”

    Your agent can now make one timed web request to any port on your node and report back the status and the response time. It works on ports you have not made public, and it replaces the fragile dance of quoting a curl command inside a shell command inside a tool call.

  1. Batch jobs: queue hundreds of runs, pay only for the running ones

    You say to your agent
    “Queue 200 evaluation jobs overnight and show me a table of the results in the morning.”

    Jobs are for work nobody should babysit. Your agent describes the run, we build it, put it in a fair line, run it, and bill only the minutes it is actually running. Waiting in the queue is free, and hours in the queue on a busy night is normal, not a problem. Each job can declare its result as it finishes, so “show me the results” comes back as a tidy table instead of a pile of logs.

    You say to your agent
    “Try learning rates 1e-4, 3e-4, and 1e-3 on the same setup and tell me which one trains best.”

    One request can carry up to 256 variations of the same job. They share one build, run as separate jobs, and read back as one comparison.

  2. A training script can stop its own node

    The last line of a training script can now be one small web request that stops the node it is running on, so a run that finishes at 3 AM stops billing at 3 AM instead of when someone wakes up:

    curl -s -X POST -H 'Metadata-Flavor: givemeanode' http://169.254.42.1/v1/stop

    Scripts on a node can also ask who they are and what they cost per minute, and watch for warnings that carry deadlines, like a machine being retired, in time to save a checkpoint. No password or key is needed for any of this; running on the node is the credential.

  1. Pin the GPU clock for benchmarks

    You say to your agent
    “Get me a node with the GPU clock pinned. I want benchmark numbers I can compare across runs.”

    GPUs quietly raise and lower their own speed with temperature and load, which makes two runs of the same benchmark disagree for no interesting reason. Ask for a pinned clock when the node is created and your timings become comparable. It costs nothing extra.

  1. Let a connection do less than everything

    Give a CI agent a connection that can run nodes and jobs but cannot see billing or invite anyone. Give a finance script a connection that can read spending and touch nothing. When an agent connects, the approval screen is now a checklist: infrastructure and organization are separate boxes, each with a read-only version, and a box you leave unchecked is an ability that connection never even sees.

  1. See exactly what you spent

    You say to your agent
    “How much did we spend on GPUs this week, and on what?”

    The answer comes back per node and per minute, and the same ledger renders in the browser at /usage, split by workspace, by person, and by node, with a CSV download for your spreadsheet. Invoices, receipts, and your payment method live at /billing.

  1. Bring your team

    You say to your agent
    “Invite sam@lab.edu to our workspace as a member.”

    Every account is a team of one until you invite someone. Members run their own nodes on the shared bill, admins see everything, and a billing role sees just the money pages. A workspace can carry a spending cap, and an admin can stop any node in the organization, which is the answer to a student's forgotten node burning money over the weekend. The same controls live at /team.

  1. Put a port on the internet

    You say to your agent
    “Serve the model on this node and give me a link I can open in my browser.”

    Your agent can now take any port on a node, a TensorBoard, a Jupyter server, a model answering requests, and give it a public HTTPS address. Anyone holding the link can reach it, so treat the link like a password, or ask for token protection on top. Traffic through the link is free and never keeps the node awake on its own.

  1. A queue that holds your place

    You say to your agent
    “Get me an 8 GPU machine. I can wait up to an hour.”

    When every machine is busy, asking for a node now gets you a place in line instead of an error, with a live position and a wait estimate. The moment a slot frees, the node is yours. Waiting costs nothing, and asking again never loses your spot or creates a duplicate.

  1. Files in and out

    You say to your agent
    “When training finishes, download the checkpoint folder to my machine.”

    Your agent gets back a private download link, and a whole folder arrives as a single archive. In the other direction it can write small files like scripts and configs straight onto the node, and fetch big public things like datasets and models from inside the node, where the network is fast.

  1. Training runs that outlive the conversation

    You say to your agent
    “Start the training run, then check on it every hour and tell me if the loss stops falling.”

    Long work now runs in the background on the node, so nothing is lost when a chat moves on or a tool call times out. Your agent can read the newest log lines, see whether the run is still going, and stop it, all later. Checking on finished work never wakes a stopped node, so it is always free.

  1. Stop paying, keep your files

    You say to your agent
    “Stop the node. We will pick this up tomorrow.”

    A stopped node costs nothing and keeps its disk exactly as you left it. Tomorrow, “wake tulip back up and keep going” is the whole procedure; the next command wakes it automatically. It behaves like a machine you can power off: files survive, running programs do not.

  1. givemeanode is live: GPU nodes your agent can ask for

    You say to your agent
    “Get me a GPU node, clone github.com/you/yourrepo on it, and run the benchmark.”

    That sentence is the whole product. givemeanode gives AI agents like Claude, Codex, and opencode on-demand H100 nodes, billed by the minute, with no SSH keys and no console to click through. You connect it once:

    claude mcp add --transport http givemeanode https://mcp.givemeanode.com

    A browser window asks you to approve, and from then on your agent can get nodes, run commands on them, and hand you the results. The price is quoted at the moment each node is created, and that quote is what you pay.