diff --git a/src/components/Layout/mdx/Admonition.tsx b/src/components/Layout/mdx/Admonition.tsx
index 5848d66904..dd85e669e1 100644
--- a/src/components/Layout/mdx/Admonition.tsx
+++ b/src/components/Layout/mdx/Admonition.tsx
@@ -2,7 +2,7 @@ import React from 'react';
 import cn from '@ably/ui/core/utils/cn';
 import Aside from '../../blocks/dividers/Aside';
 
-const LEGACY_ADMONITION_TYPES = ['new', 'updated', 'experimental', 'public-preview'];
+const LEGACY_ADMONITION_TYPES = ['new', 'updated', 'experimental', 'see-evidence'];
 
 type AdmonitionVariant = 'neutral' | 'note' | 'further-reading' | 'important' | 'warning';
 
diff --git a/src/components/blocks/dividers/Aside.tsx b/src/components/blocks/dividers/Aside.tsx
index 151a323bad..d0ea494fc0 100644
--- a/src/components/blocks/dividers/Aside.tsx
+++ b/src/components/blocks/dividers/Aside.tsx
@@ -44,6 +44,14 @@ const Aside = ({ children, attribs }: AsideProps) => {
             <span className="ui-text-p2 font-bold text-neutral-1300 mb-12">Further Reading</span>
           </strong>
         </>
+      ) : attribs && attribs[`data-type`] === `see-evidence` ? (
+        <>
+          <span className={`${leftSideElement} ${styles['see-evidence-element']}`}>&nbsp;</span>
+          <strong className={tipTitleElement}>
+            <span className="mr-3 text-3xl">🔎</span>
+            <span className="ui-text-p2 font-bold text-neutral-1300 mb-12">See evidence</span>
+          </strong>
+        </>
       ) : attribs && isVersioningInfo ? (
         <>
           <span
diff --git a/src/components/blocks/dividers/dividers.module.css b/src/components/blocks/dividers/dividers.module.css
index c11886aace..529bf3d09f 100644
--- a/src/components/blocks/dividers/dividers.module.css
+++ b/src/components/blocks/dividers/dividers.module.css
@@ -21,6 +21,9 @@ span.left-side-element {
 .further-reading-element {
   background-color: #08fe13;
 }
+.see-evidence-element {
+  background-color: #14b8a6;
+}
 
 strong.tip-title-element {
   margin-left: var(--spacing-16);
diff --git a/src/pages/docs/liveobjects/batch.mdx b/src/pages/docs/liveobjects/batch.mdx
index 1ddbb21a09..e0269b2672 100644
--- a/src/pages/docs/liveobjects/batch.mdx
+++ b/src/pages/docs/liveobjects/batch.mdx
@@ -31,6 +31,10 @@ Batch operations are only currently only supported in LiveObjects JavaScript. Su
 
 Batch operations allow multiple updates to be grouped into a single channel message and applied atomically. It ensures that all operations in a batch either succeed together or are discarded entirely. Batching is essential when multiple related updates to channel objects must be applied as a single atomic unit, for example, when application logic depends on multiple objects being updated simultaneously. Batching ensures that all operations in the batch either succeed or fail together.
 
+<Aside data-type='see-evidence'>
+With 50% capacity headroom built in, Ably instantly absorbs traffic spikes without degradation or pre-provisioning. [See evidence here 🕵️](/docs/platform/architecture/infrastructure-operations#resource-implications)
+</Aside>
+
 <Aside data-type="note">
 Batch operations are different from ["Message batching"](/docs/messages/batch), which is a server-side feature of [Pub/Sub](/docs/basics).
 </Aside>
diff --git a/src/pages/docs/liveobjects/concepts/objects.mdx b/src/pages/docs/liveobjects/concepts/objects.mdx
index a3200d07ec..9c8b2851cd 100644
--- a/src/pages/docs/liveobjects/concepts/objects.mdx
+++ b/src/pages/docs/liveobjects/concepts/objects.mdx
@@ -27,6 +27,10 @@ meta_description: "Learn how data is represented as objects in Ably LiveObjects"
 
 LiveObjects enables you to store shared data as "objects" on a channel, allowing your application data to be synchronized across multiple users and devices in realtime. This document explains the key concepts you need to know when working with objects.
 
+<Aside data-type='see-evidence'>
+Within a single region, all MQTT subscribers will observe messages in the same order, ensuring consistent experiences for users in that region. [See evidence here 🕵️](/docs/platform/architecture/message-ordering#practical-implications-of-dual-ordering)
+</Aside>
+
 ## Primitive types <a id="primitive-types"/>
 
 Primitive types are the fundamental data types that can be stored in a collection type. Currently, the only supported collection type is a [LiveMap](/docs/liveobjects/map).
diff --git a/src/pages/docs/liveobjects/concepts/operations.mdx b/src/pages/docs/liveobjects/concepts/operations.mdx
index 3353bfa619..1210030a4a 100644
--- a/src/pages/docs/liveobjects/concepts/operations.mdx
+++ b/src/pages/docs/liveobjects/concepts/operations.mdx
@@ -29,6 +29,10 @@ LiveObjects operations define how object data is updated and synchronized across
 
 When you create or update an object, the change is expressed as an _operation_ that is sent as an [object message](/docs/metadata-stats/stats#messages) on the channel. The operation is then applied to the object instance on all clients that are subscribed to the channel.
 
+<Aside data-type='see-evidence'>
+Applications maintain their state during disruptions. All messages are received in correct order with zero message loss. [See evidence here 🕵️](/docs/platform/architecture/connection-recovery)
+</Aside>
+
 This document explains the key concepts you need to know when working with operations.
 
 ## Operation types <a id="operation-types"/>
diff --git a/src/pages/docs/liveobjects/concepts/synchronization.mdx b/src/pages/docs/liveobjects/concepts/synchronization.mdx
index 795ce1d899..b1d8b0a83b 100644
--- a/src/pages/docs/liveobjects/concepts/synchronization.mdx
+++ b/src/pages/docs/liveobjects/concepts/synchronization.mdx
@@ -37,6 +37,10 @@ Ably stores the object data durably such that the data is available even after t
 
 When a channel first becomes active in a region, the channel loads the object data from durable storage into memory to facilitate low-latency operation processing.
 
+<Aside data-type='see-evidence'>
+Every message is redundantly stored across multiple isolated datacenters within your region before acknowledgment, preventing data loss. [See evidence here 🕵️](/docs/platform/architecture/fault-tolerance#core-layer)
+</Aside>
+
 ## Client objects <a id="client-objects"/>
 
 While Ably maintains the source of truth on the channel, each connected client keeps a local representation of the objects on the channel.
@@ -56,3 +60,7 @@ Currently, when a client publishes an operation it is not immediately applied to
 </Aside>
 
 If there is a loss of continuity on the channel for any reason, such as the client becoming disconnected for more than two minutes and entering the [suspended state](/docs/connect/states#connection-states), the client objects will automatically be resynchronized when it reconnects.
+
+<Aside data-type='see-evidence'>
+If a client reconnects within two minutes, full connection recovery with exactly-once delivery is guaranteed. [See evidence here 🕵️](/docs/platform/architecture/idempotency#connection-recovery-and-exactly-once-delivery)
+</Aside>
diff --git a/src/pages/docs/liveobjects/inband-objects.mdx b/src/pages/docs/liveobjects/inband-objects.mdx
index ca30536478..c2cd2bfdbb 100644
--- a/src/pages/docs/liveobjects/inband-objects.mdx
+++ b/src/pages/docs/liveobjects/inband-objects.mdx
@@ -37,6 +37,10 @@ If you're using LiveObjects from one of the the following languages, then use th
 
 Inband objects works by delivering changes to channel objects as regular channel messages, similar to [inband occupancy](/docs/channels/options#occupancy).
 
+<Aside data-type='see-evidence'>
+Ably achieves a global median message delivery latency of 37ms, continuously monitored through over 6 million measurements daily across all regions. [See evidence here 🕵️](/docs/platform/architecture/latency#how-latency-is-measured)
+</Aside>
+
 ## Enable Inband Objects <a id="inband-objects-enable"/>
 
 To enable inband objects, use the `objects` [channel parameter](/docs/channels/options#objects) when getting a channel:
diff --git a/src/pages/docs/liveobjects/index.mdx b/src/pages/docs/liveobjects/index.mdx
index 9ffd8a4f3d..fbabf1ce1a 100644
--- a/src/pages/docs/liveobjects/index.mdx
+++ b/src/pages/docs/liveobjects/index.mdx
@@ -37,6 +37,10 @@ LiveObjects enables you to store shared data as "objects" on [channels](/docs/ch
 
 LiveObjects provides a simple, purpose-built API that handles realtime synchronization, persistence, and convergence behind the scenes. The result is a single logical view of your data - distributed to the edge, updated in real time, and always in sync - no matter how many users are connected or where they are in the world.
 
+<Aside data-type='see-evidence'>
+Ably's tiered fanout architecture allows it to scale to handle millions of subscribers per channel. [See evidence here 🕵️](/docs/platform/architecture/platform-scalability#handling-high-scale-fanout)
+</Aside>
+
 ## Use cases <a id="use-cases"/>
 
 You can use LiveObjects to build all sorts of powerful functionality in your applications that require realtime updates to shared data. It is useful when your application has data that:
diff --git a/src/pages/docs/liveobjects/lifecycle.mdx b/src/pages/docs/liveobjects/lifecycle.mdx
index ebc0b2cb53..97ab57839e 100644
--- a/src/pages/docs/liveobjects/lifecycle.mdx
+++ b/src/pages/docs/liveobjects/lifecycle.mdx
@@ -76,6 +76,10 @@ channel.getObjects().on(ObjectsStateEvent.SYNCED, (stateEvent) -> {
 LiveObjects synchronization events do not replace [connection](/docs/connect/states) or [channel](/docs/channel/states) states. You should still monitor these states and handle [connection](/docs/connect/states#handling-failures) and [channel](/docs/channel/states#failure) failures to ensure your application behaves as expected. LiveObjects synchronization events specifically inform you about the progress of LiveObjects data synchronization and should be used alongside other state management mechanisms.
 </Aside>
 
+<Aside data-type='see-evidence'>
+Ably's SDKs automatically resolve edge network failures within 30 seconds, keeping your users connected even during infrastructure issues. [See evidence here 🕵️](/docs/platform/architecture/edge-network)
+</Aside>
+
 ## Handle object lifecycle events <a id="objects-lifecycle"/>
 
 <If lang="javascript">
diff --git a/src/pages/docs/liveobjects/storage.mdx b/src/pages/docs/liveobjects/storage.mdx
index 7f7ba0a557..35eec9317c 100644
--- a/src/pages/docs/liveobjects/storage.mdx
+++ b/src/pages/docs/liveobjects/storage.mdx
@@ -7,6 +7,10 @@ meta_description: "Learn about LiveObjects object storage."
 
 Ably durably stores all objects on a channel for a retention period that is configured to 90 days by default. If the data is not updated within the retention period, it automatically expires. After expiry, the channel is reset to its initial state and only includes an empty <If lang="javascript">[channel object](/docs/liveobjects/concepts/objects#channel-object)</If><If lang="swift,java">[root object](/docs/liveobjects/concepts/objects#root-object)</If>.
 
+<Aside data-type='see-evidence'>
+Ably maintains message continuity for up to 2 minutes during disconnections. The SDKs automatically handle reconnection and deliver all missed messages. [See evidence here 🕵️](/docs/platform/architecture/connection-recovery)
+</Aside>
+
 <Aside data-type='note'>
 If you're interested in a configurable default object storage duration, please [get in touch](https://ably.com/support) with your requirements.
 </Aside>