PYTHON · NUMPY

The loop you can hold

You snap together a sense, think, act graph and then write the think step in code. What is the relationship between the two?

Write a sense-think-act controller that drives an agent to a target, and see that the graph you snapped together is a program.

01Challenge

The Bench opens on a Cubelets-style loop written out in code: a SENSE block that reads the error to the target, an ACT block that moves, and a THINK block in between that returns zero -- so the agent sits still. Make think() steer toward the error and watch the loop close. This is the exact shape of every embodied agent, and of every block kit: sense, think, act.

Predict firstYou snap together a sense, think, act graph and then write the think step in code. What is the relationship between the two?

02Model

A Cubelet passes a value across its magnetic face; here the value is the error, and the blocks are functions. When you make think() return a velocity proportional to the error, you have written a proportional controller -- the simplest policy there is.

03Guided practice

Step A (worked): think(err) returns 0, so v is always 0 and x never leaves the origin -- run it and read the FAIL. Step B (the fix): return a velocity toward the target, e.g. return 0.5 * err; a positive error means the target is ahead, so drive forward. Step C (feel the gain): try 0.1 (crawls), 0.5 (smooth), 2.0 (overshoots) -- the gain is the whole personality of the block. Step D (independent): reach the target in under 40 steps.

04Feedback

PASS WHEN PASS when think() steers the agent to within 0.2 of the target.

If your run fails, check:

Read the bench’s printed result, it passes when think() steers the agent to within 0.2 of the target. Run the cells top to bottom; if one errors, the FAIL line names the step to fix.
think() still returns a velocity that does not close on the target.

05Retrieve & space

Name the three blocks of the loop and what each one does.
Why does a bigger gain reach faster but risk overshoot?
A Cubelet has no code -- where does its think() live instead?

06Mastery & project

Pass the lab: think() drives the agent to the target. You have written the smallest real policy -- a proportional controller -- and seen a block kit as a program.

Feeds the whole course: every later lab is this same loop, made more capable. The proportional rule you wrote here is the hand policy that learning will beat two labs from now.

GO FURTHER · THE LIVE PLAYGROUND

Feel it live: the sense-think-act interactive ↗ · the same loop as a block graph you can drag and watch.

← Connection Systems: From a Snap to a Policy What the wire carries →

PYTHON · NUMPY

The loop you can hold

Write a sense-think-act controller that drives an agent to a target, and see that the graph you snapped together is a program.

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you