WorksComputer Science
SceneBound: How Much Should a Streaming 3D Reconstruction Model Remember?
Abstract
Streaming 3D reconstruction models keep past video frames in a recurrent state, fast weights from test-time training, or a key-value (KV) cache. Each written frame shifts the coordinate frame of later cameras or occupies GPU memory. Training-free rules decide what to write from a signal of the current frame. How much they write accounts for their mean accuracy: spending the update budget of a gate at uniformly spaced frames, with no signal, matches nine published gates, and the budget bounds the drift of the state wherever the writes fall. We propose SceneBound, a training-free rule that writes a frame only when its predicted camera pose lies at least a fixed radius from every stored keyframe. Its keyframe count stays within a constant factor of the covering number of the visited poses, the fewest views that keep a keyframe near every camera, so the count grows with the places visited and stays flat when the camera returns. In large scenes, SceneBound closes a submap once decoding its first frame again reveals drift. SceneBound uses one radius across four released models and three memory types. In the recurrent state of CUT3R and the KV cache of StreamVGGT, it achieves the lowest mean trajectory error among the published training-free rules we evaluate, in one pass and over nine passes of a scene, where its keyframes grow by 3% to 6%.
Introduction
A home robot vacuuming an apartment or augmented reality glasses worn around an office record video for hours, spending most of that time in the same few rooms. To act in that space, the device must recover 3D scene structure and track the camera. Feed-forward networks map a set of images to camera poses, the position and orientation of each view [38, 76, 79, 86], and a 3D point per pixel in one pass [35, 45, 80]. In a video stream, frames arrive in sequence and the full video cannot fit in memory; streamingends_mid=1 3D reconstruction predicts the pose and 3D points of each frame online from the frames seen so far [15, 72, 77, 95]. To relate the current view to earlier views, a streaming model equips a feed-forward network with an online memory of past frames [8, 43, 49, 82]. These are the same memories that language models use to carry context. CUT3R [77] compresses past observations into a fixed-size recurrent state of latent tokens updated at each step, following recurrent networks and state-space models [28, 30]. ZipMap [32] stores past frames in fast weights, layer parameters updated by gradient descent at inference through test-time training [5, 46, 66]. StreamVGGT [95] and Stream3R [37] append the attention features of each frame to a growing key-value (KV) cache, the memory that transformers use to attend to past tokens [70, 83, 92].
Writing a frame into any of these memories carries a cost. Each update to a recurrent state or fast weights shifts the coordinate frame in which later cameras and points are expressed, so the trajectory drifts from the true path. In a KV cache, each stored frame occupies GPU memory, and the cache of StreamVGGT fills 80 GB within 10 seconds of video. Both costs grow with the number of frames written, and the rooms stay the same size.
Training-free rules manage the memory of a frozen network at test time by reading a signal from the current frame to decide how much to write. In recurrent states, update gates scale each update by a gain computed from attention weights or state uncertainty [14, 21, 33, 93], reliability and information content [4, 40, 42, 58], or motion and geometric cues [1, 19, 61, 71]. In KV caches, compression rules keep the highest-scoring tokens of each frame [48, 53, 54, 65], keep a fixed number of tokens or frames [12, 51, 85, 89], or index kept frames by place [78, 87, 96]. These rules share a premise: a sharper signal of the current frame makes a better memory. Like a visitor sketching the living room on a fresh page every time they pass the sofa, a camera returning to a known room produces the same signals, so these memories write the room again and grow with the video, or, at fixed capacity, forget the earlier visit (Figure 1).

Figure 1. Over nine passes in the KV cache of StreamVGGT, SceneBound holds its memory near the first-pass size at the accuracy of a fixed interval of 50 frames†, whose memory grows with every pass; † marks a constructed baseline. (a) One room with the retained cameras. (b) Sums over the revisit sequences each rule completed.
To test this premise, we remove the signal and keep the amount written, following budget-matched baselines in network pruning and language-model caches [47, 50, 75]. Our budget-matched baseline spends the update budget of a gate, the sum of its gains on a video, at uniformly spaced frames with no image signal. On our long-sequence benchmark, this blind schedule matches nine published gates with a geometric-mean error ratio of 0.99, so their signals add no mean accuracy beyond their budget. We prove that when the expected coordinate shift per write keeps a direction, the drift of every rule stays within a constant factor of its budget wherever writes fall, and measured drift grows almost in proportion to the budget. In the fast weights of ZipMap, a sparse schedule cuts the error of writing every frame by nearly an order of magnitude. The right question for a memory rule is therefore how much to write. A fixed interval answers it by counting frames, rewriting a visited room on every visit and leaving views uncovered when the camera moves fast.
We propose SceneBound, a training-free rule that lets the scene set the amount, following the keyframe principle of visual simultaneous localisation and mapping (SLAM) [9, 18, 25, 36]. Visual SLAM stores a view as a keyframe when the camera moves far enough from stored ones and culls redundant keyframes so the map grows with the scene [10, 24, 34, 55]. SceneBound writes a frame into the memory of a frozen network as a keyframe when its predicted pose lies at least a fixed radius from every stored keyframe, and decodes closer frames from the unchanged memory. Because each frame is compared with all stored keyframes, the keyframes lie near the best placement for their count, which stays within a constant factor of the covering number of the visited poses, the fewest views keeping a stored view near every camera [22, 27]; the count thus grows with the places visited and stops growing on revisits, regardless of video length. The poses come from the model’s own pose head, so the test needs no extra network pass and applies to any memory that can keep or drop a frame. In large scenes, where one state drifts as the visited region grows, SceneBound splits memory into submaps, as SLAM does [6, 20, 23, 52], and closes the active submap once its first frame, decoded again by the frozen model, moves beyond a threshold, a check needing no ground truth.
With one radius across CUT3R, ZipMap, StreamVGGT and Stream3R, SceneBound achieves the lowest mean absolute trajectory error (ATE) among the published training-free rules we evaluate in the recurrent state of CUT3R and the KV cache of StreamVGGT, in one pass and over nine passes of a scene. Over those repeated passes, its keyframes grow by 3% to 6%, published gates multiply their initial budget, and fixed-capacity caches multiply their error.
Related work
Streaming 3D reconstruction. Streaming models extend multi-view feed-forward networks [35, 38, 86] with online memories of spatial tokens, keyframes or KV caches [37, 43, 49, 82]. Models trained for long videos learn what to keep through persistent tokens, hybrid memories or fast weights [16, 39, 46, 90], and recent ones read their memory through test-time training, geometric context or long-horizon attention [13, 17, 29, 32]. SceneBound decides, without training, what enters the memory of a released model.
Training-free memory management. Training-free rules filter the updates of a recurrent state [19, 61, 71], evict or merge cache tokens [2, 31], or index memory by place in a state [91] or a cache [12, 78, 87, 96]. Adaptive gains have been reported to settle near constant values [1, 58], and gate papers compare with constant gains or fixed intervals at budgets set by hand [21, 33]. We give a signal-free schedule the budget that each gate logs on each video and let the visited places set the budget.
Keyframes and submaps. Classical SLAM bounds its map by keyframe insertion and culling [10, 24, 25] and by submaps in large scenes [6, 23], and learned systems optimise keyframes or chunks in a back end that closes loops [20, 52, 56, 68] across local and global maps [41, 74]. Feed-forward and tracking methods select keyframes by pose distance or point overlap against recent or stored views [8, 44, 67, 73]. SceneBound applies the test against all stored keyframes to the memory of a frozen network and bounds it by the covering number of the predicted poses.
Method
Preliminaries
A frozen streaming model reads frames in order and predicts the camera pose and 3D points of each frame in the coordinate frame of . In CUT3R [77], the memory is a state of tokens initialised from , beside a fixed-size pose memory updated at every frame. At frame , the decoder reads and to predict the pose, the points
and a candidate state . An update rule gives state token a gain scaling the increment towards ,
Unit gain across the state is a full update, applied at every frame in CUT3R; zero gain skips the update. An update gate computes gains from a frame signal, and a schedule, such as a constant gain or fixed interval, fixes them beforehand. With mean frame gain , a rule has update budget and sum of squared gains ; under full updates, both equal the count of updated frames. The distance between two predicted poses is their relative rotation angle in radians plus their camera-centre distance divided by the median predicted depth of , so one radius serves both a desk and a street.
The budget determines the drift
To see what a gate signal adds, we first ask how much drift the update budget causes by itself. The state increments are nearly uncorrelated, so the change that adds up lies in the coordinate frame that encodes, and we measure it through a read-out , the pose of decoded again from with no write. With the largest increment norm and the Lipschitz constant of , a write of gain moves by at most and by at most . When each write pushes on average along a common direction, the coherent parts add in proportion to , and the unpredictable parts add like a random walk.
Theorem 1 (Budget bound). Let be a read-out of the state, such as the pose decoded for a fixed frame with no write, whose change has norm at most , as it does for one gain per frame. If, given the earlier frames and the gains of frame , has an expected component of at least along a fixed unit vector , then every update rule, gates included, has
and the parts of that the earlier frames and the gains do not predict sum to a vector of mean squared norm at most .
The budget thus confines expected drift to a factor of , wherever writes fall and whatever signal sets the gains, and a larger budget raises drift without limit. Comparing a constant gain () with full updates () at equal budget separates the two terms: on 7-Scenes and Neural RGB-D, full updates at our keyframes have 22 times the of a constant gain and after 500 frames shift the pose of by 0.92 and 1.11 times as much. Across five constant gains and three full-update rules, this shift grows with exponent 1.2 in , against 0.5 for increments without a common direction, and stays within a factor of 2.4 per unit budget (Figure 2a), as in the fast weights of ZipMap.
Figure 2. The amount written orders the drift and the error in four released models. (a) After 500 frames, geometric mean over the benchmark datasets; the dashed line is proportional to the budget. (b–e) Benchmark means; lines in (b) join each gate to its budget-matched baseline. (f) CUT3R solid, StreamVGGT dashed, STream3R dash-dotted, ZipMap dotted; † marks constructed baselines.
Within this band, a signal can lower drift at a fixed budget by writing where the expected change is small or giving small gains where the random part is large. To test whether published signals do this, our budget-matched baseline takes the sums of a gate on a video of gated frames and applies one gain at uniformly spaced frames, with the integer in closest to . Its budget is , and its sum of squared gains lies within 0.3% of across all 549 gate-sequence pairs. Reading no frame, its gap to the gate measures what the signal adds at the gate’s chosen budget; we mark constructed baselines with †.
On the 61 benchmark sequences, the baseline matches nine published gates from eight papers (Figure 2b): the ratio of its mean ATE to the gate’s ranges from 0.92 for AFG-Img to 1.06 for TTSA3R, with a geometric mean of 0.99, and lies within resampling noise for seven of the nine. This ratio is 1.04 in the second released checkpoint at 224 pixels, 0.98 on held-out Replica and 0.96 under the periodic reset of TTT3R. Under that reset on full-length KITTI drives [26] and TUM RGB-D sequences, the signals add accuracy, and the baselines reach a geometric mean of 1.12 and 1.13 times the gate error.
The budget thus sets mean accuracy on the benchmark, and the increments set the form of update: at equal budget, full updates every 10 to 150 frames reach 1% to 18% lower ATE than a constant gain (Figure 2b), whose increments 8 to 16 frames apart repeat one push at a gain of 0.05, with a mean inner product of 0.46 times their mean squared norm.
Spatial keyframes
The decoder localises a frame against stored views of the same place, so a state needs one view near every camera, and by the budget bound further writes add drift. SceneBound therefore lets the visited poses set the budget (Figure 3). When the predicted pose of frame lies at least from every stored keyframe, we apply a full update, as CUT3R is trained with, and store the pose as a keyframe. Closer frames skip the update and are decoded from the unchanged state; as for the gates, the pose memory receives every frame. Because each keyframe lies at least from earlier ones, no open ball of radius holds two keyframes.
Figure 3. SceneBound writes a frame at least from every keyframe, returns to a closed submap within of its keyframes, reads every other frame with no update, and closes a submap once its anchor drifts by at least a threshold .
Theorem 2 (Keyframe count). Let be the set of predicted poses of the frames of a video, the number of keyframes that SceneBound stores at radius , frame 0 included, and the least number of open balls of radius in the distance , centred anywhere in pose space, that cover . Every pose of lies at distance below from a keyframe stored no later than it, and
where balls of radius cover a ball of radius . Every rule that keeps a stored pose at distance below from every pose of stores at least frames, and every rule that stores frames leaves a pose of at distance or more from all of them. If the frames split into sets, in each of which one rigid motion carries the true poses of the set to within of the predicted ones, then . Fed every -th frame, with every pose of within of the last pose fed, it stores between and keyframes.
The covering number measures the visited region at resolution and stays unchanged on revisits up to pose error. SceneBound thus stays online within the factor of the least budget at any length and places keyframes near the best for their count: no choice of one frame forever covers at half the radius, the guarantee of greedy -centre clustering [27]. Uniform sampling in time has no such guarantee, since a lingering camera draws most frames in one place. With predicted poses within of the truth, the bounds hold for the true poses at radii and , and a rigid break in the predicted poses adds at most the covering number of the region seen after it. Since is a metric for every fixed depth unit, a first frame times closer refines the counting radius by at most . Since a full update moves by at most , one state moves by at most at any length, and updating every frames moves it by at least in expectation.
This bound requires comparing each frame with all stored keyframes, as in keyframe-based SLAM [36]; testing the latest keyframe or a recent window writes a revisited place again once its keyframes leave that set. Predicted poses can index the memory because revisits receive the same pose: on the revisit sequences of § 4.1 in the KV cache, 99.5% of frames in later passes lie within of their first-pass pose under SceneBound, against 66.8% under InfiniteVGGT. On the benchmark in the KV cache, SceneBound stores 1,433 keyframes, with between 571 and 965.
Submaps from measured drift
On a long trajectory, the covering number grows with the visited region, and with it the drift bound of one state. Periodic resets and the chunks of VGGT-Long [20] close a state at fixed frame counts; SceneBound closes it when it measures drift. A submap is a state with its keyframes, and its anchor is the frame that opened it; SceneBound, one state is the single-submap variant. After each keyframe write, the drift check decodes the anchor again with the current state and closes the submap once this pose moves by at least from its initial pose. The next frame opens a new submap with a fresh state and pose memory, placed in the closed submap’s coordinates by decoding the frame once with the closed state, and every submap keeps the depth unit of . Closed submaps stay in memory beside the active one, and a frame at distance below from a closed submap’s keyframe returns to it, which resumes as it was left.
For the counts below, consecutive predicted poses lie less than apart, and the decoded pose of a fixed frame moves by at most times a change of the state, so a full update moves the anchor by at most .
Theorem 3 (Submap counts). Let be the number of frames, other than those that open a submap, whose pose lies at distance or more from every keyframe when the frame arrives, the number of submaps and the number of keyframes. Every frame is decoded with a submap that holds a keyframe at distance below from its pose, and
A return to a kept submap adds no submap, no keyframe and no placement. Under the drift check at threshold , every submap that the check closes holds more than keyframes, and a video on which one state stores at most keyframes, in particular every video with , keeps one state.
The covering number thus bounds the keyframes and states in memory, a revisit adds neither, and a room that one state holds without drift never splits.
Because the anchor image is fixed, its pose shift measures state drift without ground truth (see Figure 4a, Figure 4b). Inside a submap this shift rises with the true pose error, with median rank correlations of 0.74 on TUM RGB-D and 0.89 on KITTI (see Figure 4c), and partial rank correlations of 0.27 and 0.02 given the frame count since the anchor.
Figure 4. The anchor drift that the state measures tracks the true error and closes a submap at . (a, b) A robot sequence of TUM RGB-D. (c) TUM RGB-D and KITTI, with medians and quartiles per bin.
Fast weights and the KV cache
ZipMap [32] replaces global attention by test-time training: each frame updates the fast weights of every global block by a normalised gradient step and is decoded with them. After decoding a non-keyframe, we restore the fast weights to their values before it, so each frame applies a full update or a skip, as the budget bound treats. In the KV caches of StreamVGGT [95] and STream3R [37], every camera is expressed in the coordinate frame of , whose keys and values never change. A written frame leaves the coordinate frame in place and costs memory, and the number of retained frames sets the error (see Figure 2d, Figure 2e). After decoding a non-keyframe, we remove its keys and values from every aggregator layer and the camera head, so the keyframe count bounds the cache by the covering number.
Experiments
Experimental setup
Implementation. Methods in the recurrent state share one evaluator and the released 512-pixel CUT3R checkpoint. Cache methods and ZipMap run released checkpoints with official streaming settings in the RegVGGT [54] evaluator, ZipMap with a one-frame online window. AFG-Img and AFG-Pose are the image and pose gates of AFG, Info3R in full adds its resets to its gate, TTT3R with reset restarts every 100 frames, and cache memory counts the GPU memory beyond the stored input frames. Where papers report TUM-dynamics at 1,000 frames, our runs lie within 13% of their values, OVGGТ within 22%, our implementations of AFG-Pose and Info3R included. Constructed baselines (†) replace the keyframe test of SceneBound: a fixed interval writes every 50 frames, the best of seven intervals from 10 to 150 frames in the state on the test sequences, uniform sampling spreads the count of SceneBound evenly over each video, a count known only after the run, and the latest keyframe tests the radius against the most recent keyframe alone. We chose the keyframe radius from 0.15, 0.2 and 0.3 on 15 TUM sequences including the eight from TUM-dynamics; a later benchmark sweep from 0.2 to 0.5 is lowest at 0.3 and within 1% up to 0.4. We set the depth unit of on the benchmark and on seven TUM RGB-D sequences, fixing all three across models and datasets. Inference is deterministic, so each configuration runs once.
Datasets and metrics. Our long-sequence benchmark applies the TTT3R [14] pose protocol (stride 1, up to 1,000 frames) to 61 sequences (51,256 frames) from TUM-dynamics [64], Bonn [57], 7-Scenes [62] and Neural RGB-D [3]. Revisit sequences play 24 sequences forward and backward nine times, 17 from TUM-dynamics and Neural RGB-D in every memory and seven from 7-Scenes in the state. Concatenated rooms stream all sequences of six 7-Scenes rooms in turn, returning to each along a new path. At full length, we evaluate on 19 TUM RGB-D and 11 KITTI
odometry sequences [26], and once with fixed constants on four held-out sets: eight Replica scenes [63], 11 EuRoC [7], 61 ETH3D SLAM training [60] and 19 further TUM RGB-D sequences. We report ATE in metres after similarity alignment [69], fused-point accuracy, memory and frame rate.
Main results
We ask whether the count set by the visited poses is as accurate in one pass as the best tuned amount, and whether memory and accuracy hold on revisits Table 1. In one pass, SceneBound has the lowest mean ATE in both memories, 9% below Info3R in full and 18% below RetrieveVGGT, and ranks first or second in each of the eight dataset columns. On TUM-dynamics, where we chose , both its values lie below every value reported at 1,000 frames, including that of the trained LoGeR [90]. Every 50 frames reaches 0.084 in the state, and the best interval in the cache, every 25 frames, matches SceneBound with 2.7 GB more memory Figure 2b, Figure 2e; outside TUM-dynamics, SceneBound lies within 2% of every 50 frames in the state. SceneBound thus finds online the amount that a sweep of intervals tunes on the test sequences. Placement also matters: at the same count, uniform sampling and random frames raise the state’s error by 12% and 13%.
| Method | One pass of the benchmark, ATE (m) ↓ | Revisits, nine passes | |||||
| TUM-dynamics | Bonn | 7-Scenes | Neural RGB-D | Mean | ATE (m) ↓ | Cost ↓ | |
| Recurrent state of CUT3R | budget | ||||||
| CUT3R [77] | 0.161 | 0.322 | 0.655 | 1.156 | 0.522 | 0.815 | 196,518 |
| MeMix [21] | 0.102 | 0.264 | 0.393 | 0.604 | 0.331 | 0.673 | 54,398 |
| TTT3R [14] | 0.115 | 0.269 | 0.410 | 0.457 | 0.318 | 0.672 | 59,122 |
| TTSA3R [93] | 0.093 | 0.220 | 0.315 | 0.289 | 0.241 | 0.653 | 42,908 |
| RayMap3R [71] | 0.131 | 0.127 | 0.206 | 0.257 | 0.170 | 0.700 | 33,413 |
| BAT3R [40] | 0.069 | 0.155 | 0.170 | 0.262 | 0.164 | 0.608 | 22,241 |
| FILT3R [33] | 0.074 | 0.143 | 0.190 | 0.245 | 0.163 | 0.601 | 29,939 |
| AFG-Img‡[58] | 0.083 | 0.165 | 0.163 | 0.162 | 0.153 | 0.516 | 23,389 |
| ReCal3R [42] | 0.067 | 0.110 | 0.146 | 0.185 | 0.126 | 0.552 | 22,129 |
| AFG-Pose‡[58] | 0.055 | 0.107 | 0.094 | 0.098 | 0.095 | 0.134 | 5,304 |
| Info3R‡ [4], gate | 0.060 | 0.094 | 0.101 | 0.085 | 0.090 | 0.124 | 7,642 |
| Info3R‡, in full | 0.056 | 0.091 | 0.095 | 0.099 | 0.089 | 0.252 | 7,618 |
| TTT3R with reset | 0.096 | 0.115 | 0.163 | 0.167 | 0.134 | 0.573 | 68,399 |
| SceneBound (ours) | 0.048 | 0.078 | 0.095 | 0.088 | 0.080 | 0.084 | 698 |
| KV cache of StreamVGGT | GB | ||||||
| RegVGGT [54], 1% of keys | 0.058 | 0.099 | 0.116 | 0.195 | 0.113 | 0.129 | 15.2 |
| RegVGGT, 10% of keys | 0.051 | 0.091 | 0.113 | 0.188 | 0.107 | 0.138 | 52.6 |
| InfiniteVGGT [89] | 0.067 | 0.129 | 0.161 | 0.178 | 0.137 | 0.335 | 18.1 |
| OVGGT [51] | 0.071 | 0.192 | 0.167 | 0.203 | 0.170 | 0.166 | 8.9 |
| GHOST [12] | 0.072 | 0.173 | 0.248 | 0.302 | 0.201 | 0.768 | 18.6 |
| FrameVGGT [85] | 0.047 | 0.139 | 0.153 | 0.133 | 0.130 | 0.077 | 33.1 |
| XStreamVGGT [65] | 0.065 | 0.224 | 0.287 | 0.316 | 0.235 | 0.197 | 27.2 |
| RetrieveVGGT [96] | 0.050 | 0.101 | 0.126 | 0.102 | 0.102 | 0.080§ | 15.6§ |
| SceneBound (ours) | 0.033 | 0.071 | 0.104 | 0.122 | 0.083 | 0.069 | 14.8 |
Table 1. Published training-free rules and SceneBound in one pass of the long-sequence benchmark and over nine passes of the revisit sequences, with the cost after them: the update budget in the state and the GPU memory in the cache.
Over nine passes, the keyframes of SceneBound grow by 3% in the state and 6% in the cache, and every other rule pays in update budget, memory or accuracy. In the state, published rules end at 1.5 to 9.7 times its error, and the closest, the Info3R gate, spends 11 times its budget. In the cache, the fixed-capacity InfiniteVGGT and GHOST forget the room, their error more than doubling after the first pass; FrameVGGT takes over twice the memory of SceneBound, and OVGGТ holds less at 2.4 times its error.
On the concatenated rooms, where new paths bring new poses, SceneBound reaches 0.139 against 0.142 for AFG-Pose and every 50 frames. On the Bonn sequences where a person moves boxes, it reaches 0.085 against 0.094 for the Info3R gate, since each frame’s points come from its own image. The count set by the visited poses thus matches the
‡Our implementation of a method without released code. §With its pose-aware memory on, which holds 211 GB of host memory.
best tuned amount in one pass, and SceneBound alone holds both its cost and its accuracy over revisits.
Four released models and four frame rates
We test whether one radius transfers across memory types and camera speeds. In ZipMap, SceneBound writes 24 frames per sequence and cuts the error from 0.590 to 0.089 (Figure 2c); every 50 frames and uniform sampling at its count reach 0.083 and 0.084, so the count brings the gain. In STream3R, SceneBound reaches 0.075, ahead of every fixed interval and of uniform sampling at its count (Figure 2d), and in both models its writes grow by at most 1% over nine passes.
To vary camera speed along the same paths, we feed every second, fourth and eighth frame of the benchmark, scaling the motion per frame by (Figure 2f). At stride 8, SceneBound writes about 15% fewer frames in every model and changes its error by at most 6%; every 50 input frames more than doubles its error, and a fixed time interval stays within 5% of SceneBound and writes again on revisits. A first frame facing a far scene raises the error by 3%, and one facing a near wall, at half or a quarter of the depth unit, writes more frames and raises the error by 11% and 20%, as the budget bound predicts at larger budgets. A unit that rises with the median depth of later keyframes, never falling, keeps the count bound and brings these to 2% and 3%. One radius
thus serves three memory types and an eightfold range of camera speeds.
Long sequences and held-out data
We test whether the drift check bounds the drift of one state on long trajectories and held-out data. Submaps cut the error of one state by 29% on the TUM RGB-D sequences not used for and by 71% on the KITTI drives (Figure 5), where SceneBound reaches 50.7 m against 61.7 m for TTT3R with reset. On these drives, closing the state every 30 frames is lower, and Info3R with constants set for driving, AFG-Pose and the trained LoGeR report 30.5, 44.0 and 25.4 m; on TUM, Info3R in full and TTT3R with reset stay about 11% lower. Aligned to the truth one by one, the KITTI submaps have an error of 4.2 m, so most of the error lies in placing the submaps, the task of a back end with its own place recognition and geometric verification, as in VGGT-Long [20]. SceneBound runs at 22 frames per second, and its keyframe test against 10,000 stored keyframes takes 0.2 ms on one CPU core.
Figure 5. Two KITTI drives in the recurrent state, from above, with the true path dashed and the ATE under each map. Rings mark the anchors of SceneBound; its submaps alternate in shade.
On held-out ETH3D and TUM, SceneBound has the lowest error, 6% and 30% below the next published rules. On EuRoC, the drift check splits fast drone flights into up to 52 submaps and raises the error of one state from 1.78 to 2.14, behind AFG-Pose at 1.25 and both forms of Info3R; aligned one by one, the submaps are more accurate than one state over the same frames, so placing them causes the excess. On Replica, where the error of gates grows with their budget, SceneBound reaches 0.181, behind both forms of Info3R, the gate at 0.152, as the covering number at exceeds the best budget. The drift check thus cuts the drift of one state on long trajectories and held-out cameras.
Point clouds
To measure surface accuracy, we fuse the points of the first 1,000 frames of the 7-Scenes and Neural RGB-D benchmark sequences with the CUT3R evaluator. In the state, SceneBound reaches accuracy errors of 0.026 and 0.086 m, TTT3R with reset has 3.3 and 1.6 times these, and every 50 frames is lowest, about 10% below them. Fed every eighth frame, SceneBound is lowest on both, and every 50 frames has 4.2 and 1.2 times its error. In the cache, the rules that keep whole frames lead on 7-Scenes, and on Neural RGB-D RetrieveVGGT and OVGGT, which read tokens of every earlier frame, have 21% to 25% less error than SceneBound.
Ablation study
Table 2 tests whether a keyframe rule should measure poses or points and check all stored keyframes or recent ones. Beside the latest keyframe, we port three tests from their official code at the count of SceneBound without their trained components: AMB3R [73] on the rotation and centre distance to its 10 active keyframes, and the point tests of Scal3R [44] on the first and last four writes and MUSt3R [8] on all writes.
What the test measures matters on moving content. In the state, the ported tests lie 7% to 10% above SceneBound, losing mostly on TUM-dynamics: the point tests write where people walk, 22 frames of a static camera against one for poses, and 12 to 14 of one half-sphere sweep against 26, with four times the error. In the cache, all rules at this count
†Constructed baseline. *Five, nine and 15 of the 17 videos fit in GPU memory.
lie within 2%, and MUSt3R runs at 4.8 frames per second against 6.3 for SceneBound. The test scope decides the writes on revisits. On the benchmark, the latest keyframe writes 14% more frames on returns within a pass, within 2% in error. On the revisit sequences, it has 2.5 times the error of SceneBound; only MUSt3R and SceneBound check all stored views and keep their growth small. In the cache, MUSt3R ends at 0.062 against 0.069 through one video where predicted poses jump up to nine radii between frames; holding writes to steps below , as the submap counts assume, closes this gap. Checking all stored views thus keeps the writes flat on revisits, and measuring poses writes less on moving content.
Conclusion
The update budget of a training-free memory rule fixes its drift up to a constant factor wherever the writes fall and sets its mean trajectory error on the long-sequence benchmark, so a rule must first decide how much to write. SceneBound lets the visited poses decide, placing keyframes near the best for their count, so the amount it writes follows the scene and stops growing on revisits, with one radius across recurrent states, fast weights and KV caches in four released models and an eightfold range of camera speeds. Its drift check cuts the drift of one state on long trajectories, where the remaining error lies in placing submaps, a task for a back end with independent loop verification, and scenes that change call for a test that retires stored views.
LLM Usage Statement
We used Claude Code (Anthropic), Codex (OpenAI) and Gemini (Google) to assist our research and its execution: implementing and running the experiments and the figures, searching the literature, and preparing and editing the text. The research questions, the theory, the design of the method and the division of the work are the authors’ own. The authors checked every result, proof and citation and take full responsibility for the content.
Proofs
Proofs of the budget bound
Let hold the frames before , frame 0 included, their states, increments and gains, and the gains of frame , so that for . Write for the change of the read-out at frame , for its prediction from the past and for the rest, so that . The conditions of Theorem 1 read and . With one gain per frame the first follows from and a read-out that moves by at most times a change of the state, since then ; with gains per token it is a condition, since is bounded only by .
Theorem 1 (Budget bound). Let be a read-out of the state, such as the pose decoded for a fixed frame with no write, whose change has norm at most , as it does for one gain per frame. If, given the earlier frames and the gains of frame , has an expected component of at least along a fixed unit vector , then every update rule, gates included, has
and the parts of that the earlier frames and the gains do not predict sum to a vector of mean squared norm at most .
Proof. On every video, , which gives the upper bound. For the lower bound, , and summing over the frames gives ; since is a unit vector, for every . For the rest is fixed by , so , and . Summing over pairs of frames gives , since by Jensen’s inequality, with equality for one gain per frame. □
The bound needs no model of the state, and its two constants can be measured: is the least expected change of the read-out per unit gain along the direction of drift, and the largest change. The condition is stated given the gain of the frame, so it covers gates, whose gains depend on the frame they scale. Read as a learning rate, as TTT3R reads its gate, and are the two sums of the conditions of stochastic approximation [59].
An identity for a constant push is the special case in which the read-out is the state itself.
Proposition A.1 (Constant push). Let the increments, of norm at most , split as , with a push shared by all frames and rules and a random part each of whose tokens has, given , zero mean and mean squared norm . Every update rule moves the state by with and . A schedule with one gain per frame has for every placement of its gains, and every rule with one gain per frame has .
Proof. The recursion gives , and with one gain per frame . For the gains and the increment are fixed by , so
and . Summing over pairs of frames gives ; every expectation is finite since . A schedule fixes its gains before the video, so and are constants and , which gives . For gains computed from the video, is fixed by , so and for one gain per frame; the second moment of a vector is at least the squared norm of its mean. □
With the read-out and one gain per frame, the conditions of Theorem 1 hold with , and , and for schedules the proposition sharpens the bound to an identity. A gate that sets small gains where is large has , which is the way the identity leaves for a signal to lower the drift at fixed sums. In the state of CUT3R this push is small and the read-out moves coherently (Sec. B.4), which is why Theorem 1 bounds a read-out of the state and not the state itself.
Proofs of the keyframe count
Let be a pseudometric space of views and the predicted poses of the frames, of which rule accepts . is the least number of open balls of radius with centres in that cover , and is the largest size of a subset of with pairwise distances at least . The rule accepts when for every accepted .
Theorem 2 (Keyframe count). Let be the set of predicted poses of the frames of a video, the number of keyframes that SceneBound stores at radius , frame 0 included, and the least number of open balls of radius in the distance , centred anywhere in pose space, that cover . Every pose of lies at distance below from a keyframe stored no later than it, and
where balls of radius cover a ball of radius . Every rule that keeps a stored pose at distance below from every pose of stores at least frames, and every rule that stores frames leaves a pose of at distance or more from all of them. If the frames split into sets, in each of which one rigid motion carries the true poses of the set to within of the predicted ones, then . Fed every -th frame, with every pose of within of the last pose fed, it stores between and keyframes.
Proof. The later of two accepted views passed the test against the earlier one, so accepted views are pairwise at distance at least . An accepted view is at distance zero from itself and a rejected one failed the test against an accepted view, which gives the guarantee. The balls of radius around the accepted views therefore cover , so , and the accepted views form a subset with pairwise distances at least , so . Two points of one ball of radius $M/2 lie at distance below , so such a subset has at most one point in each ball of a cover at radius , and . Every rule that keeps a stored pose at distance below from every pose of supplies a cover of by balls of radius around its stored poses, and so stores at least frames. If a rule stored frames within distance below of every keyframe, two keyframes would lie within of one stored frame and so at distance below from each other, which the test excludes; hence one keyframe, a pose of , lies at distance or more from all stored frames. For the split into sets, let be the rigid motion of set ; since is invariant under a common rigid motion of both poses, two keyframes , of set have , so the packing argument at radius bounds the keyframes of set by , and summing over the sets gives the bound. A similarity of scale changes the centre term of by , which is a feature of the depth unit, and by Proposition A.3 the term of set becomes with . A cover of by balls of radius , each covered by a ball of radius $M/2, covers at radius $M/2, so . Fed every -th frame, the rule sees the poses , so its count is at most , and its keyframes cover at radius ; every pose of lies within of a pose of , so the same keyframes cover at radius , and the count is at least .
The statement carries over to the true poses when the predicted poses are accurate to below half the radius.
Proposition A.2 (Keyframe count on true poses). Let be the true poses carried into the coordinates of the predictions by one similarity. If for every frame, every true pose lies at distance below from the true pose of a keyframe stored no later than it, and .
Proof. The triangle inequality gives for a frame and the accepted frame that covers it, so the balls of radius around the true poses of the keyframes cover , and for two accepted frames, so the packing argument at radius gives .
The bounding quantities are functions of the set , which is invariant to the order of the frames and to repeated visits, and a lower frame rate enters them through the single quantity . The second statement is the guarantee of greedy -centre clustering [27], met online, since at its own count SceneBound covers at a radius within a factor 2 of the radius that any choice of one frame fewer achieves. The split into sets bounds the cost of a break in the predicted poses, such as a jump of the camera head after which later poses are consistent among themselves and rigidly shifted from the earlier ones. Each break adds at most one covering number of the region seen after it, and a break that also rescales the later poses adds the factor of Proposition A.3, never a cost that grows with the length of the video. With the bound is that of Proposition A.2. For online covering by unit balls in a Euclidean space of dimension , every deterministic rule has a competitive ratio of at least against the offline optimum [22], so a constant factor is the best order an online rule achieves. The distance of the method, with the rotation angle , the camera centres and the fixed depth unit , is a metric on poses for every fixed , so all statements hold whatever depth the first frame sees.
Proposition A.3 (Depth unit). Let SceneBound use the depth unit for some , and let . Its keyframe count lies between
and , with the distance at unit , and Theorems 2 and 3 hold with the distance at unit .
Proof. Write for the distance at unit . For , , and for , ; in both cases . A ball of radius in lies inside the ball of radius in with the same centre, so , and in the same way . Theorem 2 at radius in gives , and the two inequalities give the stated range. □
A first frame that faces a wall four times closer than the rest of the scene thus counts the scene at a radius at most four times finer, and the count stays independent of the length of the video and of repeated visits. A unit that changes along the video and never falls below keeps the upper bound at unit , since a keyframe written at a unit lies at distance at least at unit from every earlier keyframe, and so at least at unit .
Drift at every length
Theorems 1 and 2 together bound the displacement of one state at every length.
Proposition A.4 (Drift at every length). With increments of norm at most and a decoded pose that moves by at most times a change of the state, SceneBound in one state has for every length , and the pose it predicts for any fixed frame moves by at most . Under the conditions of Theorem 1, a full update every frames has , which grows with , and every rule of full updates that keeps frame 0 or a written frame at distance below from every pose of has , and SceneBound has .
Proof. With the largest gain of frame , , so for every choice of gains, gains chosen from the video included. SceneBound in one state performs full updates after frame 0, so by Theorem 2, which gives the first bound. By the assumptions the pose that the decoder returns for a fixed frame moves by at most times the change of the state, so by at most . A full update every frames has on every video, and Theorem 1 gives . A rule of full updates that keeps frame 0 or a written frame at distance below from every pose of places the centres of open balls of radius that cover at frame 0 and at its writes, so on every video, and Theorem 1 gives . For SceneBound, by Theorem 2. □
The first bound uses the triangle inequality alone, so it holds for every choice of gains.
Proofs of the submap counts
As in § 3.4, consecutive predicted poses lie less than apart, every increment has norm at most , and the pose decoded for a fixed frame moves by at most times a change of the state, with and . SceneBound with keyframe radius treats the view of frame by the first of three cases that applies.
Read. A view written in the current submap lies at distance below from . The frame is read against the current submap.
Return. A view written in another submap lies at distance below from . The frame is read against the current submap, and the submap that holds the nearest such view becomes current at frame , with its state and its keyframes as they were when it was left.
Write. The view is written into the current submap. A new submap opens at frame when, after this write, the anchor read against the state lies at distance or more from its opening pose.
A submap that opens at frame has the anchor , written by a full update, and is placed by reading against the submap it replaces. The anchor is exempt from the return test, and views of different submaps are compared in the frame of the first submap, into which each submap is carried by the composition of the placements that chain it to the first. Frames of case 3 are the uncovered frames, and is their number. Under submaps, is the set of predicted poses carried into the frame of the first submap in this way, and the opening pose of an anchor is the pose that its own submap gives it right after it is written.
Theorem 3 (Submap counts). Let be the number of frames, other than those that open a submap, whose pose lies at distance or more from every keyframe when the frame arrives, the number of submaps and the number of keyframes. Every frame is decoded with a submap that holds a keyframe at distance below from its pose, and
A return to a kept submap adds no submap, no keyframe and no placement. Under the drift check at threshold , every submap that the check closes holds more than keyframes, and a video on which one state stores at most keyframes, in particular every video with , keeps one state.
Proof. Reads. A frame of case 1 has a keyframe of its submap below . A frame of case 2 or 3 is read against the current submap before anything is written, and for it consider frame . If frame was read by case 1, or written by case 3 or as an anchor in the submap that is current at frame , a keyframe of that submap has , so . If frame was a return, the submap current at frame holds a view with , and the same bound holds. Frame is never a write that closed its submap, since frame would then be an anchor, and an anchor is placed by a read against the submap it replaces, which holds , within of the anchor.
Counts. An uncovered view failed cases 1 and 2, so it lies at distance at least from every view written before it in any submap, and it is written itself. The uncovered views are therefore pairwise at distance at least , and the packing argument of Theorem 2 gives . Every submap after the first opens at the frame after an uncovered frame, and an uncovered frame opens at most one submap, so . A keyframe is the view of frame 0, an uncovered view or an anchor, so . These bounds are functions of the set .
Drift check. A return restores the state of a submap as it was left, so the state of a submap changes through its own writes alone. Let be the state of a submap after its anchor is written and its state after further full updates of case 3. Each write changes the state by at most , so , and the pose of the anchor decoded with lies within of its opening pose. A submap that the check closes has this distance at least , so and the submap holds keyframes. If one state writes views on the video, SceneBound follows it write for write as long as its first submap is open, and after writes the decoded anchor lies within of its opening pose, so the first submap never closes and the two rules coincide. By Theorem 2, .
Placements. A submap is placed once, by one read against the submap it replaces, and cases 1 and 2 create no submap, so the submaps form a tree and a return adds no placement.
Budget-matched baselines
Construction
For the budget-matched baseline of § 3.2, we spend the logged budget of a gate on a uniformly spaced schedule. Proposition B.1 states the schedule and the range of the two sums. By Theorem 1, sets the band of the drift and bounds the part that the past does not predict, and under the constant push of Proposition A.1 the expected squared drift depends on the gains through these two sums alone (Proposition B.2), so matching them suffices.
Proposition B.1 (Uniformly spaced schedule). Let and be integers and . The schedule with at the frames with and elsewhere writes at exactly frames, has and , and its prefix sums satisfy for every . Every gain sequence in with budget has , where the constant gain attains the first bound and gains in attain the second. Hence , and for every integer with the gain lies in and gives the budget and the sum of squared gains , which equals when .
Proof. The number of writes up to frame is by telescoping, which equals at , and yields the bound on the prefix sums after multiplication by . By the Cauchy–Schwarz inequality, , with equality exactly for a constant , and on , with equality exactly at the endpoints, hence and . Then implies , and the sums are and .
Proposition B.2 (Two sums). Under the constant push of Proposition A.1 the increments of a schedule have the Gram matrix , so depends on the gains through and alone. If a symmetric matrix and a function satisfy for every with , then with and .
Proof. For the noise is fixed by the information before frame ; thus , and . With , this yields the Gram matrix and . For the converse, let be a permutation matrix. The cube is invariant under , and and take the same values at and at ; therefore on the cube. A quadratic form that vanishes on a set with nonempty interior has a zero matrix, and hence is invariant under every permutation of the indices. A transposition yields , and a permutation carries any ordered pair of distinct indices to any other; thus has one diagonal value and one off-diagonal value.
In the experiments, we take as the integer in nearest , which makes the budget exact and places within a factor of . Two schedules with equal sums move a state differently when the increments are correlated in time. For scalar increments with a random sign , the schedules and have equal sums and displacements 2 and 0. Since the baseline spreads its writes uniformly, the comparison of a gate with its baseline measures the placement of its gains and their feedback on later increments together.
Gates versus their baselines
Per sequence, the gates and their baselines fall on both sides of equal error (Figure 6). We list each gate in Table 3 with a paired resampling interval of its ratio over the 61 sequences. taken as the central 95% of 4,000 draws of sequences with replacement. When we resample the 38 scenes, holding the sequences of one 7-Scenes room or one Bonn scene together, both ends of all intervals move by at most 0.01. The gate of TTSA3R is ahead of its baseline at 1.06, with an interval from 1.01 to 1.12, and the baseline of AFG-Img is ahead of its gate at 0.92, with an interval from 0.86 to 0.97. The largest ratio on one dataset, AFG-Pose on TUM-dynamics at 1.51 over eight sequences, comes from one sequence, sitting halfsphere, where the baseline and the matched constant reach 0.271 and 0.272 and the gate reaches 0.062. Single sequences show differences between a gate and its baseline, with quartiles of the ratio between 0.84 and 1.12 across the gates. The match therefore holds for the benchmark mean, and single scenes place a gate ahead of or its baseline. The baselines of these soft gates write on 73% to 99% of the frames at mean gains of 0.04 to 0.32, close to a constant gain.
| Gate | Baseline† | Interval | Constant† | TUM-dyn | Bonn | 7-Scenes | NRGBD | Quartiles | Baseline lower |
| TTT3R [14] | 1.04 | 0.99–1.09 | 1.07 | 0.97 | 1.05 | 1.02 | 1.05 | 0.91–1.12 | 26 of 61 |
| MeMix [21] | 0.95 | 0.79–1.09 | 1.00 | 0.92 | 1.04 | 1.00 | 0.77 | 0.88–1.12 | 38 of 61 |
| TTSA3R [93] | 1.06 | 1.01–1.12 | 1.09 | 0.99 | 1.05 | 1.03 | 1.20 | 0.95–1.11 | 22 of 61 |
| FILT3R [33] | 1.04 | 0.97–1.12 | 1.08 | 0.99 | 1.10 | 1.01 | 1.00 | 0.91–1.10 | 26 of 61 |
| ReCal3R [42] | 0.99 | 0.95–1.02 | 0.99 | 0.97 | 1.01 | 0.94 | 1.01 | 0.94–1.02 | 39 of 61 |
| AFG-Img‡ [58] | 0.92 | 0.86–0.97 | 0.91 | 0.94 | 0.90 | 0.94 | 0.94 | 0.87–1.01 | 41 of 61 |
| AFG-Pose‡ [58] | 0.97 | 0.91–1.06 | 0.97 | 1.51 | 0.89 | 0.98 | 0.93 | 0.84–1.04 | 44 of 61 |
| Info3R‡ [4], gate | 1.01 | 0.98–1.05 | 1.02 | 1.07 | 1.00 | 0.98 | 1.08 | 0.97–1.03 | 29 of 61 |
| BAT3R [40] | 0.95 | 0.87–1.03 | 1.01 | 0.90 | 0.96 | 0.96 | 0.92 | 0.88–1.05 | 39 of 61 |
| SceneBound (ours) | 1.12 | 1.02–1.29 | 1.21 | 1.69 | 1.16 | 1.00 | 1.03 | 0.97–1.09 | 28 of 61 |
Table 3. Each gate against its budget-matched baseline and its matched constant on the 61 benchmark sequences, with a paired resampling interval, the ratio per dataset and the spread over sequences. SceneBound runs in one state. †Constructed baseline. ‡Our implementation of a method without released code.
Figure 6. Each published gate and its budget-matched baseline† on the 61 benchmark sequences, coloured by dataset. (a) The two errors per sequence, with the line of equal error. (b) Their ratio per sequence; bars mark the ratio of the mean errors.
We run three further controls that remove what a baseline knows about its gate. A constant gain on each sequence, the total budget of the gate divided by its frames, reaches 0.91 to 1.09 times the error of the gate, 1.01 in the geometric mean, and is lower on 24 to 44 of the 61 sequences. When we move the writes of each baseline to frames drawn at random, the error is 1.00 to 1.06 times that of the uniformly spaced baseline. The match thus holds for spaced, random and constant placements of the budget. For SceneBound in one state, the three placements of its budget result in 0.0805 at new views, 0.0904 at uniform sampling and 0.0913 at random frames, and its lead over uniform sampling falls on the two datasets with moving people, with a ratio of 1.07 on the 53 sequences outside TUM-dynamics.
The published papers of these gates compare them with signal-free schedules at budgets chosen by hand. AFG compares its gate with constants from 0.1 to 0.7 and with writes on alternate frames and on one frame in three, and in its own table a constant of 0.5 matches writes on alternate frames and a constant of 0.3 matches writes on one frame in three, as a budget would predict. FILT3R reports a fixed gain of 0.05, which writes a third of what its gate writes, with a lower trajectory error and a higher rotation error than the gate. MeMix reports that random tokens at an equal count reach the pose error of its rule.
Five further settings
We repeat the comparison in five settings (Table 4). Inside the periodic reset of TTT3R, which starts a new state every 100 frames, the long-sequence benchmark shows the same picture as § 3.2, with a geometric mean of 0.96. In the second released checkpoint, at 224 pixels, the baselines have 0.99 to 1.13 times the error of their gates, each rule has 1.4 to 2.7 times its error in the first checkpoint, and the eight gates and SceneBound rank identically by budget and by error. On the held-out Replica, the ratio ranges from 0.81 to 1.16, with 0.98 in the geometric mean, and across the gates and CUT3R the rank correlation between budget and error is 1.00.
| Gate | Reset | 224 px | Replica | KITTI | TUM |
| TTT3R [14] | 0.92 | 1.04 | 0.96 | 1.24 | 1.24 |
| MeMix [21] | 0.88 | 1.04 | 0.97 | 1.15 | 1.17 |
| TTSA3R [93] | 1.01 | 1.06 | 1.16 | 1.15 | 1.21 |
| FILT3R [33] | 1.01 | 1.06 | 1.09 | 1.06 | 0.99 |
| AFG-Img‡ [58] | 0.92 | 0.99 | 0.90 | 1.25 | 1.35 |
| ReCal3R [42] | 1.00 | 1.01 | 0.95 | 1.07 | 1.02 |
| Info3R‡ [4], gate | 0.99 | 1.13 | 1.03 | 1.05 | 0.97 |
| AFG-Pose‡ [58] | 0.99 | 1.01 | 0.81 | 1.05 | 1.12 |
| Geometric mean | 0.96 | 1.04 | 0.98 | 1.12 | 1.13 |
Table 4. Baseline† over gate ATE inside the reset of the TTT3R release, in the second checkpoint at 224 pixels, on Replica, and inside the reset on the 11 KITTI drives and 12 TUM RGB-D sequences. †Constructed baseline. ‡Our implementation of a method without released code.
Inside short states on long sequences, the signals of several gates add accuracy beyond their budget. Across the 11 KITTI drives, all gates are ahead of their baselines by 5% to 25%, and the rank correlation between budget and error falls to 0.45. On the 12 TUM RGB-D sequences outside development, four gates are ahead by 17% to 35% and AFG-Pose by 12%, and the baselines fall between 0.526 and 0.573 at budgets from 1,124 to 8,567. We run two controls that preserve the gain of TTT3R frame by frame, one applying the mean gain of each frame to all tokens and one handing the gains of each frame to its tokens in random order. On KITTI these controls reach 76.3 and 74.6 m, compared with 61.7 for the gate and 76.3 for its baseline, and on TUM RGB-D they reach 0.531 and 0.551, compared with 0.449 and 0.557. Inside the reset, the gate therefore gains by which tokens it writes. In the cache of RegVGGT, three choices of keys that use no score are 4% to 7% below its scored selection at 10% of the keys. At 1% of the keys, random keys are 6% above it with more than twice its rotation RPE, and uniformly spaced keys reach 1.94 times its error.
The increments
We decode frame 0 again with the current state and no write, which returns the pose that the state now assigns to its first camera, and the distance of this pose from the pose at the start measures the displacement of the coordinate frame. Over five constant gains and three rules of full updates, the slope of the logarithm of this displacement versus the logarithm of the budget is 0.63, 1.00, 1.41 and 1.76 on TUM-dynamics, Bonn, 7-Scenes and Neural RGB-D after 500 frames, as in Figure 2a, and 0.98, 0.98, 1.34 and 1.37 after 1,000 frames. Over all four datasets the slope of the geometric mean is 1.2 after 500 frames, and the shift per unit budget stays within a factor of 2.4 across the eight rules, the band of Theorem 1; increments without a common direction would give a slope of 0.5. For the ratio test of § 3.2, SceneBound writes 23.0 and 22.5 full updates per sequence over the first 500 frames of 7-Scenes and Neural RGB-D, so a constant gain of equal budget has , 22 times less, and a dominant uncorrelated random part would give times its shift. Interpolated in log budget between the constant gains of 0.03 and 0.05, the keyframes shift the first camera by 0.92 and 1.11 times as much after 500 frames and by 0.93 and 1.53 times after 1,000 frames. The Gram matrix of the increments in Table 5, which we compute from one increment in eight along each sequence, is short-ranged and grows as the gain falls. At gains of 1 and 0.3, the state increments are therefore nearly uncorrelated, with a common part near zero, and the change that grows with the budget is the coherent change of the read-out that Theorem 1 bounds. At small gains, neighbouring increments repeat one push, and the moments of the increments thus differ between schedules.
| Schedule | Set | Sequences | 8–16 | 24–48 | 56–104 | 112–200 | 208–400 | 408–600 | 608–800 | 808–992 |
| Constant gain 1 (CUT3R) | TUM-dyn | 8 | −0.011 | −0.005 | −0.001 | 0.000 | 0.000 | 0.000 | −0.001 | −0.003 |
| Constant gain 1 (CUT3R) | NRGBD | 9 | −0.001 | −0.003 | −0.001 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 |
| Constant gain 0.3† | TUM-dyn | 8 | 0.018 | −0.028 | −0.014 | −0.003 | −0.001 | 0.000 | −0.001 | 0.000 |
| Constant gain 0.3† | NRGBD | 9 | 0.035 | −0.013 | −0.011 | −0.005 | −0.002 | −0.001 | 0.000 | −0.001 |
| Constant gain 0.05† | NRGBD | 9 | 0.464 | 0.162 | 0.003 | −0.047 | −0.036 | −0.014 | −0.007 | −0.002 |
| SceneBound (ours) | NRGBD | 9 | 0.528 | 0.139 | 0.012 | −0.025 | −0.024 | −0.013 | −0.006 | 0.002 |
Table 5. Gram matrix of the state increments, the mean off-diagonal entry over the mean diagonal entry in each band of lags.
Two experiments test what the gains say about the tokens. Permuting the gains of a gate over the state tokens of each frame preserves their distribution, their mean and their course over time, and results in 0.92 to 1.11 times the error of the gate for TTT3R, TTSA3R, FILT3R and AFG-Pose, with MeMix at 0.96 for random tokens of its count. A keyframe that reaches part of the state, either with each token at the TTT3R gain of the frame or as a full update of the half of the tokens with the largest gain, is above the full update of SceneBound (0.0805) in all forms. The half with the largest gain is also above a random half at both radii tried, with 0.230 versus 0.123 and 0.263 versus 0.116.
Keyframe selection tests across thresholds
We port each test from the official code of its system without the trained parts, as a rule that writes a whole frame to the state of CUT3R or retains it in the cache of StreamVGGT. AMB3R (commit 92c4081) writes a frame when the rotation angle over plus the distance of its centre, in the depth unit of the first frame, exceeds the threshold for all active keyframes, and holds at most 10 active keyframes, resampled as released. MUSt3R (commit efc5b08) writes a frame when the 85th percentile of the depth-normalised distances from its world points to the stored points seen in the same octant of view directions exceeds the threshold, with the confidence limit of its release. Scal3R applies the same percentile to the points of the frame placed by the predicted camera, which stands in for its trained pose graph; in the state it follows commit af4c8e8 and retains its first four frames and the last four written, and in the cache it follows the STream3R branch of its release (commit 87a7924) and compares the frame with frame 0 and the last 12 frames kept. We run each test at four thresholds, including the released one.
Every rule runs in one state. 1Constructed baseline.
In the state, each test at each threshold is 5% to 38% above SceneBound (Table 6). At the thresholds whose total count matches that of SceneBound, AMB3R at 0.175, Scal3R at 0.115 and MUSt3R at 0.052 write 1,422, 1,417 and 1,415 frames and reach 0.0875, 0.0864 and 0.0887 against 0.0805, the rows of Table 2. Most of the gap lies on TUM-dynamics, where the two point tests reach 0.093 and 0.090 against 0.048: on the two sequences in which a static camera watches people walk past, they write 22 and 23 frames where the pose test writes one, and on the two half-sphere sweeps, which view one desk from new directions, they write 12 to 44 frames against 26 and 25 and reach 0.19 to 0.22 against 0.049 and 0.073. On Bonn, which also holds moving people, they are 4% and 5% above SceneBound, on 7-Scenes within 2%, and on Neural RGB-D Scal3R is 8% below it. When we interpolate in log count to the count of SceneBound on each sequence, AMB3R is 5.9% above SceneBound on the 54 sequences that its thresholds bracket (paired interval 1.01 to 1.14), MUSt3R is 5.7% above on 37 (0.97 to 1.17) and Scal3R is 8.7% above on 39 (1.01 to 1.19). With the camera head kept whole, the three tests in the cache are 1.6%, 3.1% and 1.7% above SceneBound on the 55, 45 and 39 sequences that their thresholds bracket, with intervals from 0.95 to 1.08. With the camera head pruned, as in Table 2, AMB3R at 0.15 and 0.175, MUSt3R at 0.05 and 0.1 and Scal3R at 0.05 and 0.1 reach 0.0830, 0.0825, 0.0846, 0.0844, 0.0844 and 0.0834 with 1,703, 1,406, 1,662, 996, 1,990 and 1,066 frames, and at the 1,433 frames of SceneBound, interpolated in log count, 0.0826, 0.0845 and 0.0839 against 0.0831 for SceneBound and 0.0841 for uniform sampling; per sequence, the two thresholds of each test bracket 34, 21 and 24 sequences, on which the tests reach 1.00, 1.02 and 1.00 times SceneBound, with intervals from 0.91 to 1.09. Run at the matched thresholds with the camera head pruned, Scal3R at 0.072 and MUSt3R at 0.061 keep 1,413 and 1,423 frames at 0.0845 and 0.0831, against 1,433 frames at 0.0831 for SceneBound, and process 5.7 and 4.8 frames per second against 6.3 for SceneBound and 6.4 for AMB3R.
| Write rule | Test | Writes | ATE (m) ↓ State | ATE (m) ↓ Cache | Growth ↓ State | Growth ↓ Cache |
| No test | ||||||
| Every 50 frames† | none | 1,039 | 0.0839 | 0.0863 | 8.93 | 8.89 |
| Uniform sampling† | none | 1,421 | 0.0904 | 0.0841 | 6.39 | 6.34 |
| Test against recent views | ||||||
| Latest keyframe† | pose | 1,616 | 0.0820 | 0.0846 | 8.44 | 7.95* |
| AMB3R [73] | pose | 1,422 | 0.0875 | 0.0825 | 6.54 | 5.41* |
| Scal3R [44] | points | 1,417 | 0.0864 | 0.0845 | 5.52 | 2.80* |
| Test against all stored views | ||||||
| MUSt3R [8] | points | 1,415 | 0.0887 | 0.0831 | 1.16 | 1.12 |
| SceneBound (ours) | pose | 1,421 | 0.0805 | 0.0831 | 1.03 | 1.06 |
Table 2. Write rules on the 61 benchmark sequences in one state and in the KV cache, and the growth of their writes over nine passes of the revisit sequences.
| Test | Threshold | State Writes | State ATE ↓ | Cache Kept | Cache ATE ↓ |
| AMB3R | 0.125 | 2,069 | 0.0901 | 2,117 | 0.0888 |
| 0.15 | 1,687 | 0.0876 | 1,707 | 0.0873 | |
| 0.175 | 1,422 | 0.0875 | 1,416 | 0.0879 | |
| 0.2 | 1,219 | 0.0848 | 1,225 | 0.0908 | |
| MUSt3R | 0.025 | 2,168 | 0.1113 | 2,798 | 0.0919 |
| 0.05 | 1,451 | 0.0885 | 1,650 | 0.0880 | |
| 0.052 | 1,415 | 0.0887 | 1,604 | 0.0887 | |
| 0.1 | 958 | 0.0867 | 995 | 0.0884 | |
| 0.2 | 597 | 0.0855 | 566 | 0.0924 | |
| Scal3R | 0.05 | 2,560 | 0.0896 | 1,981 | 0.0879 |
| 0.1 | 1,576 | 0.0847 | 1,066 | 0.0873 | |
| 0.115 | 1,417 | 0.0864 | 921 | 0.0881 | |
| 0.2 | 960 | 0.0862 | 576 | 0.0940 | |
| 0.4 | 572 | 0.0891 | 322 | 0.1022 | |
| Uniform sampling† | none | 1,421 | 0.0904 | 1,426 | 0.0853 |
| SceneBound (ours) | 1,421 | 0.0805 | 1,426 | 0.0870 |
Table 6. The ported keyframe selection tests at each threshold on the benchmark, with summed writes or kept frames and mean ATE (m), the cache with the camera head kept whole.
Two tests against recent writes alone complete the comparison of history scopes. A test against the latest keyframe, at radius , writes 1,616 frames on the benchmark at 0.0820, against 1,421 at 0.0805, and on the 24 revisit sequences 788 frames in the first passes and 6,651 over all nine, at 0.206 against 0.084. In the cache it keeps 1,638 frames on the benchmark at 0.0846, against 1,433 at 0.0831, and over nine passes it fills the GPU on 12 of the 17 revisit sequences, between frames 5,071 and 8,503, and keeps 7.95 times its first passes on the other five. A test of the distance travelled since the last write, at the same radius, writes 2,751 frames on the benchmark at 0.086 and 11,788 over the nine passes at 0.354. Over the nine passes in the state, AMB3R, Scal3R and MUSt3R write 4,577, 3,181 and 701 frames, 6.54, 5.52 and 1.16 times their first passes, at 0.170, 0.143 and 0.129, and uniform sampling, whose frames are fixed in advance, spreads the 722 writes of SceneBound evenly, 113 of them in the first passes, a growth of 6.39.
On the revisit sequences, we run each test in the cache at the threshold whose total count on the long-sequence benchmark matches that of SceneBound (Table 7). The test of MUSt3R compares a frame with the points of each stored frame and completes all 17 videos, with 402 frames kept in the first passes and 449 in all nine, 1.12 times, against 1.06 times for SceneBound, at 14.6 against 14.8 GB. AMB3R compares a frame with its 10 active keyframes and Scal3R with its first four and last four writes, so a place seen on an earlier pass is new to them once its keyframes have left that set. AMB3R fills the 80 GB GPU on the same eight of the 17 videos as with the camera head kept whole, where SceneBound retains 29 to 64 frames over all nine passes, and its kept frames grow 5.4 times on the other nine, against 1.01 times for SceneBound. Scal3R fills the GPU on two videos and grows 2.8 times on the other 15, against 1.03 times for SceneBound. The tests of MUSt3R and Scal3R end at 0.062 and 0.055 against 0.069 and 0.063 for SceneBound, and one video makes the difference, the breakfast room of Neural RGB-D. On its second to fourth passes, six frames receive a predicted pose up to 2.6 from that of the frame before, beyond the radius , SceneBound writes them as new views, and every later pass reads these misplaced views, so its error rises from 0.043 after one pass to 0.215 over nine; the test of MUSt3R finds the points of these frames stored and writes none. Without this video, MUSt3R and Scal3R reach 0.063 and 0.055 against 0.060 and 0.052 for SceneBound. Theorem 3 assumes steps below between consecutive poses, and a write rule can hold its writes to this bound by measuring the step of each frame from the last frame that passed it; a frame beyond the bound is decoded and not written. With this test, SceneBound keeps the six views out, writes three frames of later passes whose predicted pose lies beyond of every keyframe, and reaches 0.106 on the breakfast room with 46 frames. Over the 17 videos its mean falls from 0.069 to 0.062, below the 0.067 of every 50 frames, with 447 frames, and on the long-sequence benchmark it moves from 0.0831 to 0.0832.
| Rule | Videos | 1 pass | 9 passes | GPU ↓ | ATE ↓ |
| AMB3R, 0.175 | 9 of 17 | 107 | 579 | 24.4 | 0.033 |
| SceneBound (ours) | 9 | 131 | 132 | 11.6 | 0.032 |
| MUSt3R, 0.061 | 17 of 17 | 402 | 449 | 14.6 | 0.062 |
| SceneBound (ours) | 17 | 426 | 450 | 14.8 | 0.069 |
| Scal3R, 0.072 | 15 of 17 | 289 | 810 | 21.7 | 0.055 |
| SceneBound (ours) | 15 | 349 | 360 | 14.1 | 0.063 |
Table 7. The ported keyframe selection tests on the 17 revisit sequences in the cache, beside SceneBound on the videos each test completed, every rule with the camera head pruned: GPU memory (GB) and ATE (m) after nine passes.
SceneBound in detail
Constants and their selection
The rule has two constants. We fixed the keyframe radius on 15 TUM sequences, seven static sequences outside the benchmark and the eight TUM-dynamics sequences of the benchmark, choosing from the values 0.15, 0.2 and 0.3. The depth unit of the distance, the median depth of frame 0, replaced a running unit after a comparison on the 61 benchmark sequences (0.0805 versus 0.0831). Table 8 reports the benchmark at six radii in one state, which we ran after these choices. The error falls from 0.2 to 0.3 and rises again above 0.4. A radius of 0.3 yields the lowest error of the six on the benchmark and on TUM-dynamics, and on the 53 sequences outside TUM-dynamics the response is flat within 1.5% between 0.3 and 0.5. On these 53 sequences, SceneBound reaches 0.0854 in the state and 0.0906 in the cache, 9% and 17% below the best published rules, Info3R in full (0.094) and RetrieveVGGT (0.110), and every 50 frames reaches 0.0839 and 0.0943.
| Bench. | Outside TUM-dyn | TUM-dyn | Writes | |
| 0.2 | 0.0910 | 0.0967 | 0.053 | 2,312 |
| 0.25 | 0.0857 | 0.0911 | 0.050 | 1,785 |
| 0.3 (ours) | 0.0805 | 0.0855 | 0.048 | 1,421 |
| 0.35 | 0.0808 | 0.0856 | 0.050 | 1,166 |
| 0.4 | 0.0812 | 0.0843 | 0.061 | 992 |
| 0.5 | 0.0860 | 0.0843 | 0.098 | 731 |
Table 8. Keyframe radius on the benchmark in one state.
The depth unit is the median depth that frame 0 predicts, and Proposition A.3 preserves every bound for any fixed unit. Across the 61 benchmark sequences, the ratio of each frame’s median depth to this unit has 5th and 95th percentiles of 0.67 and 1.15 in the median sequence, and 0.11 and 2.47 at the extremes. Table 9 scales the unit by from 1/4 to 4 in both the keyframe test and the drift check, matching a first frame that sees its scene times farther away than at . A larger unit measures the scene more coarsely, writes 0.75 and 0.58 times as many frames at and 4, and raises the mean ATE by 3%. A smaller unit measures it more finely, writes 1.5 and 2.4 times as many frames at and 1/4, and raises the mean ATE by 11% and 20%, as Theorem 1 predicts for a larger update budget; the radius sweep of Table 8 shows the same response. A first frame that faces a near wall therefore costs accuracy through the writes it adds, and it leaves memory bounded at every sequence length. A unit that rises, never falls, to the median of the median depths of frame 0 and of every keyframe written since removes most of this cost. It never falls below the unit of frame 0, so the count bound at that unit holds (Sec. A.2), and once the keyframes outnumber the first frame it follows their depth. On the benchmark it reaches 0.0832 and 0.0821 at and 1/2, 3% and 2% above the fixed unit at , with 1,432 and 1,418 writes, and 0.0801 with 1,374 writes at . All other results of the paper use the fixed unit of frame 0.
| TUM-dyn | Bonn | 7-Scenes | NRGD | Bench. | Writes | |
| 1/4 | 0.058 | 0.086 | 0.105 | 0.145 | 0.0967 | 3,415 |
| 1/2 | 0.051 | 0.082 | 0.107 | 0.107 | 0.0890 | 2,100 |
| 1 (ours) | 0.048 | 0.078 | 0.095 | 0.088 | 0.0804 | 1,423 |
| 2 | 0.055 | 0.082 | 0.096 | 0.084 | 0.0830 | 1,061 |
| 4 | 0.050 | 0.076 | 0.109 | 0.081 | 0.0830 | 828 |
| Unit rising with the median depth of the keyframes | ||||||
| 1/4 | 0.049 | 0.082 | 0.096 | 0.090 | 0.0832 | 1,432 |
| 1/2 | 0.048 | 0.080 | 0.097 | 0.089 | 0.0821 | 1,418 |
| 1 | 0.050 | 0.077 | 0.095 | 0.088 | 0.0801 | 1,374 |
Table 9. Depth unit of frame 0 scaled by on the benchmark in one state, the unit of a first frame that sees its scene times farther away, fixed and rising with the keyframes.
We selected the threshold among 10 candidates by the lowest mean ATE on seven of the 19 TUM RGB-D sequences. The candidates are five thresholds from 0.05 to 0.2, each with the plain placement of a submap and with a placement estimated from the anchor and the eight frames after it, each read against both submaps, by chordal-mean rotation, median translation and median depth ratio. At the five thresholds, the plain placement reaches 0.126, 0.117, 0.112, 0.210 and 0.326, and the bridge reaches 0.121, 0.201, 0.129, 0.115 and 0.116. Table 10 reports all thresholds of the plain placement on each set, with three larger ones from a separate run. The benchmark responds by at most 1.4%, since the check fires on few of its sequences. On the 12 other TUM RGB-D sequences, the threshold 0.1 has the lowest error of the eight. On KITTI, the eight thresholds result in 36.9 to 49.6 m, the lowest at the smallest threshold, 0.05, and the selected one in 48.0.
| Bench. | Dev., 7 | Other, 12 | KITTI, 02–10 | |
| Mean ATE (m) ↓ | ||||
| TUM RGB-D | ||||
| 0.05 | 0.0815 | 0.126 | 0.544 | 36.9 |
| 0.075 | 0.0812 | 0.117 | 0.529 | 39.8 |
| 0.1 (ours) | 0.0804 | 0.112 | 0.503 | 48.0 |
| 0.15 | 0.0804 | 0.210 | 0.543 | 40.9 |
| 0.2 | 0.0805 | 0.326 | 0.608 | 42.2 |
| 0.3 | 0.0805 | 0.249 | 0.687 | 43.2 |
| 0.45 | 0.0805 | 0.268 | 0.722 | 49.6 |
| 0.6 | 0.0805 | 0.275 | 0.668 | 42.3 |
| One state | 0.0805 | 0.138 | 0.713 | 136.8 |
Table 10. Threshold of the drift check on all sets where it ran.
Closing a submap
Table 11 lists all ways of closing a state that we ran. On KITTI sequences 02 to 10, the drift check opens 301 submaps over 17,559 frames, one per 58 frames. In rooms, a fixed reset comes at a cost. With SceneBound inside, resets at 60 and 30 frames result in 0.1112 and 0.1301 on the benchmark versus 0.0805 for one state, in 0.407 and 0.456 versus 0.138 on the concatenated rooms, and in a point cloud with 2.4 to 2.5 times the accuracy error. On the revisit sequences, the point clouds and KITTI sequences 04, 07 and 09, SceneBound makes zero returns to a stored submap, and its kept and dropped variants give equal errors. On the eight drives with a return, the dropped variant reaches 59.1 m compared with 62.1 for the kept one, and 0.494 compared with 0.503 on the 12 TUM RGB-D sequences outside development. Per drive, returns lower the error on 00, 01 and 03, from 59.4, 105.7 and 21.3 m with the closed submaps dropped to 36.4, 89.5 and 19.6 m, and raise it on 02, 05, 06 and 08. The gain of SceneBound over one state on these sets therefore comes from closing submaps, and stored submaps add their bound on the memory. Evenly spaced closing ends as many submaps as the drift check on each sequence, at frames spaced evenly in time, and releases them as the dropped variant does. On KITTI 02 to 10 it reaches 32.4 against 41.0 m for the dropped variant of the drift check and is ahead on seven of the nine drives (Sec. D.3). On the TUM RGB-D sequences it reaches 0.133 against 0.113 on the seven development sequences and 0.596 against 0.494 on the 12 others. On the benchmark it closes states on two sequences and reaches 0.0798 against 0.0805 for one state, on the concatenated rooms it closes states in two rooms and reaches 0.140 against 0.138, and on the revisit sequences and the point clouds, where the drift check opens no submap, it keeps one state.
| Closing and keeping a state | Mean ATE (m) ↓ | Cloud acc. (m) ↓ | ||||
| Benchmark | Revisits | Concatenated | TUM RGB-D, 12 | KITTI, 02–10 | NRGBD | |
| One state | 0.0805 | 0.084 | 0.138 | 0.713 | 136.8 | 0.0565 |
| Reset every 100 frames, TTT3R [14] gate, dropped | 0.1344 | 0.573 | 0.478 | 0.449 | 56.0 | 0.1214 |
| Count of writes, kept | 0.0806 | 0.084 | 0.174 | 0.642 | 53.0 | 0.0565 |
| Drift check, kept (ours) | 0.0804 | 0.084 | 0.139 | 0.503 | 48.0 | 0.0565 |
| Drift check, dropped | 0.0802 | 0.084 | 0.137 | 0.494 | 41.0 | 0.0565 |
| Reset every 60 frames, dropped | 0.1112 | 0.125 | 0.407 | 0.515 | 39.0 | 0.1351 |
| Reset every 30 frames, dropped | 0.1301 | 0.154 | 0.456 | 0.508 | 30.9 | 0.1397 |
| Radius of 1, kept | 0.0800 | 0.086 | 0.251 | 0.546 | 37.3 | 0.1103 |
| Radius of 1, dropped | 0.0937 | 0.098 | 0.360 | 0.635 | 39.5 | 0.1103 |
| Evenly spaced, count of the drift check, dropped | 0.0798 | 0.084 | 0.140 | 0.596 | 32.4 | 0.0565 |
Table 11. Ways of closing a state, kept or dropped, with mean ATE per set and point-cloud accuracy on Neural RGB-D at 500 views.
We selected three alternatives to the drift check on the two development sets, the seven TUM RGB-D sequences and KITTI sequences 03, 04 and 10. The selection score, fixed before any candidate ran, is the mean over the two sets of the ATE relative to the drift check. The first alternative is a submap radius, and the search over six radii from 0.6 to 4 with and without the drift check selected a radius of 1 (score 0.748). On the other sets, this radius is ahead on KITTI and on the two benchmark datasets with moving people, level on the benchmark mean and the revisit sequences, and behind on the two room datasets of the benchmark, the concatenated rooms, the point clouds and the 12 TUM RGB-D sequences outside development. The second alternative measures the drift at the camera as the turn of the anchor times one plus the distance of the camera from the anchor in depth units. It met the adoption criterion at a threshold of 0.05 (score 0.70) and yields 0.0830 on the benchmark, 75.1 versus 63.2 m on the eight drives outside development and 0.420 versus 0.378 on 16 TUM RGB-D sequences. The third alternative rolls a failed submap back to its state at the last check it passed. On the development drives it reaches 17.3 versus 17.4 m, an improvement of 1% against the 10% that the adoption criterion requires, and on the development sequences 0.117 versus 0.112. Outside development, the rollback reaches 57.8 versus 63.2 m on the eight drives and 0.448 versus 0.503 on the 12 sequences. SceneBound retains the drift check measured at the anchor, and we made these choices with all of these sets in view.
The drift that a state measures at its anchor tracks the true error of the poses in its submap. Over the keyframes of all submaps on the 19 TUM RGB-D sequences and 11 drives, the Spearman correlation of the true error relative to the anchor is 0.41 and 0.45 with the drift measured at the anchor, 0.40 and 0.62 with the frames since the anchor and 0.45 and 0.70 with the distance travelled. On KITTI the error grows with the distance from the anchor.
Where the error of the submaps lies
To locate the error of a run with submaps, we split each sequence at the frames that open or return to a submap, so that each piece is read against a single submap, and align each piece to the ground truth on its own (Table 12). On EuRoC, the pieces of SceneBound have an error of 0.44 m, below the 0.56 m of one state over the same frames; the drift check thus makes each submap more accurate than the state it replaces, and the full flights reach 2.14 m against 1.78 m through the relative placement of 5 to 52 submaps. On KITTI, the pieces of SceneBound have an error of 4.2 m against 50.7 m for the full drives, and the same frames of one state have 11.6 m against 177.2 m, lower than SceneBound on drive 06 alone; the remaining error lies in placing the submaps.
| Sequence | Pieces | SceneBound Whole | SceneBound Inside | One state Whole | One state Inside |
| EuRoC MH 01 | 13 | 1.84 | 0.57 | 1.41 | 0.73 |
| EuRoC MH 02 | 20 | 1.91 | 0.46 | 3.62 | 0.67 |
| EuRoC MH 03 | 5 | 2.77 | 0.76 | 2.17 | 1.04 |
| EuRoC MH 04 | 28 | 4.12 | 0.31 | 3.54 | 0.45 |
| EuRoC MH 05 | 6 | 4.89 | 1.11 | 3.45 | 1.34 |
| EuRoC V1 01 | 14 | 0.84 | 0.26 | 0.82 | 0.32 |
| EuRoC V1 02 | 52 | 1.73 | 0.11 | 1.29 | 0.16 |
| EuRoC V1 03 | 13 | 1.29 | 0.28 | 1.00 | 0.34 |
| EuRoC V2 01 | 13 | 1.44 | 0.29 | 0.72 | 0.31 |
| EuRoC V2 02 | 9 | 1.05 | 0.26 | 0.75 | 0.34 |
| EuRoC V2 03 | 20 | 1.66 | 0.45 | 0.82 | 0.43 |
| EuRoC, mean | 2.14 | 0.44 | 1.78 | 0.56 | |
| KITTI 00 | 88 | 36.4 | 0.8 | 188.0 | 8.1 |
| KITTI 01 | 25 | 89.5 | 6.0 | 529.9 | 29.7 |
| KITTI 02 | 92 | 159.2 | 2.7 | 275.6 | 13.7 |
| KITTI 03 | 16 | 19.6 | 2.2 | 56.9 | 7.8 |
| KITTI 04 | 5 | 3.5 | 1.1 | 12.3 | 5.4 |
| KITTI 05 | 44 | 31.2 | 0.8 | 115.8 | 8.1 |
| KITTI 06 | 21 | 79.5 | 25.5 | 136.1 | 22.6 |
| KITTI 07 | 22 | 5.6 | 0.5 | 73.2 | 4.7 |
| KITTI 08 | 85 | 52.0 | 3.6 | 232.6 | 10.2 |
| KITTI 09 | 35 | 52.2 | 1.1 | 191.2 | 9.8 |
| KITTI 10 | 19 | 29.2 | 2.1 | 137.2 | 7.5 |
| KITTI, mean | 50.7 | 4.2 | 177.2 | 11.6 |
Table 12. Error of SceneBound and of one state over whole sequences and inside the pieces that SceneBound reads against one submap, each piece aligned to the truth on its own, ATE (m); the lower of the two runs is in bold.
SceneBound keeps every closed submap with its state, so the submaps can serve as the nodes of a pose graph, as in submap-based SLAM [6, 20, 23, 52]. We tested a pose graph that adds no constant beyond . Each node is the placement of submap in the coordinates of the first submap, and each edge asks for . When submap opens from submap , the read that places it gives an edge whose is the pose of its anchor in submap . At every keyframe write, the stored keyframe from another submap whose mean encoder token has the highest cosine similarity to the current frame names a candidate, excluding the submap that the current one opened from and those opened from it. The frame is decoded against the stored state of the candidate, as in a return, and the read passes when its predicted pose lies at distance below from a keyframe in that submap. Two consecutive keyframes whose reads pass
against the same candidate submap, with relative motions in the two submaps within of each other, confirm a loop; each read adds an edge , with and the poses of the frame in the candidate and current submaps. At the end of the video, the placements minimise the sum of squared edge residuals, with rotation in radians and translation in the depth unit of frame 0 and with the first submap fixed, and every output camera and point moves with the updated placement of its submap. The graph changes no write, submap or return of the rule.
On the seven KITTI drives with loops, the pose graph raises the error on six and lowers it on drive 02, from 59.5 to 85.3 m in the mean, and it runs at 15 to 17 frames per second against 22 to 23 (Table 13). On drives 03 and 04, which revisit nothing, it confirms one and two loops, which must be false, and raises the error from 19.6 and 3.5 m to 55.6 and 101.4 m; on eight TUM RGB-D sequences it confirms no loop and leaves the error unchanged. On drive 07, a single confirmed loop raises the error from 5.6 to 40.5 m. Reading a frame against a stored state places the frame near the keyframes of that state, which confirms false loops and yields relative poses too coarse to correct true loops.
| 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | Mean | |
| SceneBound (ours) | 36.4 | 89.5 | 159.2 | 19.6 | 3.5 | 31.2 | 79.5 | 5.6 | 52.0 | 52.2 | 29.2 | 50.7 |
| With the pose graph | 61.1 | 89.5 | 154.6 | 55.6 | 101.4 | 51.1 | 96.6 | 40.5 | 121.6 | 71.8 | 29.2 | 79.4 |
| Confirmed loops | 97 | 0 | 17 | 1 | 2 | 40 | 27 | 1 | 23 | 4 | 0 | 19.3 |
Table 13. A pose graph over the kept submaps, with loops confirmed by reads of the frozen model, on the 11 KITTI drives: ATE (m) and confirmed loops. Drives 01, 03, 04 and 10 revisit nothing.
Cost
On KITTI 00, where the drift check opens 83 submaps and returns to kept ones four times, the peak GPU memory of SceneBound is 6,456 MB, compared with 4,968 MB in one state, 4,966 MB for CUT3R and 5,779 MB for TTT3R with reset. A stored submap thus costs about 18 MB, and Table 14 lists the cost on the other drives and on TUM RGB-D.
| Rule | Set | FPS ↑ | GPU (GB) ↓ | Submaps |
| SceneBound (ours) | TUM | 22.3 | 8.3 | 8 |
| TTT3R 2 with reset | TUM | 23.6 | 8.3 | 1 |
| SceneBound (ours) | KITTI | 21.7 | 6.5 | 88 |
| TTT3R with reset | KITTI | 25.7 | 5.8 | 1 |
| Radius of 1 | KITTI | 23.6 | 7.4 | 237 |
Table 14. Throughput, peak GPU memory and the most submaps held at once on the 19 TUM RGB-D sequences and KITTI sequences 02–10.
The KV cache
We run the cache rules in the released StreamVGGT checkpoint through the code and evaluator of RegVGGT (commit 3ec82dbe, the 518-pixel crop of its pose evaluation, bfloat16) and score each predicted pose as the pose of the camera in the world. The pose script of RegVGGT scores the inverse, the pose of the world in the camera. Scored that way, our run at 1% of keys reproduces the nine values of its Table 1 at 800, 900 and 1,000 frames within 0.5%. The rules run the cache unregulated, with all keys of all layers, and decide once per frame, after the camera head, whether the frame stays. SceneBound stores the frame when, with the depth unit of frame 0, its predicted camera is at pose distance 0.3 or more from every kept frame. Uniform sampling selects frame 0 and the same number of later frames at the spacing of Proposition B.1, and a fixed interval selects frames a fixed number apart. A frame that leaves the cache is replaced by an empty tensor, which frees its storage. The camera head of StreamVGGT keeps its own cache, four refinement steps of four blocks per frame; the fixed intervals, uniform sampling and SceneBound of the main tables prune it, so a frame that leaves the aggregator’s cache leaves this cache too. Pruning the camera head lowers the mean ATE of SceneBound from 0.0870 to 0.0831 and of a frame every 25, 50, 100 and 200 frames by 2% to 5%; with the camera head kept whole, as the published caches run, SceneBound is 15% below RetrieveVGGT and ahead of all seven published caches; the radius sweep keeps the camera head whole. We retuned nothing for this model.
The peak GPU memory of a run includes the model and its activations, the cache and the input frames, which the evaluator of RegVGGT stores on the GPU in float32 at 2.35 MB per frame for 378 by 518 pixels. We report the peak less the stored input frames in all tables. A least-squares fit over the runs of SceneBound, its uniform sampling and the interval of 50 frames yields about 255 MB per kept frame, and the full cache fills the 80 GB GPU at frame 287 on all 61 benchmark sequences.
On TUM-dynamics, Bonn, 7-Scenes and Neural RGB-D, SceneBound stores 116, 317, 690 and 310 frames, and the state of CUT3R takes 113, 314, 697 and 299 writes. Over the 61 sequences, the two counts have a rank correlation of 0.99. Fixed intervals of 25 and 50 frames fall within 0.009 of SceneBound on each dataset (Table 15). Every published cache is at or above SceneBound on each dataset except RetrieveVGGT on Neural RGB-D (0.102 against 0.122), with the largest gaps on Neural RGB-D and 7-Scenes, where
| Rule | TUM-dyn | Bonn | 7-Scenes | N RGBD | Mean | Rot. RPE (°) ↓ | GPU (GB) ↓ |
| RegVGGT [54], 1% of keys | 0.058 | 0.099 | 0.116 | 0.195 | 0.1128 | 0.86 | 8.3 |
| RegVGGT, 10% of keys | 0.051 | 0.091 | 0.113 | 0.188 | 0.1067 | 0.73 | 11.9 |
| Random 1% of keys† | 0.051 | 0.110 | 0.119 | 0.208 | 0.1191 | 2.11 | 8.3 |
| Random 10% of keys† | 0.050 | 0.086 | 0.107 | 0.175 | 0.1006 | 0.69 | 11.9 |
| Uniformly spaced 10% of keys† | 0.051 | 0.090 | 0.109 | 0.173 | 0.1027 | 0.73 | 11.9 |
| Every 10 frames, regulated layers† | 0.049 | 0.085 | 0.107 | 0.173 | 0.0995 | 0.70 | 12.0 |
| Every 10 frames† | 0.038 | 0.071 | 0.107 | 0.123 | 0.0850 | 0.66 | 28.9 |
| Every 25 frames† | 0.033 | 0.071 | 0.102 | 0.121 | 0.0828 | 0.72 | 16.0 |
| Every 50 frames† | 0.033 | 0.079 | 0.101 | 0.124 | 0.0863 | 0.91 | 11.7 |
| Every 100 frames† | 0.035 | 0.103 | 0.100 | 0.150 | 0.1002 | 1.19 | 9.6 |
| Every 200 frames† | 0.041 | 0.149 | 0.210 | 0.196 | 0.1596 | 4.08 | 8.5 |
| Uniform sampling† | 0.032 | 0.075 | 0.105 | 0.115 | 0.0841 | 0.71 | 13.3 |
| SceneBound (ours) | 0.033 | 0.071 | 0.104 | 0.122 | 0.0831 | 0.67 | 13.3 |
Table 15. Signal-free rules in the KV cache of StreamVGGT on the benchmark, beside the scored keys of RegVGGT. Fixed intervals, uniform sampling and SceneBound prune the camera head, and the other rules keep it whole. ATE (m) ↓
†Constructed baseline.
GHOST reaches 0.302 and 0.248 compared with 0.122 and 0.104 (Table 16).
| Method | TUM-dyn | Bonn | 7-Scenes | NRGBD | Mean | Trans. (m) | Rot. (°) | Cost |
| Recurrent state of CUT3R | budget | |||||||
| CUT3R [77] | 0.161 | 0.322 | 0.655 | 1.156 | 0.5224 | 0.0154 | 1.231 | 51,195 |
| MeMix [21] | 0.102 | 0.264 | 0.393 | 0.604 | 0.3312 | 0.0175 | 0.801 | 14,432 |
| TTT3R [14] | 0.115 | 0.269 | 0.410 | 0.457 | 0.3182 | 0.0179 | 0.897 | 15,716 |
| TTSA3R [93] | 0.093 | 0.220 | 0.315 | 0.289 | 0.2414 | 0.0181 | 0.677 | 11,322 |
| RayMap3R [71] | 0.131 | 0.127 | 0.206 | 0.257 | 0.1699 | 0.0100 | 0.673 | 9,566 |
| BAT3R [40] | 0.069 | 0.155 | 0.170 | 0.262 | 0.1642 | 0.0183 | 0.759 | 6,920 |
| FILT3R [33] | 0.074 | 0.143 | 0.190 | 0.245 | 0.1629 | 0.0167 | 0.630 | 7,790 |
| AFG-Img‡ [58] | 0.083 | 0.165 | 0.163 | 0.162 | 0.1534 | 0.0170 | 0.639 | 6,798 |
| ReCal3R [42] | 0.067 | 0.110 | 0.146 | 0.185 | 0.1258 | 0.0159 | 0.625 | 5,794 |
| AFG-Pose‡ [58] | 0.055 | 0.107 | 0.094 | 0.098 | 0.0950 | 0.0175 | 0.641 | 1,390 |
| Info3R‡ [4], gate | 0.060 | 0.094 | 0.101 | 0.085 | 0.0901 | 0.0163 | 0.635 | 2,901 |
| Info3R‡, in full | 0.056 | 0.091 | 0.095 | 0.099 | 0.0888 | 0.0152 | 0.642 | 2,127 |
| TTT3R with reset | 0.096 | 0.115 | 0.163 | 0.167 | 0.1344 | _0.0102_ | 0.548 | 17,825 |
| Every 50 frames† | 0.083 | 0.078 | 0.092 | 0.083 | _0.0839_ | 0.0199 | 1.066 | 1,039 |
| SceneBound (ours) | 0.048 | 0.078 | 0.095 | 0.088 | 0.0804 | 0.0173 | 0.697 | 1,423 |
| KV cache of StreamVGGT | GB | |||||||
| RegVGGT [54], 1% of keys | 0.058 | 0.099 | 0.116 | 0.195 | 0.1128 | 0.0263 | 0.863 | 8.3 |
| RegVGGT, 10% of keys | 0.051 | 0.091 | 0.113 | 0.188 | 0.1067 | 0.0222 | 0.730 | 11.9 |
| InfiniteVGGT [89] | 0.067 | 0.129 | 0.161 | 0.178 | 0.1374 | 0.0287 | 0.870 | 16.1 |
| OVGGT [51] | 0.071 | 0.192 | 0.167 | 0.203 | 0.1702 | 0.0442 | 1.385 | _8.8_ |
| GHOST [12] | 0.072 | 0.173 | 0.248 | 0.302 | 0.2009 | 0.0382 | 1.793 | 16.5 |
| FrameVGGT [85] | 0.047 | 0.139 | 0.153 | 0.133 | 0.1304 | 0.0323 | 1.726 | 23.0 |
| XStreamVGGT [65] | 0.065 | 0.224 | 0.287 | 0.316 | 0.2354 | 0.0531 | 3.990 | 10.0 |
| RetrieveVGGT [96] | 0.050 | 0.101 | 0.126 | 0.102 | 0.1019 | 0.0290 | 0.947 | 11.3§ |
| Every 50 frames† | 0.033 | 0.079 | 0.101 | 0.124 | 0.0863 | 0.0227 | 0.915 | 11.7 |
| Uniform sampling† | 0.032 | 0.075 | 0.105 | _0.115_ | 0.0841 | 0.0193 | 0.711 | 13.3 |
| SceneBound, camera head kept whole | 0.051 | _0.073_ | 0.105 | _0.123_ | 0.0870 | _0.0190_ | _0.667_ | 13.6 |
| SceneBound (ours) | 0.033 | 0.071 | 0.104 | 0.122 | 0.0831 | 0.0189 | 0.666 | 13.3 |
Table 16. Camera pose on the long-sequence benchmark of 61 sequences, with the cost of each rule: the update budget in the state and the GPU memory, less the stored input frames, in the cache. ATE (m) ↓; RPE ↓.
InfiniteVGGT (commit 7f9a5a26) holds at most 1,200,000 tokens over the 24 global layers and shares them among the layers by the diversity of their keys. OVGGT (commit 43304e42) caps the cache at 200,000 tokens and 384 in the camera head, evicts by the size of the residual update of each token and its diversity, retains the first frame and protects up to three anchor frames. FrameVGGT (commit 7e76cfbf) stores two recent frames, 16 middle frames chosen to be complementary in key space and up to 64 anchors, with the memory setting of its released pose evaluation. Since five benchmark sequences fill the released buffer, we size the token buffer of our runner for the frames that this setting retains. XStreamVGGT (commit 3ec1d8d6) keeps, in every global layer, the first frame, the current frame and the tokens between whose keys best match the queries of the frame, up to 2,048 tokens, and prunes the cache of its camera head to the same length. RetrieveVGGT (commit 3b3923cb) runs its released pose evaluation, in which each frame attends to frame 0 and to the earlier frames that segment sampling retrieves by the similarity of their mean key with its mean query, with its pose-aware memory off as released; it keeps the keys and values of every frame in host memory, 98.7 MB per frame. With its pose-aware memory and per-region compression on, at the defaults of its launcher, it reaches 0.1067 on the benchmark (0.053, 0.107, 0.127 and 0.113 per dataset), and SceneBound is lower on 49 of the 61 sequences. This memory files frames in a grid of camera poses and halves the crowded regions every 200 frames, so it thins by the clock: over the nine passes of the revisit sequences it holds 227,710 frames after 6,690 in the first, 3.4 times as many, with a mean peak of 211 GB of host memory, and it ends at 0.080 against 0.069 for SceneBound, which is lower on 13 of the 17 videos (Sec. D.5). We run all four with the constructor of their own pose evaluation on the same checkpoint, crop and evaluator. OVGGT evaluates the poses of InfiniteVGGT in its tbl:S1, and our run agrees with these values within 4% at all five lengths. Our run of OVGGT is 20% to 28% above the same table, because its authors replaced the anchor code of the repository after the paper version and its loader takes 518 by 392 pixels, compared with 518 by 378 in our pose runs of the cache. FrameVGGT reports poses on sequences of up to 300 frames. It processes 0.5 frames per second on the benchmark and 0.24 to 0.42 on the revisit sequences, up to 10.6 hours for one video.
Further results
All runs use one NVIDIA H100 with 80 GB or one H200 and PyTorch 2.8 or 2.9; runs of SceneBound on the two GPUs agree to five digits.
Each dataset of the benchmark
Table 16 lists the mean ATE of every rule on each dataset of the long-sequence benchmark, with the relative pose error (RPE) between consecutive frames and the cost, and adds the constructed baselines and SceneBound with the camera head of StreamVGGT kept whole. Over the 61 sequences, Info3R in full, the Info3R gate and AFG-Pose reach 1.10, 1.12 and 1.18 times the mean ATE of SceneBound in the state, with paired resampling intervals of 0.99 to 1.24, 1.04 to 1.21 and 1.08 to 1.30 as in Table 3, and RetrieveVGGT reaches 1.23 times in the cache, 1.07 to 1.39. On 7-Scenes and Neural RGB-D, AFG-Pose and the Info3R gate are 1% and 3% below SceneBound in the state through three of the 27 sequences, and in the cache RetrieveVGGT is lower on Neural RGB-D through one kitchen. The relative pose error of SceneBound between consecutive frames is 1.7 cm, against 1.5 cm for CUT3R and 1.0 cm for TTT3R with reset. Thirteen Bonn sequences change the scene during recording as a person places, removes, moves or carries a box past the camera. On these sequences, SceneBound writes 3 to 24 frames per sequence and keeps views from before the change, reaching 0.085 against 0.094 for the gate of Info3R, 0.106 for AFG-Pose and 0.096 for a full update every 50 frames, with a lower error than the two gates on 11 and 12 of the 13 sequences and than the interval on eight.
Table 17 lists the recurrent state on the revisit sequences, the long sequences, the held-out data and the point clouds with the constructed baselines beside the published rules.
| Method | Revisions ATE ↓ | Revisions Budget ↓ | Long sequences, ATE ↓ Concat., 6 | Long sequences, ATE ↓ TUM, 12 | Long sequences, ATE ↓ KITTI, 11 | Held out, ATE ↓ Replica, 8 | Held out, ATE ↓ EuRoC, 11 | Held out, ATE ↓ ETH3D, 61 | Held out, ATE ↓ TUM, 19 | Point cloud, Acc. ↓ 7-Scenes, 18 | Point cloud, Acc. ↓ NRGBD, 9 |
| CUT3R [77] | 0.815 | 196,518 | 0.736 | 1.223 | 193.4 | 0.968 | 3.027 | 0.948 | 0.952 | 0.257 | 0.397 |
| AFG-Pose‡ [58] | 0.134 | 5,304 | 0.142 | 0.766 | 175.6 | 0.206 | 1.245 | 0.628 | 0.183 | 0.029 | 0.085 |
| Info3R‡ [4], gate | _0.124_ | 7,642 | 0.228 | 0.772 | 176.7 | _0.152_ | 1.743 | 0.604 | 0.182 | 0.026 | 0.085 |
| Info3R‡, in full | 0.252 | 7,618 | 0.145 | 0.445 | 72.3 | 0.156 | 2.053 | 0.535 | 0.195 | 0.026 | _0.084_ |
| TTT3R [14] with reset | 0.573 | 68,399 | 0.478 | _0.449_ | _61.7_ | 0.353 | 2.261 | _0.525_ | 0.230 | 0.085 | 0.139 |
| Every 50 frames† | 0.130 | _3,936_ | 0.142 | 0.735 | _175.8_ | 0.142 | _1.301_ | 0.672 | 0.178 | 0.024 | 0.077 |
| SceneBound, one state | 0.084 | 698 | 0.138 | 0.713 | 177.2 | 0.184 | 1.780 | 0.583 | 0.169 | _0.025_ | 0.086 |
| SceneBound (ours) | 0.084 | 698 | _0.139_ | 0.503 | 50.7 | 0.181 | 2.140 | 0.492 | 0.127 | 0.026 | 0.086 |
Table 17. Mean ATE (m) in the recurrent state on the revisit sequences over nine passes, with the update budget, on long sequences and on held-out data, with the number of sequences, and accuracy error (m) of point clouds fused from the first 1,000 frames of benchmark sequences.
Protocol and published values
We run all rules of the recurrent state through one evaluator, the pose, depth and reconstruction scripts of the CUT3R release as packaged with ReCal3R, at 512 pixels and stride 1, with at most 1,000 frames on the long-sequence benchmark and at full length elsewhere. The checkpoint, the preprocessing, the frames and the alignment of the metric are identical across rows, and inference is deterministic. On the full-length TUM RGB-D sequences, all RGB frames are fed to the model and the frames with a true pose within 20 ms are scored. For KITTI, we use the grey left camera of the odometry benchmark, staged from a public mirror and checked against the official archive.
Rows with official code reproduce the published values within 13% and OVGGТ within 22%, for the reasons in Sec. C.5 (Table 18). Table 19 sets SceneBound beside the values that published methods report on TUM-dynamics at 1,000 frames, trained ones included.
| Rule | Set | Ours | Published | Source |
| CUT3R [77] | TUM-dynamics, 1,000 frames | 0.161 | 0.173 | TTT3R, Table 5 |
| TTT3R [14] | TUM-dynamics, 1,000 frames | 0.115 | 0.106 | TTT3R, Table 5 |
| CUT3R with reset | TUM-dynamics, 1,000 frames | 0.121 | 0.126 | TTT3R, Table 2 |
| TTT3R with reset | TUM-dynamics, 1,000 frames | 0.096 | 0.093 | TTT3R, Table 5 |
| TTSA3R [93] | TUM-dynamics, 1,000 frames | 0.093 | 0.092 | TTSA3R, supplement |
| ReCal3R [42] | TUM-dynamics, 1,000 frames | 0.067 | 0.077 | ReCal3R, Table 2 |
| AFG-Pose [58], our implementation | TUM-dynamics, 1,000 frames | 0.055 | 0.054 | AFG, Table 11 |
| Info3R [4] in full, our implementation | TUM-dynamics, 1,000 frames | 0.056 | 0.061 | Info3R, Table II |
| CUT3R with reset | KITTI 02–10 | 85.9 | 80.8 | AFG, Table 1 |
| TTT3R with reset | KITTI 02–10 | 56.0 | 59.2 | AFG, Table 1 |
| AFG-Pose with reset, our implementation | KITTI 02–10 | 57.6 | 36.2 | AFG, Table 1 |
| Info3R in full, our implementation | KITTI 02–10 | 62.7 | 23.1 | Info3R, Table I |
| InfiniteVGGT [89] | TUM-dynamics, 1,000 frames | 0.067 | 0.066 | OVGGT, Table S1 |
| OVGGT [51] | TUM-dynamics, 1,000 frames | 0.071 | 0.058 | OVGGT, Table S1 |
| RegVGGT [54] at 1% of keys, scored as its release scores | TUM-dynamics, 1,000 frames | 0.135 | 0.135 | RegVGGT, Table 1 |
Table 18. Our runs compared with the published values of the same rule.
FILT3R reports 0.057 on TUM-dynamics at 800 frames, our port obtains 0.074 at 1,000, and MeMix and AFG-Img report no value at 1,000 frames. Since AFG-Pose and Info3R have no released code, we implement their equations, and our implementations agree with the papers on TUM-dynamics. On KITTI, our AFG-Pose with the periodic reset of TTT3R is within 20% of the paper on six of the 11 sequences, and our Info3R with the constants its paper specifies for driving is above the published value on 10 of the 11 sequences, with 72.3 against 30.5 m in the mean. The releases of CUT3R and TTT3R with reset, run on the same grey frames, lie within 7% of the values that AFG reports for them on drives 02 to 10, so the camera changes little for the model, and the gap lies with the two implementations. MeMix, the two AFG gates and BAT3R scale the token gain of TTT3R by a mask, a frame gain or further factors, and five of the nine gates therefore share that token signal. RayMap3R resets its state at intervals of 100 frames and smooths the output translation, and the similarity alignment of its resets calls an unimported function, so in the release each segment of 100 frames keeps its own coordinate frame. Our runs import this function; as released, RayMap3R reaches 0.3797 on the benchmark against 0.1699 with the function imported. The gate of BAT3R needs an untrained network that the CUT3R checkpoint lacks, and its release therefore draws this network afresh in each process. Our port fixes draw 0, which yields 0.069 on TUM-dynamics, compared with 0.157 and 0.143 for draws 1 and 2. With full updates at a fixed interval after an opening window, we reproduce the published TTT3R baseline rows at intervals of 100 and 150 within 15%; the published row at an interval of 50 is 0.150 and ours is 0.090.
KITTI
Table 20 reports all rules on the 11 sequences. Systems trained for long sequences, or equipped with a back end and loop closure, report lower errors on the 11 sequences, 25.4 m for LoGeR [90], 19.8 for Horizon-Stream [17], 18.3 for ABoT-ReCon [29] and 13.1 for AMB3R-SLAM [74]. Chunked systems on a frozen VGGT align chunks after the fact and report 26.4 m for VGGT-Long [20], 24.1 for LingBot-Map [13] and 12.8 for CLoSeR [41].
TUM RGB-D and concatenated rooms
Table 21 reports all rules on each of the 19 sequences. The concatenated rooms are revisits along new paths. Summed over the six rooms, the first sequences store 107 keyframes, 17.8 per sequence, and the 21 later sequences 401 with submaps, 19.1 per sequence. Of the keyframes of later sequences, 4.0% are within of a keyframe of an earlier sequence in true pose, and the median distance to the nearest earlier keyframe is 0.57 in true and 0.54 in predicted pose. A later sequence therefore views the room from new poses, and the rule stores those views.
| Sequence | CUT3R | TTT3R | AFG-Pose‡ | Info3R‡ in full | With reset CUT3R | With reset TTT3R | Every 50† | One state | Ours | Radius of 1 |
| fr1 360 (dev) | 0.190 | 0.181 | 0.182 | 0.127 | 0.178 | 0.105 | 0.172 | 0.144 | 0.103 | 0.065 |
| fr1 desk (dev) | 0.732 | 0.367 | 0.057 | 0.095 | 0.151 | 0.111 | 0.054 | 0.095 | 0.050 | 0.076 |
| fr1 desk2 (dev) | 0.713 | 0.188 | 0.119 | 0.271 | 0.405 | 0.133 | 0.132 | 0.155 | 0.120 | 0.101 |
| fr1 room (dev) | 0.995 | 0.623 | 0.461 | 0.162 | 0.380 | 0.235 | 0.206 | 0.333 | 0.244 | 0.215 |
| fr2 desk (dev) | 1.580 | 1.606 | 0.065 | 0.172 | 0.632 | 0.329 | 0.060 | 0.058 | 0.056 | 0.117 |
| fr2 xyz (dev) | 0.278 | 0.245 | 0.021 | 0.018 | 0.333 | 0.249 | 0.017 | 0.010 | 0.010 | 0.011 |
| fr3 long office (dev) | 1.809 | 1.766 | 0.118 | 0.280 | 0.258 | 0.278 | 0.103 | 0.168 | 0.202 | 0.173 |
| fr1 floor | 0.726 | 0.569 | 0.456 | 0.235 | 0.342 | 0.267 | 0.214 | 0.106 | 0.109 | 0.086 |
| fr1 rpy | 0.051 | 0.061 | 0.057 | 0.055 | 0.056 | 0.054 | 0.060 | 0.049 | 0.049 | 0.041 |
| fr1 xyz | 0.147 | 0.090 | 0.030 | 0.023 | 0.088 | 0.081 | 0.021 | 0.020 | 0.020 | 0.020 |
| fr2 360 hemisphere | 1.113 | 0.963 | 0.656 | 0.433 | 0.696 | 0.419 | 0.748 | 0.852 | 0.825 | 0.353 |
| fr2 360 kidnap | 1.598 | 1.661 | 1.492 | 1.036 | 1.385 | 0.500 | 1.144 | 1.617 | 1.610 | 1.316 |
| fr2 large no loop | 1.949 | 0.913 | 0.587 | 0.179 | 0.770 | 0.949 | 1.752 | 0.710 | 0.438 | 0.685 |
| fr2 large with loop | 1.484 | 1.271 | 1.217 | 1.048 | 1.019 | 0.945 | 1.435 | 1.254 | 0.615 | 0.863 |
| fr2 pioneer 360 | 1.795 | 0.947 | 0.905 | 0.564 | 0.555 | 0.360 | 0.458 | 0.831 | 0.462 | 0.882 |
| fr2 pioneer slam | 1.930 | 1.358 | 1.276 | 0.953 | 1.668 | 0.900 | 0.588 | 1.073 | 1.003 | 0.894 |
| fr2 pioneer slam2 | 1.823 | 1.097 | 1.478 | 0.479 | 0.762 | 0.460 | 1.521 | 1.051 | 0.420 | 0.817 |
| fr2 pioneer slam3 | 1.979 | 1.825 | 0.975 | 0.283 | 0.557 | 0.385 | 0.824 | 0.948 | 0.443 | 0.552 |
| fr2 rpy | 0.079 | 0.070 | 0.061 | 0.055 | 0.065 | 0.071 | 0.050 | 0.042 | 0.042 | 0.041 |
| Mean of the 12 others | 1.223 | 0.902 | 0.766 | 0.445 | 0.664 | 0.449 | 0.735 | 0.713 | 0.503 | 0.546 |
| Geometric mean of the 12 | 0.742 | 0.564 | 0.442 | 0.261 | 0.423 | 0.313 | 0.382 | 0.359 | 0.268 | 0.284 |
| Mean of the 19 | 1.104 | 0.832 | 0.538 | 0.340 | 0.542 | 0.360 | 0.503 | 0.501 | 0.359 | 0.385 |
Table 21. Full-length TUM RGB-D sequences, ATE (m) per sequence; dev marks the seven sequences that selected the threshold.
Revisit sequences
On the 17 revisit sequences whose first pass is a benchmark sequence, one state writes 412 views in the first pass and 430 in all nine, and on 12 of the eight further passes add no write. For these sequences, uniform sampling of the same writes yields 0.088 and a constant gain of the same budget 0.082, compared with 0.078 for the rule, and on all 24 the rule reaches 0.084 against 0.124 for the best gate, and most of the lead of the rule over the gates is therefore a lead of its budget, which the baselines receive as an input and the rule finds online. In the cache, SceneBound retains 426 frames in the first passes and 450 over all nine, no growth on 13 of the 17 sequences and at most 27% (Table 22 and Table 23). Spreading the same 450 frames uniformly over the nine passes requires the final count and length in advance, and it holds 0.112 after the first pass against 0.080 for SceneBound, and 0.076 over all nine against 0.069, above SceneBound on 13 of the 17 sequences at the same memory and equal on the two static scenes where both keep the first frame alone. Played once, the same sequences give 0.076 for uniform
| Method | Setting | ATE (m) ↓ 1 pass | ATE (m) ↓ 9 passes | GPU (GB) ↓ 9 passes |
| RegVGGT [54] | 1% of keys | 0.131 | 0.129 | 15.2 |
| RegVGGT | 10% of keys | 0.124 | 0.138 | 52.6 |
| InfiniteVGGT [89] | 1.2M tokens | 0.125 | 0.335 | 18.1 |
| OVGGT [51] | 0.2M tokens | 0.141 | 0.166 | 8.9 |
| GHOST [12] | 1.2M tokens | 0.194 | 0.768 | 18.6 |
| FrameVGGT [85] | ≤82 frames | 0.093 | 0.077 | 33.1 |
| RetrieveVGGT [96] | pose-aware | 0.085 | 0.080 | 15.6§ |
| Every 50 frames† | 2.0% of frames | 0.081 | 0.067 | 49.6 |
| Uniform sampling† | 2.8% of frames | 0.076 | 0.076 | 14.7 |
| SceneBound (ours) | 2.8% of frames | 0.080 | 0.069 | 14.8 |
Table 22. The KV cache of StreamVGGT on the 17 revisit sequences after one pass and after all nine, with the setting that bounds each cache. †Constructed baseline. §Plus 211 GB of host memory.
| Video | Frames | Kept | RegVGGT, 10% | InfiniteVGGT | OV GGT | FrameVGGT | Every 50† | SceneBound |
| NRGBD breakfast room | 9,000 | 43, 49 | 0.190 | 0.494 | 0.278 | 0.042 | 0.050 | 0.215 |
| NRGBD complete kitchen | 9,000 | 49, 62 | 0.415 | 0.717 | 0.201 | 0.219 | 0.206 | 0.180 |
| NRGBD green room | 9,000 | 25, 25 | 0.120 | 0.578 | 0.210 | 0.060 | 0.052 | 0.043 |
| NRGBD grey-white room | 9,000 | 25, 29 | 0.460 | 1.033 | 0.494 | 0.146 | 0.154 | 0.148 |
| NRGBD kitchen | 9,000 | 41, 41 | 0.307 | 0.707 | 0.322 | 0.170 | 0.142 | 0.133 |
| NRGBD morning apartment | 8,280 | 28, 28 | 0.055 | 0.322 | 0.147 | 0.077 | 0.045 | 0.036 |
| NRGBD staircase | 9,000 | 42, 42 | 0.150 | 0.327 | 0.147 | 0.074 | 0.083 | 0.062 |
| NRGBD thin geometry | 3,555 | 18, 19 | 0.097 | 0.096 | 0.093 | 0.059 | 0.075 | 0.070 |
| NRGBD whiteroom | 9,000 | 39, 39 | 0.127 | 0.452 | 0.205 | 0.085 | 0.072 | 0.065 |
| TUM-dyn sitting halfsphere | 9,000 | 28, 28 | 0.097 | 0.181 | 0.104 | 0.085 | 0.038 | 0.037 |
| TUM-dyn sitting rpy | 7,353 | 20, 20 | 0.033 | 0.058 | 0.044 | 0.027 | 0.021 | 0.021 |
| TUM-dyn sitting static | 6,327 | 1, 1 | 0.015 | 0.038 | 0.031 | 0.012 | 0.018 | 0.012 |
| TUM-dyn sitting xyz | 9,000 | 6, 6 | 0.038 | 0.092 | 0.073 | 0.031 | 0.025 | 0.022 |
| TUM-dyn walking halfsphere | 9,000 | 28, 28 | 0.099 | 0.274 | 0.208 | 0.097 | 0.060 | 0.043 |
| TUM-dyn walking rpy | 8,154 | 24, 24 | 0.060 | 0.147 | 0.140 | 0.049 | 0.044 | 0.039 |
| TUM-dyn walking static | 6,660 | 1, 1 | 0.019 | 0.025 | 0.022 | 0.016 | 0.018 | 0.015 |
| TUM-dyn walking xyz | 7,713 | 8, 8 | 0.066 | 0.152 | 0.102 | 0.058 | 0.033 | 0.026 |
| Mean | 0.138 | 0.335 | 0.166 | 0.077 | 0.067 | 0.069 |
Table 23. All revisit sequences in the KV cache, with the frames that SceneBound retains after one and nine passes and the ATE (m) of each method; every 50 frames† and SceneBound prune the camera head.
sampling of SceneBound’s count, so the count sets the error of a single pass, and placing keyframes by place lowers it by 10% once the camera returns. Each later pass reads the stored views because it receives their poses again (Figure 7): the predicted pose of a frame in passes 2 to 9 lies at a median distance of 0.019 from that of the same image in pass 1 under SceneBound, flat from the second pass, against 0.047 under RegVGGT at 10% of keys, 0.078 under OVGGT and 0.210 under InfiniteVGGT, whose share within falls from 85% in pass 2 to 57% in pass 9 as it drops the views of the first passes.
Figure 7. Nine passes over the revisit sequences in the KV cache of StreamVGGT. (a) Predicted camera centres on the complete kitchen of Neural RGB-D from above, from the first pass (light) to the ninth (dark). (b) Frames of each later pass within of the pose predicted for the same image in pass 1, over the 17 sequences.
Table 19. TUM-dynamics at 1,000 frames, published values beside SceneBound, ATE (m).
The radius of SceneBound was chosen on these eight sequences, and radii from 0.25 to 0.35 give 0.048 to 0.050 in the state.
Held-out sets
EuRoC [7] comprises the 11 sequences MH 01 to V2 03 of the left grey camera at 752 by 480 pixels and 20 Hz, ETH3D SLAM [60] the 61 training sequences with public ground truth, and the TUM set all TUM RGB-D sequences with public ground truth in the categories Structure vs. Texture, Dynamic Objects and 3D Object Reconstruction that no earlier result of this work used, excluding the calibration sequences. We froze the inputs of each set before any method ran, and each method ran once with the settings of § 4.1. SceneBound achieves a lower error than TTT3R with reset on six of the 11 EuRoC sequences, 40 of the 61 ETH3D sequences and 18 of the 19 TUM sequences, and a lower error than CUT3R and TTT3R on nine and six of 11, 50 and 50 of 61 and all 19. Its submaps lower the error of one state on ETH3D and the TUM set and raise it on EuRoC (Table 17).
ZipMap and STream3R
ZipMap [32] runs its streaming checkpoint (checkpoint_online.pt of coast01/ZipMap at 71e449db, source e0ef1f400) with its online window of one frame, Muon-normalised updates of the fast weights and the camera of its MLP head, in the RegVGGT evaluator with the release’s image loader. We read one frame per call with the fast weights of every global block carried; with every frame kept this reproduces the release’s online pass to in a behavioural check with the released
| Rule | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | All | 02–10 |
| CUT3R [77] | 188.5 | 672.9 | 282.1 | 46.9 | 16.3 | 151.1 | 132.2 | 72.6 | 231.0 | 199.9 | 133.6 | 193.4 | 140.6 |
| TTT3R [14] | 189.4 | 556.0 | 259.7 | 51.3 | 9.2 | 115.8 | 134.9 | 68.9 | 261.2 | 180.6 | 119.5 | 177.0 | 133.5 |
| AFG-Pose‡ [58] | 180.4 | 584.7 | 259.3 | 19.3 | 7.8 | 93.6 | 105.4 | 79.3 | 238.1 | 155.8 | 208.1 | 175.6 | 129.6 |
| Every 50 frames† | 170.5 | 578.7 | 245.9 | 82.5 | 8.9 | 152.6 | 99.2 | 86.9 | 233.5 | 193.7 | 81.2 | 175.8 | 131.6 |
| SceneBound, one state | 188.0 | 529.9 | 275.6 | 56.9 | 12.3 | 115.8 | 136.1 | 73.2 | 232.6 | 191.2 | 137.2 | 177.2 | 136.8 |
| CUT3R with reset | 189.4 | 123.5 | 271.3 | 18.5 | 7.8 | 88.9 | 59.2 | 25.8 | 152.2 | 124.9 | 24.2 | 98.7 | 85.9 |
| TTT3R with reset | 76.6 | 98.4 | 216.5 | 14.0 | 3.6 | 30.7 | 34.7 | 11.0 | 87.5 | 76.6 | 29.4 | 61.7 | 56.0 |
| TTT3R with reset every 50 frames | 70.4 | 89.4 | 121.8 | 11.0 | 2.3 | 42.6 | 20.7 | 12.0 | 50.1 | 42.9 | 31.4 | 45.0 | 37.2 |
| TTT3R with reset every 30 frames | 79.4 | 107.5 | 91.5 | 11.4 | 2.9 | 48.9 | 28.2 | 14.3 | 50.3 | 36.3 | 22.6 | 44.9 | 34.1 |
| AFG-Pose‡ with reset | 54.0 | 90.9 | 265.0 | 13.2 | 3.5 | 36.8 | 35.8 | 20.3 | 60.5 | 54.4 | 28.9 | 60.3 | 57.6 |
| Info3R‡ [4], gate with reset | 69.1 | 124.4 | 173.7 | 16.3 | 3.6 | 51.4 | 45.4 | 18.9 | 78.8 | 65.3 | 32.0 | 61.7 | 53.9 |
| Info3R‡, in full, driving constants | 68.0 | 162.6 | 143.1 | 14.6 | 5.3 | 87.9 | 44.6 | 25.0 | 110.0 | 102.9 | 31.5 | 72.3 | 62.7 |
| SceneBound (ours) | 36.4 | 89.5 | 159.2 | 19.6 | 3.5 | 31.2 | 79.5 | 5.6 | 52.0 | 52.2 | 29.2 | 50.7 | 48.0 |
| SceneBound, reset every 60 frames | 55.6 | 104.1 | 164.2 | 9.7 | 3.2 | 28.1 | 25.2 | 10.1 | 38.1 | 52.7 | 20.0 | 46.5 | 39.0 |
| SceneBound, reset every 30 frames | 91.7 | 107.4 | 130.3 | 7.6 | 2.3 | 26.8 | 14.3 | 7.7 | 37.3 | 35.5 | 16.5 | 43.4 | 30.9 |
| Radius of 1 | 82.5 | 117.5 | 132.4 | 7.2 | 1.6 | 49.1 | 14.6 | 16.0 | 36.2 | 59.7 | 18.7 | 48.7 | 37.3 |
| Drift check, submaps dropped | 59.4 | 105.7 | 141.9 | 21.3 | 3.5 | 23.8 | 45.3 | 5.6 | 46.7 | 52.2 | 28.3 | 48.5 | 41.0 |
| Evenly spaced, submaps dropped | 44.9 | 94.0 | 118.0 | 12.7 | 3.5 | 19.9 | 30.7 | 6.8 | 38.1 | 48.3 | 13.1 | 39.1 | 32.4 |
| Radius of 1 with a return under drift | 148.3 | 118.1 | 248.5 | 7.2 | 1.6 | 29.6 | 17.7 | 16.0 | 42.4 | 58.4 | 16.7 | 64.0 | 48.7 |
| Info3R, reported | 30.0 | 97.2 | 86.6 | 9.1 | 6.3 | 23.6 | 11.2 | 7.6 | 30.0 | 22.9 | 10.8 | 30.5 | 23.1 |
| AFG-Pose, reported | 72.2 | 85.5 | 119.0 | 12.1 | 6.5 | 35.2 | 30.1 | 17.4 | 45.9 | 28.6 | 31.1 | 44.0 | 36.2 |
| TTT3R with reset, reported | 118.2 | 103.0 | 242.1 | 14.4 | 4.5 | 31.6 | 37.8 | 12.0 | 81.5 | 79.1 | 29.8 | 68.5 | 59.2 |
| CUT3R with reset, reported | 190.4 | 90.6 | 264.4 | 20.4 | 7.3 | 92.2 | 67.5 | 22.5 | 145.1 | 67.4 | 40.0 | 91.6 | 80.8 |
| LongStream [16], reported, trained | 92.5 | 46.0 | 134.7 | 3.8 | 1.9 | 84.7 | 23.1 | 14.9 | 62.1 | 85.6 | 21.5 | 51.9 | 48.0 |
Table 20. KITTI odometry at full length. Reported rows list the published values of each paper, obtained with the colour camera, and are left unmarked. ATE (m) per sequence ↓. Mean ↓.
†Constructed baseline. ‡Our implementation of a method without released code.
Ours is SceneBound; one state and a radius of 1 are its variants. †Constructed baseline. ‡Our implementation of a method without released code.
model code. A frame that SceneBound or a fixed interval skips returns the fast weights to their values before it, and under such a rule each frame’s pose equals that of an online pass over the kept frames before it and the frame itself. To measure the drift of the fast weights, frame 0 is read again after 100 to 500 frames with a forward pass through every block that applies the fast weights and leaves them unchanged. STream3R [37] runs its causal streaming session (7bdca8cf, weights 0af188b4); a frame that leaves the cache leaves the keys and values of every global attention layer and of the camera head. Its whole cache fills the 80 GB GPU at frame 473, and the six sequences shorter than 473 frames complete. Over the nine passes of the 17 revisit sequences, SceneBound keeps 404 frames after the first passes and 408 after all nine in ZipMap and 410 and 411 in STream3R, against 311 and 2,766 for every 50 frames in both. Table 24 lists every rule per dataset.
| Model | Rule | TUM-dyn | Bonn | 7-Scenes | NRGBD | Mean | Trans. (m) | Rot. (°) | Cost |
| ZipMap [32] | Every frame, as released | 0.205 | 0.355 | 0.675 | 1.439 | 0.5897 | 0.0514 | 7.294 | 51,256 |
| Every 5 frames† | 0.130 | 0.200 | 0.367 | 0.880 | 0.3406 | 0.0448 | 2.815 | 10,262 | |
| Every 10 frames† | 0.062 | 0.112 | 0.161 | 0.502 | 0.1774 | 0.0391 | 1.396 | 5,137 | |
| Every 25 frames† | 0.041 | 0.080 | 0.092 | 0.119 | 0.0841 | 0.0291 | 0.854 | 2,065 | |
| Every 50 frames† | 0.040 | 0.086 | 0.087 | 0.103 | 0.0827 | 0.0306 | 0.843 | 1,039 | |
| Every 100 frames† | 0.043 | 0.117 | 0.100 | 0.101 | 0.0998 | 0.0344 | 1.408 | 526 | |
| Every 200 frames† | 0.044 | 0.155 | 0.178 | 0.156 | 0.1473 | 0.0509 | 3.258 | 269 | |
| Uniform sampling† | 0.041 | 0.079 | 0.095 | 0.111 | 0.0837 | 0.0293 | 0.858 | 1,437 | |
| SceneBound (ours) | 0.045 | 0.081 | 0.102 | 0.127 | 0.0890 | 0.0295 | 0.843 | 1,437 | |
| STream3R [37] | Every 10 frames† | 0.037 | 0.088 | 0.095 | 0.067 | 0.0800 | 0.0203 | 0.778 | 20.7 |
| Every 25 frames† | 0.034 | 0.086 | 0.092 | 0.056 | 0.0763 | 0.0221 | 0.981 | 12.7 | |
| Every 50 frames† | 0.032 | 0.091 | 0.092 | 0.052 | 0.0776 | 0.0248 | 1.051 | 10.1 | |
| Every 100 frames† | 0.033 | 0.117 | 0.104 | 0.052 | 0.0925 | 0.0274 | 1.506 | 8.8 | |
| Every 200 frames† | 0.036 | 0.167 | 0.205 | 0.069 | 0.1462 | 0.0507 | 3.648 | 8.1 | |
| Uniform sampling† | 0.034 | 0.089 | 0.090 | 0.055 | 0.0769 | 0.0238 | 0.917 | 11.1 | |
| SceneBound (ours) | 0.033 | 0.081 | 0.094 | 0.058 | 0.0751 | 0.0211 | 0.793 | 11.1 |
Table 24. ZipMap and STream3R on the 61 benchmark sequences, ATE (m) per dataset, RPE and cost: the frames written into the fast weights of ZipMap, summed over the sequences, and the peak GPU memory (GB) of STream3R.
Frame rate
We feed the first 1,000 frames of each benchmark sequence to all four models at every first, second, fourth and eighth frame, so that the camera visits the same poses in 1,000, 500, 250 and 125 frames, and every constant stays as it is. Table 25 lists the frames written and the mean ATE of each rule, and Figure 2f plots the error relative to every frame. At every frame, the runs give the values of Table 16 for SceneBound, AFG-Pose and the gate of Info3R. In all four models, SceneBound writes 14% to 16% fewer frames at every eighth frame, since a coarser sampling of the same path offers the keyframe test fewer poses, and its error changes by −6% to +3%. Per dataset, the cache of StreamVGGT holds SceneBound within 0.003 of its error at every frame on each of the four at every stride, and in the state every rule rises on TUM-dynamics, whose scenes hold walking people, at every eighth frame, SceneBound from 0.048 to 0.073 and AFG-Pose from 0.055 to 0.088, and SceneBound stays within 0.004 on the other three datasets. A fixed interval of 50 frames writes in proportion to the frames fed, and at every eighth frame it writes about three frames per sequence and has 2.1 to 2.6 times its error at every frame in the four models. The gates read the change from the previous frame, which grows with the step: AFG-Pose writes half its budget at every eighth frame and its error rises by 12%, and the gate of Info3R writes 39% less and its error falls by 6%, toward the minimum of the curve in Figure 2b. A fixed time interval writes every 25, 12 and 6 input frames at strides 2, 4 and 8, every 48 to 50 frames of video, and holds its count at 1,039 to 1,089. In the state it reaches 0.0863, 0.0813 and 0.0811 against 0.0812, 0.0800 and 0.0821 for SceneBound, and in the cache 0.0865, 0.0859 and 0.0855 against 0.0823, 0.0827 and 0.0819, keeping 1,039, 1,089 and 1,089 frames against 1,395, 1,322 and 1,216. Its point clouds at every eighth frame reach 0.027 and 0.079 m in the state and 0.044 and 0.073 m in the cache on 7-Scenes and Neural RGB-D, within 6% of SceneBound. A fixed time interval thus follows the frame rate as SceneBound does; it reads the frame rate of the video, and on the revisit sequences it writes on every pass (Table 22).
| Frames written | Mean ATE (m) ↓ | |||||||
| Stride | 1 | 2 | 4 | 8 | 1 | 2 | 4 | 8 |
| Recurrent state of CUT3R | ||||||||
| SceneBound (ours) | 1,423 | 1,379 | 1,325 | 1,220 | 0.080 | 0.081 | 0.080 | 0.082 |
| Every 50 frames† | 1,039 | 526 | 269 | 160 | 0.084 | 0.096 | 0.147 | 0.187 |
| Fixed time interval† | 1,039 | 1,039 | 1,089 | 1,089 | 0.084 | 0.084 | 0.081 | 0.081 |
| AFG-Pose‡ [58] | 1,390 | 935 | 743 | 694 | 0.095 | 0.099 | 0.103 | 0.107 |
| Info3R‡, gate | 2,901 | 2,717 | 2,312 | 1,756 | 0.090 | 0.089 | 0.087 | 0.085 |
| KV cache of StreamVGGT | ||||||||
| SceneBound (ours) | 1,433 | 1,395 | 1,322 | 1,216 | 0.083 | 0.082 | 0.083 | 0.082 |
| Every 50 frames† | 1,039 | 526 | 269 | 160 | 0.086 | 0.101 | 0.159 | 0.182 |
| Fixed time interval† | 1,039 | 1,039 | 1,089 | 1,089 | 0.086 | 0.086 | 0.086 | 0.086 |
| KV cache of STream3R | ||||||||
| SceneBound (ours) | 1,435 | 1,392 | 1,329 | 1,235 | 0.075 | 0.076 | 0.079 | 0.078 |
| Every 50 frames† | 1,039 | 526 | 269 | 160 | 0.078 | 0.092 | 0.146 | 0.180 |
| Fast weights of ZipMap | ||||||||
| SceneBound (ours) | 1,437 | 1,394 | 1,326 | 1,211 | 0.089 | 0.086 | 0.086 | 0.084 |
| Every 50 frames† | 1,039 | 526 | 269 | 160 | 0.083 | 0.100 | 0.146 | 0.215 |
Table 25. The benchmark at four strides: frames written, summed over the 61 sequences, and mean ATE (m). The fixed time interval writes every 50, 25, 12 and 6 input frames.
Replica and video depth
On Replica, a full update every 50 frames achieves the lowest mean, 0.142, followed by the gate of Info3R, 0.152, and SceneBound obtains 0.181 (Table 26). Its error is lower than that of CUT3R, six gates and both reset baselines on all eight scenes, than that of AFG-Pose on six, than that of the gate of Info3R on two and than that of the fixed interval on one. SceneBound opens nine submaps beyond the first on the eight scenes and is 1.3% below one state.
| Rule | room0 | room1 | room2 | office0 | office1 | office2 | office3 | office4 | Mean | Trans. (m) | Rot. (°) | Budget ↓ |
| CUT3R [77] | 1.023 | 0.926 | 0.905 | 0.819 | 0.423 | 1.189 | 1.387 | 1.074 | 0.9682 | 0.0162 | 2.464 | 15,992 |
| TTT3R [14] | 1.069 | 0.622 | 0.721 | 0.651 | 0.332 | 0.930 | 1.077 | 0.825 | 0.7784 | 0.0157 | 1.569 | 4,967 |
| MeMix [21] | 1.071 | 0.538 | 0.712 | 0.661 | 0.354 | 1.020 | 0.631 | 0.902 | 0.7362 | 0.0168 | 1.701 | 4,534 |
| TTSA3R [93] | 0.580 | 0.525 | 0.617 | 0.529 | 0.311 | 0.651 | 0.620 | 0.578 | 0.5514 | 0.0154 | 1.111 | 3,076 |
| FILT3R [33] | 0.542 | 0.474 | 0.856 | 0.481 | 0.325 | 0.573 | 0.502 | 0.442 | 0.5244 | 0.0166 | 1.995 | 2,509 |
| ReCal3R [42] | 0.528 | 0.444 | 0.517 | 0.792 | 0.307 | 0.557 | 0.362 | 0.402 | 0.4885 | 0.0140 | 0.997 | 1,805 |
| AFG-Img‡[58] | 0.353 | 0.409 | 0.373 | 0.851 | 0.294 | 0.468 | 0.311 | 0.451 | 0.4387 | 0.0145 | 0.783 | 1,399 |
| AFG-Pose‡[58] | 0.168 | 0.261 | 0.160 | 0.246 | 0.260 | 0.200 | 0.103 | 0.251 | 0.2062 | 0.0142 | 0.371 | 393 |
| Info3R‡ [4], gate | 0.132 | 0.245 | 0.113 | 0.182 | 0.212 | 0.102 | 0.073 | 0.160 | 0.1524 | 0.0157 | 1.076 | 283 |
| Info3R‡, in full | 0.132 | 0.277 | 0.113 | 0.182 | 0.212 | 0.102 | 0.073 | 0.160 | 0.1564 | 0.0158 | 1.078 | 283 |
| CUT3R with reset | 0.705 | 0.488 | 0.845 | 0.564 | 0.399 | 1.000 | 0.611 | 1.098 | 0.7138 | 0.0149 | 0.821 | 15,992 |
| TTT3R with reset | 0.346 | 0.344 | 0.420 | 0.382 | 0.363 | 0.380 | 0.274 | 0.319 | 0.3534 | 0.0130 | 0.464 | 5,781 |
| Every 50 frames† | 0.130 | 0.196 | 0.111 | 0.151 | 0.204 | 0.123 | 0.060 | 0.163 | 0.1422 | 0.0152 | 0.513 | 320 |
| SceneBound, one state | 0.159 | 0.275 | 0.164 | 0.160 | 0.195 | 0.241 | 0.088 | 0.188 | 0.1837 | 0.0149 | 0.462 | 604 |
| SceneBound (ours) | 0.161 | 0.246 | 0.188 | 0.162 | 0.176 | 0.241 | 0.088 | 0.188 | 0.1813 | 0.0172 | 0.677 | 612 |
| SceneBound, reset every 60 frames | 0.177 | 0.162 | 0.256 | 0.256 | 0.311 | 0.208 | 0.135 | 0.192 | 0.2120 | 0.0090 | 0.243 | 751 |
| SceneBound, reset every 30 frames | 0.369 | 0.338 | 0.298 | 0.489 | 0.342 | 0.435 | 0.265 | 0.377 | 0.3641 | 0.0088 | 0.280 | 866 |
Table 26. Replica, eight scenes of 2,000 frames held out until all constants were fixed, ATE (m) per scene, RPE and budget.
Video depth over the first 500 frames depends little on the write rule, with an absolute relative error after scale alignment of 0.112 to 0.127 for the seven gates on TUM-dynamics and 0.056 to 0.061 on Bonn, compared with 0.116 and 0.057 for SceneBound.
Point clouds
The reconstruction evaluator of the CUT3R release, as Re-Cal3R packages it, aligns the fused points of all views to the depth of the dataset by scale, median depth and ICP and scores the central 224 by 224 pixels of each view, at 512 by 384 pixels in the state. It encodes all views in one batch, which fills an 80 GB GPU at 1,000 views, so we encode them 32 at a time, which leaves every token unchanged, and keep the maps and views of all frames on the host until they are scored. At 1,000 frames, SceneBound reaches an accuracy error of 0.026 and 0.086 m on 7-Scenes and Neural RGB-D, where CUT3R has 10 and 4.6 times this error and TTT3R 5.6 and 3.1 times (Table 27). A full update every 50 frames, which writes 340 and 167 frames on the two datasets against 696 and 297 for **SceneBound,
Point clouds fused from the first 1,000 frames of the benchmark sequences of 7-Scenes and Neural RGB-D and from every eighth of these frames: accuracy and completion errors (m) and normal consistency.
| Rule | 7-Scenes, 18 | Neural RGB-D, 9 | ||||
| Acc. | Comp. | NC | Acc. | Comp. | NC | |
| Recurrent state of CUT3R, 1,000 frames | ||||||
| CUT3R [77] | 0.2569 | 0.1088 | 0.536 | 0.3965 | 0.2103 | 0.549 |
| TTT3R [14] | 0.1439 | 0.0545 | 0.563 | 0.2713 | 0.1143 | 0.578 |
| TTT3R with reset | 0.0851 | 0.0359 | 0.609 | 0.1385 | 0.0502 | 0.645 |
AFG-Pose{sup}‡ {citep}[58]` | 0.0289 | 0.0228 | 0.619 | 0.0847 | 0.0296 | 0.689 |
Info3R{sup}‡ {citep}[4]`, gate | 0.0255 | 0.0218 | 0.626 | 0.0852 | 0.0344 | 0.671 |
| Info3R{sup}‡`, in full | 0.0255 | 0.0218 | 0.626 | 0.0836 | 0.0341 | 0.677 |
| Every 50 frames{sup}†` | 0.0238 | 0.0211 | 0.630 | 0.0769 | 0.0284 | 0.701 |
| SceneBound, one state | 0.0254 | 0.0226 | 0.629 | 0.0863 | 0.0338 | 0.693 |
| SceneBound (ours) | 0.0258 | 0.0226 | 0.629 | 0.0863 | 0.0338 | 0.693 |
| KV cache of StreamVGGT, 1,000 frames | ||||||
| RegVGGT [54], 10% of keys | 0.0457 | 0.0243 | 0.600 | 0.1100 | 0.0427 | 0.675 |
| InfiniteVGGT [89] | 0.0769 | 0.0413 | 0.610 | 0.0914 | 0.0484 | 0.694 |
| OVGGT [51] | 0.0541 | 0.0259 | 0.605 | 0.0568 | 0.0309 | 0.697 |
| RetrieveVGGT [96] | 0.0470 | 0.0227 | 0.616 | 0.0542 | 0.0339 | 0.722 |
| Every 50 frames{sup}†` | 0.0433 | 0.0244 | 0.643 | 0.0735 | 0.0423 | 0.745 |
| Uniform sampling{sup}†` | 0.0428 | 0.0250 | 0.649 | 0.0691 | 0.0412 | 0.729 |
| SceneBound (ours) | 0.0445 | 0.0253 | 0.648 | 0.0721 | 0.0417 | 0.730 |
| Recurrent state of CUT3R, every eighth frame | ||||||
| CUT3R [77] | 0.0564 | 0.0328 | 0.626 | 0.1375 | 0.0649 | 0.657 |
| TTT3R [14] | 0.0317 | 0.0258 | 0.637 | 0.0884 | 0.0350 | 0.702 |
| TTT3R with reset | 0.0436 | 0.0283 | 0.638 | 0.0928 | 0.0354 | 0.705 |
AFG-Pose{sup}‡ {citep}[58]` | 0.0308 | 0.0238 | 0.639 | 0.0868 | 0.0333 | 0.704 |
Info3R{sup}‡ {citep}[4]`, gate | 0.0269 | 0.0232 | 0.645 | 0.0854 | 0.0356 | 0.703 |
| Info3R{sup}‡`, in full | 0.0269 | 0.0232 | 0.645 | 0.0840 | 0.0353 | 0.704 |
| Every 50 frames{sup}†` | 0.1063 | 0.0357 | 0.625 | 0.0974 | 0.0351 | 0.695 |
| SceneBound, one state | 0.0251 | 0.0235 | 0.649 | 0.0816 | 0.0315 | 0.713 |
| SceneBound (ours) | 0.0251 | 0.0235 | 0.649 | 0.0816 | 0.0315 | 0.713 |
| KV cache of StreamVGGT, every eighth frame | ||||||
| RegVGGT [54], 10% of keys | 0.0434 | 0.0253 | 0.635 | 0.0855 | 0.0435 | 0.698 |
| RetrieveVGGT [96] | 0.0444 | 0.0255 | 0.648 | 0.0840 | 0.0492 | 0.720 |
| Every 50 frames{sup}†` | 0.1163 | 0.0386 | 0.626 | 0.0817 | 0.0428 | 0.705 |
| Uniform sampling{sup}†` | 0.0432 | 0.0269 | 0.662 | 0.0703 | 0.0427 | 0.741 |
| SceneBound (ours) | 0.0452 | 0.0268 | 0.661 | 0.0733 | 0.0431 | 0.741 |
Table 27. †Constructed baseline. ‡Our implementation of a method without released code.
achieves the lowest errors, 0.024 and 0.077 m; the gates of Info3R lie between it and SceneBound on both datasets and that of AFG-Pose on Neural RGB-D, and on 7-Scenes AFG-Pose lies 12% above SceneBound. In the KV cache of StreamVGGT, the views of the same evaluator at 518 by 392 pixels give each rule the world points of its point head. On 7-Scenes, the rules that keep whole frames give the most accurate clouds and the highest normal consistency, 0.043 to 0.045 for SceneBound, every 50 frames and uniform sampling at the count of SceneBound, against 0.046 to 0.077 for RegVGGT, RetrieveVGGT, OV GGT and InfiniteVGGT. On
Neural RGB-D, RetrieveVGGT and OV GGT, which read tokens of every earlier frame, reach 0.054 and 0.057 against 0.072 for SceneBound, and RegVGGT and InfiniteVGGT 0.110 and 0.091. In the cache, the points of a frame thus depend on the tokens it reads more than on the trajectory, which SceneBound sets with 2.8% of the frames (Table 22). From 500 to 1,000 views, the accuracy error of SceneBound in the state grows by 8% and 53% and that of TTT3R doubles; at 200 and 500 views, SceneBound is within 3% of a full update every 50 frames, CUT3R has 2.5 to 7.4 times its error, and on 7-Scenes at 200 views it achieves 0.0198, where
†Constructed baseline. ‡Our implementation of a method without released code.
the cache models Point3R, InfiniteVGGT and OVGGT report 0.041, 0.046 and 0.024. At every eighth of the first 1,000 frames, the input of the frame-rate test of § 4.3, SceneBound in the state achieves the lowest accuracy error of the nine rules on both datasets, 0.025 and 0.082 m, 3% and 5% below its error at 1,000 frames, with 33 and 29 keyframes per sequence. A full update every 50 frames, the lowest at 1,000 frames, writes once every 400 frames of the video and reaches 0.106 and 0.097 m as its pose error grows (Figure 2f). In the cache, SceneBound keeps 32 and 30 frames per sequence and reaches 0.045 and 0.073 m, within 5% of uniform sampling at its count, which needs the count in advance; every 50 frames reaches 2.6 and 1.1 times SceneBound, and RetrieveVGGT, at 0.054 on Neural RGB-D with 1,000 frames, reaches 0.084 there.
The assumptions beside their measurements
We measure each assumption of the theorems on the stored runs (Figure 8).
Figure 8. Measured assumptions of the theorems. (a) The 99th percentile of the step between consecutive poses per sequence. (b) Share of frames within half a radius of the truth. (c) Keyframes versus the covering number.
A read-out that drifts in a fixed direction (Theorem 1 and Proposition A.4). The shift of frame 0 grows with exponent 1.2 in the budget and stays within a factor of 2.4 per unit budget across eight rules (Sec. B.4).
Consecutive poses less than apart (Theorem 3). On each stream, 99.3% to 100% of the steps fall below , and one step exceeds on 13 of the 38 streams.
Covering numbers of the predicted poses (Theorem 2). In the state, , and in the cache, compared with 1,433 keyframes, a ratio of 1.49 to 2.51.
A place receives the same predicted pose on a return (Theorem 2). In the cache, 99.5% of later-pass frames are within of their first-pass pose (Figure 7).
Predicted poses within of the truth (Proposition A.2). This holds for 72% of Replica frames, for nine in ten frames on four of the 19 TUM RGB-D sequences and on no KITTI drive.
The amount stays fixed as the video grows. The revisit sequences take 678 writes in one pass and 698 in nine. Of the 49,823 frames that SceneBound skips on the benchmark, 15.4% are nearest to a keyframe other than the latest one, 33% on TUM-dynamics and 2.6% on Neural RGB-D. The benchmark thus tests exploration, and the revisit sequences test the returns. On the revisit sequences, the covering number of the predicted poses at half the radius grows by 23% from one pass to nine, and the number of writes by 3%. In one state, submaps lower the median distance between predicted and true pose on 13 of the 19 TUM RGB-D sequences and on all 11 KITTI drives, where the median over the drives falls from 9.6 to 1.4.
Limitations
Our analysis covers the recurrent state of two released checkpoints of CUT3R, the fast weights of ZipMap and the KV caches of StreamVGGT and Stream3R. STAC, RetrieveVGGT and OVGGT report that scored retention beats random retention; of the scored caches, we compare only RegVGGT with a signal-free rule at equal budget.
The keyframe test and the drift check act on predicted poses, so their guarantees carry pose accuracy as a condition. A frame whose predicted pose jumps beyond from its predecessor is written as a new view, and on one of the 17 revisit sequences in the cache such writes raise the error of all later passes (Sec. B.5). Every later pass reads these misplaced views, as errors in the experience that a language-model agent distils into skills persist into its later tasks [88]. A first frame that sees the scene closer than the frames after it sets a finer depth unit for the whole video and adds writes (Table 9).
A return finds a stored submap by predicted pose up to an accumulated drift of one keyframe radius, and place recognition on the stored keyframes extends returns beyond this radius. The error of SceneBound on long drives lies in placing its submaps (Table 12); a pose graph whose loops the frozen model confirms by its own reads raises this error (Table 13), so global placement needs a back end with independent place recognition and geometric verification. On KITTI, resets at fixed intervals with SceneBound inside are ahead of SceneBound, and Info3R, with constants set for driving, and AFG-Pose, both without released code, report lower errors. On EuRoC, submaps raise the error compared with one state, and in the second CUT3R checkpoint writes at new views are on par with uniform sampling.
†Constructed baseline. ‡Our implementation of a method without released code.
In the KV cache on Neural RGB-D, RetrieveVGGT and OVGGT, which read tokens of every earlier frame, fuse more accurate clouds than SceneBound (Sec. D.10). SceneBound keeps one state of about 18 MB per submap, so its memory grows with the visited region; a closed submap is read only on a return and can wait in host memory, where each return adds a host-to-device transfer, a cost that lies on the critical path of decoding when mixture-of-experts language models offload their experts [11].
Moving people enter memory as the rest of the scene does, and a stored view stays in memory after the scene it shows has changed; longer-term changes call for a test that retires stored views, as the persistent memory of a language-model agent resolves a new fact that contradicts a stored one [81]. Executing a program renders a video together with the ground-truth answer and time interval of every question about it [94], so a program that changes a scene at known times could supply the ground truth for such a test.
References
- [1]Anonymous. DDD3R: Directional decomposition and dampening for recurrent 3D reconstruction. Submission to the International Conference on Learning Representations (ICLR) 2027, OpenReview I J2r1BfdMJ, 2026. 2
- [2]Anonymous. DiaStream: Distribution-aware KV cache for streaming 3D reconstruction. Submission to the International Conference on Learning Representations (ICLR) 2027, OpenReview Rb1LMtqN7M, 2026. 2
- [3]Dejan Azinovic, Ricardo Martin-Brualla, Dan B. Goldman, Matthias Nießner, and Justus Thies. Neural RGB-D surface reconstruction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 6280–6291, 2022. 6
- [4]Sunghyun Baek, Hanna Bae, Minchan Kwon, and Junmo Kim. Info3R: Information-adaptive test-time training for 3D reconstruction. arXiv preprint arXiv:2609.21938, 2026. 2, 7, 18, 19, 27, 28, 29, 33, 34arxiv.org/abs/2609.21938
- [5]Ali Behrouz, Peilin Zhong, and Vahab Mirrokni. Titans: Learning to memorize at test time. In Advances in Neural Information Processing Systems (NeurIPS), 2025. 2arxiv.org/abs/2501.00663
- [6]Michael Bosse, Paul M. Newman, John J. Leonard, and Seth J. Teller. Simultaneous localization and map building in large-scale cyclic environments using the Atlas framework. The International Journal of Robotics Research, 23(12):1113–1139, 2004. 2, 3, 23DOI
- [7]Michael Burri, Janosch Nikolic, Pascal Gohl, Thomas Schneider, Joern Rehder, Sammy Omari, Markus W. Achtelik, and Roland Siegwart. The EuRoC micro aerial vehicle datasets. The International Journal of Robotics Research, 35(10):1157–1163, 2016. 6, 28DOI
- [8]Yohann Cabon, Lucas Stoffl, Leonid Antsfeld, Gabriela Csurka, Boris Chidlovskii, Jérôme Revaud, and Vincent Leroy. MUSt3R: Multi-view network for stereo 3D reconstruction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 1050–1060, 2025. 2, 3, 8
- [9]Cesar Cadena, Luca Carlone, Henry Carrillo, Yasir Latif, Davide Scaramuzza, José Neira, Ian Reid, and John J. Leonard. Past, present, and future of simultaneous localization and mapping: Toward the robust-perception age. IEEE Transactions on Robotics, 32(6):1309–1332, 2016. 2
- [10]Carlos Campos, Richard Elvira, Juan J. Gómez Rodríguez, José M. M. Montiel, and Juan D. Tardós. ORB-SLAM3: An accurate open-source library for visual, visual-inertial, and multimap SLAM. IEEE Transactions on Robotics, 37(6):1874–1890, 2021. 2, 3DOI
- [11]Hongliang Cao, Xiuyu Li, Siqi Wang, Ziming Wang, Jingmin Zhu, and Hailong Yang. SpecFit: Not all draft tokens cost the same in offloaded MoE inference. arXiv preprint arXiv:2610.15417, 2026. 33arxiv.org/abs/2610.15417
- [12]Leyang Chen, Junyi Wu, Zhiteng Li, and Yulun Zhang. GHOST: Geometry-hierarchical online streaming token eviction for efficient 3D reconstruction. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 2, 7, 27, 30arxiv.org/abs/2605.15852
- [13]Lin-Zhuo Chen, Jianc Gao, Shangzhan Zhang, Yihang Chen, Nan Xue, Jianyuan Wang, Christian Rupprecht, Xun Cao, Xing Zhu, Yujun Shen, Yao Yao, and Yinghao Xu. Geometric context transformer for streaming 3D reconstruction. In Proceedings of the European Conference on Computer Vision (ECCV), pages 293–314, 2026. 2, 26arxiv.org/abs/2604.14141
- [14]Xingyu Chen, Yue Chen, Yuliang Xiu, Andreas Geiger, and Anpei Chen. TT3R: 3D reconstruction as test-time training. In Proceedings of the International Conference on Learning Representations (ICLR), 2026. 2, 6, 7, 18, 19, 23, 24, 27, 28, 29, 33, 34DOI
- [15]Zhuoguang Chen, Minghui Qin, Tianyuan Yuan, Zhe Liu, and Hang Zhao. LONG3R: Long sequence streaming 3D reconstruction. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 5273–5284, 2025. 2arxiv.org/abs/2507.18255
- [16]Chong Cheng, Xianda Chen, Tao Xie, Wei Yin, Weiqiang Ren, Qian Zhang, Xiaoyang Guo, and Hao Wang. LongStream: Long-sequence streaming autoregressive visual geometry. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 272–283, 2026. 2, 29arxiv.org/abs/2602.13172
- [17]Chong Cheng, Peilin Tao, Nanjie Yao, Guanzhi Ding, Xianda Chen, Yuansen Du, Xiaoyang Guo, Wei Yin, Weiqiang Ren, Qian Zhang, Zhengqing Chen, and Hao Wang. Horizon-Stream: Long-horizon attention for streaming 3D reconstruction. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 2, 26arxiv.org/abs/2605.23889
- [18]Andrew J. Davison, Ian D. Reid, Nicholas D. Molton, and Olivier Stasse. MonoSLAM: Real-time single camera SLAM. IEEE Transactions on Pattern Analysis and Machine Intelligence, 29(6):1052–1067, 2007. 2pubmed.ncbi.nlm.nih.gov/17431302
- [19]Hui Deng, Yuxin Mao, Yuxin He, and Yuchao Dai. SSR: A training-free approach for streaming 3D reconstruction. arXiv preprint arXiv:2603.14765, 2026. 2arxiv.org/abs/2603.14765
- [20]Kai Deng, Zexin Ti, Jiawei Xu, Jian Yang, and Jin Xie. VGGT-Long: Chunk it, loop it, align it – pushing VGGT’s limits on kilometer-scale long RGB sequences. In Proceedings of the IEEE International Conference on Robotics and Automation (ICRA), pages 5446–5453, 2026. 2, 3, 5, 7, 23, 26
- [21]Jiacheng Dong, Huan Li, Sicheng Zhou, Wenhao Hu, Weili Xu, and Yan Wang. MeMix: Writing less, remembering more for streaming 3D reconstruction. arXiv preprint arXiv:2603.15330, 2026. 2, 3, 7, 18, 19, 27, 33arxiv.org/abs/2603.15330
- [22]Adrian Dumitrescu, Anirban Ghosh, and Csaba D. Tóth. Online unit covering in Euclidean space. Theoretical Computer Science, 809:218–230, 2020. 2, 15
- [23]Richard Elvira, Juan D. Tardós, and J. M. M. Montiel. ORBSLAM-Atlas: a robust and accurate multi-map system. In Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 6253–6259, 2019. 2, 3, 23arxiv.org/abs/1908.11585
- [24]Jakob J. Engel, Vladlen Koltun, and Daniel Cremers. Direct sparse odometry. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(3):611–625, 2018. 2, 3
- [25]Christian Forster, Matia Pizzoli, and Davide Scaramuzza. SVO: Fast semi-direct monocular visual odometry. In Proceedings of the IEEE International Conference on Robotics and Automation (ICRA), pages 15–22, 2014. 2, 3DOI
- [26]Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving? the KITTI vision benchmark suite. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 3354–3361, 2012. 4, 6
- [27]Teofilo F. Gonzalez. Clustering to minimize the maximum intercluster distance. Theoretical Computer Science, 38:293–306, 1985. 2, 4, 15DOI
- [28]Albert Gu and Tri Dao. Mamba: Linear-time sequence modeling with selective state spaces. In Proceedings of the Conference on Language Modeling (COLM), 2024. 2arxiv.org/abs/2312.00752
- [29]Jiarong Han, Jincheng Xiong, Yuzhou Liu, Linzhe Shi, Changjie Wu, Ning Guo, Mu Xu, Hang Zhang, and Ming Qian. Revisiting local context for long-horizon streaming 3D reconstruction. arXiv preprint arXiv:2608.27529, 2026. 2, 26arxiv.org/abs/2608.27529
- [30]Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural Computation, 9(8):1735–1780, 1997. 2
- [31]Peng Jiang, Fuyuan Wang, Zhiwei Chen, and Wenbo Pan. Motion-aware geometric context adaptation for streaming 3D reconstruction of intelligent rail vehicles in low-parallax scenes. Vehicles, 8(7):168, 2026. 2DOI
- [32]Haian Jin, Rundi Wu, Tianyuan Zhang, Ruiqi Gao, Jonathan T. Barron, Noah Snavely, and Aleksander Hołyński. ZipMap: Linear-time stateful 3D reconstruction via test-time training. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 21748–21759, 2026. 2, 5, 28, 31arxiv.org/abs/2603.04385
- [33]Seongyun Jin and Jong Chul Ye. FILT3R: Latent state adaptive Kalman filter for streaming 3D reconstruction. In Proceedings of the European Conference on Computer Vision (ECCV), pages 289–307, 2026. 2, 3, 7, 18, 19, 27, 33arxiv.org/abs/2603.18493
- [34]Hordur Johannsson, Michael Kaess, Maurice F. Fallon, and John J. Leonard. Temporally scalable visual SLAM using a reduced pose graph. In Proceedings of the IEEE International Conference on Robotics and Automation (ICRA), pages 54–61, 2013. 2
- [35]Nikhil Varma Keetha, Norman Müller, Johannes L. Schönberger, Lorenzo Porzi, Yuchen Zhang, Tobias Fischer, Arno Knaptisch, Duncan Zauss, Ethan Weber, Nelson Antunes, Jonathon Luiten, Manuel Lopez-Antequera, Samuel Rota Bulò, Christian Richardt, Deva Ramanan, Sebastian A. Scherer, and Peter Kontschieder. MapAnything: Universal feed-forward metric 3D reconstruction. In Proceedings of the International Conference on 3D Vision (3DV), pages 499–509, 2026. 1, 2
- [36]Georg Klein and David William Murray. Parallel tracking and mapping for small AR workspaces. In Proceedings of the IEEE/ACM International Symposium on Mixed and Augmented Reality (ISMAR), pages 225–234, 2007. 2, 5DOI
- [37]Yushi Lan, Yihang Luo, Fangzhou Hong, Shangchen Zhou, Honghua Chen, Zhaoyang Lyu, Bo Dai, Shuai Yang, Chen Change Loy, and Xingang Pan. SStream3R: Scalable sequential 3D reconstruction with causal transformer. In Proceedings of the International Conference on Learning Representations (ICLR), 2026. 2, 5, 30, 31arxiv.org/abs/2508.10893
- [38]Vincent Leroy, Yohann Cabon, and Jérôme Revaud. Grounding image matching in 3D with MASt3R. In Proceedings of the European Conference on Computer Vision (ECCV), pages 71–91, 2024. 1, 2arxiv.org/abs/2406.09756
- [39]Fang Li, Jiraphon Yenphraphai, Quentin Herau, Depu Meng, Yihan Hu, Tianshuo Xu, Narendra Ahuja, and Wei Zhan. S2Tok: Streaming 3D Gaussian reconstruction with persistent spatial tokens. arXiv preprint arXiv:2610.08978, 2026. 2arxiv.org/abs/2610.08978
- [40]Lijian Li, Yuanpeng He, Yudian Zheng, Chung-ju Huang, Linyu Li, Dongming Jin, Wenpin Jiao, Zhi Jin, and Chi-Man Pun. BAT3R: Robust online 3D reconstruction with Bayesian adaptive state updates. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 2, 7, 18, 27arxiv.org/abs/2610.16330
- [41]Moyang Li, Zihan Zhu, Wei Zhang, Kaiyu Croftelevs, and Daniel Barath. CLoSeR: Closing the loop for long-context streaming reconstruction. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 3, 26arxiv.org/abs/2610.01927
- [42]Xinze Li, Yiyuan Wang, Pengxu Chen, Weifeng Su, Weisi Lin, and Wentao Cheng. ReCal3R: Reliability-calibrated learning rates for streaming 3D reconstruction. arXiv preprint arXiv:2607.05356, 2026. 2, 7, 18, 19, 27, 28, 33arxiv.org/abs/2607.05356
- [43]Zizun Li, Jianjun Zhou, Yifan Wang, Haoyu Guo, Wenzheng Chang, Yang Zhou, Haoyi Zhu, Junyi Chen, Chunhua Shen, and Tong He. WinT3R: Window-based streaming reconstruction with camera token pool. In Proceedings of the International Conference on Learning Representations (ICLR), 2026. 2arxiv.org/abs/2509.05296
- [44]Chin-Yang Lin, Yang-Che Sun, Cheng Sun, Fu-En Yang, Min-Hung Chen, Yen-Yu Lin, Wei-Chen Chiu, and Yu-Lun Liu. Scal3R: Learning efficient multi-relative pose query for scalable online 3D reconstruction. In Proceedings of the European Conference on Computer Vision (ECCV), pages 1–22, 2026. 3, 8arxiv.org/abs/2609.04201
- [45]Haotong Lin, Sili Chen, Jun Hao Liew, Donny Y. Chen, Zhenyu Li, Yang Zhao, Sida Peng, Hengkai Guo, Xiaowei Zhou, Guang Shi, Jiashi Feng, and Bingyi Kang. Depth Anything 3: Recovering the visual space from any views. In Proceedings of the International Conference on Learning Representations (ICLR), 2026. 1arxiv.org/abs/2511.10647
- [46]Changkun Liu, Jiezhi Yang, Zeman Li, Yuan Deng, Jiancong Guo, Binbin Xu, and Luca Ballan. Mem3R: Streaming 3D reconstruction with hybrid memory. arXiv preprint arXiv:2604.07279, 2026. 2, 28arxiv.org/abs/2604.07279
- [47]Shiwei Liu, Tianlong Chen, Xiaohan Chen, Li Shen, Dec ebal Constantin Mocanu, Zhangyang Wang, and Mykola Pechenizkiy. The unreasonable effectiveness of random pruning: Return of the most naive baseline for sparse training. In Proceedings of the International Conference on Learning Representations (ICLR), 2022. 2arxiv.org/abs/2202.02643
- [48]Xuanyi Liu, Chunan Yu, Deyi Ji, Qi Zhu, Lingyun Sun, Xunfu Li, Jin Ma, Tianrun Chen, and Lanyun Zhu. Stream- CacheVGGT: Streaming visual geometry transformers with robust scoring and hybrid cache compression. arXiv preprint arXiv:2604.15237, 2026. 2arxiv.org/abs/2604.15237
- [49]Yuzheng Liu, Siyan Dong, Shuzhe Wang, Yingda Yin, Yanchao Yang, Qingnan Fan, and Baoquan Chen. SLAM3R: Real-time dense scene reconstruction from monocular RGB videos. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 16651–16662, 2025. 2arxiv.org/abs/2412.09401
- [50]Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In Proceedings of the International Conference on Learning Representations (ICLR), 2019. 2arxiv.org/abs/1810.05270
- [51]Si-Yu Lu, Po-Ting Chen, Hui-Che Hsu, Sin-Ye Jhong, Wen-Huang Cheng, and Yung-Yao Chen. OVGGT: O(1) constant-cost streaming visual geometry transformer. In Proceedings of the European Conference on Computer Vision (ECCV), pages 112–129, 2026. 2, 7, 27, 28, 30, 34arxiv.org/abs/2603.05959
- [52]Dominic Maggio, Hyungtae Lim, and Luca Carlone. VGGT-SLAM: Dense RGB SLAM optimized on the SL(4) manifold. In Advances in Neural Information Processing Systems (NeurIPS), 2025. 2, 3, 23
- [53]Soroush Mahdi, Fardin Ayar, Ehsan Javanmard, Manabu Tsukada, and Mahdi Javanmardi. Evict3R: Training-free token eviction for memory-bounded streaming visual geometry transformers. arXiv preprint arXiv:2509.17650, 2025. 2arxiv.org/abs/2509.17650
- [54]Hongbo Mao, Junjun Jiang, Youyu Chen, Jiaxin Zhang, Zhemeng Dong, and Xianming Liu. RegVGGT: Sustainable visual geometry grounding for streaming via regulated memory. In Proceedings of the European Conference on Computer Vision (ECCV), pages 1–18, 2026. 2, 6, 7, 25, 27, 28, 30, 34arxiv.org/abs/2609.23286
- [55]Raul Mur-Artal, J. M. M. Montiel, and Juan D. Tardós. ORB-SLAM: A versatile and accurate monocular SLAM system. IEEE Transactions on Robotics, 31(5):1147–1163, 2015. 2
- [56]Riku Murai, Eric Dexheimer, and Andrew J. Davison. MASt3R-SLAM: Real-time dense SLAM with 3D reconstruction priors. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 16695–16705, 2025. 3arxiv.org/abs/2412.12392
- [57]Emanuele Palazzolo, Jens Behley, Philipp Lottes, Philippe Giguère, and Cyrill Stachniss. ReFusion: 3D reconstruction in dynamic environments for RGB-D cameras exploiting residuals. In Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 7855–7862, 2019. 6arxiv.org/abs/1905.02082
- [58]Kejun Ren, Lei Jin, Tianxin Huang, Lianming Xu, and Li Wang. Rethinking the state update gate for long-sequence recurrent 3D reconstruction. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 2, 7, 18, 19, 27, 28, 29, 32, 33, 34arxiv.org/abs/2605.16981
- [59]Herbert Robbins and Sutton Monro. A stochastic approximation method. The Annals of Mathematical Statistics, 22(3):400–407, 1951. 14
- [60]Thomas Schöps, Torsten Sattler, and Marc Pollefeys. BAD SLAM: Bundle adjusted direct RGB-D SLAM. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 134–144, 2016. 6, 28
- [61]Guole Shen, Tianchen Deng, Xingrui Qin, Nailin Wang, Jianyu Wang, Yanbo Wang, Yongtao Chen, Hesheng Wang, and Jingchuan Wang. MUT3R: Motion-aware updating transformer for dynamic 3D reconstruction. arXiv preprint arXiv:2512.03939, 2025. 2arxiv.org/abs/2512.03939
- [62]Jamie Shotton, Ben Glocker, Christopher Zach, Shahram Izadi, Antonio Criminisi, and Andrew W. Fitzgibbon. Scene coordinate regression forests for camera relocalization in RGB-D images. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 2930–2937, 2013. 6DOI
- [63]Julian Straub, Thomas Whelan, Lingni Ma, Yufan Chen, Erik Wijmans, Simon Green, Jakob J. Engel, Raul Mur-Artal, Carl Ren, Shobhit Verma, Anton Clarkson, Mingfei Yan, Brian Budge, Yajie Yan, Xiaqiang Pan, June Yon, Yuyang Zou, Kimberly Leon, Nigel Carter, Jesus Briales, Tyler Gillingham, Elias Mueggler, Luis Pesqueira, Manolis Salas, Dhruv Batra, Hauke M. Strassdat, Renzo De Nardi, Michael Goesele, Steven Lovegrove, and Richard Newcombe. The Replica dataset: A digital replica of indoor spaces. arXiv preprint arXiv:1906.05797, 2019. 6arxiv.org/abs/1906.05797
- [64]Jürgen Sturm, Nikolas Engelhard, Felix Endres, Wolfram Burgard, and Daniel Cremers. A benchmark for the evaluation of RGB-D SLAM systems. In Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 573–580, 2012. 6DOI
- [65]Zunhai Sun, Weihiao Ye, Hansen Feng, Keyu Fan, Jing Zhang, Dahai Yu, Zhengwu Liu, and Ngai Wong. XStreamVGGT: Extremely memory-efficient streaming vision geometry grounded transformer with KV cache compression. Journal of the Society for Information Display, 34(5):535–545, 2026. 2, 7, 27
- [66]Yu Sun, Xinhao Li, Karan Dalal, Jiarui Xu, Arjun Vikram, Genghan Zhang, Yann Dubois, Xinlei Chen, Xiaolong Wang, Sanmi Koyejo, Tatsunori Hashimoto, and Carlos Guestrin. Learning to (learn at test time): RNNs with expressive hidden states. In Proceedings of the International Conference on Machine Learning (ICML), 2025. 2arxiv.org/abs/2407.04620
- [67]Marwan Taher, Ignacio Alzugaray, Kirill Mazur, Xin Kong, and Andrew J. Davison. KV-Tracker: Real-time pose tracking with transformers. In Proceedings of the IEEE/CVF Confer- ence on Computer Vision and Pattern Recognition (CVPR), pages 28990–28999, 2026. 3arxiv.org/abs/2512.22581
- [68]Zachary Teed and Jia Deng. DROID-SLAM: Deep visual SLAM for monocular, stereo, and RGB-D cameras. In Advances in Neural Information Processing Systems (NeurIPS), pages 16558–16569, 2026. 3
- [69]Shinji Umeyama. Least-squares estimation of transformation parameters between two point patterns. IEEE Transactions on Pattern Analysis and Machine Intelligence, 13(4):376–380, 1991. 6DOI
- [70]Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), pages 5998–6008, 2017. 2arxiv.org/abs/1706.03762
- [71]Feiran Wang, Zezhou Shang, Gaowen Liu, and Yan Yan. RayMap3R: Inference-time RayMap for dynamic 3D reconstruction. In Proceedings of the European Conference on Computer Vision (ECCV), pages 210–227, 2026. 2, 7, 27arxiv.org/abs/2603.20588
- [72]Hengyi Wang and Lourdes Agapito. 3D reconstruction with spatial memory. In Proceedings of the International Conference on 3D Vision (3DV), pages 78–89, 2025. 2arxiv.org/abs/2408.16061
- [73]Hengyi Wang and Lourdes Agapito. AMB3R: Accurate feed-forward metric-scale 3D reconstruction with backend. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 14612–14625, 2026. 3, 8arxiv.org/abs/2511.20343
- [74]Hengyi Wang and Lourdes Agapito. AMB3R-SLAM: Kilometer-scale SLAM with hierarchical backend. arXiv preprint arXiv:2609.19518, 2026. 3, 26arxiv.org/abs/2609.19518
- [75]Heng Wang, Jielin Qiu, Wenting Zhao, Cheng Qian, Liangwei Yang, Weizhi Zhang, Jiawei Han, Heng Ji, Silvio Savarese, Shelby Heinecke, and Huan Wang. Random attention: Rethinking KV cache eviction for efficient reasoning. arXiv preprint arXiv:2609.03430, 2026. 2arxiv.org/abs/2609.03430
- [76]Jianyuan Wang, Minghao Chen, Nikita Karaev, Andrea Vedaldi, Christian Ruprecht, and David Novotný. VGGT: Visual geometry grounded transformer. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 5294–5306, 2025. 1arxiv.org/abs/2503.11651
- [77]Qianqian Wang, Yifei Zhang, Aleksander Holýnski, Alexei A. Efros, and Anjoo Kanazawa. Continuous 3D perception model with persistent state. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 10510–10522, 2025. 2, 3, 7, 27, 28, 29, 33, 34arxiv.org/abs/2501.12387
- [78]Runze Wang, Yuxuan Song, Youcheng Cai, and Ligang Liu. STAC: Plug-and-play spatio-temporal aware cache compression for streaming 3D reconstruction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 7567–7576, 2026. 2arxiv.org/abs/2603.20284
- [79]Shuzhe Wang, Vincent Leroy, Yohann Cabon, Boris Chidlovskii, and Jérôme Revaud. DUSt3R: Geometric 3D vision made easy. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 20697–20709, 2024. 1arxiv.org/abs/2312.14132
- [80]Yifan Wang, Jianjun Zhou, Haoyi Zhu, Wenzheng Chang, Yang Zhou, Zizun Li, Junyi Chen, Jiangmiao Pang, Chunhua Shen, and Tong He. π^3: Permutation-equivariant visual geometry learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2026. 1arxiv.org/abs/2507.13347
- [81]Ziming Wang. TOKI: A bitemporal operator algebra for contradiction resolution in LLM-agent persistent memory. arXiv preprint arXiv:2606.06240, 2026. 33arxiv.org/abs/2606.06240
- [82]Yuqi Wu, Wenzhao Zheng, Jie Zhou, and Jiwen Lu. Point3R: Streaming 3D reconstruction with explicit spatial pointer memory. In Advances in Neural Information Processing Systems (NeurIPS), 2025. 2
- [83]Guangxuan Xiao, Yuandong Tian, Beidi Chen, Song Han, and Mike Lewis. Efficient streaming language models with attention sinks. In Proceedings of the International Conference on Learning Representations (ICLR), 2024. 2arxiv.org/abs/2309.17453
- [84]Lanbo Xu, Liang Guo, Caigui Jiang, and Cheng Wang. PAS3R: Pose-adaptive streaming 3D reconstruction for long video sequences. arXiv preprint arXiv:2603.21436, 2026. 28arxiv.org/abs/2603.21436
- [85]Zhishong Xu and Takeshi Oishi. FrameVGGT: Coherence-preserving memory for bounded streaming geometry. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 2, 7, 27, 30arxiv.org/abs/2603.07690
- [86]Jianing Yang, Alexander Sax, Kevin J. Liang, Mikael Henaff, Hao Tang, Ang Cao, Joyce Chai, Franziska Meier, and Matt Feiszli. Fast3R: Towards 3D reconstruction of 1000+ images in one forward pass. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 21924–21935, 2025. 1, 2arxiv.org/abs/2501.13928
- [87]Shujun Yao, Junhui Lin, Congyin Han, Tiande Guo, Ziwen Liu, and Bonan Li. BlazeVGGT: 13x faster VGGT at 2,000 frames via camera token without training. arXiv preprint arXiv:2610.29454, 2026. 2arxiv.org/abs/2610.29454
- [88]Tao Yu, Zhongtian Luo, Yuchen Long, Yiheng Lu, Yuxuan Zhou, Yanpei Gong, Siyi Cao, Yuqing Wu, Haopeng Jin, Zhenghao Zhang, Yujia Yang, Jingmin Zhu, Yunyun Hou, Xinming Wang, Hongzhu Yi, Jiachen Liu, Sirui Wang, Nan Duan, Yan Huang, Liang Wang, Tianjin Huang, and Yanyan Zou. When non-adversarial noise hurts learning: Benchmarking skill self-evolution in agents. arXiv preprint arXiv:2610.19910, 2026. 32arxiv.org/abs/2610.19910
- [89]Shuai Yuan, Yantai Yang, Xiaotian Yang, Xupeng Zhang, Zhonghao Zhao, Lingming Zhang, and Zhipeng Zhang. InfiniteVGGT: Visual geometry grounded transformer for endless streams. arXiv preprint arXiv:2601.02281, 2026. 2, 7, 27, 28, 30, 34arxiv.org/abs/2601.02281
- [90]Junyi Zhang, Charles Herrmann, Junhwa Hur, Chen Sun, Ming-Hsuan Yang, Forrester Cole, Trevor Darrell, and Deqing Sun. LoGeR: Long-context geometric reconstruction with hybrid memory. In Proceedings of the European Conference on Computer Vision (ECCV), pages 263–281, 2026. 2, 6, 26, 28arxiv.org/abs/2603.03269
- [91]Xiyuan Zhang, Yanming Yang, Kaiyuan Xu, Ruibo Li, and Chi Zhang. Slot3R: Set-associative spatial memory for streaming 3D reconstruction. arXiv preprint arXiv:2610.12282, 2026. 2arxiv.org/abs/2610.12282
- [92]Zhenyu Zhang, Ying Sheng, Tianyi Zhou, Tianlong Chen, Lianmin Zheng, Ruisi Cai, Zhao Song, Yuandong Tian, Christopher Ré, Clark W. Barrett, Zhangyang Wang, and Beidi Chen. H₂O: Heavy-hitter oracle for efficient generative inference of large language models. In Advances in Neural Information Processing Systems (NeurIPS), 2023. 2
- [93]Zhijie Zheng, Xinhao Xiang, and Jiawei Zhang. TTSA3R: Training-free temporal-spatial adaptive persistent state for streaming 3D reconstruction. arXiv preprint arXiv:2601.22615, 2026. 2, 7, 18, 19, 27, 28, 33arxiv.org/abs/2601.22615
- [94]Jingmin Zhu, Yanyan Zou, Xiuyu Li, James Bailey, Dinh Phung, Tao Yu, Yunyun Hou, Jun Liu, Jun Zhou, Sirui Wang, Nan Duan, Jiachen Liu, and Qiuhong Ke. Tempo-Zero: Recursive self-play in executable worlds for video reasoning. arXiv preprint arXiv:2610.32433, 2026. 33arxiv.org/abs/2610.32433
- [95]Dong Zhuo, Wenzhao Zheng, Jiahe Guo, Yuqi Wu, Jie Zhou, and Jiwen Lu. Streaming 4D visual geometry transformer. In Proceedings of the International Conference on Learning Representations (ICLR), 2026. 2, 5arxiv.org/abs/2507.11539
- [96]Zichen Zou, Xiaosong Jia, Zuxuan Wu, and Yu-Gang Jiang. Attention itself could retrieve. RetrieveVGG-T: Training-free long context streaming 3D reconstruction via query-key similarity retrieval. In Advances in Neural Information Processing Systems (NeurIPS), 2026. 2, 7, 27, 30, 34






