I’m leaving the post below in place…but see my latest update to see how this has evolved…

I hope you’ve found the TrustIndex Signals, Briefings and Reports useful. I know I’ve learned a lot putting them together.

But a couple of things mean I’m going to pause this - just for a moment.

First, if you haven’t seen I’ve been working on a project that’s putting all the things I’ve learned here into action. You can read the “vision” essay here. And you can visit the project itself at flo.monster.

Second, my health just doesn’t let me do as much as I want.

If there’s one thing this project has shown me, it’s that things really are changing faster and faster. It’s not an illusion and it’s not just hype. The interface is thickening and we’re walking (if not running) into an AI-Mediated future.

The “World Generation” tools that were the focus of the first TrustIndex / Report have already moved ahead in leaps and bounds and this is just going to continue.

And the next area I’ve been looking at is “Realtime GenAI”. This is just starting to really hit it’s stride and will likely have a big impact over the next few months.

Plus ALL the other tools and developments that are impacting the TrustIndex dials. So much to discuss!

But for now this is “PAUSE”.

Hopefully I can re-visit this all soon, and I’m confident what’s here already will provide a useful landmark for us to compare against.

Thanks for reading…

It’s positioned as browser-level tooling for autonomous task completion, rather than a separate app experience.

This puts upward pressure on the Reality dial as agents take on more of our daily tasks.

When the browser can execute steps end-to-end, the user spends less time verifying pages directly and more time accepting an agent’s interpretation of what it opened, what it ignored, and what it decided was “good enough” to act on. That shifts the locus of trust from the raw web to the model-mediated interface.

As this pattern normalises, the “agent-as-interface” layer thickens - the model becomes the practical gateway to information and action, including which sources are surfaced and which are silently bypassed. In Reality terms, that concentrates power in the selection and sequencing logic, because the model isn’t just summarising the web - it is choosing and performing the path through it, with less user friction to notice mistakes.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

The release packages capabilities that can be integrated directly into downstream apps and toolchains.

This puts upward pressure on the Fidelity dial.

- Lowers the cost and friction of producing near-human speech by making cloning and controllable voice design widely accessible.
- Widens distribution pathways: open-source availability speeds reuse in apps, agents, and localisation pipelines without bespoke vendor deals.
- Reduces the gap between “synthetic” and “indistinguishable” audio in everyday deployments, pushing expectations of realism upwards.
- Expands misuse surface area (e.g., scams and impersonation) by enabling high-quality voice generation with minimal barriers

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

This is positioned as broadly reusable speech-to-text infrastructure rather than a single product deployment.

This puts upward pressure on the Equality dial. Low-resource and historically unsupported languages get materially better baseline coverage, reducing exclusion driven by “language availability” gaps. Open access enables local organisations (education, civic services, disability support) to adopt ASR without waiting for commercial prioritisation of high-demand markets. Wider language coverage can shift where speech interfaces work reliably, improving access for communities that are typically left out of mainstream speech tech.

Open models lower experimentation costs, increasing the likelihood of targeted, community-led adaptations for under-served languages.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

This Nature Electronics work is a strong signal: topology-based body sensor networks - where sensors are distributed across clothing (or the body) and the shape/topology of that network helps coordinate sensing and data flow.

In plain terms: you’re no longer measuring a couple of points (wrist, chest, ring). You’re turning large areas of your body into an instrumented interface.

That’s upward pressure on the Reality dial. Because as the sensing footprint expands, the AI layer gets more continuous, more intimate, and more “default”:

- More of you becomes measurable (movement, posture, physiology, environment contact).
- More of your day becomes legible (not just workouts or sleep - everything in between).
- More decisions get nudged by models that sit between your lived experience and what the data implies.

And topology matters because it’s a step toward wearable sensing that can scale beyond rigid, fixed placements - sensors embedded into fabric, arranged dynamically, and still meaningfully interpreted.

This is what “AI-mediated” looks like when it’s not just on screens: it’s stitched into the layer you live inside.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

This particular device is a wearable, skin-mounted system designed to capture sweat in real time and translate it into measurable signals - turning hydration, stress, exertion, and metabolic by-products into something that can be tracked, interpreted, and (eventually) acted on.

That’s upward pressure on the Reality dial as the interface layer thickening inward.

Because the more of your bodily output we can sense continuously, the more the “default interface” to your own body shifts from “felt experience” to “AI-mediated interpretation”:

- From “I feel off” to “the model says you’re trending off.”
- From occasional check-ins to continuous monitoring.
- From personal intuition to dashboards, alerts, and automated recommendations.

On its own, a sweat sensor isn’t world-changing. But stacked with wearables, glucose monitors, smart rings, and health assistants, it’s part of the same pattern: more of you becomes legible to machines — and therefore governable by them.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

If you’ve spent any time with the early versions of spatial computing then there’s a particular kind of AR experience you probably got used to. You looked at an object and the system tried to meet you halfway - an asset loaded, then a label, then the label jittered as little as you moved. The overlay was technically “tracking”, but it didn’t feel like the world had been understood. It just felt like a clever sticker fighting to stay attached.

For years that separation was the giveaway. You could tolerate it in a demo, you could forgive it in a prototype, you could even learn to ignore it in a product - but you always felt it. The digital layer was sitting on reality rather than in it.

And then, every so often, you got a glimpse of the opposite as things slowly improved.

You could pan a phone through a room and the overlay didn’t slide. You could lean closer and it didn’t wobble. You’d walk behind a chair and whatever was “there” stayed there, calmly and correctly, as if it belonged. It’s not that the graphics are prettier or the models are bigger. It’s that the experience stopped arguing with your senses.

That’s the threshold that’s been changing over the last year or so - the moment when spatial computing stopped looking like computer vision dressed up as product, and started feeling like a seamless blend of the world around you with worlds that never existed - but behave as if they do. But this evolution is about to accelerate, significantly.

We’ve already lived through one revolution to get here. The quiet one.

We went from hand‑crafted pipelines (the brittle era of tuned thresholds, feature descriptors, geometry tricks, heuristic association rules) to systems that learn to perceive. We replaced cleverness with gradient descent. The results were not subtle. Categories that used to require careful engineering became commodities - pose estimation running in real time on edge devices. Multi‑object tracking (MOT) that holds together under occlusion. Lightweight models that can run in a browser and still give you a surprisingly stable skeleton. Entire libraries became like a muscle memory.

It’s easy to forget how dramatic that shift was because it happened in slow motion and then, suddenly, it was everywhere.

Look at human pose as an example.

You can pick almost any modern baseline and get decent keypoints at a reasonable frame rate - a single‑stage model like YOLO(26) Pose will happily give you COCO joints in one forward pass. ViTPose treats joints as a global relationship problem rather than a local heatmap. And Google MediaPipe / BlazePose keeps the whole thing light enough for phones and browsers while still covering an unusually rich skeleton. If you want the classic “don’t lose resolution” approach you reach for HRNet. If you care about temporal coherence you start looking at designs like HSTPN and multi‑frame approaches like DCPose. And if you’re doing anything even slightly off the main highway you end up in toolboxes like DeepLabCut, because it’s often the quickest way to adapt the machinery to the reality you actually have.

None of this is magic anymore. It’s more like a menu.

Multi‑object tracking (MOT) followed the same arc. First came the tracking‑by‑detection lineage - the pragmatic, industrial path where you detect each frame and then you stitch together identities with association logic.

That family evolved fast - SORT to DeepSORT, and then into the modern wave that made “use the detector, then track everything” feel almost obvious. ByteTrack is the name most people remember because it catalysed that pattern.

At the same time, a second paradigm grew in parallel - end‑to‑end transformers that try to treat tracking as a sequence modelling problem, where the system predicts identities the way language models predict tokens.

If you look at the current crest you can see where the field is trying to go - MOTIP reframing MOT as ID prediction, SambaMOTR modelling synchronised sets of sequences, CO‑MOT playing with coopetition and shadow sets to keep identities stable. And you can see the “make it general” thread running through work like MASA (matching anything by segmenting anything) and GeneralTrack, alongside pragmatic hybrids like Hybrid‑SORT.

Underneath all of it, the detector backbones are shifting too.

CNN workhorses still matter, but more and more stacks are built on transformer detectors such as RF‑DETR and real‑time variants like RT‑DETR, while the YOLO line keeps advancing (people now pair trackers with YOLO as casually as they used to with much older generations).

If you read the field’s recent surveys you can feel the split - heuristic‑heavy methods still look surprisingly good when the world behaves. Dense crowds moving in roughly linear motion, predictable trajectories, the kinds of scenes where a good detector plus a sensible association policy can be brutally effective. Meanwhile deep association methods, both tracking‑by‑detection and end‑to‑end, start to dominate when motion becomes messy, the camera gets ambitious, the scene becomes non‑linear, the world stops being polite.

That story (the arms race between heuristics and learning) has been the dominant narrative for the last few years.

But I think we’re at a different kind of inflection point now.

The next revolution is not primarily about trackers becoming “better” in the old sense. It’s about something upstream changing so profoundly that “better tracking” becomes the default outcome of a whole new stack.

The stack itself is starting to invert.

Instead of building a pipeline that extracts the world from raw pixels, we are building systems that can generate worlds - and then train perception inside them, at scale, under controlled variation, with edge cases on demand. At the same time, we are standardising a practical representation of the world that is cheap enough to store, stream, update, and localise against.

World models and 3D Gaussian splatting are the two pillars of that inversion.

On the surface they look like separate threads. One is about synthetic environments and interactive generation. The other is about an uncanny rendering technique that suddenly made photorealistic scenes run in real time.

But if you follow the direction of travel, they converge into something else - a data plane for reality.

The collapse

The first clue that something structural is changing is how quickly specialised vision pipelines are being eaten by general models.

A few years ago, segmentation was a task. You had a model for it, you trained it, you tuned it, you deployed it. You treated masks as outputs in a pipeline.

Then the Segment Anything family showed up and segmentation became interaction. The model didn’t just output a mask, it responded to prompts. A point, a box, a scribble. The mask was not a prediction, it was a negotiation.

When SAM moved into video as SAM 2, the negotiation gained memory. It started to carry context through time, to handle motion and occlusion, to act like a system that could keep an object in mind.

As the ecosystem expanded - SAM 2 pushing tracking “at any granularity” via prompts and a unified decoder, and the more speculative leap towards SAM 3 with open‑vocabulary text prompting (with SAM3D reaching toward single‑image 3D reconstruction) - the interesting work shifted from “how do we segment?” to “how do we manage memory?”

Different variants started to look like governance policies. SAMURAI reads like motion‑aware memory selection made explicit. DAM4SAM is a set of rules for dealing with distractors before they poison the memory. SAM2Long reaches for multiple parallel memory banks so long sequences don’t decay into mush. MoSAM pulls motion into the prompting loop so the model doesn’t have to infer dynamics from scratch.

It’s tempting to treat these as incremental research tweaks. But together they’re a sign that we’re moving from models that predict to systems that manage coherence.

And once coherence management is the game, you can start chaining models together.

The emerging “pipeline 2.0” looks less like classical CV and more like orchestration - a model that can produce a rough localisation. A foundation segmenter that turns that into precise masks. A tracker that keeps those masks stable. A prompt policy that decides what counts as “the same thing” across time.

You can already see this becoming a pattern in the wild - ChatGPT, Claude or Gemini proposes a box. SAM 2 turns it into a mask and keeps it alive.

Open‑vocabulary detectors like YOLO‑World do the same job when you’d rather not rely on a VLM to propose the first guess. And you can feel where it’s going when you see work like Seg2Track‑SAM2 claiming zero‑shot MOT+segmentation behaviour.

The point isn’t the leaderboard, it’s the direction - tracking as a callable capability, not a bespoke pipeline.

In that world, the core product question is not “which tracker is best?” It’s “what are the controls?”

Where do you let the model drift? How do you recover? How do you handle occlusion? What does the system do when the user moves quickly, or when lighting changes, or when a hand enters the frame and blocks the object you care about?

The moat becomes the control surface - the interface between a general perception engine and a specific experience.

TrustIndex pressure: as creation friction drops, Fidelity pressure rises. Generated output stops being seen as “content” and starts being seen as part of your lived environment - which makes failures feel less like bugs and more like reality glitching.

Anchors - the world needs places to stick

Seamless spatial computing doesn’t just require recognising objects. It requires anchoring them - knowing where they are, how they’re oriented, and how that relationship changes as you move.

This is where 6DoF object pose and camera localisation matter, and where the trend lines get interesting.

For a long time, robust 6DoF tracking felt like the territory of specialised setups. Depth sensors helped. Markers helped. Carefully curated object models helped. The constraint was always the same - the world is three‑dimensional, the camera gives you a two‑dimensional slice, and you need to reconstruct enough geometry to make interaction believable.

But the field has been moving towards “RGB‑only is winning”. Not as a philosophical preference, but as an inevitability.

If you can do 6DoF pose estimation and tracking on novel objects without fine‑tuning, you’ve removed an entire category of friction. FoundationPose is the cleanest signal there - a foundation‑model approach to 6D pose that aims to work on novel objects without the usual object‑specific retraining rituals.

If you can do it in real time with RGB alone (inferring depth as needed, recovering gracefully when things go wrong) then you’ve changed the economics of spatial interaction. RGBTrack makes the bet explicit - RGB‑only, practical recovery policies, and a path to consumer deployment without assuming LiDAR as a crutch. Around that you can see the broader push toward generalisability - ideas like ConceptPose using VLM‑style priors for open‑vocabulary 3D concept maps. Iterative model‑free methods like iG‑6DoF. Memory‑queue thinking like PoseStreamer. And approaches that explicitly connect pose estimation to splats, like GS‑Pose.

Suddenly any phone camera becomes a viable sensor for experiences that used to require specialised hardware.

Camera pose tracking has its own parallel story. Classical SLAM is a triumph of geometry, but it has always been fragile in the ways that matter for consumer experiences - dynamic scenes, changing lighting, textureless surfaces, environments that don’t sit still.

So we started augmenting it. Deep learning for retrieval and matching. Semantics to avoid treating moving objects as static landmarks.

People are literally wiring detectors and segmenters into systems like ORB‑SLAM3 now, because dynamic environments are where classical geometry has always looked most fragile. Event camera SLAM became a serious thread. Even direct pose regression models (PoseNet, MapNet, DeepVO) that try to bypass the whole geometric stack.

And then 3D Gaussian splatting entered the discussion.

Because once you have a representation that can capture a scene with high visual fidelity and render it efficiently, you can start using it as a map. Not a point cloud, not a mesh, but a dense, photorealistic substrate that the camera can localise against.

The result has been an explosion of work connecting splats to localisation.

GSplatLoc and SplatLoc, newer work like STDLoc and 3DGS‑Loc, semantic variants like SGLoc, and robust relocalisation threads such as GS‑Loc that explicitly lean on vision foundation models to make the representation less brittle.

It’s a sign that 3DGS is not just a rendering technique, it’s becoming a practical spatial medium.

Splats as the ‘JPEG of 3D’

The “JPEG of 3D” metaphor gets used a lot, and it’s useful…but it’s also incomplete.

JPEG didn’t win because it was the prettiest image format. It won because it was good enough, cheap enough, and standardised enough that the rest of the world could build around it.

That’s what’s starting to happen with Gaussian splats.

In a remarkably short period (about 18-24 months by some counts) we went from a research paper showing real‑time rendering to mobile‑friendly capture pipelines, to city‑scale real‑time systems like FlashGS, to practical compression and streaming techniques like Voyager that make splats viable as content you can move around.

More importantly, we’re seeing early standardisation efforts - the glTF ecosystem absorbing splats, and compact containers like SPZ designed to make them interoperable.

This is the boring part of revolutions - file formats and interchange layers. But it’s also where revolutions become inevitable.

Once a representation can move between tools, engines, and devices, it stops being a novelty and becomes infrastructure. And you can see that infrastructure taking shape as systems.

Online mapping and tracking like SplaTAM and GS-SLAM. Dynamic and relightable worlds like 4D‑GS and LiveGS. Practical tooling like gsplat in the Nerfstudio ecosystem. And product‑adjacent work like Niantic Morpheus, which treats splats as something you can edit rather than merely capture.

And infrastructure changes the question.

Instead of asking, “Can we reconstruct this environment?” we start asking, “Can we persist it? Can we update it? Can we share it? Can we localise against it reliably?”

That is exactly the set of questions you need to answer if you want spatial computing to become seamless.

Because seamlessness requires persistence. It requires the digital layer to behave like it belongs, not just in a single session but across time. It requires the world to have memory.

TrustIndex pressure: persistence pulls on Portability. Once your world is a living artefact (splats, anchors, edits, shared maps) switching providers stops being ‘export my data’ and becomes ‘move my environment’.

The training factory - when worlds become synthetic by default

Now we reach the real inflection point that’s just starting to hit.

The bottleneck for tracking has never been ideas. The ideas are abundant. The bottleneck has been data - diverse, labelled, messy, in‑the‑wild data that covers the edges rather than the centre.

If you’ve ever tried to harden a spatial system for real users, you know where it breaks. Not in the lab. In the weird lighting. The overly sparse bathroom, or overly cluttered kitchen. The reflective surfaces. The unusual object that looks like three things at once. The moment the user moves faster than your assumptions. The day it rains and everything changes.

The cost of collecting those edge cases is what has kept many spatial experiences narrow.

World models flip that.

They are not simply “better simulators”. They’re a new kind of primitive - systems that can generate environments, trajectories, sensor outputs, and rare events on demand - and then use those synthetic worlds to train perception stacks that will run in the real world.

You can see the pattern forming across the major players.

There are general interactive world models that can generate navigable environments in real time from prompts, maintaining a kind of visual memory and physical consistency for long enough to be useful.

DeepMind’s Genie 3 is the latest and cleanest marker here, and the existence of a consumer‑facing Project Genie preview is an early hint about where this is heading.

There are infrastructure platforms designed explicitly for physical AI - NVIDIA Cosmos, with its Predict / Transfer / Reason framing and its tight coupling to synthetic data tooling.

There are commercial products focused on persistent, downloadable 3D worlds that can be created from multimodal inputs and exported in formats that plug directly into the splat ecosystem.

World Labs’ Marble is notable not just because it exists as a product, but because it exports in splats and meshes, and because tools like Chisel make the “structure vs style” separation feel like a deliberate design philosophy rather than a technical trick.

There are multi‑domain, product‑oriented models that condition on actions (camera pose, robot commands) and ship with SDKs designed to slot into robotics workflows. Runway’s GWM‑1 is unusually explicit about this - worlds, robotics, avatars, all as variants of a single direction.

And then there’s the clearest proof point of the whole thesis - the Waymo World Model. A domain‑specific post‑training of the Genie line, producing multi‑sensor simulations that match Waymo’s camera+lidar outputs. It generates scenarios that were never captured by the fleet, and even converts arbitrary dashcam footage into multimodal Waymo‑style sensor simulations. It’s a statement of intent - the general world model becomes a base layer, and domains become post‑training recipes.

That last move matters because it reveals the architecture.

Real data improves the world model. The world model generates synthetic data. Synthetic data trains a better tracker and a better policy. A better deployed system collects harder real data.

And the loop tightens.

This is not a single model improving. It’s a flywheel. And it’s just starting to spin. Once the flywheel exists, “tracking quality” stops being an isolated technical metric and becomes the downstream consequence of an organisation’s ability to run that loop.

TrustIndex pressure: the flywheel makes Fidelity cheap, but it also quietly increases Reality pressure. When the system can generate the edge cases that shape your perception stack, it starts deciding what kinds of worlds you’re trained to see - and what kinds of worlds you’re blind to.

Convergence - generated worlds flowing into real ones

If you connect these threads (promptable perception, RGB‑first anchoring, splats as a spatial substrate, world models as data factories) you end up heading toward a specific destination.

A world where the boundary between capture and generation becomes porous.

First you use the real world to train systems that can track, segment, and localise robustly. Then those systems become good enough that you can seamlessly lay generated content into the real world.

And once you can do that, you can start to do something more ambitious - blend generated worlds into and over the world around you, in a way that feels less like an overlay and more like a new layer of reality.

This is the moment spatial computing becomes really seamless. Not because the graphics are better. Because the experience becomes coherent under your motion. Because the system’s internal world model (whether it is reconstructive, generative, or some hybrid) matches the way your senses expect the world to behave.

TrustIndex: Fidelity takes the cleanest hit

If we instrument this with the TrustIndex, the cleanest pressure is on Fidelity.

Fidelity is where spatial computing either becomes mundane (quietly useful, like glasses) or becomes perpetually uncanny. It is the dial that captures whether the mediated layer feels believable, whether it integrates with your environment, whether it holds up during interaction.

The new wave we’re describing is essentially a Fidelity engine.

Better tracking increases Fidelity because it stabilises the relationship between you and the world. Better anchoring increases Fidelity because it makes the digital layer behave like it has weight. Splats increase Fidelity because they give us a way to store and render the world with high visual realism at practical cost. World models increase Fidelity because they allow us to train the entire stack under far more diverse conditions than we can collect.

But Fidelity doesn’t rise in isolation.

As the seam disappears, Reality (the degree to which the system mediates perception and action) starts to move as well. When the blended layer becomes the default way you see, the interface becomes a filter on more of your attention and a guide for more of your behaviour.

Transparency becomes harder too. The better the blend, the higher the cost of provenance. This mediation becomes less visible, because the user cannot rely on “it looks fake” as a cue. We’re already well past this with Generative AI Video, and this inflection point will let that leak into the real world.

Portability becomes a new kind of lock‑in. If your experience depends on a vendor’s world layer (their map formats, their memory policies, their identity and anchoring systems) then switching stops being “move my data” and becomes “move my reality interface”.

This is why I think Fidelity is the right dial to watch. Not because it’s the only one that matters. Because it’s the one that changes the moment this technology stops feeling like a demo. And all the other changes here flow from that.

Who gets edit rights?

There’s a comforting story we tell about spatial computing, where the goal is simply to make digital things sit properly in the real world. But the trajectory here points somewhere stranger.

When tracking becomes robust, and when the world can be captured and represented cheaply, and when synthetic environments can be generated at will, the question stops being, “Can we overlay content?”

The question becomes, “What do we let reality become?”

Because a seamless blend is not just a technical achievement. It’s a choice about what counts as real enough to act on.

And once the seam disappears, that choice moves from the user’s conscious awareness into the system’s defaults - what it remembers, what it forgets, what it stabilises, what it edits, what it smooths over.

If the future of spatial computing is a world where generated worlds flow into real ones without friction, then the most important question may not be how fast we can track, or how photorealistic we can render.

It may be simpler.

When the world is editable, who gets the edit rights? This is why the TrustIndex’s Equality dial is so important.

Join in as we track this slope and stay up-to-date. You can always find the current dashboard at TrustIndex.today and subscribe for regular updates as new Signals arrive, weekly Briefings are published and new Reports are released.

The core idea: a training-free method that can add voxel/3D-style scene structure to existing vision models, improving their ability to analyse and reason about what’s happening in a space (objects, layout, relationships) without needing to retrain the model from scratch.

That’s Reality dial pressure.

Because once scene understanding gets cheaper and more portable (something you can bolt onto today’s models) it becomes much easier for AI to sit between you and the world in real time:

- More of the world becomes legible. Not just “there’s a chair”, but “the chair is behind the table, blocking the path”, “the mug is near the edge”, “that surface is reachable”.
- Context becomes actionable. Better scene structure means better grounding for assistants that navigate, guide, and decide - in AR, robotics, accessibility, and everyday “what am I looking at?” use-cases.
- It scales without a big retraining tax. Training-free approaches spread fast, because they’re adoptable by anyone already shipping a vision model.

This isn’t a consumer feature on its own. But it’s exactly the kind of infrastructure upgrade that quietly turns into mainstream behaviour once it lands inside phones, glasses, browsers, and assistants.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

DNA Decoder predicts these tracks down to single–base-pair resolution across modalities like gene expression, chromatin accessibility, transcription factor binding, contact maps, and splicing.

That’s Reality dial pressure.

Because the moment you can ask an API “what does this variant do?” and get a probabilistic, multi-layer biological story back, an AI system starts to sit between you and your biology - not just as a research tool, but as an interface layer for how risk, diagnosis, and identity are interpreted.

A few reasons this matters:

- Interpretation becomes a product surface. We’re moving from “I have a genome report” to “I have an always-on model that can score changes and simulate likely downstream effects.”
- Biology becomes queryable. The body starts to look like another dataset you can interrogate conversationally - and that changes how people relate to health, heredity, and decision-making.
- The interface thickens inward. We’ve watched AI mediate search, inboxes, browsers, and the physical world. Now it’s starting to mediate the internal world as well.

This isn’t a consumer feature yet. But it’s exactly how consumer features get born: a high-leverage model becomes an API, the API becomes a workflow, and the workflow becomes the default interface.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

Agents can post tasks, and real people carry them out in the physical world. The site frames it as “the meatspace layer for AI” and the tagline is blunt - “robots need your body”.

This puts upward pressure on the Autonomy dial, but not in the way we usually mean it.

Because autonomy isn’t only about models getting smarter - it’s about how long a system can run end-to-end without you. And one of the fastest ways to extend an agent’s action horizon is to give it a human proxy when it hits the boundary of the digital world:

- need something picked up, photographed, checked, delivered, returned? rent a person
- need a “hands-and-eyes” loop in a place your agent can’t access? rent a person
- need a “real-world click” where robots still can’t touch grass? rent a person

So yes - agents can now operate for longer without “you”...by directing “someone else”.

This is autonomy via outsourcing and the gig economy just got an AI upgrade. It’s a bridge technology that helps agents behave like they already have bodies, before robots scale. It’s also a subtle social reframe - the “human-in-the-loop” isn’t the user providing oversight. It’s an on-demand labour layer that makes the agent look more capable than it actually is. This also puts downward pressure on the Equality dial.

If you want the broader context - this fits neatly alongside the “Feb 2026 TrustIndex / Report” on Autonomous Assistants - where the trajectory is clear: longer-running agents don’t just need better reasoning, they need execution infrastructure. rentahuman.ai is execution infrastructure. Just...made of people.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

It’s a new approach that aims to produce “metric (to-scale) depth from a single camera”, and can also “recover camera intrinsics” and “use sparse depth as an input”. In other words - it’s pushing toward a world where “how far away is that?” or “how big is that?” become a default capability for commodity cameras. Not just something you only get from specialised sensors or carefully controlled setups.

Why this matters for TrustIndex - this puts upward pressure on the Fidelity dial.

High-fidelity AI-Mediation isn’t just prettier overlays - it’s “correct overlays” and AI-based “spatial reasoning”. If your system can infer real-world scale and geometry reliably, then:

- AR/UI layers can sit on the world instead of floating near it
- agents can reason about reach, clearance, placement, and navigation with fewer hallucinated distances
- “digital twins” become less like vibes and more like measurements
- the hand-off from perception → action gets tighter (robots, assistants, assistive tech, tools)

This is the quiet kind of progress that makes future interfaces feel inevitable. Once you can get metric depth from “just a camera”, you can ship spatial understanding everywhere (phones, glasses, laptops, drones) without waiting for the hardware stack to catch up.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

This is upward pressure on the Reality dial.

Because silent-speech interfaces don’t just make input faster - they make the interface less visible. You don’t need to type. You don’t even need to speak. The interaction layer moves closer to intent, and the AI sits between your internal articulation and the external world as the default mediator.

It’s also not a brand-new category. This acquisition builds on a line of research going back at least to MIT’s 2018 AlterEgo project - a wearable “silent speech interface” that captures neuromuscular signals associated with internal speech and turns them into a discreet, two-way interface (with private audio feedback - see image). The implementation details differ (q.ai’s optical approach vs AlterEgo’s EMG-style capture), but the direction is the same: communication becomes sub-vocal, ambient, and increasingly mediated by an assistant.

If this sticks, it thickens the interface in a particularly consequential way - the “default UI” isn’t a screen or voice command - it’s an always-available layer that can translate micro-intent into actions and messages, even when silence is required.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

Because the real shift isn’t “better answers”. It’s the move from systems that tell you things to systems that do things. An interface layer that sits between you and the world (browsing, deciding, acting) and (increasingly) doing it without asking for permission every step of the way.

The slope shows up first as convenience. Then it becomes default. And by the time it’s obvious, you’re no longer using tools.

You’re delegating to them.

Each TrustIndex / Report is my attempt to track that slope - not the hype cycle, not the launch theatre. Each one is an instrument panel plus a signal map - what moved, why it matters, and where the incentives are pushing next. Autonomy. Reality (mediation). Fidelity. Transparency. Portability. Equality.

The theme for this report is Autonomous Assistants.

Not “agents” as a vibe. Not chatbots with a longer leash. But assistants that can take an intent and turn it into action across real surfaces - the web, your desktop, your inbox, your calendar, your files, your money, your life!

And that’s where the trust problem becomes concrete.

Trust stops being a feeling and becomes a set of affordances:

• Can you see what it did?

• Can you interrupt it?

• Can you roll it back?

• Can you revoke access cleanly?

• Can you prove who (or what) acted?

If those control surfaces exist, delegation scales. If they don’t, autonomy doesn’t “arrive” - it just leaks risk into everything around it.

This report covers:

• why Autonomous Assistants are the next thickening of the interface layer (and why that matters more than any single model jump)

• the signals that moved this month (and what they imply beyond the demos)

• the TrustIndex dials - what’s climbing, what’s lagging, and where pressure is building

• the second-order impacts - utility, culture, economics, attention, and the trust layer that has to carry it all

If you’ve been feeling that subtle tilt as the slope shifts under your feet, my hope is this will help you make it legible - in a pragmatic and useful way.

Download the PDF version of the report here:

20260201 TrustIndex / Report - Autonomous Assistants

5.52MB ∙ PDF file

Download

The February 2026 TrustIndex / Report. The theme for this report is "Autonomous Assistants".

Download

Or read the HTML version here:

https://medium.com/@robman/feb-2026-autonomous-assistants-cfede38837db

And if you want to keep tracking the slope with me - you can always find the current dashboard at TrustIndex.today and subscribe for regular updates as new Signals arrive, weekly Briefings land, and new Reports are released.

The latest update to Project Genie pushes further toward “infinite” interactive world creation: generate a world from text/visual prompts, step inside as it renders in real time, then remix and iterate. In parallel, World Labs has now shipped the World API - a public interface for generating explorable 3D environments from text, images, panoramas, multi-view inputs, and video, with explicit pathways to export and integrate those worlds downstream. And now the Open Source LingBot-World described as “an open frontier for world models” too.

That’s upward pressure on the Fidelity dial: not just prettier frames, but worlds that are more coherent, navigable, and reusable - the kind of consistency that makes “synthetic space” feel less like a clip and more like a place.

And it’s beginning to bite. After the Project Genie news cycle, Unity (along with other gaming/platform names) saw a sharp sell-off - a sign investors are already pricing in disruption risk to traditional 3D/game-engine value chains.

This is an extension of the thread from my last TrustIndex / Report: we’re moving from “generated media” to “generated environments” - and once world generation becomes cheap, interactive, and widely accessible, the centre of gravity shifts from building worlds by hand to curating, steering, and differentiating them.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

Their summary of new research (using OpenRouter usage data) is blunt - closed models account for ~80% of token usage (and nearly 96% of the revenue) despite open models averaging ~90% of closed-model performance and costing dramatically less to run.

That’s downward pressure on the Transparency dial. When the market’s revealed preference is “ship me the black box”, we normalise AI interfaces where provenance is unclear, decision paths are hidden, and inspection is not possible. MIT Sloan also points to why this happens - switching costs, reliability/security perceptions, and the ecosystem gravity that forms around the big closed providers.

Not a moral judgment - just a signal provided by human behaviour.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

This is another Fidelity dial signal. DeepMind frames the failure mode clearly - if a model misses a fine detail (a serial number, a distant sign), it’s forced to guess. Agentic Vision changes that by combining “visual reasoning + code execution” so the model can actively crop/rotate/annotate/analyze via Python, then re-inspect the transformed image before answering (“Think / Act / Observe”). They also claim code execution yields a consistent 5–10% quality boost across most vision benchmarks.

Why this could go mainstream fast - Google is already pushing Gemini deeper into Chrome - including a persistent sidebar that can now answer questions using the context of your open tabs and group related tabs, plus “auto browse” task automation. This builds on their “personal intelligence” rollout in Chrome (connecting to Gmail/Search/YouTube/Photos) so Gemini can draft/send emails and act across your data without switching apps.

Today it’s “images”. But the direction is obvious - agents that can reason “in depth” about what they (and you) see are a step toward mediated interfaces that hold up under interaction, not just in curated demos.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

This is upward pressure on the Reality dial.

Because once an “agentic” assistant isn’t just answering questions but actively guiding people through government processes with individually-tailored support (and “routing people to the right services”), the AI layer becomes part of how citizens “experience” the state. The partnership explicitly frames this as going beyond Q&A, maintaining context across interactions so users “don’t have to start from scratch”.

The intentions are good (better access, less friction, more personalised help) and the rollout approach is cautious (“Scan, Pilot, Scale,” user control over what’s remembered, opt-out, UK data protection alignment). But the structural shift remains - AI becomes a mediation layer between you and government services, shaping what you see, which pathways you’re nudged toward, and how “the system” feels.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

Archetype AI’s TimeFusion is a strong Reality dial signal. TimeFusion (Newton) is framed as a sensor–language fusion model that unifies human language + time-series sensor data using “Universal Tokens,” so you can have natural conversations with sensors and machines for insight, prediction, and control. That’s the interface thickening - more of the world around you becomes legible through language, which also makes it easier to route into LLM workflows.

The most “interface-y” detail - TimeFusion isn’t just sensor → text. Archetype says it can also do text → sensor, generating realistic time-series data from natural language prompts (and even combining examples + text prompts to fill gaps or create “what-if” simulations). In other words - language becomes a control surface for sensing, simulation, and actuation.

Not mainstream yet - but it’s a clear direction-of-travel signal. Here your Cocoon doesn’t just wrap screens and apps. It starts wrapping sensors, streams, and physical systems, with language as the universal interface.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.

Portability is sometimes presented as the antidote. But the way we talk about Portability often makes lock-in feel inevitable.

This Briefing reframes what Portability can mean, and why rising Autonomy quietly amplifies it.

The ‘obvious’ Portability frame

Portability is often framed as a “right of exit”. I did that myself in the initial “vision” post that launched the TrustIndex.

This framing is naturally borrowed from places where it feels clean and morally obvious - you keep your phone number when you change telcos (Mobile Number Portability), or you can switch banks (if you’re lucky) without your whole financial life getting trapped in one institution. The intuition is simple - providers shouldn’t be able to hold your data and identity hostage.

It’s a compelling frame, and it maps neatly onto how people tend to think about AI platforms. If one company becomes “the interface” to your life, surely you should be free to take your AI-Mediated Cocoon and move it elsewhere.

The trouble is that this framing quietly suggests lock-in is the natural end state, and that Portability is a kind of bureaucratic afterthought. It also ignores the real complexity around AI memory and platform features that function like an AI equivalent of the ‘social graph’ lock-in relied upon by social media platforms.

If Portability means moving your Cocoon, then the thing you’re trying to move is not a dataset. It’s a living relationship - projects, habits, context, and a growing stack of small decisions that sit underneath your daily work. The more useful a system becomes, the more it encourages you to store those decisions inside it, because it makes the next interaction smoother. Over time, the system isn’t just responding to you. It is shaping how you ask, what you notice, what you tolerate, and what you expect.

Under that framing, Portability starts to look like an export button that can never be good enough. Even if you can download a transcript, you can’t export the interaction quality that came from a specific model’s behaviour. Even if you can export preferences, you can’t export the subtle calibration you built up through months of seeing how it fails. Even if you can export artefacts, you can’t export the way the system has started to become the default surface you use to expand your thinking.

So the old Portability frame tends to land in a predictable place - Portability is hard, lock-in is inevitable, and the best system becomes the least portable simply because it becomes the most used.

That conclusion has been haunting the discussion. But there is another option - what if Portability is already improving, but just not as migration?

The subtle shift people are already making

If you watch what the most capable users actually do, you’ll see a pattern that doesn’t fit the “export and switch” story.

They distribute their thinking.

They’ll ask the same question in more than one place, not because they are indecisive, but because they’ve learnt that model responses vary in quality and depth in ways that matter. A plan that feels sharp in one system can feel vague in another. A confident answer in one can trigger a caveat in another. One model will notice an edge case. Another will miss it entirely.

That variance is the very thing they are using. It’s also one of the most important tools for expanding your thinking, because it reveals where the problem is under-specified, where the model is bluffing, and where your own assumptions are doing the work.

In traditional machine learning, this is the classic logic behind ensembles - when individual outputs are noisy, diversity stabilises the result. You are less exposed to any one model’s blind spots. You get a more robust outcome, not because any single response is perfect, but because the differences between responses reveal structure.

In social contexts, people point to the “wisdom of the crowd”, and in its more formalised form it shows up in prediction markets.

In practice, people already do this as a kind of informal quality control with AI. They treat multiple models the way you might treat multiple colleagues - one is good at synthesis, another is good at critique, another is good at generating options. Then they contrast and compare to see what survives contact with each system.

The important point is that this behaviour produces a form of Portability without any formal Portability feature. The user isn’t moving a Cocoon in totality. They’re refusing to let a single platform become the only place their Cocoon can exist.

Once you notice this, the Portability dial starts to look less like a legal right and more like a cognitive capability - one you can control yourself, right now.

Portability as Distributed Cognition

Portability, under this frame, is the ability to distribute and then reconstitute your thinking across platforms.

That sounds abstract until you define the unit that actually moves.

The unit is not “the chat”, and it’s not even “the memory”. The unit is a workflow of thought - you pose a problem, you generate options, you compare and stress-test, you synthesise constraints, you decide, and then you act. The output might be a document, a code change, a plan, an email, a purchase, a meeting agenda, or a decision you want to live with. What makes it yours is not where it was generated, but how you orchestrated its formation.

When Portability is framed this way, you stop waiting for a perfect export mechanism to appear. Instead, you start paying attention to whether your cognitive workflow can move smoothly between surfaces.

The lock-in story changes too. Lock-in is no longer just a matter of data captivity. It becomes a matter of process captivity. If your best outcomes depend on a single platform’s particular personality, interface and memory, then Portability is genuinely low even if you can technically export your data. If, on the other hand, your workflow is designed to run across multiple systems, then Portability can be high even if exports are mediocre, because you are not relying on any one system to hold the whole thread. And if one platform begins to tighten the screws, you can respond by reducing your dependence on it.

This reframing doesn’t magically dissolve lock-in. It relocates the battleground. The question then becomes - how easily can you keep continuity while your tools change?

Autonomy amplifies Portability

At low Autonomy, distributed Portability is mostly a human practice. You run the workflow yourself - you copy, paste, compare, and curate.

As Autonomy rises, that manual work starts to become delegable.

The shift is subtle at first. Asking multiple models becomes delegating to multiple agents. Comparison becomes a task. Synthesis becomes a task. Cross-checking becomes a task. The ensemble becomes active rather than purely interpretive.

This is where Minsky’s “Society of Mind” shape becomes visible - not as an internal architecture inside a single model, but as an external behaviour across platforms. You naturally end up with roles - an agent that proposes, an agent that critiques, an agent that checks constraints, an agent that looks for missing information, and an agent that turns a plan into actions. You don’t have to label or formalise it that way for the pattern to emerge.

That’s the coupling - rising Autonomy makes it easier to distribute the workflow, so more people do it, so Portability rises in this distributed sense.

And it matters because it pushes Portability away from being a provider-controlled feature and towards being a user-controlled capability.

Cross-model/platform arbitration becomes the bottleneck

Once you have an ensemble, a new scarcity appears. The scarce resource stops being generation. It becomes resolution.

If you involve multiple models and agents across platforms, you need a way to settle disagreements across those platforms. You need to decide which claims to trust, which suggestions to discard, which uncertainties to investigate, and when to act. You need to decide whether a disagreement is a sign of risk, a sign of ambiguity, or simply a difference in style. This is cross-model/platform arbitration.

I want to keep that boundary clear, because there is a separate story about arbitration inside a single model or a single agent system. Here, the pressure comes specifically from coordination across platforms - multiple external models, multiple training histories, multiple incentive gradients, and often multiple interfaces.

Arbitration as mechanism

When cross-platform arbitration is strong, ensembles become stabilising. Variance becomes signal. Disagreement becomes a map of uncertainty. You get better outcomes because you have built a system that can surface weak assumptions, reveal missing constraints, and reduce the probability of marching confidently into the wrong answer.

In practice, strong arbitration usually means you are explicit (sometimes only lightly explicit) about what “good” looks like for the task. Are you optimising for correctness, speed, regret minimisation, value alignment, or preserving optionality? Different tasks legitimately demand different selection signals.

Arbitration as failure mode

Most people already have an arbitration rule, even if they’ve never clearly defined it. Often it shows up as a bundle of quick heuristics - we gravitate towards the response that best fits the current task, or the one delivered with the most certainty, or the one coming from the platform we’ve mentally anointed as “the strong one”. On tired days it can be even simpler than that - whatever arrives first and feels actionable becomes the decision.

Those implicit rules explain why distributed setups can produce wildly different outcomes for different users. The ensemble isn’t doing the work on its own. The arbitration rule is doing the work. When the arbitration rule is weak, ensembles inflate confidence without increasing correctness.

This matters because models adapt to us. They mirror our style, our expectations, our inferred literacy, and the level of complexity we seem to want.

If the system is reflecting you, then “porting the interaction” is not just porting content. It is porting the loop between your prompts, your arbitration habits, and the model’s learned response posture.

As Autonomy rises, arbitration becomes more consequential. When agents are tied to actions, resolution is no longer a philosophical preference. It becomes a practical safety mechanism. It is the difference between “we considered multiple views” and “we acted on the most persuasive narrative”.

So the central mechanism in the Portability reframing is straightforward - Portability rises when you can hold a coherent thread across platforms, and that depends on how you arbitrate.

Second-order effects that actually matter

Once Portability is distributed in this way, the second-order effects stop being edge cases.

For one thing, lock-in reduces, but not because an export button got better. It reduces because the skill that matters (designing and running the workflow) sits outside any single platform. That shifts incentives. Compatibility becomes strategic. Interoperability stops being a courtesy and starts being a growth lever.

There is also a robustness gain that is hard to overstate. When model behaviour varies, an ensemble can turn variation into signal. A single model’s blind spot becomes less catastrophic. A single model’s confident mistake becomes easier to spot. A single model’s stylistic bias becomes easier to counterbalance. In the best cases, these differences become signals in their own right.

This has knock-on effects for the Reality dial as well. If one platform is trying to become the default mediation layer through which you see the world, distributed Portability disperses that mediation. You are less likely to have your preferences shaped by a single surface when your workflow naturally moves across surfaces.

But the shadow side is real. Ensembles can become confidence engines.

If a user can always find a model to endorse a plan, distribution becomes a kind of rationalisation machine. You don’t need a social-media-style bubble if you can shop for a satisfying justification across models.

Action-tied selection pressure helps here. When agents act, the world responds. Bad plans create costs. Good plans create value. In principle, that is a stronger feedback loop than pure discourse.

In practice, selection signals are messy. Outcomes are delayed, causality is diffuse, and externalities are often borne by people who didn’t opt in. This creates room for a more sophisticated failure mode - accountability becomes smeared. The ensemble can provide plausible narratives while the environment absorbs the costs.

At the same time, the economics shift. Distributed cognition is expensive by default. Tokens compound. Latency compounds. The friction you removed from “thinking” can reappear as a cost wall. And then there is a risk the memory starts to break.

Distributed workflows fragment context. Each platform may hold a partial history. Each agent may remember a different slice. You can become more robust in reasoning while becoming more fragile in continuity. That is where the Portability reframing becomes operational rather than conceptual.

TrustIndex pressure: Equality and Transparency come under pressure as evaluation and audit become the new separators, and Autonomy turns mistakes into externalities.

Convenience vs Sovereignty

This is the tension that sits underneath everything above.

For most people, the appeal of a thick Cocoon is not ideological. It’s ergonomic. A single, continuous interface makes our life easier and reduces cognitive load. It makes work feel smoother. It removes the need to compare, arbitrate, and maintain continuity across surfaces.

Distributed Portability asks you to reintroduce some friction. That friction can be small - running the same question twice, forcing a critique pass, checking disagreement before acting. But it is still friction, and it is still effort. For some users it will feel like prudence. For others it will feel like a tax.

The TrustIndex frame here is measurement - there isn’t one “correct” choice. The point is to recognise the trade and make it visible.

Convenience buys you speed and cognitive relief. Sovereignty buys you optionality and a lower chance of waking up inside a single provider’s mediation layer.

The second-order impact is that this trade can become a separator. If sovereignty requires extra friction, then not everyone will choose it, and not everyone will be able to choose it equally.

TrustIndex pressure: this naturally puts downward pressure on the Equality dial as different people choose different levels of effort vs. comfort.

Memory reforms outside the platforms

Fragmented memory is not a minor inconvenience. It is the point where distributed Portability forces a new architecture.

If you distribute your cognition, you need a way to preserve continuity across systems. At first, people patch this manually. They summarise. They carry context. They do the translation work between platforms. That’s happening now. But as Autonomy rises, the obvious adaptation is to externalise memory.

Not memory as “a transcript”, but memory as a personal substrate - a semantic store, an evidence trail, a log of decisions and constraints, a record of preferences that can be queried by whichever agent is currently working. This is where people begin to take back real control, because platforms become participants in a workflow rather than owners of the workflow.

Externalising memory also creates a new control surface. It forces explicit choices about what gets written, what gets forgotten, what is shareable, and what remains private. Those choices are not abstract governance talk. They are the practical boundary between a helpful swarm and a swarm that slowly leaks your life.

Memory sovereignty becomes a thing you build, not a thing you request.

TrustIndex pressure: external memory can relieve Portability pressure by providing continuity across platforms, while increasing Transparency and Equality pressure around provenance, access control, and who can write to (or query) the substrate.

How the reframed Portability dial behaves

With this updated framing, the Portability dial stops being mostly about export. It becomes - how easily can your cognition be distributed and then reconstituted.

A system can score poorly on the old Portability story (limited exports, fragile formats), while users are still able to forge independence by distributing their workflows. Another system can score better on exports while still leaving users constrained because their process and memory attempt to keep them inside.

Autonomy tends to push this dial upwards. Delegation makes ensembles easier, orchestration becomes normal, and cross-checking becomes cheap enough to do routinely and automatically.

But Autonomy also raises the governance requirements. When agents act, you need legible provenance. You need to know what was considered, what evidence was used, and how a decision was reached across platforms. This is where Transparency begins to matter in a more structural way - without traceable arbitration, distributed cognition becomes a machine for plausible stories.

Equality shows up sharply here too. Equality is not only access to tools. It is access to outcomes. If distributed Portability depends on cross-platform arbitration and evaluation, then the separator becomes literacy - who can design strong loops, choose strong selection signals, and maintain coherence across platforms. Two people can have the same models and live in entirely different cognitive worlds.

Intermediaries and new lock-in points

Once Portability is framed as cross-platform distributed cognition, it becomes obvious why the orchestration layer is contested.

The major platforms are not well positioned to own cross-platform orchestration, because the strength is precisely in running across platforms. A platform can orchestrate inside its boundary, but the moment the ensemble is distributed, the centre of gravity moves elsewhere.

That creates room for new intermediaries - conductors that broker multiple models, manage the workflow, hold memory, and provide arbitration tooling.

It also creates room for something more user-owned. For some users, orchestration may arrive as generated artefacts - workflows, scripts, agent graphs, disposable pieces of coordination created on demand and then thrown away, running locally or in environments the user controls.

These paths have different TrustIndex profiles.

A SaaS conductor lowers the barrier and reduces immediate friction, which makes distributed Portability accessible to more people. It can look like an Equality win in the short run. But it also concentrates metadata, arbitration logic and continuity in a new place. If the conductor becomes the thing you can’t leave, lock-in has simply moved up a layer.

User-owned orchestration preserves sovereignty and keeps the exit options real, but it carries a higher friction cost. That friction can show up as maintenance, security burden, and a need to understand the workflow at a deeper level.

Distributed Portability doesn’t eliminate lock-in - it moves it upward. The gravitational points become the orchestrator, the memory substrate, and the cross-platform arbitration layer. The question is not whether lock-in exists, but where it concentrates and how easily users can step out of it.

TrustIndex pressure: Portability can rise at the model layer while falling at the orchestration layer if conductors become the new choke point. Transparency becomes a competitive axis (arbiter legibility), and Equality shifts towards who can choose and switch orchestration.

Lifecycle trust for swarms

When you take back the orchestration layer, you also inherit the cleanup duty. This is where the story becomes unavoidable. A world of swarms is a world of lifecycle governance.

If you can spawn agents across platforms, you need to know where they run, what permissions they hold, how those permissions are revoked, and what happens when an agent is disposed of. You need to know what “forgetting” means when memory is externalised, and what auditability means when decisions crossed multiple systems.

These are not boutique security questions. They are the trust substrate for distributed Autonomy.

If you can spawn, act, remember and forget safely, distributed Portability becomes a source of resilience.

If you can’t, it becomes a source of silent risk.

TrustIndex pressure: high Autonomy without lifecycle controls is effectively low Transparency with a high blast radius, while Portability depends on safe swarm instantiation and disposal.

What this reframing changes

Reframing Portability as distributed cognition changes where you look.

It shifts attention away from the fantasy of a perfect export and towards the mechanics that actually determine whether you can move - ensembles, cross-platform arbitration, and memory sovereignty.

It also clarifies why Autonomy amplifies Portability in this sense. Delegation makes distribution easy enough to become normal, and once distribution is normal, dependence becomes harder to concentrate. The economics change.

Portability, here, is not a feature. It is a capability - the ability to keep your continuity intact while your tools change, and to hold a coherent thread while your work moves across platforms.

As that capability spreads, the Portability dial rises for reasons that don’t look like traditional Portability at all - and that is exactly why it has been easy to miss.

Seen through the TrustIndex, Portability is no longer an export problem - it’s an orchestration problem, and Autonomy amplifies it fast. If the pressures are shifting this way, how much convenience are you willing to trade for sovereignty?

Join in as we track this slope and stay up-to-date. You can always find the current dashboard at TrustIndex.today and subscribe for regular updates as new Signals arrive, weekly Briefings are published and new Reports are released.

This is not just recognising what’s in a frame, but tracking how everything moves and relates as scenes evolve.

DeepMind frames the core challenge plainly - to understand a dynamic scene from video, an AI system must track every pixel of every object through 3D space AND time, while disentangling object motion from camera motion (occlusions, objects leaving the frame, etc.). D4RT’s approach is a unified, query-based model that repeatedly answers a fundamental question:

“Where is this pixel in 3D at an arbitrary time, from a chosen camera view?”

Why this matters for Fidelity - D4RT isn’t pitched as a niche benchmark win. It’s pitched as fast, accurate 4D understanding that can support real-time robotics + AR-class “what’s happening around me?” perception. DeepMind claims 18× to 300× speedups vs prior SOTA, including processing a one-minute video in ~5 seconds on a single TPU, while still outperforming prior methods across 4D reconstruction tasks. And the project highlights “all pixels tracking” to produce holistic 3D tracks for the entire video in world coordinates. This is a robust system that’s fast enough for real-time.

Not mainstream yet - but it’s a clear signal that the “interface layer” is getting better at coherent, real-time world modelling, which is the substrate for higher-fidelity mediated reality.

> The interface layer is thickening. If you disagree with my interpretation, or you’ve spotted a better signal then reply and tell me.