diff --git a/cli/mock_resource_arm.txt b/cli/mock_resource_arm.txt
index 8ee58c65aec..de7b30599d1 100644
--- a/cli/mock_resource_arm.txt
+++ b/cli/mock_resource_arm.txt
@@ -57,7 +57,7 @@ func Named(name string) resource.Name {
 //
 // EndPosition example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //	// Get the end position of the arm as a Pose.
 //	pos, err := myArm.EndPosition(context.Background(), nil)
 //
@@ -65,7 +65,7 @@ func Named(name string) resource.Name {
 //
 // MoveToPosition example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //	// Create a Pose for the arm.
 //	examplePose := spatialmath.NewPose(
 //	        r3.Vector{X: 5, Y: 5, Z: 5},
@@ -79,7 +79,7 @@ func Named(name string) resource.Name {
 //
 // MoveToJointPositions example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	// Declare an array of values with your desired rotational value (in radians) for each joint on the arm.
 //	inputs := referenceframe.FloatsToInputs([]float64{0, math.Pi/2, math.Pi})
@@ -91,7 +91,7 @@ func Named(name string) resource.Name {
 //
 // MoveThroughJointPositions example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	// Declare a 2D array of values with your desired rotational value (in radians) for each joint on the arm.
 //	inputs := [][]referenceframe.Input{
@@ -106,7 +106,7 @@ func Named(name string) resource.Name {
 //
 // JointPositions example:
 //
-//	myArm , err := arm.FromRobot(machine, "my_arm")
+//	myArm , err := arm.FromProvider(machine, "my_arm")
 //
 //	// Get the current position of each joint on the arm as JointPositions.
 //	pos, err := myArm.JointPositions(context.Background(), nil)
@@ -144,15 +144,11 @@ type Arm interface {
 	JointPositions(ctx context.Context, extra map[string]interface{}) ([]referenceframe.Input, error)
 }
 
-// FromDependencies is a helper for getting the named arm from a collection of
-// dependencies.
-func FromDependencies(deps resource.Dependencies, name string) (Arm, error) {
-	return resource.FromDependencies[Arm](deps, Named(name))
-}
-
-// FromRobot is a helper for getting the named Arm from the given Robot.
-func FromRobot(r robot.Robot, name string) (Arm, error) {
-	return robot.ResourceFromRobot[Arm](r, Named(name))
+// FromProvider is a helper for getting the named Arm from either a collection of dependencies
+// or the given robot.
+// FromProvider is a helper for getting the named arm from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Arm, error) {
+	return resource.FromProvider[Arm](provider, Named(name))
 }
 
 // NamesFromRobot is a helper for getting all arm names from the given Robot.
diff --git a/cli/motion.go b/cli/motion.go
index c28e77af461..731d61e7e45 100644
--- a/cli/motion.go
+++ b/cli/motion.go
@@ -94,7 +94,7 @@ func motionPrintStatusAction(c *cli.Context, args motionPrintArgs) error {
 		return err
 	}
 
-	myMotion, err := motion.FromRobot(robotClient, "builtin")
+	myMotion, err := motion.FromProvider(robotClient, "builtin")
 	if err != nil || myMotion == nil {
 		return fmt.Errorf("no motion: %w", err)
 	}
@@ -148,7 +148,7 @@ func motionGetPoseAction(c *cli.Context, args motionGetPoseArgs) error {
 		utils.UncheckedError(robotClient.Close(ctx))
 	}()
 
-	myMotion, err := motion.FromRobot(robotClient, "builtin")
+	myMotion, err := motion.FromProvider(robotClient, "builtin")
 	if err != nil || myMotion == nil {
 		return fmt.Errorf("no motion: %w", err)
 	}
@@ -200,7 +200,7 @@ func motionSetPoseAction(c *cli.Context, args motionSetPoseArgs) error {
 		utils.UncheckedError(robotClient.Close(ctx))
 	}()
 
-	myMotion, err := motion.FromRobot(robotClient, "builtin")
+	myMotion, err := motion.FromProvider(robotClient, "builtin")
 	if err != nil || myMotion == nil {
 		return fmt.Errorf("no motion: %w", err)
 	}
diff --git a/components/arm/arm.go b/components/arm/arm.go
index 8ee58c65aec..3db8de8f348 100644
--- a/components/arm/arm.go
+++ b/components/arm/arm.go
@@ -57,7 +57,7 @@ func Named(name string) resource.Name {
 //
 // EndPosition example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //	// Get the end position of the arm as a Pose.
 //	pos, err := myArm.EndPosition(context.Background(), nil)
 //
@@ -65,7 +65,7 @@ func Named(name string) resource.Name {
 //
 // MoveToPosition example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //	// Create a Pose for the arm.
 //	examplePose := spatialmath.NewPose(
 //	        r3.Vector{X: 5, Y: 5, Z: 5},
@@ -79,7 +79,7 @@ func Named(name string) resource.Name {
 //
 // MoveToJointPositions example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	// Declare an array of values with your desired rotational value (in radians) for each joint on the arm.
 //	inputs := referenceframe.FloatsToInputs([]float64{0, math.Pi/2, math.Pi})
@@ -91,7 +91,7 @@ func Named(name string) resource.Name {
 //
 // MoveThroughJointPositions example:
 //
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	// Declare a 2D array of values with your desired rotational value (in radians) for each joint on the arm.
 //	inputs := [][]referenceframe.Input{
@@ -106,7 +106,7 @@ func Named(name string) resource.Name {
 //
 // JointPositions example:
 //
-//	myArm , err := arm.FromRobot(machine, "my_arm")
+//	myArm , err := arm.FromProvider(machine, "my_arm")
 //
 //	// Get the current position of each joint on the arm as JointPositions.
 //	pos, err := myArm.JointPositions(context.Background(), nil)
@@ -144,17 +144,27 @@ type Arm interface {
 	JointPositions(ctx context.Context, extra map[string]interface{}) ([]referenceframe.Input, error)
 }
 
-// FromDependencies is a helper for getting the named arm from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named arm from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Arm, error) {
 	return resource.FromDependencies[Arm](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named Arm from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Arm from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Arm, error) {
 	return robot.ResourceFromRobot[Arm](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named arm from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Arm, error) {
+	return resource.FromProvider[Arm](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all arm names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/arm/wrapper/wrapper.go b/components/arm/wrapper/wrapper.go
index 738c4fdddd4..a501414b0a7 100644
--- a/components/arm/wrapper/wrapper.go
+++ b/components/arm/wrapper/wrapper.go
@@ -79,7 +79,7 @@ func (wrapper *Arm) Reconfigure(ctx context.Context, deps resource.Dependencies,
 		return err
 	}
 
-	newArm, err := arm.FromDependencies(deps, newConf.ArmName)
+	newArm, err := arm.FromProvider(deps, newConf.ArmName)
 	if err != nil {
 		return err
 	}
diff --git a/components/audioinput/audio_input.go b/components/audioinput/audio_input.go
index 5ae8efe1b5e..03075b5112d 100644
--- a/components/audioinput/audio_input.go
+++ b/components/audioinput/audio_input.go
@@ -61,17 +61,27 @@ type LivenessMonitor interface {
 	Monitor(notifyReset func())
 }
 
-// FromDependencies is a helper for getting the named audio input from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named audio input from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (AudioInput, error) {
 	return resource.FromDependencies[AudioInput](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named audio input from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named audio input from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (AudioInput, error) {
 	return robot.ResourceFromRobot[AudioInput](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named AudioInput from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (AudioInput, error) {
+	return resource.FromProvider[AudioInput](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all audio input names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/base/base.go b/components/base/base.go
index 7f8993f482f..d89aedf4720 100644
--- a/components/base/base.go
+++ b/components/base/base.go
@@ -44,7 +44,7 @@ func Named(name string) resource.Name {
 //
 // MoveStraight example:
 //
-//	myBase, err := base.FromRobot(machine, "my_base")
+//	myBase, err := base.FromProvider(machine, "my_base")
 //	// Move the base forward 40 mm at a velocity of 90 mm/s.
 //	myBase.MoveStraight(context.Background(), 40, 90, nil)
 //
@@ -55,7 +55,7 @@ func Named(name string) resource.Name {
 //
 // Spin example:
 //
-//	myBase, err := base.FromRobot(machine, "my_base")
+//	myBase, err := base.FromProvider(machine, "my_base")
 //
 //	// Spin the base 10 degrees at an angular velocity of 15 deg/sec.
 //	myBase.Spin(context.Background(), 10, 15, nil)
@@ -64,7 +64,7 @@ func Named(name string) resource.Name {
 //
 // SetPower example:
 //
-//	myBase, err := base.FromRobot(machine, "my_base")
+//	myBase, err := base.FromProvider(machine, "my_base")
 //
 //	// Make your wheeled base move forward. Set linear power to 75%.
 //	logger.Info("move forward")
@@ -86,7 +86,7 @@ func Named(name string) resource.Name {
 //
 // SetVelocity example:
 //
-//	myBase, err := base.FromRobot(machine, "my_base")
+//	myBase, err := base.FromProvider(machine, "my_base")
 //
 //	// Set the linear velocity to 50 mm/sec and the angular velocity to 15 deg/sec.
 //	myBase.SetVelocity(context.Background(), r3.Vector{Y: 50}, r3.Vector{Z: 15}, nil)
@@ -95,7 +95,7 @@ func Named(name string) resource.Name {
 //
 // Properties example:
 //
-//	myBase, err := base.FromRobot(machine, "my_base")
+//	myBase, err := base.FromProvider(machine, "my_base")
 //
 //	// Get the width and turning radius of the base
 //	properties, err := myBase.Properties(context.Background(), nil)
@@ -147,17 +147,27 @@ type Base interface {
 	Properties(ctx context.Context, extra map[string]interface{}) (Properties, error)
 }
 
-// FromDependencies is a helper for getting the named base from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named base from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Base, error) {
 	return resource.FromDependencies[Base](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named base from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named base from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Base, error) {
 	return robot.ResourceFromRobot[Base](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Base from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Base, error) {
+	return resource.FromProvider[Base](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all base names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/base/base_test.go b/components/base/base_test.go
index b5c4b6e1923..16518157e48 100644
--- a/components/base/base_test.go
+++ b/components/base/base_test.go
@@ -29,15 +29,15 @@ func TestFromRobot(t *testing.T) {
 	expected := []string{"base1", "base2"}
 	testutils.VerifySameElements(t, base.NamesFromRobot(r), expected)
 
-	_, err := base.FromRobot(r, "base1")
+	_, err := base.FromProvider(r, "base1")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = base.FromRobot(r, "base2")
+	_, err = base.FromProvider(r, "base2")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = base.FromRobot(r, "base0")
+	_, err = base.FromProvider(r, "base0")
 	test.That(t, err, test.ShouldNotBeNil)
 
-	_, err = base.FromRobot(r, "g")
+	_, err = base.FromProvider(r, "g")
 	test.That(t, err, test.ShouldNotBeNil)
 }
diff --git a/components/base/sensorcontrolled/sensorcontrolled.go b/components/base/sensorcontrolled/sensorcontrolled.go
index 2aa828aeb4a..c637258ca82 100644
--- a/components/base/sensorcontrolled/sensorcontrolled.go
+++ b/components/base/sensorcontrolled/sensorcontrolled.go
@@ -149,7 +149,7 @@ func (sb *sensorBase) Reconfigure(ctx context.Context, deps resource.Dependencie
 	sb.controlledBase = nil
 
 	for _, name := range newConf.MovementSensor {
-		ms, err := movementsensor.FromDependencies(deps, name)
+		ms, err := movementsensor.FromProvider(deps, name)
 		if err != nil {
 			return errors.Wrapf(err, "no movement sensor named (%s)", name)
 		}
@@ -201,7 +201,7 @@ func (sb *sensorBase) Reconfigure(ctx context.Context, deps resource.Dependencie
 		return errNoGoodSensor
 	}
 
-	sb.controlledBase, err = base.FromDependencies(deps, newConf.Base)
+	sb.controlledBase, err = base.FromProvider(deps, newConf.Base)
 	if err != nil {
 		return errors.Wrapf(err, "no base named (%s)", newConf.Base)
 	}
diff --git a/components/base/wheeled/wheeled_base.go b/components/base/wheeled/wheeled_base.go
index 9cf78d8b376..a903a1b5dde 100644
--- a/components/base/wheeled/wheeled_base.go
+++ b/components/base/wheeled/wheeled_base.go
@@ -151,7 +151,7 @@ func (wb *wheeledBase) Reconfigure(ctx context.Context, deps resource.Dependenci
 					return newMotors, rdkutils.NewBuildTimeoutError(wb.Name().String(), wb.logger)
 				default:
 				}
-				m, err := motor.FromDependencies(deps, name)
+				m, err := motor.FromProvider(deps, name)
 				if err != nil {
 					return newMotors, errors.Wrapf(err, "no %s motor named (%s)", whichMotor, name)
 				}
@@ -167,7 +167,7 @@ func (wb *wheeledBase) Reconfigure(ctx context.Context, deps resource.Dependenci
 				}
 				if (curr)[i].Name().String() != (fromConfig)[i] {
 					for _, name := range fromConfig {
-						m, err := motor.FromDependencies(deps, name)
+						m, err := motor.FromProvider(deps, name)
 						if err != nil {
 							return newMotors, errors.Wrapf(err, "no %s motor named (%s)", whichMotor, name)
 						}
diff --git a/components/board/board.go b/components/board/board.go
index 0c5bd185641..8874aa2cea8 100644
--- a/components/board/board.go
+++ b/components/board/board.go
@@ -56,7 +56,7 @@ func Named(name string) resource.Name {
 //
 // AnalogByName example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the Analog pin "my_example_analog".
 //	analog, err := myBoard.AnalogByName("my_example_analog")
@@ -65,7 +65,7 @@ func Named(name string) resource.Name {
 //
 // DigitalInterruptByName example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the DigitalInterrupt "my_example_digital_interrupt".
 //	interrupt, err := myBoard.DigitalInterruptByName("my_example_digital_interrupt")
@@ -74,7 +74,7 @@ func Named(name string) resource.Name {
 //
 // GPIOPinByName example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
@@ -83,7 +83,7 @@ func Named(name string) resource.Name {
 //
 // SetPowerMode example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	Set the power mode of the board to OFFLINE_DEEP.
 //	myBoard.SetPowerMode(context.Background(), boardpb.PowerMode_POWER_MODE_OFFLINE_DEEP, nil)
@@ -92,7 +92,7 @@ func Named(name string) resource.Name {
 //
 // StreamTicks example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Make a channel to stream ticks
 //	ticksChan := make(chan board.Tick)
@@ -143,7 +143,7 @@ type Board interface {
 //
 // Read example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the analog pin "my_example_analog".
 //	analog, err := myBoard.AnalogByName("my_example_analog")
@@ -157,7 +157,7 @@ type Board interface {
 //
 // Write example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the Analog pin "my_example_analog".
 //	analog, err := myBoard.AnalogByName("my_example_analog")
@@ -188,17 +188,26 @@ type AnalogValue struct {
 	StepSize float32
 }
 
-// FromDependencies is a helper for getting the named board from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named board from a collection of
+// dependencies. Use FromProvider instead.
+// //nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Board, error) {
 	return resource.FromDependencies[Board](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named board from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named board from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Board, error) {
 	return robot.ResourceFromRobot[Board](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Board from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Board, error) {
+	return resource.FromProvider[Board](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all board names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/board/board_test.go b/components/board/board_test.go
index 73d8b36da11..4780bdd6198 100644
--- a/components/board/board_test.go
+++ b/components/board/board_test.go
@@ -23,12 +23,12 @@ func TestFromRobot(t *testing.T) {
 	expected := []string{"board1"}
 	testutils.VerifySameElements(t, board.NamesFromRobot(r), expected)
 
-	_, err := board.FromRobot(r, "board1")
+	_, err := board.FromProvider(r, "board1")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = board.FromRobot(r, "board0")
+	_, err = board.FromProvider(r, "board0")
 	test.That(t, err, test.ShouldNotBeNil)
 
-	_, err = board.FromRobot(r, "g")
+	_, err = board.FromProvider(r, "g")
 	test.That(t, err, test.ShouldNotBeNil)
 }
diff --git a/components/board/digital_interrupts.go b/components/board/digital_interrupts.go
index 654adb23340..5ecf1661c24 100644
--- a/components/board/digital_interrupts.go
+++ b/components/board/digital_interrupts.go
@@ -21,7 +21,7 @@ type Tick struct {
 //
 // Value example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the DigitalInterrupt "my_example_digital_interrupt".
 //	interrupt, err := myBoard.DigitalInterruptByName("my_example_digital_interrupt")
diff --git a/components/board/gpio_pin.go b/components/board/gpio_pin.go
index 0aac4fe667f..8cc5fb55852 100644
--- a/components/board/gpio_pin.go
+++ b/components/board/gpio_pin.go
@@ -11,7 +11,7 @@ import (
 //
 // Set example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
@@ -23,7 +23,7 @@ import (
 //
 // Get example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
@@ -35,7 +35,7 @@ import (
 //
 // PWM example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
@@ -47,7 +47,7 @@ import (
 //
 // SetPWM example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
@@ -59,7 +59,7 @@ import (
 //
 // PWMFreq example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
@@ -71,7 +71,7 @@ import (
 //
 // SetPWMFreq example:
 //
-//	myBoard, err := board.FromRobot(robot, "my_board")
+//	myBoard, err := board.FromProvider(robot, "my_board")
 //
 //	// Get the GPIOPin with pin number 15.
 //	pin, err := myBoard.GPIOPinByName("15")
diff --git a/components/button/button.go b/components/button/button.go
index 7ad94c78820..d3c2540b69e 100644
--- a/components/button/button.go
+++ b/components/button/button.go
@@ -43,16 +43,27 @@ type Button interface {
 	Push(ctx context.Context, extra map[string]interface{}) error
 }
 
-// FromRobot is a helper for getting the named Button from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Button from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Button, error) {
 	return robot.ResourceFromRobot[Button](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named button component from a collection of dependencies.
+// Deprecated: FromDependencies is a helper for getting the named button component from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Button, error) {
 	return resource.FromDependencies[Button](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named Button from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Button, error) {
+	return resource.FromProvider[Button](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all gripper names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/camera/camera.go b/components/camera/camera.go
index 482fdd578f3..ba7f2c8c015 100644
--- a/components/camera/camera.go
+++ b/components/camera/camera.go
@@ -174,19 +174,19 @@ type ImageMetadata struct {
 //
 // Image example:
 //
-//	myCamera, err := camera.FromRobot(machine, "my_camera")
+//	myCamera, err := camera.FromProvider(machine, "my_camera")
 //	imageBytes, mimeType, err := myCamera.Image(context.Background(), utils.MimeTypeJPEG, nil)
 //
 // Or try to directly decode as an image.Image:
 //
-//	myCamera, err := camera.FromRobot(machine, "my_camera")
+//	myCamera, err := camera.FromProvider(machine, "my_camera")
 //	img, err = camera.DecodeImageFromCamera(context.Background(), utils.MimeTypeJPEG, nil, myCamera)
 //
 // For more information, see the [Image method docs].
 //
 // Images example:
 //
-//	myCamera, err := camera.FromRobot(machine, "my_camera")
+//	myCamera, err := camera.FromProvider(machine, "my_camera")
 //
 //	images, metadata, err := myCamera.Images(context.Background(), nil)
 //
@@ -194,7 +194,7 @@ type ImageMetadata struct {
 //
 // NextPointCloud example:
 //
-//	myCamera, err := camera.FromRobot(machine, "my_camera")
+//	myCamera, err := camera.FromProvider(machine, "my_camera")
 //
 //	// gets the next point cloud from a camera
 //	pointCloud, err := myCamera.NextPointCloud(context.Background())
@@ -203,7 +203,7 @@ type ImageMetadata struct {
 //
 // Close example:
 //
-//	myCamera, err := camera.FromRobot(machine, "my_camera")
+//	myCamera, err := camera.FromProvider(machine, "my_camera")
 //
 //	err = myCamera.Close(context.Background())
 //
@@ -380,17 +380,27 @@ func NewPropertiesError(cameraIdentifier string) error {
 	return errors.Errorf("failed to get properties from %s", cameraIdentifier)
 }
 
-// FromDependencies is a helper for getting the named camera from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named camera from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Camera, error) {
 	return resource.FromDependencies[Camera](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named Camera from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Camera from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Camera, error) {
 	return robot.ResourceFromRobot[Camera](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Camera from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Camera, error) {
+	return resource.FromProvider[Camera](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all camera names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/camera/client_test.go b/components/camera/client_test.go
index 00d3818b560..fd8ea0834b2 100644
--- a/components/camera/client_test.go
+++ b/components/camera/client_test.go
@@ -924,7 +924,7 @@ func TestMultiplexOverRemoteConnection(t *testing.T) {
 	defer mainRobot.Close(mainCtx)
 	defer mainWebSvc.Close(mainCtx)
 
-	cameraClient, err := camera.FromRobot(mainRobot, "remote:rtpPassthroughCamera")
+	cameraClient, err := camera.FromProvider(mainRobot, "remote:rtpPassthroughCamera")
 	test.That(t, err, test.ShouldBeNil)
 
 	image, _, err := cameraClient.Images(mainCtx, nil, nil)
@@ -997,7 +997,7 @@ func TestMultiplexOverMultiHopRemoteConnection(t *testing.T) {
 	defer mainRobot.Close(mainCtx)
 	defer mainWebSvc.Close(mainCtx)
 
-	cameraClient, err := camera.FromRobot(mainRobot, "rtpPassthroughCamera")
+	cameraClient, err := camera.FromProvider(mainRobot, "rtpPassthroughCamera")
 	test.That(t, err, test.ShouldBeNil)
 
 	image, _, err := cameraClient.Images(mainCtx, nil, nil)
@@ -1081,7 +1081,7 @@ func TestWhyMustTimeoutOnReadRTP(t *testing.T) {
 	defer mainRobot.Close(mainCtx)
 	defer mainWebSvc.Close(mainCtx)
 
-	cameraClient, err := camera.FromRobot(mainRobot, "rtpPassthroughCamera")
+	cameraClient, err := camera.FromProvider(mainRobot, "rtpPassthroughCamera")
 	test.That(t, err, test.ShouldBeNil)
 
 	image, _, err := cameraClient.Images(mainCtx, nil, nil)
@@ -1217,7 +1217,7 @@ func TestGrandRemoteRebooting(t *testing.T) {
 	defer mainRobot.Close(mainCtx)
 	defer mainWebSvc.Close(mainCtx)
 
-	mainCameraClient, err := camera.FromRobot(mainRobot, "rtpPassthroughCamera")
+	mainCameraClient, err := camera.FromProvider(mainRobot, "rtpPassthroughCamera")
 	test.That(t, err, test.ShouldBeNil)
 
 	image, _, err := mainCameraClient.Images(mainCtx, nil, nil)
diff --git a/components/camera/replaypcd/replaypcd.go b/components/camera/replaypcd/replaypcd.go
index 995cdbbfa4b..ec8336407d1 100644
--- a/components/camera/replaypcd/replaypcd.go
+++ b/components/camera/replaypcd/replaypcd.go
@@ -386,7 +386,7 @@ func (replay *pcdCamera) Reconfigure(ctx context.Context, deps resource.Dependen
 	replay.APIKey = replayCamConfig.APIKey
 	replay.APIKeyID = replayCamConfig.APIKeyID
 
-	cloudConnSvc, err := resource.FromDependencies[cloud.ConnectionService](deps, cloud.InternalServiceName)
+	cloudConnSvc, err := resource.FromProvider[cloud.ConnectionService](deps, cloud.InternalServiceName)
 	if err != nil {
 		return err
 	}
diff --git a/components/camera/transformpipeline/classifier.go b/components/camera/transformpipeline/classifier.go
index 807c42b360d..bad81e28ee2 100644
--- a/components/camera/transformpipeline/classifier.go
+++ b/components/camera/transformpipeline/classifier.go
@@ -86,7 +86,7 @@ func (cs *classifierSource) Read(ctx context.Context) (image.Image, func(), erro
 	ctx, span := trace.StartSpan(ctx, "camera::transformpipeline::classifier::Read")
 	defer span.End()
 
-	srv, err := vision.FromRobot(cs.r, cs.classifierName)
+	srv, err := vision.FromProvider(cs.r, cs.classifierName)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "source_classifier can't find vision service")
 	}
diff --git a/components/camera/transformpipeline/classifier_test.go b/components/camera/transformpipeline/classifier_test.go
index 01efc08c718..52a2c35aaf2 100644
--- a/components/camera/transformpipeline/classifier_test.go
+++ b/components/camera/transformpipeline/classifier_test.go
@@ -94,7 +94,7 @@ func TestClassifierSource(t *testing.T) {
 		test.That(t, r.Close(context.Background()), test.ShouldBeNil)
 	}()
 
-	classifier, err := camera.FromRobot(r, "classification_transform_camera")
+	classifier, err := camera.FromProvider(r, "classification_transform_camera")
 	test.That(t, err, test.ShouldBeNil)
 	defer classifier.Close(ctx)
 
diff --git a/components/camera/transformpipeline/detector.go b/components/camera/transformpipeline/detector.go
index b83851307bb..fad3b3485ce 100644
--- a/components/camera/transformpipeline/detector.go
+++ b/components/camera/transformpipeline/detector.go
@@ -79,7 +79,7 @@ func (ds *detectorSource) Read(ctx context.Context) (image.Image, func(), error)
 	ctx, span := trace.StartSpan(ctx, "camera::transformpipeline::detector::Read")
 	defer span.End()
 	// get the bounding boxes from the service
-	srv, err := vision.FromRobot(ds.r, ds.detectorName)
+	srv, err := vision.FromProvider(ds.r, ds.detectorName)
 	if err != nil {
 		return nil, nil, fmt.Errorf("source_detector cant find vision service: %w", err)
 	}
diff --git a/components/camera/transformpipeline/detector_test.go b/components/camera/transformpipeline/detector_test.go
index d4b9203bd78..65d6c6f6a80 100644
--- a/components/camera/transformpipeline/detector_test.go
+++ b/components/camera/transformpipeline/detector_test.go
@@ -116,7 +116,7 @@ func TestColorDetectionSource(t *testing.T) {
 		test.That(t, r.Close(context.Background()), test.ShouldBeNil)
 	}()
 
-	detector, err := camera.FromRobot(r, "color_detect")
+	detector, err := camera.FromProvider(r, "color_detect")
 	test.That(t, err, test.ShouldBeNil)
 	defer detector.Close(ctx)
 
@@ -138,7 +138,7 @@ func BenchmarkColorDetectionSource(b *testing.B) {
 		test.That(b, r.Close(context.Background()), test.ShouldBeNil)
 	}()
 	test.That(b, err, test.ShouldBeNil)
-	detector, err := camera.FromRobot(r, "color_detect")
+	detector, err := camera.FromProvider(r, "color_detect")
 	test.That(b, err, test.ShouldBeNil)
 	defer detector.Close(ctx)
 
diff --git a/components/camera/transformpipeline/pipeline.go b/components/camera/transformpipeline/pipeline.go
index c0fb0729ee7..c9f4a100e3f 100644
--- a/components/camera/transformpipeline/pipeline.go
+++ b/components/camera/transformpipeline/pipeline.go
@@ -48,7 +48,7 @@ func init() {
 					return nil, err
 				}
 				sourceName := newConf.Source
-				source, err := camera.FromRobot(actualR, sourceName)
+				source, err := camera.FromProvider(actualR, sourceName)
 				if err != nil {
 					return nil, fmt.Errorf("no source camera for transform pipeline (%s): %w", sourceName, err)
 				}
diff --git a/components/encoder/encoder.go b/components/encoder/encoder.go
index 079d335c9c5..2c228af577e 100644
--- a/components/encoder/encoder.go
+++ b/components/encoder/encoder.go
@@ -69,7 +69,7 @@ func (t PositionType) String() string {
 //
 // Position example:
 //
-//	myEncoder, err := encoder.FromRobot(machine, "my_encoder")
+//	myEncoder, err := encoder.FromProvider(machine, "my_encoder")
 //	if err != nil {
 //	  logger.Fatalf("cannot get encoder: %v", err)
 //	}
@@ -81,7 +81,7 @@ func (t PositionType) String() string {
 //
 // ResetPosition example:
 //
-//	myEncoder, err := encoder.FromRobot(machine, "my_encoder")
+//	myEncoder, err := encoder.FromProvider(machine, "my_encoder")
 //	if err != nil {
 //	  logger.Fatalf("cannot get encoder: %v", err)
 //	}
@@ -92,7 +92,7 @@ func (t PositionType) String() string {
 //
 // Properties example:
 //
-//	myEncoder, err := encoder.FromRobot(machine, "my_encoder")
+//	myEncoder, err := encoder.FromProvider(machine, "my_encoder")
 //
 //	// Get whether the encoder returns position in ticks or degrees.
 //	properties, err := myEncoder.Properties(context.Background(), nil)
@@ -121,17 +121,27 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromDependencies is a helper for getting the named encoder from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named encoder from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Encoder, error) {
 	return resource.FromDependencies[Encoder](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named encoder from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named encoder from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Encoder, error) {
 	return robot.ResourceFromRobot[Encoder](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Encoder from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Encoder, error) {
+	return resource.FromProvider[Encoder](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all encoder names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/encoder/encoder_test.go b/components/encoder/encoder_test.go
index e1eff8d9699..10edca40908 100644
--- a/components/encoder/encoder_test.go
+++ b/components/encoder/encoder_test.go
@@ -23,12 +23,12 @@ func TestFromRobot(t *testing.T) {
 	expected := []string{"e1"}
 	testutils.VerifySameElements(t, encoder.NamesFromRobot(r), expected)
 
-	_, err := encoder.FromRobot(r, "e1")
+	_, err := encoder.FromProvider(r, "e1")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = encoder.FromRobot(r, "e0")
+	_, err = encoder.FromProvider(r, "e0")
 	test.That(t, err, test.ShouldNotBeNil)
 
-	_, err = encoder.FromRobot(r, "g")
+	_, err = encoder.FromProvider(r, "g")
 	test.That(t, err, test.ShouldNotBeNil)
 }
diff --git a/components/encoder/incremental/incremental_encoder.go b/components/encoder/incremental/incremental_encoder.go
index 860e7f84d45..718cc801192 100644
--- a/components/encoder/incremental/incremental_encoder.go
+++ b/components/encoder/incremental/incremental_encoder.go
@@ -130,7 +130,7 @@ func (e *Encoder) Reconfigure(
 		existingEncAName != newConf.Pins.A ||
 		existingEncBName != newConf.Pins.B
 
-	board, err := board.FromDependencies(deps, newConf.BoardName)
+	board, err := board.FromProvider(deps, newConf.BoardName)
 	if err != nil {
 		return err
 	}
diff --git a/components/encoder/single/single_encoder.go b/components/encoder/single/single_encoder.go
index 999e7ae132d..4c4186862ef 100644
--- a/components/encoder/single/single_encoder.go
+++ b/components/encoder/single/single_encoder.go
@@ -151,7 +151,7 @@ func (e *Encoder) Reconfigure(
 	needRestart := existingBoardName != newConf.BoardName ||
 		existingDIPinName != newConf.Pins.I
 
-	board, err := board.FromDependencies(deps, newConf.BoardName)
+	board, err := board.FromProvider(deps, newConf.BoardName)
 	if err != nil {
 		return err
 	}
diff --git a/components/gantry/gantry.go b/components/gantry/gantry.go
index 0ebd7729362..ade68f024c5 100644
--- a/components/gantry/gantry.go
+++ b/components/gantry/gantry.go
@@ -52,7 +52,7 @@ func Named(name string) resource.Name {
 //
 // Position example:
 //
-//	myGantry, err := gantry.FromRobot(machine, "my_gantry")
+//	myGantry, err := gantry.FromProvider(machine, "my_gantry")
 //
 //	// Get the current positions of the axes of the gantry in millimeters.
 //	position, err := myGantry.Position(context.Background(), nil)
@@ -61,7 +61,7 @@ func Named(name string) resource.Name {
 //
 // MoveToPosition example:
 //
-//	myGantry, err := gantry.FromRobot(machine, "my_gantry")
+//	myGantry, err := gantry.FromProvider(machine, "my_gantry")
 //
 //	// Create a list of positions for the axes of the gantry to move to.
 //	// Assume in this example that the gantry is multi-axis, with 3 axes.
@@ -76,7 +76,7 @@ func Named(name string) resource.Name {
 //
 // Lengths example:
 //
-//	myGantry, err := gantry.FromRobot(machine, "my_gantry")
+//	myGantry, err := gantry.FromProvider(machine, "my_gantry")
 //
 //	// Get the lengths of the axes of the gantry in millimeters.
 //	lengths_mm, err := myGantry.Lengths(context.Background(), nil)
@@ -85,7 +85,7 @@ func Named(name string) resource.Name {
 //
 // Home example:
 //
-//	myGantry, err := gantry.FromRobot(machine, "my_gantry")
+//	myGantry, err := gantry.FromProvider(machine, "my_gantry")
 //
 //	myGantry.Home(context.Background(), nil)
 //
@@ -115,17 +115,27 @@ type Gantry interface {
 	Home(ctx context.Context, extra map[string]interface{}) (bool, error)
 }
 
-// FromDependencies is a helper for getting the named gantry from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named gantry from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Gantry, error) {
 	return resource.FromDependencies[Gantry](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named gantry from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named gantry from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Gantry, error) {
 	return robot.ResourceFromRobot[Gantry](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Gantry from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Gantry, error) {
+	return resource.FromProvider[Gantry](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all gantry names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/gantry/multiaxis/multiaxis.go b/components/gantry/multiaxis/multiaxis.go
index b104a06285a..1acc2ee547e 100644
--- a/components/gantry/multiaxis/multiaxis.go
+++ b/components/gantry/multiaxis/multiaxis.go
@@ -74,7 +74,7 @@ func newMultiAxis(
 	}
 
 	for _, s := range newConf.SubAxes {
-		subAx, err := gantry.FromDependencies(deps, s)
+		subAx, err := gantry.FromProvider(deps, s)
 		if err != nil {
 			return nil, errors.Wrapf(err, "no axes named [%s]", s)
 		}
diff --git a/components/gantry/singleaxis/singleaxis.go b/components/gantry/singleaxis/singleaxis.go
index d7a6db67428..5a40a0f9473 100644
--- a/components/gantry/singleaxis/singleaxis.go
+++ b/components/gantry/singleaxis/singleaxis.go
@@ -169,7 +169,7 @@ func (g *singleAxis) Reconfigure(ctx context.Context, deps resource.Dependencies
 	// Rerun homing if the board has changed
 	if newConf.Board != "" {
 		if g.board == nil || g.board.Name().ShortName() != newConf.Board {
-			board, err := board.FromDependencies(deps, newConf.Board)
+			board, err := board.FromProvider(deps, newConf.Board)
 			if err != nil {
 				return err
 			}
@@ -181,7 +181,7 @@ func (g *singleAxis) Reconfigure(ctx context.Context, deps resource.Dependencies
 	// Rerun homing if the motor changes
 	if g.motor == nil || g.motor.Name().ShortName() != newConf.Motor {
 		needsToReHome = true
-		motorDep, err := motor.FromDependencies(deps, newConf.Motor)
+		motorDep, err := motor.FromProvider(deps, newConf.Motor)
 		if err != nil {
 			return err
 		}
diff --git a/components/generic/generic.go b/components/generic/generic.go
index eee8d6d7b86..648cadc0a8d 100644
--- a/components/generic/generic.go
+++ b/components/generic/generic.go
@@ -36,17 +36,27 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromDependencies is a helper for getting the named generic from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named generic from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (resource.Resource, error) {
 	return resource.FromDependencies[resource.Resource](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named Generic from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Generic from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (resource.Resource, error) {
 	return robot.ResourceFromRobot[resource.Resource](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Generic from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (resource.Resource, error) {
+	return resource.FromProvider[resource.Resource](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all generic names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/gripper/gripper.go b/components/gripper/gripper.go
index ba76513fa20..863ab59f490 100644
--- a/components/gripper/gripper.go
+++ b/components/gripper/gripper.go
@@ -53,7 +53,7 @@ type HoldingStatus struct {
 //
 // Open example:
 //
-//	myGripper, err := gripper.FromRobot(machine, "my_gripper")
+//	myGripper, err := gripper.FromProvider(machine, "my_gripper")
 //
 //	// Open the gripper.
 //	err := myGripper.Open(context.Background(), nil)
@@ -62,7 +62,7 @@ type HoldingStatus struct {
 //
 // Grab example:
 //
-//	myGripper, err := gripper.FromRobot(machine, "my_gripper")
+//	myGripper, err := gripper.FromProvider(machine, "my_gripper")
 //
 //	// Grab with the gripper.
 //	grabbed, err := myGripper.Grab(context.Background(), nil)
@@ -91,17 +91,27 @@ type Gripper interface {
 	IsHoldingSomething(ctx context.Context, extra map[string]interface{}) (HoldingStatus, error)
 }
 
-// FromRobot is a helper for getting the named Gripper from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Gripper from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Gripper, error) {
 	return robot.ResourceFromRobot[Gripper](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named gripper from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named gripper from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Gripper, error) {
 	return resource.FromDependencies[Gripper](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named Gripper from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Gripper, error) {
+	return resource.FromProvider[Gripper](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all gripper names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/input/gpio/gpio.go b/components/input/gpio/gpio.go
index 43bfd89affd..bf0114507d6 100644
--- a/components/input/gpio/gpio.go
+++ b/components/input/gpio/gpio.go
@@ -111,7 +111,7 @@ func NewGPIOController(
 		return nil, err
 	}
 
-	brd, err := board.FromDependencies(deps, newConf.Board)
+	brd, err := board.FromProvider(deps, newConf.Board)
 	if err != nil {
 		return nil, err
 	}
diff --git a/components/input/input.go b/components/input/input.go
index 24252909c4f..9830fbf65af 100644
--- a/components/input/input.go
+++ b/components/input/input.go
@@ -45,7 +45,7 @@ func Named(name string) resource.Name {
 //
 // Controls example:
 //
-//	myController, err := input.FromRobot(machine, "my_input_controller")
+//	myController, err := input.FromProvider(machine, "my_input_controller")
 //
 //	// Get the list of Controls provided by the controller.
 //	controls, err := myController.Controls(context.Background(), nil)
@@ -54,7 +54,7 @@ func Named(name string) resource.Name {
 //
 // Events example:
 //
-//	myController, err := input.FromRobot(machine, "my_input_controller")
+//	myController, err := input.FromProvider(machine, "my_input_controller")
 //
 //	// Get the most recent Event for each Control.
 //	recent_events, err := myController.Events(context.Background(), nil)
@@ -68,7 +68,7 @@ func Named(name string) resource.Name {
 //	    logger.Info("Start Menu Button was pressed at this time: %v", event.Time)
 //	}
 //
-//	myController, err := input.FromRobot(machine, "my_input_controller")
+//	myController, err := input.FromProvider(machine, "my_input_controller")
 //
 //	// Define the EventType "ButtonPress" to serve as the trigger for printStartTime.
 //	triggers := []input.EventType{input.ButtonPress}
@@ -191,17 +191,27 @@ type Triggerable interface {
 	TriggerEvent(ctx context.Context, event Event, extra map[string]interface{}) error
 }
 
-// FromDependencies is a helper for getting the named input controller from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named input controller from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Controller, error) {
 	return resource.FromDependencies[Controller](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named input controller from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named input controller from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment checkx
 func FromRobot(r robot.Robot, name string) (Controller, error) {
 	return robot.ResourceFromRobot[Controller](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Input Controller from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Controller, error) {
+	return resource.FromProvider[Controller](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all input controller names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/input/mux/mux.go b/components/input/mux/mux.go
index ddc662c6894..2e0cc7d7b91 100644
--- a/components/input/mux/mux.go
+++ b/components/input/mux/mux.go
@@ -50,7 +50,7 @@ func NewController(
 	}
 
 	for _, s := range newConf.Sources {
-		c, err := input.FromDependencies(deps, s)
+		c, err := input.FromProvider(deps, s)
 		if err != nil {
 			return nil, err
 		}
diff --git a/components/motor/fake/motor.go b/components/motor/fake/motor.go
index eb10e97233d..0758b7d0f04 100644
--- a/components/motor/fake/motor.go
+++ b/components/motor/fake/motor.go
@@ -121,7 +121,7 @@ func (m *Motor) Reconfigure(ctx context.Context, deps resource.Dependencies, con
 	var b board.Board
 	if newConf.BoardName != "" {
 		m.Board = newConf.BoardName
-		b, err = board.FromDependencies(deps, m.Board)
+		b, err = board.FromProvider(deps, m.Board)
 		if err != nil {
 			return err
 		}
@@ -156,7 +156,7 @@ func (m *Motor) Reconfigure(ctx context.Context, deps resource.Dependencies, con
 	if newConf.Encoder != "" {
 		m.TicksPerRotation = newConf.TicksPerRotation
 
-		e, err := encoder.FromDependencies(deps, newConf.Encoder)
+		e, err := encoder.FromProvider(deps, newConf.Encoder)
 		if err != nil {
 			return err
 		}
diff --git a/components/motor/gpio/setup.go b/components/motor/gpio/setup.go
index 209e7762bf9..5336050acbc 100644
--- a/components/motor/gpio/setup.go
+++ b/components/motor/gpio/setup.go
@@ -168,7 +168,7 @@ func getBoardFromRobotConfig(deps resource.Dependencies, conf resource.Config) (
 	if motorConfig.BoardName == "" {
 		return nil, nil, errors.New("expected board name in config for motor")
 	}
-	b, err := board.FromDependencies(deps, motorConfig.BoardName)
+	b, err := board.FromProvider(deps, motorConfig.BoardName)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -189,7 +189,7 @@ func createNewMotor(
 	}
 
 	if motorConfig.Encoder != "" {
-		e, err := encoder.FromDependencies(deps, motorConfig.Encoder)
+		e, err := encoder.FromProvider(deps, motorConfig.Encoder)
 		if err != nil {
 			return nil, err
 		}
diff --git a/components/motor/gpiostepper/gpiostepper.go b/components/motor/gpiostepper/gpiostepper.go
index 8484afe0e7f..9a07a76fea6 100644
--- a/components/motor/gpiostepper/gpiostepper.go
+++ b/components/motor/gpiostepper/gpiostepper.go
@@ -118,7 +118,7 @@ func newGPIOStepper(
 		return nil, err
 	}
 
-	b, err := board.FromDependencies(deps, mc.BoardName)
+	b, err := board.FromProvider(deps, mc.BoardName)
 	if err != nil {
 		return nil, err
 	}
diff --git a/components/motor/motor.go b/components/motor/motor.go
index 1bbdfbc6f45..684057255f1 100644
--- a/components/motor/motor.go
+++ b/components/motor/motor.go
@@ -48,7 +48,7 @@ var API = resource.APINamespaceRDK.WithComponentType(SubtypeName)
 //
 // SetPower example:
 //
-//	myMotorComponent, err := motor.FromRobot(machine, "my_motor")
+//	myMotorComponent, err := motor.FromProvider(machine, "my_motor")
 //	// Set the motor power to 40% forwards.
 //	myMotorComponent.SetPower(context.Background(), 0.4, nil)
 //
@@ -56,7 +56,7 @@ var API = resource.APINamespaceRDK.WithComponentType(SubtypeName)
 //
 // GoFor example:
 //
-//	myMotorComponent, err := motor.FromRobot(machine, "my_motor")
+//	myMotorComponent, err := motor.FromProvider(machine, "my_motor")
 //	// Turn the motor 7.2 revolutions at 60 RPM.
 //	myMotorComponent.GoFor(context.Background(), 60, 7.2, nil)
 //
@@ -171,17 +171,27 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromDependencies is a helper for getting the named motor from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named motor from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Motor, error) {
 	return resource.FromDependencies[Motor](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named motor from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named motor from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Motor, error) {
 	return robot.ResourceFromRobot[Motor](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Motor from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Motor, error) {
+	return resource.FromProvider[Motor](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all motor names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/motor/motor_test.go b/components/motor/motor_test.go
index be78b2756de..625461c3e63 100644
--- a/components/motor/motor_test.go
+++ b/components/motor/motor_test.go
@@ -30,15 +30,15 @@ func TestFromRobot(t *testing.T) {
 	expected := []string{"m1", "m2"}
 	testutils.VerifySameElements(t, motor.NamesFromRobot(r), expected)
 
-	_, err := motor.FromRobot(r, "m1")
+	_, err := motor.FromProvider(r, "m1")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = motor.FromRobot(r, "m2")
+	_, err = motor.FromProvider(r, "m2")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = motor.FromRobot(r, "m0")
+	_, err = motor.FromProvider(r, "m0")
 	test.That(t, err, test.ShouldNotBeNil)
 
-	_, err = motor.FromRobot(r, "g")
+	_, err = motor.FromProvider(r, "g")
 	test.That(t, err, test.ShouldNotBeNil)
 }
diff --git a/components/movementsensor/merged/merged.go b/components/movementsensor/merged/merged.go
index 234dc576deb..8c900fe0f55 100644
--- a/components/movementsensor/merged/merged.go
+++ b/components/movementsensor/merged/merged.go
@@ -100,7 +100,7 @@ func (m *merged) Reconfigure(ctx context.Context, deps resource.Dependencies, co
 		}
 
 		for _, name := range names {
-			ms, err := movementsensor.FromDependencies(deps, name)
+			ms, err := movementsensor.FromProvider(deps, name)
 			msName := ms.Name().ShortName()
 			if err != nil {
 				logger.CDebugf(ctx, "error getting sensor %v from dependencies", msName)
diff --git a/components/movementsensor/movementsensor.go b/components/movementsensor/movementsensor.go
index 8da499eecf4..6b1000eb759 100644
--- a/components/movementsensor/movementsensor.go
+++ b/components/movementsensor/movementsensor.go
@@ -181,17 +181,27 @@ type MovementSensor interface {
 	Accuracy(ctx context.Context, extra map[string]interface{}) (*Accuracy, error)
 }
 
-// FromDependencies is a helper for getting the named movementsensor from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named movementsensor from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (MovementSensor, error) {
 	return resource.FromDependencies[MovementSensor](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named MovementSensor from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named MovementSensor from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (MovementSensor, error) {
 	return robot.ResourceFromRobot[MovementSensor](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named MovementSensor from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (MovementSensor, error) {
+	return resource.FromProvider[MovementSensor](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all MovementSensor names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/movementsensor/replay/replay.go b/components/movementsensor/replay/replay.go
index 19b953f442a..e63b811a1ea 100644
--- a/components/movementsensor/replay/replay.go
+++ b/components/movementsensor/replay/replay.go
@@ -407,7 +407,7 @@ func (replay *replayMovementSensor) Reconfigure(ctx context.Context, deps resour
 	replay.APIKey = replayMovementSensorConfig.APIKey
 	replay.APIKeyID = replayMovementSensorConfig.APIKeyID
 
-	cloudConnSvc, err := resource.FromDependencies[cloud.ConnectionService](deps, cloud.InternalServiceName)
+	cloudConnSvc, err := resource.FromProvider[cloud.ConnectionService](deps, cloud.InternalServiceName)
 	if err != nil {
 		return err
 	}
diff --git a/components/movementsensor/wheeledodometry/wheeledodometry.go b/components/movementsensor/wheeledodometry/wheeledodometry.go
index 6a39687d7d8..374b53b3a72 100644
--- a/components/movementsensor/wheeledodometry/wheeledodometry.go
+++ b/components/movementsensor/wheeledodometry/wheeledodometry.go
@@ -153,7 +153,7 @@ func (o *odometry) Reconfigure(ctx context.Context, deps resource.Dependencies,
 	}
 
 	// set baseWidth and wheelCircumference from the new base properties
-	newBase, err := base.FromDependencies(deps, newConf.Base)
+	newBase, err := base.FromProvider(deps, newConf.Base)
 	if err != nil {
 		return err
 	}
@@ -173,7 +173,7 @@ func (o *odometry) Reconfigure(ctx context.Context, deps resource.Dependencies,
 	for i := range newConf.LeftMotors {
 		var motorLeft, motorRight motor.Motor
 
-		motorLeft, err = motor.FromDependencies(deps, newConf.LeftMotors[i])
+		motorLeft, err = motor.FromProvider(deps, newConf.LeftMotors[i])
 		if err != nil {
 			return err
 		}
@@ -185,7 +185,7 @@ func (o *odometry) Reconfigure(ctx context.Context, deps resource.Dependencies,
 			return motor.NewPropertyUnsupportedError(properties, newConf.LeftMotors[i])
 		}
 
-		motorRight, err = motor.FromDependencies(deps, newConf.RightMotors[i])
+		motorRight, err = motor.FromProvider(deps, newConf.RightMotors[i])
 		if err != nil {
 			return err
 		}
diff --git a/components/posetracker/pose_tracker.go b/components/posetracker/pose_tracker.go
index 1ab1ce34a87..c14ab88efa3 100644
--- a/components/posetracker/pose_tracker.go
+++ b/components/posetracker/pose_tracker.go
@@ -45,13 +45,23 @@ type PoseTracker interface {
 	Poses(ctx context.Context, bodyNames []string, extra map[string]interface{}) (referenceframe.FrameSystemPoses, error)
 }
 
-// FromRobot is a helper for getting the named force matrix sensor from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named force matrix sensor from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (PoseTracker, error) {
 	return robot.ResourceFromRobot[PoseTracker](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named pose tracker from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named pose tracker from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (PoseTracker, error) {
 	return resource.FromDependencies[PoseTracker](deps, Named(name))
 }
+
+// FromProvider is a helper for getting the named PoseTracker from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (PoseTracker, error) {
+	return resource.FromProvider[PoseTracker](provider, Named(name))
+}
diff --git a/components/powersensor/powersensor.go b/components/powersensor/powersensor.go
index 3a3d431a457..f9edfa589a3 100644
--- a/components/powersensor/powersensor.go
+++ b/components/powersensor/powersensor.go
@@ -95,17 +95,27 @@ type PowerSensor interface {
 	Power(ctx context.Context, extra map[string]interface{}) (float64, error)
 }
 
-// FromDependencies is a helper for getting the named PowerSensor from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named PowerSensor from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (PowerSensor, error) {
 	return resource.FromDependencies[PowerSensor](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named PowerSensor from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named PowerSensor from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (PowerSensor, error) {
 	return robot.ResourceFromRobot[PowerSensor](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named PowerSensor from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (PowerSensor, error) {
+	return resource.FromProvider[PowerSensor](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all PowerSensor names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/sensor/sensor.go b/components/sensor/sensor.go
index ae422e8a52e..bd0ccdf9cb3 100644
--- a/components/sensor/sensor.go
+++ b/components/sensor/sensor.go
@@ -47,17 +47,27 @@ type Sensor interface {
 	resource.Sensor
 }
 
-// FromDependencies is a helper for getting the named sensor from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named sensor from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Sensor, error) {
 	return resource.FromDependencies[Sensor](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named Sensor from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Sensor from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Sensor, error) {
 	return robot.ResourceFromRobot[Sensor](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Sensor from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Sensor, error) {
+	return resource.FromProvider[Sensor](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all sensor names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/servo/gpio/servo.go b/components/servo/gpio/servo.go
index a644d25104c..be06f3bcf41 100644
--- a/components/servo/gpio/servo.go
+++ b/components/servo/gpio/servo.go
@@ -141,7 +141,7 @@ func (s *servoGPIO) Reconfigure(ctx context.Context, deps resource.Dependencies,
 
 	boardName := newConf.Board
 
-	b, err := board.FromDependencies(deps, boardName)
+	b, err := board.FromProvider(deps, boardName)
 	if err != nil {
 		return errors.Wrap(err, "board doesn't exist")
 	}
diff --git a/components/servo/servo.go b/components/servo/servo.go
index ea219e1d7e6..810571e3e99 100644
--- a/components/servo/servo.go
+++ b/components/servo/servo.go
@@ -83,11 +83,19 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named servo from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named servo from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Servo, error) {
 	return robot.ResourceFromRobot[Servo](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Servo from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Servo, error) {
+	return resource.FromProvider[Servo](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all servo names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/components/switch/switch.go b/components/switch/switch.go
index 11c2c822b5d..e2be7871926 100644
--- a/components/switch/switch.go
+++ b/components/switch/switch.go
@@ -51,16 +51,27 @@ type Switch interface {
 	GetNumberOfPositions(ctx context.Context, extra map[string]interface{}) (uint32, []string, error)
 }
 
-// FromRobot is a helper for getting the named Switch from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Switch from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Switch, error) {
 	return robot.ResourceFromRobot[Switch](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named button component from a collection of dependencies.
+// Deprecated: FromDependencies is a helper for getting the named switch component from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Switch, error) {
 	return resource.FromDependencies[Switch](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named Switch from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Switch, error) {
+	return resource.FromProvider[Switch](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all switch names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/examples/customresources/apis/gizmoapi/gizmoapi.go b/examples/customresources/apis/gizmoapi/gizmoapi.go
index f67dcc939dc..4246745065d 100644
--- a/examples/customresources/apis/gizmoapi/gizmoapi.go
+++ b/examples/customresources/apis/gizmoapi/gizmoapi.go
@@ -12,7 +12,6 @@ import (
 	pb "go.viam.com/rdk/examples/customresources/apis/proto/api/component/gizmo/v1"
 	"go.viam.com/rdk/logging"
 	"go.viam.com/rdk/resource"
-	"go.viam.com/rdk/robot"
 )
 
 // API is the full API definition.
@@ -23,9 +22,10 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named Gizmo from the given Robot.
-func FromRobot(r robot.Robot, name string) (Gizmo, error) {
-	return robot.ResourceFromRobot[Gizmo](r, Named(name))
+// FromProvider is a helper for getting the named Gizmo
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Gizmo, error) {
+	return resource.FromProvider[Gizmo](provider, Named(name))
 }
 
 func init() {
diff --git a/examples/customresources/apis/summationapi/summationapi.go b/examples/customresources/apis/summationapi/summationapi.go
index 9b04b5e568f..6360d527c60 100644
--- a/examples/customresources/apis/summationapi/summationapi.go
+++ b/examples/customresources/apis/summationapi/summationapi.go
@@ -9,7 +9,6 @@ import (
 	pb "go.viam.com/rdk/examples/customresources/apis/proto/api/service/summation/v1"
 	"go.viam.com/rdk/logging"
 	"go.viam.com/rdk/resource"
-	"go.viam.com/rdk/robot"
 )
 
 // API is the full API definition.
@@ -20,9 +19,10 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named Summation from the given Robot.
-func FromRobot(r robot.Robot, name string) (Summation, error) {
-	return robot.ResourceFromRobot[Summation](r, Named(name))
+// FromProvider is a helper for getting the named Summation
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Summation, error) {
+	return resource.FromProvider[Summation](provider, Named(name))
 }
 
 func init() {
diff --git a/examples/customresources/demos/complexmodule/client/client.go b/examples/customresources/demos/complexmodule/client/client.go
index d633ff5ba49..ba33c6b8ae1 100644
--- a/examples/customresources/demos/complexmodule/client/client.go
+++ b/examples/customresources/demos/complexmodule/client/client.go
@@ -34,7 +34,7 @@ func main() {
 	}()
 
 	logger.Info("---- Testing gizmo1 (gizmoapi) -----")
-	comp1, err := gizmoapi.FromRobot(robot, "gizmo1")
+	comp1, err := gizmoapi.FromProvider(robot, "gizmo1")
 	if err != nil {
 		logger.Fatal(err)
 	}
@@ -75,7 +75,7 @@ func main() {
 	logger.Info(ret3)
 
 	logger.Info("---- Testing adder (summationapi) -----")
-	add, err := summationapi.FromRobot(robot, "adder")
+	add, err := summationapi.FromProvider(robot, "adder")
 	if err != nil {
 		logger.Fatal(err)
 	}
@@ -88,7 +88,7 @@ func main() {
 	logger.Info(nums, "sum to", retAdd)
 
 	logger.Info("---- Testing subtractor (summationapi) -----")
-	sub, err := summationapi.FromRobot(robot, "subtractor")
+	sub, err := summationapi.FromProvider(robot, "subtractor")
 	if err != nil {
 		logger.Fatal(err)
 	}
@@ -99,7 +99,7 @@ func main() {
 	logger.Info(nums, "subtract to", retSub)
 
 	logger.Info("---- Testing denali (navigation) -----")
-	nav, err := navigation.FromRobot(robot, "denali")
+	nav, err := navigation.FromProvider(robot, "denali")
 	if err != nil {
 		logger.Fatal(err)
 	}
@@ -133,7 +133,7 @@ func main() {
 	}
 
 	logger.Info("---- Testing base1 (base) -----")
-	mybase, err := base.FromRobot(robot, "base1")
+	mybase, err := base.FromProvider(robot, "base1")
 	if err != nil {
 		logger.Fatal(err)
 	}
diff --git a/examples/customresources/demos/multiplemodules/client/client.go b/examples/customresources/demos/multiplemodules/client/client.go
index 82d69967859..deaa06dada8 100644
--- a/examples/customresources/demos/multiplemodules/client/client.go
+++ b/examples/customresources/demos/multiplemodules/client/client.go
@@ -27,7 +27,7 @@ func main() {
 	}()
 
 	logger.Info("---- Testing gizmo1 (gizmoapi) -----")
-	comp1, err := gizmoapi.FromRobot(robot, "gizmo1")
+	comp1, err := gizmoapi.FromProvider(robot, "gizmo1")
 	if err != nil {
 		logger.Fatal(err)
 	}
@@ -68,7 +68,7 @@ func main() {
 	logger.Info(ret4)
 
 	logger.Info("---- Testing adder (summationapi) -----")
-	add, err := summationapi.FromRobot(robot, "adder")
+	add, err := summationapi.FromProvider(robot, "adder")
 	if err != nil {
 		logger.Fatal(err)
 	}
diff --git a/examples/customresources/demos/optionaldepsmodule/module.go b/examples/customresources/demos/optionaldepsmodule/module.go
index a6857cc202a..0a86b604b6e 100644
--- a/examples/customresources/demos/optionaldepsmodule/module.go
+++ b/examples/customresources/demos/optionaldepsmodule/module.go
@@ -93,13 +93,13 @@ func (f *foo) Reconfigure(ctx context.Context, deps resource.Dependencies,
 		return err
 	}
 
-	f.requiredMotor, err = motor.FromDependencies(deps, fooConfig.RequiredMotor)
+	f.requiredMotor, err = motor.FromProvider(deps, fooConfig.RequiredMotor)
 	if err != nil {
 		return fmt.Errorf("could not get required motor %s from dependencies",
 			fooConfig.RequiredMotor)
 	}
 
-	f.optionalMotor, err = motor.FromDependencies(deps, fooConfig.OptionalMotor)
+	f.optionalMotor, err = motor.FromProvider(deps, fooConfig.OptionalMotor)
 	if err != nil {
 		f.logger.Infof("could not get optional motor %s from dependencies; continuing",
 			fooConfig.OptionalMotor)
@@ -188,7 +188,7 @@ func newMutualOptionalChild(ctx context.Context,
 		return nil, err
 	}
 
-	moc.otherMOC, err = generic.FromDependencies(deps, mutualOptionalChildConfig.OtherMOC)
+	moc.otherMOC, err = generic.FromProvider(deps, mutualOptionalChildConfig.OtherMOC)
 	if err != nil {
 		moc.logger.Infof("could not get other MOC %s from dependencies; continuing",
 			mutualOptionalChildConfig.OtherMOC)
diff --git a/examples/customresources/models/mybase/mybase.go b/examples/customresources/models/mybase/mybase.go
index cf27e6d0dd0..fa365d5f68d 100644
--- a/examples/customresources/models/mybase/mybase.go
+++ b/examples/customresources/models/mybase/mybase.go
@@ -57,12 +57,12 @@ func (b *myBase) Reconfigure(ctx context.Context, deps resource.Dependencies, co
 		return err
 	}
 
-	b.left, err = motor.FromDependencies(deps, baseConfig.LeftMotor)
+	b.left, err = motor.FromProvider(deps, baseConfig.LeftMotor)
 	if err != nil {
 		return errors.Wrapf(err, "unable to get motor %v for mybase", baseConfig.LeftMotor)
 	}
 
-	b.right, err = motor.FromDependencies(deps, baseConfig.RightMotor)
+	b.right, err = motor.FromProvider(deps, baseConfig.RightMotor)
 	if err != nil {
 		return errors.Wrapf(err, "unable to get motor %v for mybase", baseConfig.RightMotor)
 	}
diff --git a/examples/customresources/models/mygizmosummer/mygizmosummer.go b/examples/customresources/models/mygizmosummer/mygizmosummer.go
index 6cfb16713d5..53b58e5793f 100644
--- a/examples/customresources/models/mygizmosummer/mygizmosummer.go
+++ b/examples/customresources/models/mygizmosummer/mygizmosummer.go
@@ -77,7 +77,7 @@ func (g *myActualGizmo) Reconfigure(ctx context.Context, deps resource.Dependenc
 	if err != nil {
 		return err
 	}
-	summer, err := resource.FromDependencies[summationapi.Summation](deps, summationapi.Named(gizmoConfig.Summer))
+	summer, err := resource.FromProvider[summationapi.Summation](deps, summationapi.Named(gizmoConfig.Summer))
 	if err != nil {
 		return err
 	}
diff --git a/module/multiversionmodule/module.go b/module/multiversionmodule/module.go
index a5311408d8c..e5b6049a7f1 100644
--- a/module/multiversionmodule/module.go
+++ b/module/multiversionmodule/module.go
@@ -102,7 +102,7 @@ func (c *component) Reconfigure(ctx context.Context, deps resource.Dependencies,
 	}
 	if VERSION == "v3" {
 		// Version 3 should have a motor in the deps
-		if _, err := motor.FromDependencies(deps, "motor1"); err != nil {
+		if _, err := motor.FromProvider(deps, "motor1"); err != nil {
 			return errors.Wrapf(err, "failed to resolve motor %q for version 3", "motor1")
 		}
 	}
diff --git a/module/testmodule/main.go b/module/testmodule/main.go
index e004911ce1e..a1cdb129dbf 100644
--- a/module/testmodule/main.go
+++ b/module/testmodule/main.go
@@ -116,7 +116,7 @@ func newHelper(
 	var dependsOnSensor sensor.Sensor
 	var err error
 	if len(conf.DependsOn) > 0 {
-		dependsOnSensor, err = sensor.FromDependencies(deps, conf.DependsOn[0])
+		dependsOnSensor, err = sensor.FromProvider(deps, conf.DependsOn[0])
 		if err != nil {
 			return nil, err
 		}
diff --git a/module/testmodule2/main.go b/module/testmodule2/main.go
index 0575e7ec7a1..3d3ac65664d 100644
--- a/module/testmodule2/main.go
+++ b/module/testmodule2/main.go
@@ -73,7 +73,7 @@ func newHelper(
 	var dependsOnGeneric resource.Resource
 	var err error
 	if len(conf.DependsOn) > 0 {
-		dependsOnGeneric, err = generic.FromDependencies(deps, conf.DependsOn[0])
+		dependsOnGeneric, err = generic.FromProvider(deps, conf.DependsOn[0])
 		if err != nil {
 			return nil, err
 		}
diff --git a/resource/resource.go b/resource/resource.go
index adf3ac6d1ca..fb2cff72f39 100644
--- a/resource/resource.go
+++ b/resource/resource.go
@@ -56,7 +56,7 @@ var (
 // DoCommand example:
 //
 //	// This example shows using DoCommand with an arm component.
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	command := map[string]interface{}{"cmd": "test", "data1": 500}
 //	result, err := myArm.DoCommand(context.Background(), command)
@@ -64,7 +64,7 @@ var (
 // Close example:
 //
 //	// This example shows using Close with an arm component.
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	err = myArm.Close(context.Background())
 type Resource interface {
@@ -88,7 +88,10 @@ type Resource interface {
 // Dependencies are a set of resources that a resource requires for reconfiguration.
 type Dependencies map[Name]Resource
 
-// FromDependencies returns a named component from a collection of dependencies.
+// Deprecated: FromDependencies returns a named component from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies[T Resource](resources Dependencies, name Name) (T, error) {
 	var zero T
 	res, err := resources.Lookup(name)
@@ -102,6 +105,25 @@ func FromDependencies[T Resource](resources Dependencies, name Name) (T, error)
 	return typedRes, nil
 }
 
+// FromProvider returns a named resource from given Provider (collection of dependencies or a robot).
+func FromProvider[T Resource](provider Provider, name Name) (T, error) {
+	var zero T
+	res, err := provider.GetResource(name)
+	if err != nil {
+		return zero, err
+	}
+	typedRes, ok := res.(T)
+	if !ok {
+		return zero, DependencyTypeError[T](name, res)
+	}
+	return typedRes, nil
+}
+
+// GetResource implements Provider for Dependencies by looking up a resource by name.
+func (d Dependencies) GetResource(name Name) (Resource, error) {
+	return d.Lookup(name)
+}
+
 // Lookup searches for a given dependency by name.
 func (d Dependencies) Lookup(name Name) (Resource, error) {
 	res, ok := d[name]
@@ -172,7 +194,7 @@ type Sensor interface {
 // IsMoving example:
 //
 //	// This example shows using IsMoving with an arm component.
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	// Stop all motion of the arm. It is assumed that the arm stops immediately.
 //	myArm.Stop(context.Background(), nil)
@@ -184,7 +206,7 @@ type Sensor interface {
 // Stop example:
 //
 //	// This example shows using Stop with an arm component.
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	// Stop all motion of the arm. It is assumed that the arm stops immediately.
 //	err = myArm.Stop(context.Background(), nil)
@@ -201,7 +223,7 @@ type Actuator interface {
 // Geometries example:
 //
 //	// This example shows using Geometries with an arm component.
-//	myArm, err := arm.FromRobot(machine, "my_arm")
+//	myArm, err := arm.FromProvider(machine, "my_arm")
 //
 //	geometries, err := myArm.Geometries(context.Background(), nil)
 //
diff --git a/resource/resource_provider.go b/resource/resource_provider.go
new file mode 100644
index 00000000000..4c8b249fe6b
--- /dev/null
+++ b/resource/resource_provider.go
@@ -0,0 +1,7 @@
+package resource
+
+// Provider defines an interface for looking up resources by their name.
+type Provider interface {
+	// GetResource returns the Resource associated with the given name.
+	GetResource(name Name) (Resource, error)
+}
diff --git a/robot/client/README.md b/robot/client/README.md
index 4f2ab3d2f90..161f0cd2fe8 100644
--- a/robot/client/README.md
+++ b/robot/client/README.md
@@ -59,7 +59,7 @@ You can then query resources and also grab a resource by its name.
   	logger.Info(robot.ResourceNames())
 
 	// grab a motor by its name and query for its position
-	m1, err := motor.FromRobot(robot, "motor1")
+	m1, err := motor.FromProvider(robot, "motor1")
 	if err != nil {
 		logger.Fatal(err)
 	}
diff --git a/robot/client/client.go b/robot/client/client.go
index 33919c8ca6d..7954643e5a5 100644
--- a/robot/client/client.go
+++ b/robot/client/client.go
@@ -127,6 +127,11 @@ type RobotClient struct {
 	sharedConn *grpc.SharedConn
 }
 
+// GetResource implements resource.Provider for a RobotClient by looking up a resource by name.
+func (rc *RobotClient) GetResource(name resource.Name) (resource.Resource, error) {
+	return rc.ResourceByName(name)
+}
+
 // RemoteTypeName is the type name used for a remote. This is for internal use.
 const RemoteTypeName = string("remote")
 
diff --git a/robot/client/client_test.go b/robot/client/client_test.go
index 88121dfebd8..c98d70788cd 100644
--- a/robot/client/client_test.go
+++ b/robot/client/client_test.go
@@ -492,7 +492,7 @@ func TestStatusClient(t *testing.T) {
 	client, err := New(context.Background(), listener1.Addr().String(), logger)
 	test.That(t, err, test.ShouldBeNil)
 
-	arm1, err := arm.FromRobot(client, "arm1")
+	arm1, err := arm.FromProvider(client, "arm1")
 	test.That(t, err, test.ShouldBeNil)
 	_, err = arm1.EndPosition(context.Background(), nil)
 	test.That(t, err, test.ShouldNotBeNil)
@@ -510,10 +510,10 @@ func TestStatusClient(t *testing.T) {
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err.Error(), test.ShouldContainSubstring, "not found")
 
-	_, err = base.FromRobot(client, "base1")
+	_, err = base.FromProvider(client, "base1")
 	test.That(t, err, test.ShouldBeNil)
 
-	board1, err := board.FromRobot(client, "board1")
+	board1, err := board.FromProvider(client, "board1")
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, board1, test.ShouldNotBeNil)
 	pin, err := board1.GPIOPinByName("pin")
@@ -521,7 +521,7 @@ func TestStatusClient(t *testing.T) {
 	_, err = pin.Get(context.Background(), nil)
 	test.That(t, err.Error(), test.ShouldContainSubstring, "not found")
 
-	camera1, err := camera.FromRobot(client, "camera1")
+	camera1, err := camera.FromProvider(client, "camera1")
 	test.That(t, err, test.ShouldBeNil)
 	imgBytes, metadata, err := camera1.Image(context.Background(), rutils.MimeTypeJPEG, nil)
 	test.That(t, err, test.ShouldNotBeNil)
@@ -529,7 +529,7 @@ func TestStatusClient(t *testing.T) {
 	test.That(t, imgBytes, test.ShouldBeNil)
 	test.That(t, metadata, test.ShouldResemble, camera.ImageMetadata{})
 
-	gripper1, err := gripper.FromRobot(client, "gripper1")
+	gripper1, err := gripper.FromProvider(client, "gripper1")
 	test.That(t, err, test.ShouldBeNil)
 	err = gripper1.Open(context.Background(), map[string]interface{}{})
 	test.That(t, err, test.ShouldNotBeNil)
@@ -538,7 +538,7 @@ func TestStatusClient(t *testing.T) {
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err.Error(), test.ShouldContainSubstring, "not found")
 
-	motor1, err := motor.FromRobot(client, "motor1")
+	motor1, err := motor.FromProvider(client, "motor1")
 	test.That(t, err, test.ShouldBeNil)
 	err = motor1.SetPower(context.Background(), 0, nil)
 	test.That(t, err, test.ShouldNotBeNil)
@@ -547,13 +547,13 @@ func TestStatusClient(t *testing.T) {
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err.Error(), test.ShouldContainSubstring, "not found")
 
-	sensorDevice, err := sensor.FromRobot(client, "sensor1")
+	sensorDevice, err := sensor.FromProvider(client, "sensor1")
 	test.That(t, err, test.ShouldBeNil)
 	_, err = sensorDevice.Readings(context.Background(), make(map[string]interface{}))
 	test.That(t, err, test.ShouldNotBeNil)
 	test.That(t, err.Error(), test.ShouldContainSubstring, "not found")
 
-	servo1, err := servo.FromRobot(client, "servo1")
+	servo1, err := servo.FromProvider(client, "servo1")
 	test.That(t, err, test.ShouldBeNil)
 	err = servo1.Move(context.Background(), 5, nil)
 	test.That(t, err, test.ShouldNotBeNil)
@@ -589,19 +589,19 @@ func TestStatusClient(t *testing.T) {
 
 	test.That(t, func() { client.RemoteByName("remote1") }, test.ShouldPanic)
 
-	arm1, err = arm.FromRobot(client, "arm1")
+	arm1, err = arm.FromProvider(client, "arm1")
 	test.That(t, err, test.ShouldBeNil)
 	pos, err := arm1.EndPosition(context.Background(), nil)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, spatialmath.PoseAlmostEqual(pos, pose1), test.ShouldBeTrue)
 
-	_, err = base.FromRobot(client, "base1")
+	_, err = base.FromProvider(client, "base1")
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = board.FromRobot(client, "board1")
+	_, err = board.FromProvider(client, "board1")
 	test.That(t, err, test.ShouldBeNil)
 
-	camera1, err = camera.FromRobot(client, "camera1")
+	camera1, err = camera.FromProvider(client, "camera1")
 	test.That(t, err, test.ShouldBeNil)
 
 	frame, err := camera.DecodeImageFromCamera(context.Background(), rutils.MimeTypeRawRGBA, nil, camera1)
@@ -610,28 +610,28 @@ func TestStatusClient(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, compVal, test.ShouldEqual, 0) // exact copy, no color conversion
 
-	gripper1, err = gripper.FromRobot(client, "gripper1")
+	gripper1, err = gripper.FromProvider(client, "gripper1")
 	test.That(t, err, test.ShouldBeNil)
 	err = gripper1.Open(context.Background(), map[string]interface{}{})
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, gripperOpenCalled, test.ShouldBeTrue)
 	test.That(t, gripperGrabCalled, test.ShouldBeFalse)
 
-	inputDev, err := input.FromRobot(client, "inputController1")
+	inputDev, err := input.FromProvider(client, "inputController1")
 	test.That(t, err, test.ShouldBeNil)
 	controlList, err := inputDev.Controls(context.Background(), map[string]interface{}{})
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, controlList, test.ShouldResemble, []input.Control{input.AbsoluteX, input.ButtonStart})
 
-	motor1, err = motor.FromRobot(client, "motor1")
+	motor1, err = motor.FromProvider(client, "motor1")
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, motor1, test.ShouldNotBeNil)
 
-	motor2, err := motor.FromRobot(client, "motor2")
+	motor2, err := motor.FromProvider(client, "motor2")
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, motor2, test.ShouldNotBeNil)
 
-	servo1, err = servo.FromRobot(client, "servo1")
+	servo1, err = servo.FromProvider(client, "servo1")
 	test.That(t, err, test.ShouldBeNil)
 	err = servo1.Move(context.Background(), 4, nil)
 	test.That(t, err, test.ShouldBeNil)
diff --git a/robot/framesystem/framesystem.go b/robot/framesystem/framesystem.go
index 57aa69d1a0f..955f3b218fe 100644
--- a/robot/framesystem/framesystem.go
+++ b/robot/framesystem/framesystem.go
@@ -113,7 +113,7 @@ type RobotFrameSystem interface {
 
 // FromDependencies is a helper for getting the framesystem from a collection of dependencies.
 func FromDependencies(deps resource.Dependencies) (Service, error) {
-	return resource.FromDependencies[Service](deps, PublicServiceName)
+	return resource.FromProvider[Service](deps, PublicServiceName)
 }
 
 // New returns a new frame system service for the given robot.
diff --git a/robot/impl/local_robot.go b/robot/impl/local_robot.go
index 4e90deee9fe..59a3324bf32 100644
--- a/robot/impl/local_robot.go
+++ b/robot/impl/local_robot.go
@@ -1813,3 +1813,8 @@ func (r *localRobot) ListTunnels(_ context.Context) ([]config.TrafficTunnelEndpo
 	}
 	return nil, nil
 }
+
+// GetResource implements resource.Provider for a localRobot by looking up a resource by name.
+func (r *localRobot) GetResource(name resource.Name) (resource.Resource, error) {
+	return r.ResourceByName(name)
+}
diff --git a/robot/impl/local_robot_test.go b/robot/impl/local_robot_test.go
index 812a0fbc09a..d2a8122f6ea 100644
--- a/robot/impl/local_robot_test.go
+++ b/robot/impl/local_robot_test.go
@@ -85,7 +85,7 @@ func TestConfig1(t *testing.T) {
 
 	r := setupLocalRobot(t, context.Background(), cfg, logger)
 
-	c1, err := camera.FromRobot(r, "c1")
+	c1, err := camera.FromProvider(r, "c1")
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, c1.Name(), test.ShouldResemble, camera.Named("c1"))
 
@@ -1181,7 +1181,7 @@ func TestConfigStartsInvalidReconfiguresValid(t *testing.T) {
 
 	// Test Component Error
 	name := base.Named("test")
-	noBase, err := base.FromRobot(r, "test")
+	noBase, err := base.FromProvider(r, "test")
 	test.That(
 		t,
 		err,
@@ -1201,7 +1201,7 @@ func TestConfigStartsInvalidReconfiguresValid(t *testing.T) {
 
 	r.Reconfigure(ctx, goodConfig)
 	// Test Component Valid
-	noBase, err = base.FromRobot(r, "test")
+	noBase, err = base.FromProvider(r, "test")
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, noBase, test.ShouldNotBeNil)
 	// Test Service Valid
@@ -1287,7 +1287,7 @@ func TestConfigStartsValidReconfiguresInvalid(t *testing.T) {
 	}
 	test.That(t, badConfig.Ensure(false, logger), test.ShouldBeNil)
 	// Test Component Valid
-	noBase, err := base.FromRobot(r, "test")
+	noBase, err := base.FromProvider(r, "test")
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, noBase, test.ShouldNotBeNil)
 	// Test Service Valid
@@ -1302,7 +1302,7 @@ func TestConfigStartsValidReconfiguresInvalid(t *testing.T) {
 	r.Reconfigure(ctx, badConfig)
 	// Test Component Error
 	name := base.Named("test")
-	noBase, err = base.FromRobot(r, "test")
+	noBase, err = base.FromProvider(r, "test")
 	test.That(
 		t,
 		err,
diff --git a/robot/impl/optional_dependencies_test.go b/robot/impl/optional_dependencies_test.go
index 263bfd283d1..7f417af9e24 100644
--- a/robot/impl/optional_dependencies_test.go
+++ b/robot/impl/optional_dependencies_test.go
@@ -81,13 +81,13 @@ func (oc *optionalChild) Reconfigure(ctx context.Context, deps resource.Dependen
 		return err
 	}
 
-	oc.requiredMotor, err = motor.FromDependencies(deps, optionalChildConfig.RequiredMotor)
+	oc.requiredMotor, err = motor.FromProvider(deps, optionalChildConfig.RequiredMotor)
 	if err != nil {
 		return fmt.Errorf("could not get required motor %s from dependencies",
 			optionalChildConfig.RequiredMotor)
 	}
 
-	oc.optionalMotor, err = motor.FromDependencies(deps, optionalChildConfig.OptionalMotor)
+	oc.optionalMotor, err = motor.FromProvider(deps, optionalChildConfig.OptionalMotor)
 	if err != nil {
 		oc.logger.Infof("could not get optional motor %s from dependencies; continuing",
 			optionalChildConfig.OptionalMotor)
@@ -672,7 +672,7 @@ func (moc *mutualOptionalChild) Reconfigure(ctx context.Context, deps resource.D
 		return err
 	}
 
-	moc.otherMOC, err = generic.FromDependencies(deps, mutualOptionalChildConfig.OtherMOC)
+	moc.otherMOC, err = generic.FromProvider(deps, mutualOptionalChildConfig.OtherMOC)
 	if err != nil {
 		moc.logger.Infof("could not get other MOC %s from dependencies; continuing",
 			mutualOptionalChildConfig.OtherMOC)
diff --git a/robot/impl/resource_manager_test.go b/robot/impl/resource_manager_test.go
index 82e0ba69f20..bac24e2446f 100644
--- a/robot/impl/resource_manager_test.go
+++ b/robot/impl/resource_manager_test.go
@@ -1574,7 +1574,7 @@ func TestRemoteConnClosedOnReconfigure(t *testing.T) {
 		mainRobot := setupLocalRobot(t, ctx, mainRobotCfg, logger.Sublogger("main"))
 
 		// Grab motor of remote1 to check that it won't work after switching remotes
-		motor1, err := motor.FromRobot(mainRobot, "motor")
+		motor1, err := motor.FromProvider(mainRobot, "motor")
 		test.That(t, err, test.ShouldBeNil)
 
 		moving, speed, err := motor1.IsPowered(ctx, nil)
@@ -1592,7 +1592,7 @@ func TestRemoteConnClosedOnReconfigure(t *testing.T) {
 		test.That(t, err, test.ShouldNotBeNil)
 
 		// Grab motor of remote2 to check that it won't work after switching remotes
-		motor2, err := motor.FromRobot(mainRobot, "motor")
+		motor2, err := motor.FromProvider(mainRobot, "motor")
 		test.That(t, err, test.ShouldBeNil)
 
 		moving, speed, _ = motor2.IsPowered(ctx, nil)
@@ -1612,7 +1612,7 @@ func TestRemoteConnClosedOnReconfigure(t *testing.T) {
 		test.That(t, err, test.ShouldNotBeNil)
 
 		// Check that we were able to grab the motor from remote1 through the main robot and successfully call IsPowered()
-		motor1, err = motor.FromRobot(mainRobot, "motor")
+		motor1, err = motor.FromProvider(mainRobot, "motor")
 		test.That(t, err, test.ShouldBeNil)
 
 		moving, speed, err = motor1.IsPowered(ctx, nil)
@@ -1648,7 +1648,7 @@ func TestRemoteConnClosedOnReconfigure(t *testing.T) {
 		mainRobot := setupLocalRobot(t, ctx, mainRobotCfg, logger.Sublogger("main"))
 
 		// Grab arm of remote1 to check that it won't work after switching remotes
-		arm1, err := arm.FromRobot(mainRobot, "arm")
+		arm1, err := arm.FromProvider(mainRobot, "arm")
 		test.That(t, err, test.ShouldBeNil)
 
 		moving, err := arm1.IsMoving(ctx)
@@ -1665,7 +1665,7 @@ func TestRemoteConnClosedOnReconfigure(t *testing.T) {
 		test.That(t, err, test.ShouldNotBeNil)
 
 		// Grab motor of remote2 to check that it won't work after switching remotes
-		motor1, err := motor.FromRobot(mainRobot, "motor")
+		motor1, err := motor.FromProvider(mainRobot, "motor")
 		test.That(t, err, test.ShouldBeNil)
 
 		moving, speed, _ := motor1.IsPowered(ctx, nil)
@@ -1685,7 +1685,7 @@ func TestRemoteConnClosedOnReconfigure(t *testing.T) {
 		test.That(t, err, test.ShouldNotBeNil)
 
 		// Check that we were able to grab the arm from remote1 through the main robot and successfully call IsMoving()
-		arm1, err = arm.FromRobot(mainRobot, "arm")
+		arm1, err = arm.FromProvider(mainRobot, "arm")
 		test.That(t, err, test.ShouldBeNil)
 
 		moving, err = arm1.IsMoving(ctx)
@@ -1787,6 +1787,11 @@ type dummyRobot struct {
 	offline bool
 }
 
+// GetResource implements resource.Provider for a dummyRobot by looking up a resource by name.
+func (rr *dummyRobot) GetResource(name resource.Name) (resource.Resource, error) {
+	return rr.ResourceByName(name)
+}
+
 // newDummyRobot returns a new dummy robot wrapping a given robot.Robot
 // and its configuration.
 func newDummyRobot(t *testing.T, robot robot.Robot) *dummyRobot {
diff --git a/robot/robot.go b/robot/robot.go
index d8a97e5cae4..d97b532e379 100644
--- a/robot/robot.go
+++ b/robot/robot.go
@@ -79,6 +79,7 @@ const (
 //	err := machine.Shutdown(context.Background())
 type Robot interface {
 	framesystem.RobotFrameSystem
+	resource.Provider
 
 	// GetModelsFromModules returns a list of models supported by the configured modules,
 	// and specifies whether the models are from a local or registry module.
diff --git a/robot/session_test.go b/robot/session_test.go
index 1d8be4c17ba..4d13481016d 100644
--- a/robot/session_test.go
+++ b/robot/session_test.go
@@ -186,7 +186,7 @@ func TestSessions(t *testing.T) {
 			roboClient, err := client.New(ctx, addr, logger.Sublogger("client"))
 			test.That(t, err, test.ShouldBeNil)
 
-			motor1, err := motor.FromRobot(roboClient, "motor1")
+			motor1, err := motor.FromProvider(roboClient, "motor1")
 			test.That(t, err, test.ShouldBeNil)
 
 			t.Log("get position of motor1 which will not be safety monitored")
@@ -202,7 +202,7 @@ func TestSessions(t *testing.T) {
 			roboClient, err = client.New(ctx, addr, logger.Sublogger("client"))
 			test.That(t, err, test.ShouldBeNil)
 
-			motor1, err = motor.FromRobot(roboClient, "motor1")
+			motor1, err = motor.FromProvider(roboClient, "motor1")
 			test.That(t, err, test.ShouldBeNil)
 
 			t.Log("set power of motor1 which will be safety monitored")
@@ -220,7 +220,7 @@ func TestSessions(t *testing.T) {
 			roboClient, err = client.New(ctx, addr, logger.Sublogger("client"))
 			test.That(t, err, test.ShouldBeNil)
 
-			motor2, err := motor.FromRobot(roboClient, "motor2")
+			motor2, err := motor.FromProvider(roboClient, "motor2")
 			test.That(t, err, test.ShouldBeNil)
 
 			t.Log("set power of motor2 which will be safety monitored")
@@ -418,7 +418,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	roboClient, err := client.New(ctx, addr, logger.Sublogger("client"))
 	test.That(t, err, test.ShouldBeNil)
 
-	motor1, err := motor.FromRobot(roboClient, "rem1motor1")
+	motor1, err := motor.FromProvider(roboClient, "rem1motor1")
 	if err != nil {
 		bufSize := 1 << 20
 		traces := make([]byte, bufSize)
@@ -444,7 +444,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	roboClient, err = client.New(ctx, addr, logger.Sublogger("client"))
 	test.That(t, err, test.ShouldBeNil)
 
-	motor1, err = motor.FromRobot(roboClient, "rem1motor1")
+	motor1, err = motor.FromProvider(roboClient, "rem1motor1")
 	test.That(t, err, test.ShouldBeNil)
 
 	// this should cause safety monitoring
@@ -465,7 +465,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	roboClient, err = client.New(ctx, addr, logger.Sublogger("client"))
 	test.That(t, err, test.ShouldBeNil)
 
-	motor1, err = motor.FromRobot(roboClient, "rem1motor1")
+	motor1, err = motor.FromProvider(roboClient, "rem1motor1")
 	test.That(t, err, test.ShouldBeNil)
 
 	t.Log("set power of rem1:motor1 which will be safety monitored")
@@ -492,7 +492,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	roboClient, err = client.New(ctx, addr, logger.Sublogger("client"))
 	test.That(t, err, test.ShouldBeNil)
 
-	motor2, err := motor.FromRobot(roboClient, "rem1motor2")
+	motor2, err := motor.FromProvider(roboClient, "rem1motor2")
 	if err != nil {
 		bufSize := 1 << 20
 		traces := make([]byte, bufSize)
@@ -592,9 +592,9 @@ func TestSessionsMixedClients(t *testing.T) {
 	roboClient2, err := client.New(ctx, addr, logger.Sublogger("client2"))
 	test.That(t, err, test.ShouldBeNil)
 
-	motor1Client1, err := motor.FromRobot(roboClient1, "motor1")
+	motor1Client1, err := motor.FromProvider(roboClient1, "motor1")
 	test.That(t, err, test.ShouldBeNil)
-	motor1Client2, err := motor.FromRobot(roboClient2, "motor1")
+	motor1Client2, err := motor.FromProvider(roboClient2, "motor1")
 	test.That(t, err, test.ShouldBeNil)
 
 	test.That(t, motor1Client1.SetPower(ctx, 50, nil), test.ShouldBeNil)
@@ -691,7 +691,7 @@ func TestSessionsMixedOwnersNoAuth(t *testing.T) {
 	// 4) Client 1 will disconnect. This results in the client ceasing heartbeats for the
 	//    `SetPower` operation. The robot's heartbeat thread will call `motor1.Stop`. While Client 2 sent a command
 	//    to the motor, it used Client 1's session and never sent heartbeats.
-	motor1Client1, err := motor.FromRobot(roboClient1, "motor1")
+	motor1Client1, err := motor.FromProvider(roboClient1, "motor1")
 	test.That(t, err, test.ShouldBeNil)
 
 	// clients made directly with a connection will not send heartbeats.
@@ -798,7 +798,7 @@ func TestSessionsMixedOwnersImplicitAuth(t *testing.T) {
 	// 4) Client 1 will disconnect. This results in the client ceasing heartbeats for the
 	//    `SetPower` operation. As Client 2 never sent a successful command to the motor (even if it did, Client 2
 	//    won't sent heartbeats), the robot's heartbeat thread will call `motor1.Stop`.
-	motor1Client1, err := motor.FromRobot(roboClient1, "motor1")
+	motor1Client1, err := motor.FromProvider(roboClient1, "motor1")
 	test.That(t, err, test.ShouldBeNil)
 
 	// clients made directly with a connection will not send heartbeats.
diff --git a/robot/web/stream/camera/camera.go b/robot/web/stream/camera/camera.go
index 6dda774cd80..86d910698e7 100644
--- a/robot/web/stream/camera/camera.go
+++ b/robot/web/stream/camera/camera.go
@@ -19,7 +19,7 @@ import (
 func Camera(robot robot.Robot, stream gostream.Stream) (camera.Camera, error) {
 	// Stream names are slightly modified versions of the resource short name
 	shortName := stream.Name()
-	cam, err := camera.FromRobot(robot, shortName)
+	cam, err := camera.FromProvider(robot, shortName)
 	if err != nil {
 		return nil, err
 	}
diff --git a/robot/web/stream/camera2/camera.go b/robot/web/stream/camera2/camera.go
index 2b6ea32319c..60cc367227e 100644
--- a/robot/web/stream/camera2/camera.go
+++ b/robot/web/stream/camera2/camera.go
@@ -56,7 +56,7 @@ func cropToEvenDimensions(img image.Image) (image.Image, error) {
 func Camera(robot robot.Robot, stream gostream.Stream) (camera.Camera, error) {
 	// Stream names are slightly modified versions of the resource short name
 	shortName := resource.SDPTrackNameToShortName(stream.Name())
-	cam, err := camera.FromRobot(robot, shortName)
+	cam, err := camera.FromProvider(robot, shortName)
 	if err != nil {
 		return nil, err
 	}
diff --git a/robot/web/stream/server.go b/robot/web/stream/server.go
index 65104f4fcd2..745ff481b36 100644
--- a/robot/web/stream/server.go
+++ b/robot/web/stream/server.go
@@ -173,7 +173,7 @@ func (server *Server) AddStream(ctx context.Context, req *streampb.AddStreamRequ
 
 	// return error if resource is neither a camera nor audioinput
 	_, isCamErr := cameraUtilsCamera(server.robot, streamStateToAdd.Stream)
-	_, isAudioErr := audioinput.FromRobot(server.robot, streamStateToAdd.Stream.Name())
+	_, isAudioErr := audioinput.FromProvider(server.robot, streamStateToAdd.Stream.Name())
 	if isCamErr != nil && isAudioErr != nil {
 		return nil, errors.Errorf("stream is neither a camera nor audioinput. streamName: %v", streamStateToAdd.Stream)
 	}
@@ -272,7 +272,7 @@ func (server *Server) RemoveStream(ctx context.Context, req *streampb.RemoveStre
 	}
 
 	streamName := streamToRemove.Stream.Name()
-	_, isAudioResourceErr := audioinput.FromRobot(server.robot, streamName)
+	_, isAudioResourceErr := audioinput.FromProvider(server.robot, streamName)
 	_, isCameraResourceErr := cameraUtilsCamera(server.robot, streamToRemove.Stream)
 
 	if isAudioResourceErr != nil && isCameraResourceErr != nil {
@@ -311,7 +311,7 @@ func (server *Server) GetStreamOptions(
 	if req.Name == "" {
 		return nil, errors.New("stream name is required")
 	}
-	cam, err := camera.FromRobot(server.robot, req.Name)
+	cam, err := camera.FromProvider(server.robot, req.Name)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get camera from robot: %w", err)
 	}
@@ -404,7 +404,7 @@ func (server *Server) resizeVideoSource(ctx context.Context, name string, width,
 	if !ok {
 		return fmt.Errorf("video source %q not found", name)
 	}
-	cam, err := camera.FromRobot(server.robot, name)
+	cam, err := camera.FromProvider(server.robot, name)
 	if err != nil {
 		server.logger.Errorf("error getting camera %q from robot", name)
 		return err
@@ -436,7 +436,7 @@ func (server *Server) resetVideoSource(ctx context.Context, name string) error {
 	if !ok {
 		return fmt.Errorf("video source %q not found", name)
 	}
-	cam, err := camera.FromRobot(server.robot, name)
+	cam, err := camera.FromProvider(server.robot, name)
 	if err != nil {
 		server.logger.Errorf("error getting camera %q from robot", name)
 	}
@@ -579,13 +579,13 @@ func (server *Server) removeMissingStreams() {
 		// Stream names are slightly modified versions of the resource short name
 		camName := streamState.Stream.Name()
 		shortName := resource.SDPTrackNameToShortName(camName)
-		if _, err := audioinput.FromRobot(server.robot, shortName); err == nil {
+		if _, err := audioinput.FromProvider(server.robot, shortName); err == nil {
 			// `nameToStreamState` can contain names for both camera and audio resources. Leave the
 			// stream in place if its an audio resource.
 			continue
 		}
 
-		_, err := camera.FromRobot(server.robot, shortName)
+		_, err := camera.FromProvider(server.robot, shortName)
 		if !resource.IsNotFoundError(err) {
 			// Cameras can go through transient states during reconfigure that don't necessarily
 			// imply the camera is missing. E.g: *resource.notAvailableError. To double-check we
@@ -633,7 +633,7 @@ func (server *Server) removeMissingStreams() {
 // refreshVideoSources checks and initializes every possible video source that could be viewed from the robot.
 func (server *Server) refreshVideoSources(ctx context.Context) {
 	for _, name := range camera.NamesFromRobot(server.robot) {
-		cam, err := camera.FromRobot(server.robot, name)
+		cam, err := camera.FromProvider(server.robot, name)
 		if err != nil {
 			continue
 		}
@@ -686,7 +686,7 @@ func (server *Server) refreshVideoSources(ctx context.Context) {
 // refreshAudioSources checks and initializes every possible audio source that could be viewed from the robot.
 func (server *Server) refreshAudioSources() {
 	for _, name := range audioinput.NamesFromRobot(server.robot) {
-		input, err := audioinput.FromRobot(server.robot, name)
+		input, err := audioinput.FromProvider(server.robot, name)
 		if err != nil {
 			continue
 		}
@@ -747,7 +747,7 @@ func (server *Server) startAudioStream(ctx context.Context, source gostream.Audi
 }
 
 func (server *Server) getFramerateFromCamera(name string) (int, error) {
-	cam, err := camera.FromRobot(server.robot, name)
+	cam, err := camera.FromProvider(server.robot, name)
 	if err != nil {
 		return 0, fmt.Errorf("failed to get camera from robot: %w", err)
 	}
diff --git a/services/baseremotecontrol/base_remote_control.go b/services/baseremotecontrol/base_remote_control.go
index 7197afe49df..e29b11f7dd6 100644
--- a/services/baseremotecontrol/base_remote_control.go
+++ b/services/baseremotecontrol/base_remote_control.go
@@ -24,11 +24,20 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named base remote control service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named base remote control service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Base Remote Control service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 func init() {
 	resource.RegisterAPI(API, resource.APIRegistration[Service]{})
 	data.RegisterCollector(data.MethodMetadata{
diff --git a/services/baseremotecontrol/builtin/builtin.go b/services/baseremotecontrol/builtin/builtin.go
index 847766d409a..71dc9ad22d8 100644
--- a/services/baseremotecontrol/builtin/builtin.go
+++ b/services/baseremotecontrol/builtin/builtin.go
@@ -134,11 +134,11 @@ func (svc *builtIn) Reconfigure(
 	if err != nil {
 		return err
 	}
-	base1, err := base.FromDependencies(deps, svcConfig.BaseName)
+	base1, err := base.FromProvider(deps, svcConfig.BaseName)
 	if err != nil {
 		return err
 	}
-	controller, err := input.FromDependencies(deps, svcConfig.InputControllerName)
+	controller, err := input.FromProvider(deps, svcConfig.InputControllerName)
 	if err != nil {
 		return err
 	}
diff --git a/services/datamanager/builtin/builtin.go b/services/datamanager/builtin/builtin.go
index 1d99f1bdf50..2760e30f31f 100644
--- a/services/datamanager/builtin/builtin.go
+++ b/services/datamanager/builtin/builtin.go
@@ -181,7 +181,7 @@ func (b *builtIn) Reconfigure(ctx context.Context, deps resource.Dependencies, c
 		return ErrCaptureDirectoryConfigurationDisabled
 	}
 
-	cloudConnSvc, err := resource.FromDependencies[cloud.ConnectionService](deps, cloud.InternalServiceName)
+	cloudConnSvc, err := resource.FromProvider[cloud.ConnectionService](deps, cloud.InternalServiceName)
 	if err != nil {
 		// If this error occurs it's a resource graph error
 		return err
@@ -216,7 +216,7 @@ func syncSensorFromDeps(name string, deps resource.Dependencies, logger logging.
 	if name == "" {
 		return nil, false
 	}
-	syncSensor, err := sensor.FromDependencies(deps, name)
+	syncSensor, err := sensor.FromProvider(deps, name)
 	if err != nil {
 		// see sync.Config for how this affects whether or not scheduled sync will run
 		logger.Errorw(
diff --git a/services/datamanager/data_manager.go b/services/datamanager/data_manager.go
index 08be396b4ca..1088cd8d0ba 100644
--- a/services/datamanager/data_manager.go
+++ b/services/datamanager/data_manager.go
@@ -40,7 +40,7 @@ func init() {
 //
 // Sync example:
 //
-//	data, err := datamanager.FromRobot(machine, "my_data_manager")
+//	data, err := datamanager.FromProvider(machine, "my_data_manager")
 //	// Sync data stored on the machine to the cloud.
 //	err := data.Sync(context.Background(), nil)
 //
@@ -69,16 +69,28 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromDependencies is a helper for getting the named data manager service from a collection of dependencies.
+// Deprecated: FromDependencies is a helper for getting the named data manager service from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
 
-// FromRobot is a helper for getting the named data manager service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named data manager service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Data Manager service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all data manager services from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/services/discovery/discovery.go b/services/discovery/discovery.go
index 6422780c28a..56079f9c490 100644
--- a/services/discovery/discovery.go
+++ b/services/discovery/discovery.go
@@ -40,17 +40,28 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named discovery service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named discovery service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named discovery service from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named discovery service from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named Discovery service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // Service describes the functions that are available to the service.
 //
 // For more information, see the [Discovery service docs].
diff --git a/services/generic/generic.go b/services/generic/generic.go
index 8753b14f280..c1997adc0e4 100644
--- a/services/generic/generic.go
+++ b/services/generic/generic.go
@@ -36,11 +36,20 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named Generic from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named Generic from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (resource.Resource, error) {
 	return robot.ResourceFromRobot[resource.Resource](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Generic
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (resource.Resource, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // NamesFromRobot is a helper for getting all generic names from the given Robot.
 func NamesFromRobot(r robot.Robot) []string {
 	return robot.NamesByAPI(r, API)
diff --git a/services/mlmodel/mlmodel.go b/services/mlmodel/mlmodel.go
index 2a1c3100a46..6f1812c8ede 100644
--- a/services/mlmodel/mlmodel.go
+++ b/services/mlmodel/mlmodel.go
@@ -40,7 +40,7 @@ func init() {
 //		"gorgonia.org/tensor"
 //	 )
 //
-//	myMLModel, err := mlmodel.FromRobot(machine, "my_mlmodel")
+//	myMLModel, err := mlmodel.FromProvider(machine, "my_mlmodel")
 //
 //	input_tensors := ml.Tensors{
 //		"image": tensor.New(
@@ -56,7 +56,7 @@ func init() {
 //
 // Metadata example:
 //
-//	myMLModel, err := mlmodel.FromRobot(machine, "my_mlmodel")
+//	myMLModel, err := mlmodel.FromProvider(machine, "my_mlmodel")
 //	metadata, err := myMLModel.Metadata(context.Background())
 //
 // For more information, see the [Metadata method docs].
@@ -333,12 +333,24 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named ML model service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named ML model service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named ml model service from a collection of dependencies.
+// Deprecated: FromDependencies is a helper for getting the named ml model service from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
+
+// FromProvider is a helper for getting the named ML model service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
diff --git a/services/motion/builtin/builtin_test.go b/services/motion/builtin/builtin_test.go
index 2d451021b38..f88074be0b7 100644
--- a/services/motion/builtin/builtin_test.go
+++ b/services/motion/builtin/builtin_test.go
@@ -49,7 +49,7 @@ func setupMotionServiceFromConfig(t *testing.T, configFilename string) (motion.S
 	test.That(t, err, test.ShouldBeNil)
 	myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
-	svc, err := motion.FromRobot(myRobot, "builtin")
+	svc, err := motion.FromProvider(myRobot, "builtin")
 	test.That(t, err, test.ShouldBeNil)
 	return svc, func() {
 		myRobot.Close(context.Background())
diff --git a/services/motion/builtin/move_on_map_test.go b/services/motion/builtin/move_on_map_test.go
index 1b0c9a3d711..36607de61c2 100644
--- a/services/motion/builtin/move_on_map_test.go
+++ b/services/motion/builtin/move_on_map_test.go
@@ -48,7 +48,7 @@ func TestMoveOnMap(t *testing.T) {
 
 		injectSlam := createInjectedSlam("test_slam")
 
-		realBase, err := base.FromRobot(myRobot, "test-base")
+		realBase, err := base.FromProvider(myRobot, "test-base")
 		test.That(t, err, test.ShouldBeNil)
 
 		deps := resource.Dependencies{
diff --git a/services/motion/builtin/testutils.go b/services/motion/builtin/testutils.go
index 23fe26b7232..86adab943df 100644
--- a/services/motion/builtin/testutils.go
+++ b/services/motion/builtin/testutils.go
@@ -380,7 +380,7 @@ func CreateMoveOnGlobeTestEnvironment(ctx context.Context, t *testing.T, origin
 
 	// create fake wheeled base
 	deps := createDependencies(t, ctx, logger, geometrySize, origin, noise)
-	movementSensor, err := movementsensor.FromDependencies(deps, moveSensorName)
+	movementSensor, err := movementsensor.FromProvider(deps, moveSensorName)
 	test.That(t, err, test.ShouldBeNil)
 	// create base link
 	baseLink := createBaseLink(t)
@@ -461,7 +461,7 @@ func CreateMoveOnMapTestEnvironment(
 
 	deps := createDependencies(t, ctx, logger, geomSize, &geo.Point{}, nil)
 
-	movementSensor, err := movementsensor.FromDependencies(deps, moveSensorName)
+	movementSensor, err := movementsensor.FromProvider(deps, moveSensorName)
 	test.That(t, err, test.ShouldBeNil)
 	injectSlam, err := createMockSlamService("test_slam", pcdPath, origin, movementSensor)
 	test.That(t, err, test.ShouldBeNil)
@@ -521,9 +521,9 @@ func createTestKinematicBase(ctx context.Context, t *testing.T) (
 
 	// create fake wheeled base
 	deps := createDependencies(t, ctx, logger, 80, &geo.Point{}, nil)
-	movementSensor, err := movementsensor.FromDependencies(deps, moveSensorName)
+	movementSensor, err := movementsensor.FromProvider(deps, moveSensorName)
 	test.That(t, err, test.ShouldBeNil)
-	b, err := base.FromDependencies(deps, baseName)
+	b, err := base.FromProvider(deps, baseName)
 	test.That(t, err, test.ShouldBeNil)
 
 	startPosition, _, err := movementSensor.Position(context.Background(), nil)
diff --git a/services/motion/motion.go b/services/motion/motion.go
index af4dcb7de37..e32353616a1 100644
--- a/services/motion/motion.go
+++ b/services/motion/motion.go
@@ -210,7 +210,7 @@ type PlanWithStatus struct {
 //
 // Move example:
 //
-//	motionService, err := motion.FromRobot(machine, "builtin")
+//	motionService, err := motion.FromProvider(machine, "builtin")
 //
 //	// Assumes a gripper configured with name "my_gripper" on the machine
 //	gripperName := gripper.Named("my_gripper")
@@ -307,7 +307,7 @@ type PlanWithStatus struct {
 //
 // StopPlan example:
 //
-//	motionService, err := motion.FromRobot(machine, "builtin")
+//	motionService, err := motion.FromProvider(machine, "builtin")
 //	myBaseResourceName := base.Named("myBase")
 //
 //	myMvmntSensorResourceName := movement_sensor.Named("my_movement_sensor")
@@ -323,7 +323,7 @@ type PlanWithStatus struct {
 //
 // ListPlanStatuses example:
 //
-//	motionService, err := motion.FromRobot(machine, "builtin")
+//	motionService, err := motion.FromProvider(machine, "builtin")
 //
 //	// Get the plan(s) of the base component's most recent execution i.e. `MoveOnGlobe()` or `MoveOnMap()` call.
 //	planStatuses, err := motionService.ListPlanStatuses(context.Background(), motion.ListPlanStatusesReq{})
@@ -428,16 +428,28 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named motion service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named motion service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named motion service from a collection of dependencies.
+// Deprecated: FromDependencies is a helper for getting the named motion service from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named Motion service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // ToProto converts a PlanWithStatus to a *pb.PlanWithStatus.
 func (pws PlanWithStatus) ToProto() *pb.PlanWithStatus {
 	statusHistory := []*pb.PlanStatus{}
diff --git a/services/navigation/builtin/builtin.go b/services/navigation/builtin/builtin.go
index 0b42464f730..e5ce71b8a18 100644
--- a/services/navigation/builtin/builtin.go
+++ b/services/navigation/builtin/builtin.go
@@ -328,13 +328,13 @@ func (svc *builtIn) Reconfigure(ctx context.Context, deps resource.Dependencies,
 	}
 
 	// Parse base from the configuration
-	baseComponent, err := base.FromDependencies(deps, svcConfig.BaseName)
+	baseComponent, err := base.FromProvider(deps, svcConfig.BaseName)
 	if err != nil {
 		return err
 	}
 
 	// Parse motion services from the configuration
-	motionSvc, err := motion.FromDependencies(deps, motionServiceName)
+	motionSvc, err := motion.FromProvider(deps, motionServiceName)
 	if err != nil {
 		return err
 	}
@@ -342,11 +342,11 @@ func (svc *builtIn) Reconfigure(ctx context.Context, deps resource.Dependencies,
 	var obstacleDetectorNamePairs []motion.ObstacleDetectorName
 	visionServicesByName := make(map[string]vision.Service)
 	for _, pbObstacleDetectorPair := range svcConfig.ObstacleDetectors {
-		visionSvc, err := vision.FromDependencies(deps, pbObstacleDetectorPair.VisionServiceName)
+		visionSvc, err := vision.FromProvider(deps, pbObstacleDetectorPair.VisionServiceName)
 		if err != nil {
 			return err
 		}
-		camera, err := camera.FromDependencies(deps, pbObstacleDetectorPair.CameraName)
+		camera, err := camera.FromProvider(deps, pbObstacleDetectorPair.CameraName)
 		if err != nil {
 			return err
 		}
@@ -358,7 +358,7 @@ func (svc *builtIn) Reconfigure(ctx context.Context, deps resource.Dependencies,
 
 	// Parse movement sensor from the configuration if map type is GPS
 	if mapType == navigation.GPSMap {
-		movementSensor, err := movementsensor.FromDependencies(deps, svcConfig.MovementSensorName)
+		movementSensor, err := movementsensor.FromProvider(deps, svcConfig.MovementSensorName)
 		if err != nil {
 			return err
 		}
diff --git a/services/navigation/builtin/builtin_test.go b/services/navigation/builtin/builtin_test.go
index b49a16c56c9..97bfc803596 100644
--- a/services/navigation/builtin/builtin_test.go
+++ b/services/navigation/builtin/builtin_test.go
@@ -61,7 +61,7 @@ func setupNavigationServiceFromConfig(t *testing.T, configFilename string) (navi
 	test.That(t, cfg.Ensure(false, logger), test.ShouldBeNil)
 	myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
-	svc, err := navigation.FromRobot(myRobot, "test_navigation")
+	svc, err := navigation.FromProvider(myRobot, "test_navigation")
 	test.That(t, err, test.ShouldBeNil)
 	return svc, func() {
 		myRobot.Close(context.Background())
@@ -596,7 +596,7 @@ func TestNavSetUpFromFaultyConfig(t *testing.T) {
 		test.That(t, cfg.Ensure(false, logger), test.ShouldBeNil)
 		myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 		test.That(t, err, test.ShouldBeNil)
-		_, err = navigation.FromRobot(myRobot, "test_navigation")
+		_, err = navigation.FromProvider(myRobot, "test_navigation")
 		test.That(t, err, test.ShouldNotBeNil)
 		test.That(t, err.Error(), test.ShouldContainSubstring, tc.expectedError)
 	}
diff --git a/services/navigation/navigation.go b/services/navigation/navigation.go
index dc32a2b03b4..3bae4c848e7 100644
--- a/services/navigation/navigation.go
+++ b/services/navigation/navigation.go
@@ -219,11 +219,20 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named navigation service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named navigation service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
+// FromProvider is a helper for getting the named Navigation service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 func mapTypeToProtobuf(mapType MapType) servicepb.MapType {
 	switch mapType {
 	case NoMap:
diff --git a/services/slam/slam.go b/services/slam/slam.go
index 63a876b1ad5..7deffdda638 100644
--- a/services/slam/slam.go
+++ b/services/slam/slam.go
@@ -113,17 +113,28 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named SLAM service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named SLAM service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named SLAM service from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named SLAM service from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named SLAM service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // Service describes the functions that are available to the service.
 //
 // The Go SDK implements helper functions that concatenate streaming
diff --git a/services/vision/colordetector/color_detector.go b/services/vision/colordetector/color_detector.go
index d65ad163bbc..f1a2ca1df56 100644
--- a/services/vision/colordetector/color_detector.go
+++ b/services/vision/colordetector/color_detector.go
@@ -54,7 +54,7 @@ func registerColorDetector(
 		return nil, errors.Wrapf(err, "error registering color detector %q", name)
 	}
 	if conf.DefaultCamera != "" {
-		_, err = camera.FromRobot(r, conf.DefaultCamera)
+		_, err = camera.FromProvider(r, conf.DefaultCamera)
 		if err != nil {
 			return nil, errors.Errorf("could not find camera %q", conf.DefaultCamera)
 		}
diff --git a/services/vision/mlvision/ml_model.go b/services/vision/mlvision/ml_model.go
index 8d4fde77034..ebb5f00f083 100644
--- a/services/vision/mlvision/ml_model.go
+++ b/services/vision/mlvision/ml_model.go
@@ -110,7 +110,7 @@ func registerMLModelVisionService(
 	_, span := trace.StartSpan(ctx, "service::vision::registerMLModelVisionService")
 	defer span.End()
 
-	mlm, err := mlmodel.FromRobot(r, params.ModelName)
+	mlm, err := mlmodel.FromProvider(r, params.ModelName)
 	if err != nil {
 		return nil, err
 	}
@@ -214,7 +214,7 @@ func registerMLModelVisionService(
 	}
 
 	if params.DefaultCamera != "" {
-		_, err = camera.FromRobot(r, params.DefaultCamera)
+		_, err = camera.FromProvider(r, params.DefaultCamera)
 		if err != nil {
 			return nil, errors.Errorf("could not find camera %q", params.DefaultCamera)
 		}
diff --git a/services/vision/vision.go b/services/vision/vision.go
index 56dd53d4204..9d2f616ed27 100644
--- a/services/vision/vision.go
+++ b/services/vision/vision.go
@@ -42,7 +42,7 @@ func init() {
 //
 // DetectionsFromCamera example:
 //
-//	myDetectorService, err := vision.FromRobot(machine, "my_detector")
+//	myDetectorService, err := vision.FromProvider(machine, "my_detector")
 //	if err != nil {
 //		logger.Error(err)
 //		return
@@ -63,7 +63,7 @@ func init() {
 //
 //	 // add "go.viam.com/rdk/utils" to imports to use this code snippet
 //
-//		myCam, err := camera.FromRobot(machine, "my_camera")
+//		myCam, err := camera.FromProvider(machine, "my_camera")
 //		if err != nil {
 //			logger.Error(err)
 //			return
@@ -71,7 +71,7 @@ func init() {
 //		// Get an image from the camera decoded as an image.Image
 //		img, err = camera.DecodeImageFromCamera(context.Background(), utils.MimeTypeJPEG, nil, myCam)
 //
-//		myDetectorService, err := vision.FromRobot(machine, "my_detector")
+//		myDetectorService, err := vision.FromProvider(machine, "my_detector")
 //		if err != nil {
 //			logger.Error(err)
 //			return
@@ -89,7 +89,7 @@ func init() {
 //
 // ClassificationsFromCamera example:
 //
-//	myClassifierService, err := vision.FromRobot(machine, "my_classifier")
+//	myClassifierService, err := vision.FromProvider(machine, "my_classifier")
 //	if err != nil {
 //		logger.Error(err)
 //		return
@@ -109,7 +109,7 @@ func init() {
 //
 //	 // add "go.viam.com/rdk/utils" to imports to use this code snippet
 //
-//		myCam, err := camera.FromRobot(machine, "my_camera")
+//		myCam, err := camera.FromProvider(machine, "my_camera")
 //		if err != nil {
 //			logger.Error(err)
 //			return
@@ -117,7 +117,7 @@ func init() {
 //		// Get an image from the camera decoded as an image.Image
 //		img, err = camera.DecodeImageFromCamera(context.Background(), utils.MimeTypeJPEG, nil, myCam)
 //
-//		myClassifierService, err := vision.FromRobot(machine, "my_classifier")
+//		myClassifierService, err := vision.FromProvider(machine, "my_classifier")
 //		if err != nil {
 //			logger.Error(err)
 //			return
@@ -135,7 +135,7 @@ func init() {
 //
 // GetObjectPointClouds example:
 //
-//	mySegmenterService, err := vision.FromRobot(machine, "my_segmenter")
+//	mySegmenterService, err := vision.FromProvider(machine, "my_segmenter")
 //	if err != nil {
 //		logger.Error(err)
 //		return
@@ -225,16 +225,28 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named vision service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named vision service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named vision service from a collection of dependencies.
+// Deprecated: FromDependencies is a helper for getting the named vision service from a collection of dependencies.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named Vision service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // Properties returns various information regarding the current vision service,
 // specifically, which vision tasks are supported by the resource.
 type Properties struct {
diff --git a/services/vision/vision_service_builder.go b/services/vision/vision_service_builder.go
index b90fc49e431..68d1f059596 100644
--- a/services/vision/vision_service_builder.go
+++ b/services/vision/vision_service_builder.go
@@ -60,7 +60,7 @@ func NewService(
 	}
 
 	getCamera := func(cameraName string) (camera.Camera, error) {
-		return camera.FromDependencies(deps, cameraName)
+		return camera.FromProvider(deps, cameraName)
 	}
 
 	return &vizModel{
@@ -106,7 +106,7 @@ func DeprecatedNewService(
 	logger := r.Logger()
 
 	getCamera := func(cameraName string) (camera.Camera, error) {
-		return camera.FromRobot(r, cameraName)
+		return camera.FromProvider(r, cameraName)
 	}
 
 	return &vizModel{
diff --git a/services/vision/vision_test.go b/services/vision/vision_test.go
index 61a254e4f6f..6c90940340f 100644
--- a/services/vision/vision_test.go
+++ b/services/vision/vision_test.go
@@ -32,7 +32,7 @@ func TestFromRobot(t *testing.T) {
 	r.ResourceByNameFunc = func(name resource.Name) (resource.Resource, error) {
 		return svc1, nil
 	}
-	svc, err := vision.FromRobot(&r, testVisionServiceName)
+	svc, err := vision.FromProvider(&r, testVisionServiceName)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, svc, test.ShouldNotBeNil)
 	result, err := svc.Detections(context.Background(), nil, nil)
diff --git a/services/worldstatestore/world_state_store.go b/services/worldstatestore/world_state_store.go
index 1de3a45f9a9..69ebe98ba6f 100644
--- a/services/worldstatestore/world_state_store.go
+++ b/services/worldstatestore/world_state_store.go
@@ -42,17 +42,28 @@ func Named(name string) resource.Name {
 	return resource.NewName(API, name)
 }
 
-// FromRobot is a helper for getting the named world state store service from the given Robot.
+// Deprecated: FromRobot is a helper for getting the named world state store service from the given Robot.
+// Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check
 func FromRobot(r robot.Robot, name string) (Service, error) {
 	return robot.ResourceFromRobot[Service](r, Named(name))
 }
 
-// FromDependencies is a helper for getting the named world state store service from a collection of
-// dependencies.
+// Deprecated: FromDependencies is a helper for getting the named world state store service from a collection of
+// dependencies. Use FromProvider instead.
+//
+//nolint:revive // ignore exported comment check.
 func FromDependencies(deps resource.Dependencies, name string) (Service, error) {
 	return resource.FromDependencies[Service](deps, Named(name))
 }
 
+// FromProvider is a helper for getting the named World State Store service
+// from a resource Provider (collection of Dependencies or a Robot).
+func FromProvider(provider resource.Provider, name string) (Service, error) {
+	return resource.FromProvider[Service](provider, Named(name))
+}
+
 // Service describes the functions that are available to the service.
 //
 // For more information, see the [WorldStateStore service docs].
diff --git a/testutils/inject/robot.go b/testutils/inject/robot.go
index a7988262836..645a61ce08c 100644
--- a/testutils/inject/robot.go
+++ b/testutils/inject/robot.go
@@ -123,6 +123,11 @@ func (r *Robot) ResourceByName(name resource.Name) (resource.Resource, error) {
 	return r.ResourceByNameFunc(name)
 }
 
+// GetResource calls the injected ResourceByName or the real version of GetResource.
+func (r *Robot) GetResource(name resource.Name) (resource.Resource, error) {
+	return r.ResourceByName(name)
+}
+
 // RemoteNames calls the injected RemoteNames or the real version.
 func (r *Robot) RemoteNames() []string {
 	r.Mu.RLock()