diff --git a/lib/shared/messages/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index 6d0c41e61..51cad53d7 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,252 +1,255 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateSidebarMessageData,
   CreateSidebarMessageInfo,
   RawCreateSidebarMessageInfo,
 } from '../../types/messages/create-sidebar';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
+import {
+  ET,
+  type EntityText,
+  pluralizeEntityText,
+} from '../../utils/entity-text';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
-  type RobotextParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSidebarMessageSpec: MessageSpec<
   CreateSidebarMessageData,
   RawCreateSidebarMessageInfo,
   CreateSidebarMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSidebarMessageData | RawCreateSidebarMessageInfo,
   ): string {
     return JSON.stringify({
       ...data.initialThreadState,
       sourceMessageAuthorID: data.sourceMessageAuthorID,
     });
   },
 
   messageContentForClientDB(data: RawCreateSidebarMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateSidebarMessageInfo>) {
     let validMessageInfo: CreateSidebarMessageInfo = (messageInfo: CreateSidebarMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         sourceMessageAuthor: {
           ...validMessageInfo.sourceMessageAuthor,
           isViewer: false,
         },
         initialThreadState: {
           ...validMessageInfo.initialThreadState,
           otherMembers: validMessageInfo.initialThreadState.otherMembers.map(
             item => ({
               ...item,
               isViewer: false,
             }),
           ),
         },
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateSidebarMessageInfo {
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       row.content,
     );
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessageAuthorID,
       initialThreadState,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSidebarMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
 
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       clientDBMessageInfo.content,
     );
     const rawCreateSidebarMessageInfo: RawCreateSidebarMessageInfo = {
       type: messageTypes.CREATE_SIDEBAR,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       sourceMessageAuthorID: sourceMessageAuthorID,
       initialThreadState: initialThreadState,
     };
     return rawCreateSidebarMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSidebarMessageInfo {
     const { threadInfos } = params;
     const parentThreadInfo =
       threadInfos[rawMessageInfo.initialThreadState.parentThreadID];
 
     const sourceMessageAuthor = params.createRelativeUserInfos([
       rawMessageInfo.sourceMessageAuthorID,
     ])[0];
     if (!sourceMessageAuthor) {
       return null;
     }
 
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessageAuthor,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSidebarMessageData,
     id: ?string,
   ): RawCreateSidebarMessageInfo {
     invariant(id, 'RawCreateSidebarMessageInfo needs id');
     return { ...messageData, id };
   },
 
-  robotext(
-    messageInfo: CreateSidebarMessageInfo,
-    creator: string,
-    params: RobotextParams,
-  ): string {
-    let text = `started ${params.encodedThreadEntity(
-      messageInfo.threadID,
-      `this thread`,
-    )}`;
+  robotext(messageInfo: CreateSidebarMessageInfo): EntityText {
+    let text = ET`started ${ET.thread({
+      display: 'alwaysDisplayShortName',
+      threadID: messageInfo.threadID,
+    })}`;
     const users = messageInfo.initialThreadState.otherMembers.filter(
       member => member.id !== messageInfo.sourceMessageAuthor.id,
     );
     if (users.length !== 0) {
-      const initialUsersString = params.robotextForUsers(users);
-      text += ` and added ${initialUsersString}`;
+      const initialUsers = pluralizeEntityText(
+        users.map(user => ET`${ET.user({ userInfo: user })}`),
+      );
+      text = ET`${text} and added ${initialUsers}`;
     }
-    return `${creator} ${text}`;
+    const creator = ET.user({ userInfo: messageInfo.creator });
+    return ET`${creator} ${text}`;
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawCreateSidebarMessageInfo | RawUnsupportedMessageInfo {
     // TODO determine min code version
     if (hasMinCodeVersion(platformDetails, 75)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'created a thread',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawCreateSidebarMessageInfo,
   ): RawCreateSidebarMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SIDEBAR,
       'messageInfo should be messageTypes.CREATE_SIDEBAR!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const sourceMessageAuthorPossessive = messageInfo.sourceMessageAuthor
       .isViewer
       ? 'your'
       : `${stringForUser(messageInfo.sourceMessageAuthor)}'s`;
     const body =
       `started a thread in response to ${sourceMessageAuthorPossessive} ` +
       `message "${messageInfo.initialThreadState.name ?? ''}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateSidebarMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSidebarMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return [parentThreadID];
   },
 });
diff --git a/lib/shared/messages/create-thread-message-spec.js b/lib/shared/messages/create-thread-message-spec.js
index 456ac1dea..106b90262 100644
--- a/lib/shared/messages/create-thread-message-spec.js
+++ b/lib/shared/messages/create-thread-message-spec.js
@@ -1,220 +1,222 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateThreadMessageData,
   CreateThreadMessageInfo,
   RawCreateThreadMessageInfo,
 } from '../../types/messages/create-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
+import {
+  ET,
+  type EntityText,
+  pluralizeEntityText,
+} from '../../utils/entity-text';
 import {
   robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
-  type RobotextParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createThreadMessageSpec: MessageSpec<
   CreateThreadMessageData,
   RawCreateThreadMessageInfo,
   CreateThreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateThreadMessageData | RawCreateThreadMessageInfo,
   ): string {
     return JSON.stringify(data.initialThreadState);
   },
 
   messageContentForClientDB(data: RawCreateThreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateThreadMessageInfo>) {
     let validMessageInfo: CreateThreadMessageInfo = (messageInfo: CreateThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         initialThreadState: {
           ...validMessageInfo.initialThreadState,
           otherMembers: validMessageInfo.initialThreadState.otherMembers.map(
             item => ({
               ...item,
               isViewer: false,
             }),
           ),
         },
       };
     }
     return robotextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateThreadMessageInfo {
     return {
       type: messageTypes.CREATE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       initialThreadState: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateThreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateThreadMessageInfo: RawCreateThreadMessageInfo = {
       type: messageTypes.CREATE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       initialThreadState: JSON.parse(content),
     };
     return rawCreateThreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateThreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): CreateThreadMessageInfo {
     const initialParentThreadID =
       rawMessageInfo.initialThreadState.parentThreadID;
     const parentThreadInfo = initialParentThreadID
       ? params.threadInfos[initialParentThreadID]
       : null;
 
     return {
       type: messageTypes.CREATE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         type: rawMessageInfo.initialThreadState.type,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateThreadMessageData,
     id: ?string,
   ): RawCreateThreadMessageInfo {
     invariant(id, 'RawCreateThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
-  robotext(
-    messageInfo: CreateThreadMessageInfo,
-    creator: string,
-    params: RobotextParams,
-  ): string {
-    let text = `created ${params.encodedThreadEntity(
-      messageInfo.threadID,
-      `this chat`,
-    )}`;
+  robotext(messageInfo: CreateThreadMessageInfo): EntityText {
+    let text = ET`created ${ET.thread({
+      display: 'alwaysDisplayShortName',
+      threadID: messageInfo.threadID,
+    })}`;
     const parentThread = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThread) {
-      text +=
-        ' as a child of ' +
-        `<${encodeURI(parentThread.uiName)}|t${parentThread.id}>`;
+      text = ET`${text} as a child of ${ET.thread({
+        display: 'uiName',
+        threadInfo: parentThread,
+      })}`;
     }
     if (messageInfo.initialThreadState.name) {
-      text += ` with the name "${encodeURI(
-        messageInfo.initialThreadState.name,
-      )}"`;
+      text = ET`${text} with the name "${messageInfo.initialThreadState.name}"`;
     }
     const users = messageInfo.initialThreadState.otherMembers;
     if (users.length !== 0) {
-      const initialUsersString = params.robotextForUsers(users);
-      text += ` and added ${initialUsersString}`;
+      const initialUsers = pluralizeEntityText(
+        users.map(user => ET`${ET.user({ userInfo: user })}`),
+      );
+      text = ET`${text} and added ${initialUsers}`;
     }
-    return `${creator} ${text}`;
+    const creator = ET.user({ userInfo: messageInfo.creator });
+    return ET`${creator} ${text}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_THREAD,
       'messageInfo should be messageTypes.CREATE_THREAD!',
     );
     const parentThreadInfo = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThreadInfo) {
       return params.notifTextForSubthreadCreation(
         messageInfo.creator,
         messageInfo.initialThreadState.type,
         parentThreadInfo,
         messageInfo.initialThreadState.name,
         threadInfo.uiName,
       );
     }
     const prefix = stringForUser(messageInfo.creator);
     const body = 'created a new chat';
     let merged = `${prefix} ${body}`;
     if (messageInfo.initialThreadState.name) {
       merged += ` called "${messageInfo.initialThreadState.name}"`;
     }
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateThreadMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   startsThread: true,
 
   threadIDs(
     rawMessageInfo: RawCreateThreadMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return parentThreadID ? [parentThreadID] : [];
   },
 });