Babco Labs Compute — Azure Developer Machine Wiki

This article is about Babco Labs Compute, the shared Azure developer machine available through ChatGPT.

Babco Labs Compute is a real Linux developer machine hosted in Microsoft Azure that ChatGPT can operate for you. It gives a chat access to an actual operating system for short engineering jobs: running scripts, installing tools, testing code, manipulating files, using developer utilities, and performing diagnostics.

The practical idea is simple: you should not have to sit in front of a Windows developer workstation just because a task needs a real computer. If you can open ChatGPT — including on your phone — you can launch work on Compute and receive the result back in the conversation.

The pitch: bring the developer machine to the conversation. No Remote Desktop session, no opening a dedicated development PC for a five-minute job, and no need to manage the ten execution channels yourself.

Contents

Why it exists
What you can do
Ten concurrent channels
Use it from your phone
Server specifications
Compute vs. a Windows developer machine
Best-fit workload and limits
Installation and use
Starter prompt
Glossary

Why it exists

Many engineering tasks need a real machine but do not need a human staring at a desktop. A developer might only need to run a test suite, install a command-line utility, extract an archive, inspect a package, render a file, execute a browser tool, or reproduce a failure.

Traditionally, that means opening a developer laptop or Windows workstation, connecting to a remote desktop, setting up the environment, and manually driving the task. Compute removes most of that ceremony. Describe the outcome in ChatGPT; the Azure machine performs the bounded work.

ChatGPT conversation → authenticated compute.invoke → shared Azure Linux VM → result returned to the conversation

What you can do

Compute is intended for practical developer and automation work such as:

Run scripts and command-line tools using Linux or PowerShell.
Build and test software for short, automated validation jobs.
Install temporary Linux packages with apt-get when the task needs another utility.
Create, inspect, transform, package, and delete files in a real filesystem.
Use browser and developer tooling for bounded automated jobs.
Perform diagnostics that require an operating system rather than pure chat reasoning.
Carry temporary working files across nearby invocations through shared scratch space.

The environment is deliberately general-purpose. It is not a single-purpose build runner; it is a small shared developer machine that an authorized ChatGPT workflow can use as needed.

Ten concurrent execution channels

The machine now supports 10 concurrent execution channels. Ten independent ChatGPT jobs can be admitted at the same time through ten fixed, reusable Azure Managed Run Command carriers.

When all ten channels are occupied, request 11 waits in FIFO order and starts when a channel is released. It does not create an uncontrolled eleventh carrier and does not collide with a running job.

Important: ten channels do not mean ten separate virtual machines or ten dedicated CPUs. They are ten execution lanes sharing the same 4-vCPU / 16-GiB Azure VM. This is excellent for mixed short jobs, scripts, I/O, automation, and normal developer work; ten simultaneous CPU-saturating builds will still share the same underlying machine.

Carrier recovery is automatic: temporarily busy execution lanes are reconciled and returned to the reusable pool instead of silently disappearing from capacity.

Use it from your phone

This is one of the most useful parts of Compute. The user interface is ChatGPT, not the server desktop.

Open ChatGPT on your phone, tablet, or computer.
Describe the engineering task and the result you need.
ChatGPT sends the bounded machine work to Babco Labs Compute.
The Azure VM runs it and the result comes back into the conversation.

For the right kind of task, there is no need to VPN into a workstation, launch Remote Desktop, open Visual Studio, or manually type shell commands. Your phone can be the control surface for a real cloud development machine.

Server specifications

The current Compute machine is a Microsoft Azure general-purpose Linux virtual machine. The following profile reflects the live Azure resource and its current VM size.

Azure VM	`vm-kvsf-compute-dev`
Region	Central US
VM size	`Standard_D4s_v3` (Azure Dsv3 general-purpose series)
CPU	4 vCPU · x86-64 Azure host CPU; exact physical host processor may vary
Memory	16 GiB RAM
Operating system	Linux · Canonical Ubuntu 24.04 LTS Server
OS disk	128 GB · Azure Standard SSD (`StandardSSD_LRS`)
Local temp storage	32 GiB available to this Azure VM size class
GPU	None — this is a general-purpose CPU VM, not a GPU machine
Execution channels	10 fixed reusable Managed Run Command carriers
Single invocation limit	600 seconds (10 minutes)
Scratch workspace	`/var/lib/babco-exec/scratch`
Scratch retention	24 hours, best-effort automatic cleanup
ChatGPT interface	One public Compute tool: `compute.invoke`

The 4-vCPU / 16-GiB and local-temp-storage values are properties of the Azure Standard_D4s_v3 size. The 128-GB Standard SSD, Ubuntu image, region, and VM identity are from the live Azure resource.

Compute vs. a Windows developer machine

Use Compute when…	the task can be described, automated, and completed as a short non-interactive job.
Use a Windows developer PC when…	you need a long interactive desktop session, a heavy GUI, repeated manual debugging, or hours of continuous IDE work.
Compute advantage	available through ChatGPT from anywhere; no workstation handoff; shared by many conversations.
Desktop advantage	better for continuous human interaction, large graphical workspaces, and software that specifically requires Windows GUI behavior.

Rule of thumb: if you would normally walk over to a developer machine just to run something for a few minutes, try Compute first.

Best-fit workload and limits

Compute is optimized for short, bounded engineering work, not for becoming somebody's permanent personal desktop.

A single invocation is capped at 10 minutes.
Temporary scratch data is intended to be short-lived and is cleaned after roughly 24 hours.
Durable source code and important artifacts should remain in their normal systems of record, such as GitHub or approved storage.
Package-manager activity is serialized so simultaneous jobs do not fight over apt locks.
All ten channels share the same CPU, RAM, and disk resources.

For jobs that may be retried, developers should also think about idempotency: design the operation so running it again does not create unintended duplicate effects.

Going forward, the expected experience is a shared cloud developer machine behind ChatGPT: simple at the surface, real Linux underneath, and immediately useful whenever a conversation needs a computer rather than just an answer.

Installation and use

Install the Babco Labs Compute v5 plugin in ChatGPT.

Open Plugins in ChatGPT from the sidebar, or go to Settings → Plugins.
Choose Browse plugins and open My Workspace.
Find Babco Labs Compute v5.
Select Install.
Select Connect and complete authorization if ChatGPT prompts you.

Once connected, you do not need to learn shell commands or manage the server directly. Ask ChatGPT for the outcome you want and let it use Compute when a real machine is useful.

Starter prompt

After installing the plugin, copy and paste this prompt into ChatGPT:

@Babco Labs Compute v5 I just installed Babco Labs Compute. Show me what this Azure developer machine can do for me from ChatGPT. Explain it in plain English, tell me what kinds of short engineering jobs I can run from my phone or computer, and give me practical examples. Explain the 10 concurrent execution channels, 10-minute run limit, package installation, temporary scratch space, file operations, testing and automation capabilities, and when I should use Compute instead of a Windows developer machine. Then suggest one safe, useful first task I can try.