diff --git a/vivarium/experimental/notebooks/selective_sensors.ipynb b/vivarium/experimental/notebooks/selective_sensors.ipynb
new file mode 100644
index 0000000..aee523f
--- /dev/null
+++ b/vivarium/experimental/notebooks/selective_sensors.ipynb
@@ -0,0 +1,814 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quick tutorial to explain how to create a environment with braitenberg vehicles equiped with selective sensors (still a draft so comments of the notebook won't be complete yet)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-07-09 15:48:58.727097: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import logging as lg\n",
+    "\n",
+    "from enum import Enum\n",
+    "from functools import partial\n",
+    "from typing import Tuple\n",
+    "\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "\n",
+    "from jax import vmap, jit\n",
+    "from jax import random, ops, lax\n",
+    "\n",
+    "from flax import struct\n",
+    "from jax_md.rigid_body import RigidBody\n",
+    "from jax_md import simulate \n",
+    "from jax_md import space, rigid_body, partition, quantity\n",
+    "\n",
+    "from vivarium.experimental.environments.utils import normal, distance \n",
+    "from vivarium.experimental.environments.base_env import BaseState, BaseEnv\n",
+    "from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn\n",
+    "from vivarium.experimental.environments.braitenberg.simple import relative_position, proximity_map, sensor_fn, sensor\n",
+    "from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params, linear_behavior\n",
+    "from vivarium.experimental.environments.braitenberg.simple import lr_2_fwd_rot, fwd_rot_2_lr, motor_command\n",
+    "from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the classes and helper functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add entity sensed type as a field in entities + sensed in agents. The agents sense the \"sensed type\" of the entities. In our case, there will be preys, predators, ressources and poison."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "### Define the constants and the classes of the environment to store its state ###\n",
+    "SPACE_NDIMS = 2\n",
+    "\n",
+    "class EntityType(Enum):\n",
+    "    AGENT = 0\n",
+    "    OBJECT = 1\n",
+    "\n",
+    "class EntitySensedType(Enum):\n",
+    "    PREY = 0\n",
+    "    PRED = 1\n",
+    "    RESSOURCE = 2\n",
+    "    POISON = 3\n",
+    "\n",
+    "# Already incorporates position, momentum, force, mass and velocity\n",
+    "@struct.dataclass\n",
+    "class EntityState(simulate.NVEState):\n",
+    "    entity_type: jnp.array\n",
+    "    ent_sensed_type: jnp.array\n",
+    "    entity_idx: jnp.array\n",
+    "    diameter: jnp.array\n",
+    "    friction: jnp.array\n",
+    "    exists: jnp.array\n",
+    "    \n",
+    "@struct.dataclass\n",
+    "class ParticleState:\n",
+    "    ent_idx: jnp.array\n",
+    "    color: jnp.array\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class AgentState(ParticleState):\n",
+    "    prox: jnp.array\n",
+    "    motor: jnp.array\n",
+    "    proximity_map_dist: jnp.array\n",
+    "    proximity_map_theta: jnp.array\n",
+    "    behavior: jnp.array\n",
+    "    params: jnp.array\n",
+    "    sensed: jnp.array\n",
+    "    wheel_diameter: jnp.array\n",
+    "    speed_mul: jnp.array\n",
+    "    max_speed: jnp.array\n",
+    "    theta_mul: jnp.array    \n",
+    "    proxs_dist_max: jnp.array\n",
+    "    proxs_cos_min: jnp.array\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class ObjectState(ParticleState):\n",
+    "    pass\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class State(BaseState):\n",
+    "    max_agents: jnp.int32\n",
+    "    max_objects: jnp.int32\n",
+    "    neighbor_radius: jnp.float32\n",
+    "    dt: jnp.float32  # Give a more explicit name\n",
+    "    collision_alpha: jnp.float32\n",
+    "    collision_eps: jnp.float32\n",
+    "    entities: EntityState\n",
+    "    agents: AgentState\n",
+    "    objects: ObjectState    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define get_relative_displacement"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n",
+    "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n",
+    "    body = state.entities.position\n",
+    "    senders, receivers = agents_neighs_idx\n",
+    "    Ra = body.center[senders]\n",
+    "    Rb = body.center[receivers]\n",
+    "    dR = - space.map_bond(displacement_fn)(Ra, Rb)  # Looks like it should be opposite, but don't understand why\n",
+    "\n",
+    "    dist, theta = proximity_map(dR, body.orientation[senders])\n",
+    "    proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
+    "    proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)\n",
+    "    proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
+    "    proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)\n",
+    "    return dist, theta, proximity_map_dist, proximity_map_theta\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "to compute motors, only use linear behaviors (don't vmap it) because we vmap the functions to compute agents proxiemters and motors at a higher level \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_motor(proxs, params, behaviors, motors):\n",
+    "    \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n",
+    "\n",
+    "    :param proxs: proximeters of all agents\n",
+    "    :param params: parameters mapping proximeters to new motor values\n",
+    "    :param behaviors: array of behaviors\n",
+    "    :param motors: current motor values\n",
+    "    :return: new motor values\n",
+    "    \"\"\"\n",
+    "    manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n",
+    "    manual_mask = manual\n",
+    "    linear_motor_values = linear_behavior(proxs, params)\n",
+    "    motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n",
+    "    return motor_values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add Mask sensors and don't change functions\n",
+    "\n",
+    "- mask_sensors: mask sensors according to sensed entity type for an agent\n",
+    "- don't change: return agent raw_proxs (surely return either the masked or the same prox array according to a sensed e type)\n",
+    "\n",
+    "Then for each agent, we iterate on all of his behaviors. For each behavior, we iterate on each possible sensed entity type. If the entity is sensed, we keep the raw proximeters of the agent as they are currently. If it is not, we mask the proximeters of the specific (non sensed) entity type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n",
+    "    mask = jnp.where(state.entities.ent_sensed_type[ent_target_idx] == ent_type_id, 0, 1)\n",
+    "    mask = jnp.expand_dims(mask, 1)\n",
+    "    mask = jnp.broadcast_to(mask, agent_raw_proxs.shape)\n",
+    "    return agent_raw_proxs * mask\n",
+    "\n",
+    "def dont_change(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n",
+    "    return agent_raw_proxs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n",
+    "\n",
+    "- compute_behavior_prox: compute the proxs for one behavior (enumerate through all the sensed entities on this particular behavior)\n",
+    "- compute_behavior_proxs_motors: use fn above to compute the proxs and compute the motor values according to the behavior\n",
+    "- #vmap compute_all_behavior_proxs_motors:  computes this for all the behaviors of an agent\n",
+    "- compute_agent_proxs_motors: compute the proximeters and motor values of an agent for all its behaviors. Just return mean motor value\n",
+    "- #vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO : Use a fori_loop on this later\n",
+    "def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities):\n",
+    "    for ent_type_id, sensed in enumerate(sensed_entities):\n",
+    "        # need the lax.cond because you don't want to change the proxs if you perceive the entity\n",
+    "        # but you want to mask the raw proxs if you don't detect it\n",
+    "        agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx)\n",
+    "    proxs = jnp.max(agent_raw_proxs, axis=0)\n",
+    "    return proxs\n",
+    "\n",
+    "def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_target_idx):\n",
+    "    behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed)\n",
+    "    behavior_motors = compute_motor(behavior_prox, params, behavior, motor)\n",
+    "    return behavior_prox, behavior_motors\n",
+    "\n",
+    "# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same)\n",
+    "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None))\n",
+    "\n",
+    "def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n",
+    "    behavior = jnp.expand_dims(behavior, axis=1)\n",
+    "    ent_ag_idx = ag_idx_dense_senders[agent_idx]\n",
+    "    ent_target_idx = ag_idx_dense_receivers[agent_idx]\n",
+    "    agent_raw_proxs = raw_proxs[ent_ag_idx]\n",
+    "\n",
+    "    # vmap on params, sensed, behaviors and motorss (vmap on all agents)\n",
+    "    agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_target_idx)\n",
+    "    mean_agent_motors = jnp.mean(agent_motors, axis=0)\n",
+    "\n",
+    "    return agent_proxs, mean_agent_motors\n",
+    "\n",
+    "compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add classical braitenberg force fn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the main environment class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "#--- 4 Define the environment class with its different functions (step ...) ---#\n",
+    "class SelectiveSensorsEnv(BaseEnv):\n",
+    "    def __init__(self, state, seed=42):\n",
+    "        self.seed = seed\n",
+    "        self.init_key = random.PRNGKey(seed)\n",
+    "        self.displacement, self.shift = space.periodic(state.box_size)\n",
+    "        self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n",
+    "        self.neighbor_fn = partition.neighbor_list(\n",
+    "            self.displacement, \n",
+    "            state.box_size,\n",
+    "            r_cutoff=state.neighbor_radius,\n",
+    "            dr_threshold=10.,\n",
+    "            capacity_multiplier=1.5,\n",
+    "            format=partition.Sparse\n",
+    "        )\n",
+    "\n",
+    "        self.neighbors = self.allocate_neighbors(state)\n",
+    "        # self.neighbors, self.agents_neighs_idx = self.allocate_neighbors(state)\n",
+    "\n",
+    "    def distance(self, point1, point2):\n",
+    "            return distance(self.displacement, point1, point2)\n",
+    "    \n",
+    "    ### Add ag_idx_dense !!! \n",
+    "    @partial(jit, static_argnums=(0,))\n",
+    "    def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]:\n",
+    "        # Differences : compute raw proxs for all agents first \n",
+    "        dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement)\n",
+    "        senders, receivers = agents_neighs_idx\n",
+    "\n",
+    "        dist_max = state.agents.proxs_dist_max[senders]\n",
+    "        cos_min = state.agents.proxs_cos_min[senders]\n",
+    "        targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n",
+    "        raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask)\n",
+    "\n",
+    "        # 2: Use dense idx for neighborhoods to vmap all of this\n",
+    "        # TODO : Could even just pass ag_idx_dense in the fn and do this inside\n",
+    "        ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense\n",
+    "\n",
+    "        agent_proxs, mean_agent_motors = compute_all_agents_proxs_motors(\n",
+    "            state,\n",
+    "            state.agents.ent_idx,\n",
+    "            state.agents.params,\n",
+    "            state.agents.sensed,\n",
+    "            state.agents.behavior,\n",
+    "            state.agents.motor,\n",
+    "            raw_proxs,\n",
+    "            ag_idx_dense_senders,\n",
+    "            ag_idx_dense_receivers,\n",
+    "        )\n",
+    "\n",
+    "        agents = state.agents.replace(\n",
+    "            prox=agent_proxs, \n",
+    "            proximity_map_dist=proximity_dist_map, \n",
+    "            proximity_map_theta=proximity_dist_theta,\n",
+    "            motor=mean_agent_motors\n",
+    "        )\n",
+    "\n",
+    "        # Last block unchanged\n",
+    "        state = state.replace(agents=agents)\n",
+    "        entities = self.apply_physics(state, neighbors)\n",
+    "        state = state.replace(time=state.time+1, entities=entities)\n",
+    "        neighbors = neighbors.update(state.entities.position.center)\n",
+    "\n",
+    "        return state, neighbors\n",
+    "    \n",
+    "    def step(self, state: State) -> State:\n",
+    "        if state.entities.momentum is None:\n",
+    "             state = self.init_fn(state, self.init_key)\n",
+    "             \n",
+    "        current_state = state\n",
+    "        state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense)\n",
+    "\n",
+    "        if self.neighbors.did_buffer_overflow:\n",
+    "            # reallocate neighbors and run the simulation from current_state\n",
+    "            lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')\n",
+    "            neighbors = self.allocate_neighbors(state)\n",
+    "            assert not neighbors.did_buffer_overflow\n",
+    "\n",
+    "        self.neighbors = neighbors\n",
+    "        return state\n",
+    "        \n",
+    "    def allocate_neighbors(self, state, position=None):\n",
+    "        position = state.entities.position.center if position is None else position\n",
+    "        neighbors = self.neighbor_fn.allocate(position)\n",
+    "\n",
+    "        # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here)\n",
+    "        ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n",
+    "        self.agents_neighs_idx = neighbors.idx[:, ag_idx]\n",
+    "        agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)])\n",
+    "        # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n",
+    "        agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders]\n",
+    "        # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)])\n",
+    "        self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n",
+    "        return neighbors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = 0\n",
+    "max_agents = 10\n",
+    "max_objects = 10\n",
+    "n_dims = 2\n",
+    "box_size = 100\n",
+    "diameter = 5.0\n",
+    "friction = 0.1\n",
+    "mass_center = 1.0\n",
+    "mass_orientation = 0.125\n",
+    "neighbor_radius = 100.0\n",
+    "collision_alpha = 0.5\n",
+    "collision_eps = 0.1\n",
+    "dt = 0.1\n",
+    "wheel_diameter = 2.0\n",
+    "speed_mul = 1.0\n",
+    "max_speed = 10.0\n",
+    "theta_mul = 1.0\n",
+    "prox_dist_max = 40.0\n",
+    "prox_cos_min = 0.0\n",
+    "behavior = Behaviors.AGGRESSION.value\n",
+    "behaviors=Behaviors.AGGRESSION.value\n",
+    "existing_agents = None\n",
+    "existing_objects = None\n",
+    "\n",
+    "n_preys = 5\n",
+    "n_preds = 5\n",
+    "n_ress = 5\n",
+    "n_pois = 5\n",
+    "\n",
+    "key = random.PRNGKey(seed)\n",
+    "key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Entities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "existing_agents = max_agents if not existing_agents else existing_agents\n",
+    "existing_objects = max_objects if not existing_objects else existing_objects\n",
+    "\n",
+    "n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects \n",
+    "# Assign random positions to each entity in the environment\n",
+    "agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size\n",
+    "objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size\n",
+    "positions = jnp.concatenate((agents_positions, objects_positions))\n",
+    "# Assign random orientations between 0 and 2*pi to each entity\n",
+    "orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi\n",
+    "# Assign types to the entities\n",
+    "agents_entities = jnp.full(max_agents, EntityType.AGENT.value)\n",
+    "object_entities = jnp.full(max_objects, EntityType.OBJECT.value)\n",
+    "entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)\n",
+    "# Define arrays with existing entities\n",
+    "exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))\n",
+    "exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))\n",
+    "exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n",
+    "\n",
+    "### TODO : Actually find a way to init this later\n",
+    "sensed_ent_types = jnp.concatenate([\n",
+    "    jnp.full(n_preys, EntitySensedType.PREY.value),\n",
+    "    jnp.full(n_preds, EntitySensedType.PRED.value),\n",
+    "    jnp.full(n_ress, EntitySensedType.RESSOURCE.value),\n",
+    "    jnp.full(n_pois, EntitySensedType.POISON.value),\n",
+    "])\n",
+    "\n",
+    "ent_sensed_types = jnp.zeros(n_entities)\n",
+    "\n",
+    "entities =  EntityState(\n",
+    "    position=RigidBody(center=positions, orientation=orientations),\n",
+    "    momentum=None,\n",
+    "    force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),\n",
+    "    mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),\n",
+    "    entity_type=entity_types,\n",
+    "    ent_sensed_type=sensed_ent_types,\n",
+    "    entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),\n",
+    "    diameter=jnp.full((n_entities), diameter),\n",
+    "    friction=jnp.full((n_entities), friction),\n",
+    "    exists=exists\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Agents"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(5, 2, 2, 3) (5, 2, 4)\n",
+      "(5, 2, 2, 3) (5, 2, 4)\n",
+      "(10, 2, 2, 3) (10, 2, 4) (10, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Prey behaviors\n",
+    "love = behavior_to_params(Behaviors.LOVE.value)\n",
+    "fear = behavior_to_params(Behaviors.FEAR.value)\n",
+    "sensed_love = jnp.array([1, 0, 1, 0])\n",
+    "sensed_fear = jnp.array([0, 1, 0, 1])\n",
+    "prey_params = jnp.array([love, fear])\n",
+    "prey_sensed = jnp.array([sensed_love, sensed_fear])\n",
+    "\n",
+    "# Do like if we had batches of params and sensed entities for all agents\n",
+    "prey_batch_params = jnp.tile(prey_params[None], (n_preys, 1, 1 ,1))\n",
+    "prey_batch_sensed = jnp.tile(prey_sensed[None], (n_preys, 1, 1))\n",
+    "print(prey_batch_params.shape, prey_batch_sensed.shape)\n",
+    "\n",
+    "prey_behaviors = jnp.array([Behaviors.LOVE.value, Behaviors.FEAR.value])\n",
+    "prey_batch_behaviors = jnp.tile(prey_behaviors[None], (n_preys, 1))\n",
+    "\n",
+    "# Pred behaviors\n",
+    "aggr = behavior_to_params(Behaviors.AGGRESSION.value)\n",
+    "fear = behavior_to_params(Behaviors.FEAR.value)\n",
+    "sensed_aggr = jnp.array([1, 0, 0, 0])\n",
+    "sensed_fear = jnp.array([0, 0, 0, 1])\n",
+    "pred_params = jnp.array([aggr, fear])\n",
+    "pred_sensed = jnp.array([sensed_aggr, sensed_fear])\n",
+    "\n",
+    "# Do like if we had batches of params and sensed entities for all agents\n",
+    "pred_batch_params = jnp.tile(pred_params[None], (n_preys, 1, 1 ,1))\n",
+    "pred_batch_sensed = jnp.tile(pred_sensed[None], (n_preys, 1, 1))\n",
+    "print(pred_batch_params.shape, pred_batch_sensed.shape)\n",
+    "\n",
+    "pred_behaviors = jnp.array([Behaviors.AGGRESSION.value, Behaviors.FEAR.value])\n",
+    "pred_batch_behaviors = jnp.tile(pred_behaviors[None], (n_preds, 1))\n",
+    "\n",
+    "\n",
+    "params = jnp.concatenate([prey_batch_params, pred_batch_params], axis=0)\n",
+    "sensed = jnp.concatenate([prey_batch_sensed, pred_batch_sensed], axis=0)\n",
+    "behaviors  = jnp.concatenate([prey_batch_behaviors, pred_batch_behaviors], axis=0)\n",
+    "print(params.shape, sensed.shape, behaviors.shape)\n",
+    "\n",
+    "\n",
+    "prey_color = jnp.array([0., 0., 1.])\n",
+    "pred_color = jnp.array([1., 0., 0.])\n",
+    "\n",
+    "prey_color=jnp.tile(prey_color, (n_preys, 1))\n",
+    "pred_color=jnp.tile(pred_color, (n_preds, 1))\n",
+    "\n",
+    "agent_colors = jnp.concatenate([\n",
+    "    prey_color,\n",
+    "    pred_color\n",
+    "])\n",
+    "\n",
+    "agents =  AgentState(\n",
+    "    # idx in the entities (ent_idx) state to map agents information in the different data structures\n",
+    "    ent_idx=jnp.arange(max_agents, dtype=int), \n",
+    "    prox=jnp.zeros((max_agents, 2)),\n",
+    "    motor=jnp.zeros((max_agents, 2)),\n",
+    "    behavior=behaviors,\n",
+    "    params=params,\n",
+    "    sensed=sensed,\n",
+    "    wheel_diameter=jnp.full((max_agents), wheel_diameter),\n",
+    "    speed_mul=jnp.full((max_agents), speed_mul),\n",
+    "    max_speed=jnp.full((max_agents), max_speed),\n",
+    "    theta_mul=jnp.full((max_agents), theta_mul),\n",
+    "    proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n",
+    "    proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n",
+    "    proximity_map_dist=jnp.zeros((max_agents, 1)),\n",
+    "    proximity_map_theta=jnp.zeros((max_agents, 1)),\n",
+    "    color=jnp.tile(agent_colors, (max_agents, 1))\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Objects"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Entities idx of objects\n",
+    "start_idx, stop_idx = max_agents, max_agents + max_objects \n",
+    "objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n",
+    "\n",
+    "res_color = jnp.array([0., 1., 0.])\n",
+    "pois_color = jnp.array([1., 0., 1.])\n",
+    "\n",
+    "res_color=jnp.tile(res_color, (n_preys, 1))\n",
+    "pois_color=jnp.tile(pois_color, (n_preds, 1))\n",
+    "\n",
+    "objects_colors = jnp.concatenate([\n",
+    "    res_color,\n",
+    "    pois_color\n",
+    "])\n",
+    "\n",
+    "objects =  ObjectState(\n",
+    "    ent_idx=objects_ent_idx,\n",
+    "    color=jnp.tile(objects_colors, (max_objects, 1))\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### State"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state =  State(\n",
+    "    time=0,\n",
+    "    box_size=box_size,\n",
+    "    max_agents=max_agents,\n",
+    "    max_objects=max_objects,\n",
+    "    neighbor_radius=neighbor_radius,\n",
+    "    collision_alpha=collision_alpha,\n",
+    "    collision_eps=collision_eps,\n",
+    "    dt=dt,\n",
+    "    entities=entities,\n",
+    "    agents=agents,\n",
+    "    objects=objects\n",
+    ")   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test the simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from vivarium.experimental.environments.braitenberg.render import render, render_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env = SelectiveSensorsEnv(state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Autonomous behaviors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 10_000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test manual behavior for an agent\n",
+    "\n",
+    "Need to set all of its behaviors to manual."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ag_idx = 9\n",
+    "manual_behaviors = jnp.array([Behaviors.MANUAL.value, Behaviors.MANUAL.value,])\n",
+    "manual_color = jnp.array([0., 0., 0.])\n",
+    "manual_motors = jnp.array([1., 1.])\n",
+    "\n",
+    "behaviors = state.agents.behavior.at[ag_idx].set(manual_behaviors)\n",
+    "colors = state.agents.color.at[ag_idx].set(manual_color)\n",
+    "motors = state.agents.motor.at[ag_idx].set(manual_motors)\n",
+    "\n",
+    "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n",
+    "state = state.replace(agents=agents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 5_000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}