🤖 AI

City Editing: Hierarchical Agentic Execution for Dependency-Aware Urban Geospatial Modification

This paper proposes a hierarchical agentic framework that automates urban renewal by decomposing natural language instructions into multi-level geometric operations, utilizing iterative execution and validation to ensure dependency-aware, spatially consistent modifications of existing geospatial plans.

Original authors: Rui Liu, Steven Jige Quan, Zhong-Ren Peng, Zijun Yao, Han Wang, Zhengzhang Chen, Kunpeng Liu, Yanjie Fu, Dongjie Wang

Published 2026-03-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Rui Liu, Steven Jige Quan, Zhong-Ren Peng, Zijun Yao, Han Wang, Zhengzhang Chen, Kunpeng Liu, Yanjie Fu, Dongjie Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a city planner. In the old days, if you wanted to fix a traffic jam or add a new park, you had to throw out the entire city blueprint and draw a brand new one from scratch. It was like trying to fix a leak in a boat by building a whole new boat instead of just patching the hole. This was slow, expensive, and incredibly difficult.

Even a tiny change—like moving a single bench or widening a sidewalk—required a team of experts to manually redraw thousands of lines on a map, checking that nothing crashed into anything else.

Enter "CEAE": The Smart City Editor

This paper introduces a new system called CEAE (City Editing: Hierarchical Agentic Execution). Think of it not as a "city generator," but as a super-smart, robotic city editor that can take your natural language instructions (like "Make the park bigger and add a path") and actually fix the existing map for you, step-by-step.

Here is how it works, using some simple analogies:

1. The Problem: The "House Renovation" Nightmare

Imagine you want to renovate your kitchen.

The Old Way (Generative AI): You tell a robot, "I want a new kitchen." The robot ignores your existing cabinets, walls, and plumbing, and tries to build a completely new house from the ground up. It might look cool, but it doesn't fit your actual house, and you lose all your existing furniture.
The Human Way: You hire a contractor who has to manually measure every inch, draw new blueprints, and hope they don't accidentally knock down a load-bearing wall while moving the fridge. It takes forever.

2. The Solution: The "Architect, Builder, and Inspector" Team

CEAE solves this by acting like a highly organized construction crew with three distinct roles working together:

🧠 The Architect (Task Planner)

When you say, "Expand the park," the Architect doesn't just start digging. It breaks your big, fuzzy wish into a strict, step-by-step to-do list.

The Analogy: It's like a chef reading a recipe. Instead of just "cook dinner," it says: "First, chop the onions (Polygon level). Then, sauté them (Line level). Finally, garnish the plate (Point level)."
Why it matters: It understands that you can't paint the walls (fine detail) before you've built the frame (big structure). It plans the order of operations so nothing gets messed up.

🔨 The Builder (GeoExecutor)

This is the worker who actually does the physical changes on the map. But here's the trick: CEAE works from big to small (Coarse-to-Fine).

The Analogy: Imagine editing a photo. You don't start by fixing a single pixel. First, you crop the whole image (Polygon). Then, you straighten the horizon line (Line). Finally, you fix the color of a single flower (Point).
The Magic: The Builder updates the map at the "Polygon" level first. Once that's done, the new map is passed to the next stage. The "Line" builder sees the new park shape, not the old one. This ensures that every small change fits perfectly into the big change.

🔍 The Inspector (Validator)

This is the most important part. In the real world, if a builder makes a mistake, the whole house could collapse. In the digital world, a mistake means the map becomes "broken" (e.g., a road overlapping a building).

The Analogy: Think of the Inspector as a strict safety officer at a construction site. After the Builder finishes a small task, the Inspector checks: "Is this road still connected? Did we accidentally delete a house? Does this fit the rules?"
The "Do-Over" Button: If the Inspector says "No," the Builder doesn't just move on. They have to redo that specific step until it's perfect. This prevents small errors from piling up and ruining the whole project.

3. Why This is a Game-Changer

The paper tested this system on real city data (like OpenStreetMap) and found that:

It's Faster: It does in minutes what takes humans days.
It's Smarter: It understands that if you move a park, you might need to move the street next to it too. It handles these "dependencies" automatically.
It's Reliable: Because of the "Inspector," the final map is always valid and usable. It doesn't produce broken, impossible cities.

The Bottom Line

CEAE is like giving city planners a time-traveling editor. Instead of erasing the past and starting over, it lets them make precise, safe, and logical changes to the city as it exists right now. It turns the chaotic, manual process of urban renewal into a smooth, automated conversation between a human and a smart machine.

In short: It's the difference between trying to fix a watch by smashing it and building a new one, versus having a master watchmaker who can gently adjust the tiny gears inside without breaking the casing.

1. Problem Statement

Urban renewal rarely involves redesigning cities from scratch; instead, it requires the iterative, targeted modification of existing urban plans to address issues like traffic congestion, functional imbalance, and inefficient land use. Current workflows are labor-intensive, relying on manual redrawing of geospatial layouts (e.g., adjusting park boundaries often requires repositioning adjacent paths and street furniture).

Existing computational approaches fail to support this specific workflow because they fall into three categories that treat planning as a holistic generation problem rather than an iterative modification process:

Generative AI: Synthesizes complete plans from scratch, ignoring existing layouts.
Optimization-based methods: Rely on simplified abstractions and predefined objectives, lacking flexibility for natural language instructions.
LLM Agent methods: Focus on plan synthesis but lack explicit modeling of intermediate decision dependencies and spatial constraints.

Core Challenges:

Executable Editing: How to formalize urban renewal as a machine-executable task over structured geospatial data (GeoJSON).
Dependency-Aware Iteration: How to manage complex dependencies where a change at a coarse level (e.g., a polygon) affects finer levels (lines, points) and requires constraint propagation.
Error Correction: How to detect and correct intermediate errors during multi-step editing to prevent error accumulation and ensure global spatial validity.

2. Methodology: The CEAE Framework

The authors propose CEAE (City Editing with Agentic Execution), a hierarchical agentic framework that treats urban renewal as a structured, multi-stage execution process. The system operates on GeoJSON representations and accepts natural language instructions.

A. Hierarchical Coarse-to-Fine Execution

The editing process is decomposed into three geometric abstraction levels, executed sequentially:

Polygon Level: Modifying large areas (e.g., land use zones, parks).
Line Level: Adjusting linear features (e.g., roads, paths, boundaries).
Point Level: Relocating or adding discrete objects (e.g., street furniture, trees).

This coarse-to-fine strategy ensures that structural decisions made at higher levels provide valid contextual constraints for subsequent finer-grained edits.

B. Four-Agent Architecture

The framework utilizes four specialized agents to orchestrate the workflow:

Task Planner Agent ( $F_{plan}$ ):
- Role: Interprets natural language instructions and decomposes them into a structured editing plan.
- Output: A sequence of geometry-level editing intents ( $I_{\ell}$ ), each defined by a scope, goal, subtasks ( $T_{\ell}$ ), and constraints ( $C_{\ell}$ ).
- Function: Bridges high-level semantic intent with low-level geometric execution.
GeoExecutor Agent ( $F_{exec}$ ):
- Role: Executes subtasks at specific geometric levels using level-dependent geospatial tools.
- Mechanism: Operates as a state transition process. It performs subtasks sequentially, retaining intermediate observations as context.
- Flow: Outputs from the Polygon level are propagated as inputs to the Line level, and so on, ensuring downstream edits respect upstream structural changes.
Validator Agent ( $F_{val}$ ):
- Role: Performs self-reflective validation after every subtask.
- Mechanism: Checks for geometric validity (e.g., no self-intersections), dependency consistency, and constraint satisfaction.
- Control: If a subtask fails validation, it triggers re-execution with diagnostic feedback (up to a global limit). Only validated states are propagated, preventing error accumulation.
Aggregator Agent ( $F_{agg}$ ):
- Role: Integrates all validated execution outcomes.
- Output: Produces the final updated GeoJSON plan ( $G^*$ ) and a comprehensive execution summary ( $S$ ) containing traces, validation decisions, and statistics for traceability.

3. Key Contributions

Problem Formulation: Introduced City Geospatial Editing as a distinct computational paradigm, reframing urban renewal as dependency-aware layout modification with iterative error correction, distinct from generative planning.
Algorithmic Framework: Proposed CEAE, a hierarchical agentic system that enables multi-level geometric editing via structured dependency propagation and self-reflective validation.
Empirical Validation: Demonstrated through extensive experiments that explicit intent decomposition and hierarchical execution are critical for handling complex, multi-entity editing tasks in real-world scenarios.

4. Experimental Results

The authors evaluated CEAE on a dataset of 219 cities (OpenStreetMap data) across three editing levels: Point (500 samples), Line (500 samples), and Polygon (1,500 samples).

Metrics:

Relative Execution Error (REE): Geometric deviation from the target.
Area Compliance Error (ACE): Deviation in green area changes.
Execution Validity Rate (EVR): Proportion of tasks completed successfully without failure.

Key Findings:

Superior Performance: CEAE consistently outperformed single-pass (one-shot) baselines (including GPT-5, DeepSeek, and Qwen models) across all levels.
- Example: In Polygon editing, CEAE achieved an EVR of 0.979 compared to ~0.926 for the best single-pass LLM, with significantly lower error rates.
Ablation Studies: Removing the Task Planner ( $CEAE^{-t}$ ) or the Validator ( $CEAE^{-v}$ ) resulted in significant performance drops, confirming that both structured planning and iterative validation are essential.
Robustness: CEAE maintained high performance under prompt perturbations (reordering, synonym substitution), whereas baselines degraded significantly.
Parameter Sensitivity: Increasing the maximum re-execution attempts ( $R$ ) improved EVR (robustness) but had diminishing returns on geometric accuracy, suggesting the mechanism primarily aids in recovering from execution failures.

5. Significance and Impact

Paradigm Shift: Moves urban planning AI from "generative" (creating new worlds) to "editorial" (modifying existing worlds), which aligns with real-world urban renewal practices.
Reliability: The self-reflective validation mechanism addresses the "hallucination" and error propagation issues common in LLM-based geospatial tasks, ensuring the final output is topologically and geometrically valid.
Practical Application: The system supports complex, multi-step planning considerations (e.g., merging green spaces while maintaining road buffers) that are difficult for humans to execute manually without errors.
Future Direction: Highlights the potential for integrating richer planning constraints and interactive human feedback to further enhance adaptability in smart city management.

In conclusion, CEAE provides a robust, machine-executable framework for iterative urban renewal, proving that structured intent decomposition and hierarchical, validated execution are necessary to bridge the gap between natural language instructions and precise geospatial modifications.