diff --git a/README.md b/README.md
index 6d06df473..ca41615d5 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,10 @@ See [MCP Server section](#mcp-server) for more details on how to use the MCP Ser
 * [`ably rooms list`](#ably-rooms-list)
 * [`ably rooms messages`](#ably-rooms-messages)
 * [`ably rooms messages get ROOMID`](#ably-rooms-messages-get-roomid)
+* [`ably rooms messages reactions`](#ably-rooms-messages-reactions)
+* [`ably rooms messages reactions add ROOMID MESSAGESERIAL REACTION`](#ably-rooms-messages-reactions-add-roomid-messageserial-reaction)
+* [`ably rooms messages reactions remove ROOMID MESSAGESERIAL REACTION`](#ably-rooms-messages-reactions-remove-roomid-messageserial-reaction)
+* [`ably rooms messages reactions subscribe ROOMID`](#ably-rooms-messages-reactions-subscribe-roomid)
 * [`ably rooms messages send ROOMID TEXT`](#ably-rooms-messages-send-roomid-text)
 * [`ably rooms messages subscribe ROOMID`](#ably-rooms-messages-subscribe-roomid)
 * [`ably rooms occupancy`](#ably-rooms-occupancy)
@@ -3507,6 +3511,8 @@ EXAMPLES
   $ ably rooms messages subscribe my-room
 
   $ ably rooms messages get my-room
+
+  $ ably rooms messages reactions add my-room "message-id" "👍"
 ```
 
 _See code: [src/commands/rooms/messages/index.ts](https://github.com/ably/cli/blob/v0.5.1/src/commands/rooms/messages/index.ts)_
@@ -3558,6 +3564,161 @@ EXAMPLES
 
 _See code: [src/commands/rooms/messages/get.ts](https://github.com/ably/cli/blob/v0.5.1/src/commands/rooms/messages/get.ts)_
 
+## `ably rooms messages reactions`
+
+Commands for working with message reactions in chat rooms
+
+```
+USAGE
+  $ ably rooms messages reactions
+
+DESCRIPTION
+  Commands for working with message reactions in chat rooms
+
+EXAMPLES
+  $ ably rooms messages reactions add my-room "message-id" "👍"
+
+  $ ably rooms messages reactions subscribe my-room
+
+  $ ably rooms messages reactions remove my-room "message-id" "👍"
+```
+
+_See code: [src/commands/rooms/messages/reactions/index.ts](https://github.com/ably/cli/blob/v0.5.1/src/commands/rooms/messages/reactions/index.ts)_
+
+## `ably rooms messages reactions add ROOMID MESSAGESERIAL REACTION`
+
+Add a reaction to a message in a chat room
+
+```
+USAGE
+  $ ably rooms messages reactions add ROOMID MESSAGESERIAL REACTION [--access-token <value>] [--api-key <value>] [--client-id
+    <value>] [--control-host <value>] [--env <value>] [--host <value>] [--json | --pretty-json] [--token <value>] [-v]
+    [--count <value> --type unique|distinct|multiple]
+
+ARGUMENTS
+  ROOMID         The room ID where the message is located
+  MESSAGESERIAL  The serial ID of the message to react to
+  REACTION       The reaction to add (e.g. 👍, ❤️, 😂)
+
+FLAGS
+  -v, --verbose               Output verbose logs
+      --access-token=<value>  Overrides any configured access token used for the Control API
+      --api-key=<value>       Overrides any configured API key used for the product APIs
+      --client-id=<value>     Overrides any default client ID when using API authentication. Use "none" to explicitly
+                              set no client ID. Not applicable when using token authentication.
+      --control-host=<value>  Override the host endpoint for the control API, which defaults to control.ably.net
+      --count=<value>         Count value for Multiple type reactions
+      --env=<value>           Override the environment for all product API calls
+      --host=<value>          Override the host endpoint for all product API calls
+      --json                  Output in JSON format
+      --pretty-json           Output in colorized JSON format
+      --token=<value>         Authenticate using an Ably Token or JWT Token instead of an API key
+      --type=<option>         The type of reaction (unique, distinct, or multiple)
+                              <options: unique|distinct|multiple>
+
+DESCRIPTION
+  Add a reaction to a message in a chat room
+
+EXAMPLES
+  $ ably rooms messages reactions add my-room message-serial 👍
+
+  $ ably rooms messages reactions add --api-key "YOUR_API_KEY" my-room message-serial ❤️
+
+  $ ably rooms messages reactions add my-room message-serial 👍 --type multiple --count 10
+
+  $ ably rooms messages reactions add my-room message-serial 👍 --type unique
+
+  $ ably rooms messages reactions add my-room message-serial 👍 --json
+```
+
+_See code: [src/commands/rooms/messages/reactions/add.ts](https://github.com/ably/cli/blob/v0.5.1/src/commands/rooms/messages/reactions/add.ts)_
+
+## `ably rooms messages reactions remove ROOMID MESSAGESERIAL REACTION`
+
+Remove a reaction from a message in a chat room
+
+```
+USAGE
+  $ ably rooms messages reactions remove ROOMID MESSAGESERIAL REACTION [--access-token <value>] [--api-key <value>] [--client-id
+    <value>] [--control-host <value>] [--env <value>] [--host <value>] [--json | --pretty-json] [--token <value>] [-v]
+    [--type unique|distinct|multiple]
+
+ARGUMENTS
+  ROOMID         The room ID where the message is located
+  MESSAGESERIAL  The serial ID of the message to remove reaction from
+  REACTION       The reaction to remove (e.g. 👍, ❤️, 😂)
+
+FLAGS
+  -v, --verbose               Output verbose logs
+      --access-token=<value>  Overrides any configured access token used for the Control API
+      --api-key=<value>       Overrides any configured API key used for the product APIs
+      --client-id=<value>     Overrides any default client ID when using API authentication. Use "none" to explicitly
+                              set no client ID. Not applicable when using token authentication.
+      --control-host=<value>  Override the host endpoint for the control API, which defaults to control.ably.net
+      --env=<value>           Override the environment for all product API calls
+      --host=<value>          Override the host endpoint for all product API calls
+      --json                  Output in JSON format
+      --pretty-json           Output in colorized JSON format
+      --token=<value>         Authenticate using an Ably Token or JWT Token instead of an API key
+      --type=<option>         The type of reaction (unique, distinct, or multiple)
+                             <options: unique|distinct|multiple>
+
+DESCRIPTION
+  Remove a reaction from a message in a chat room
+
+EXAMPLES
+  $ ably rooms messages reactions remove my-room message-serial 👍
+
+  $ ably rooms messages reactions remove --api-key "YOUR_API_KEY" my-room message-serial ❤️
+
+  $ ably rooms messages reactions remove my-room message-serial 👍 --type unique
+
+  $ ably rooms messages reactions remove my-room message-serial 👍 --json
+```
+
+_See code: [src/commands/rooms/messages/reactions/remove.ts](https://github.com/ably/cli/blob/v0.5.1/src/commands/rooms/messages/reactions/remove.ts)_
+
+## `ably rooms messages reactions subscribe ROOMID`
+
+Subscribe to message reactions in a chat room
+
+```
+USAGE
+  $ ably rooms messages reactions subscribe ROOMID [--access-token <value>] [--api-key <value>] [--client-id <value>] [--control-host
+    <value>] [--env <value>] [--host <value>] [--json | --pretty-json] [--token <value>] [-v] [--raw]
+
+ARGUMENTS
+  ROOMID  Room ID to subscribe to message reactions in
+
+FLAGS
+  -v, --verbose               Output verbose logs
+      --access-token=<value>  Overrides any configured access token used for the Control API
+      --api-key=<value>       Overrides any configured API key used for the product APIs
+      --client-id=<value>     Overrides any default client ID when using API authentication. Use "none" to explicitly
+                              set no client ID. Not applicable when using token authentication.
+      --control-host=<value>  Override the host endpoint for the control API, which defaults to control.ably.net
+      --env=<value>           Override the environment for all product API calls
+      --host=<value>          Override the host endpoint for all product API calls
+      --json                  Output in JSON format
+      --pretty-json           Output in colorized JSON format
+      --raw                   Subscribe to raw individual reaction events instead of summaries
+      --token=<value>         Authenticate using an Ably Token or JWT Token instead of an API key
+
+DESCRIPTION
+  Subscribe to message reactions in a chat room
+
+EXAMPLES
+  $ ably rooms messages reactions subscribe my-room
+
+  $ ably rooms messages reactions subscribe my-room --raw
+
+  $ ably rooms messages reactions subscribe my-room --json
+
+  $ ably rooms messages reactions subscribe my-room --pretty-json
+```
+
+_See code: [src/commands/rooms/messages/reactions/subscribe.ts](https://github.com/ably/cli/blob/v0.5.1/src/commands/rooms/messages/reactions/subscribe.ts)_
+
 ## `ably rooms messages send ROOMID TEXT`
 
 Send a message to an Ably Chat room
diff --git a/src/commands/rooms/messages/index.ts b/src/commands/rooms/messages/index.ts
index 0076ac8eb..78f145cb8 100644
--- a/src/commands/rooms/messages/index.ts
+++ b/src/commands/rooms/messages/index.ts
@@ -8,6 +8,7 @@ export default class MessagesIndex extends Command {
     '$ ably rooms messages send my-room "Hello world!"',
     "$ ably rooms messages subscribe my-room",
     "$ ably rooms messages get my-room",
+    '$ ably rooms messages reactions add my-room "message-id" "👍"',
   ];
 
   async run(): Promise<void> {
@@ -22,5 +23,8 @@ export default class MessagesIndex extends Command {
     this.log(
       "  ably rooms messages get        - Get historical messages from a chat room",
     );
+    this.log(
+      "  ably rooms messages reactions  - Work with message reactions in a chat room",
+    );
   }
 }
diff --git a/src/commands/rooms/messages/reactions/add.ts b/src/commands/rooms/messages/reactions/add.ts
new file mode 100644
index 000000000..0c9310522
--- /dev/null
+++ b/src/commands/rooms/messages/reactions/add.ts
@@ -0,0 +1,319 @@
+import { Args, Flags } from "@oclif/core";
+import * as Ably from "ably";
+import { ChatClient, RoomStatus, RoomStatusChange, MessageReactionType } from "@ably/chat";
+import chalk from "chalk";
+
+import { ChatBaseCommand } from "../../../../chat-base-command.js";
+
+// Map CLI-friendly type names to SDK MessageReactionType values
+const REACTION_TYPE_MAP: Record<string, MessageReactionType> = {
+  unique: MessageReactionType.Unique,
+  distinct: MessageReactionType.Distinct,
+  multiple: MessageReactionType.Multiple,
+};
+
+interface MessageReactionResult {
+  [key: string]: unknown;
+  success: boolean;
+  roomId: string;
+  messageSerial?: string;
+  reaction?: string;
+  type?: string;
+  count?: number;
+  error?: string;
+}
+
+export default class MessagesReactionsAdd extends ChatBaseCommand {
+  static override args = {
+    roomId: Args.string({
+      description: "The room ID where the message is located",
+      required: true,
+    }),
+    messageSerial: Args.string({
+      description: "The serial ID of the message to react to",
+      required: true,
+    }),
+    reaction: Args.string({
+      description: "The reaction to add (e.g. 👍, ❤️, 😂)",
+      required: true,
+    }),
+  };
+
+  static override description = "Add a reaction to a message in a chat room";
+
+  static override examples = [
+    "$ ably rooms messages reactions add my-room message-serial 👍",
+    '$ ably rooms messages reactions add --api-key "YOUR_API_KEY" my-room message-serial ❤️',
+    "$ ably rooms messages reactions add my-room message-serial 👍 --type multiple --count 10",
+    "$ ably rooms messages reactions add my-room message-serial 👍 --type unique",
+    "$ ably rooms messages reactions add my-room message-serial 👍 --json",
+  ];
+
+  static override flags = {
+    ...ChatBaseCommand.globalFlags,
+    type: Flags.string({
+      description: "The type of reaction (unique, distinct, or multiple)",
+      options: Object.keys(REACTION_TYPE_MAP),
+    }),
+    count: Flags.integer({
+      description: "Count value for Multiple type reactions",
+      dependsOn: ["type"],
+    }),
+  };
+
+  private ablyClient: Ably.Realtime | null = null;
+  private chatClient: ChatClient | null = null;
+  private unsubscribeStatusFn: (() => void) | null = null;
+
+  async finally(err: Error | undefined): Promise<void> {
+    if (this.unsubscribeStatusFn) {
+      try {
+        this.unsubscribeStatusFn();
+      } catch {
+        /* ignore */
+      }
+    }
+    if (
+      this.ablyClient &&
+      this.ablyClient.connection.state !== "closed" &&
+      this.ablyClient.connection.state !== "failed"
+    ) {
+      this.ablyClient.close();
+    }
+
+    return super.finally(err);
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MessagesReactionsAdd);
+    const { roomId, messageSerial, reaction } = args;
+
+    try {
+      // Validate count for Multiple type
+      if (flags.type === "multiple" && flags.count !== undefined && flags.count <= 0) {
+        const errorMsg = "Count must be a positive integer for Multiple type reactions";
+        this.logCliEvent(flags, "reaction", "invalidCount", errorMsg, {
+          error: errorMsg,
+          count: flags.count,
+        });
+        if (this.shouldOutputJson(flags)) {
+          this.log(
+            this.formatJsonOutput(
+              { error: errorMsg, roomId, success: false },
+              flags,
+            ),
+          );
+        } else {
+          this.error(errorMsg);
+        }
+        return;
+      }
+
+      // Create Chat client
+      this.chatClient = await this.createChatClient(flags);
+      // Also get the underlying Ably client for connection state changes
+      this.ablyClient = await this.createAblyClient(flags);
+
+      if (!this.chatClient) {
+        this.error("Failed to create Chat client");
+        return;
+      }
+      if (!this.ablyClient) {
+        this.error("Failed to create Ably client");
+        return;
+      }
+
+      // Add listeners for connection state changes
+      this.ablyClient.connection.on(
+        (stateChange: Ably.ConnectionStateChange) => {
+          this.logCliEvent(
+            flags,
+            "connection",
+            stateChange.current,
+            `Realtime connection state changed to ${stateChange.current}`,
+            { reason: stateChange.reason },
+          );
+        },
+      );
+
+      // Get the room
+      this.logCliEvent(
+        flags,
+        "room",
+        "gettingRoom",
+        `Getting room handle for ${roomId}`,
+      );
+      const room = await this.chatClient.rooms.get(roomId);
+      this.logCliEvent(
+        flags,
+        "room",
+        "gotRoom",
+        `Got room handle for ${roomId}`,
+      );
+
+      // Subscribe to room status changes
+      this.logCliEvent(
+        flags,
+        "room",
+        "subscribingToStatus",
+        "Subscribing to room status changes",
+      );
+      const { off: unsubscribeStatus } = room.onStatusChange(
+        (statusChange: RoomStatusChange) => {
+          let reason: Error | null | string | undefined;
+          if (statusChange.current === RoomStatus.Failed) {
+            reason = room.error; // Get reason from room.error on failure
+          }
+
+          const reasonMsg = reason instanceof Error ? reason.message : reason;
+          this.logCliEvent(
+            flags,
+            "room",
+            `status-${statusChange.current}`,
+            `Room status changed to ${statusChange.current}`,
+            { reason: reasonMsg },
+          );
+
+          if (
+            statusChange.current === RoomStatus.Failed &&
+            !this.shouldOutputJson(flags)
+          ) {
+            this.error(
+              `Failed to attach to room: ${reasonMsg || "Unknown error"}`,
+            );
+          }
+        },
+      );
+      this.unsubscribeStatusFn = unsubscribeStatus;
+      this.logCliEvent(
+        flags,
+        "room",
+        "subscribedToStatus",
+        "Successfully subscribed to room status changes",
+      );
+
+      // Attach to the room
+      this.logCliEvent(
+        flags,
+        "room",
+        "attaching",
+        `Attaching to room ${roomId}`,
+      );
+      await room.attach();
+      this.logCliEvent(
+        flags,
+        "room",
+        "attached",
+        `Successfully attached to room ${roomId}`,
+      );
+
+      // Prepare the reaction parameters
+      const reactionParams: {
+        name: string;
+        type?: MessageReactionType;
+        count?: number;
+      } = {
+        name: reaction,
+      };
+
+      // Set optional parameters if provided
+      if (flags.type) {
+        reactionParams.type = REACTION_TYPE_MAP[flags.type];
+      }
+      if (flags.type === "multiple" && flags.count) {
+        reactionParams.count = flags.count;
+      }
+
+      // Add the reaction
+      this.logCliEvent(
+        flags,
+        "reaction",
+        "adding",
+        `Adding reaction ${reaction} to message`,
+        {
+          messageSerial,
+          reaction: reactionParams,
+        }
+      );
+
+      await room.messages.reactions.add({ serial: messageSerial }, reactionParams);
+      
+      this.logCliEvent(
+        flags,
+        "reaction",
+        "added",
+        `Successfully added reaction ${reaction} to message`,
+      );
+
+      // Format the response
+      const resultData: MessageReactionResult = {
+        messageSerial,
+        reaction,
+        roomId,
+        success: true,
+        ...(flags.type && { type: flags.type }),
+        ...(flags.count && { count: flags.count }),
+      };
+
+      if (this.shouldOutputJson(flags)) {
+        this.log(this.formatJsonOutput(resultData, flags));
+      } else {
+        this.log(
+          `${chalk.green("✓")} Added reaction ${chalk.yellow(reaction)} to message ${chalk.cyan(messageSerial)} in room ${chalk.cyan(roomId)}`,
+        );
+      }
+
+      // Clean up resources
+      this.logCliEvent(flags, "room", "releasing", `Releasing room ${roomId}`);
+      await this.chatClient.rooms.release(roomId);
+      this.logCliEvent(flags, "room", "released", `Released room ${roomId}`);
+
+      this.logCliEvent(
+        flags,
+        "connection",
+        "closing",
+        "Closing Realtime connection",
+      );
+      this.ablyClient.close();
+      this.logCliEvent(
+        flags,
+        "connection",
+        "closed",
+        "Realtime connection closed",
+      );
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.logCliEvent(
+        flags,
+        "reaction",
+        "error",
+        `Failed to add reaction: ${errorMsg}`,
+        { error: errorMsg, roomId, messageSerial, reaction },
+      );
+
+      // Close the connection in case of error
+      if (this.ablyClient) {
+        this.ablyClient.close();
+      }
+
+      if (this.shouldOutputJson(flags)) {
+        this.log(
+          this.formatJsonOutput(
+            { 
+              error: errorMsg, 
+              roomId, 
+              messageSerial, 
+              reaction, 
+              success: false,
+              ...(flags.type && { type: flags.type }),
+              ...(flags.count && { count: flags.count }),
+            },
+            flags,
+          ),
+        );
+      } else {
+        this.error(`Failed to add reaction: ${errorMsg}`);
+      }
+    }
+  }
+}
diff --git a/src/commands/rooms/messages/reactions/index.ts b/src/commands/rooms/messages/reactions/index.ts
new file mode 100644
index 000000000..c0a303fe2
--- /dev/null
+++ b/src/commands/rooms/messages/reactions/index.ts
@@ -0,0 +1,26 @@
+import { Command } from "@oclif/core";
+
+export default class MessagesReactionsIndex extends Command {
+  static override description =
+    "Commands for working with message reactions in chat rooms";
+
+  static override examples = [
+    '$ ably rooms messages reactions add my-room "message-id" "👍"',
+    "$ ably rooms messages reactions subscribe my-room",
+    '$ ably rooms messages reactions remove my-room "message-id" "👍"',
+  ];
+
+  async run(): Promise<void> {
+    this.log("Use one of the message reactions subcommands:");
+    this.log("");
+    this.log(
+      "  ably rooms messages reactions add       - Add a reaction to a message",
+    );
+    this.log(
+      "  ably rooms messages reactions subscribe - Subscribe to message reactions in a room",
+    );
+    this.log(
+      "  ably rooms messages reactions remove    - Remove a reaction from a message",
+    );
+  }
+}
diff --git a/src/commands/rooms/messages/reactions/remove.ts b/src/commands/rooms/messages/reactions/remove.ts
new file mode 100644
index 000000000..e42266929
--- /dev/null
+++ b/src/commands/rooms/messages/reactions/remove.ts
@@ -0,0 +1,282 @@
+import { Args, Flags } from "@oclif/core";
+import * as Ably from "ably";
+import { ChatClient, RoomStatus, RoomStatusChange, MessageReactionType } from "@ably/chat";
+import chalk from "chalk";
+
+import { ChatBaseCommand } from "../../../../chat-base-command.js";
+
+// Map CLI-friendly type names to SDK MessageReactionType values
+const REACTION_TYPE_MAP: Record<string, MessageReactionType> = {
+  unique: MessageReactionType.Unique,
+  distinct: MessageReactionType.Distinct,
+  multiple: MessageReactionType.Multiple,
+};
+
+interface MessageReactionResult {
+  [key: string]: unknown;
+  success: boolean;
+  roomId: string;
+  messageSerial?: string;
+  reaction?: string;
+  type?: string;
+  error?: string;
+}
+
+export default class MessagesReactionsRemove extends ChatBaseCommand {
+  static override args = {
+    roomId: Args.string({
+      description: "The room ID where the message is located",
+      required: true,
+    }),
+    messageSerial: Args.string({
+      description: "The serial ID of the message to remove reaction from",
+      required: true,
+    }),
+    reaction: Args.string({
+      description: "The reaction to remove (e.g. 👍, ❤️, 😂)",
+      required: true,
+    }),
+  };
+
+  static override description = "Remove a reaction from a message in a chat room";
+
+  static override examples = [
+    "$ ably rooms messages reactions remove my-room message-serial 👍",
+    '$ ably rooms messages reactions remove --api-key "YOUR_API_KEY" my-room message-serial ❤️',
+    "$ ably rooms messages reactions remove my-room message-serial 👍 --type unique",
+    "$ ably rooms messages reactions remove my-room message-serial 👍 --json",
+  ];
+
+  static override flags = {
+    ...ChatBaseCommand.globalFlags,
+    type: Flags.string({
+      description: "The type of reaction (unique, distinct, or multiple)",
+      options: Object.keys(REACTION_TYPE_MAP),
+    }),
+  };
+
+  private ablyClient: Ably.Realtime | null = null;
+  private chatClient: ChatClient | null = null;
+  private unsubscribeStatusFn: (() => void) | null = null;
+
+  async finally(err: Error | undefined): Promise<void> {
+    if (this.unsubscribeStatusFn) {
+      try {
+        this.unsubscribeStatusFn();
+      } catch {
+        /* ignore */
+      }
+    }
+    if (
+      this.ablyClient &&
+      this.ablyClient.connection.state !== "closed" &&
+      this.ablyClient.connection.state !== "failed"
+    ) {
+      this.ablyClient.close();
+    }
+
+    return super.finally(err);
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MessagesReactionsRemove);
+    const { roomId, messageSerial, reaction } = args;
+
+    try {
+      // Create Chat client
+      this.chatClient = await this.createChatClient(flags);
+      // Also get the underlying Ably client for connection state changes
+      this.ablyClient = await this.createAblyClient(flags);
+
+      if (!this.chatClient) {
+        this.error("Failed to create Chat client");
+        return;
+      }
+      if (!this.ablyClient) {
+        this.error("Failed to create Ably client");
+        return;
+      }
+
+      // Add listeners for connection state changes
+      this.ablyClient.connection.on(
+        (stateChange: Ably.ConnectionStateChange) => {
+          this.logCliEvent(
+            flags,
+            "connection",
+            stateChange.current,
+            `Realtime connection state changed to ${stateChange.current}`,
+            { reason: stateChange.reason },
+          );
+        },
+      );
+
+      // Get the room
+      this.logCliEvent(
+        flags,
+        "room",
+        "gettingRoom",
+        `Getting room handle for ${roomId}`,
+      );
+      const room = await this.chatClient.rooms.get(roomId);
+      this.logCliEvent(
+        flags,
+        "room",
+        "gotRoom",
+        `Got room handle for ${roomId}`,
+      );
+
+      // Subscribe to room status changes
+      this.logCliEvent(
+        flags,
+        "room",
+        "subscribingToStatus",
+        "Subscribing to room status changes",
+      );
+      const { off: unsubscribeStatus } = room.onStatusChange(
+        (statusChange: RoomStatusChange) => {
+          let reason: Error | null | string | undefined;
+          if (statusChange.current === RoomStatus.Failed) {
+            reason = room.error; // Get reason from room.error on failure
+          }
+
+          const reasonMsg = reason instanceof Error ? reason.message : reason;
+          this.logCliEvent(
+            flags,
+            "room",
+            `status-${statusChange.current}`,
+            `Room status changed to ${statusChange.current}`,
+            { reason: reasonMsg },
+          );
+
+          if (
+            statusChange.current === RoomStatus.Failed &&
+            !this.shouldOutputJson(flags)
+          ) {
+            this.error(
+              `Failed to attach to room: ${reasonMsg || "Unknown error"}`,
+            );
+          }
+        },
+      );
+      this.unsubscribeStatusFn = unsubscribeStatus;
+      this.logCliEvent(
+        flags,
+        "room",
+        "subscribedToStatus",
+        "Successfully subscribed to room status changes",
+      );
+
+      // Attach to the room
+      this.logCliEvent(
+        flags,
+        "room",
+        "attaching",
+        `Attaching to room ${roomId}`,
+      );
+      await room.attach();
+      this.logCliEvent(
+        flags,
+        "room",
+        "attached",
+        `Successfully attached to room ${roomId}`,
+      );
+
+      // Remove the reaction
+      this.logCliEvent(
+        flags,
+        "reaction",
+        "removing",
+        `Removing reaction ${reaction} from message`,
+        {
+          messageSerial,
+          reaction,
+          ...(flags.type && { type: flags.type }),
+        }
+      );
+
+      // Use delete method instead of remove
+      await room.messages.reactions.delete(
+        { serial: messageSerial }, 
+        { 
+          name: reaction,
+          ...(flags.type && { type: REACTION_TYPE_MAP[flags.type] }),
+        }
+      );
+      
+      this.logCliEvent(
+        flags,
+        "reaction",
+        "removed",
+        `Successfully removed reaction ${reaction} from message`,
+      );
+
+      // Format the response
+      const resultData: MessageReactionResult = {
+        messageSerial,
+        reaction,
+        roomId,
+        success: true,
+        ...(flags.type && { type: flags.type }),
+      };
+
+      if (this.shouldOutputJson(flags)) {
+        this.log(this.formatJsonOutput(resultData, flags));
+      } else {
+        this.log(
+          `${chalk.green("✓")} Removed reaction ${chalk.yellow(reaction)} from message ${chalk.cyan(messageSerial)} in room ${chalk.cyan(roomId)}`,
+        );
+      }
+
+      // Clean up resources
+      this.logCliEvent(flags, "room", "releasing", `Releasing room ${roomId}`);
+      await this.chatClient.rooms.release(roomId);
+      this.logCliEvent(flags, "room", "released", `Released room ${roomId}`);
+
+      this.logCliEvent(
+        flags,
+        "connection",
+        "closing",
+        "Closing Realtime connection",
+      );
+      this.ablyClient.close();
+      this.logCliEvent(
+        flags,
+        "connection",
+        "closed",
+        "Realtime connection closed",
+      );
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.logCliEvent(
+        flags,
+        "reaction",
+        "error",
+        `Failed to remove reaction: ${errorMsg}`,
+        { error: errorMsg, roomId, messageSerial, reaction },
+      );
+
+      // Close the connection in case of error
+      if (this.ablyClient) {
+        this.ablyClient.close();
+      }
+
+      if (this.shouldOutputJson(flags)) {
+        this.log(
+          this.formatJsonOutput(
+            { 
+              error: errorMsg, 
+              roomId, 
+              messageSerial, 
+              reaction,
+              ...(flags.type && { type: flags.type }), 
+              success: false 
+            },
+            flags,
+          ),
+        );
+      } else {
+        this.error(`Failed to remove reaction: ${errorMsg}`);
+      }
+    }
+  }
+}
diff --git a/src/commands/rooms/messages/reactions/subscribe.ts b/src/commands/rooms/messages/reactions/subscribe.ts
new file mode 100644
index 000000000..6ddaec38a
--- /dev/null
+++ b/src/commands/rooms/messages/reactions/subscribe.ts
@@ -0,0 +1,582 @@
+import { ChatClient, RoomStatus, Subscription, MessageReactionRawEvent, MessageReactionEvents, MessageReactionSummaryEvent } from "@ably/chat";
+import { Args, Flags } from "@oclif/core";
+import * as Ably from "ably";
+import chalk from "chalk";
+
+import { ChatBaseCommand } from "../../../../chat-base-command.js";
+
+interface ReactionSummary {
+  messageSerial: string;
+  unique?: Record<string, { total: number; clientIds: string[] }>;
+  distinct?: Record<string, { total: number; clientIds: string[] }>;
+  multiple?: Record<string, { total: number; clientIds: Record<string, number> }>;
+}
+
+export default class MessagesReactionsSubscribe extends ChatBaseCommand {
+  static override args = {
+    roomId: Args.string({
+      description: "Room ID to subscribe to message reactions in",
+      required: true,
+    }),
+  };
+
+  static override description = "Subscribe to message reactions in a chat room";
+
+  static override examples = [
+    "$ ably rooms messages reactions subscribe my-room",
+    "$ ably rooms messages reactions subscribe my-room --raw",
+    "$ ably rooms messages reactions subscribe my-room --json",
+    "$ ably rooms messages reactions subscribe my-room --pretty-json",
+  ];
+
+  static override flags = {
+    ...ChatBaseCommand.globalFlags,
+    raw: Flags.boolean({
+      description: "Subscribe to raw individual reaction events instead of summaries",
+      default: false,
+    }),
+  };
+
+  private chatClient: ChatClient | null = null;
+  private ablyClient: Ably.Realtime | null = null;
+  private unsubscribeReactionsFn: Subscription | null = null;
+  private unsubscribeRawReactionsFn: Subscription | null = null;
+  private unsubscribeStatusFn: (() => void) | null = null;
+
+  // Override finally to ensure resources are cleaned up
+  async finally(err: Error | undefined): Promise<void> {
+    if (this.unsubscribeReactionsFn) {
+      try {
+        this.unsubscribeReactionsFn.unsubscribe();
+      } catch {
+        /* ignore */
+      }
+    }
+    if (this.unsubscribeRawReactionsFn) {
+      try {
+        this.unsubscribeRawReactionsFn.unsubscribe();
+      } catch {
+        /* ignore */
+      }
+    }
+    if (this.unsubscribeStatusFn) {
+      try {
+        this.unsubscribeStatusFn();
+      } catch {
+        /* ignore */
+      }
+    }
+    if (
+      this.ablyClient &&
+      this.ablyClient.connection.state !== "closed" &&
+      this.ablyClient.connection.state !== "failed"
+    ) {
+      this.ablyClient.close();
+    }
+
+    return super.finally(err);
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MessagesReactionsSubscribe);
+
+    try {
+      // Create Chat client
+      this.chatClient = await this.createChatClient(flags);
+      this.ablyClient = await this.createAblyClient(flags);
+      
+      if (!this.chatClient || !this.ablyClient) {
+        this.error("Failed to initialize clients");
+        return;
+      }
+
+      const { roomId } = args;
+
+      // Add listeners for connection state changes
+      this.ablyClient.connection.on(
+        (stateChange: Ably.ConnectionStateChange) => {
+          this.logCliEvent(
+            flags,
+            "connection",
+            stateChange.current,
+            `Realtime connection state changed to ${stateChange.current}`,
+            { reason: stateChange.reason },
+          );
+        },
+      );
+
+      this.logCliEvent(
+        flags,
+        "subscribe",
+        "connecting",
+        `Connecting to Ably and subscribing to message reactions in room ${roomId}...`,
+      );
+      if (!this.shouldOutputJson(flags)) {
+        this.log(
+          `Connecting to Ably and subscribing to message reactions in room ${chalk.cyan(roomId)}...`,
+        );
+      }
+
+      // Get the room
+      this.logCliEvent(
+        flags,
+        "room",
+        "gettingRoom",
+        `Getting room handle for ${roomId}`,
+      );
+      
+      // Set room options to receive raw reactions if requested
+      const roomOptions = flags.raw ? {
+        messages: {
+          rawMessageReactions: true,
+        },
+      } : {};
+      
+      const room = await this.chatClient.rooms.get(roomId, roomOptions);
+      this.logCliEvent(
+        flags,
+        "room",
+        "gotRoom",
+        `Got room handle for ${roomId}`,
+      );
+
+      // Subscribe to room status changes
+      this.logCliEvent(
+        flags,
+        "room",
+        "subscribingToStatus",
+        "Subscribing to room status changes",
+      );
+      const { off: unsubscribeStatus } = room.onStatusChange((statusChange) => {
+        let reason: Error | null | string | undefined;
+        if (statusChange.current === RoomStatus.Failed) {
+          reason = room.error; // Get reason from room.error on failure
+        }
+
+        const reasonMsg = reason instanceof Error ? reason.message : reason;
+        this.logCliEvent(
+          flags,
+          "room",
+          `status-${statusChange.current}`,
+          `Room status changed to ${statusChange.current}`,
+          { reason: reasonMsg },
+        );
+
+        switch (statusChange.current) {
+          case RoomStatus.Attached: {
+            if (!this.shouldOutputJson(flags)) {
+              this.log(chalk.green("Successfully connected to Ably"));
+              this.log(
+                `Listening for message reactions in room ${chalk.cyan(roomId)}. Press Ctrl+C to exit.`,
+              );
+            }
+
+            break;
+          }
+
+          case RoomStatus.Detached: {
+            if (!this.shouldOutputJson(flags)) {
+              this.log(chalk.yellow("Disconnected from Ably"));
+            }
+
+            break;
+          }
+
+          case RoomStatus.Failed: {
+            if (!this.shouldOutputJson(flags)) {
+              this.error(
+                `${chalk.red("Connection failed:")} ${reasonMsg || "Unknown error"}`,
+              );
+            }
+
+            break;
+          }
+          // No default
+        }
+      });
+      this.unsubscribeStatusFn = unsubscribeStatus;
+      this.logCliEvent(
+        flags,
+        "room",
+        "subscribedToStatus",
+        "Successfully subscribed to room status changes",
+      );
+
+      // Attach to the room
+      this.logCliEvent(
+        flags,
+        "room",
+        "attaching",
+        `Attaching to room ${roomId}`,
+      );
+      await room.attach();
+      // Successful attach logged by onStatusChange handler
+
+      // Subscribe to message reactions based on the flag
+      if (flags.raw) {
+        // Subscribe to raw reaction events
+        this.logCliEvent(
+          flags,
+          "reactions",
+          "subscribingRaw",
+          "Subscribing to raw reaction events",
+        );
+        this.unsubscribeRawReactionsFn = room.messages.reactions.subscribeRaw((event: MessageReactionRawEvent) => {
+          const timestamp = new Date().toISOString();
+          const eventData = {
+            type: event.type,
+            serial: event.reaction.messageSerial,
+            reaction: event.reaction,
+            roomId,
+            timestamp,
+          };
+          this.logCliEvent(
+            flags,
+            "reactions",
+            "rawReceived",
+            "Raw reaction event received",
+            eventData,
+          );
+
+          if (this.shouldOutputJson(flags)) {
+            this.log(
+              this.formatJsonOutput({ success: true, ...eventData }, flags),
+            );
+          } else {
+            this.log(
+              `[${chalk.dim(timestamp)}] ${chalk.green("⚡")} ${chalk.blue(event.reaction.clientId || "Unknown")} [${event.reaction.type}] ${event.type}: ${chalk.yellow(event.reaction.name || "unknown")} to message ${chalk.cyan(event.reaction.messageSerial)}`,
+            );
+          }
+        });
+        this.logCliEvent(
+          flags,
+          "reactions",
+          "subscribedRaw",
+          "Successfully subscribed to raw reaction events",
+        );
+      } else {
+        // Subscribe to reaction summaries
+        this.logCliEvent(
+          flags,
+          "reactions",
+          "subscribing",
+          "Subscribing to reaction summaries",
+        );
+        this.unsubscribeReactionsFn = room.messages.reactions.subscribe((event: MessageReactionSummaryEvent) => {
+          const timestamp = new Date().toISOString();
+          
+          // Format the summary for display
+          const summaryData: ReactionSummary = event.summary;
+          
+          this.logCliEvent(
+            flags,
+            "reactions",
+            "summaryReceived",
+            "Reaction summary received",
+            {
+              roomId,
+              timestamp,
+              summary: summaryData,
+            }
+          );
+
+          if (this.shouldOutputJson(flags)) {
+            this.log(
+              this.formatJsonOutput({ 
+                success: true, 
+                roomId,
+                timestamp,
+                summary: summaryData 
+              }, flags),
+            );
+          } else {
+            this.log(
+              `[${chalk.dim(timestamp)}] ${chalk.green("📊")} Reaction summary for message ${chalk.cyan(event.summary.messageSerial)}:`,
+            );
+
+            // Display the summaries by type if they exist
+            if (event.summary.unique && Object.keys(event.summary.unique).length > 0) {
+              this.log(`  ${chalk.blue("Unique reactions:")}`);
+              this.displayReactionSummary(event.summary.unique, flags);
+            }
+            
+            if (event.summary.distinct && Object.keys(event.summary.distinct).length > 0) {
+              this.log(`  ${chalk.blue("Distinct reactions:")}`);
+              this.displayReactionSummary(event.summary.distinct, flags);
+            }
+            
+            if (event.summary.multiple && Object.keys(event.summary.multiple).length > 0) {
+              this.log(`  ${chalk.blue("Multiple reactions:")}`);
+              this.displayMultipleReactionSummary(event.summary.multiple, flags);
+            }
+          }
+        });
+        this.logCliEvent(
+          flags,
+          "reactions",
+          "subscribed",
+          "Successfully subscribed to reaction summaries",
+        );
+      }
+
+      this.logCliEvent(
+        flags,
+        "reactions",
+        "listening",
+        "Listening for message reactions...",
+      );
+      
+      // Keep the process running until interrupted
+      await new Promise<void>((resolve) => {
+        let cleanupInProgress = false;
+        const cleanup = async () => {
+          if (cleanupInProgress) return;
+          cleanupInProgress = true;
+          this.logCliEvent(
+            flags,
+            "reactions",
+            "cleanupInitiated",
+            "Cleanup initiated (Ctrl+C pressed)",
+          );
+          if (!this.shouldOutputJson(flags)) {
+            this.log(
+              `\n${chalk.yellow("Unsubscribing and closing connection...")}`,
+            );
+          }
+
+          // Set a force exit timeout
+          const forceExitTimeout = setTimeout(() => {
+            const errorMsg = "Force exiting after timeout during cleanup";
+            this.logCliEvent(flags, "reactions", "forceExit", errorMsg, {
+              roomId,
+            });
+            if (!this.shouldOutputJson(flags)) {
+              this.log(chalk.red("Force exiting after timeout..."));
+            }
+          }, 5000);
+
+          // Unsubscribe from reactions
+          if (this.unsubscribeReactionsFn) {
+            try {
+              this.logCliEvent(
+                flags,
+                "reactions",
+                "unsubscribing",
+                "Unsubscribing from reaction summaries",
+              );
+              this.unsubscribeReactionsFn.unsubscribe();
+              this.logCliEvent(
+                flags,
+                "reactions",
+                "unsubscribed",
+                "Unsubscribed from reaction summaries",
+              );
+            } catch (error) {
+              const errorMsg =
+                error instanceof Error ? error.message : String(error);
+              this.logCliEvent(
+                flags,
+                "reactions",
+                "unsubscribeError",
+                `Error unsubscribing from reactions: ${errorMsg}`,
+                { error: errorMsg },
+              );
+            }
+          }
+
+          // Unsubscribe from raw reactions
+          if (this.unsubscribeRawReactionsFn) {
+            try {
+              this.logCliEvent(
+                flags,
+                "reactions",
+                "unsubscribingRaw",
+                "Unsubscribing from raw reaction events",
+              );
+              this.unsubscribeRawReactionsFn.unsubscribe();
+              this.logCliEvent(
+                flags,
+                "reactions",
+                "unsubscribedRaw",
+                "Unsubscribed from raw reaction events",
+              );
+            } catch (error) {
+              const errorMsg =
+                error instanceof Error ? error.message : String(error);
+              this.logCliEvent(
+                flags,
+                "reactions",
+                "unsubscribeRawError",
+                `Error unsubscribing from raw reactions: ${errorMsg}`,
+                { error: errorMsg },
+              );
+            }
+          }
+
+          // Unsubscribe from status changes
+          if (this.unsubscribeStatusFn) {
+            try {
+              this.logCliEvent(
+                flags,
+                "room",
+                "unsubscribingStatus",
+                "Unsubscribing from room status",
+              );
+              this.unsubscribeStatusFn();
+              this.logCliEvent(
+                flags,
+                "room",
+                "unsubscribedStatus",
+                "Unsubscribed from room status",
+              );
+            } catch (error) {
+              const errorMsg =
+                error instanceof Error ? error.message : String(error);
+              this.logCliEvent(
+                flags,
+                "room",
+                "unsubscribeStatusError",
+                `Error unsubscribing from status: ${errorMsg}`,
+                { error: errorMsg },
+              );
+            }
+          }
+
+          try {
+            this.logCliEvent(
+              flags,
+              "room",
+              "releasing",
+              `Releasing room ${roomId}`,
+            );
+            if (this.chatClient) {
+              await this.chatClient.rooms.release(roomId);
+              this.logCliEvent(
+                flags,
+                "room",
+                "released",
+                `Room ${roomId} released`,
+              );
+            } else {
+              this.logCliEvent(
+                flags,
+                "room",
+                "releaseError",
+                "Chat client was null during cleanup",
+                { error: "Chat client null" },
+              );
+            }
+          } catch (error) {
+            const errorMsg =
+              error instanceof Error ? error.message : String(error);
+            this.logCliEvent(
+              flags,
+              "room",
+              "releaseError",
+              `Error releasing room: ${errorMsg}`,
+              { error: errorMsg },
+            );
+            if (this.shouldOutputJson(flags)) {
+              this.log(
+                this.formatJsonOutput(
+                  { error: errorMsg, roomId, success: false },
+                  flags,
+                ),
+              );
+            } else {
+              this.log(`Error releasing room: ${errorMsg}`);
+            }
+          }
+
+          if (this.ablyClient) {
+            this.logCliEvent(
+              flags,
+              "connection",
+              "closing",
+              "Closing Realtime connection",
+            );
+            this.ablyClient.close();
+            this.logCliEvent(
+              flags,
+              "connection",
+              "closed",
+              "Realtime connection closed",
+            );
+          }
+
+          if (!this.shouldOutputJson(flags)) {
+            this.log(chalk.green("Successfully disconnected."));
+          }
+
+          clearTimeout(forceExitTimeout);
+          resolve();
+
+          process.exit(0);
+        };
+
+        process.on("SIGINT", () => void cleanup());
+        process.on("SIGTERM", () => void cleanup());
+      });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.logCliEvent(flags, "reactions", "fatalError", `Error: ${errorMsg}`, {
+        error: errorMsg,
+        roomId: args.roomId,
+      });
+      if (this.shouldOutputJson(flags)) {
+        this.log(
+          this.formatJsonOutput(
+            { error: errorMsg, roomId: args.roomId, success: false },
+            flags,
+          ),
+        );
+      } else {
+        this.error(`Error: ${errorMsg}`);
+      }
+    } finally {
+      // Ensure client is closed even if cleanup promise didn't resolve
+      if (
+        this.ablyClient &&
+        this.ablyClient.connection.state !== "closed" &&
+        this.ablyClient.connection.state !== "failed"
+      ) {
+        this.logCliEvent(
+          flags || {},
+          "connection",
+          "finalCloseAttempt",
+          "Ensuring connection is closed in finally block.",
+        );
+        this.ablyClient.close();
+      }
+    }
+  }
+
+  private displayReactionSummary(
+    summary: Record<string, { total: number; clientIds: string[] }>,
+    flags: any
+  ): void {
+    for (const [reaction, data] of Object.entries(summary)) {
+      this.log(
+        `    ${chalk.yellow(reaction)}: ${chalk.white(data.total.toString())} from ${chalk.cyan(data.clientIds.join(", "))}`
+      );
+    }
+  }
+
+  private displayMultipleReactionSummary(
+    summary: Record<string, { total: number; clientIds: Record<string, number> }>,
+    flags: any
+  ): void {
+    for (const [reaction, data] of Object.entries(summary)) {
+      this.log(
+        `    ${chalk.yellow(reaction)}: ${chalk.white(data.total.toString())} total`
+      );
+      
+      // Display client details for multiple reactions
+      for (const [clientId, count] of Object.entries(data.clientIds)) {
+        this.log(
+          `      ${chalk.cyan(clientId)}: ${chalk.white(count.toString())}`
+        );
+      }
+    }
+  }
+}