Recommended Free Tools
To run CircleCI machine jobs on several self-hosted machines, create one organization namespace and a resource class for each runner pool, save the class token, install Machine Runner 3 on every host, and set each job’s resource_class to the exact namespace/name. Scale each class from its own unclaimed and running-task demand, while enforcing your organization’s concurrency limit. Use single-task runners for disposable hosts and continuous runners only when an external controller retires idle machines.
The registration workflow is straightforward; reliable scaling is the systems problem. You must separate unlike hosts into meaningful pools, protect runner credentials, prevent queued work from exceeding plan capacity, and choose a lifecycle that actually removes unused compute.
As an Amazon Associate I earn from qualifying purchases.
How CircleCI routes work to multiple machine runners
CircleCI does not route a job to an arbitrary machine merely because the runner is online. A job requests a resource class, and only runners registered to that class can claim it. The namespace identifies your organization’s runner space; the resource-class name identifies a pool within that namespace. In project configuration, the value is written as namespace/name.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Most organizations use one namespace. Create additional resource classes when machines differ in an important way: operating system, CPU architecture, GPU or other hardware, installed toolchain, network placement, or trust level. A Linux build pool and a macOS signing pool should not share a class simply because both have spare capacity. Conversely, identical Linux hosts that can run the same jobs can share one class and be scaled as a single pool.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
The token generated for a resource class is the credential that lets a runner join that pool. CircleCI displays it only when the class is created. Treat it like a password: store it in a secret manager, limit who can read it, and never commit it to a repository or paste it into a public issue.
Plan the fleet before registering hosts
Identify the pools jobs really need
- Platform: separate Linux, macOS, and Windows execution where the job’s tools or licensing require it.
- Architecture: use separate classes for x86_64 and ARM when binaries or container images are not interchangeable.
- Hardware: isolate machines with large memory, accelerators, hardware security modules, or other scarce devices.
- Trust and network: keep production-connected or signing hosts apart from pools that execute untrusted pull-request code.
- Dependency image: group hosts that have the same SDKs, compilers, certificates, and system libraries so a job has predictable behavior.
Each class becomes a scaling boundary. If you combine unlike machines, demand data cannot tell you which capacity is useful, and a job may remain queued even while another host in the same class is technically idle but incompatible in practice.
Check administrative and infrastructure prerequisites
- An organization administrator must create the namespace and resource class for the manual Machine Runner 3 setup.
- If your organization already uses CircleCI Orbs, the runner namespace is shared with that setup rather than recreated independently.
- Confirm your plan’s organization concurrency limit. Adding hosts does not let more jobs run than that ceiling allows.
- Choose a host image, operating-system account, workspace location, cleanup policy, and provisioning method for each class.
- Decide whether hosts are persistent or disposable before selecting the runner lifecycle mode.
CircleCI’s documentation changes over time, including package versions, API details, plan limits, and chart compatibility. Check the current Machine Runner 3 manual installation page immediately before copying platform-specific installation commands.
Register a namespace and resource class
Use the CircleCI CLI or the organization’s documented administration workflow. The following commands show the CLI pattern; replace the example values with your organization ID, namespace, class name, and description.
- Choose a stable namespace name. Organizations generally need one namespace for their self-hosted runner classes.
- If the namespace does not already exist, create it:
circleci namespace create <name> --org-id <organization-id>- Create a resource class and generate its token:
circleci runner resource-class create <namespace>/<resource-class> <description> --generate-token- Capture the token at creation time and put it in your approved secret store. Do not assume it can be displayed again; CircleCI says the generated value is shown once.
- Repeat the resource-class command for every materially different pool, such as
acme/linux-x86,acme/linux-arm, oracme/macos-signing.
Use names that describe capability rather than a temporary host group. A class called linux-large can survive replacement of individual machines; a class called host-17 encourages jobs to depend on one machine and makes scaling awkward.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Install and configure Machine Runner 3 on each host
Install the runner separately on every machine that should consume work. All hosts in one class should have compatible software and permissions, but each runner needs a distinct runner name for inventory and troubleshooting.
- Prepare the operating-system account. Create a dedicated account where practical, grant it only the filesystem, network, and device access required by the jobs, and create a working directory with sufficient disk space.
- Install the current runner package. Follow the platform-specific commands in CircleCI’s manual installation guide. The documentation uses
currentas the binary-version selector; pin a specific version when reproducibility requires it, and update that pin deliberately. - Set a unique runner name. Include an immutable host identifier or inventory name. A name such as
linux-x86-az2-014is more useful than a generic label when a task fails. - Choose the working directory and cleanup behavior. Keep workspaces on a volume with predictable performance. Remove credentials, build outputs, and temporary files between tasks unless your isolation design explicitly requires caching.
- Configure the resource-class token. Put the token in the runner API configuration through the supported secret mechanism, not directly in source-controlled project configuration.
- Set the runner API endpoint. CircleCI Cloud uses the runner service at
runner.circleci.com. For CircleCI Server, configure the API URL for your Server installation hostname as described in the installation documentation. - Start the runner as a managed service. Use the host’s service manager or your image/bootstrap system so the process starts after reboot and logs are collected centrally.
- Verify registration. Confirm that the runner appears in the runner inventory, reports a recent connection, and is attached to the intended resource class before sending production jobs.
Repeat these steps for every host. Do not reuse a token from one class on a host intended for another class; the token is what binds that installation to its pool.
Route a job to the correct class
Set resource_class on the job that should run on your machine pool. The namespace and class must match the values created during registration, including capitalization and punctuation.
version: 2.1
jobs:
build:
machine: true
resource_class: acme/linux-x86
steps:
- checkout
- run: echo "Build on the self-hosted Linux pool"
- run: ./ci/build.sh
workflows:
build-workflow:
jobs:
- buildThe example is illustrative: replace acme/linux-x86 with your real namespace and class. A typo, deleted class, or token registered to a different class can leave the job waiting indefinitely because no eligible runner can claim it.
Use one job definition per capability when requirements differ. For example, a signing job should target a restricted signing class rather than relying on a runtime check that happens after the job has already landed on an unsuitable host.
Rank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
Choose a lifecycle: single-task or continuous
| Mode | Best fit | What happens after a task | Scale-down responsibility |
|---|---|---|---|
single-task |
Ephemeral VMs, containers, or instances created for one build | The runner exits after completing one task | Your provisioning system recycles the host when the runner exits |
continuous |
Persistent machines intended to process multiple jobs | The runner keeps polling for more work | Your controller must detect and retire idle machines; an idle timeout can assist |
single-task gives clean teardown semantics: create a host, run one task, then destroy or reset it. It is usually the safer default for untrusted workloads because state does not accumulate between jobs, although the host still needs correct isolation while that task runs.
continuous avoids provisioning latency and can keep a warm pool, but it does not scale down by itself. A controller must know when a host is idle, drain it safely, and stop it without interrupting a running task. CircleCI documents runner idle timeout as one mechanism for recycling resources when demand drops; select a timeout that is longer than normal startup gaps but short enough to control waste.
Scale each resource class from demand data
CircleCI’s scaling guidance recommends using unclaimed tasks, running tasks, and resource-class information to drive a fleet controller. The task data is scoped to one resource class, so query and make decisions per class rather than treating every runner as interchangeable.
A practical control loop
- Enumerate classes. Maintain the list of resource classes your controller is allowed to manage. Keep class metadata such as operating system, image, maximum size, and trust level alongside it.
- Read unclaimed work for one class. Unclaimed tasks represent queued demand that currently has no runner able to claim it.
- Read running work for the same class. Running tasks show capacity already consumed and help prevent a controller from terminating hosts that are still busy.
- Apply the organization concurrency ceiling. The number of hosts you could start is not the number of jobs CircleCI can execute. Cap launches so aggregate running work stays within the plan’s limit.
- Account for startup time. If a VM image takes several minutes to boot, request capacity before the queue becomes large enough to breach your service objective. Keep only the warm capacity that your workload justifies.
- Launch or retire hosts in that class. Add hosts when eligible demand exceeds available capacity. For scale-down, drain continuous runners, wait for running tasks to finish, then stop idle hosts; for single-task hosts, let the task completion path recycle them.
- Repeat on a controlled interval. Use a polling cadence that captures bursts without creating API pressure or launch thrashing. Add hysteresis so one short queue does not repeatedly create and destroy machines.
There is no universal threshold for queue length, polling interval, warm capacity, or maximum host count. Those values depend on build duration, startup time, budget, and the latency target for each class. Treat them as configuration, measure outcomes, and change one control at a time.
CircleCI’s scaling documentation summarizes the cost problem directly: “Maintaining a fixed compute fleet of self-hosted runners can incur unnecessary costs as the workload can fluctuate depending on the rate at which jobs are queued.” A demand-based controller addresses that fluctuation, but it cannot override your plan’s concurrency limit or make an incompatible host eligible for a class.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
Use the runner API for inventory and control signals
The runner API is separate from CircleCI’s v2 API. For CircleCI Cloud it is hosted at runner.circleci.com; CircleCI Server installations use the appropriate Server address. The documented API can list installed runners and query unclaimed and running tasks. Review authentication, endpoint paths, and Server differences in the self-hosted runner API reference before implementing a controller.
Inventory responses can include the hostname, runner name, resource class, connection timestamps, last-use timestamp, and runner version. These fields support practical operations:
- Find a host that stopped checking in even though the infrastructure provider reports it as running.
- Detect stale registrations after an image replacement.
- Compare runner versions across a class before a planned upgrade.
- Identify machines that have never processed a task and may be misconfigured or assigned to the wrong class.
- Correlate a failing build with the exact host and last-use time.
Store API credentials separately from resource-class tokens and grant the controller only the permissions it needs. Log decisions such as “three unclaimed tasks, two eligible idle hosts, launch one” so an operator can explain why capacity changed.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.When the Machine Runner Orchestrator fits
Manual host management is not the only option. CircleCI documents a Machine Runner Orchestrator that creates runner virtual machines through Kubernetes and KubeVirt. It is suited to teams already operating a Kubernetes control plane and willing to expose hardware virtualization to the nodes that host runner VMs.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Required components
- Kubernetes with KubeVirt installed.
kubectland Helm 3 or later.- A resource-class token for every class the deployment will provision.
/dev/kvmexposed on every node that runs runner VMs. Cloud nodes may require nested virtualization enabled before node creation.- The correct CircleCI Cloud or Server API address for the chart configuration.
The orchestrator can define several resource classes in one deployment. Classes are configured as a map keyed by namespace/name; entries can share defaults and override settings for a particular pool. This lets one deployment express common image, sizing, or lifecycle behavior while retaining separate tokens and capabilities.
Use the current Machine Runner Orchestrator documentation for chart values and version compatibility. Chart requirements and Kubernetes integrations are mutable, so do not hard-code an old chart version from an archived example.
Remember the scope boundary: CircleCI can describe automatic scaling of runner pods as work arrives, but it does not scale the underlying Kubernetes compute for you. Your Kubernetes cluster still needs enough node capacity, and machine-runner autoscaling likewise requires a fleet or orchestration system that can create and remove hosts.
Security boundaries you must design explicitly
A machine runner executes with the privileges of its operating-system user. If that user can access a Docker daemon, the effective access can be equivalent to root on the machine. A runner process is therefore not a security boundary for arbitrary, untrusted workloads.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problems- Protect tokens: keep class tokens in a secret store, restrict read access, rotate them through the supported administrative process, and scrub them from logs.
- Limit targeting: allow only approved projects and workflows to use sensitive classes, especially signing, production-network, or licensed-tool hosts.
- Isolate trust levels: use separate classes, accounts, networks, and images for untrusted pull requests and privileged internal builds.
- Prefer disposable state: recycle ephemeral hosts after a task, or aggressively clean persistent workspaces, credentials, caches, and temporary files.
- Constrain host privileges: avoid giving the runner account unnecessary sudo, cloud credentials, mounted host paths, or access to unrelated internal services.
- Audit activity: retain runner inventory, task assignments, image versions, and provisioning events so incidents can be investigated.
Security and scaling are coupled. A single shared class makes capacity easy to pool but also broadens which projects can reach the same machines. Split classes when the trust boundary matters more than maximum utilization.
Troubleshoot the common failure modes
The job stays queued with no eligible runner
- Check the job’s
resource_classspelling against the registerednamespace/name. - Confirm at least one runner is online in that exact class, not merely in another class in the same namespace.
- Verify the host can reach the runner API endpoint and that its service is running.
- Check whether your organization has reached its concurrency limit; additional machines cannot create execution slots beyond that ceiling.
The runner appears online but never claims work
- Confirm the token belongs to the intended class and was not truncated by a shell, environment variable, or secret-manager format.
- Inspect runner logs for authentication, TLS, clock, filesystem, or permission errors.
- Compare the configured runner version with the current installation guidance and verify that the working directory is writable.
- Check that the job’s machine executor and class combination is supported by the host image.
Hosts accumulate and costs rise after a demand spike
- Determine whether the runners are in
continuousmode; those hosts keep polling until an external controller retires them. - Add an idle timeout or an explicit drain-and-terminate path.
- Introduce scale-down hysteresis so the controller does not react to every short queue fluctuation.
- Compare per-class running and unclaimed tasks rather than using organization-wide totals that hide an idle class beside a busy one.
Jobs fail only on some hosts
- Compare operating-system image, architecture, installed SDKs, environment variables, disk space, and runner version.
- Use inventory data to identify the exact hostname and last-use timestamp for failing tasks.
- Rebuild divergent machines from the same image or split genuinely different capabilities into separate classes.
Manual fleet or orchestrator: which model to choose?
| Decision axis | Manually managed hosts | Kubernetes/KubeVirt orchestrator |
|---|---|---|
| Provisioning control | Use your existing VM, bare-metal, or cloud-image tooling and a custom scaler. | Declare runner VM behavior through Kubernetes resources and chart configuration. |
| Lifecycle | Implement single-task recycling or continuous-host idle cleanup yourself. |
Coordinate VM creation and retirement through the orchestrator and cluster controls. |
| Prerequisites | Host images, service management, secrets, networking, and fleet automation. | Kubernetes, KubeVirt, Helm 3+, tokens, and /dev/kvm with virtualization support. |
| Pool boundaries | Create and scale classes independently with your controller. | Define multiple namespace/name entries and per-class overrides in one deployment. |
| Underlying compute | Your infrastructure system must add and remove hosts. | Your Kubernetes cluster still needs sufficient node capacity; the orchestrator does not enlarge the cluster automatically. |
Choose the manual model when you already have reliable host provisioning and only a few pools. Choose the orchestrator when Kubernetes and KubeVirt are established operational platforms and you want a common declarative control plane for many runner classes. Neither model removes the need to enforce concurrency, secure tokens, or isolate untrusted jobs.
Operational checklist for production
- Namespace exists and is shared correctly with any existing runner setup.
- Every pool has a documented purpose, capability contract, owner, and maximum size.
- Resource-class tokens are stored outside source control and are available to provisioning automation.
- Each host has a unique runner name, managed service, writable workspace, cleanup policy, and monitored logs.
- Jobs use the exact intended
namespace/namevalue. - Scaling logic reads unclaimed and running tasks per class and applies the organization concurrency limit.
- Single-task hosts have a reliable destroy-or-reset path; continuous hosts have idle detection and safe draining.
- Runner inventory is monitored for stale connections, version drift, and hosts that never process work.
- Sensitive classes are restricted to approved projects and separated from untrusted workloads.
- For the orchestrator, Kubernetes, KubeVirt, Helm, virtualization exposure, chart version, and Cloud or Server API address are validated against current documentation.
With those controls in place, adding a host is repeatable: provision the approved image, inject the class secret, start Machine Runner 3, verify inventory, and let the class-specific controller account for it. Removing capacity is the inverse operation: stop accepting new work, finish or terminate safely according to the lifecycle mode, revoke access when necessary, and delete the host without leaving a stale registration.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
