Our own U.S. GPU data center
Actrium AI is building its own GPU data center in the United States. Location, capacity and service dates will be published here once confirmed.
Train · Deploy · Operate
Training & Compute
From robot data to deployed skills. Actrium connects your datasets, model training, hosted inference and on-robot execution in one traceable workflow, and we are building our own GPU data center in the United States to run it.
U.S. infrastructure
Building our own U.S. GPU data center.
Actrium AI is building its own GPU data center in the United States, and the first servers have been ordered. The facility is not yet in service. Until it comes online, compute for each project is scoped individually, and we confirm in writing where your training and inference will run before any data moves.
First servers on order
The first servers for the facility have been ordered. Hardware configurations will be listed here as they are confirmed.
NVIDIA Inception
Actrium AI is a member of NVIDIA Inception, NVIDIA's program for startups.
NVIDIA and NVIDIA Inception are trademarks and/or registered trademarks of NVIDIA Corporation in the U.S. and other countries.
Why Actrium
Compute organized around robot learning.
Run models your robot can't host.
When a policy or vision model needs more GPU memory than a robot can carry, we evaluate server-class inference so the heavy compute stays off the robot.
Share compute across robots.
Compatible robots can share one model service instead of duplicating environments and idle GPUs. Whether that lowers cost depends on GPU, network, storage and operations together, and we model it with you first.
Ship skill versions, not device images.
Models, adapter configurations and evaluation records are managed centrally, released to devices in stages and rolled back to a validated version if a regression appears.
Train & fine-tune
Training runs that start from your data.
Bring datasets from Actrium data collection and the Data Platform, or from your own storage. We size GPU memory and count from model size, sequence length, visual inputs, batch size and precision, then confirm the estimate with a short pilot run before committing to a full training job.
Data Platform →Typical workloads
- Embodied data processing and dataset export
- VLA fine-tuning on task-specific demonstrations
- World-model experiments
- Imitation-learning baselines for Atlas robot learning workstations
- LeRobot-compatible data and training workflows, tested per version
1. Pilot run
Train on a representative slice to measure throughput, memory use and early signal, then estimate full-run resources.
2. Full training
Run on an agreed dataset version with fixed splits, seeds and environment dependencies.
3. Offline evaluation
Replay held-out episodes and compare against baselines under the same data and training budget.
4. Physical evaluation
Supervised trials on the target robot, with success rates tied to named tasks, objects, starting states and trial counts.
Model support, data-upload rights and training services are confirmed per project. We don't promise fixed training times or general success rates.
GPU compute & model API
Two services for two kinds of work.
GPU compute
Environments for data processing, VLA and world-model training. We match GPU memory, software dependencies and storage to the workload and record usage by resource type.
ExperimentGPUArtifacts
Model API access
When a project uses hosted vision or language models for annotation, retrieval or quality review, we agree which models are used, who can access them and usage limits with you up front.
Data toolsAPIModels
API access and GPU resources are scoped separately. Neither is a robot control interface. Availability and authorized data transfer are confirmed per project.
| Option | Status | Best for |
|---|---|---|
| Actrium U.S. GPU data center | Under construction; first servers ordered | Training, fine-tuning and hosted inference once the facility is in service |
| Project-scoped compute | Where it runs is confirmed in writing per project | Pilots and training runs before our own facility comes online |
| Your cloud or GPU cluster | We deliver configurations, containers and experiment records | Teams with existing capacity, or data that must stay in their environment |
| On-site workstation | RTX 4070 / 4080 / 4090 / 5070 / 5080 / 5090 options | Collection, preprocessing and local inference; compatibility confirmed per configuration |
Configure three distinct workloads.
Collection and processing
Local workstations support sensors, replay and preprocessing. Prioritize interface bandwidth, storage throughput, timing and sustained operation.
Training and fine-tuning
Select GPU memory and count for model size, sequence length, visual inputs, batch size and precision. Estimate resources after a pilot run.
Online robot inference
Choose hosted, private-site or onboard deployment for latency, network, power and data permissions. Adapt the model interface and runtime to the robot.
Workstation configuration options
RTX 4070 / 4080 / 4090 / 5070 / 5080 / 5090 options require confirmation of memory, power, cooling, chassis and software compatibility. High-power configurations are not assumed to fit onboard a mobile robot. Hosted compute and model API usage are scoped separately.
Hosted inference for robots
Cloud intelligence. Local control.
Deploy a trained policy as a monitored, versioned skill service. An on-site gateway connects the robot, and emergency stop and low-level control never wait on the network.
Hosted inferenceModel + adapter + version
Observations ↑Validated results ↓
Robot gatewayState alignment · Action expiry
Choose where inference runs.
Host the model remotely. Keep control on site.
Run inference off the robot when connectivity is stable and data transfer is authorized. Where the model is hosted is confirmed in writing for each project; hosting in Actrium's own U.S. data center becomes available once the facility is in service.
Share model environments and versions without duplicating large-memory compute on every robot.
Validate tail latency, jitter, concurrency, queueing and transfer cost. Retain necessary local compute and safe fallback.
Model service
Task understanding, policy inference and candidate action chunks. Receives authorized observations and returns time-limited results.
On-site gateway
Timestamps, state alignment, action mapping and validity checks. Only actions that pass constraint checks are executed.
Robot local control
Servo control, limits, emergency stop and validated fault handling. Results and exceptions flow back to authorized logs for evaluation and recollection.
High-frequency control stays with the robot.
Align camera inputs, state, coordinates and action spaces through a local gateway. Validate action expiry, bounds, timeouts, emergency stop and human takeover before enabling execution.
Optimize the whole path, not just the GPU.
Model
Evaluate quantization, inference steps and action-chunk strategy against task performance and response time.
GPU kernels
Evaluate operator, compiler and memory-access optimizations per model and hardware; re-validate numerics and policy behavior after acceleration.
Network
Tune observation encoding, transport and connection handling to control bandwidth, jitter and stale data, not just average latency.
Placement
Choose where inference runs by robot location and site conditions, with warm-up and concurrency scheduling or private-site compute.
We compare hosted, private-site and onboard options on the same task baseline and don't assume hosted is better.
How an engagement runs
A versioned path from model to robot.
1. Package the skill
Version weights, preprocessing, input and output contracts, robot adapters and operating conditions together.
Delivers: Skill manifest and adapter configuration
2. Deploy the inference service
Configure resources, warm-up, monitoring and concurrency isolation on hosted or private GPUs.
Delivers: Deployment configuration and performance report
3. Integrate on the robot
Align cameras, state, coordinate frames and action space through the gateway; test action expiry, bounds and timeouts.
Delivers: Interface adaptation and fault-test results
4. Evaluate and release
Offline replay and shadow inference first, then supervised trials and staged rollout to compatible devices.
Delivers: Acceptance report and rollback procedure
Deliver a reproducible experiment.
Experiment configuration
Dataset version, splits, preprocessing, hyperparameters, random seeds and environment dependencies.
Model artifacts
Agreed weights, configurations, licenses and third-party dependency manifest.
Evaluation report
Fixed tasks and trial conditions, success rates, interventions, duration and failure categories.
Resource records
GPU type, runtime, storage and API consumption recorded separately.
Model availability, API permissions, data upload and training services require project confirmation. An unvalidated model is not described as ready to run on an arbitrary robot; training duration and success rates depend on the task.
Understanding and data processing
Vision and language APIs can support task descriptions, candidate annotations, retrieval and quality review. Their outputs need review and are not automatically action ground truth.
Robot policy inference
Specify camera inputs, state fields, action spaces, end effectors and control frequency. Correct offline output does not establish safe physical execution.
Security & data residency
Your data, handled under a written data contract.
Customer data is stored and processed in the United States by default. Before any transfer, we agree in writing on ownership, usage scope, retention, access and any third-party processing.
Compliance requirements
Tell us your security, compliance and procurement requirements at the start. We confirm in writing what applies to your project before work begins.
- U.S. storage and processing of customer data by default.
- Project data leaves your environment only with written authorization.
- Access isolation, logging and operational responsibilities defined for each deployment.
- Evaluation data separated by participant, scene or date.
- API keys stay server-side; sensitive raw data is not sent to third-party models without specific authorization.
Pricing & engagement
Scoped to the task, itemized on the invoice.
Most projects start with a pilot on one task. After the pilot, GPU compute, model API usage and engineering services are quoted as separate line items, so you can see what each part of the work costs.
What we need to quote
- Target robot, cameras and action space
- Dataset size, modalities and current format
- Model family and training objective
- Where inference must run, and your latency requirements
- Data residency, security and procurement requirements
FAQ
Questions teams ask before training with us.
Is Actrium's own data center available today?
Not yet. We are building our own GPU data center in the United States, and the first servers have been ordered. Until it is in service, compute for each project is scoped individually, and we confirm in writing where your training and inference will run before any data moves.
What happens if the network is slow or drops?
Heartbeats, observation freshness and action validity windows are checked continuously. On a timeout or state mismatch, stale actions are rejected and the robot enters a controlled stop, a safe hold or a validated fallback, with human takeover preserved. When the connection returns, state is re-synchronized and old commands are never replayed. High-frequency contact control never depends on an internet round trip.
How do you know a deployment actually works?
We measure observation-to-action latency end to end, not just GPU inference time, and record P50, P95 and P99 latency, jitter, packet loss, queueing and cold-start time. We then check task success, interventions, timeout handling, rollback and total operating cost. We don't quote a fixed latency or a general success rate in advance.
How is this different from renting GPUs or calling a model API?
A model API gives you access to models, and GPU compute gives you resources. A robot skill also needs its own model runtime, a device adapter and a local control path. We build and validate those per project and link execution logs to data versions and recollection.
Can we train in our own cloud or cluster?
Where it fits the project, we deliver configurations, containers and experiment records for your environment. Compatibility with your cloud account or cluster is confirmed during scoping.
Where is our data stored?
Customer data is stored and processed in the United States by default. Ownership, usage scope, retention, access and any third-party processing are agreed in writing before transfer.
Build with Actrium
Have a model or a robot?
Start with a deployment assessment for one task.