Point at a well.
A network moves the arm.
Choose destination wells on a 96-well plate. A small PyTorch network turns every point of the pipette's path into joint angles, and the arm runs the protocol in your browser. The planner is a single Python service that Chalk deploys and scales.
Run a protocol
Pick up to twelve wells, then press Plan and run. Drag the scene to orbit the arm. Turn off refinement to see how close the network gets on its own.
How it works
Forward kinematics is easy: given joint angles, where is the tip? Planning needs the inverse, for thousands of points at once. A network learns that inverse, and a few gradient steps through the easy direction polish its answers.
Plan the path
Each transfer picks a fresh tip, aspirates from the reservoir, dispenses into your well and ejects the tip. Every move is a straight line for the pipette tip, sampled every 5 mm.
Solve with a network
A 135k-parameter MLP maps every waypoint to four joint angles in one batched forward pass: about 1,200 waypoints in a few milliseconds, within about a millimetre.
Refine and run
Twenty-five gradient steps through the arm's forward kinematics pull the tip error to a fifth of a millimetre and keep the pipette within a tenth of a degree of vertical.
Train it, then deploy it
Clone the example, train the network, and run the deploy script. Chalk builds the image, ships the weights, and prints a URL that serves this exact demo.
The planner is one JSON endpoint, so the same deployment can drive a simulator, a real liquid handler, or an agent that writes its own protocols.
chalk-ai/learned-arm-plannergit clone https://github.com/chalk-ai/learned-arm-planner
cd learned-arm-planner
# Train the inverse-kinematics network (about 2.5 minutes on a large CPU box).
uv run --with torch --with numpy python train.py --out ik.pt
# Or export CHALK_CLIENT_ID and CHALK_CLIENT_SECRET.
chalk login
# Ships the weights, server and WebGL page, and prints your demo's URL.
./deploy.pyWhat Chalk handles
The model is the interesting part. Everything around it is the part Chalk does for you.
Learns from physics, not labels
Training scores the arm's actual tip position through differentiable forward kinematics, so the network needs only sampled targets, never a dataset of solved joint angles.
One batched call per plan
The whole protocol is solved at once, so a 12-well plan costs about the same as a single move. That is the shape of planning at scale: many candidate paths, scored together.
Scales with requests
The planner is a ScalingGroup with an HTTPS URL. Raise min_replicas or max_replicas for more capacity; the model is small enough to run on CPU.
Weights ride on a volume
Train anywhere PyTorch runs, then deploy.py ships ik.pt next to the server code. Retrain and redeploy without touching the image.
Runs in your cloud
The planner runs in your Chalk environment, next to your instruments and data. Protocols never pass through a third-party API.
Five files, open source
Kinematics, training, server, WebGL page and deploy script are Apache-2.0 on GitHub. Swap in your own arm's geometry and labware layout.
Serve models that move things
Planning, control, or perception for your lab and your robots. Talk to an engineer about running them in your cloud.