Setting Up the ASUS Ascent GX10 for AI Projects: My Starter Toolkit

🌏 繁體中文版：ASUS Ascent GX10 AI agent 開發工具設定與安裝

I bought an ASUS Ascent GX10, a compact desktop AI machine built on NVIDIA's GB10 chip, to run practical AI projects at home. Before starting any project, I set up the basic tools I'd need to use it comfortably. Here is the checklist.

ASUS Ascent GX10
ASUS Ascent GX10

1. SSH

Lets me work on the GX10 from a laptop or phone without plugging in a monitor. It's ready to use once the GX10's initial setup is complete.

2. SFTP for file transfer

For moving files to and from the machine. SFTP runs over the same SSH service, so it works out of the box — point any SFTP client at the GX10.

Connecting with an SFTP client
Connecting with an SFTP client

3. Remote desktop

For the times I want the full graphical desktop instead of a terminal.

4. Tailscale

A mesh VPN that lets me reach and control the GX10 from any network, not just at home.

curl -fsSL https://tailscale.com/install.sh | sh
sudo systemctl enable --now tailscaled   # start now and on every boot
sudo tailscale up                        # log in and join your tailnet

5. OpenClaw

An AI agent framework I wanted to try on local hardware:

curl -fsSL https://openclaw.ai/install.sh | bash
OpenClaw status after installation
OpenClaw status after installation

6. Ollama

Runs large language models locally, which is the main reason to own a machine like this:

curl -fsSL https://ollama.com/install.sh | sh
Installing Ollama and checking the version
Installing Ollama and checking the version

7. Docker

Comes ready to use once the GX10's setup is complete — handy for running services in isolated containers.

Checking the Docker version
Checking the Docker version

Quick health check after setup

Once everything is installed, these few commands confirm the machine is what you think it is. The comments show what mine reports (Ubuntu 24.04.5 LTS, October 2026):

uname -m                 # aarch64  (it's an ARM machine, not x86)
nproc                    # 20
free -h                  # ~121 GiB total, shared by CPU and GPU
nvidia-smi --query-gpu=name,driver_version --format=csv,noheader
                         # NVIDIA GB10, 580.x
nvcc --version | tail -1 # CUDA 13.0
ollama --version
docker --version
systemctl is-active ssh tailscaled   # both should say "active"

Things that surprised me

  • It's ARM64. uname -m says aarch64. Most of what I needed has ARM builds (Ollama, Docker, Tailscale), but when a Docker image or a binary download fails with "exec format error", it's almost always an x86-only build. Look for an arm64/aarch64 tag first.
  • Memory is unified. There's no separate VRAM number to watch: the GPU and CPU share the same ~121 GiB. That's what lets a 27B-parameter model load comfortably, but it also means a big model and a big build job compete for the same memory.
  • Headless is the normal mode. After the first boot I almost never plug in a monitor; SSH plus Tailscale covers nearly everything, and remote desktop is the fallback.

What this setup turned into

This checklist was the starting point. Here's what I ended up running on top of it, each written up after it worked:

A note on piping install scripts

Several of these tools install with curl … | sh. That's convenient, but it runs a remote script with your privileges. Only do it with URLs from the project's official site, and if you want to be careful, download the script first and read it before running it.

This post is adapted from the Traditional Chinese original on Vic's Iteration Notes.

Comments

Post a Comment

Popular posts from this blog

Gear Ratio Calculator: Multi-Stage Ratio, Output Speed, Torque and Direction

When you design a gear train, the questions are always the same: what's the overall ratio, how fast does the output turn, how much torque do you get, and which way does it spin? Enter the tooth counts for up to three stages, plus your motor's speed and torque. Stage 1 driver teeth Stage 1 driven teeth Stage 2 driver teeth (optional) Stage 2 driven teeth Stage 3 driver teeth (optional) Stage 3 driven teeth Input speed (rpm) Input torque (kgf·cm) Efficiency per stage (%) Calculate Enter values and press Calculate. The formulas Each stage's ratio is driven teeth ÷ driver teeth . In a compound train (two gears fixed on the same shaft), the overall ratio is the product of the stages: Ratio = (Z₂ ÷ Z₁) × (Z₄ ÷ Z₃) × … Output speed = input speed ÷ ratio Output torque = input torque × ratio × overall efficiency (overall efficiency = per-stage efficiency raised to the number of stages) With the default values, 10 teeth drive 40 (4 : 1), then a 12-tooth gear on ...
Read more

Mecanum-Wheel Pick-and-Place Robot: From Arduino UNO to Mega2560 + ESP32-CAM

🌏 繁體中文版：[DIY專案] 麥克納姆輪取物機器人：從 UNO 初版到 Mega2560＋ESP32-CAM This mechatronics course project is a mecanum-wheel car that can drive in any direction and pick things up with a small robotic arm. This post covers the mechanical and hardware design, and how the car evolved from the first Arduino UNO version to an upgraded Mega2560 + ESP32-CAM build. Upgraded version: mecanum-wheel chassis with a 4-axis robotic arm Mecanum wheels: how a car can slide sideways A mecanum wheel has a ring of small rollers around its rim, each mounted at 45°. When the wheel spins, it pushes diagonally rather than straight ahead. By combining the direction and speed of all four wheels, those diagonal forces either cancel or add up, so the chassis can drive forward and back, strafe left and right, move diagonally, or spin in place, all without turning first. Rollers come in left-handed and right-handed versions, and the four wheels must be installed in mirrored pairs. So in Inventor, both the rollers and the wh...
Read more

Voltage Divider Calculator: Output Voltage, or the Best E24 Resistor Pair for a Target Voltage

A voltage divider uses two resistors to scale a voltage down: reading a battery voltage with an ADC, dropping a 5 V signal to 3.3 V, or making a reference voltage. This calculator works both ways: known resistors → output voltage , or target voltage → the closest pairs of standard E24 resistors . Mode Known R1 and R2 → output voltage Target output voltage → pick resistors Input voltage Vin (V) R1 (top, kΩ) R2 (bottom, kΩ) Target output Vout (V) Calculate Enter values and press Calculate. The formula R1 sits between the input and the output, and R2 between the output and ground: Vout = Vin × R2 ÷ (R1 + R2) Example: Vin = 5 V, R1 = 10 kΩ, R2 = 20 kΩ gives Vout = 5 × 20 ÷ 30 ≈ 3.33 V, with about 0.17 mA flowing through the divider all the time. In "pick resistors" mode, the calculator tries every E24 value for R2, works out the R1 that would be needed, rounds it to the nearest E24 value, and lists the three pairs with the smallest output error. Pairs that give t...
Read more