How to make a navmesh agent ignore navmesh borders

Well maybe it's not the best way to do it but I made it by enabling and desabling the navmeshagent component. I put it in a coroutine so it wouldn't do it each frame. Here I let you my code so you can see exactly how i did it. It's a Little messy but i hope it helps you.

The important things are on IEnumerator calcularCamino, void GetSteer, void start, and the beginning of the update using UnityEngine; using System.Collections; using System.Collections.Generic;

 public class MovimientoPolicia : MonoBehaviour {
 
     public int TD1_TT2_TA3;
     public float maxTorque;
     public float maxBrake;
     public float maxSpeed;
     public float maxRevSpeed;
     public float maxSteer;
 
     public float velocidadActual;
 
     private Rigidbody rg;
     public Transform centerOfMass;
 
     public WheelCollider[] wheelColliders = new WheelCollider[4];
     public Transform[] tireMeshes = new Transform[4];
 
     private float vueltasRueda;
     public float vs;
 
     private GameObject objeto;
     private Transform seguirObjeto;
 
     public float steering;
     private bool reversa = true;
 
     private bool deteccion = false;
     private float reverCounter = 0f;
     public float waitToReverse = 2f;
     public float reverFor = 1.5f;
 
     private int contadorReversas;
     public MeshRenderer mesh;
 
     public NavMeshAgent nav;
     private NavMeshPath path;
 
     private float spawnX;
     private float spawnZ;
     private Vector3 pos;
 
     private float separacion;
 
     void Start()
     {
         rg = GetComponent<Rigidbody>();
         rg.centerOfMass = centerOfMass.localPosition;
         objeto = GameObject.FindGameObjectWithTag("Carro");
         seguirObjeto = objeto.transform;
         path = new NavMeshPath();
         nav.SetDestination(seguirObjeto.position);
         StartCoroutine("calcularCamino");
         nav.updatePosition = false;
     }
 
     void Update()
     {
         UpdateMeshesPositions();
         GetSteer();
         nav.nextPosition = transform.position;
         switch (TD1_TT2_TA3)
         {
             case 1:
                 vueltasRueda = wheelColliders[0].rpm;
                 break;
             case 2:
                 vueltasRueda = wheelColliders[2].rpm;
                 break;
             case 3:
                 vueltasRueda = wheelColliders[2].rpm;
                 break;
             default:
 
                 break;
         }
         float radioV = ((2 * Mathf.PI * wheelColliders[3].radius) * vueltasRueda) * 60 / 1000;
         vs = Mathf.Round(radioV);
         velocidadActual = Mathf.Abs(vs);
 
         if (rg.velocity.magnitude > 2)
         {
             contadorReversas = 0;
         }
 
         if (rg.velocity.magnitude < 0.1 && !reversa)
         {
             reverCounter += Time.deltaTime;
             if (reverCounter >= waitToReverse)
             {
                 reverCounter = 0;
                 reversa = true;
                 contadorReversas ++;
 
                 if (contadorReversas > 4 && !mesh.isVisible && rg.velocity.magnitude < 0.1)
                 {
                     transform.rotation = Quaternion.Euler(0, transform.rotation.y, 0);
                     spawnX = seguirObjeto.position.x + Random.Range(10, 20);
                     spawnZ = seguirObjeto.position.z + Random.Range(10, 20);
                     pos = new Vector3(spawnX, 0, spawnZ);
                     transform.position = pos;
                 }
             }
         } else if (!reversa)
         {
             reverCounter = 0;
             steering *= 1;
         }
 
         if (reversa)
         {
             steering *= -1;
             reverCounter += Time.deltaTime;
             if (reverCounter >= reverFor)
             {
                 reverCounter = 0;
                 reversa = false;
             }
         }
 
         Vector3 dif = transform.position - seguirObjeto.position;
         separacion = dif.sqrMagnitude;
         if (separacion > 40000)
         {
             transform.rotation = Quaternion.Euler(0, transform.rotation.y, 0);
             spawnX = seguirObjeto.position.x + Random.Range(10, 20);
             spawnZ = seguirObjeto.position.z + Random.Range(10, 20);
             pos = new Vector3(spawnX, 0, spawnZ);
             transform.position = pos;
         }
     }
 
     void FixedUpdate()
     {
         wheelColliders[0].steerAngle = -steering;
         wheelColliders[1].steerAngle = -steering;
 
         if (!reversa)
         {
             switch (TD1_TT2_TA3)
             {
                 case 1:
                     if (velocidadActual < maxSpeed)
                     {
                         //acelerar delantera
                         wheelColliders[0].motorTorque = maxTorque;
                         wheelColliders[1].motorTorque = maxTorque;
                     }
                     else
                     {
                         wheelColliders[0].motorTorque = maxTorque / 32;
                         wheelColliders[1].motorTorque = maxTorque / 32;
                     }
                     break;
                 case 2:
                     if (velocidadActual < maxSpeed)
                     {
                         //acelerar trasera
                         wheelColliders[2].motorTorque = maxTorque;
                         wheelColliders[3].motorTorque = maxTorque;
                     }
                     else
                     {
                         wheelColliders[2].motorTorque = maxTorque / 32;
                         wheelColliders[3].motorTorque = maxTorque / 32;
                     }
                     break;
                 case 3:
                     if (velocidadActual < maxSpeed)
                     {
                         //acelerar cuatro
                         wheelColliders[0].motorTorque = maxTorque;
                         wheelColliders[1].motorTorque = maxTorque;
                         wheelColliders[2].motorTorque = maxTorque;
                         wheelColliders[3].motorTorque = maxTorque;
                     }
                     else
                     {
                         wheelColliders[0].motorTorque = maxTorque / 32;
                         wheelColliders[1].motorTorque = maxTorque / 32;
                         wheelColliders[2].motorTorque = maxTorque / 32;
                         wheelColliders[3].motorTorque = maxTorque / 32;
                     }
                     break;
                 default:
 
                     break;
             }
         }
         else if (reversa)
         {
             switch (TD1_TT2_TA3)
             {
                 case 1:
                     if (velocidadActual < maxRevSpeed)
                     {
                         //acelerar delantera
                         wheelColliders[0].motorTorque = -maxTorque;
                         wheelColliders[1].motorTorque = -maxTorque;
                     }
                     else
                     {
                         wheelColliders[0].motorTorque = -maxTorque / 32;
                         wheelColliders[1].motorTorque = -maxTorque / 32;
                     }
                     break;
                 case 2:
                     if (velocidadActual < maxRevSpeed)
                     {
                         //acelerar trasera
                         wheelColliders[2].motorTorque = -maxTorque;
                         wheelColliders[3].motorTorque = -maxTorque;
                     }
                     else
                     {
                         wheelColliders[2].motorTorque = -maxTorque / 32;
                         wheelColliders[3].motorTorque = -maxTorque / 32;
                     }
                     break;
                 case 3:
                     if (velocidadActual < maxRevSpeed)
                     {
                         //acelerar cuatro
                         wheelColliders[0].motorTorque = -maxTorque;
                         wheelColliders[1].motorTorque = -maxTorque;
                         wheelColliders[2].motorTorque = -maxTorque;
                         wheelColliders[3].motorTorque = -maxTorque;
                     }
                     else
                     {
                         wheelColliders[0].motorTorque = -maxTorque / 32;
                         wheelColliders[1].motorTorque = -maxTorque / 32;
                         wheelColliders[2].motorTorque = -maxTorque / 32;
                         wheelColliders[3].motorTorque = -maxTorque / 32;
                     }
                     break;
                 default:
 
                     break;
             }
         }
     }
 
     void GetSteer()
     {
         Vector3 steerVector = transform.InverseTransformPoint(nav.steeringTarget);
         steering = maxSteer * (steerVector.x / steerVector.magnitude);
     }
 
     IEnumerator calcularCamino ()
     {
         nav.enabled = false;
         nav.enabled = true;
 
         NavMesh.CalculatePath(transform.position, seguirObjeto.position, NavMesh.AllAreas, path);
         nav.path = path;
 
         yield return new WaitForSeconds(0.5f);
 
         StartCoroutine("calcularCamino");
     }
 
     void UpdateMeshesPositions()
     {
         for (int i = 0; i < 4; i++)
         {
             Quaternion quat;
             Vector3 pos;
             wheelColliders[i].GetWorldPose(out pos, out quat);
 
             tireMeshes[i].position = pos;
             tireMeshes[i].rotation = quat;
         }
     }
 }