# Echo-3, taken apart from the outside: a room scan as 7.3 million flat discs

> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.thesatyajit.com/articles/echo-3-world-model
> date: 2026-10-27
> tags: 3d, gaussian-splatting, world-models, reconstruction

A post made the rounds this week: a four-minute scan of a hotel room, rebuilt
by SpAItial's new Echo-3 into something you can walk through in a browser. The
claim is a good one. A phone, a slow lap of a room, and a few minutes later a
photorealistic splat scene at real-world scale.

I cannot tell you how Echo-3 works. Nobody outside SpAItial can. There is no
technical report on the company's site, no GitHub organisation I could find, and
a search of the Hugging Face API for the name returned an empty list. What I
can do is read everything the launch exposes: the product page, the launch
posts, the terms, and the files behind one public sample world. Each claim
below is labelled **reported** (someone said it), **measured** (I read it out of
a file) or **reasoned** (I inferred it and say how).

## What is claimed

The launch is dated 27 October 2026. Three outlets and the company's own
pages agree on the outline (reported):

- Echo-3 takes "a few minutes of phone capture" and returns a Gaussian-splat
  scene "scaled to real-world dimensions". The three steps on the product page
  are capture (walk slowly, on-screen guides show coverage), generate, then
  explore, measure and share by link.
- The announcement says phone captures are incomplete, so Echo-3 builds the
  scene from what was captured and then fills the missing regions to match
  their surroundings. The stated goal is to "preserve what you captured and
  complete what you missed".
- It follows two earlier models. Echo (December) made a scene from an image or
  text. Echo-2 (April) added decomposition and per-object editing. Echo-3 is
  the first that starts from a walkthrough of a real place.
- SpAItial compared one scene against Polycam, KIRI Engine and Niantic
  Scaniverse and says its surfaces are sharp with no visible floaters. It
  published no benchmark figures, no error in centimetres, and no processing
  time.

That last sentence is the one to hold on to. "Faithful" and "state of the art"
are the company's words. I found nothing that would let a reader check either.

## What you can get

**Reported.** An iPhone app is out now, Android is "coming soon". Scans are
saved on the phone and uploaded for cloud processing. On a LiDAR iPhone the app
shows live coverage guidance and a dense point-cloud preview; other iPhones
capture without them. An enterprise API is promised for real-estate
visualisation, simulation inputs and agents that understand or edit scenes. A
Claude plugin and a hosted MCP server for the earlier Echo models shipped in
June.

Weights: not released, as far as I can find. The model is reachable through the
app, the web viewer and, for enterprises, the API. That is why the article's
`runsOn` says API.

Pricing is a credit meter. Processing costs 300 credits per recorded scan
minute with a 900-credit minimum. Standard gives 7,500 credits a month, about
25 scan minutes, for non-commercial use. Pro gives 15,000 credits, about 50
minutes, with commercial rights. Eligible new subscribers get the first month
free. The slider below is that arithmetic and nothing else, so a four-minute
scan is 1,200 credits: 16% of a Standard month.

<CreditMeter />

The table under the bars uses the file size I measured later in this piece.
Only the first row is a download; the other two are the same bytes per splat
applied to their counts, an estimate (reasoned).

## The terms

I read the terms of service rather than summarising a summary. Four clauses
matter to anyone scanning somewhere that is not theirs (reported, clause
numbers as the document gives them):

- 6.1: the user owns the intellectual property in Generated Content.
- 5.1 and 6.9: SpAItial gets a "worldwide, irrevocable, perpetual,
  royalty-free, sublicensable" licence over the user's input and the generated
  content.
- 7.1: SpAItial may use that data for "training, fine-tuning, evaluating, and
  improving the Underlying Model". Clause 6.9 says commercial rights do not
  change this.
- 6.3, 6.4: Free and Standard are personal and non-commercial; Pro allows
  commercial use of Echo-2 or Echo-3 outputs worldwide. 6.7 forbids using the
  output to train a competing model without written consent.

Read together: you own the room, and the company may train on your scan of it
forever. A capture of a client's factory floor is not yours alone to give. The
terms say nothing I could find about world visibility, so I cannot tell you
whether a link is private by default.

## The sample world

The tweet links a world in SpAItial's web viewer. The viewer page is plain HTML
that points at its assets, and the asset links are public. That gives me a real
Echo-3 output to measure. Two caveats up front. I cannot show that this world is
the four-minute hotel scan; its title is "Modern room with wood floors and white
walls", and the output path of the file contains `video2splat`. And it is one
scene, so nothing below is a statistic about Echo-3. It is a reading of one
output.

What the viewer loads (measured):

| File | What it is | Size |
|---|---|---|
| `splat.spz` | the scene, Niantic SPZ | 119,247,965 bytes |
| `lod-meta.json` | a three-level streaming hierarchy | 10,777 bytes |
| `splat.voxel.json` | an occupancy grid for the same scene | 623 bytes |

Both JSON files name their generator: PlayCanvas's `splat-transform` v2.6.0. So
the web viewer is built on the standard open splat tooling, with SpAItial's
model upstream of it (reasoned; the generator string tells me the converter,
not the model).

### Header and layout

SPZ is a gzip stream. I decompressed it and parsed the header (measured):
magic `NGSP`, version 3, **7,276,512** points, spherical-harmonics degree 0, 12
fractional bits for positions, flag 1 (antialiased). Degree 0 means colour is
one RGB triple per splat: no view-dependent shading, so a reflection will not
slide across a wall as you move. Raw layout is 9 bytes of position, 1 of
opacity, 3 of colour, 3 of scale and 4 of rotation: 20 bytes. The gzipped file
is 119,247,965 bytes, which is **16.39 bytes per splat**, 82% of raw.

For comparison, the [SOG teardown](/articles/sog-splat-format) measured 13.64
bytes per splat for a trained scene in PlayCanvas's own format, from 248 for
the raw PLY. SPZ at 16.4 sits between those; this is what the "download SPZ"
button hands you.

`lod-meta.json` lists 10,696,472 splats in three levels: 7,276,512, 2,546,779
and 873,181. The first equals the SPZ's count exactly, so the SPZ export is the
finest level and the viewer streams coarser ones over 18 chunk files (measured,
the match; the reading that level 0 is the SPZ is reasoned).

### How big is the room

Positions are 24-bit fixed point, so decoding is exact to 1/4096 m. The SPZ
documentation for this service says positions are exported in the RDF
(OpenCV/COLMAP) frame: x right, y **down**, z forward. I took that as given and
checked it against the data. The two tallest bands in the height histogram are
at y = +1.35 and y around −1.15, and the first carries 875,553 splats in a
single 5 cm bin. If y points down, +1.35 is the floor and −1.15 the ceiling,
which makes the room 2.5 m high (measured, with the axis convention taken from
the docs). That is a normal room height, which is mild evidence for the scale
claim. It is one dimension of one room and no substitute for a tape measure.

The occupancy grid agrees about the footprint. Its `gridBounds` span 11.0 by
4.0 by 8.8 m at 5 cm voxels, in a different axis order and padded; the splats
span 10.75 by 3.0 by 8.54 m (measured). Counting 0.25 m floor cells that hold
at least 200 splats gives 893 cells, or 55.8 m². Move the threshold and watch
the number; the heat map is every splat, binned.

<RoomScan />

The grid file also tells you something about use. A leaf size of 4 voxels and a
tree depth of 6 gives 14,440 nodes, 11,421 of them mixed leaves (measured).
Occupancy at that resolution is what a walking camera needs to stay out of
walls. That is my reading of its purpose (reasoned); the file does not say.

### The splats are discs

This is the finding I did not expect. In SPZ, scale is stored per axis as
`byte/16 − 10` in the log domain. I decoded all of them and sorted each splat's
three axes (measured):

- Median longest axis: 3.84 mm. Median middle axis: 2.19 mm.
- 5th to 95th percentile of the longest axis: 1.1 mm to 17.21 mm. The 99th is
  32.14 mm.
- The shortest axis is byte 0 on 7,218,723 splats, **99.2%**, which decodes to
  e<sup>−10</sup> m, 0.045 mm. The next byte values hold about 1,300 splats each.

Three-dimensional Gaussian splatting usually trains full ellipsoids. A
distribution with 99.2% of the mass pinned at the format's minimum is not
that. The splats are flat discs (surfels), the representation of 2D Gaussian
splatting, where each primitive is a small oriented patch lying on a surface
(reasoned from the scale arrays; SpAItial has not said which representation
Echo-3 emits, and a clamp to the minimum would look identical).

Why it matters: a flat disc has a normal, and the launch material lists
"normals" and "depth" among exports. Discs give clean geometry for a mesh or
a depth map in a way blobs do not. It would also explain the "no floaters"
claim, since a disc not lying on a surface has nothing to hold it up. Both are
speculation about why; the measurement is the 99.2%.

<SurfelSizes />

Opacity follows suit. The lowest stored value is byte 11, about 0.04, so
nothing fainter survived. A quarter of the splats, 24.5%, are at 250 or above
out of 255, and the median is 0.616. Colour is a single triple. At a median
3.84 by 2.19 mm a disc covers roughly 7 mm², so one square metre of surface
takes on the order of a hundred thousand of them before overlap (reasoned,
back of the envelope). That is where 7.3 million splats goes.

## Where it sits among the splat articles here

It is a different kind of subject from the others on this site, which is why
the comparison is short.

- [Gaussian-splat capture in practice](/articles/3dgs-capture-pipelines) walks
  through the manual route: a 360 camera, structure from motion, training,
  trimming, a map. Echo-3 replaces that chain with an app and a credit meter,
  and keeps the output format the same. The cost is that every stage between
  frames and splats is now opaque.
- [InfiniSplat v2](/articles/infinisplat-2) is the open feed-forward version of
  the idea: frames in, Gaussians out, in one pass, with the method readable. Echo-3 is plausibly the same class of system with a generative
  completion stage (reasoned from the "fills missing regions" claim); I can
  confirm none of it.
- [WorldCrafter](/articles/worldcrafter) is the world-model reading of "3D":
  generate video that stays consistent when you return to a place. Echo-3
  starts from a real place and ends in an explicit asset, which does not
  drift, because it is a file.
- [Atlas Camera Studio](/articles/marble-camera-studio) is a reminder that
  "world model" labels very different pipelines.

## Read it yourself

The whole measurement is a page of Python and works on any SPZ you export. The
format is a gzip stream, a 16-byte header, then planar arrays in a fixed order.

```python
import gzip, struct, numpy as np
f = gzip.open("splat.spz", "rb")
magic, ver, n, sh, frac, flags, _ = struct.unpack("<IIIBBBB", f.read(16))
pos = np.frombuffer(f.read(n * 9), np.uint8).reshape(n, 3, 3).astype(np.int32)
v = pos[:, :, 0] | (pos[:, :, 1] << 8) | (pos[:, :, 2] << 16)
v = np.where(v & 0x800000, v - (1 << 24), v) / (1 << frac)   # metres
alpha = np.frombuffer(f.read(n), np.uint8)
f.read(n * 3)                                                # colour
scale = np.frombuffer(f.read(n * 3), np.uint8).reshape(n, 3)
print((scale.min(1) == 0).mean())                            # the 99.2%
```

It decompresses to a few hundred megabytes of arrays for this file, so keep
the intermediate steps in 32-bit integers. If your number for the flat
fraction on a different Echo-3 scene is not near 99%, the disc reading is
wrong, and I would like to hear it.

## Why filling in is the hard part

A walkthrough never sees the back of a sofa, the top of a wardrobe or the
floor under a bed. A pure reconstruction leaves holes there, and a viewer who
steps close enough sees through the wall of the scan into the void. Echo-3's
selling point is that it does not leave them (reported). Making the fill
credible needs a prior over what rooms look like, which is a generative model's
job, and it is the reason this is called a world model rather than a
reconstruction pipeline (reasoned; the label is the company's, the
justification is mine).

The same strength is the audit problem. A measuring tool built on this output
has two kinds of surface in it, captured and invented, and the file does not
mark which is which. The app offers measurements, so the useful question for
SpAItial is whether a distance between two captured walls and a distance
across a filled gap come with the same error bar. Until that is published, treat
a measurement as accurate only between surfaces you walked past.

## What I could not check

- **Accuracy.** There is no ground truth for this room. 2.5 m is plausible, not
  verified. The launch gives no centimetre error.
- **The completion.** The headline feature is filling what the phone missed. A
  filled region and a captured region look the same in the file, and I have no
  capture to difference against. Whether the four-minute hotel video produced
  this world I cannot say.
- **Anything inside the model.** Architecture, training data and size are
  undisclosed.
- **Rendering.** I decoded the file and did not render it, so I make no claim
  about how it looks. A 119 MB download is also a real cost on a phone, which
  is presumably why the viewer streams the lower levels.
- **Other scenes.** One file, one afternoon.

Everything numeric above came from two commands' worth of Python: gunzip the
SPZ, read the 16-byte header, read the arrays in order. Nothing from SpAItial
was executed; the only files I fetched were public assets the viewer itself
requests.

## What I would do with it

If you scan places you own and want a metric splat without an SfM stack, the
app is a convenient front end, and the price list is simple enough to budget:
300 credits a minute, and keep scans short because the minimum is 900. If you
scan anyone else's space, read clause 7.1 first. If you need to know how good
it is, wait for a number: the sentence "the same scene against three
competitors" is a demo, and the question that decides it is the error in
centimetres on a room you can measure by hand.

The artefact is useful even so. A flat-disc splat with degree-0 colour and
14,440 voxel nodes of occupancy beside it is a well-chosen delivery format for
a web viewer, and everything past the capture is closed.

<RepoCard repo="playcanvas/splat-transform" />