diff --git a/rclrs/Cargo.toml b/rclrs/Cargo.toml
index 712f98c5..bdcd0715 100644
--- a/rclrs/Cargo.toml
+++ b/rclrs/Cargo.toml
@@ -17,12 +17,18 @@ path = "src/lib.rs"
 # Needed for dynamically finding type support libraries
 ament_rs = { version = "0.2", optional = true }
 
+# Needed to create the GoalClientStream
+async-stream = "*"
+
 # Needed for uploading documentation to docs.rs
 cfg-if = "1.0.0"
 
 # Needed for clients
 futures = "0.3"
 
+# Needed for racing futures
+futures-lite = { version = "2.6", features = ["std", "race"] }
+
 # Needed for the runtime-agnostic timeout feature
 async-std = "1.13"
 
@@ -36,6 +42,18 @@ rosidl_runtime_rs = "0.4"
 serde = { version = "1", optional = true, features = ["derive"] }
 serde-big-array = { version = "0.5.1", optional = true }
 
+# Needed to watch for the cancel signal for actions. Note that this only brings
+# in the sync module of tokio, which is a fairly light weight dependency. The
+# channels in this module work with any async runtime, so this does not lock us
+# into the tokio runtime.
+tokio = { version = "1", features = ["sync"] }
+
+# Needed to combine concurrent streams for easier ergonomics in action clients
+tokio-stream = "0.1"
+
+# Needed by action clients to generate UUID values for their goals
+uuid = { version = "1", features = ["v4"] }
+
 [dev-dependencies]
 # Needed for e.g. writing yaml files in tests
 tempfile = "3.3.0"
diff --git a/rclrs/build.rs b/rclrs/build.rs
index 28f38874..f0a3351c 100644
--- a/rclrs/build.rs
+++ b/rclrs/build.rs
@@ -116,6 +116,7 @@ fn main() {
     }
 
     println!("cargo:rustc-link-lib=dylib=rcl");
+    println!("cargo:rustc-link-lib=dylib=rcl_action");
     println!("cargo:rustc-link-lib=dylib=rcl_yaml_param_parser");
     println!("cargo:rustc-link-lib=dylib=rcutils");
     println!("cargo:rustc-link-lib=dylib=rmw");
diff --git a/rclrs/src/action.rs b/rclrs/src/action.rs
new file mode 100644
index 00000000..fd826433
--- /dev/null
+++ b/rclrs/src/action.rs
@@ -0,0 +1,355 @@
+use std::{collections::HashMap, ops::Deref};
+
+pub(crate) mod action_client;
+pub use action_client::*;
+
+pub(crate) mod action_goal_receiver;
+pub use action_goal_receiver::*;
+
+pub(crate) mod action_server;
+pub use action_server::*;
+
+use crate::{
+    rcl_bindings::*,
+    vendor::builtin_interfaces::msg::Time,
+    DropGuard,
+    log_error,
+};
+use std::fmt;
+
+
+/// A unique identifier for a goal request.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct GoalUuid(pub [u8; RCL_ACTION_UUID_SIZE]);
+
+impl GoalUuid {
+    /// A zeroed-out goal ID has a special meaning for cancellation requests
+    /// which indicates that no specific goal is being requested.
+    fn zero() -> Self {
+        Self([0; RCL_ACTION_UUID_SIZE])
+    }
+}
+
+impl fmt::Display for GoalUuid {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(f, "{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+               self.0[0],
+               self.0[1],
+               self.0[2],
+               self.0[3],
+               self.0[4],
+               self.0[5],
+               self.0[6],
+               self.0[7],
+               self.0[8],
+               self.0[9],
+               self.0[10],
+               self.0[11],
+               self.0[12],
+               self.0[13],
+               self.0[14],
+               self.0[15],
+               )
+    }
+}
+
+impl Deref for GoalUuid {
+    type Target = [u8; RCL_ACTION_UUID_SIZE];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<[u8; RCL_ACTION_UUID_SIZE]> for GoalUuid {
+    fn from(value: [u8; RCL_ACTION_UUID_SIZE]) -> Self {
+        Self(value)
+    }
+}
+
+impl From<&[u8; RCL_ACTION_UUID_SIZE]> for GoalUuid {
+    fn from(value: &[u8; RCL_ACTION_UUID_SIZE]) -> Self {
+        Self(*value)
+    }
+}
+
+/// The response returned by an [`ActionServer`]'s cancel callback when a goal is requested to be cancelled.
+#[repr(i8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum CancelResponseCode {
+    /// The server will try to cancel the goal.
+    Accept = 0,
+    /// The server will not try to cancel the goal.
+    Reject = 1,
+    /// The requested goal is unknown.
+    UnknownGoal = 2,
+    /// The goal already reached a terminal state.
+    GoalTerminated = 3,
+}
+
+impl CancelResponseCode {
+    /// Check if the cancellation was accepted.
+    pub fn is_accepted(&self) -> bool {
+        matches!(self, Self::Accept)
+    }
+}
+
+impl From<i8> for CancelResponseCode {
+    fn from(value: i8) -> Self {
+        if 0 <= value && value <= 3 {
+            unsafe {
+                // SAFETY: We have already ensured that the integer value is
+                // within the acceptable range for the enum, so transmuting is
+                // safe.
+                return std::mem::transmute(value);
+            }
+        }
+
+        log_error!(
+            "cancel_response.from",
+            "Invalid integer value being cast to a cancel response: {value}. \
+            Values should be in the range [0, 3]. We will set this as 1 (Reject).",
+        );
+        CancelResponseCode::Reject
+    }
+}
+
+/// This is returned by [`CancellationClient`] to inform whether a cancellation
+/// of a single goal was successful.
+///
+/// When a cancellation request might cancel multiple goals, [`MultiCancelResponse`]
+/// will be used.
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct CancelResponse {
+    /// What kind of response was given.
+    pub code: CancelResponseCode,
+    /// What time the response took effect according to the action server.
+    /// This will be default-initialized if no goal was cancelled.
+    pub stamp: Option<Time>,
+}
+
+impl CancelResponse {
+    /// Check whether the request was accepted.
+    pub fn is_accepted(&self) -> bool {
+        self.code.is_accepted()
+    }
+}
+
+/// This is returned by [`ActionClientState::cancel_all_goals`] and
+/// [`ActionClientState::cancel_goals_prior_to`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct MultiCancelResponse {
+    /// What kind of response was given.
+    pub code: CancelResponseCode,
+    /// The time stamp that the response took effect for each goal that is being
+    /// cancelled. If the request was not accepted then this may be empty.
+    pub stamps: HashMap<GoalUuid, Time>,
+}
+
+impl MultiCancelResponse {
+    /// Check whether the request was accepted.
+    pub fn is_accepted(&self) -> bool {
+        self.code.is_accepted()
+    }
+}
+
+/// Values defined by `action_msgs/msg/GoalStatus`
+#[repr(i8)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub enum GoalStatusCode {
+    /// The goal status has never been initialized. This likely means it has not
+    /// yet been accepted.
+    Unknown = 0,
+    /// The goal was accepted by the action server.
+    Accepted = 1,
+    /// The goal is being executed by the action server.
+    Executing = 2,
+    /// The action server has accepting cancelling the goal and is in the process
+    /// of cancelling it.
+    Cancelling = 3,
+    /// The action server has successfully reached the goal.
+    Succeeded = 4,
+    /// The action server has finished cancelling the goal.
+    Cancelled = 5,
+    /// The action server has aborted the goal. This suggests an error happened
+    /// during execution or cancelling.
+    Aborted = 6,
+}
+
+impl From<i8> for GoalStatusCode {
+    fn from(value: i8) -> Self {
+        if 0 <= value && value <= 6 {
+            unsafe {
+                // SAFETY: We have already ensured that the integer value is
+                // within the acceptable range for the enum, so transmuting is
+                // safe.
+                return std::mem::transmute(value);
+            }
+        }
+
+        log_error!(
+            "goal_status_code.from",
+            "Invalid integer value being cast to a goal status code: {value}. \
+            Values should be in the range [0, 6]. We will set this as 0 (Unknown).",
+        );
+        GoalStatusCode::Unknown
+    }
+}
+
+/// A status update for a goal. Includes the status code, the goal uuid, and the
+/// timestamp of when the status was set by the action server.
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct GoalStatus {
+    /// The status code describing what status was set by the action server.
+    pub code: GoalStatusCode,
+    /// The uuid of the goal whose status was updated.
+    pub goal_id: GoalUuid,
+    /// Time that the status was set by the action server. The time measured by
+    /// the action server might not align with the time measured by the action
+    /// client, so care should be taken when using this time value.
+    pub stamp: Time,
+}
+
+fn empty_goal_status_array() -> DropGuard<rcl_action_goal_status_array_t> {
+    DropGuard::new(
+        unsafe {
+            // SAFETY: No preconditions
+            let mut array = rcl_action_get_zero_initialized_goal_status_array();
+            array.allocator = rcutils_get_default_allocator();
+            array
+        },
+        |mut goal_statuses| unsafe {
+            // SAFETY: The goal_status array is either zero-initialized and empty or populated by
+            // `rcl_action_get_goal_status_array`. In either case, it can be safely finalized.
+            rcl_action_goal_status_array_fini(&mut goal_statuses);
+        }
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    use example_interfaces::action::{Fibonacci, Fibonacci_Goal, Fibonacci_Result, Fibonacci_Feedback};
+    use tokio::sync::mpsc::unbounded_channel;
+    use futures::StreamExt;
+    use std::time::Duration;
+
+    #[test]
+    fn test_action_success() {
+        let mut executor = Context::default().create_basic_executor();
+
+        let node = executor.create_node(&format!("test_action_success_{}", line!())).unwrap();
+        let action_name = format!("test_action_success_{}_action", line!());
+        let _action_server = node.create_action_server(
+            &action_name,
+            fibonacci_action,
+        ).unwrap();
+
+        let client = node.create_action_client::<Fibonacci>(&action_name).unwrap();
+
+        let order_10_sequence = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+
+        let request = client.request_goal(Fibonacci_Goal {
+            order: 10,
+        });
+
+        let promise = executor.commands().run(async move {
+            let mut goal_client_stream = request.await.unwrap().stream();
+            let mut expected_feedback_len = 0;
+            while let Some(event) = goal_client_stream.next().await {
+                match event {
+                    GoalEvent::Feedback(feedback) => {
+                        expected_feedback_len += 1;
+                        assert_eq!(feedback.sequence.len(), expected_feedback_len);
+                    }
+                    GoalEvent::Status(s) => {
+                        assert!(
+                            matches!(s.code, GoalStatusCode::Unknown | GoalStatusCode::Executing | GoalStatusCode::Succeeded),
+                            "Actual code: {:?}",
+                            s.code,
+                        );
+                    }
+                    GoalEvent::Result((status, result)) => {
+                        assert_eq!(status, GoalStatusCode::Succeeded);
+                        assert_eq!(result.sequence, order_10_sequence);
+                        return;
+                    }
+                }
+            }
+        });
+
+        executor.spin(SpinOptions::default().until_promise_resolved(promise));
+
+        let request = client.request_goal(Fibonacci_Goal {
+            order: 10,
+        });
+
+        let promise = executor.commands().run(async move {
+            let (status, result) = request.await.unwrap().result.await;
+            assert_eq!(status, GoalStatusCode::Succeeded);
+            assert_eq!(result.sequence, order_10_sequence);
+        });
+
+        executor.spin(SpinOptions::default().until_promise_resolved(promise));
+    }
+
+    async fn fibonacci_action(handle: RequestedGoal<Fibonacci>) -> TerminatedGoal {
+        let goal_order = handle.goal().order;
+        if goal_order < 0 {
+            return handle.reject();
+        }
+
+        let mut result = Fibonacci_Result::default();
+
+        let executing = match handle.accept().begin() {
+            BeginAcceptedGoal::Execute(executing) => executing,
+            BeginAcceptedGoal::Cancel(cancelling) => {
+                return cancelling.cancelled_with(result);
+            }
+        };
+
+        let (sender, mut receiver) = unbounded_channel();
+        std::thread::spawn(move || {
+
+            let mut previous = 0;
+            let mut current = 1;
+
+            for _ in 0..goal_order {
+                if let Err(_) = sender.send(current) {
+                    // The action has been cancelled early, so just drop this thread.
+                    return;
+                }
+
+                let next = previous + current;
+                previous = current;
+                current = next;
+                std::thread::sleep(Duration::from_micros(10));
+            }
+        });
+
+        let mut sequence = Vec::new();
+        loop {
+            match executing.unless_cancel_requested(receiver.recv()).await {
+                Ok(Some(next)) => {
+                    // We have a new item in the sequence
+                    sequence.push(next);
+                    executing.publish_feedback(
+                        Fibonacci_Feedback {
+                            sequence: sequence.clone(),
+                        }
+                    );
+                }
+                Ok(None) => {
+                    // The sequence has finished
+                    result.sequence = sequence;
+                    return executing.succeeded_with(result);
+                }
+                Err(_) => {
+                    // The action has been cancelled
+                    result.sequence = sequence;
+                    return executing.begin_cancelling().cancelled_with(result);
+                }
+            }
+        }
+    }
+}
diff --git a/rclrs/src/action/action_client.rs b/rclrs/src/action/action_client.rs
new file mode 100644
index 00000000..72fb54dd
--- /dev/null
+++ b/rclrs/src/action/action_client.rs
@@ -0,0 +1,897 @@
+use crate::{
+    rcl_bindings::*,
+    vendor::{
+        action_msgs::{msg::GoalInfo, srv::{CancelGoal_Response, CancelGoal_Request}},
+        builtin_interfaces::msg::Time,
+        unique_identifier_msgs::msg::UUID,
+    },
+    log_warn,
+    CancelResponse, CancelResponseCode, DropGuard, GoalStatus, GoalStatusCode, GoalUuid,
+    MultiCancelResponse, Node, NodeHandle, QoSProfile, RclrsError, RclPrimitive,
+    RclPrimitiveHandle, RclPrimitiveKind, ReadyKind, TakeFailedAsNone, ToResult,
+    Waitable, WaitableLifecycle, ENTITY_LIFECYCLE_MUTEX,
+};
+use super::empty_goal_status_array;
+use std::{
+    any::Any,
+    borrow::{Borrow, Cow},
+    collections::HashMap,
+    ffi::CString,
+    sync::{Arc, Mutex, MutexGuard, Weak},
+};
+use tokio::sync::{
+    watch::Sender as WatchSender,
+    mpsc::{unbounded_channel, UnboundedSender},
+    oneshot::{channel as oneshot_channel, Sender},
+};
+use rosidl_runtime_rs::{Action, Message, RmwGoalResponse, RmwFeedbackMessage, RmwResultResponse};
+
+mod cancellation_client;
+pub use cancellation_client::*;
+
+mod feedback_client;
+pub use feedback_client::*;
+
+mod goal_client;
+pub use goal_client::*;
+
+mod status_client;
+pub use status_client::*;
+
+mod result_client;
+pub use result_client::*;
+
+mod requested_goal_client;
+pub use requested_goal_client::*;
+
+/// `ActionClientOptions` are used by [`Node::create_action_client`][1] to initialize an
+/// [`ActionClient`].
+///
+/// [1]: crate::Node::create_action_client
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct ActionClientOptions<'a> {
+    /// The name of the action that this client will send requests to
+    pub action_name: &'a str,
+    /// The quality of service profile for the goal service
+    pub goal_service_qos: QoSProfile,
+    /// The quality of service profile for the result service
+    pub result_service_qos: QoSProfile,
+    /// The quality of service profile for the cancel service
+    pub cancel_service_qos: QoSProfile,
+    /// The quality of service profile for the feedback topic
+    pub feedback_topic_qos: QoSProfile,
+    /// The quality of service profile for the status topic
+    pub status_topic_qos: QoSProfile,
+}
+
+impl<'a> ActionClientOptions<'a> {
+    /// Initialize a new [`ActionClientOptions`] with default settings.
+    pub fn new(action_name: &'a str) -> Self {
+        Self {
+            action_name,
+            goal_service_qos: QoSProfile::services_default(),
+            result_service_qos: QoSProfile::services_default(),
+            cancel_service_qos: QoSProfile::services_default(),
+            feedback_topic_qos: QoSProfile::topics_default(),
+            status_topic_qos: QoSProfile::action_status_default(),
+        }
+    }
+}
+
+impl<'a, T: Borrow<str> + ?Sized + 'a> From<&'a T> for ActionClientOptions<'a> {
+    fn from(value: &'a T) -> Self {
+        Self::new(value.borrow())
+    }
+}
+
+/// Main class responsible for sending goals to a ROS action server.
+///
+/// Create a client using [`Node::create_action_client`][1].
+///
+/// Receiving feedback and results requires the node's executor to [spin][2].
+///
+/// [1]: crate::NodeState::create_action_client
+/// [2]: crate::spin
+pub type ActionClient<A> = Arc<ActionClientState<A>>;
+
+/// The inner state of an [`ActionClient`].
+///
+/// This is public so that you can choose to create a [`Weak`][1] reference to it
+/// if you want to be able to refer to an [`ActionClient`] in a non-owning way. It is
+/// generally recommended to manage the `ActionClientState` inside of an [`Arc`],
+/// and [`ActionClient`] is provided as a convenience alias for that.
+///
+/// The public API of the [`ActionClient`] type is implemented via `ActionClientState`.
+///
+/// [1]: std::sync::Weak
+pub struct ActionClientState<A: Action> {
+    board: Arc<ActionClientGoalBoard<A>>,
+    #[allow(unused)]
+    lifecycle: WaitableLifecycle,
+}
+
+impl<A: Action> ActionClientState<A> {
+    /// Request the action server to execute a goal. You will receive a
+    /// [`RequestedGoalClient`] which you can use to wait for the reply from the
+    /// action server that indicates whether the goal was accepted.
+    ///
+    /// If the goal is accepted, the [`RequestedGoalClient`] will yield a
+    /// [`GoalClient`]. If the goal was rejected by the action server then it will
+    /// yield a [`None`]. The easiest way to get the response is to use `.await`
+    /// in an async function.
+    ///
+    /// In the unlikely event of an error at the rcl layer, this will panic.
+    /// Use [`Self::try_request_goal`] to handle errors without panicking.
+    pub fn request_goal(self: &Arc<Self>, goal: A::Goal) -> RequestedGoalClient<A> {
+        self.try_request_goal(goal).unwrap()
+    }
+
+    /// A version of [`Self::request_goal`] which allows you to handle any errors
+    /// that may happen at the rcl layer.
+    pub fn try_request_goal(
+        self: &Arc<Self>,
+        goal: A::Goal,
+    ) -> Result<RequestedGoalClient<A>, RclrsError> {
+        self.board.request_goal(self, goal)
+    }
+
+    /// Get a client to receive feedback for a specific goal.
+    pub fn receive_feedback(self: &Arc<Self>, goal_id: GoalUuid) -> FeedbackClient<A> {
+        self.board.create_feedback_client(self, goal_id)
+    }
+
+    /// Get a client to receive all status updates for a specific goal. If you
+    /// only care about the latest status update, consider using [`Self::watch_status`]
+    /// instead.
+    pub fn receive_status(self: &Arc<Self>, goal_id: GoalUuid) -> StatusClient<A> {
+        self.board.create_status_client(self, goal_id)
+    }
+
+    /// Get a client to watch the status of a specific goal.
+    pub fn watch_status(self: &Arc<Self>, goal_id: GoalUuid) -> StatusWatcher<A> {
+        self.board.create_status_watcher(self, goal_id)
+    }
+
+    /// Ask to receive the result of a goal. You can `.await` the [`ResultClient`]
+    /// to get the result asynchronously.
+    ///
+    /// In the unlikely event of an error at the rcl layer, this will panic.
+    /// Use [`Self::try_receive_result`] to catch errors without panicking.
+    pub fn receive_result(self: &Arc<Self>, goal_id: GoalUuid) -> ResultClient<A> {
+        self.try_receive_result(goal_id).unwrap()
+    }
+
+    /// Try to receive the result of a goal. If an rcl error happens, you can
+    /// handle it.
+    pub fn try_receive_result(self: &Arc<Self>, goal_id: GoalUuid) -> Result<ResultClient<A>, RclrsError> {
+        self.board.request_result(Arc::clone(self), goal_id)
+    }
+
+    /// Ask the action server to cancel a single goal.
+    ///
+    /// In the unlikely event of an error at the rcl layer, this will panic.
+    /// Use [`Self::try_cancel_goal`] to handle errors without panicking.
+    pub fn cancel_goal(self: &Arc<Self>, goal_id: GoalUuid) -> CancelResponseClient<A> {
+        self.try_cancel_goal(goal_id).unwrap()
+    }
+
+    /// Try to ask the action server to cancel a single goal. If an rcl error
+    /// happens, you can handle it.
+    pub fn try_cancel_goal(self: &Arc<Self>, goal_id: GoalUuid) -> Result<CancelResponseClient<A>, RclrsError> {
+        self.board.request_single_cancel(self, goal_id)
+    }
+
+    /// Ask the action server to cancel all of its goals.
+    ///
+    /// In the unlikely event of an error at the rcl layer, this will panic.
+    /// Use [`Self::try_cancel_all_goals`] to catch errors without panicking.
+    pub fn cancel_all_goals(self: &Arc<Self>) -> MultiCancelResponseClient<A> {
+        self.try_cancel_all_goals().unwrap()
+    }
+
+    /// Try to ask the action server to cancel all of its goals. If an rcl error
+    /// happens, you can handle it.
+    pub fn try_cancel_all_goals(self: &Arc<Self>) -> Result<MultiCancelResponseClient<A>, RclrsError> {
+        self.board.request_multi_cancel(self, None)
+    }
+
+    /// Ask the action server to cancel all of its goals that started before a
+    /// specified time stamp.
+    ///
+    /// <div class="warning">Make sure the time stamp is based on the time according to the action server.</div>
+    ///
+    /// In the unlikely event of an error at the rcl layer, this will panic.
+    /// Use [`Self::try_cancel_goals_prior_to`] to catch errors without panicking.
+    pub fn cancel_goals_prior_to(self: &Arc<Self>, time: Time) -> MultiCancelResponseClient<A> {
+        self.try_cancel_goals_prior_to(time).unwrap()
+    }
+
+    /// Try to ask the action server to cancel all of its goals that started before
+    /// a specified time stamp. If an rcl error happens, you can handle it.
+    ///
+    /// <div class="warning">Make sure the time stamp is based on the time according to the action server.</div>
+    pub fn try_cancel_goals_prior_to(self: &Arc<Self>, time: Time) -> Result<MultiCancelResponseClient<A>, RclrsError> {
+        self.board.request_multi_cancel(self, Some(time))
+    }
+
+    /// Creates a new action client.
+    pub(crate) fn create<'a>(
+        node: &Node,
+        options: impl Into<ActionClientOptions<'a>>,
+    ) -> Result<Arc<Self>, RclrsError> {
+        let options = options.into();
+        // SAFETY: Getting a zero-initialized value is always safe.
+        let mut rcl_action_client = unsafe { rcl_action_get_zero_initialized_client() };
+        let type_support = A::get_type_support() as *const rosidl_action_type_support_t;
+        let action_name_c_string =
+            CString::new(options.action_name).map_err(|err| RclrsError::StringContainsNul {
+                err,
+                s: options.action_name.into(),
+            })?;
+
+        // SAFETY: No preconditions for this function.
+        let action_client_options = unsafe { rcl_action_client_get_default_options() };
+
+        {
+            let mut rcl_node = node.handle().rcl_node.lock().unwrap();
+            let _lifecycle_lock = ENTITY_LIFECYCLE_MUTEX.lock().unwrap();
+
+            // SAFETY:
+            // * The rcl_action_client was zero-initialized as expected by this function.
+            // * The rcl_node is kept alive by the NodeHandle because it is a dependency of the action client.
+            // * The action name and the options are copied by this function, so they can be dropped
+            //   afterwards.
+            // * The entity lifecycle mutex is locked to protect against the risk of global
+            //   variables in the rmw implementation being unsafely modified during initialization.
+            unsafe {
+                rcl_action_client_init(
+                    &mut rcl_action_client,
+                    &mut *rcl_node,
+                    type_support,
+                    action_name_c_string.as_ptr(),
+                    &action_client_options,
+                )
+                .ok()?;
+            }
+        }
+
+        let handle = Arc::new(ActionClientHandle {
+            rcl_action_client: Mutex::new(rcl_action_client),
+            node_handle: Arc::clone(&node.handle()),
+        });
+
+        let board = Arc::new(ActionClientGoalBoard {
+            handle,
+            node: Arc::clone(node),
+            pending_goal_clients: Default::default(),
+            feedback_senders: Default::default(),
+            status_senders: Default::default(),
+            status_posters: Default::default(),
+            cancel_response_senders: Default::default(),
+            result_senders: Default::default(),
+            client: Default::default(),
+        });
+
+        let async_commands = node.commands().async_worker_commands();
+        let (waitable, lifecycle) = Waitable::new(
+            Box::new(ActionClientExecutable {
+                board: Arc::clone(&board),
+            }),
+            Some(Arc::clone(async_commands.get_guard_condition())),
+        );
+        async_commands.add_to_wait_set(waitable);
+
+        let client = Arc::new(Self { board, lifecycle });
+        *client.board.client.lock().unwrap() = Arc::downgrade(&client);
+        Ok(client)
+    }
+}
+
+struct ActionClientGoalBoard<A: Action> {
+    pending_goal_clients: Mutex<HashMap<i64, PendingGoalClient<A>>>,
+    feedback_senders: Mutex<HashMap<GoalUuid, Vec<UnboundedSender<A::Feedback>>>>,
+    status_senders: Mutex<HashMap<GoalUuid, Vec<UnboundedSender<GoalStatus>>>>,
+    status_posters: Mutex<HashMap<GoalUuid, WatchSender<GoalStatus>>>,
+    cancel_response_senders: Mutex<HashMap<i64, CancelResponseSender>>,
+    result_senders: Mutex<HashMap<i64, Sender<(GoalStatusCode, A::Result)>>>,
+    handle: Arc<ActionClientHandle>,
+    client: Mutex<Weak<ActionClientState<A>>>,
+    /// Ensure the parent node remains alive as long as the subscription is held.
+    /// This implementation will change in the future.
+    #[allow(unused)]
+    node: Node,
+}
+
+enum CancelResponseSender {
+    /// Used when only a single goal is being cancelled
+    SingleGoalCancel(Sender<CancelResponse>),
+    /// Used when multiple goals are being cancelled
+    MultiGoalCancel(Sender<MultiCancelResponse>),
+}
+
+impl<A: Action> ActionClientGoalBoard<A> {
+    fn execute_feedback(&self) -> Result<(), RclrsError> {
+        let Some(feedback_rmw) = self.handle.take_feedback::<A>().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let (goal_uuid, feedback) = A::split_feedback_message(feedback_rmw);
+        let feedback: A::Feedback = Message::from_rmw_message(feedback);
+        if let Some(senders) = self.feedback_senders.lock().unwrap().get(&GoalUuid(goal_uuid)) {
+            // Avoid making any unnecessary clones
+            for sender in senders.iter().take(senders.len() - 1) {
+                let _ =sender.send(feedback.clone());
+            }
+
+            if let Some(last_sender) = senders.last() {
+                let _ = last_sender.send(feedback);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn execute_status(&self) -> Result<(), RclrsError> {
+        let Some(goal_statuses) = self.handle.take_status().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let all_status_senders = self.status_senders.lock().unwrap();
+        let all_status_watchers = self.status_posters.lock().unwrap();
+        for index in 0..goal_statuses.msg.status_list.size {
+            let rcl_status = unsafe {
+                &*goal_statuses.msg.status_list.data.add(index)
+            };
+
+            let stamp = &rcl_status.goal_info.stamp;
+            let goal_id = GoalUuid(rcl_status.goal_info.goal_id.uuid);
+            let status = GoalStatus {
+                goal_id,
+                code: rcl_status.status.into(),
+                stamp: Time { sec: stamp.sec, nanosec: stamp.nanosec },
+            };
+
+            if let Some(senders) = all_status_senders.get(&goal_id) {
+                for sender in senders {
+                    let _ = sender.send(status.clone());
+                }
+            }
+
+            if let Some(watcher) = all_status_watchers.get(&goal_id) {
+                watcher.send_modify(|watched_status| *watched_status = status);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn execute_goal_response(&self) -> Result<(), RclrsError> {
+        let Some(client) = self.client.lock().unwrap().upgrade() else {
+            // The action client has already expired which means the user is not
+            // waiting for this response any longer. We can just discard it.
+            return Ok(());
+        };
+
+        let Some((response_rmw, header)) = self.handle.take_goal_response::<A>().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let accepted = A::get_goal_response_accepted(&response_rmw);
+        let stamp = A::get_goal_response_stamp(&response_rmw);
+
+        let Some(pending) = self.pending_goal_clients.lock().unwrap().remove(&header.sequence_number) else {
+            // This suggests that the RequestedGoalClient was dropped before the result arrived.
+            return Ok(());
+        };
+
+        if accepted {
+            let _ = pending.sender.send(
+                Some(GoalClient {
+                    feedback: pending.feedback,
+                    status: pending.status,
+                    result: self.request_result(Arc::clone(&client), pending.goal_id)?,
+                    cancellation: CancellationClient::new(client, pending.goal_id),
+                    stamp: Time { sec: stamp.0, nanosec: stamp.1 },
+                })
+            );
+        } else {
+            let _ = pending.sender.send(None);
+        }
+
+        Ok(())
+    }
+
+    fn execute_cancel_response(&self) -> Result<(), RclrsError> {
+        let Some((result, header)) = self.handle.take_cancel_response().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let seq = header.sequence_number;
+        let Some(sender) = self.cancel_response_senders.lock().unwrap().remove(&seq) else {
+            // If the sender doesn't exist, most likely it means the CancelResponseClient
+            // has been dropped.
+            return Ok(());
+        };
+
+        let code: CancelResponseCode = result.return_code.into();
+        match sender {
+            CancelResponseSender::SingleGoalCancel(sender) => {
+                if result.goals_canceling.len() > 1 {
+                    log_warn!(
+                        "action_client.execute_cancel_response",
+                        "Multiple goals were cancelled when only one was expected. \
+                        This may indicate a client library implementation bug.",
+                    );
+                }
+
+                // Use the first goal's info to get the time stamp. We should
+                // only be expecting one goal to be cancelled anyway.
+                let stamp = result
+                    .goals_canceling
+                    .first()
+                    .map(|g| g.stamp.clone());
+                let _ = sender.send(CancelResponse { code, stamp });
+            }
+            CancelResponseSender::MultiGoalCancel(sender) => {
+                let mut stamps = HashMap::default();
+                for info in result.goals_canceling {
+                    stamps.insert(GoalUuid(info.goal_id.uuid), info.stamp);
+                }
+                let _ = sender.send(MultiCancelResponse { code, stamps });
+            }
+        }
+
+        Ok(())
+    }
+
+    fn execute_result_response(&self) -> Result<(), RclrsError> {
+        let Some((result_rmw, header)) = self.handle.take_result_response::<A>().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let (status, result) = A::split_result_response(result_rmw);
+        let status_code = status.into();
+
+        let seq = header.sequence_number;
+        let Some(sender) = self.result_senders.lock().unwrap().remove(&seq) else {
+            // If the sender doesn't exist, most likely it means the ResultClient
+            // has been dropped.
+            return Ok(());
+        };
+
+
+        let result = Message::from_rmw_message(result);
+        let _ = sender.send((status_code, result));
+        Ok(())
+    }
+
+    fn request_goal(
+        &self,
+        client: &ActionClient<A>,
+        goal: A::Goal,
+    ) -> Result<RequestedGoalClient<A>, RclrsError> {
+        let goal_id: GoalUuid = uuid::Uuid::new_v4().as_bytes().into();
+        let goal_rmw = <A::Goal as Message>::into_rmw_message(Cow::Owned(goal)).into_owned();
+        let request = A::create_goal_request(&*goal_id, goal_rmw);
+
+        let mut seq: i64 = 0;
+        unsafe {
+            let handle = self.handle.lock();
+            rcl_action_send_goal_request(
+                &*handle,
+                &request as *const _ as *const _,
+                &mut seq,
+            )
+        }
+        .ok()?;
+
+        let (sender, receiver) = oneshot_channel();
+        let feedback = self.create_feedback_client(client, goal_id);
+        let status = self.create_status_watcher(client, goal_id);
+
+        self.pending_goal_clients.lock().unwrap().insert(
+            seq,
+            PendingGoalClient { goal_id, feedback, status, sender },
+        );
+
+        Ok(RequestedGoalClient::new(
+            goal_id,
+            receiver,
+            GoalClientLifecycle {
+                kind: GoalClientKind::Request(seq),
+                client: Arc::clone(client),
+            },
+        ))
+    }
+
+    fn create_feedback_client(
+        &self,
+        client: &ActionClient<A>,
+        goal_id: GoalUuid,
+    ) -> FeedbackClient<A> {
+        let (sender, receiver) = unbounded_channel();
+        self.feedback_senders.lock().unwrap().entry(goal_id).or_default().push(sender);
+        FeedbackClient::new(
+            receiver,
+            goal_id,
+            GoalClientLifecycle {
+                kind: GoalClientKind::Feedback(goal_id),
+                client: Arc::clone(client),
+            },
+        )
+    }
+
+    fn create_status_client(
+        &self,
+        client: &ActionClient<A>,
+        goal_id: GoalUuid,
+    ) -> StatusClient<A> {
+        let (sender, receiver) = unbounded_channel();
+        self.status_senders.lock().unwrap().entry(goal_id).or_default().push(sender);
+        StatusClient::new(
+            receiver,
+            goal_id,
+            GoalClientLifecycle {
+                kind: GoalClientKind::Status(goal_id),
+                client: Arc::clone(client),
+            },
+        )
+    }
+
+    fn create_status_watcher(
+        &self,
+        client: &ActionClient<A>,
+        goal_id: GoalUuid,
+    ) -> StatusWatcher<A> {
+        let watcher = self
+            .status_posters
+            .lock()
+            .unwrap()
+            .entry(goal_id)
+            .or_insert_with(||
+                WatchSender::new(GoalStatus {
+                    code: GoalStatusCode::Unknown,
+                    goal_id,
+                    stamp: Time { sec: 0, nanosec: 0 },
+                })
+            )
+            .subscribe();
+
+        StatusWatcher::new(
+            watcher,
+            Arc::new(GoalClientLifecycle {
+                kind: GoalClientKind::Status(goal_id),
+                client: Arc::clone(client),
+            }),
+        )
+    }
+
+    fn request_single_cancel(
+        &self,
+        client: &ActionClient<A>,
+        goal_id: GoalUuid,
+    ) -> Result<CancelResponseClient<A>, RclrsError> {
+        let seq = self.handle.send_cancel_goal(goal_id, Time { sec: 0, nanosec: 0 })?;
+        let (sender, receiver) = oneshot_channel();
+        self.cancel_response_senders.lock().unwrap().insert(seq, CancelResponseSender::SingleGoalCancel(sender));
+        Ok(CancelResponseClient::new(
+            receiver,
+            GoalClientLifecycle {
+                kind: GoalClientKind::CancelResponse(seq),
+                client: Arc::clone(client),
+            },
+        ))
+    }
+
+    fn request_multi_cancel(
+        &self,
+        client: &ActionClient<A>,
+        stamp: Option<Time>,
+    ) -> Result<MultiCancelResponseClient<A>, RclrsError> {
+        let goal_id = GoalUuid::zero();
+        let stamp = stamp.unwrap_or(Time { sec: 0, nanosec: 0 });
+        let seq = self.handle.send_cancel_goal(goal_id, stamp)?;
+        let (sender, receiver) = oneshot_channel();
+        self.cancel_response_senders.lock().unwrap().insert(seq, CancelResponseSender::MultiGoalCancel(sender));
+        Ok(MultiCancelResponseClient::new(
+            receiver,
+            GoalClientLifecycle {
+                kind: GoalClientKind::CancelResponse(seq),
+                client: Arc::clone(client),
+            },
+        ))
+    }
+
+    fn request_result(
+        &self,
+        client: ActionClient<A>,
+        goal_id: GoalUuid,
+    ) -> Result<ResultClient<A>, RclrsError> {
+        let request_rmw = A::create_result_request(&*goal_id);
+        let mut seq: i64 = 0;
+        unsafe {
+            let handle = self.handle.lock();
+            rcl_action_send_result_request(
+                &*handle,
+                &request_rmw as *const _ as *const _,
+                &mut seq,
+            )
+        }
+        .ok()?;
+
+        let (sender, receiver) = oneshot_channel();
+        self.result_senders.lock().unwrap().insert(seq, sender);
+        let lifecycle = GoalClientLifecycle {
+            client,
+            kind: GoalClientKind::Result(seq),
+        };
+        Ok(ResultClient::new(receiver, lifecycle))
+    }
+}
+
+/// This struct represents a goal client that has not been accepted yet. We
+/// create the feedback and status channels before sending the request just in
+/// case the action server sends updates for the goal before we process that the
+/// goal was accepted. This ensures that no information can be lost by accident.
+struct PendingGoalClient<A: Action> {
+    goal_id: GoalUuid,
+    feedback: FeedbackClient<A>,
+    status: StatusWatcher<A>,
+    sender: Sender<Option<GoalClient<A>>>,
+}
+
+/// Once all of the constituent clients for the goal are dropped, this will
+/// remove the [`GoalClientSender`][super::GoalClientSender] from the goal
+/// board.
+///
+/// This also ensures that the action client remains alive for as long as any
+/// of its constituent clients are using it.
+struct GoalClientLifecycle<A: Action> {
+    kind: GoalClientKind,
+    client: ActionClient<A>,
+}
+
+enum GoalClientKind {
+    Request(i64),
+    Feedback(GoalUuid),
+    Status(GoalUuid),
+    Result(i64),
+    CancelResponse(i64),
+}
+
+impl<A: Action> Drop for GoalClientLifecycle<A> {
+    fn drop(&mut self) {
+        match self.kind {
+            GoalClientKind::Request(seq) => {
+                let mut all_pending_goal_clients = self.client.board.pending_goal_clients.lock().unwrap();
+                all_pending_goal_clients.remove(&seq);
+            }
+            GoalClientKind::Feedback(goal_uuid) => {
+                let mut all_feedback_senders = self.client.board.feedback_senders.lock().unwrap();
+
+                let mut is_empty = false;
+                if let Some(senders) = all_feedback_senders.get_mut(&goal_uuid) {
+                    senders.retain(|sender| !sender.is_closed());
+                    is_empty = senders.is_empty();
+                }
+                if is_empty {
+                    all_feedback_senders.remove(&goal_uuid);
+                }
+            }
+            GoalClientKind::Status(goal_uuid) => {
+                {
+                    let mut all_status_senders = self.client.board.status_senders.lock().unwrap();
+                    let mut is_empty = false;
+                    if let Some(senders) = all_status_senders.get_mut(&goal_uuid) {
+                        senders.retain(|sender| !sender.is_closed());
+                        is_empty = senders.is_empty();
+                    }
+                    if is_empty {
+                        all_status_senders.remove(&goal_uuid);
+                    }
+                }
+
+                {
+                    let mut all_status_posters = self.client.board.status_posters.lock().unwrap();
+                    let remove = all_status_posters.get(&goal_uuid).is_some_and(|sender| sender.is_closed());
+                    if remove {
+                        all_status_posters.remove(&goal_uuid);
+                    }
+                }
+            }
+            GoalClientKind::CancelResponse(seq) => {
+                let mut all_cancel_response_senders = self.client.board.cancel_response_senders.lock().unwrap();
+                all_cancel_response_senders.remove(&seq);
+            }
+            GoalClientKind::Result(seq) => {
+                let mut all_result_senders = self.client.board.result_senders.lock().unwrap();
+                all_result_senders.remove(&seq);
+            }
+        }
+    }
+}
+
+struct ActionClientExecutable<A: Action> {
+    board: Arc<ActionClientGoalBoard<A>>,
+}
+
+impl<A: Action> RclPrimitive for ActionClientExecutable<A> {
+    unsafe fn execute(&mut self, ready: ReadyKind, _: &mut dyn Any) -> Result<(), RclrsError> {
+        let ready = ready.for_action_client()?;
+
+        if ready.goal_response {
+            self.board.execute_goal_response()?;
+        }
+
+        if ready.feedback {
+            self.board.execute_feedback()?;
+        }
+
+        if ready.status {
+            self.board.execute_status()?;
+        }
+
+        if ready.cancel_response {
+            self.board.execute_cancel_response()?;
+        }
+
+        if ready.result_response {
+            self.board.execute_result_response()?;
+        }
+
+        Ok(())
+    }
+
+    fn kind(&self) -> RclPrimitiveKind {
+        RclPrimitiveKind::ActionClient
+    }
+
+    fn handle(&self) -> crate::RclPrimitiveHandle {
+        RclPrimitiveHandle::ActionClient(self.board.handle.lock())
+    }
+}
+
+/// Manage the lifecycle of an `rcl_action_client_t`, including managing its dependencies
+/// on `rcl_node_t` and `rcl_context_t` by ensuring that these dependencies are
+/// [dropped after][1] the `rcl_action_client_t`.
+///
+/// [1]: <https://doc.rust-lang.org/reference/destructors.html>
+pub struct ActionClientHandle {
+    rcl_action_client: Mutex<rcl_action_client_t>,
+    node_handle: Arc<NodeHandle>,
+}
+
+impl ActionClientHandle {
+    fn lock(&self) -> MutexGuard<rcl_action_client_t> {
+        self.rcl_action_client.lock().unwrap()
+    }
+
+    fn take_goal_response<A: Action>(&self) -> Result<(RmwGoalResponse<A>, rmw_request_id_t), RclrsError> {
+        let mut response_rmw = RmwGoalResponse::<A>::default();
+        let mut response_header = rmw_request_id_t {
+            writer_guid: [0; RCL_ACTION_UUID_SIZE],
+            sequence_number: 0,
+        };
+
+        unsafe {
+            let handle = self.lock();
+            rcl_action_take_goal_response(
+                &*handle,
+                &mut response_header,
+                &mut response_rmw as *mut _ as *mut _,
+            )
+        }
+        .ok()?;
+
+        Ok((response_rmw, response_header))
+    }
+
+    fn take_feedback<A: Action>(&self) -> Result<RmwFeedbackMessage<A>, RclrsError> {
+        let mut feedback_rmw = RmwFeedbackMessage::<A>::default();
+        unsafe {
+            let handle = self.lock();
+            rcl_action_take_feedback(&*handle, &mut feedback_rmw as *mut _ as *mut _)
+        }
+        .ok()?;
+
+        Ok(feedback_rmw)
+    }
+
+    fn take_status(&self) -> Result<DropGuard<rcl_action_goal_status_array_t>, RclrsError> {
+        let mut goal_statuses = empty_goal_status_array();
+        unsafe {
+            let handle = self.lock();
+            rcl_action_take_status(&*handle, &mut *goal_statuses as *mut _ as *mut _)
+        }
+        .ok()?;
+
+        Ok(goal_statuses)
+    }
+
+    fn take_result_response<A: Action>(&self) -> Result<(RmwResultResponse<A>, rmw_request_id_t), RclrsError> {
+        let mut result_rmw = RmwResultResponse::<A>::default();
+        let mut response_header = rmw_request_id_t {
+            writer_guid: [0; RCL_ACTION_UUID_SIZE],
+            sequence_number: 0,
+        };
+
+        unsafe {
+            let handle = self.lock();
+            rcl_action_take_result_response(
+                &*handle,
+                &mut response_header,
+                &mut result_rmw as *mut _ as *mut _,
+            )
+        }
+        .ok()?;
+
+        Ok((result_rmw, response_header))
+    }
+
+    fn send_cancel_goal(
+        &self,
+        goal_id: GoalUuid,
+        stamp: Time,
+    ) -> Result<i64, RclrsError> {
+        let cancel_request = CancelGoal_Request {
+            goal_info: GoalInfo {
+                goal_id: UUID { uuid: *goal_id },
+                stamp,
+            }
+        };
+
+        let cancel_request_rmw = <CancelGoal_Request as Message>::into_rmw_message(Cow::Owned(cancel_request));
+        let mut seq: i64 = 0;
+
+        unsafe {
+            let handle = self.lock();
+            rcl_action_send_cancel_request(
+                &*handle,
+                &cancel_request_rmw as *const _ as *const _,
+                &mut seq,
+            )
+        }
+        .ok()?;
+
+        Ok(seq)
+    }
+
+    fn take_cancel_response(&self) -> Result<(CancelGoal_Response, rmw_request_id_t), RclrsError> {
+        let mut result_rmw = <CancelGoal_Response as Message>::RmwMsg::default();
+        let mut header = rmw_request_id_t {
+            writer_guid: [0; RCL_ACTION_UUID_SIZE],
+            sequence_number: 0,
+        };
+
+        unsafe {
+            let handle = self.lock();
+            rcl_action_take_cancel_response(
+                &*handle,
+                &mut header,
+                &mut result_rmw as *mut _ as *mut _,
+            )
+        }
+        .ok()?;
+
+        let result = Message::from_rmw_message(result_rmw);
+        Ok((result, header))
+    }
+}
+
+impl Drop for ActionClientHandle {
+    fn drop(&mut self) {
+        let rcl_action_client = self.rcl_action_client.get_mut().unwrap();
+        let mut rcl_node = self.node_handle.rcl_node.lock().unwrap();
+        let _lifecycle_lock = ENTITY_LIFECYCLE_MUTEX.lock().unwrap();
+        // SAFETY: The entity lifecycle mutex is locked to protect against the risk of
+        // global variables in the rmw implementation being unsafely modified during cleanup.
+        unsafe {
+            rcl_action_client_fini(rcl_action_client, &mut *rcl_node);
+        }
+    }
+}
+
+// SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
+// they are running in. Therefore, this type can be safely sent to another thread.
+unsafe impl Send for rcl_action_client_t {}
diff --git a/rclrs/src/action/action_client/cancellation_client.rs b/rclrs/src/action/action_client/cancellation_client.rs
new file mode 100644
index 00000000..acdcaa8c
--- /dev/null
+++ b/rclrs/src/action/action_client/cancellation_client.rs
@@ -0,0 +1,126 @@
+use crate::{ActionClient, CancelResponse, GoalUuid, MultiCancelResponse, RclrsError};
+use super::GoalClientLifecycle;
+use tokio::sync::oneshot::Receiver;
+use rosidl_runtime_rs::Action;
+use std::{
+    sync::Arc,
+    ops::{Deref, DerefMut}
+};
+
+/// This can be used to request the cancellation of a specific goal. When you
+/// put in the request you will get a one-shot receiver which will tell you
+/// whether the request was accepted or rejected.
+pub struct CancellationClient<A: Action> {
+    client: ActionClient<A>,
+    goal_id: GoalUuid,
+}
+
+impl<A: Action> Clone for CancellationClient<A> {
+    fn clone(&self) -> Self {
+        Self {
+            client: Arc::clone(&self.client),
+            goal_id: self.goal_id,
+        }
+    }
+}
+
+impl<A: Action> CancellationClient<A> {
+    /// Ask the goal to cancel. You will receiver a [`CancelResponseClient`]
+    /// which you can use to await the response from the action server.
+    ///
+    /// If an rcl error occurs, this will panic. This function is not likely to
+    /// result in any rcl errors.
+    pub fn cancel(&self) -> CancelResponseClient<A> {
+        self.try_cancel().unwrap()
+    }
+
+    /// A version of [`Self::cancel`] which does not panic when an error occurs.
+    pub fn try_cancel(&self) -> Result<CancelResponseClient<A>, RclrsError> {
+        self.client.board.request_single_cancel(&self.client, self.goal_id)
+    }
+
+    pub(super) fn new(
+        client: ActionClient<A>,
+        goal_id: GoalUuid,
+    ) -> Self {
+        Self { client, goal_id }
+    }
+}
+
+/// This will allow you to receive a response to your cancellation request so you
+/// can know if the cancellation was successful or not.
+///
+/// You can obtain one of these using [`CancellationClient`] (which is provided
+/// by [`GoalClient`][1]) or using [`ActionClientState::cancel_goal`][2].
+///
+/// [1]: crate::GoalClient
+/// [2]: crate::ActionClientState::cancel_goal
+pub struct CancelResponseClient<A: Action> {
+    receiver: Receiver<CancelResponse>,
+    /// This keeps track of whether any goal client components are still being used.
+    /// This must come after the receiver in the struct to ensure cleanup is done
+    /// correctly.
+    #[allow(unused)]
+    lifecycle: GoalClientLifecycle<A>,
+}
+
+impl<A: Action> Deref for CancelResponseClient<A> {
+    type Target = Receiver<CancelResponse>;
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for CancelResponseClient<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> CancelResponseClient<A> {
+    pub(super) fn new(
+        receiver: Receiver<CancelResponse>,
+        lifecycle: GoalClientLifecycle<A>,
+    ) -> Self {
+        Self { receiver, lifecycle }
+    }
+}
+
+/// This will allow you to receive a response to a cancellation request that
+/// impacts multiple goals.
+///
+/// You can obtain one of these using [`ActionClientState::cancel_all_goals`][1]
+/// or [`ActionClientState::cancel_goals_prior_to`][2].
+///
+/// [1]: crate::ActionClientState::cancel_all_goals
+/// [2]: crate::ActionClientState::cancel_goals_prior_to
+pub struct MultiCancelResponseClient<A: Action> {
+    receiver: Receiver<MultiCancelResponse>,
+    /// This keeps track of whether any goal client components are still being used.
+    /// This must come after the receiver in the struct to ensure cleanup is done
+    /// correctly.
+    #[allow(unused)]
+    lifecycle: GoalClientLifecycle<A>,
+}
+
+impl<A: Action> Deref for MultiCancelResponseClient<A> {
+    type Target = Receiver<MultiCancelResponse>;
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for MultiCancelResponseClient<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> MultiCancelResponseClient<A> {
+    pub(super) fn new(
+        receiver: Receiver<MultiCancelResponse>,
+        lifecycle: GoalClientLifecycle<A>,
+    ) -> Self {
+        Self { receiver, lifecycle }
+    }
+}
diff --git a/rclrs/src/action/action_client/feedback_client.rs b/rclrs/src/action/action_client/feedback_client.rs
new file mode 100644
index 00000000..ff8468ac
--- /dev/null
+++ b/rclrs/src/action/action_client/feedback_client.rs
@@ -0,0 +1,46 @@
+use super::{GoalClientLifecycle, GoalUuid};
+use rosidl_runtime_rs::Action;
+use tokio::sync::mpsc::UnboundedReceiver;
+use std::ops::{Deref, DerefMut};
+
+/// This struct allows you to receive feedback messages for the goal. Through the
+/// [`DerefMut`] trait you can use the [`UnboundedReceiver`] API to await new
+/// feedback messages.
+pub struct FeedbackClient<A: Action> {
+    receiver: UnboundedReceiver<A::Feedback>,
+    goal_id: GoalUuid,
+    /// This keeps track of whether any goal client components are still being used.
+    /// This must come after the receiver in the struct to ensure cleanup is done
+    /// correctly.
+    #[allow(unused)]
+    lifecycle: GoalClientLifecycle<A>,
+}
+
+impl<A: Action> Clone for FeedbackClient<A> {
+    fn clone(&self) -> Self {
+        self.lifecycle.client.receive_feedback(self.goal_id)
+    }
+}
+
+impl<A: Action> Deref for FeedbackClient<A> {
+    type Target = UnboundedReceiver<A::Feedback>;
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for FeedbackClient<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> FeedbackClient<A> {
+    pub(super) fn new(
+        receiver: UnboundedReceiver<A::Feedback>,
+        goal_id: GoalUuid,
+        lifecycle: GoalClientLifecycle<A>,
+    ) -> Self {
+        Self { receiver, goal_id, lifecycle }
+    }
+}
diff --git a/rclrs/src/action/action_client/goal_client.rs b/rclrs/src/action/action_client/goal_client.rs
new file mode 100644
index 00000000..3fe7fdf9
--- /dev/null
+++ b/rclrs/src/action/action_client/goal_client.rs
@@ -0,0 +1,108 @@
+use crate::{
+    vendor::builtin_interfaces::msg::Time,
+    CancellationClient, FeedbackClient, GoalStatus, GoalStatusCode, StatusWatcher, ResultClient,
+};
+use rosidl_runtime_rs::Action;
+use tokio_stream::{StreamMap, Stream};
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// The goal client bundles a set of receivers that will allow you to await
+/// different information from the action server, such as feedback messages,
+/// status updates, and the final result. It also provides a way to request
+/// cancelling a goal.
+///
+/// This struct is designed to be [destructured][1] so each of its fields can be
+/// used independently. This is important because many of them require mutable
+/// access (or one-time access) to be used, so being blocked behind `&mut self`
+/// would make it impossible to use them independently, e.g. to await more than
+/// one at a time.
+///
+/// [1]: https://doc.rust-lang.org/rust-by-example/flow_control/match/destructuring/destructure_structures.html
+pub struct GoalClient<A: Action> {
+    /// Receive feedback messages for the goal.
+    pub feedback: FeedbackClient<A>,
+    /// Watch the status of the goal.
+    pub status: StatusWatcher<A>,
+    /// Get the final result of the goal.
+    pub result: ResultClient<A>,
+    /// Use this if you want to request the goal to be cancelled.
+    pub cancellation: CancellationClient<A>,
+    /// The time that the goal was accepted.
+    pub stamp: Time,
+}
+
+impl<A: Action> Clone for GoalClient<A> {
+    fn clone(&self) -> Self {
+        Self {
+            feedback: self.feedback.clone(),
+            status: self.status.clone(),
+            result: self.result.clone(),
+            cancellation: self.cancellation.clone(),
+            stamp: self.stamp.clone(),
+        }
+    }
+}
+
+impl<A: Action> GoalClient<A> {
+    /// Create a concurrent stream that will emit events related to this goal.
+    pub fn stream(self) -> GoalClientStream<A> {
+        let Self { mut feedback, mut status, result, .. } = self;
+
+        let rx_feedback = Box::pin(async_stream::stream! {
+            while let Some(msg) = feedback.recv().await {
+                yield GoalEvent::Feedback(msg);
+            }
+        }) as Pin<Box<dyn Stream<Item = GoalEvent<A>> + Send>>;
+
+        let rx_status = Box::pin(async_stream::stream! {
+            let initial_value = (*status.borrow_and_update()).clone();
+            yield GoalEvent::Status(initial_value);
+
+            while let Ok(_) = status.changed().await {
+                let value = (*status.borrow_and_update()).clone();
+                yield GoalEvent::Status(value);
+            }
+        }) as Pin<Box<dyn Stream<Item = GoalEvent<A>> + Send>>;
+
+        let rx_result = Box::pin(async_stream::stream! {
+            yield GoalEvent::Result(result.await);
+        }) as Pin<Box<dyn Stream<Item = GoalEvent<A>> + Send>>;
+
+        let mut stream_map: StreamMap<i32, Pin<Box<dyn Stream<Item = GoalEvent<A>> + Send>>> = StreamMap::new();
+        stream_map.insert(0, rx_feedback);
+        stream_map.insert(1, rx_status);
+        stream_map.insert(2, rx_result);
+        GoalClientStream { stream_map }
+    }
+}
+
+/// Use this to
+pub struct GoalClientStream<A: Action> {
+    stream_map: StreamMap<i32, Pin<Box<dyn Stream<Item = GoalEvent<A>> + Send>>>,
+}
+
+impl<A: Action> Stream for GoalClientStream<A> {
+    type Item = GoalEvent<A>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        Stream::poll_next(Pin::new(&mut self.get_mut().stream_map), cx)
+            .map(|r| r.map(|(_, event)| event))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.stream_map.size_hint()
+    }
+}
+
+/// Any of the possible update events that can happen for a goal.
+pub enum GoalEvent<A: Action> {
+    /// A feedback message was received
+    Feedback(A::Feedback),
+    /// A status update was received
+    Status(GoalStatus),
+    /// The result of the goal was received
+    Result((GoalStatusCode, A::Result)),
+}
diff --git a/rclrs/src/action/action_client/requested_goal_client.rs b/rclrs/src/action/action_client/requested_goal_client.rs
new file mode 100644
index 00000000..33495f3b
--- /dev/null
+++ b/rclrs/src/action/action_client/requested_goal_client.rs
@@ -0,0 +1,68 @@
+use crate::{GoalClient, GoalUuid};
+use super::GoalClientLifecycle;
+use rosidl_runtime_rs::Action;
+use tokio::sync::oneshot::Receiver;
+use std::{
+    future::Future,
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// This struct allows you to receive a [`GoalClient`] for a goal that you
+/// requested. Call `.await` on this to obtain the response to the goal request.
+/// Note that the [`GoalClient`] can only be received once.
+///
+/// Through the [`DerefMut`] trait you can use the [`oneshot::Receiver`][Receiver] API.
+///
+/// If the action server rejects the goal then this will yield a [`None`] instead
+/// of a [`GoalClient`].
+pub struct RequestedGoalClient<A: Action> {
+    goal_id: GoalUuid,
+    receiver: Receiver<Option<GoalClient<A>>>,
+    /// This keeps track of whether any goal client components are still being used.
+    /// This must come after the receiver in the struct to ensure cleanup is done
+    /// correctly.
+    #[allow(unused)]
+    lifecycle: GoalClientLifecycle<A>,
+}
+
+impl<A: Action> RequestedGoalClient<A> {
+    /// Get the unique ID for the goal that has been requested.
+    pub fn goal_id(&self) -> &GoalUuid {
+        &self.goal_id
+    }
+
+    pub(super) fn new(
+        goal_id: GoalUuid,
+        receiver: Receiver<Option<GoalClient<A>>>,
+        lifecycle: GoalClientLifecycle<A>,
+    ) -> Self {
+        Self { goal_id, receiver, lifecycle }
+    }
+}
+
+impl<A: Action> Deref for RequestedGoalClient<A> {
+    type Target = Receiver<Option<GoalClient<A>>>;
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for RequestedGoalClient<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> Future for RequestedGoalClient<A> {
+    type Output = Option<GoalClient<A>>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Future::poll(Pin::new(&mut self.get_mut().receiver), cx)
+            // SAFETY: The Receiver returns an Err if the sender is dropped, but
+            // the RegisteredGoalClient makes sure that the sender is alive in
+            // the ActionClient, so we can always safely unwrap this.
+            .map(|result| result.unwrap())
+    }
+}
diff --git a/rclrs/src/action/action_client/result_client.rs b/rclrs/src/action/action_client/result_client.rs
new file mode 100644
index 00000000..8b9aef42
--- /dev/null
+++ b/rclrs/src/action/action_client/result_client.rs
@@ -0,0 +1,70 @@
+use crate::GoalStatusCode;
+use super::GoalClientLifecycle;
+use rosidl_runtime_rs::Action;
+use tokio::sync::oneshot::Receiver;
+use std::{
+    future::Future,
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+use futures::{future::Shared, FutureExt};
+
+/// This struct allows you to receive the result of the goal. Through the [`DerefMut`]
+/// trait you can use the [`oneshot::Receiver`][Receiver] API to await the final
+/// result. Note that it can only be received once.
+pub struct ResultClient<A: Action> {
+    receiver: Shared<Receiver<(GoalStatusCode, A::Result)>>,
+    /// This keeps track of whether any goal client components are still being used.
+    /// This must come after the receiver in the struct to ensure cleanup is done
+    /// correctly.
+    #[allow(unused)]
+    lifecycle: Arc<GoalClientLifecycle<A>>,
+}
+
+impl<A: Action> Clone for ResultClient<A> {
+    fn clone(&self) -> Self {
+        Self {
+            receiver: self.receiver.clone(),
+            lifecycle: Arc::clone(&self.lifecycle),
+        }
+    }
+}
+
+impl<A: Action> ResultClient<A> {
+    pub(super) fn new(
+        receiver: Receiver<(GoalStatusCode, A::Result)>,
+        lifecycle: GoalClientLifecycle<A>,
+    ) -> Self {
+        Self {
+            receiver: receiver.shared(),
+            lifecycle: Arc::new(lifecycle),
+        }
+    }
+}
+
+impl<A: Action> Deref for ResultClient<A> {
+    type Target = Shared<Receiver<(GoalStatusCode, A::Result)>>;
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for ResultClient<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> Future for ResultClient<A> {
+    type Output = (GoalStatusCode, A::Result);
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Future::poll(Pin::new(&mut self.get_mut().receiver), cx)
+            // SAFETY: The Receiver returns an Err if the sender is dropped, but
+            // the RegisteredGoalClient makes sure that the sender is alive in
+            // the ActionClient, so we can always safely unwrap this.
+            .map(|result| result.unwrap())
+    }
+}
diff --git a/rclrs/src/action/action_client/status_client.rs b/rclrs/src/action/action_client/status_client.rs
new file mode 100644
index 00000000..d8edb1f3
--- /dev/null
+++ b/rclrs/src/action/action_client/status_client.rs
@@ -0,0 +1,96 @@
+use crate::{GoalStatus, GoalUuid};
+use super::GoalClientLifecycle;
+use rosidl_runtime_rs::Action;
+use tokio::sync::{watch::Receiver as Watcher, mpsc::UnboundedReceiver};
+use std::{
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
+
+/// This struct allows you to receive every status update experienced by a goal.
+///
+/// If you only care about checking the latest status, you can call [`Self::watch`]
+/// to use a [`StatusWatcher`] instead.
+pub struct StatusClient<A: Action> {
+    receiver: UnboundedReceiver<GoalStatus>,
+    goal_id: GoalUuid,
+    #[allow(unused)]
+    lifecycle: GoalClientLifecycle<A>,
+}
+
+impl<A: Action> Clone for StatusClient<A> {
+    fn clone(&self) -> Self {
+        self.lifecycle.client.receive_status(self.goal_id)
+    }
+}
+
+impl<A: Action> Deref for StatusClient<A> {
+    type Target = UnboundedReceiver<GoalStatus>;
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for StatusClient<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> StatusClient<A> {
+    /// Watch the latest value of the goal status.
+    pub fn watch(&self) -> StatusWatcher<A> {
+        self.lifecycle.client.watch_status(self.goal_id)
+    }
+
+    pub(super) fn new(
+        receiver: UnboundedReceiver<GoalStatus>,
+        goal_id: GoalUuid,
+        lifecycle: GoalClientLifecycle<A>,
+    ) -> Self {
+        Self { receiver, goal_id, lifecycle }
+    }
+}
+
+/// This struct allows you to monitor the status of the goal. Through the
+/// [`DerefMut`] trait you can use the [`watch::Receiver`][Watcher] API to
+/// check the latest status and monitor changes.
+pub struct StatusWatcher<A: Action> {
+    watcher: Watcher<GoalStatus>,
+    /// This keeps track of whether any goal client components are still being used.
+    /// This must come after the receiver in the struct to ensure cleanup is done
+    /// correctly.
+    #[allow(unused)]
+    lifecycle: Arc<GoalClientLifecycle<A>>,
+}
+
+impl<A: Action> Clone for StatusWatcher<A> {
+    fn clone(&self) -> Self {
+        Self {
+            watcher: self.watcher.clone(),
+            lifecycle: Arc::clone(&self.lifecycle),
+        }
+    }
+}
+
+impl<A: Action> Deref for StatusWatcher<A> {
+    type Target = Watcher<GoalStatus>;
+    fn deref(&self) -> &Self::Target {
+        &self.watcher
+    }
+}
+
+impl<A: Action> DerefMut for StatusWatcher<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.watcher
+    }
+}
+
+impl<A: Action> StatusWatcher<A> {
+    pub(super) fn new(
+        watcher: Watcher<GoalStatus>,
+        lifecycle: Arc<GoalClientLifecycle<A>>,
+    ) -> Self {
+        Self { watcher, lifecycle }
+    }
+}
diff --git a/rclrs/src/action/action_goal_receiver.rs b/rclrs/src/action/action_goal_receiver.rs
new file mode 100644
index 00000000..0e6ce947
--- /dev/null
+++ b/rclrs/src/action/action_goal_receiver.rs
@@ -0,0 +1,74 @@
+use crate::{
+    ActionServer, ActionServerOptions, ActionServerState, RequestedGoal, TerminatedGoal,
+    Node, RclrsError,
+};
+use rosidl_runtime_rs::Action;
+use std::{
+    future::Future,
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
+
+/// This is an alternative tool for implementing an [`ActionServer`]. Instead of
+/// specifying a callback to receive goal requests, you can use this receiver to
+/// obtain incoming goal requests and then process them in an async task.
+///
+/// The [`ActionGoalReceiver`] may have some advantages over the [`ActionServer`]
+/// for action servers that support multiple simultaneous goals which may interact
+/// with each other and therefore need to be processed within the same async task.
+//
+// TODO(@mxgrey): Add usage examples here.
+pub struct ActionGoalReceiver<A: Action> {
+    server: ActionServerState<A>,
+    receiver: UnboundedReceiver<RequestedGoal<A>>,
+}
+
+impl<A: Action> Deref for ActionGoalReceiver<A> {
+    type Target = UnboundedReceiver<RequestedGoal<A>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+impl<A: Action> DerefMut for ActionGoalReceiver<A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.receiver
+    }
+}
+
+impl<A: Action> ActionGoalReceiver<A> {
+    /// Change this action goal receiver into a callback-based action server.
+    ///
+    /// It is unusual to switch from an action goal receiver to an action server,
+    /// so consider carefully whether this is what you really want to do. Usually
+    /// an action server is created by [`NodeState::create_action_server`].
+    #[must_use]
+    pub fn into_action_server<Task>(
+        self,
+        callback: impl FnMut(RequestedGoal<A>) -> Task + Send + Sync + 'static,
+    ) -> ActionServer<A>
+    where
+        Task: Future<Output = TerminatedGoal> + Send + Sync + 'static,
+    {
+        let Self { server, receiver } = self;
+        server.drain_receiver_into_callback(receiver, callback);
+        Arc::new(server)
+    }
+
+    pub(crate) fn new<'a>(
+        node: &Node,
+        options: impl Into<ActionServerOptions<'a>>,
+    ) -> Result<Self, RclrsError> {
+        let (sender, receiver) = unbounded_channel();
+        let server = ActionServerState::new_for_receiver(node, options, sender)?;
+        Ok(Self { server, receiver })
+    }
+
+    pub(super) fn from_server(server: ActionServerState<A>) -> Self {
+        let (sender, receiver) = unbounded_channel();
+        server.set_goal_sender(sender);
+        Self { server, receiver }
+    }
+}
diff --git a/rclrs/src/action/action_server.rs b/rclrs/src/action/action_server.rs
new file mode 100644
index 00000000..e6b7153c
--- /dev/null
+++ b/rclrs/src/action/action_server.rs
@@ -0,0 +1,658 @@
+use crate::{
+    action::GoalUuid,
+    error::ToResult,
+    rcl_bindings::*,
+    ActionGoalReceiver, DropGuard, GoalStatusCode, Node, NodeHandle, QoSProfile, RclPrimitive, RclrsError,
+    RclPrimitiveHandle, RclPrimitiveKind, ReadyKind, TakeFailedAsNone,
+    Waitable, WaitableLifecycle, ENTITY_LIFECYCLE_MUTEX,
+};
+use super::empty_goal_status_array;
+use rosidl_runtime_rs::{Action, Message, RmwGoalRequest, RmwResultRequest};
+use std::{
+    any::Any,
+    borrow::Borrow,
+    collections::HashMap,
+    ffi::CString,
+    future::Future,
+    sync::{Arc, Mutex, MutexGuard, Weak},
+};
+use futures::future::BoxFuture;
+use tokio::sync::mpsc::{UnboundedSender, UnboundedReceiver};
+
+mod accepted_goal;
+pub use accepted_goal::*;
+
+mod action_server_goal_handle;
+use action_server_goal_handle::*;
+
+mod cancellation_state;
+use cancellation_state::*;
+
+mod cancelling_goal;
+use cancelling_goal::*;
+
+mod executing_goal;
+pub use executing_goal::*;
+
+mod feedback_publisher;
+pub use feedback_publisher::*;
+
+mod live_action_server_goal;
+use live_action_server_goal::*;
+
+mod requested_goal;
+pub use requested_goal::*;
+
+mod terminated_goal;
+pub use terminated_goal::*;
+
+/// `ActionServerOptions` are used by [`Node::create_action_server`][1] to initialize an
+/// [`ActionServer`].
+///
+/// [1]: crate::NodeState::create_action_server
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct ActionServerOptions<'a> {
+    /// The name of the action implemented by this server
+    pub action_name: &'a str,
+    /// The quality of service profile for the goal service
+    pub goal_service_qos: QoSProfile,
+    /// The quality of service profile for the result service
+    pub result_service_qos: QoSProfile,
+    /// The quality of service profile for the cancel service
+    pub cancel_service_qos: QoSProfile,
+    /// The quality of service profile for the feedback topic
+    pub feedback_topic_qos: QoSProfile,
+    /// The quality of service profile for the status topic
+    pub status_topic_qos: QoSProfile,
+    // TODO(nwn): result_timeout
+}
+
+impl<'a> ActionServerOptions<'a> {
+    /// Initialize a new [`ActionServerOptions`] with default settings.
+    pub fn new(action_name: &'a str) -> Self {
+        Self {
+            action_name,
+            goal_service_qos: QoSProfile::services_default(),
+            result_service_qos: QoSProfile::services_default(),
+            cancel_service_qos: QoSProfile::services_default(),
+            feedback_topic_qos: QoSProfile::topics_default(),
+            status_topic_qos: QoSProfile::action_status_default(),
+        }
+    }
+}
+
+impl<'a, T: Borrow<str> + ?Sized + 'a> From<&'a T> for ActionServerOptions<'a> {
+    fn from(value: &'a T) -> Self {
+        Self::new(value.borrow())
+    }
+}
+
+/// An action server that can respond to requests sent by ROS action clients.
+///
+/// Create an action server using [`NodeState::create_action_server`][1].
+///
+/// ROS only supports having one server for any given fully-qualified
+/// action name. "Fully-qualified" means the namespace is also taken into account
+/// for uniqueness. A clone of an `ActionServer` will refer to the same server
+/// instance as the original. The underlying instance is tied to [`ActionServerState`]
+/// which implements the [`ActionServer`] API.
+///
+/// Responding to requests requires the node's executor to [spin][2].
+///
+/// You may also consider using [`ActionGoalReceiver`] to implement your action
+/// server. It provides different ergonomics which may be useful in some situations.
+///
+/// [1]: crate::NodeState::create_action_server
+/// [2]: crate::Executor::spin
+pub type ActionServer<A> = Arc<ActionServerState<A>>;
+
+/// The inner state of an [`ActionServer`].
+///
+/// This is public so that you can choose to create a [`Weak`][1] reference to it
+/// if you want to be able to refer to a [`ActionServer`] in a non-owning way. It is
+/// generally recommended to manage the `ActionServerState` inside of an [`Arc`],
+/// and [`ActionServer`] is provided as a convenience alias for that.
+///
+/// The public API of the [`ActionServer`] type is implemented via `ActionServerState`.
+///
+/// [1]: std::sync::Weak
+pub struct ActionServerState<A: Action> {
+    board: Arc<ActionServerGoalBoard<A>>,
+
+    /// Holding onto this keeps the waitable for this action server alive in the
+    /// wait set of the executor.
+    #[allow(unused)]
+    lifecycle: WaitableLifecycle,
+}
+
+impl<A: Action> ActionServerState<A> {
+    /// Change the callback for this action server.
+    pub fn set_callback<Task>(
+        &self,
+        mut callback: impl FnMut(RequestedGoal<A>) -> Task + Send + Sync + 'static,
+    )
+    where
+        Task: Future<Output = TerminatedGoal> + Send + Sync + 'static,
+    {
+        let callback = Box::new(move |requested_goal| -> BoxFuture<'static, TerminatedGoal> {
+            Box::pin(callback(requested_goal))
+        });
+
+        let mut dispatch = match self.board.dispatch.lock() {
+            Ok(dispatch) => dispatch,
+            Err(poison) => poison.into_inner(),
+        };
+
+        *dispatch = GoalDispatch::Callback(callback);
+        self.board.dispatch.clear_poison();
+    }
+
+    /// Change this action server into an action goal receiver, which may be more
+    /// ergonomic for some implementations of an action server.
+    ///
+    /// Note that you'll need to obtain a uniquely owned instance of the
+    /// [`ActionServerState`] to do this conversion. If you have an [`ActionServer`]
+    /// (which is managed by an [`Arc`]) then you will need to use [`Arc::into_inner`]
+    /// to obtain the unique [`ActionServerState`].
+    ///
+    /// It is unusual to switch from an action server to an action goal receiver,
+    /// so consider carefully whether this is what you really want to do. Usually
+    /// an action goal receiver is created by [`NodeState::create_action_goal_receiver`]
+    /// when the action server is being initialized.
+    #[must_use]
+    pub fn into_goal_receiver(self) -> ActionGoalReceiver<A> {
+        ActionGoalReceiver::from_server(self)
+    }
+
+    pub(crate) fn create<'a, Task>(
+        node: &Node,
+        options: impl Into<ActionServerOptions<'a>>,
+        mut callback: impl FnMut(RequestedGoal<A>) -> Task + Send + Sync + 'static,
+    ) -> Result<ActionServer<A>, RclrsError>
+    where
+        Task: Future<Output = TerminatedGoal> + Send + Sync + 'static,
+    {
+        let callback = Box::new(move |requested_goal| -> BoxFuture<'static, TerminatedGoal> {
+            Box::pin(callback(requested_goal))
+        });
+
+        Ok(Arc::new(Self::new(node, options, GoalDispatch::Callback(callback))?))
+    }
+
+    pub(super) fn new_for_receiver<'a>(
+        node: &Node,
+        options: impl Into<ActionServerOptions<'a>>,
+        sender: UnboundedSender<RequestedGoal<A>>,
+    ) -> Result<Self, RclrsError> {
+        Self::new(node, options, GoalDispatch::Sender(sender))
+    }
+
+    /// Creates a new action server.
+    fn new<'a>(
+        node: &Node,
+        options: impl Into<ActionServerOptions<'a>>,
+        dispatch: GoalDispatch<A>,
+    ) -> Result<Self, RclrsError> {
+        let options = options.into();
+        // SAFETY: Getting a zero-initialized value is always safe.
+        let mut rcl_action_server = unsafe { rcl_action_get_zero_initialized_server() };
+        let type_support = A::get_type_support() as *const rosidl_action_type_support_t;
+        let action_name_c_string =
+            CString::new(options.action_name).map_err(|err| RclrsError::StringContainsNul {
+                err,
+                s: options.action_name.into(),
+            })?;
+
+        // SAFETY: No preconditions for this function.
+        let action_server_options = unsafe { rcl_action_server_get_default_options() };
+
+        {
+            let mut rcl_node = node.handle().rcl_node.lock().unwrap();
+            let clock = node.get_clock();
+            let rcl_clock = clock.get_rcl_clock();
+            let mut rcl_clock = rcl_clock.lock().unwrap();
+            let _lifecycle_lock = ENTITY_LIFECYCLE_MUTEX.lock().unwrap();
+
+            // SAFETY:
+            // * The rcl_action_server is zero-initialized as mandated by this function.
+            // * The rcl_node is kept alive by the NodeHandle because it is a dependency of the action server.
+            // * The action name and the options are copied by this function, so they can be dropped
+            //   afterwards.
+            // * The entity lifecycle mutex is locked to protect against the risk of global
+            //   variables in the rmw implementation being unsafely modified during initialization.
+            unsafe {
+                rcl_action_server_init(
+                    &mut rcl_action_server,
+                    &mut *rcl_node,
+                    &mut *rcl_clock,
+                    type_support,
+                    action_name_c_string.as_ptr(),
+                    &action_server_options,
+                )
+                .ok()?;
+            }
+        }
+
+        let handle = Arc::new(ActionServerHandle {
+            rcl_action_server: Mutex::new(rcl_action_server),
+            node_handle: Arc::clone(&node.handle()),
+            goals: Default::default(),
+        });
+
+        let board = Arc::new(ActionServerGoalBoard::new(dispatch, handle, node));
+
+        let async_commands = node.commands().async_worker_commands();
+        let (waitable, lifecycle) = Waitable::new(
+            Box::new(ActionServerExecutable {
+                board: Arc::clone(&board),
+            }),
+            Some(Arc::clone(async_commands.get_guard_condition())),
+        );
+        async_commands.add_to_wait_set(waitable);
+
+        Ok(Self { board, lifecycle })
+    }
+
+    pub(super) fn set_goal_sender(&self, sender: UnboundedSender<RequestedGoal<A>>) {
+        let mut dispatch = match self.board.dispatch.lock() {
+            Ok(dispatch) => dispatch,
+            Err(poison) => poison.into_inner(),
+        };
+
+        *dispatch = GoalDispatch::Sender(sender);
+        self.board.dispatch.clear_poison();
+    }
+
+    /// Used internally to change a receiver into an action server without the
+    /// risk of dropping any buffered goal requests or receiving goals out of
+    /// their original order.
+    pub(super) fn drain_receiver_into_callback<Task>(
+        &self,
+        mut receiver: UnboundedReceiver<RequestedGoal<A>>,
+        mut callback: impl FnMut(RequestedGoal<A>) -> Task + Send + Sync + 'static,
+    )
+    where
+        Task: Future<Output = TerminatedGoal> + Send + Sync + 'static,
+    {
+        let mut callback = Box::new(move |requested_goal| -> BoxFuture<'static, TerminatedGoal> {
+            Box::pin(callback(requested_goal))
+        });
+
+        let mut dispatch = match self.board.dispatch.lock() {
+            Ok(dispatch) => dispatch,
+            Err(poison) => poison.into_inner(),
+        };
+
+        // The dispatch sender is blocked by the mutex, so once we finish draining
+        // the current values in the receiver, there will never be any more values.
+        // By the time we unlock the dispatch mutex, the sender will be dropped,
+        // replaced by the callback.
+        while let Ok(requested_goal) = receiver.try_recv() {
+            let f = (*callback)(requested_goal);
+            let _ = self.board.node.commands().run(f);
+        }
+
+        *dispatch = GoalDispatch::Callback(callback);
+        self.board.dispatch.clear_poison();
+    }
+}
+
+struct ActionServerGoalBoard<A: Action> {
+    /// These goals have a live handle held by the user. We refer to them with a
+    /// Weak to prevent a circular reference. When the user drops the live handle
+    /// it will automatically be moved into the dropped_goals map.
+    live_goals: Mutex<HashMap<GoalUuid, Weak<LiveActionServerGoal<A>>>>,
+    dispatch: Mutex<GoalDispatch<A>>,
+    handle: Arc<ActionServerHandle<A>>,
+    node: Node,
+}
+
+impl<A: Action> ActionServerGoalBoard<A> {
+    fn new(
+        dispatch: GoalDispatch<A>,
+        handle: Arc<ActionServerHandle<A>>,
+        node: &Node,
+    ) -> Self {
+        Self {
+            dispatch: Mutex::new(dispatch),
+            handle,
+            node: Arc::clone(node),
+            live_goals: Default::default(),
+        }
+    }
+
+    pub fn node(&self) -> &Node {
+        &self.node
+    }
+
+    fn execute_goal_request(self: &Arc<Self>) -> Result<(), RclrsError> {
+        let Some((request, goal_request_id)) = self.handle.take_goal_request().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let (uuid, request) = <A as Action>::split_goal_request(request);
+        let requested_goal = RequestedGoal::new(
+            Arc::clone(self),
+            Arc::new(Message::from_rmw_message(request)),
+            GoalUuid(uuid),
+            goal_request_id,
+        );
+
+        match &mut *self.dispatch.lock()? {
+            GoalDispatch::Callback(callback) => {
+                let f = callback(requested_goal);
+                let _ = self.node.commands().run(f);
+            }
+            GoalDispatch::Sender(sender) => {
+                // A send error means the user has dropped their receiver, so
+                // the requested goal will be dropped and then the goal will be
+                // automatically rejected, so we don't need to do anyting with
+                // SendErrors from here.
+                let _ = sender.send(requested_goal);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn execute_cancel_request(&self) -> Result<(), RclrsError> {
+        let Some((request, request_id)) = self.handle.take_cancel_request().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let response_rmw = {
+            // SAFETY: No preconditions
+            let mut response_rmw = unsafe { rcl_action_get_zero_initialized_cancel_response() };
+            unsafe {
+                // SAFETY: The action server is locked by the handle. The request was initialized
+                // by rcl_action, and the response is a zero-initialized
+                // rcl_action_cancel_response_t.
+                rcl_action_process_cancel_request(
+                    &*self.handle.lock(),
+                    &request,
+                    &mut response_rmw as *mut _,
+                )
+            }
+            .ok()?;
+
+            DropGuard::new(response_rmw, |mut response_rmw| unsafe {
+                // SAFETY: The response was initialized by rcl_action_process_cancel_request().
+                // Later modifications only truncate the size of the array and shift elements,
+                // without modifying the data pointer or capacity.
+                rcl_action_cancel_response_fini(&mut response_rmw);
+            })
+        };
+
+        let mut waiting_for = Vec::new();
+        for idx in 0..response_rmw.msg.goals_canceling.size {
+            let goal_info = unsafe {
+                // SAFETY: The array pointed to by response_rmw.msg.goals_canceling.data is
+                // guaranteed to contain at least response_rmw.msg.goals_canceling.size members.
+                &*response_rmw.msg.goals_canceling.data.add(idx)
+            };
+            let goal_uuid = GoalUuid(goal_info.goal_id.uuid);
+            waiting_for.push(goal_uuid);
+        }
+
+        let cancellation_request = CancellationRequest::new(
+            request_id,
+            waiting_for.clone(),
+            Arc::clone(&self.handle),
+            Arc::clone(&self.node),
+        );
+
+        let live_goals = self.live_goals.lock()?;
+        for goal in waiting_for {
+            if let Some(live_goal) = live_goals.get(&goal).and_then(|goal| goal.upgrade()) {
+                live_goal.request_cancellation(cancellation_request.clone());
+            } else {
+                if let Some(handle) = self.handle.goals.lock()?.get(&goal) {
+                    // If the goal is already cancelled then we will say that we
+                    // accept the cancellation request. There is no need to
+                    // check for the cancelling state since non-live goals must
+                    // be in a terminal state.
+                    if handle.is_cancelled() {
+                        cancellation_request.accept(goal);
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn execute_result_request(&self) -> Result<(), RclrsError> {
+        let Some((request, mut request_id)) = self.handle.take_result_request().take_failed_as_none()? else {
+            return Ok(());
+        };
+
+        let uuid = GoalUuid(*<A as Action>::get_result_request_uuid(&request));
+        if let Some(goal) = self.handle.goals.lock()?.get(&uuid) {
+            goal.add_result_request(&self.handle, request_id)?;
+        } else {
+            // The goal either never existed or expired, so we give back an
+            // unknown response
+            let result_rmw = <<A::Result as Message>::RmwMsg as Default>::default();
+            let mut response_rmw = A::create_result_response(GoalStatusCode::Unknown as i8, result_rmw);
+
+            let server = self.handle.lock();
+            unsafe {
+                // SAFETY: The action server handle is kept valid by the mutex.
+                // The compiler ensures we have unique access to the result_request
+                // and result_response structures.
+                rcl_action_send_result_response(
+                    &*server,
+                    &mut request_id,
+                    &mut response_rmw as *mut _ as *mut _
+                )
+            }
+            .ok()?;
+        }
+
+        Ok(())
+    }
+
+    fn execute_goal_expired(&self) -> Result<(), RclrsError> {
+        // We assume here that only one goal expires at a time. If not, the only consequence is
+        // that we'll call rcl_action_expire_goals() more than necessary.
+
+        // SAFETY: No preconditions
+        let mut expired_goal = unsafe { rcl_action_get_zero_initialized_goal_info() };
+        let mut num_expired = 1;
+
+        loop {
+            unsafe {
+                // SAFETY: The action server is locked through the handle. The `expired_goal`
+                // argument points to an array of one rcl_action_goal_info_t and num_expired points
+                // to a `size_t`.
+                rcl_action_expire_goals(&*self.handle.lock(), &mut expired_goal, 1, &mut num_expired)
+            }
+            .ok()?;
+
+            if num_expired > 0 {
+                // Clean up the expired goal.
+                let uuid = GoalUuid(expired_goal.goal_id.uuid);
+                self.live_goals.lock().unwrap().remove(&uuid);
+                self.handle.goals.lock().unwrap().remove(&uuid);
+            } else {
+                break;
+            }
+        }
+
+        // Clear any lingering dropped goals from the board to avoid leaks
+        self.live_goals.lock().unwrap().retain(
+            |_, weak| weak.upgrade().is_some()
+        );
+
+        Ok(())
+    }
+}
+
+struct ActionServerExecutable<A: Action> {
+    board: Arc<ActionServerGoalBoard<A>>,
+}
+
+impl<A: Action> RclPrimitive for ActionServerExecutable<A> {
+    unsafe fn execute(
+        &mut self,
+        ready: ReadyKind,
+        _payload: &mut dyn Any,
+    ) -> Result<(), RclrsError> {
+        let ready = ready.for_action_server()?;
+
+        if ready.goal_request {
+            self.board.execute_goal_request()?;
+        }
+
+        if ready.cancel_request {
+            self.board.execute_cancel_request()?;
+        }
+
+        if ready.result_request {
+            self.board.execute_result_request()?;
+        }
+
+        if ready.goal_expired {
+            self.board.execute_goal_expired()?;
+        }
+
+        Ok(())
+    }
+
+    fn kind(&self) -> crate::RclPrimitiveKind {
+        RclPrimitiveKind::ActionServer
+    }
+
+    fn handle(&self) -> RclPrimitiveHandle {
+        RclPrimitiveHandle::ActionServer(self.board.handle.lock())
+    }
+}
+
+/// Manage the lifecycle of an `rcl_action_server_t`, including managing its dependencies
+/// on `rcl_node_t` and `rcl_context_t` by ensuring that these dependencies are
+/// [dropped after][1] the `rcl_action_server_t`.
+///
+/// [1]: <https://doc.rust-lang.org/reference/destructors.html>
+pub(crate) struct ActionServerHandle<A: Action> {
+    rcl_action_server: Mutex<rcl_action_server_t>,
+    /// Ensure the node remains active while the action server is running.
+    #[allow(unused)]
+    node_handle: Arc<NodeHandle>,
+    /// Ensure the `impl_*` of the action server goals remain valid until they
+    /// have expired or until the rcl_action_server_t gets fini-ed.
+    goals: Mutex<HashMap<GoalUuid, Arc<ActionServerGoalHandle<A>>>>,
+}
+
+// SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
+// they are running in. Therefore, this type can be safely sent to another thread.
+unsafe impl Send for rcl_action_server_t {}
+
+impl<A: Action> ActionServerHandle<A> {
+    pub(super) fn lock(&self) -> MutexGuard<rcl_action_server_t> {
+        self.rcl_action_server.lock().unwrap()
+    }
+
+    pub(super) fn publish_status(&self) -> Result<(), RclrsError> {
+        let mut goal_statuses = empty_goal_status_array();
+        let rcl_handle = self.lock();
+        unsafe {
+            // SAFETY: The action server is locked through the handle and goal_statuses is
+            // zero-initialized.
+            rcl_action_get_goal_status_array(&*rcl_handle, &mut *goal_statuses)
+        }
+        .ok()?;
+
+        unsafe {
+            // SAFETY: The action server is locked through the handle and goal_statuses.msg is a
+            // valid `action_msgs__msg__GoalStatusArray` by construction.
+            rcl_action_publish_status(
+                &*rcl_handle,
+                &goal_statuses.msg as *const _ as *const std::ffi::c_void,
+            )
+        }
+        .ok()
+    }
+
+    fn take_goal_request(&self) -> Result<(RmwGoalRequest<A>, rmw_request_id_t), RclrsError> {
+        let mut request_id = rmw_request_id_t {
+            writer_guid: [0; RCL_ACTION_UUID_SIZE],
+            sequence_number: 0,
+        };
+        let mut request_rmw = RmwGoalRequest::<A>::default();
+        unsafe {
+            let handle = self.lock();
+            // SAFETY: The action server is locked by the handle. The request_id is a
+            // zero-initialized rmw_request_id_t, and the request_rmw is a default-initialized
+            // SendGoalService request message.
+            rcl_action_take_goal_request(
+                &*handle,
+                &mut request_id,
+                &mut request_rmw as *mut RmwGoalRequest<A> as *mut _,
+            )
+        }
+        .ok()?;
+
+        Ok((request_rmw, request_id))
+    }
+
+    fn take_cancel_request(&self) -> Result<(action_msgs__srv__CancelGoal_Request, rmw_request_id_t), RclrsError> {
+        let mut request_id = rmw_request_id_t {
+            writer_guid: [0; RCL_ACTION_UUID_SIZE],
+            sequence_number: 0,
+        };
+        // SAFETY: No preconditions
+        let mut request_rmw = unsafe { rcl_action_get_zero_initialized_cancel_request() };
+        unsafe {
+            let handle = self.lock();
+            // SAFETY: The action server is locked by the handle. The request_id is a
+            // zero-initialized rmw_request_id_t, and the request_rmw is a zero-initialized
+            // action_msgs__srv__CancelGoal_Request.
+            rcl_action_take_cancel_request(
+                &*handle,
+                &mut request_id,
+                &mut request_rmw as *mut _ as *mut _,
+            )
+        }
+        .ok()?;
+
+        Ok((request_rmw, request_id))
+    }
+
+    fn take_result_request(&self) -> Result<(RmwResultRequest<A>, rmw_request_id_t), RclrsError> {
+        let mut request_id = rmw_request_id_t {
+            writer_guid: [0; RCL_ACTION_UUID_SIZE],
+            sequence_number: 0,
+        };
+
+        let mut request_rmw = RmwResultRequest::<A>::default();
+        unsafe {
+            let handle = self.lock();
+            // SAFETY: The action server is locked by the handle. The request_id is a
+            // zero-initialized rmw_request_id_t, and the request_rmw is a default-initialized
+            // GetResultService request message.
+            rcl_action_take_result_request(
+                &*handle,
+                &mut request_id,
+                &mut request_rmw as *mut RmwResultRequest<A> as *mut _,
+            )
+        }
+        .ok()?;
+
+        Ok((request_rmw, request_id))
+    }
+}
+
+enum GoalDispatch<A: Action> {
+    Callback(Box<dyn FnMut(RequestedGoal<A>) -> BoxFuture<'static, TerminatedGoal> + Send + Sync>),
+    Sender(UnboundedSender<RequestedGoal<A>>),
+}
+
+/// Possible status values for terminal states
+#[repr(i8)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+enum TerminalStatus {
+    Succeeded = 4,
+    Cancelled = 5,
+    Aborted = 6,
+}
diff --git a/rclrs/src/action/action_server/accepted_goal.rs b/rclrs/src/action/action_server/accepted_goal.rs
new file mode 100644
index 00000000..3f8eeccb
--- /dev/null
+++ b/rclrs/src/action/action_server/accepted_goal.rs
@@ -0,0 +1,151 @@
+use super::{CancellingGoal, ExecutingGoal, FeedbackPublisher, LiveActionServerGoal};
+use std::{
+    future::Future,
+    sync::Arc
+};
+use rosidl_runtime_rs::Action;
+
+/// This manages a goal which has been accepted but has not begun executing yet.
+/// It is allowed to transition into the executing or cancelling state.
+pub struct AcceptedGoal<A: Action> {
+    live: Arc<LiveActionServerGoal<A>>,
+}
+
+impl<A: Action> AcceptedGoal<A> {
+    /// Get the goal of this action.
+    #[must_use]
+    pub fn goal(&self) -> &Arc<A::Goal> {
+        self.live.goal()
+    }
+
+    /// Transition the goal into the executing state. This will allow you to
+    /// start sending feedback and transition to other states such as cancelling,
+    /// succeedded, and aborted.
+    ///
+    /// You can use this even if an action client has requested a cancellation,
+    /// but the cancellation request will be ignored until you handle it with
+    /// [`ExecutingGoal`].
+    #[must_use]
+    pub fn execute(self) -> ExecutingGoal<A> {
+        ExecutingGoal::new(self.live)
+    }
+
+    /// Process a [`Future`] until it is finished or until a cancellation request
+    /// is received.
+    ///
+    /// If the [`Future`] finishes, its output will be provided in [`Ok`].
+    ///
+    /// If a cancellation request is received before the [`Future`] is finished,
+    /// you will receive an [`Err`] with the current state of the [`Future`],
+    /// which you can continue processing later if you choose. If you would rather
+    /// discard the [`Future`] when a cancellation request is received, you can
+    /// call [`Self::unless_cancel_requested`] instead.
+    ///
+    /// After the cancellation request is received, you will still need to trigger
+    /// [`Self::begin_cancelling`] or [`Self::reject_cancellation`] to respond to
+    /// the request. Otherwise the cancellation request will not receive a response
+    /// until the goal reaches a terminal state.
+    //
+    // TODO(@mxgrey): Add a doctest and example for this.
+    pub async fn until_cancel_requested<F: Future + Unpin>(&self, f: F) -> Result<F::Output, F> {
+        self.live.cancellation().until_cancel_requested(f).await
+    }
+
+    /// Process a [`Future`] until it is finished unless a cancellation request
+    /// is received.
+    ///
+    /// If the [`Future`] finishes, its output will be provided in [`Ok`].
+    ///
+    /// If a cancellation request is received before the [`Future`] is finished,
+    /// the [`Future`] will be discarded. This allows non-[`Unpin`] futures to
+    /// be passed to this method. If your future implements [`Unpin`] and you want
+    /// the option to keep processing it after the cancellation request is received,
+    /// then you can call [`Self::until_cancel_requested`] instead.
+    ///
+    /// After the cancellation request is received, you will still need to trigger
+    /// [`Self::begin_cancelling`] or [`Self::reject_cancellation`] to respond to
+    /// the request. Otherwise the cancellation request will not receive a response
+    /// until the goal reaches a terminal state.
+    //
+    // TODO(@mxgrey): Add a doctest and example for this.
+    pub async fn unless_cancel_requested<F: Future>(&self, f: F) -> Result<F::Output, ()> {
+        self.live.cancellation().unless_cancel_requested(f).await
+    }
+
+    /// Transition the goal into the cancelling state.
+    ///
+    /// This does not require an action client to request a cancellation. If no
+    /// cancellation was requested, then using this function will have your action
+    /// server act as an action client that is commanding that the goal transition
+    /// to cancel.
+    ///
+    /// If there are any open cancellation requests for this goal from any action
+    /// clients, they will all be notified that the cancellation is accepted. Any
+    /// new cancellation requests that arrive for the goal after this will
+    /// automatically be accepted.
+    ///
+    /// For the goal to reach the cancelled state, you must follow this up with
+    /// [`CancellingGoal::cancelled_with`].
+    #[must_use]
+    pub fn begin_cancelling(self) -> CancellingGoal<A> {
+        CancellingGoal::new(self.live)
+    }
+
+    /// If there are any open cancellation requests for this goal, reject them.
+    /// This does not transition the goal in any way.
+    pub fn reject_cancellation(&self) {
+        self.live.reject_cancellation();
+    }
+
+    /// Transition the goal into either the executing mode or the cancelling mode.
+    ///
+    /// If any action client has sent a cancellation request, this will automatically
+    /// transition the goal into the cancelling state and provide you with a
+    /// [`CancellingGoal`]. Otherwise the goal will transition into the executing
+    /// state and you will receive an [`ExecutingGoal`].
+    #[must_use]
+    pub fn begin(self) -> BeginAcceptedGoal<A> {
+        if self.live.cancel_requested() {
+            BeginAcceptedGoal::Cancel(self.begin_cancelling())
+        } else {
+            BeginAcceptedGoal::Execute(self.execute())
+        }
+    }
+
+    /// Publish feedback for action clients to read.
+    ///
+    /// If you need to publish feedback from a separate thread or async task
+    /// which does not have direct access to the goal's state machine, you can
+    /// use [`Self::feedback_publisher`] to get a handle that you can pass along.
+    pub fn publish_feedback(&self, feedback: A::Feedback) {
+        self.live.publish_feedback(feedback);
+    }
+
+    /// Get a handle specifically for publishing feedback for this goal. This
+    /// publisher can be used separately from the overall state machine of the
+    /// goal, but it will stop working once the goal reaches a terminal state.
+    ///
+    /// If you just need to publish a one-off feedback message, you can use
+    /// [`Self::publish_feedback`].
+    pub fn feedback_publisher(&self) -> FeedbackPublisher<A> {
+        FeedbackPublisher::new(Arc::clone(&self.live))
+    }
+
+    pub(super) fn new(live: Arc<LiveActionServerGoal<A>>) -> Self {
+        Self { live }
+    }
+}
+
+/// While a goal was waiting to be executed, it is possible for cancellation
+/// requests to arrive for it. An accepted goal may transition directly into
+/// either executing or cancelling.
+///
+/// If you use [`AcceptedGoal::begin`] then the goal will be transitioned into
+/// the executing state if no cancellation requests have arrived, or the cancelling
+/// state if a cancellation has arrived. This enum will tell you which has occurred.
+pub enum BeginAcceptedGoal<A: Action> {
+    /// The goal has transitioned into executing.
+    Execute(ExecutingGoal<A>),
+    /// The goal has transitioned into cancelling.
+    Cancel(CancellingGoal<A>),
+}
diff --git a/rclrs/src/action/action_server/action_server_goal_handle.rs b/rclrs/src/action/action_server/action_server_goal_handle.rs
new file mode 100644
index 00000000..3351c170
--- /dev/null
+++ b/rclrs/src/action/action_server/action_server_goal_handle.rs
@@ -0,0 +1,192 @@
+use crate::{
+    rcl_bindings::*,
+    log_error,
+    GoalUuid, ToResult, RclrsError, RclReturnCode, RclErrorMsg, ActionServerHandle,
+};
+use super::{GoalStatusCode};
+use std::sync::{Mutex, MutexGuard};
+use rosidl_runtime_rs::{Action, RmwResultResponse};
+
+/// This struct is a minimal bridge to the `rcl_action` API for action server goals.
+/// While the goal is still live, it will be managed by a [`LiveActionServerGoal`][1]
+/// struct. Once the [`LiveActionServerGoal`][1] is dropped, it will remain inside
+/// the [`ActionServerHandle`][2] until the goal is reported as expired by `rcl_action`.
+///
+/// This will be created by [`RequestedActionServerGoal`][3]
+///
+/// [1]: super::LiveActionServerGoal
+/// [2]: super::ActionServerHandle
+/// [3]: super::RequestedGoal::accept
+pub(super) struct ActionServerGoalHandle<A: Action> {
+    rcl_handle: Mutex<rcl_action_goal_handle_t>,
+    result_response: Mutex<ResponseState<A>>,
+    uuid: GoalUuid,
+}
+
+impl<A: Action> ActionServerGoalHandle<A> {
+    pub(super) fn new(
+        rcl_handle: rcl_action_goal_handle_s,
+        uuid: GoalUuid,
+    ) -> Self {
+        Self {
+            rcl_handle: Mutex::new(rcl_handle),
+            result_response: Mutex::new(ResponseState::new()),
+            uuid,
+        }
+    }
+
+    pub(super) fn lock(&self) -> MutexGuard<rcl_action_goal_handle_t> {
+        self.rcl_handle.lock().unwrap()
+    }
+
+    /// Returns the goal state.
+    pub(super) fn get_status(&self) -> GoalStatusCode {
+        let mut state = GoalStatusCode::Unknown as rcl_action_goal_state_t;
+        {
+            let rcl_handle = self.lock();
+            // SAFETY: The provided goal handle is properly initialized by construction.
+            let r = unsafe { rcl_action_goal_handle_get_status(&*rcl_handle, &mut state).ok() };
+            if let Err(err) = r {
+                log_error!(
+                    "ActionServerGoalHandle.get_status",
+                    "Unexpected error while getting status: {err}",
+                );
+            }
+        }
+        // SAFETY: state is initialized to a valid GoalStatus value and will only ever by set by
+        // rcl_action_goal_handle_get_status to a valid GoalStatus value.
+        unsafe { std::mem::transmute(state) }
+    }
+
+    /// This is used to check if we should respond as accepting a cancellation
+    /// request for this goal after it is no longer live.
+    pub(super) fn is_cancelled(&self) -> bool {
+        self.get_status() == GoalStatusCode::Cancelled
+    }
+
+    /// Get the unique identifier of the goal.
+    pub(super) fn goal_id(&self) -> &GoalUuid {
+        &self.uuid
+    }
+
+    /// Provie the result for this action goal
+    pub(super) fn provide_result(
+        &self,
+        action_server_handle: &ActionServerHandle<A>,
+        result: RmwResultResponse<A>,
+    ) -> Result<(), RclrsError> {
+        self.result_response.lock()?.provide_result(action_server_handle, &self.uuid, result)
+    }
+
+    /// Add a result requester for this action goal
+    pub(super) fn add_result_request(
+        &self,
+        action_server_handle: &ActionServerHandle<A>,
+        result_request: rmw_request_id_t,
+    ) -> Result<(), RclrsError> {
+        self.result_response.lock()?.add_result_request(action_server_handle, result_request)
+    }
+}
+
+impl<A: Action> Drop for ActionServerGoalHandle<A> {
+    fn drop(&mut self) {
+        // SAFETY: There should not be any way for the mutex to be poisoned
+        let mut rcl_handle = self.rcl_handle.lock().unwrap();
+        unsafe {
+            // SAFETY: The goal handle was propertly initialized, and it will
+            // never be accessed again after this.
+            rcl_action_goal_handle_fini(&mut *rcl_handle);
+        }
+    }
+}
+
+// SAFETY: The functions accessing this type don't care about the thread they are
+// running in. Therefore this type can be safely sent to another thread.
+unsafe impl Send for rcl_action_goal_handle_t {}
+
+/// Manages the state of a goal's response.
+enum ResponseState<A: Action> {
+    /// The response has not arrived yet. There may be some clients waiting for
+    /// the response, and they'll be listed here.
+    Waiting(Vec<rmw_request_id_t>),
+    /// The response is available.
+    Available(RmwResultResponse<A>),
+}
+
+impl<A: Action> ResponseState<A> {
+    fn new() -> Self {
+        Self::Waiting(Vec::new())
+    }
+
+    fn provide_result(
+        &mut self,
+        action_server_handle: &ActionServerHandle<A>,
+        goal_id: &GoalUuid,
+        mut result: RmwResultResponse<A>,
+    ) -> Result<(), RclrsError> {
+        let result_requests = match self {
+            Self::Waiting(waiting) => waiting,
+            Self::Available(previous) => {
+                log_error!(
+                    "action_server_goal_handle.provide_result",
+                    "Action goal {goal_id} was provided with multiple results, \
+                    which is not allowed by the action server state machine and \
+                    indicates a bug in rclrs. The new result will be discarded.\
+                    \nPrevious result: {previous:?}\
+                    \nNew result: {result:?}"
+                );
+                return Err(RclrsError::RclError {
+                    code: RclReturnCode::ActionGoalEventInvalid,
+                    msg: Some(RclErrorMsg("action goal response is already set".to_string())),
+                });
+            }
+        };
+
+        if !result_requests.is_empty() {
+            let action_server = action_server_handle.lock();
+
+            // Respond to all queued requests.
+            for mut result_request in result_requests {
+                Self::send_result(&*action_server, &mut result_request, &mut result)?;
+            }
+        }
+
+        *self = Self::Available(result);
+        Ok(())
+    }
+
+    fn add_result_request(
+        &mut self,
+        action_server_handle: &ActionServerHandle<A>,
+        mut result_request: rmw_request_id_t,
+    ) -> Result<(), RclrsError> {
+        match self {
+            Self::Waiting(waiting) => {
+                waiting.push(result_request);
+            }
+            Self::Available(result) => {
+                let action_server = action_server_handle.lock();
+                Self::send_result(&*action_server, &mut result_request, result)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn send_result(
+        action_server: &rcl_action_server_t,
+        result_request: &mut rmw_request_id_t,
+        result_response: &mut RmwResultResponse<A>,
+    ) -> Result<(), RclrsError> {
+        unsafe {
+            // SAFETY: The action server handle is kept valid by the
+            // ActionServerHandle. The compiler ensures we have unique access
+            // to the result_request and result_response structures.
+            rcl_action_send_result_response(
+                action_server,
+                result_request,
+                result_response as *mut _ as *mut _,
+            )
+            .ok()
+        }
+    }
+}
diff --git a/rclrs/src/action/action_server/cancellation_state.rs b/rclrs/src/action/action_server/cancellation_state.rs
new file mode 100644
index 00000000..bde70aa1
--- /dev/null
+++ b/rclrs/src/action/action_server/cancellation_state.rs
@@ -0,0 +1,290 @@
+use crate::{
+    rcl_bindings::*,
+    vendor::{
+        action_msgs::{
+            msg::GoalInfo,
+            srv::CancelGoal_Response,
+        },
+        unique_identifier_msgs::msg::UUID,
+    },
+    log_error,
+    CancelResponseCode, GoalUuid, ToResult, Node, RclrsErrorFilter,
+};
+use super::ActionServerHandle;
+use std::{
+    borrow::Cow,
+    collections::HashSet,
+    sync::{Arc, Mutex},
+    future::Future,
+};
+use futures::{future::{select, Either}, pin_mut};
+use futures_lite::future::race;
+use rosidl_runtime_rs::{Action, Message};
+use tokio::sync::watch::{Sender, Receiver, channel as watch_channel};
+
+pub(super) struct CancellationState<A: Action> {
+    receiver: Receiver<bool>,
+    sender: Sender<bool>,
+
+    /// We put a mutex on the mode because when we respond to cancellation
+    /// requests we need to ensure that we update the cancellation mode
+    /// atomically
+    mode: Mutex<CancellationMode<A>>,
+}
+
+impl<A: Action> CancellationState<A> {
+    pub(super) fn until_cancel_requested<F: Future + Unpin>(&self, f: F) -> impl Future<Output = Result<F::Output, F>> {
+        let mut watcher = self.receiver.clone();
+        async move {
+            let cancel_requested = watcher.wait_for(|request_received| *request_received);
+            pin_mut!(cancel_requested);
+            match select(f, cancel_requested).await {
+                Either::Left((result, _)) => Ok(result),
+                Either::Right((_, f)) => Err(f),
+            }
+        }
+    }
+
+    pub(super) fn unless_cancel_requested<F: Future>(&self, f: F) -> impl Future<Output = Result<F::Output, ()>> {
+        let mut watcher = self.receiver.clone();
+        race(
+            async move {
+                Ok(f.await)
+            },
+            async move {
+                let _ = watcher.wait_for(|request_received| *request_received).await;
+                Err(())
+            }
+        )
+    }
+
+    /// Check if a cancellation is currently being requested.
+    pub(super) fn cancel_requested(&self) -> bool {
+        *self.receiver.borrow()
+    }
+
+    pub(super) fn request_cancellation(
+        &self,
+        request: CancellationRequest<A>,
+        uuid: &GoalUuid,
+    ) {
+        let mut mode = self.mode.lock().unwrap();
+        match &mut *mode {
+            CancellationMode::None => {
+                let requests = Vec::from_iter([request]);
+                *mode = CancellationMode::CancelRequested(requests);
+            }
+            CancellationMode::CancelRequested(requests) => {
+                requests.push(request);
+            }
+            CancellationMode::Cancelling => {
+                request.accept(*uuid);
+            }
+        }
+    }
+
+    /// Tell current cancellation requesters that their requests are rejected
+    pub(super) fn reject_cancellation(&self, uuid: &GoalUuid) {
+        let mut mode = self.mode.lock().unwrap();
+        match &mut *mode {
+            CancellationMode::CancelRequested(requesters) => {
+                for requester in requesters.drain(..) {
+                    requester.reject(*uuid);
+                }
+
+                // Revert to not having any cancellation mode
+                *mode = CancellationMode::None;
+                // We do not need to worry about errors from sending this state
+                // since it is okay for the receiver to be dropped.
+                let _ = self.sender.send(false);
+            }
+            CancellationMode::None => {
+                // Do nothing
+            }
+            CancellationMode::Cancelling => {
+                // Do nothing. We will not revert a cancellation state.
+            }
+        }
+    }
+
+    /// Tell current and future cancellation requesters that their requests are
+    /// accepted
+    pub(super) fn accept_cancellation(&self, uuid: &GoalUuid) {
+        let mut mode = self.mode.lock().unwrap();
+        match &mut *mode {
+            CancellationMode::CancelRequested(requesters) => {
+                for requester in requesters.drain(..) {
+                    requester.accept(*uuid);
+                }
+
+                // Progress to cancelling mode
+                *mode = CancellationMode::Cancelling;
+                // Just in case this signal was never sent, make sure we have
+                // a true value in the cancel requested channel. We can ignore
+                // errors from this because it is okay for the receiver to be
+                // dropped.
+                let _ = self.sender.send(true);
+            }
+            CancellationMode::None => {
+                // Skip straight to cancellation mode since the user has accepted
+                // a cancellation even though it wasn't requested externally.
+                *mode = CancellationMode::Cancelling;
+                // Make sure the cancellation is signalled. We can ignore errors
+                // from this because it is okay for the receiver to be dropped.
+                let _ = self.sender.send(true);
+            }
+            CancellationMode::Cancelling => {
+                // Do nothing
+            }
+        }
+    }
+}
+
+impl<A: Action> Default for CancellationState<A> {
+    fn default() -> Self {
+        let (sender, receiver) = watch_channel(false);
+        Self {
+            receiver,
+            sender,
+            mode: Mutex::new(CancellationMode::None),
+        }
+    }
+}
+
+pub(super) enum CancellationMode<A: Action> {
+    None,
+    CancelRequested(Vec<CancellationRequest<A>>),
+    Cancelling,
+}
+
+/// This struct exists to deal with the fact that a single cancellation request
+/// can trigger multiple goal cancellations at once. This allows us to
+/// asynchronously receive the accept/reject results from all the different goals
+/// and then issue the reply once all are received.
+pub(super) struct CancellationRequest<A: Action> {
+    inner: Arc<Mutex<CancellationRequestInner<A>>>,
+}
+
+impl<A: Action> Clone for CancellationRequest<A> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: Arc::clone(&self.inner)
+        }
+    }
+}
+
+impl<A: Action> CancellationRequest<A> {
+    pub(super) fn new(
+        id: rmw_request_id_t,
+        waiting_for: Vec<GoalUuid>,
+        server: Arc<ActionServerHandle<A>>,
+        node: Node,
+    ) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(CancellationRequestInner {
+                id,
+                waiting_for,
+                server,
+                node,
+                received: Default::default(),
+                accepted: Vec::new(),
+                response_sent: false,
+            }))
+        }
+    }
+
+    pub(super) fn accept(&self, uuid: GoalUuid) {
+        let mut inner = self.inner.lock().unwrap();
+        if !inner.received.insert(uuid) {
+            return;
+        }
+
+        let stamp = inner.node.get_clock().now().to_ros_msg().unwrap_or_default();
+        let info = GoalInfo {
+            goal_id: UUID { uuid: *uuid },
+            stamp,
+        };
+
+        inner.accepted.push(info);
+        inner.respond_if_ready();
+    }
+
+    fn reject(&self, uuid: GoalUuid) {
+        let mut inner = self.inner.lock().unwrap();
+        if !inner.received.insert(uuid) {
+            return;
+        }
+
+        inner.respond_if_ready();
+    }
+
+}
+
+struct CancellationRequestInner<A: Action> {
+    id: rmw_request_id_t,
+    waiting_for: Vec<GoalUuid>,
+    received: HashSet<GoalUuid>,
+    accepted: Vec<GoalInfo>,
+    response_sent: bool,
+    server: Arc<ActionServerHandle<A>>,
+    node: Node,
+}
+
+impl<A: Action> CancellationRequestInner<A> {
+    fn respond_if_ready(&mut self) {
+        for expected in &self.waiting_for {
+            if !self.received.contains(expected) {
+                return;
+            }
+        }
+
+        self.respond();
+    }
+
+    fn respond(&mut self) {
+        if self.response_sent {
+            return;
+        }
+
+        self.response_sent = true;
+
+        let mut response = CancelGoal_Response::default();
+        response.goals_canceling = self.accepted.drain(..).collect();
+        if response.goals_canceling.is_empty() {
+            response.return_code = CancelResponseCode::Reject as i8;
+        } else {
+            response.return_code = CancelResponseCode::Accept as i8;
+        }
+
+        let mut response_rmw = CancelGoal_Response::into_rmw_message(Cow::Owned(response)).into_owned();
+        let r = unsafe {
+            // SAFETY: The action server handle is locked and so synchronized with other functions.
+            // The request_id and response are both uniquely owned or borrowed, and so neither will
+            // mutate during this function call.
+            rcl_action_send_cancel_response(
+                &*self.server.lock(),
+                &mut self.id,
+                &mut response_rmw as *mut _ as *mut _,
+            )
+        }
+        .ok()
+        .timeout_ok();
+
+        if let Err(err) = r {
+            log_error!(
+                "CancellationRequest.respond",
+                "Error occurred while responding to a cancellation request: {err}"
+            )
+        }
+    }
+}
+
+impl<A: Action> Drop for CancellationRequestInner<A> {
+    fn drop(&mut self) {
+        if !self.response_sent {
+            // As a last resort, send the response if all possible responders
+            // have dropped.
+            self.respond();
+        }
+    }
+}
diff --git a/rclrs/src/action/action_server/cancelling_goal.rs b/rclrs/src/action/action_server/cancelling_goal.rs
new file mode 100644
index 00000000..351f0559
--- /dev/null
+++ b/rclrs/src/action/action_server/cancelling_goal.rs
@@ -0,0 +1,74 @@
+use super::{LiveActionServerGoal, FeedbackPublisher, TerminatedGoal};
+use std::sync::Arc;
+use rosidl_runtime_rs::Action;
+
+/// This represents a goal that is in the Cancelling state. This struct is held
+/// by an action server implementation and is used to provide feedback to the
+/// client and to transition the goal into its next state. There is no need to
+/// listen for cancellation requests since being in this state means all incoming
+/// cancellation requests will automatically be accepted.
+///
+/// If you drop this struct without explicitly transitioning it to its next state,
+/// the goal will report itself as aborted.
+pub struct CancellingGoal<A: Action> {
+    live: Arc<LiveActionServerGoal<A>>,
+}
+
+impl<A: Action> CancellingGoal<A> {
+    /// Get the goal of this action.
+    #[must_use]
+    pub fn goal(&self) -> &Arc<A::Goal> {
+        self.live.goal()
+    }
+
+    /// Terminate the goal with a cancelled state and a specific result value.
+    ///
+    /// "Cancelled" is a terminal state, so the state of the goal can no longer
+    /// be changed after this. Publish all relevant feedback before calling this.
+    pub fn cancelled_with(self, result: A::Result) -> TerminatedGoal {
+        self.live.transition_to_cancelled(result);
+        TerminatedGoal { uuid: *self.live.goal_id() }
+    }
+
+    /// Transition the goal into the succeeded state.
+    ///
+    /// "Succeeded" is a terminal state, so the state of the goal can no longer
+    /// be changed after this. Publish all relevant feedback before calling this.
+    pub fn succeeded_with(self, result: A::Result) -> TerminatedGoal {
+        self.live.transition_to_succeed(result);
+        TerminatedGoal { uuid: *self.live.goal_id() }
+    }
+
+    /// Transition the goal into the aborted state.
+    ///
+    /// "Aborted" is a terminal state, so the state of the goal can no longer
+    /// be changed after this. Publish all relevant feedback before calling this.
+    pub fn aborted_with(self, result: A::Result) -> TerminatedGoal {
+        self.live.transition_to_aborted(result);
+        TerminatedGoal { uuid: *self.live.goal_id() }
+    }
+
+    /// Publish feedback for action clients to read.
+    ///
+    /// If you need to publish feedback from a separate thread or async task
+    /// which does not have direct access to the goal's state machine, you can
+    /// use [`Self::feedback_publisher`] to get a handle that you can pass along.
+    pub fn publish_feedback(&self, feedback: A::Feedback) {
+        self.live.publish_feedback(feedback);
+    }
+
+    /// Get a handle specifically for publishing feedback for this goal. This
+    /// publisher can be used separately from the overall state machine of the
+    /// goal, but it will stop working once the goal reaches a terminal state.
+    ///
+    /// If you just need to publish a one-off feedback message, you can use
+    /// [`Self::publish_feedback`].
+    pub fn feedback_publisher(&self) -> FeedbackPublisher<A> {
+        FeedbackPublisher::new(Arc::clone(&self.live))
+    }
+
+    pub(super) fn new(live: Arc<LiveActionServerGoal<A>>) -> Self {
+        live.transition_to_cancelling();
+        Self { live }
+    }
+}
diff --git a/rclrs/src/action/action_server/executing_goal.rs b/rclrs/src/action/action_server/executing_goal.rs
new file mode 100644
index 00000000..179111bf
--- /dev/null
+++ b/rclrs/src/action/action_server/executing_goal.rs
@@ -0,0 +1,133 @@
+use super::{CancellingGoal, FeedbackPublisher, LiveActionServerGoal, TerminatedGoal};
+use std::{
+    future::Future,
+    sync::Arc,
+};
+use rosidl_runtime_rs::Action;
+
+/// This represents a goal that is in the Executing state. This struct is held
+/// by an action server implementation and is used to provide feedback to the
+/// client, to listen for cancellation requests, and to transition the goal into
+/// its next state.
+///
+/// If you drop this struct without explicitly transitioning it to its next state,
+/// the goal will report itself as aborted.
+pub struct ExecutingGoal<A: Action> {
+    live: Arc<LiveActionServerGoal<A>>,
+}
+
+impl<A: Action> ExecutingGoal<A> {
+    /// Get the goal of this action.
+    pub fn goal(&self) -> &Arc<A::Goal> {
+        self.live.goal()
+    }
+
+    /// Transition the goal into the succeeded state.
+    ///
+    /// "Succeeded" is a terminal state, so the state of the goal can no longer
+    /// be changed after this. Publish all relevant feedback before calling this.
+    pub fn succeeded_with(self, result: A::Result) -> TerminatedGoal {
+        self.live.transition_to_succeed(result);
+        TerminatedGoal { uuid: *self.live.goal_id() }
+    }
+
+    /// Process a [`Future`] until it is finished or until a cancellation request
+    /// is received.
+    ///
+    /// If the [`Future`] finishes, its output will be provided in [`Ok`].
+    ///
+    /// If a cancellation request is received before the [`Future`] is finished,
+    /// you will receive an [`Err`] with the current state of the [`Future`],
+    /// which you can continue processing later if you choose. If you would rather
+    /// discard the [`Future`] when a cancellation request is received, you can
+    /// call [`Self::unless_cancel_requested`] instead.
+    ///
+    /// After the cancellation request is received, you will still need to trigger
+    /// [`Self::begin_cancelling`] or [`Self::reject_cancellation`] to respond to
+    /// the request. Otherwise the cancellation request will not receive a response
+    /// until the goal reaches a terminal state.
+    //
+    // TODO(@mxgrey): Add a doctest and example for this.
+    pub async fn until_cancel_requested<F: Future + Unpin>(&self, f: F) -> Result<F::Output, F> {
+        self.live.cancellation().until_cancel_requested(f).await
+    }
+
+    /// Process a [`Future`] until it is finished unless a cancellation request
+    /// is received.
+    ///
+    /// If the [`Future`] finishes, its output will be provided in [`Ok`].
+    ///
+    /// If a cancellation request is received before the [`Future`] is finished,
+    /// the [`Future`] will be discarded. This allows non-[`Unpin`] futures to
+    /// be passed to this method. If your future implements [`Unpin`] and you want
+    /// the option to keep processing it after the cancellation request is received,
+    /// then you can call [`Self::until_cancel_requested`] instead.
+    ///
+    /// After the cancellation request is received, you will still need to trigger
+    /// [`Self::begin_cancelling`] or [`Self::reject_cancellation`] to respond to
+    /// the request. Otherwise the cancellation request will not receive a response
+    /// until the goal reaches a terminal state.
+    //
+    // TODO(@mxgrey): Add a doctest and example for this.
+    pub async fn unless_cancel_requested<F: Future>(&self, f: F) -> Result<F::Output, ()> {
+        self.live.cancellation().unless_cancel_requested(f).await
+    }
+
+    /// Transition the goal into the cancelling state.
+    ///
+    /// This does not require an action client to request a cancellation. If no
+    /// cancellation was requested, then using this function will have your action
+    /// server act as an action client that is commanding that the goal transition
+    /// to cancel.
+    ///
+    /// If there are any open cancellation requests for this goal from any action
+    /// clients, they will all be notified that the cancellation is accepted. Any
+    /// new cancellation requests that arrive for the goal after this will
+    /// automatically be accepted.
+    ///
+    /// For the goal to reach the cancelled state, you must follow this up with
+    /// [`CancellingGoal::cancelled_with`].
+    #[must_use]
+    pub fn begin_cancelling(self) -> CancellingGoal<A> {
+        CancellingGoal::new(self.live)
+    }
+
+    /// If there are any open cancellation requests for this goal, reject them.
+    /// This does not transition the goal in any way.
+    pub fn reject_cancellation(&self) {
+        self.live.reject_cancellation();
+    }
+
+    /// Transition the goal into the aborted state.
+    ///
+    /// "Aborted" is a terminal state, so the state of the goal can no longer
+    /// be changed after this. Publish all relevant feedback before calling this.
+    pub fn aborted_with(self, result: A::Result) -> TerminatedGoal {
+        self.live.transition_to_aborted(result);
+        TerminatedGoal { uuid: *self.live.goal_id() }
+    }
+
+    /// Publish feedback for action clients to read.
+    ///
+    /// If you need to publish feedback from a separate thread or async task
+    /// which does not have direct access to the goal's state machine, you can
+    /// use [`Self::feedback_publisher`] to get a handle that you can pass along.
+    pub fn publish_feedback(&self, feedback: A::Feedback) {
+        self.live.publish_feedback(feedback);
+    }
+
+    /// Get a handle specifically for publishing feedback for this goal. This
+    /// publisher can be used separately from the overall state machine of the
+    /// goal, but it will stop working once the goal reaches a terminal state.
+    ///
+    /// If you just need to publish a one-off feedback message, you can use
+    /// [`Self::publish_feedback`].
+    pub fn feedback_publisher(&self) -> FeedbackPublisher<A> {
+        FeedbackPublisher::new(Arc::clone(&self.live))
+    }
+
+    pub(super) fn new(live: Arc<LiveActionServerGoal<A>>) -> Self {
+        live.transition_to_executing();
+        Self { live }
+    }
+}
diff --git a/rclrs/src/action/action_server/feedback_publisher.rs b/rclrs/src/action/action_server/feedback_publisher.rs
new file mode 100644
index 00000000..ca714d17
--- /dev/null
+++ b/rclrs/src/action/action_server/feedback_publisher.rs
@@ -0,0 +1,22 @@
+use super::LiveActionServerGoal;
+use std::sync::Arc;
+use rosidl_runtime_rs::Action;
+
+/// Use this to send feedback from an action server. This struct can be cloned
+/// and sent to other threads without the main goal handle. It can continue to
+/// send feedback until the goal has reached a terminal state.
+#[derive(Clone)]
+pub struct FeedbackPublisher<A: Action> {
+    live: Arc<LiveActionServerGoal<A>>,
+}
+
+impl<A: Action> FeedbackPublisher<A> {
+    /// Publish a feedback message, unless the goal has reached a terminal state.
+    pub fn publish(&self, feedback: A::Feedback) -> Result<(), A::Feedback> {
+        self.live.safe_publish_feedback(feedback)
+    }
+
+    pub(super) fn new(live: Arc<LiveActionServerGoal<A>>) -> Self {
+        Self { live }
+    }
+}
diff --git a/rclrs/src/action/action_server/live_action_server_goal.rs b/rclrs/src/action/action_server/live_action_server_goal.rs
new file mode 100644
index 00000000..32222b44
--- /dev/null
+++ b/rclrs/src/action/action_server/live_action_server_goal.rs
@@ -0,0 +1,290 @@
+use crate::{
+    rcl_bindings::*,
+    log_error,
+    RclrsError, ToResult,
+};
+use super::{
+    ActionServerGoalHandle, ActionServerHandle, CancellationState,
+    CancellationRequest, GoalStatusCode, TerminalStatus,
+};
+use std::{
+    borrow::Cow,
+    sync::Arc,
+    ops::Deref,
+};
+use rosidl_runtime_rs::{Action, Message};
+
+/// This struct is the bridge to the rcl_action API for action server goals that
+/// are still active. It can be used to perform transitions while keeping data in
+/// sync between the rclrs user and the rcl_action library.
+///
+/// When this is dropped, the goal will automatically be transitioned into the
+/// aborted status if the user did not transition the goal into a different
+/// terminal status before dropping it.
+pub(super) struct LiveActionServerGoal<A: Action> {
+    goal_request: Arc<A::Goal>,
+    cancellation: Arc<CancellationState<A>>,
+    handle: Arc<ActionServerGoalHandle<A>>,
+    server: Arc<ActionServerHandle<A>>,
+}
+
+impl<A: Action> LiveActionServerGoal<A> {
+    pub(super) fn new(
+        handle: Arc<ActionServerGoalHandle<A>>,
+        server: Arc<ActionServerHandle<A>>,
+        goal_request: Arc<A::Goal>,
+    ) -> Self {
+        Self {
+            handle,
+            server,
+            goal_request,
+            cancellation: Default::default(),
+        }
+    }
+
+    /// Get the user-provided message describing the goal.
+    pub(super) fn goal(&self) -> &Arc<A::Goal> {
+        &self.goal_request
+    }
+
+    /// Has a cancellation been requested for this goal.
+    pub(super) fn cancel_requested(&self) -> bool {
+        self.cancellation.cancel_requested()
+    }
+
+    pub(super) fn cancellation(&self) -> &Arc<CancellationState<A>> {
+        &self.cancellation
+    }
+
+    pub(super) fn request_cancellation(&self, request: CancellationRequest<A>) {
+        self.cancellation.request_cancellation(request, self.goal_id());
+    }
+
+    /// Indicate that the goal is being cancelled.
+    ///
+    /// This is called when a cancel request for the goal has been accepted.
+    ///
+    /// Returns an error if the goal is in any state other than accepted or executing.
+    pub(super) fn transition_to_cancelling(&self) {
+        self.cancellation.accept_cancellation(self.goal_id());
+        let r = self.update_state(rcl_action_goal_event_t::GOAL_EVENT_CANCEL_GOAL);
+        if let Err(err) = r {
+            log_error!(
+                "live_action_server_goal.transition_to_cancelling",
+                "Failed to transition to the cancelling state. This error should \
+                not happen, please report it to the maintainers of rclrs: {err}",
+            );
+        }
+    }
+
+    /// If there are any open cancellation requests, they will be rejected and
+    /// the [`CancellationMode`] will be restored to [`CancellationMode::None`].
+    ///
+    /// This function has no effect if the goal is already in the cancelling state.
+    pub(super) fn reject_cancellation(&self) {
+        self.cancellation.reject_cancellation(self.goal_id());
+    }
+
+    /// Indicate that the goal could not be reached and has been aborted.
+    ///
+    /// Only call this if the goal is executing but cannot be completed. This is a terminal state,
+    /// so no more methods may be called on a goal handle after this is called.
+    ///
+    /// Returns an error if the goal is in any state other than executing.
+    pub(super) fn transition_to_aborted(&self, result: A::Result) {
+        let r = self
+            .update_state(rcl_action_goal_event_t::GOAL_EVENT_ABORT)
+            .and_then(|_| self.terminate_goal(TerminalStatus::Aborted, result));
+
+        if let Err(err) = r {
+            log_error!(
+                "live_action_server_goal.transition_to_aborted",
+                "Failed to transition to the aborted state. This error should not \
+                happen, please report it to the maintainers of rclrs: {err}",
+            );
+        }
+    }
+
+    /// Indicate that the goal has succeeded.
+    ///
+    /// Only call this if the goal is executing and has reached the desired final state. This is a
+    /// terminal state, so no more methods may be called on a goal handle after this is called.
+    ///
+    /// Returns an error if the goal is in any state other than executing.
+    pub(super) fn transition_to_succeed(&self, result: A::Result) {
+        let r = self
+            .update_state(rcl_action_goal_event_t::GOAL_EVENT_SUCCEED)
+            .and_then(|_| self.terminate_goal(TerminalStatus::Succeeded, result));
+
+        if let Err(err) = r {
+            log_error!(
+                "live_action_server_goal.transition_to_succeed",
+                "Failed to transition to the succeeded state. This error should not \
+                happen, please report it to the maintainers of rclrs: {err}",
+            );
+        }
+    }
+
+    /// Indicate that the goal has been cancelled.
+    ///
+    /// Only call this if the goal is executing or pending, but has been cancelled. This is a
+    /// terminal state, so no more methods may be called on a goal handle after this is called.
+    ///
+    /// Returns an error if the goal is in any state other than executing or pending.
+    pub(super) fn transition_to_cancelled(&self, result: A::Result) {
+        let r = self
+            .update_state(rcl_action_goal_event_t::GOAL_EVENT_CANCELED)
+            .and_then(|_| self.terminate_goal(TerminalStatus::Cancelled, result));
+
+        if let Err(err) = r {
+            log_error!(
+                "live_action_server_goal.transition_to_cancelled",
+                "Failed to transition to cancelled state. This error should not \
+                happen, please report it to the maintainers of rclrs: {err}",
+            );
+        }
+    }
+
+    /// Indicate that the server is starting to execute the goal.
+    ///
+    /// Only call this if the goal is pending. This is a terminal state, so no more methods may be
+    /// called on a goal handle after this is called.
+    ///
+    /// Returns an error if the goal is in any state other than pending.
+    pub(super) fn transition_to_executing(&self) {
+        let r = self
+            .update_state(rcl_action_goal_event_t::GOAL_EVENT_EXECUTE)
+            .and_then(|_| self.server.publish_status());
+
+        if let Err(err) = r {
+            log_error!(
+                "live_action_server_goal.transition_to_executing",
+                "Failed to transition to executing status. This error should \
+                not happen, please report it to the maintainers of rclrs: {err}",
+            );
+        }
+    }
+
+    /// Send an update about the goal's progress.
+    ///
+    /// This should only be called in between a goal being accepted and terminated,
+    /// but that is not enforced in this method.
+    pub(super) fn publish_feedback(&self, feedback: A::Feedback) {
+        let feedback_rmw = <<A as Action>::Feedback as Message>::into_rmw_message(Cow::Owned(feedback));
+        let mut feedback_msg = <A as Action>::create_feedback_message(&*self.goal_id(), feedback_rmw.into_owned());
+        let r = unsafe {
+            // SAFETY: The action server is locked through the handle, meaning that no other
+            // non-thread-safe functions can be called on it at the same time. The feedback_msg is
+            // exclusively owned here, ensuring that it won't be modified during the call.
+            // rcl_action_publish_feedback() guarantees that it won't modify `feedback_msg`.
+            rcl_action_publish_feedback(
+                &*self.server.lock(),
+                &mut feedback_msg as *mut _ as *mut _,
+            )
+            .ok()
+        };
+
+        if let Err(err) = r {
+            // This is not an error that should be able to occur.
+            log_error!(
+                "live_action_server_goal.publish_feedback",
+                "Failed to publish feedback for an action server goal. This should \
+                not happen, please report it to the maintainers of rclrs: {err}",
+            );
+        }
+    }
+
+    /// Atomically check the state of the goal and send feedback if the state
+    /// has not terminated.
+    ///
+    /// This is used by [`crate::FeedbackSender`] to ensure that it does not
+    /// send feedback in an unacceptable state, even if the state of the goal
+    /// may change while it tries to send the feedback.
+    pub(super) fn safe_publish_feedback(&self, feedback: A::Feedback) -> Result<(), A::Feedback> {
+        let goal_handle = self.handle.lock();
+
+        let mut state = GoalStatusCode::Unknown as rcl_action_goal_state_t;
+        let r = unsafe {
+            // SAFETY: The goal handle is properly initialized and its mutex is locked
+            rcl_action_goal_handle_get_status(&*goal_handle, &mut state).ok()
+        };
+        if let Err(err) = r {
+            log_error!(
+                "LiveActionServerGoal.safe_publish_feedback",
+                "Unexpected error while getting status: {err}",
+            );
+            return Err(feedback);
+        }
+
+        // The goal's rcl_handle mutex is locked and will prevent the goal status from
+        // being changed until this function is finished.
+        //
+        // The publish_feedback method does not need to lock the goal's rcl_handle
+        // so there is no double-lock to worry about.
+        self.publish_feedback(feedback);
+        Ok(())
+    }
+
+    fn terminate_goal(
+        &self,
+        status: TerminalStatus,
+        result: A::Result,
+    ) -> Result<(), RclrsError> {
+        let result_rmw = <A::Result as Message>::into_rmw_message(Cow::Owned(result)).into_owned();
+        let response_rmw = <A as Action>::create_result_response(status as i8, result_rmw);
+        self.handle.provide_result(self.server.as_ref(), response_rmw)?;
+
+        // Publish the state change.
+        self.server.publish_status()?;
+
+        // Notify rcl that a goal has terminated and to therefore recalculate the expired goal timer.
+        unsafe {
+            // SAFETY: The action server is locked and valid. No other preconditions.
+            rcl_action_notify_goal_done(&*self.server.lock())
+        }
+        .ok()?;
+
+        Ok(())
+    }
+
+    /// Attempt to perform the given goal state transition.
+    fn update_state(&self, event: rcl_action_goal_event_t) -> Result<(), RclrsError> {
+        let mut rcl_handle = self.handle.lock();
+        // SAFETY: The provided goal handle is properly initialized by construction.
+        unsafe { rcl_action_update_goal_state(&mut *rcl_handle, event).ok() }
+    }
+}
+
+impl<A: Action> Deref for LiveActionServerGoal<A> {
+    type Target = ActionServerGoalHandle<A>;
+
+    fn deref(&self) -> &Self::Target {
+        self.handle.as_ref()
+    }
+}
+
+impl<A: Action> Drop for LiveActionServerGoal<A> {
+    fn drop(&mut self) {
+        match self.get_status() {
+            GoalStatusCode::Accepted => {
+                // Transition into executing and then into aborted to reach a
+                // terminal state.
+                self.transition_to_executing();
+                self.transition_to_aborted(Default::default());
+            }
+            GoalStatusCode::Cancelling | GoalStatusCode::Executing => {
+                self.transition_to_aborted(Default::default());
+            }
+            GoalStatusCode::Succeeded | GoalStatusCode::Cancelled | GoalStatusCode::Aborted => {
+                // Already in a terminal state, no need to do anything.
+            }
+            GoalStatusCode::Unknown => {
+                log_error!(
+                    "LiveActionServerGoal.drop",
+                    "Goal status is unknown. This indicates a bug, please \
+                    report this to the maintainers of rclrs."
+                );
+            }
+        }
+    }
+}
diff --git a/rclrs/src/action/action_server/requested_goal.rs b/rclrs/src/action/action_server/requested_goal.rs
new file mode 100644
index 00000000..937809e8
--- /dev/null
+++ b/rclrs/src/action/action_server/requested_goal.rs
@@ -0,0 +1,164 @@
+use crate::{
+    rcl_bindings::*,
+    log_error,
+    GoalUuid, RclrsError, RclrsErrorFilter, ToResult,
+};
+use super::{ActionServerGoalBoard, ActionServerGoalHandle, LiveActionServerGoal, AcceptedGoal, TerminatedGoal};
+use std::sync::Arc;
+use rosidl_runtime_rs::Action;
+
+/// An action goal that has been requested but not accepted yet. If this is
+/// dropped without being accepted then the goal request will be rejected.
+pub struct RequestedGoal<A: Action> {
+    board: Arc<ActionServerGoalBoard<A>>,
+    goal_request: Arc<A::Goal>,
+    uuid: GoalUuid,
+    goal_request_id: rmw_request_id_t,
+    accepted: bool,
+}
+
+impl<A: Action> RequestedGoal<A> {
+    /// Get the goal of this action.
+    #[must_use]
+    pub fn goal(&self) -> &Arc<A::Goal> {
+        &self.goal_request
+    }
+
+    /// Accept the requested goal. The action client will be notified that the
+    /// goal was accepted, and you will be able to begin executing.
+    ///
+    /// This will panic if a [`RclrsError::GoalAcceptanceError`] occurs which
+    /// most likely indicates a memory allocation failure, which the program is
+    /// not likely to recover from anyway.
+    #[must_use]
+    pub fn accept(self) -> AcceptedGoal<A> {
+        self.try_accept().unwrap()
+    }
+
+    /// An alternative to [`RequestedGoal::accept`] which does not panic in the
+    /// event of an error.
+    #[must_use]
+    pub fn try_accept(mut self) -> Result<AcceptedGoal<A>, RclrsError> {
+        let handle = {
+            let mut goal_info = unsafe {
+                // SAFETY: Zero-initialized rcl structs are always safe to make
+                rcl_action_get_zero_initialized_goal_info()
+            };
+            goal_info.goal_id.uuid = *self.uuid;
+            goal_info.stamp = self.board.node().get_clock().now().to_rcl().unwrap_or(
+                builtin_interfaces__msg__Time { sec: 0, nanosec: 0 }
+            );
+
+            let mut server_handle = self.board.handle.lock();
+            let goal_handle_ptr = unsafe {
+                // SAFETY: The action server handle is locked and so synchronized with other
+                // functions. The request_id and response message are uniquely owned, and so will
+                // not mutate during this function call. The returned goal handle pointer should be
+                // valid unless it is null.
+                rcl_action_accept_new_goal(&mut *server_handle, &goal_info)
+            };
+
+            if goal_handle_ptr.is_null() {
+                return Err(RclrsError::GoalAcceptanceError);
+            }
+
+            let mut goal_handle = rcl_action_goal_handle_t {
+                impl_: std::ptr::null_mut(),
+            };
+
+            unsafe {
+                // SAFETY: We receive a loose pointer since the function call is
+                // fallible, but the loose pointer we receive is actually managed
+                // internally by rcl_action, so we must not retain its pointer
+                // value. Instead we need to copy its internal impl* into a new
+                // struct which we will take ownership of.
+                //
+                // It remains our responsibility to call `rcl_action_goal_handle_fini`
+                // on the copy of the `rcl_action_goal_handle_t` because rcl_action
+                // will not manage the memory of the inner impl*.
+                goal_handle.impl_ = (*goal_handle_ptr).impl_;
+            };
+
+            Arc::new(ActionServerGoalHandle::new(goal_handle, self.uuid))
+        };
+
+        // We need to store a strong reference to the goal handle in the action
+        // server handle to ensure the goal handle outlives its use within the
+        // action server.
+        self.board.handle.goals.lock().unwrap().insert(*handle.goal_id(), Arc::clone(&handle));
+
+        self.accepted = true;
+        if let Err(err) = self.send_goal_response() {
+            log_error!(
+                "requested_goal.try_accept",
+                "Failed to send an action goal acceptance response: {err}",
+            );
+        }
+
+        let live = Arc::new(LiveActionServerGoal::new(
+            handle,
+            Arc::clone(&self.board.handle),
+            Arc::clone(&self.goal_request),
+        ));
+
+        // Add the live goal to the goal board so the action server executor can
+        // interact with it.
+        self.board.live_goals.lock().unwrap().insert(self.uuid, Arc::downgrade(&live));
+
+        Ok(AcceptedGoal::new(live))
+    }
+
+    /// Reject this goal request.
+    ///
+    /// This is the same as simply allowing the [`RequestedGoal`] to drop without
+    /// accepting.
+    pub fn reject(self) -> TerminatedGoal {
+        // This function does not need to do anything to transition the goal. It
+        // will simply drop the RequestedGoal, and the custom Drop implementation
+        // will notify the action server that the goal is rejected.
+        TerminatedGoal { uuid: self.uuid }
+    }
+
+    fn send_goal_response(&mut self) -> Result<(), RclrsError> {
+        let stamp = self.board.node().get_clock().now().to_sec_nanosec().unwrap_or((0, 0));
+        let mut response_rmw = <A as Action>::create_goal_response(self.accepted, stamp);
+        unsafe {
+            rcl_action_send_goal_response(
+                &*self.board.handle.lock(),
+                &mut self.goal_request_id,
+                &mut response_rmw as *mut _ as *mut _,
+            )
+        }
+        .ok()
+        .timeout_ok()
+    }
+
+    pub(super) fn new(
+        board: Arc<ActionServerGoalBoard<A>>,
+        goal_request: Arc<A::Goal>,
+        uuid: GoalUuid,
+        goal_request_id: rmw_request_id_t,
+    ) -> Self {
+        Self {
+            board,
+            goal_request,
+            uuid,
+            goal_request_id,
+            accepted: false,
+        }
+    }
+}
+
+impl<A: Action> Drop for RequestedGoal<A> {
+    fn drop(&mut self) {
+        if !self.accepted {
+            // We should notify that the goal has been rejected.
+            if let Err(err) = self.send_goal_response() {
+                log_error!(
+                    "RequestedGoal.drop",
+                    "Error occurred while attempting to reject a goal: {err}",
+                );
+            }
+        }
+    }
+}
diff --git a/rclrs/src/action/action_server/terminated_goal.rs b/rclrs/src/action/action_server/terminated_goal.rs
new file mode 100644
index 00000000..6afc8a6a
--- /dev/null
+++ b/rclrs/src/action/action_server/terminated_goal.rs
@@ -0,0 +1,18 @@
+use crate::GoalUuid;
+
+/// This represents a goal that has reached a terminated state. This struct is
+/// used as the return value for action server callbacks to guide the user to
+/// bring the goal to a terminal state.
+///
+/// It is safe to allow this struct to drop if you are using an action goal
+/// receiver instead of an action server callback.
+pub struct TerminatedGoal {
+    pub(super) uuid: GoalUuid,
+}
+
+impl TerminatedGoal {
+    /// Get the UUID of the goal that was terminated.
+    pub fn uuid(&self) -> &GoalUuid {
+        &self.uuid
+    }
+}
diff --git a/rclrs/src/client.rs b/rclrs/src/client.rs
index 971d4f88..a4b167ac 100644
--- a/rclrs/src/client.rs
+++ b/rclrs/src/client.rs
@@ -10,7 +10,7 @@ use rosidl_runtime_rs::Message;
 use crate::{
     error::ToResult, log_fatal, rcl_bindings::*, IntoPrimitiveOptions, MessageCow, Node, Promise,
     QoSProfile, RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclReturnCode, RclrsError,
-    ServiceInfo, Waitable, WaitableLifecycle, ENTITY_LIFECYCLE_MUTEX,
+    ReadyKind, ServiceInfo, Waitable, WaitableLifecycle, ENTITY_LIFECYCLE_MUTEX,
 };
 
 mod client_async_callback;
@@ -415,7 +415,8 @@ impl<T> RclPrimitive for ClientExecutable<T>
 where
     T: rosidl_runtime_rs::Service,
 {
-    unsafe fn execute(&mut self, _: &mut dyn Any) -> Result<(), RclrsError> {
+    unsafe fn execute(&mut self, ready: ReadyKind, _: &mut dyn Any) -> Result<(), RclrsError> {
+        ready.for_basic()?;
         self.board.lock().unwrap().execute(&self.handle)
     }
 
diff --git a/rclrs/src/clock.rs b/rclrs/src/clock.rs
index 992cd4b4..8dd54345 100644
--- a/rclrs/src/clock.rs
+++ b/rclrs/src/clock.rs
@@ -88,6 +88,11 @@ impl Clock {
         Self { kind, rcl_clock }
     }
 
+    /// Returns the clock's `rcl_clock_t`.
+    pub(crate) fn get_rcl_clock(&self) -> &Arc<Mutex<rcl_clock_t>> {
+        &self.rcl_clock
+    }
+
     /// Returns the clock's `ClockType`.
     pub fn clock_type(&self) -> ClockType {
         self.kind
diff --git a/rclrs/src/drop_guard.rs b/rclrs/src/drop_guard.rs
new file mode 100644
index 00000000..bd57d707
--- /dev/null
+++ b/rclrs/src/drop_guard.rs
@@ -0,0 +1,48 @@
+use std::{
+    mem::ManuallyDrop,
+    ops::{Deref, DerefMut},
+};
+
+/// A wrapper providing additional drop-logic for the contained value.
+///
+/// When this wrapper is dropped, the contained value will be passed into the given function before
+/// being destructed.
+pub(crate) struct DropGuard<T> {
+    value: ManuallyDrop<T>,
+    drop_fn: fn(T),
+}
+
+impl<T> DropGuard<T> {
+    /// Create a new `DropGuard` with the given value and drop function.
+    pub fn new(value: T, drop_fn: fn(T)) -> Self {
+        Self {
+            value: ManuallyDrop::new(value),
+            drop_fn,
+        }
+    }
+}
+
+impl<T> Deref for DropGuard<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &*self.value
+    }
+}
+
+impl<T> DerefMut for DropGuard<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut *self.value
+    }
+}
+
+impl<T> Drop for DropGuard<T> {
+    fn drop(&mut self) {
+        // SAFETY: ManuallyDrop::take() leaves `self.value` in an uninitialized state, meaning that
+        // it must not be accessed further. This is guaranteed since `self` is being dropped and
+        // cannot be accessed after this function completes. Moreover, the strict ownership of
+        // `self.value` means that it cannot be accessed by `self.drop_fn`'s drop function either.
+        let value = unsafe { ManuallyDrop::take(&mut self.value) };
+        (self.drop_fn)(value);
+    }
+}
diff --git a/rclrs/src/error.rs b/rclrs/src/error.rs
index b177aaaf..bd7a826a 100644
--- a/rclrs/src/error.rs
+++ b/rclrs/src/error.rs
@@ -2,9 +2,10 @@ use std::{
     error::Error,
     ffi::{CStr, NulError},
     fmt::{self, Display},
+    sync::PoisonError,
 };
 
-use crate::{rcl_bindings::*, DeclarationError};
+use crate::{rcl_bindings::*, DeclarationError, ReadyKind};
 
 /// The main error type.
 #[derive(Debug, PartialEq, Eq)]
@@ -51,6 +52,28 @@ pub enum RclrsError {
     ParameterDeclarationError(crate::DeclarationError),
     /// A mutex used internally has been [poisoned][std::sync::PoisonError].
     PoisonedMutex,
+    /// An [`crate::RclPrimitive`] received ready information that is not
+    /// compatible with its type.
+    InvalidReadyInformation {
+        /// The expected format of the ready information (default-initialized)
+        expected: ReadyKind,
+        /// The ready information that was received.
+        received: ReadyKind,
+    },
+    /// From rcl documentation for rcl_action_accept_new_goal:
+    ///
+    /// If a failure occurs, `NULL` is returned and an error message is set.
+    /// Possible reasons for failure:
+    ///   - action server is invalid
+    ///   - goal info is invalid
+    ///   - goal ID is already being tracked by the action server
+    ///   - memory allocation failure
+    ///
+    /// We have no way of diagnosing which of these errors caused the failure, so
+    /// all we can do is indicate that an error occurred with accepting the goal.
+    /// However, the implementation of rclrs automatically protects from all of
+    /// these errors except memory allocation failure.
+    GoalAcceptanceError,
 }
 
 impl RclrsError {
@@ -73,7 +96,10 @@ impl RclrsError {
             RclrsError::RclError {
                 code: RclReturnCode::SubscriptionTakeFailed
                     | RclReturnCode::ServiceTakeFailed
-                    | RclReturnCode::ClientTakeFailed,
+                    | RclReturnCode::ClientTakeFailed
+                    | RclReturnCode::ActionServerTakeFailed
+                    | RclReturnCode::ActionClientTakeFailed
+                    | RclReturnCode::EventTakeFailed,
                 ..
             }
         )
@@ -118,6 +144,21 @@ impl Display for RclrsError {
             RclrsError::PoisonedMutex => {
                 write!(f, "A mutex used internally has been poisoned")
             }
+            RclrsError::InvalidReadyInformation { expected, received } => {
+                write!(
+                    f,
+                    "Invalid ready information was provided. This suggests an error \
+                    in how the wait set is being used.\
+                    \n - Expected information: {expected:?}\
+                    \n - Actual: {received:?}",
+                )
+            }
+            RclrsError::GoalAcceptanceError => {
+                write!(
+                    f,
+                    "An error occurred while trying to accept an action server goal",
+                )
+            }
         }
     }
 }
@@ -133,7 +174,7 @@ impl Display for RclrsError {
 /// [1]: std::error::Error
 /// [2]: crate::RclrsError
 #[derive(Debug, PartialEq, Eq)]
-pub struct RclErrorMsg(String);
+pub struct RclErrorMsg(pub(crate) String);
 
 impl Display for RclErrorMsg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -157,6 +198,8 @@ impl Error for RclrsError {
             RclrsError::InvalidPayload { .. } => None,
             RclrsError::ParameterDeclarationError(_) => None,
             RclrsError::PoisonedMutex => None,
+            RclrsError::InvalidReadyInformation { .. } => None,
+            RclrsError::GoalAcceptanceError => None,
         }
     }
 }
@@ -251,6 +294,26 @@ pub enum RclReturnCode {
     EventInvalid = 2000,
     /// Failed to take an event from the event handle
     EventTakeFailed = 2001,
+    // ====== 2XXX: action-specific errors ======
+    /// Action name does not pass validation
+    // TODO(nwn): Consult with upstream about this reused error code.
+    // ActionNameInvalid = 2000,
+    /// Action goal accepted
+    ActionGoalAccepted = 2100,
+    /// Action goal rejected
+    ActionGoalRejected = 2101,
+    /// Action client is invalid
+    ActionClientInvalid = 2102,
+    /// Action client failed to take response
+    ActionClientTakeFailed = 2103,
+    /// Action server is invalid
+    ActionServerInvalid = 2200,
+    /// Action server failed to take request
+    ActionServerTakeFailed = 2201,
+    /// Action goal handle invalid
+    ActionGoalHandleInvalid = 2300,
+    /// Action invalid event
+    ActionGoalEventInvalid = 2301,
     // ====== 30XX: lifecycle-specific errors ======
     /// `rcl_lifecycle` state registered
     LifecycleStateRegistered = 3000,
@@ -264,6 +327,12 @@ impl From<DeclarationError> for RclrsError {
     }
 }
 
+impl<T> From<PoisonError<T>> for RclrsError {
+    fn from(_: PoisonError<T>) -> Self {
+        RclrsError::PoisonedMutex
+    }
+}
+
 impl TryFrom<i32> for RclReturnCode {
     type Error = i32;
 
@@ -305,6 +374,15 @@ impl TryFrom<i32> for RclReturnCode {
             x if x == Self::InvalidLogLevelRule as i32 => Self::InvalidLogLevelRule,
             x if x == Self::EventInvalid as i32 => Self::EventInvalid,
             x if x == Self::EventTakeFailed as i32 => Self::EventTakeFailed,
+            // x if x == Self::ActionNameInvalid as i32 => Self::ActionNameInvalid,
+            x if x == Self::ActionGoalAccepted as i32 => Self::ActionGoalAccepted,
+            x if x == Self::ActionGoalRejected as i32 => Self::ActionGoalRejected,
+            x if x == Self::ActionClientInvalid as i32 => Self::ActionClientInvalid,
+            x if x == Self::ActionClientTakeFailed as i32 => Self::ActionClientTakeFailed,
+            x if x == Self::ActionServerInvalid as i32 => Self::ActionServerInvalid,
+            x if x == Self::ActionServerTakeFailed as i32 => Self::ActionServerTakeFailed,
+            x if x == Self::ActionGoalHandleInvalid as i32 => Self::ActionGoalHandleInvalid,
+            x if x == Self::ActionGoalEventInvalid as i32 => Self::ActionGoalEventInvalid,
             x if x == Self::LifecycleStateRegistered as i32 => Self::LifecycleStateRegistered,
             x if x == Self::LifecycleStateNotRegistered as i32 => Self::LifecycleStateNotRegistered,
             other => {
@@ -386,6 +464,15 @@ impl Display for RclReturnCode {
             Self::EventTakeFailed => {
                 "Failed to take an event from the event handle (RCL_RET_EVENT_TAKE_FAILED)."
             }
+            // Self::ActionNameInvalid => "Action name does not pass validation (RCL_RET_ACTION_NAME_INVALID).",
+            Self::ActionGoalAccepted => "Action goal accepted (RCL_RET_ACTION_GOAL_ACCEPTED).",
+            Self::ActionGoalRejected => "Action goal rejected (RCL_RET_ACTION_GOAL_REJECTED).",
+            Self::ActionClientInvalid => "Action client is invalid (RCL_RET_ACTION_CLIENT_INVALID).",
+            Self::ActionClientTakeFailed => "Action client failed to take response (RCL_RET_ACTION_CLIENT_TAKE_FAILED).",
+            Self::ActionServerInvalid => "Action server is invalid (RCL_RET_ACTION_SERVER_INVALID).",
+            Self::ActionServerTakeFailed => "Action server failed to take request (RCL_RET_ACTION_SERVER_TAKE_FAILED).",
+            Self::ActionGoalHandleInvalid => "Action goal handle invalid (RCL_RET_ACTION_GOAL_HANDLE_INVALID).",
+            Self::ActionGoalEventInvalid => "Action invalid event (RCL_RET_ACTION_GOAL_EVENT_INVALID).",
             Self::LifecycleStateRegistered => {
                 "`rcl_lifecycle` state registered (RCL_RET_LIFECYCLE_STATE_REGISTERED)."
             }
@@ -512,3 +599,30 @@ impl RclrsErrorFilter for Vec<RclrsError> {
         self
     }
 }
+
+/// A helper trait to handle common error handling flows
+pub trait TakeFailedAsNone {
+    /// The type you would receive when there is no error
+    type T;
+
+    /// If the result has an error indicating that a take failed, convert the
+    /// output into an `Ok(None)`. Any other error returns `Err(error)`. If there
+    /// is no error, return `Ok(Some(value))`.
+    fn take_failed_as_none(self) -> Result<Option<Self::T>, RclrsError>;
+}
+
+impl<T> TakeFailedAsNone for Result<T, RclrsError> {
+    type T = T;
+    fn take_failed_as_none(self) -> Result<Option<T>, RclrsError> {
+        match self {
+            Ok(value) => Ok(Some(value)),
+            Err(err) => {
+                if err.is_take_failed() {
+                    return Ok(None);
+                }
+
+                return Err(err);
+            }
+        }
+    }
+}
diff --git a/rclrs/src/lib.rs b/rclrs/src/lib.rs
index 366e499b..13bbafcb 100644
--- a/rclrs/src/lib.rs
+++ b/rclrs/src/lib.rs
@@ -174,10 +174,12 @@
 //! # Ok::<(), RclrsError>(())
 //! ```
 
+mod action;
 mod arguments;
 mod client;
 mod clock;
 mod context;
+mod drop_guard;
 mod error;
 mod executor;
 mod logging;
@@ -201,10 +203,12 @@ mod rcl_bindings;
 #[cfg(feature = "dyn_msg")]
 pub mod dynamic_message;
 
+pub use action::*;
 pub use arguments::*;
 pub use client::*;
 pub use clock::*;
 pub use context::*;
+use drop_guard::DropGuard;
 pub use error::*;
 pub use executor::*;
 pub use logging::*;
diff --git a/rclrs/src/node.rs b/rclrs/src/node.rs
index dd01d060..b623460d 100644
--- a/rclrs/src/node.rs
+++ b/rclrs/src/node.rs
@@ -14,6 +14,7 @@ use std::{
     cmp::PartialEq,
     ffi::CStr,
     fmt,
+    future::Future,
     os::raw::c_char,
     sync::{atomic::AtomicBool, Arc, Mutex},
     time::Duration,
@@ -26,15 +27,17 @@ use futures::{
 
 use async_std::future::timeout;
 
-use rosidl_runtime_rs::Message;
+use rosidl_runtime_rs::{Message, Action};
 
 use crate::{
-    rcl_bindings::*, Client, ClientOptions, ClientState, Clock, ContextHandle, ExecutorCommands,
-    IntoAsyncServiceCallback, IntoAsyncSubscriptionCallback, IntoNodeServiceCallback,
-    IntoNodeSubscriptionCallback, LogParams, Logger, ParameterBuilder, ParameterInterface,
-    ParameterVariant, Parameters, Promise, Publisher, PublisherOptions, PublisherState, RclrsError,
-    Service, ServiceOptions, ServiceState, Subscription, SubscriptionOptions, SubscriptionState,
-    TimeSource, ToLogParams, Worker, WorkerOptions, WorkerState, ENTITY_LIFECYCLE_MUTEX,
+    rcl_bindings::*, ActionClient, ActionClientOptions, ActionClientState, ActionGoalReceiver,
+    ActionServer, ActionServerOptions, ActionServerState, Client, ClientOptions,
+    ClientState, Clock, ContextHandle, ExecutorCommands, IntoAsyncServiceCallback,
+    IntoAsyncSubscriptionCallback, IntoNodeServiceCallback, IntoNodeSubscriptionCallback,
+    LogParams, Logger, ParameterBuilder, ParameterInterface, ParameterVariant, Parameters,
+    Promise, Publisher, PublisherOptions, PublisherState, RclrsError, RequestedGoal, Service,
+    ServiceOptions, ServiceState, Subscription, SubscriptionOptions, SubscriptionState,
+    TerminatedGoal, TimeSource, ToLogParams, Worker, WorkerOptions, WorkerState, ENTITY_LIFECYCLE_MUTEX,
 };
 
 /// A processing unit that can communicate with other nodes. See the API of
@@ -349,6 +352,40 @@ impl NodeState {
     {
         ClientState::<T>::create(options, self)
     }
+    /// Creates an [`ActionClient`][1].
+    ///
+    /// [1]: crate::ActionClient
+    // TODO: make action client's lifetime depend on node's lifetime
+    pub fn create_action_client<'a, A: Action>(
+        self: &Arc<Self>,
+        options: impl Into<ActionClientOptions<'a>>,
+    ) -> Result<ActionClient<A>, RclrsError> {
+        ActionClientState::create(self, options)
+    }
+
+    /// Creates an [`ActionServer`].
+    //
+    // TODO(@mxgrey): Add extensive documentation and usage examples
+    pub fn create_action_server<'a, A: Action, Task>(
+        self: &Arc<Self>,
+        options: impl Into<ActionServerOptions<'a>>,
+        callback: impl FnMut(RequestedGoal<A>) -> Task + Send + Sync + 'static,
+    ) -> Result<ActionServer<A>, RclrsError>
+    where
+        Task: Future<Output = TerminatedGoal> + Send + Sync + 'static,
+    {
+        ActionServerState::create(self, options, callback)
+    }
+
+    /// Creates an [`ActionGoalReceiver`].
+    //
+    // TODO(@mxgrey): Add extensive documentation and usage examples
+    pub fn create_goal_receiver<'a, A: Action>(
+        self: &Arc<Self>,
+        options: impl Into<ActionServerOptions<'a>>,
+    ) -> Result<ActionGoalReceiver<A>, RclrsError> {
+        ActionGoalReceiver::new(self, options)
+    }
 
     /// Creates a [`Publisher`].
     ///
diff --git a/rclrs/src/qos.rs b/rclrs/src/qos.rs
index dcde5902..dcaa0b30 100644
--- a/rclrs/src/qos.rs
+++ b/rclrs/src/qos.rs
@@ -295,6 +295,11 @@ impl QoSProfile {
     pub fn system_default() -> Self {
         QOS_PROFILE_SYSTEM_DEFAULT
     }
+
+    /// Get the default QoS profile for action status topics.
+    pub fn action_status_default() -> Self {
+        QOS_PROFILE_ACTION_STATUS_DEFAULT
+    }
 }
 
 impl From<QoSHistoryPolicy> for rmw_qos_history_policy_t {
@@ -478,3 +483,17 @@ pub const QOS_PROFILE_SYSTEM_DEFAULT: QoSProfile = QoSProfile {
     liveliness_lease: QoSDuration::SystemDefault,
     avoid_ros_namespace_conventions: false,
 };
+
+/// Equivalent to `rcl_action_qos_profile_status_default` from the [`rcl_action` package][1].
+///
+/// [1]: https://github.com/ros2/rcl/blob/rolling/rcl_action/include/rcl_action/default_qos.h
+pub const QOS_PROFILE_ACTION_STATUS_DEFAULT: QoSProfile = QoSProfile {
+    history: QoSHistoryPolicy::KeepLast { depth: 1 },
+    reliability: QoSReliabilityPolicy::Reliable,
+    durability: QoSDurabilityPolicy::TransientLocal,
+    deadline: QoSDuration::SystemDefault,
+    lifespan: QoSDuration::SystemDefault,
+    liveliness: QoSLivelinessPolicy::SystemDefault,
+    liveliness_lease: QoSDuration::SystemDefault,
+    avoid_ros_namespace_conventions: false,
+};
diff --git a/rclrs/src/rcl_bindings.rs b/rclrs/src/rcl_bindings.rs
index 01de8f51..faefbae2 100644
--- a/rclrs/src/rcl_bindings.rs
+++ b/rclrs/src/rcl_bindings.rs
@@ -142,6 +142,7 @@ cfg_if::cfg_if! {
         pub struct rosidl_message_type_support_t;
 
         pub const RMW_GID_STORAGE_SIZE: usize = 24;
+        pub const RCL_ACTION_UUID_SIZE: usize = 16;
 
         extern "C" {
             pub fn rcl_context_is_valid(context: *const rcl_context_t) -> bool;
@@ -150,6 +151,7 @@ cfg_if::cfg_if! {
         include!(concat!(env!("OUT_DIR"), "/rcl_bindings_generated.rs"));
 
         pub const RMW_GID_STORAGE_SIZE: usize = rmw_gid_storage_size_constant;
+        pub const RCL_ACTION_UUID_SIZE: usize = rcl_action_uuid_size_constant;
     }
 }
 
diff --git a/rclrs/src/rcl_wrapper.h b/rclrs/src/rcl_wrapper.h
index ececf491..998f4022 100644
--- a/rclrs/src/rcl_wrapper.h
+++ b/rclrs/src/rcl_wrapper.h
@@ -1,5 +1,6 @@
 #include <rcl/graph.h>
 #include <rcl/rcl.h>
+#include <rcl_action/rcl_action.h>
 #include <rcl_yaml_param_parser/parser.h>
 #include <rcutils/error_handling.h>
 #include <rcl/logging.h>
@@ -8,3 +9,4 @@
 #include <rosidl_typesupport_introspection_c/message_introspection.h>
 
 const size_t rmw_gid_storage_size_constant = RMW_GID_STORAGE_SIZE;
+const size_t rcl_action_uuid_size_constant = UUID_SIZE;
diff --git a/rclrs/src/service.rs b/rclrs/src/service.rs
index aaa07abc..04536da4 100644
--- a/rclrs/src/service.rs
+++ b/rclrs/src/service.rs
@@ -9,8 +9,8 @@ use rosidl_runtime_rs::{Message, Service as IdlService};
 
 use crate::{
     error::ToResult, rcl_bindings::*, IntoPrimitiveOptions, MessageCow, Node, NodeHandle,
-    QoSProfile, RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclrsError, Waitable,
-    WaitableLifecycle, WorkScope, Worker, WorkerCommands, ENTITY_LIFECYCLE_MUTEX,
+    QoSProfile, RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclrsError, ReadyKind,
+    Waitable, WaitableLifecycle, WorkScope, Worker, WorkerCommands, ENTITY_LIFECYCLE_MUTEX,
 };
 
 mod any_service_callback;
@@ -249,7 +249,8 @@ where
     T: IdlService,
     Scope: WorkScope,
 {
-    unsafe fn execute(&mut self, payload: &mut dyn Any) -> Result<(), RclrsError> {
+    unsafe fn execute(&mut self, ready: ReadyKind, payload: &mut dyn Any) -> Result<(), RclrsError> {
+        ready.for_basic()?;
         self.callback
             .lock()
             .unwrap()
diff --git a/rclrs/src/subscription.rs b/rclrs/src/subscription.rs
index e57c542f..76369f00 100644
--- a/rclrs/src/subscription.rs
+++ b/rclrs/src/subscription.rs
@@ -8,8 +8,8 @@ use rosidl_runtime_rs::{Message, RmwMessage};
 
 use crate::{
     error::ToResult, qos::QoSProfile, rcl_bindings::*, IntoPrimitiveOptions, Node, NodeHandle,
-    RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclrsError, Waitable, WaitableLifecycle,
-    WorkScope, Worker, WorkerCommands, ENTITY_LIFECYCLE_MUTEX,
+    RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclrsError, ReadyKind, Waitable,
+    WaitableLifecycle, WorkScope, Worker, WorkerCommands, ENTITY_LIFECYCLE_MUTEX,
 };
 
 mod any_subscription_callback;
@@ -261,7 +261,8 @@ impl<T, Payload: 'static> RclPrimitive for SubscriptionExecutable<T, Payload>
 where
     T: Message,
 {
-    unsafe fn execute(&mut self, payload: &mut dyn Any) -> Result<(), RclrsError> {
+    unsafe fn execute(&mut self, ready: ReadyKind, payload: &mut dyn Any) -> Result<(), RclrsError> {
+        ready.for_basic()?;
         self.callback
             .lock()
             .unwrap()
diff --git a/rclrs/src/time.rs b/rclrs/src/time.rs
index 540c6248..699435fb 100644
--- a/rclrs/src/time.rs
+++ b/rclrs/src/time.rs
@@ -29,13 +29,26 @@ impl Time {
 
     /// Convenience function for converting time to ROS message
     pub fn to_ros_msg(&self) -> Result<builtin_interfaces::msg::Time, TryFromIntError> {
-        let nanosec = self.nsec % 1_000_000_000;
+        let (sec, nanosec) = self.to_sec_nanosec()?;
+        Ok(builtin_interfaces::msg::Time { nanosec, sec })
+    }
+
+    /// Convenience function for converting time into an rcl message.
+    pub fn to_rcl(&self) -> Result<builtin_interfaces__msg__Time, TryFromIntError> {
+        let (sec, nanosec) = self.to_sec_nanosec()?;
+        Ok(builtin_interfaces__msg__Time { sec, nanosec })
+    }
+
+    /// Convenience function for converting time into a (sec, nanosec) representation
+    /// which is commonly used in the ROS ecosystem.
+    pub fn to_sec_nanosec(&self) -> Result<(i32, u32), TryFromIntError> {
         let sec = self.nsec / 1_000_000_000;
+        let nanosec = self.nsec % 1_000_000_000;
 
-        Ok(builtin_interfaces::msg::Time {
-            nanosec: nanosec.try_into()?,
-            sec: sec.try_into()?,
-        })
+        Ok((
+            sec.try_into()?,
+            nanosec.try_into()?,
+        ))
     }
 }
 
diff --git a/rclrs/src/wait_set.rs b/rclrs/src/wait_set.rs
index a7951f00..94450c78 100644
--- a/rclrs/src/wait_set.rs
+++ b/rclrs/src/wait_set.rs
@@ -102,7 +102,7 @@ impl WaitSet {
     pub fn wait(
         &mut self,
         timeout: Option<Duration>,
-        mut f: impl FnMut(&mut dyn RclPrimitive) -> Result<(), RclrsError>,
+        mut f: impl FnMut(ReadyKind, &mut dyn RclPrimitive) -> Result<(), RclrsError>,
     ) -> Result<(), RclrsError> {
         let timeout_ns = match timeout.map(|d| d.as_nanos()) {
             None => -1,
@@ -138,8 +138,8 @@ impl WaitSet {
         // For the remaining entities, check if they were activated and then run
         // the callback for those that were.
         for waiter in self.primitives.values_mut().flat_map(|v| v) {
-            if waiter.is_ready(&self.handle.rcl_wait_set) {
-                f(&mut *waiter.primitive)?;
+            if let Some(ready) =  waiter.is_ready(&self.handle.rcl_wait_set) {
+                f(ready, &mut *waiter.primitive)?;
             }
         }
 
@@ -167,7 +167,7 @@ impl WaitSet {
     pub fn count(&self) -> WaitableCount {
         let mut c = WaitableCount::new();
         for (kind, collection) in &self.primitives {
-            c.add(*kind, collection.len());
+            c.add_group(kind, collection);
         }
         c
     }
diff --git a/rclrs/src/wait_set/guard_condition.rs b/rclrs/src/wait_set/guard_condition.rs
index 8860e23a..16abd9c0 100644
--- a/rclrs/src/wait_set/guard_condition.rs
+++ b/rclrs/src/wait_set/guard_condition.rs
@@ -5,7 +5,7 @@ use std::{
 
 use crate::{
     rcl_bindings::*, ContextHandle, RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclrsError,
-    ToResult, Waitable, WaitableLifecycle,
+    ReadyKind, ToResult, Waitable, WaitableLifecycle,
 };
 
 /// A waitable entity used for waking up a wait set manually.
@@ -136,6 +136,7 @@ struct GuardConditionHandle {
 /// condition variables are owned at the rclrs layer while others were obtained
 /// from rcl and either have static lifetimes or lifetimes that depend on
 /// something else.
+#[derive(Debug)]
 pub enum InnerGuardConditionHandle {
     /// This variant means the guard condition was created and owned by rclrs.
     /// Its memory is managed by us.
@@ -205,7 +206,8 @@ struct GuardConditionExecutable {
 }
 
 impl RclPrimitive for GuardConditionExecutable {
-    unsafe fn execute(&mut self, _: &mut dyn Any) -> Result<(), RclrsError> {
+    unsafe fn execute(&mut self, ready: ReadyKind, _: &mut dyn Any) -> Result<(), RclrsError> {
+        ready.for_basic()?;
         if let Some(callback) = &mut self.callback {
             callback();
         }
diff --git a/rclrs/src/wait_set/rcl_primitive.rs b/rclrs/src/wait_set/rcl_primitive.rs
index 205926c6..405df6a0 100644
--- a/rclrs/src/wait_set/rcl_primitive.rs
+++ b/rclrs/src/wait_set/rcl_primitive.rs
@@ -1,6 +1,8 @@
 use std::{any::Any, sync::MutexGuard};
 
-use crate::{rcl_bindings::*, InnerGuardConditionHandle, RclrsError};
+use crate::{
+    log_error, rcl_bindings::*, InnerGuardConditionHandle, RclrsError, ToResult,
+};
 
 /// This provides the public API for executing a waitable item.
 pub trait RclPrimitive: Send + Sync {
@@ -20,7 +22,7 @@ pub trait RclPrimitive: Send + Sync {
     /// [1]: crate::ExecutorChannel
     /// [2]: crate::WorkerChannel
     /// [3]: crate::Worker
-    unsafe fn execute(&mut self, payload: &mut dyn Any) -> Result<(), RclrsError>;
+    unsafe fn execute(&mut self, ready: ReadyKind, payload: &mut dyn Any) -> Result<(), RclrsError>;
 
     /// Indicate what kind of primitive this is.
     fn kind(&self) -> RclPrimitiveKind;
@@ -44,9 +46,14 @@ pub enum RclPrimitiveKind {
     Service,
     /// Event
     Event,
+    /// Action Server
+    ActionServer,
+    /// Action Client
+    ActionClient,
 }
 
 /// Used by the wait set to obtain the handle of a primitive.
+#[derive(Debug)]
 pub enum RclPrimitiveHandle<'a> {
     /// Handle for a subscription
     Subscription(MutexGuard<'a, rcl_subscription_t>),
@@ -60,4 +67,228 @@ pub enum RclPrimitiveHandle<'a> {
     Service(MutexGuard<'a, rcl_service_t>),
     /// Handle for an event
     Event(MutexGuard<'a, rcl_event_t>),
+    /// Handle for an action server
+    ActionServer(MutexGuard<'a, rcl_action_server_t>),
+    /// Handle for an action client
+    ActionClient(MutexGuard<'a, rcl_action_client_t>),
+}
+
+/// Describe the way in which a waitable is ready.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ReadyKind {
+    /// The basic readiness is for most wait set primitives, which only have one
+    /// execution path that may be ready.
+    Basic,
+    /// This type of readiness is specific to action servers, which consist of
+    /// multiple primitives. Any combination of those primitives might be ready,
+    /// and we need to know which to execute specifically.
+    ActionServer(ActionServerReady),
+    /// This type of readiness is specific to action clients, which consist of
+    /// multiple primitives. Any combination of those primitives might be ready,
+    /// and we need to know which to execute specifically.
+    ActionClient(ActionClientReady),
+}
+
+impl ReadyKind {
+    /// Convert a pointer's status into a basic ready indicator.
+    pub fn from_ptr<T>(ptr: *const T) -> Option<Self> {
+        if ptr.is_null() {
+            None
+        } else {
+            Some(Self::Basic)
+        }
+    }
+
+    /// This is used by the basic primitive types to validate that they are
+    /// receiving ready information that matches their primitive type.
+    pub fn for_basic(self) -> Result<(), RclrsError> {
+        match self {
+            Self::Basic => Ok(()),
+            _ => Err(RclrsError::InvalidReadyInformation {
+                expected: Self::Basic,
+                received: self,
+            })
+        }
+    }
+
+    /// This is used by action servers to get their readiness information.
+    pub fn for_action_server(self) -> Result<ActionServerReady, RclrsError> {
+        match self {
+            Self::ActionServer(ready) => Ok(ready),
+            _ => Err(RclrsError::InvalidReadyInformation {
+                expected: Self::ActionServer(Default::default()),
+                received: self,
+            })
+        }
+    }
+
+    /// This is used by action clients to get their readiness information.
+    pub fn for_action_client(self) -> Result<ActionClientReady, RclrsError> {
+        match self {
+            Self::ActionClient(ready) => Ok(ready),
+            _ => Err(RclrsError::InvalidReadyInformation {
+                expected: Self::ActionClient(Default::default()),
+                received: self,
+            })
+        }
+    }
+}
+
+/// This is the ready information for an action server.
+///
+/// Action servers provide multiple services bundled together. When a wait set
+/// wakes up it is possible for any number of those services to be ready for
+/// processing. This struct conveys which of an action's services are ready.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ActionServerReady {
+    /// True if there is a goal request message ready to take, false otherwise.
+    pub goal_request: bool,
+    /// True if there is a cancel request message ready to take, false otherwise.
+    pub cancel_request: bool,
+    /// True if there is a result request message ready to take, false otherwise.
+    pub result_request: bool,
+    /// True if a goal has expired, false otherwise.
+    pub goal_expired: bool,
+}
+
+impl Default for ActionServerReady {
+    fn default() -> Self {
+        Self {
+            goal_request: false,
+            cancel_request: false,
+            result_request: false,
+            goal_expired: false,
+        }
+    }
+}
+
+impl ActionServerReady {
+    /// Check whether any primitives in an action server are ready to be processed.
+    ///
+    /// SAFETY: This calls a function which is not thread-safe. The wait set and
+    /// action server handles must not be in used in any other threads. The
+    /// [`MutexGuard`] should ensure this for the action server, but it is up to
+    /// the caller to ensure that the wait set is not being simultaneously accessed
+    /// in any other thread.
+    pub(crate) unsafe fn check(
+        wait_set: &rcl_wait_set_t,
+        action_server: MutexGuard<rcl_action_server_t>,
+    ) -> Option<ReadyKind> {
+        let mut ready = ActionServerReady::default();
+        let r = unsafe {
+            // SAFETY: We give a safety warning to ensure that the wait set is
+            // not being used elsewhere. The action server handle is guarded by
+            // the mutex. With those two requirements met, we do not need to
+            // worry about this function not being thread-safe.
+            rcl_action_server_wait_set_get_entities_ready(
+                wait_set,
+                &*action_server,
+                &mut ready.goal_request,
+                &mut ready.cancel_request,
+                &mut ready.result_request,
+                &mut ready.goal_expired,
+            )
+        };
+
+        if let Err(err) = r.ok() {
+            log_error!(
+                "ActionServerReady.check",
+                "Error while checking readiness for action server: {err}",
+            );
+        }
+
+        if ready.any_ready() {
+            Some(ReadyKind::ActionServer(ready))
+        } else {
+            None
+        }
+    }
+
+    /// Check whether any of the primitives of the action server are ready. When
+    /// this is false, we can skip producing a [`ReadyKind`] entirely.
+    pub fn any_ready(&self) -> bool {
+        self.goal_request
+        || self.cancel_request
+        || self.result_request
+        || self.goal_expired
+    }
+}
+
+/// This is the ready information for an action client.
+///
+/// Action clients contain multiple service clients bundled together, as well as
+/// some subscribers. When a wait set wakes up it is possible for any number of
+/// those services or subscriptions to be ready for processing. This struct
+/// conveys which of an action client's messages are ready.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ActionClientReady {
+    /// True if there is a feedback message ready to take, false otherwise.
+    pub feedback: bool,
+    /// True if there is a status message ready to take, false otherwise.
+    pub status: bool,
+    /// True if there is a goal response message ready to take, false otherwise.
+    pub goal_response: bool,
+    /// True if there is a cancel response message ready to take, false otherwise.
+    pub cancel_response: bool,
+    /// True if there is a result response message ready to take, false otherwise.
+    pub result_response: bool,
+}
+
+impl ActionClientReady {
+    pub(crate) unsafe fn check(
+        wait_set: &rcl_wait_set_t,
+        action_client: MutexGuard<rcl_action_client_t>,
+    ) -> Option<ReadyKind> {
+        let mut ready = ActionClientReady::default();
+        let r = unsafe {
+            // SAFETY: We give a safety warning to ensure that the wait set is
+            // not being used elsewhere. The action client handle is guarded by
+            // the mutex. With those two requirements met, we do not need to
+            // worry about this function not being thread-safe.
+            rcl_action_client_wait_set_get_entities_ready(
+                wait_set,
+                &*action_client,
+                &mut ready.feedback,
+                &mut ready.status,
+                &mut ready.goal_response,
+                &mut ready.cancel_response,
+                &mut ready.result_response,
+            )
+        };
+
+        if let Err(err) = r.ok() {
+            log_error!(
+                "ActionClientReady.check",
+                "Error while checking readiness for action client: {err}",
+            );
+        }
+
+        if ready.any_ready() {
+            Some(ReadyKind::ActionClient(ready))
+        } else {
+            None
+        }
+    }
+
+    /// Check whether any of the primitives of the action client are ready. When
+    /// this is false, we can skip producing a [`ReadyKind`] entirely.
+    pub fn any_ready(&self) -> bool {
+        self.feedback
+        || self.status
+        || self.goal_response
+        || self.cancel_response
+        || self.result_response
+    }
+}
+
+impl Default for ActionClientReady {
+    fn default() -> Self {
+        Self {
+            feedback: false,
+            status: false,
+            goal_response: false,
+            cancel_response: false,
+            result_response: false,
+        }
+    }
 }
diff --git a/rclrs/src/wait_set/wait_set_runner.rs b/rclrs/src/wait_set/wait_set_runner.rs
index b60f0705..6b4ffc81 100644
--- a/rclrs/src/wait_set/wait_set_runner.rs
+++ b/rclrs/src/wait_set/wait_set_runner.rs
@@ -184,12 +184,12 @@ impl WaitSetRunner {
             });
 
             let mut at_least_one = false;
-            self.wait_set.wait(timeout, |executable| {
+            self.wait_set.wait(timeout, |ready, executable| {
                 at_least_one = true;
                 // SAFETY: The user of WaitSetRunner is responsible for ensuring
                 // the runner has the same payload type as the executables that
                 // are given to it.
-                unsafe { executable.execute(&mut *self.payload) }
+                unsafe { executable.execute(ready, &mut *self.payload) }
             })?;
 
             if at_least_one {
diff --git a/rclrs/src/wait_set/waitable.rs b/rclrs/src/wait_set/waitable.rs
index d510d1f9..2acafb9e 100644
--- a/rclrs/src/wait_set/waitable.rs
+++ b/rclrs/src/wait_set/waitable.rs
@@ -4,15 +4,15 @@ use std::sync::{
 };
 
 use crate::{
-    error::ToResult, rcl_bindings::*, GuardCondition, RclPrimitive, RclPrimitiveHandle,
-    RclPrimitiveKind, RclrsError,
+    error::ToResult, log_error, rcl_bindings::*, ActionServerReady, ActionClientReady, GuardCondition,
+    RclPrimitive, RclPrimitiveHandle, RclPrimitiveKind, RclrsError, ReadyKind,
 };
 
 /// This struct manages the presence of an rcl primitive inside the wait set.
 /// It will keep track of where the primitive is within the wait set as well as
 /// automatically remove the primitive from the wait set once it isn't being
 /// used anymore.
-#[must_use = "If you do not give the Waiter to a WaitSet then it will never be useful"]
+#[must_use = "If you do not give the Waitable to a WaitSet then it will never be useful"]
 pub struct Waitable {
     pub(super) primitive: Box<dyn RclPrimitive>,
     in_use: Arc<AtomicBool>,
@@ -26,7 +26,7 @@ impl Waitable {
         guard_condition: Option<Arc<GuardCondition>>,
     ) -> (Self, WaitableLifecycle) {
         let in_use = Arc::new(AtomicBool::new(true));
-        let waiter = Self {
+        let waitable = Self {
             primitive,
             in_use: Arc::clone(&in_use),
             index_in_wait_set: None,
@@ -36,7 +36,7 @@ impl Waitable {
             in_use,
             guard_condition,
         };
-        (waiter, lifecycle)
+        (waitable, lifecycle)
     }
 
     pub(super) fn in_wait_set(&self) -> bool {
@@ -47,25 +47,95 @@ impl Waitable {
         self.in_use.load(Ordering::Relaxed)
     }
 
-    pub(super) fn is_ready(&self, wait_set: &rcl_wait_set_t) -> bool {
-        self.index_in_wait_set.is_some_and(|index| {
-            let ptr_is_null = unsafe {
-                // SAFETY: Each field in the wait set is an array of points.
-                // The dereferencing that we do is equivalent to obtaining the
-                // element of the array at the index-th position.
-                match self.primitive.kind() {
-                    RclPrimitiveKind::Subscription => wait_set.subscriptions.add(index).is_null(),
-                    RclPrimitiveKind::GuardCondition => {
-                        wait_set.guard_conditions.add(index).is_null()
+    pub(super) fn is_ready(&self, wait_set: &rcl_wait_set_t) -> Option<ReadyKind> {
+        match self.primitive.kind() {
+            RclPrimitiveKind::Subscription => {
+                self.index_in_wait_set.and_then(|index| {
+                    // SAFETY: Each field in the wait set is an array of points.
+                    // The dereferencing that we do is equivalent to obtaining the
+                    // element of the array at the index-th position.
+                    ReadyKind::from_ptr(unsafe { wait_set.subscriptions.add(index) })
+                })
+            },
+            RclPrimitiveKind::GuardCondition => {
+                self.index_in_wait_set.and_then(|index| {
+                    // SAFETY: Each field in the wait set is an array of points.
+                    // The dereferencing that we do is equivalent to obtaining the
+                    // element of the array at the index-th position.
+                    ReadyKind::from_ptr(unsafe { wait_set.guard_conditions.add(index) })
+                })
+            }
+            RclPrimitiveKind::Service => {
+                self.index_in_wait_set.and_then(|index| {
+                    // SAFETY: Each field in the wait set is an array of points.
+                    // The dereferencing that we do is equivalent to obtaining the
+                    // element of the array at the index-th position.
+                    ReadyKind::from_ptr(unsafe { wait_set.services.add(index) })
+                })
+            }
+            RclPrimitiveKind::Client => {
+                self.index_in_wait_set.and_then(|index| {
+                    // SAFETY: Each field in the wait set is an array of points.
+                    // The dereferencing that we do is equivalent to obtaining the
+                    // element of the array at the index-th position.
+                    ReadyKind::from_ptr(unsafe { wait_set.clients.add(index) })
+                })
+            }
+            RclPrimitiveKind::Timer => {
+                self.index_in_wait_set.and_then(|index| {
+                    // SAFETY: Each field in the wait set is an array of points.
+                    // The dereferencing that we do is equivalent to obtaining the
+                    // element of the array at the index-th position.
+                    ReadyKind::from_ptr(unsafe { wait_set.timers.add(index) })
+                })
+            }
+            RclPrimitiveKind::Event => {
+                self.index_in_wait_set.and_then(|index| {
+                    // SAFETY: Each field in the wait set is an array of points.
+                    // The dereferencing that we do is equivalent to obtaining the
+                    // element of the array at the index-th position.
+                    ReadyKind::from_ptr(unsafe { wait_set.events.add(index) })
+                })
+            }
+            RclPrimitiveKind::ActionServer => {
+                match self.primitive.handle() {
+                    RclPrimitiveHandle::ActionServer(handle) => {
+                        // SAFETY: We have exclusive ownership of the wait set
+                        // and the action server handle right now, which satisfies
+                        // the safety requirements of the function.
+                        unsafe { ActionServerReady::check(wait_set, handle) }
+                    }
+                    handle => {
+                        log_error!(
+                            "waitable.is_ready",
+                            "Invalid handle for ActionServer type: {handle:?}. \
+                            This indicates a bug in the implementation of rclrs. \
+                            Please report this to the rclrs maintainers.",
+                        );
+                        None
+                    }
+                }
+            },
+            RclPrimitiveKind::ActionClient => {
+                match self.primitive.handle() {
+                    RclPrimitiveHandle::ActionClient(handle) => {
+                        // SAFETY: We have exclusive ownership of the wait set
+                        // and the action client handle right now, which satisfies
+                        // the safety requirements of the function.
+                        unsafe { ActionClientReady::check(wait_set, handle) }
+                    }
+                    handle => {
+                        log_error!(
+                            "waitable.is_ready",
+                            "Invalid handle for ActionClient type: {handle:?}. \
+                            This indicates a bug in the implementation of rclrs. \
+                            Please report this to the rclrs maintainers.",
+                        );
+                        None
                     }
-                    RclPrimitiveKind::Service => wait_set.services.add(index).is_null(),
-                    RclPrimitiveKind::Client => wait_set.clients.add(index).is_null(),
-                    RclPrimitiveKind::Timer => wait_set.timers.add(index).is_null(),
-                    RclPrimitiveKind::Event => wait_set.events.add(index).is_null(),
                 }
-            };
-            !ptr_is_null
-        })
+            }
+        }
     }
 
     pub(super) fn add_to_wait_set(
@@ -95,6 +165,12 @@ impl Waitable {
                 RclPrimitiveHandle::Event(handle) => {
                     rcl_wait_set_add_event(wait_set, &*handle, &mut index)
                 }
+                RclPrimitiveHandle::ActionServer(handle) => {
+                    rcl_action_wait_set_add_action_server(wait_set, &*handle, std::ptr::null_mut())
+                }
+                RclPrimitiveHandle::ActionClient(handle) => {
+                    rcl_action_wait_set_add_action_client(wait_set, &*handle, std::ptr::null_mut(), std::ptr::null_mut())
+                }
             }
         }
         .ok()?;
@@ -145,14 +221,87 @@ impl WaitableCount {
         Self::default()
     }
 
-    pub(super) fn add(&mut self, kind: RclPrimitiveKind, count: usize) {
+    pub(super) fn add_group(
+        &mut self,
+        kind: &RclPrimitiveKind,
+        waitables: &Vec<Waitable>,
+    ) {
         match kind {
-            RclPrimitiveKind::Subscription => self.subscriptions += count,
-            RclPrimitiveKind::GuardCondition => self.guard_conditions += count,
-            RclPrimitiveKind::Timer => self.timers += count,
-            RclPrimitiveKind::Client => self.clients += count,
-            RclPrimitiveKind::Service => self.services += count,
-            RclPrimitiveKind::Event => self.events += count,
+            RclPrimitiveKind::Subscription => self.subscriptions += waitables.len(),
+            RclPrimitiveKind::GuardCondition => self.guard_conditions += waitables.len(),
+            RclPrimitiveKind::Timer => self.timers += waitables.len(),
+            RclPrimitiveKind::Client => self.clients += waitables.len(),
+            RclPrimitiveKind::Service => self.services += waitables.len(),
+            RclPrimitiveKind::Event => self.events += waitables.len(),
+            RclPrimitiveKind::ActionServer => {
+                for waitable in waitables {
+                    self.add_single(&*waitable.primitive);
+                }
+            }
+            RclPrimitiveKind::ActionClient => {
+                for waitable in waitables {
+                    self.add_single(&*waitable.primitive);
+                }
+            }
+        }
+    }
+
+    fn add_single(&mut self, primitive: &dyn RclPrimitive) {
+        match primitive.handle() {
+            RclPrimitiveHandle::Subscription(_) => self.subscriptions += 1,
+            RclPrimitiveHandle::GuardCondition(_) => self.guard_conditions += 1,
+            RclPrimitiveHandle::Timer(_) => self.timers += 1,
+            RclPrimitiveHandle::Client(_) => self.clients += 1,
+            RclPrimitiveHandle::Service(_) => self.services += 1,
+            RclPrimitiveHandle::Event(_) => self.events += 1,
+            RclPrimitiveHandle::ActionServer(handle) => {
+                let mut count = WaitableCount::new();
+                let r = unsafe {
+                    // SAFETY: The handle is kept safe by the mutex guard, and
+                    // there are no other preconditions.
+                    rcl_action_server_wait_set_get_num_entities(
+                        &*handle,
+                        &mut count.subscriptions,
+                        &mut count.guard_conditions,
+                        &mut count.timers,
+                        &mut count.clients,
+                        &mut count.services,
+                    )
+                };
+                if let Err(err) = r.ok() {
+                    log_error!(
+                        "waitable_count.add_single",
+                        "Error occurred while counting primitives for an action server. \
+                        This should not happen, please report it to the rclrs maintainers: {err}",
+                    );
+                }
+
+                *self += count;
+            }
+            RclPrimitiveHandle::ActionClient(handle) => {
+                let mut count = WaitableCount::new();
+                let r = unsafe {
+                    // SAFETY: The handle is kept safe by the mutex guard, and
+                    // there are no other preconditions.
+                    rcl_action_client_wait_set_get_num_entities(
+                        &*handle,
+                        &mut count.subscriptions,
+                        &mut count.guard_conditions,
+                        &mut count.timers,
+                        &mut count.clients,
+                        &mut count.services,
+                    )
+                };
+                if let Err(err) = r.ok() {
+                    log_error!(
+                        "waitable_count.add_single",
+                        "Error occurred while counting primitives for an action client. \
+                        This should not happen, please report it to the rclrs maintainers: {err}",
+                    );
+                }
+
+                *self += count;
+            }
         }
     }
 
@@ -199,3 +348,24 @@ impl WaitableCount {
         .ok()
     }
 }
+
+impl std::ops::Add for WaitableCount {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            subscriptions: self.subscriptions + rhs.subscriptions,
+            guard_conditions: self.guard_conditions + rhs.guard_conditions,
+            timers: self.timers + rhs.timers,
+            clients: self.clients + rhs.clients,
+            services: self.services + rhs.services,
+            events: self.events + rhs.events,
+        }
+    }
+}
+
+impl std::ops::AddAssign for WaitableCount {
+    fn add_assign(&mut self, rhs: Self) {
+        let count = *self + rhs;
+        *self = count;
+    }
+}