Perplexity Computer's 3D Map of Middle-earth: A Case Study in Spatial Agentic SynthesisArticle · digest for October 25
Physical miniature diorama of a 3D Middle-earth relief map illuminated by neon synthesis paths from Perplexity Computer.
Article3 sections≈ 5 min

Perplexity Computer's 3D Map of Middle-earth: A Case Study in Spatial Agentic Synthesis

Most of us still think of Perplexity as a souped-up search engine: you type a tricky question, a search agent scans hundreds of pages, pulls relevant quotes, and compiles a neat answer with clickable citations. Useful? Definitely. Fundamentally different from what search engines have done for the past twenty years? Not really.

A recent experiment by the Perplexity Computer research team, however, signals a tectonic shift—from passive information retrieval to a full-fledged Digital Worker Paradigm. They handed the system a creative yet brutally demanding engineering task: build and deploy an interactive 3D map of J.R.R. Tolkien's Middle-earth completely from scratch, with zero pre-written code and zero ready-made 3D assets.

Instead of returning a short summary of Gondor and Mordor, Perplexity Computer spun up an isolated Linux virtual machine and kicked off a multi-hour autonomous engineering run.

Topological Synthesis of Middle-earth: 179 Locations, 41 Rivers, and Strict Geometry

The first—and hardest—phase was converting hundreds of pages of unstructured fiction, fold-out book maps, and fan wikis into a strict relational spatial data model.

Working autonomously, the agent:

  • Extracted and verified 3D coordinates for 179 key geographic landmarks (fortresses, cities, mountain passes, and hidden refuges like Rivendell).
  • Built mathematical vector polylines for 41 river systems, including the Anduin and all its tributaries.
  • Reconstructed the geometry of 23 major overland roads and trade routes.
  • Validated topological consistency—making sure rivers never flowed uphill and that distances between cities matched the multi-day travel logs described in the books.

Here is a snippet of the geographic marker schema the agent compiled in step one:

{
  "project": "middle_earth_spatial_map",
  "total_entities": 179,
  "rivers_count": 41,
  "roads_count": 23,
  "landmarks": [
    { "id": "loc_01", "name": "Minas Tirith", "x": 210.5, "z": 340.2, "elevation": 45.0, "region": "Gondor" },
    { "id": "loc_02", "name": "Mount Doom", "x": 420.0, "z": 290.8, "elevation": 120.0, "region": "Mordor" },
    { "id": "loc_03", "name": "Rivendell", "x": -80.4, "z": -310.6, "elevation": 30.5, "region": "Eriador" }
  ]
}

Autonomous Three.js Coding: From Heightmaps to an Interactive Scene

With the geodatabase locked in, the agent put on its frontend engineer hat. Inside the isolated sandbox, Perplexity Computer wrote a full client-side JavaScript web app using Three.js.

It generated a procedural heightmap for the Misty Mountains and White Mountains, tuned lighting shaders and volumetric-style fog, added interactive pins with pop-up info cards, and wired up OrbitControls so users could fly freely around the 3D terrain.

Here is a core excerpt of the scene initialization code the agent wrote:

import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';

const scene = new THREE.Scene();
scene.background = new THREE.Color(0x0a0e17);

const camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 1, 5000);
camera.position.set(0, 800, 1200);

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);

const controls = new OrbitControls(camera, renderer.domElement);
controls.enableDamping = true;

// Interactive location markers generated by the agent
const markerGeometry = new THREE.SphereGeometry(6, 16, 16);
const markerMaterial = new THREE.MeshBasicMaterial({ color: 0xffaa00 });

const locations = [
  { name: "Minas Tirith", x: 210, z: 340, elevation: 45 },
  { name: "Mount Doom", x: 420, z: 290, elevation: 120 },
  { name: "Rivendell", x: -80, z: -310, elevation: 30 }
];

locations.forEach(loc => {
  const marker = new THREE.Mesh(markerGeometry, markerMaterial);
  marker.position.set(loc.x, loc.elevation, loc.z);
  marker.userData = { name: loc.name };
  scene.add(marker);
});

function animate() {
  requestAnimationFrame(animate);
  controls.update();
  renderer.render(scene, camera);
}
animate();

What This Case Changes for Software Development

The most striking part of the whole experiment wasn't the map itself—it was the system's ability to debug its own failures. When the WebGL renderer crashed on its first run due to a mismatched geometry buffer, the agent read the browser console stack trace, tracked down the offending line, and patched it without a human touching the keyboard.

It's vivid proof that modern agents are graduating to end-to-end project delivery: taking an open-ended goal and shipping a working interactive product on their own.

Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 3