If you've built anything with motors, you know the standard parts pile: a stepper or BLDC, a driver board, a controller to generate steps or commands, maybe an encoder if you care whether the motor actually went where you told it, and a loom of wires connecting all of it. An integrated servomotor collapses that pile into one part: motor + driver + motion controller + encoder in a single housing, speaking a single cable's worth of protocol to the outside world.
What's actually inside
- The motor: usually a stepper in the maker/light-industrial class (steppers give high torque at low speed without a gearbox).
- An encoder on the rotor, so the unit knows its true shaft position at all times.
- A driver: the power electronics that energize the windings.
- A motion controller: a microcontroller running a feedback loop between encoder and driver, accepting high-level commands ("go to 90° over 2 s") instead of step pulses.
The feedback loop is the point: this is what makes it a *servo*motor. An open-loop stepper trusts that every step happened; under a snag or a too-fast move it silently loses position. A closed-loop integrated unit measures and corrects, continuously.
What it replaces
| The classic stack | The integrated unit |
|---|---|
| Motor + driver + controller + encoder, 3 vendors | one part, one datasheet |
| STEP/DIR wiring per axis + encoder cabling | one bus cable, daisy-chained |
| Tuning current/microstepping by hand | tuned at the factory for its own motor |
| "Which combination of parts failed?" | one thing to swap |
The wiring difference compounds with axis count: a 6-axis machine on STEP/DIR is dozens of conductors; on a multi-drop bus (RS-485 in the M17's case) it's one twisted pair visiting each motor. Each unit gets an address; the controller talks to all of them on one port.
The honest trade-offs
- Frame-size torque ceiling. Integration doesn't create torque. A NEMA-17 integrated unit is still a NEMA-17 motor (~0.3–0.65 N·m holding). If the axis needs more, you gear it or go up a frame size; don't expect the electronics to save you.
- Heat shares a body. Driver and motor in one housing means one thermal budget (the M17 is 25–38 W by size, IP20, indoor use; we say so on the box).
- You're trusting the vendor's firmware. With a closed product, a controller quirk is a support ticket. This is the strongest argument for open integrated servos: if the firmware is on GitHub, the failure mode is "read the code," not "wait for the vendor."
- Unit price reads higher than a bare stepper, until you price the driver, encoder, controller board, wiring, and your integration hours that the bare motor still needs.
What to look for when buying one
- Loop rate (how fast it corrects; the M17 runs its PID at 32 kHz)
- Encoder type and resolution
- The bus: multi-drop (RS-485/CAN) beats point-to-point if you'll ever add axes
- Software: real libraries with units ("degrees", "seconds"), not register tables
- Openness: schematics + firmware + libraries published, or a black box?
- An AI/agent story, the newest differentiator: can an LLM drive it through a documented API, with the motor protecting itself in firmware? (No motor vendor we've found ships this first-party except us: the M17 comes with an MCP server, so Claude can run it in plain English.)
Where the M17 sits
The M17 is our take on what this category should be: NEMA-17 integrated closed-loop servo, RS-485 daisy-chain, open hardware/firmware/software, Python and Arduino libraries, and a first-party MCP server for plain-English AI control, from $20. Where it doesn't fit: axes needing more than ~0.65 N·m un-geared, wet/dusty environments (IP20), or more power than its 25–38 W (by size) rating.
See the M17 family · Watch Claude Code drive one
Written with the help of an AI and verified by a human. Hardware, firmware and software for the M17 are open source: github.com/tomrodinger/servomotor. The MCP server: github.com/Gearotons/servomotor-mcp.
