48 AI Agents. 72 hours. NASA lidar data.
The result was a previously undocumented Maya pyramid.
The real story is not “AI found treasure.” It is how a multi-Agent system divides work, validates evidence, and introduces errors at scale.
The original report appears in Pietro Miotti’s article. Rather than repeat the outcome, this analysis treats the project as a stress test for a multi-Agent system.
An archaeological search completed in 72 hours
Google SWE drove 48 AI Agents in a joint analysis of NASA lidar data. The entire task took 72 hours and produced a previously undocumented Maya pyramid.
This was not a matter of showing a model one satellite image and asking whether anything resembled a pyramid. The process can be divided roughly into four stages:
- Load and process NASA lidar data.
- Identify terrain anomalies worth reviewing.
- Have different Agents examine geometry, regional context, and possible interpretations.
- Aggregate the evidence and eliminate false positives caused by vegetation, terrain, or data noise.
The “72 hours” is more significant from an engineering perspective than the pyramid discovery. It establishes a clear budget: the models must complete the search within that window rather than iterate on prompts indefinitely.
The report does not, however, provide the number of calls per Agent, token consumption, or failed retries. A complete per-run cost therefore cannot yet be calculated.
Forty-eight Agents also does not necessarily mean 48 machines running in parallel. A scheduler may launch them sequentially or in batches.
One point is clear: this was a search system with defined roles, artifacts, and a deadline, rather than a single question answered by a model.
Google SWE is not an ordinary chatbot
Google SWE was not used here as a conversational companion. It is closer to a software engineering execution environment: Agents can write code, run programs, inspect outputs, and revise their work based on the results.
That distinction matters.
If an LLM were only asked to infer what it saw in an image, it could easily make a plausible-sounding mistake, describing regular woodland, shadows, or drainage channels as artificial structures. Code execution provides another route to verification.
For example, one Agent could apply local smoothing to an elevation grid before calculating slope and curvature. Another could generate candidate regions and render each one using the same projection and color scale. A third could then check whether candidate boundaries conflicted with known sites, roads, or natural landforms.
Illustrative code might look like this:
import numpy as np
from scipy.ndimage import uniform_filter
def local_relief(height: np.ndarray, cell_size: float) -> np.ndarray:
"""Extract positive surface relief using neighborhood elevation differences."""
smoothed = uniform_filter(height, size=5, mode="nearest")
return height - smoothed
def candidate_mask(relief: np.ndarray, slope: np.ndarray) -> np.ndarray:
"""Retain candidate regions with clear relief and moderate slope."""
return (relief > 1.0) & (slope < 0.35)This is not the full implementation from the report, and it cannot replace genuine archaeological analysis. It illustrates where Agents add the most value: not in describing images, but in invoking deterministic data-processing code that turns ambiguous judgments into repeatable calculations.
The model decides what to check next. The software produces verifiable results. Their roles are different.
The real multi-Agent challenge is dividing the work
Forty-eight Agents sound impressive. The engineering problem is not the headcount but preventing the same work from being performed 48 times over.
A reasonable task graph needs several types of roles:
- Scheduler Agent: Maintains the task queue, dependencies, and remaining time.
- Data Agent: Crops lidar regions, repairs missing values, and standardizes coordinates.
- Detection Agent: Runs different anomaly-detection strategies.
- Validation Agent: Exclusively attempts to disprove candidates proposed by other Agents.
- Aggregation Agent: Retains only findings supported by multiple independent lines of evidence.
The most common flaw is to define “validation” as asking the model the same question again. If 48 Agents share the same context, use the same tools, and receive similar prompts, the result looks like parallel voting but is actually the same bias replicated 48 times.
A more dependable approach grounds validation in different evidence. For example:
| Candidate check | Purpose |
|---|---|
| Local elevation profiles | Detect flat-topped or terraced features consistent with artificial modification |
| Slope and curvature | Rule out ordinary hillsides, gullies, and natural rises |
| Texture and orientation | Check whether edges follow regular geometric patterns |
| Surrounding-site relationships | Determine whether a candidate lies near existing settlements or roads |
| Multi-temporal data | Rule out acquisition errors, shadows, and differences in vegetation cover |
“Multiple” does not mean every Agent must independently reach the same conclusion. A stronger system assigns one Agent to form a hypothesis and another to seek counterexamples.
Failure modes matter more here. The more Agents in a system, the faster errors can propagate. If one Agent applies the wrong coordinate transformation, the next 10 may analyze the wrong area. If the aggregation logic then treats majority agreement as evidence, the system can submit worthless results with great confidence.
The barrier to effective multi-Agent work is therefore not the scheduling framework itself, but evidence isolation and failure isolation.
What can NASA lidar data reveal?
NASA lidar data served as the analysis input. Its value is that lidar does more than capture the color of the ground; it records subtle terrain features beneath forest cover.
Tree canopies may conceal a structure without blocking every laser return. By using gaps in the vegetation, branch edges, and multiple returns, a system can generate a digital elevation model. Archaeological sites may appear as:
- Flat tops;
- Regular straight boundaries;
- Sudden changes in slope;
- Roads or platforms that differ from the surrounding natural terrain.
Algorithms generally convert the raw point cloud into a raster elevation model and then estimate a local baseline surface. “Local relief” means comparing a point with its surrounding area. If a location rises several meters above nearby terrain or forms regular steps, it enters the candidate queue.
That still represents candidate generation, not a discovery.
Lidar can also mislead. Canopy outlines, radar viewing angles, river sediment, and terrain shadows can all produce elevation anomalies that resemble buildings. The machine’s role is to reduce the area humans need to inspect, not to remove the need for expert judgment.
This is where multimodal Agents can help. Raster data supports precise measurement, while rendered views and terrain profiles help models inspect spatial relationships. A model can point to a specific coordinate, after which a researcher can examine the original point cloud and historical records.
A discovery must still pass academic and archaeological review
An algorithmic hit is not an archaeological discovery.
A candidate pyramid still requires field survey, dating, and expert review. An elevation anomaly may establish that a site is worth investigating, but it cannot by itself prove the structure’s age, cultural attribution, or even that it is artificial.
At least four further checks are required:
- Data review: Confirm that the candidate is not an artifact of point-cloud registration, filtering, or coordinate projection.
- Literature review: Check old maps, archaeological surveys, and historical archives to determine whether the site was simply missing from the record.
- Field validation: Have an archaeological team survey the location, conduct test excavation, or use surface geophysical equipment.
- Academic validation: Establish the structure’s function, materials, date, and relationship to nearby sites.
The report reached the Hacker News front page, receiving 516 points and 202 comments. The discussion appears in Hacker News item 50452455.
The 516 points show the appeal of a project that combines engineering and archaeology. The 202 comments underline the need to ask where the evidence ends.
What exactly was found? Was it confirmed in the field? How did 48 Agents avoid a consensus hallucination? How much human intervention was included in the 72 hours?
These questions should not be left to media headlines.
Engineering perspective
The value of this case is not that a fleet of 48 Agents can replace archaeologists. It is that the system compresses a geographically broad search into a scalable candidate-screening process. Lidar supplies spatial clues, models coordinate the work and propose checks, deterministic code performs measurements, and archaeologists decide what qualifies as a conclusion.
This differs from using a single model for image classification: the task has moved from recognizing an object to managing evidence production across a long pipeline.
The next contest will not be won by increasing Agent count, but by improving reproducibility. The data version, code, prompts, random seeds, per-Agent logs, and failure records must all be published before anyone can tell whether 48 Agents provided useful parallelism or simply increased cost. False-positive rates should also be reported alongside the number of discoveries; otherwise, the system may only be producing more noise for humans to review.
Public materials remain unclear about whether the “undocumented pyramid” has received field confirmation. An algorithmic hit and an archaeological conclusion cannot be treated as the same thing.