🧭 Lesson 6.1: The NavMesh — Baking & Agents

What Is a NavMesh?

A navigation mesh (NavMesh) is a simplified map of your level that answers one question: where can a character legally stand and walk? Unity analyzes your level geometry — floors, ramps, platforms — and produces a thin polygon skin that hugs every walkable surface, automatically carving out holes around walls, pits, and obstacles.

Once that map exists, an agent doesn't have to reason about your actual meshes at all. You just say "go there," and Unity finds the shortest legal path across the NavMesh, steering around obstacles for you. This is exactly how enemies, NPCs, and companions get around in most 3D games.

The word bake matters. Computing the NavMesh is relatively expensive, so you do it once in the Editor and save the result as data. At runtime the agents just read that data — cheap and instant. It's the same idea as baked lightmaps: pay the cost at author time, reap the speed at play time.

Installing AI Navigation

In older Unity versions navigation lived in a built-in Navigation window and baked a single scene-wide mesh. Unity 6 moves this into a proper package, AI Navigation, built around a component you place in the scene: the NavMeshSurface. It is more flexible (multiple surfaces, per-object control, runtime rebaking) and it's the workflow you should learn.

1. Open Window ▸ Package Manager.
2. Set the source dropdown (top-left) to Unity Registry.
3. Search for AI Navigation and click Install.

After it installs you'll have the NavMeshSurface, NavMeshModifier, and NavMeshLink components available, plus the UnityEngine.AI runtime namespace you'll use in code (NavMeshAgent ships with the engine, but the baking components come from this package).

The NavMeshSurface Component

A NavMeshSurface is the thing that does the baking. You add it to a GameObject (commonly an empty one named Navigation at the scene root, or your ground object), configure a few settings, and press Bake. Here's the component recreated from its Inspector:

The key settings on the surface:

• Agent Type — which agent size this mesh is baked for. The default Humanoid has a radius and height; the bake carves the mesh so an agent of that size fits. (You can define extra types in Window ▸ AI ▸ Navigation (Bake) for, say, a large ogre vs. a small rat.)
• Collect Objects — All bakes every renderer in the scene; Children limits it to this object's hierarchy; Volume bakes only inside a box you define.
• Include Layers — a layer mask so you can exclude things (props, triggers) from ever being considered.
• Use Geometry — bake from Render Meshes (what you see) or Physics Colliders (often cleaner and cheaper).

Marking Geometry

By default the surface treats everything it collects as Walkable. But real levels need nuance: a lava pit should be Not Walkable, a bridge might be a special area, and a decorative rock shouldn't block a path. You control this per-object with the NavMeshModifier component.

Add a NavMeshModifier to any object and you can:

• Override Area — set that object's surface to Walkable, Not Walkable, or a custom area type (areas carry a movement cost, so you can make agents prefer roads over mud).
• Ignore From Build — exclude the object entirely, as if it weren't there for navigation.

A common pattern: put your ground and static level meshes on a Ground or Environment layer, restrict the surface's Include Layers to those, and add a NavMeshModifier set to Not Walkable on hazards. That keeps agents on solid, safe ground.

Baking & Reading the Result

With the surface configured, press Bake. Unity computes the mesh and shows it as a translucent blue overlay laid over every walkable surface in the Scene view. Study that overlay carefully — it is the ground truth of where your agents can go. If the blue doesn't reach a platform, no agent will ever path there.

Here's a top-down view of a small room after baking. Notice how the walkable blue hugs the floor but pulls away from walls and carves a hole around each obstacle:

💡 The margin is the agent radius. Notice the blue never touches a wall — it stops one radius short. That's because the NavMesh represents where the agent's center can be while its body still clears the geometry. Bake for a bigger radius and the walkable area shrinks; corridors that were passable can close off entirely.

If your NavMesh looks wrong, the usual culprits are: geometry not marked static or not on an included layer, a slope steeper than the Max Slope setting (agents refuse steep ramps), or a step height taller than Step Height (agents can't climb it). Re-bake after every layout change — the mesh is a snapshot, not live.

The NavMeshAgent

The mesh is the map; the NavMeshAgent is the traveler. Add the component (Add Component ▸ Navigation ▸ Nav Mesh Agent) to the GameObject you want to move — an enemy, an NPC, even the player if you're making a point-and-click game. From now on, moving that object is a matter of telling the agent where, not how.

The settings you'll tune most (all visible in Figure 1):

• Speed — top movement speed in metres per second. 3.5 is a natural walk; bump it up for a sprinting enemy.
• Angular Speed — how fast the agent turns, in degrees per second. Low values make lumbering giants; high values make twitchy insects.
• Acceleration — how quickly it reaches top speed. Low acceleration gives weighty, momentum-heavy movement.
• Stopping Distance — how far from the destination the agent halts. Set this to your attack range so a chasing enemy stops at the player rather than trying to stand inside them.
• Radius & Height — the agent's physical size for avoidance. These should roughly match the character's capsule; they also affect which baked mesh the agent fits on.

Crucially, the agent moves the Transform itself. You do not add a Rigidbody and push it, and you don't write your own movement in Update. The agent reads the NavMesh and drives the position and rotation for you. Here's the smallest possible script that confirms an agent is present and ready:

using UnityEngine;
using UnityEngine.AI;   // NavMeshAgent lives here

[RequireComponent(typeof(NavMeshAgent))]
public class AgentProbe : MonoBehaviour
{
    NavMeshAgent agent;

    void Awake()
    {
        agent = GetComponent<NavMeshAgent>();
    }

    void Start()
    {
        // isOnNavMesh is true only if the agent spawned on top of baked mesh.
        if (!agent.isOnNavMesh)
            Debug.LogWarning($"{name} is not on a NavMesh — did you bake, and is it standing on blue?");
        else
            Debug.Log($"{name} ready. Speed {agent.speed}, stopping at {agent.stoppingDistance}m.");
    }
}

Hands-on Challenge

Summary

🚀 What's Next?

You have a map and a traveler that knows it's standing on it — but it hasn't gone anywhere yet. In Lesson 6.2: Moving Agents — Destinations & Patrol Routes you'll call SetDestination, detect when the agent has arrived, and wire up a patrol that walks a loop of waypoints.