diff --git a/doc/exploratory/cross-resonance.ipynb b/doc/exploratory/cross-resonance.ipynb
new file mode 100644
index 0000000000..147087e77f
--- /dev/null
+++ b/doc/exploratory/cross-resonance.ipynb
@@ -0,0 +1,471 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "094c8eb6-c8fc-4297-a7c2-af47a0bdce73",
+   "metadata": {},
+   "source": [
+    "# Simulate cross-resonance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cd7932cd-fa6c-4060-ae99-4354243c847f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import scipy\n",
+    "from IPython.core.display import HTML"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bcd185e-f159-429a-98ca-8e2ee18af046",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "## Plotting machinery"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6f922805-0890-4a27-8551-34ec854343a6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<style>\n",
+       ".jp-RenderedImage {\n",
+       "    display: table-cell;\n",
+       "    text-align: center;\n",
+       "    vertical-align: middle;\n",
+       "}\n",
+       "</style>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "HTML(\"\"\"\n",
+    "<style>\n",
+    ".jp-RenderedImage {\n",
+    "    display: table-cell;\n",
+    "    text-align: center;\n",
+    "    vertical-align: middle;\n",
+    "}\n",
+    "</style>\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "78208426-e0b7-4113-abe7-184d611a0f47",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cmap(name: str, n: int):\n",
+    "    return mpl.colormaps[name](np.linspace(0, 1, n))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "72e849a1-6197-4ac1-aa4c-a0b119305e75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# adapted from Qibo\n",
+    "# https://github.com/qiboteam/qibo/blob/master/src/qibo/ui/bloch.py\n",
+    "\n",
+    "\n",
+    "def _sphere():\n",
+    "    phi, theta = np.mgrid[0.0 : np.pi : 100j, 0.0 : 2.0 * np.pi : 100j]\n",
+    "    x = np.sin(phi) * np.cos(theta)\n",
+    "    y = np.sin(phi) * np.sin(theta)\n",
+    "    z = np.cos(phi)\n",
+    "    return x, y, z\n",
+    "\n",
+    "\n",
+    "def _axis():\n",
+    "    theta = np.linspace(0, 2 * np.pi, 100)\n",
+    "    z = np.zeros(100)\n",
+    "    x = np.sin(theta)\n",
+    "    y = np.cos(theta)\n",
+    "    return x, y, z\n",
+    "\n",
+    "\n",
+    "def _parallel(z):\n",
+    "    theta = np.linspace(0, 2 * np.pi, 100)\n",
+    "    z = np.full(100, z)\n",
+    "    r = np.sqrt(1 - z[0] ** 2)\n",
+    "    x = r * np.cos(theta)\n",
+    "    y = r * np.sin(theta)\n",
+    "    return x, y, z\n",
+    "\n",
+    "\n",
+    "def _meridian(phi):\n",
+    "    theta = np.linspace(0, 2 * np.pi, 100)\n",
+    "    x = np.sin(theta) * np.cos(phi)\n",
+    "    y = np.sin(theta) * np.sin(phi)\n",
+    "    z = np.cos(theta)\n",
+    "    return x, y, z\n",
+    "\n",
+    "\n",
+    "def bloch_sphere(**kwargs):\n",
+    "    fig = plt.figure()\n",
+    "    ax = fig.add_subplot(\n",
+    "        projection=\"3d\", elev=kwargs.get(\"elev\", 15), azim=kwargs.get(\"azim\", 30)\n",
+    "    )\n",
+    "    # Empty sphere\n",
+    "    ax.plot_surface(*_sphere(), color=\"lavenderblush\", alpha=0.2)\n",
+    "\n",
+    "    # Axis\n",
+    "    x, y, z = _axis()\n",
+    "    combinations_axis = [(x, y, z), (z, x, y), (y, z, x)]\n",
+    "\n",
+    "    # Axis lines\n",
+    "    line, zeros = np.linspace(-1, 1, 100), np.zeros(shape=(100))\n",
+    "    combinations_axis_line = [\n",
+    "        (line, zeros, zeros),\n",
+    "        (zeros, line, zeros),\n",
+    "        (zeros, zeros, line),\n",
+    "    ]\n",
+    "\n",
+    "    # Meridian and Parallel\n",
+    "    phi = [(n + 1) * np.pi / 3 for n in range(6)]\n",
+    "    lat = (0.4, -0.4, 0.9, -0.9)\n",
+    "    meridian = lambda x: ax.plot(*_meridian(x), color=\"darkgrey\")\n",
+    "    parallel = lambda x: ax.plot(*_parallel(x), color=\"darkgrey\")\n",
+    "\n",
+    "    # Axis, Axis lines, Meridians, Parallels\n",
+    "    with mpl.rc_context({\"lines.linewidth\": 0.6}):\n",
+    "        [ax.plot(*combinations_axis[i], color=\"darkgrey\") for i in range(3)]\n",
+    "        # [ax.plot(*combinations_axis_line[i], color=\"darkgrey\") for i in range(3)]\n",
+    "        # [meridian(p) for p in phi]\n",
+    "        # [parallel(l) for l in lat]\n",
+    "\n",
+    "    ax.axis(\"off\")\n",
+    "    scale = 1 / 1.4\n",
+    "    ax.set_xlim(np.array([-1, 1]) * scale)\n",
+    "    ax.set_ylim(np.array([-1, 1]) * scale)\n",
+    "    ax.set_zlim(np.array([-1, 1]) * scale * 0.8)\n",
+    "    return fig, ax"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b486063-862e-41ac-bb6f-20db52e7631b",
+   "metadata": {},
+   "source": [
+    "## Simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c11ae683-18c3-49a4-9e02-597e8660b188",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = np.array([[0, 1], [1, 0]])\n",
+    "y = np.array([[0, -1j], [1j, 0]])\n",
+    "z = np.array([[1, 0], [0, -1]])\n",
+    "\n",
+    "\n",
+    "def rx(theta: float) -> np.ndarray:\n",
+    "    return scipy.linalg.expm(-1j * theta * x / 2) / 1j\n",
+    "\n",
+    "\n",
+    "def ry(theta: float) -> np.ndarray:\n",
+    "    return scipy.linalg.expm(-1j * theta * y / 2) / 1j\n",
+    "\n",
+    "\n",
+    "def rz(theta: float) -> np.ndarray:\n",
+    "    return scipy.linalg.expm(-1j * theta * z / 2) / 1j\n",
+    "\n",
+    "\n",
+    "def rzx(theta: float) -> np.ndarray:\n",
+    "    c = np.cos(theta / 2)\n",
+    "    s = np.sin(theta / 2)\n",
+    "    gate = np.zeros((4, 4), dtype=np.complex128)\n",
+    "    gate[0, 0:2] = [c, -1j * s]\n",
+    "    gate[1, 0:2] = [-1j * s, c]\n",
+    "    gate[2, 2:4] = [c, 1j * s]\n",
+    "    gate[3, 2:4] = [1j * s, c]\n",
+    "    return gate\n",
+    "\n",
+    "\n",
+    "def cnot(theta: float) -> np.ndarray:\n",
+    "    zxq = rzx(theta).reshape((2, 2, 2, 2))\n",
+    "    cnotq = np.einsum(\"ijkl,km,ln->ijmn\", zxq, rz(np.pi / 2), rx(np.pi / 2))\n",
+    "    cnotph = cnotq.reshape(4, 4)\n",
+    "    return cnotph * np.sqrt(2) / (-1 + 1j)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "873f7ce2-0cd9-477a-806a-6d9a169ed9dc",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### Validate Pauli matrices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "cd5bdc70-5923-4329-8c53-c3041d39de47",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.complex128(0.9999999999999998+1.232595164407831e-32j)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = rz(np.pi / 2) @ np.ones(2) / np.sqrt(2)\n",
+    "a.conj() @ y @ a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6629c3b5-334c-4b06-9617-e1095ce681c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.complex128(-1.0000000000000002+0j)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = rx(np.pi / 2) @ [1, 0]\n",
+    "a.conj() @ y @ a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "0b23c536-4b29-455e-8fa9-b05b5d1b19b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.complex128(1.0000000000000002+0j)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = ry(np.pi / 2) @ [1, 0]\n",
+    "a.conj() @ x @ a"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59ebba24-6962-4d68-9710-fce36887b2e0",
+   "metadata": {},
+   "source": [
+    "### Evolve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3d51aae4-738f-48e2-bbea-c9427d7a8b81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def expz(input_: np.ndarray, theta: float, bare: bool = False) -> float:\n",
+    "    gate = cnot if not bare else rzx\n",
+    "    r = gate(theta) @ input_\n",
+    "    return np.real(r.conj() @ np.kron(np.eye(2), z) @ r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c45aab9-707f-49f2-a74e-adb4f90bcd5b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "thetas = np.linspace(0, 2 * np.pi, 100)\n",
+    "plt.plot([expz([1, 0, 0, 0], th) for th in thetas])\n",
+    "plt.plot([expz([0, 1, 0, 0], th) for th in thetas])\n",
+    "plt.plot([expz([0, 0, 1, 0], th) for th in thetas], c=\"tab:red\");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "b62f8833-2e0a-468a-bd54-0fb65cebcd59",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ts = np.linspace(0, 2 * np.pi, 100)\n",
+    "plt.plot([expz([1, 0, 0, 0], t, bare=True) for t in ts])\n",
+    "plt.plot([expz([0, 1, 0, 0], t, bare=True) for t in ts]);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "75b54352-04bf-4c72-a849-7ecc1c6f3698",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zx = np.kron(z, x)\n",
+    "zz = np.kron(z, z)\n",
+    "ix = np.kron(np.eye(2), x)\n",
+    "iy = np.kron(np.eye(2), y)\n",
+    "iz = np.kron(np.eye(2), z)\n",
+    "it = np.stack([ix, iy, iz]).transpose((1, 0, 2))\n",
+    "zi = np.kron(z, np.eye(2))\n",
+    "\n",
+    "\n",
+    "def evol(t: float, coeffs: list[float]):\n",
+    "    o1 = coeffs[0]\n",
+    "    o2 = coeffs[1]\n",
+    "    zeta = coeffs[2]\n",
+    "    Onu = coeffs[3]\n",
+    "    Omu = coeffs[4]\n",
+    "    return scipy.linalg.expm(\n",
+    "        -1j * (-o1 / 2 * iz + -o2 / 2 * zi + zeta / 4 * zz + Onu * ix + Omu * zx) * t\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def expevolz(input_: np.ndarray, t: float, coeffs: list[float]) -> np.ndarray:\n",
+    "    r = evol(t, coeffs) @ input_\n",
+    "    return np.real(r.conj() @ (it @ r))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "9f735ccc-9542-4926-8320-70b9a6822868",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ts = np.linspace(0, np.pi, 1000)\n",
+    "coeffs = [0, 0, 0.3, 1, 3]\n",
+    "g = np.array([expevolz([1, 0, 0, 0], t, coeffs) for t in ts]).T\n",
+    "e = np.array([expevolz([0, 0, 1, 0], t, coeffs) for t in ts]).T\n",
+    "fig, axs = plt.subplots(3, 1, sharex=True, figsize=(9, 5))\n",
+    "for ax, gc, ec in zip(axs, g, e):\n",
+    "    ax.plot(gc, label=\"ground\")\n",
+    "    ax.plot(ec, c=\"tab:red\", label=\"excited\")\n",
+    "axs[0].legend()\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "01e5a3d9-1d56-467b-90c9-29b552b4bae3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = bloch_sphere(azim=70)\n",
+    "ax.scatter(*g, c=cmap(\"Blues\", 1000), s=10)\n",
+    "ax.scatter(*e, c=cmap(\"Reds\", 1000), s=10);"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qibocal",
+   "language": "python",
+   "name": "qibocal"
+  },
+  "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.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/doc/exploratory/hamiltonian-tomography-fit.ipynb b/doc/exploratory/hamiltonian-tomography-fit.ipynb
new file mode 100644
index 0000000000..f6890d1f48
--- /dev/null
+++ b/doc/exploratory/hamiltonian-tomography-fit.ipynb
@@ -0,0 +1,91 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "51e5eb27-eaa3-48e2-ac66-588f9e198399",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import scipy.optimize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "daa15faa-2f1d-4d74-82d3-639f8a4a5dc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sin(t, omega, amp, offset, phase):\n",
+    "    return amp * np.sin(t * omega + phase) + offset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 146,
+   "id": "a8d83dc3-a05d-4b58-b37a-caf3081e30ed",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-0.03240233958816674 -3.6545492201034757\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "scale = 20\n",
+    "x = np.linspace(0, scale, 30)\n",
+    "y = np.sin(x) + np.random.rand(x.size) * 0.5\n",
+    "\n",
+    "par, cov = scipy.optimize.curve_fit(\n",
+    "    sin,\n",
+    "    x,\n",
+    "    y,\n",
+    "    [1, np.quantile(y, 0.8) - np.quantile(y, 0.2), np.median(y), 0],\n",
+    "    maxfev=int(1e6),\n",
+    ")\n",
+    "xp = np.linspace(0, scale * 1.5, 1000)\n",
+    "plt.plot(xp, sin(xp, *par))\n",
+    "plt.scatter(x, y)\n",
+    "\n",
+    "print((par[0] - 1) * 100, (par[1] - 1) * 100)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qibocal",
+   "language": "python",
+   "name": "qibocal"
+  },
+  "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.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/doc/source/protocols/cross_resonance/amplitude.png b/doc/source/protocols/cross_resonance/amplitude.png
new file mode 100644
index 0000000000..bb6694786e
Binary files /dev/null and b/doc/source/protocols/cross_resonance/amplitude.png differ
diff --git a/doc/source/protocols/cross_resonance/cross_resonance.rst b/doc/source/protocols/cross_resonance/cross_resonance.rst
new file mode 100644
index 0000000000..10638025e1
--- /dev/null
+++ b/doc/source/protocols/cross_resonance/cross_resonance.rst
@@ -0,0 +1,188 @@
+Calibration of CNOT gate using Cross-Resonance
+===============================================
+
+It is possible to generate an interaction between two superconducting qubits without requiring
+flux tunability, through a mechanism known as Cross Resonance (CR). This mechanism relies only
+on microwave drive pulses. Moreover, not using flux lines, results in a reduction of the number
+of fridge lines and allows to ignore all problems related to flux noise.
+
+The cross resonance effect was first proposed :cite:p:`CR_First` in and later
+independently discovered in :cite:p:`CR_Righetti, CR_Second`.
+
+The CR effect can be showed by starting with the Hamiltonian of a two-qubit system with
+a drive term on the first qubit :cite:p:`Manenti:2023zzn`
+
+.. math::
+
+    H = b_1^\dagger b_1 \omega_1 + \frac{\alpha_1}{2} b_1^\dagger b_1^\dagger b_1 b_1 +
+        b_2^\dagger b_2 \omega_2 + \frac{\alpha_2}{2} b_2^\dagger b_2^\dagger b_2 b_2 +
+        g (b_1 b_2^\dagger + b_1^\dagger b_2) + \Omega(t) (b_1 + b_1^\dagger)
+
+If we are in a dispersive regime (i.e. :math:`|\omega_1 - \omega_2| \gg g`), through a
+Schrieffer-Wolff transformation we can obtain the effective Hamiltonian:
+
+.. math::
+
+    H_\text{eff} = - \frac{\tilde{\omega_1}}{2} \sigma_1^z - \frac{\tilde{\omega_2}}{2} \sigma_2^z
+    + \frac{\zeta}{4} \sigma_1^z \sigma_2^z
+    + \Omega(t) \Big[ \sigma_1^x + \nu \sigma_2^x + \mu \sigma_1^z \sigma_2^x\Big]
+
+where :math:`\zeta` is the ZZ coupling, :math:`\nu` is quantum crosstalk factor and :math:`\mu` is the
+cross-resonance factor. From the equation above we can see that by driving the first qubit
+at the frequency of the second qubit .
+
+By tuning the amplitude and the duration of this drive pulse it is possible to calibrate a
+:math:`RZX` rotation to rotate exactly by :math:`- \pi/2`. This is done because starting
+from a :math:`ZX_{frac{\pi}{2}}` we can obtain a CNOT gate using single qubit rotations.
+
+.. math::
+
+    \text{CNOT} = \text{R}_\text{ZX}(-\pi/2) \text{R}_\text{IX}(\pi/2) \text{R}_\text{ZI}(\pi/2)
+
+In Qibocal we provide protocols to calibrate CR pulses.
+
+Sweeping the duration of the CR pulse
+-------------------------------------
+
+In a first experiment we can sweep the duration of the CR pulse and measure both the
+target and control qubit. The measurement is performed while preparing the control
+qubit in state :math:`\ket{0}` and :math:`\ket{1}`.
+
+Parameters
+^^^^^^^^^^
+
+.. autoclass:: qibocal.protocols.two_qubit_interaction.cross_resonance.length.CrossResonanceLengthParameters
+  :noindex:
+
+Example
+^^^^^^^
+
+A possible runcard to launch the experiment could be the following:
+
+.. code-block:: yaml
+
+  - id: CR length
+    operation: cross_resonance_length
+    parameters:
+      targets: [[0,1]]
+      pulse_duration_start: 10
+      pulse_duration_end: 200
+      pulse_duration_step: 10
+      flux_pulse_amplitude: 0.1
+      nshots: 2000
+      relaxation_time: 50000
+
+
+The expected output is the following:
+
+.. image:: length.png
+
+Post-processing
+^^^^^^^^^^^^^^^
+
+The probability of the target qubit is fitted in both cases to a dumped cosine functions.
+It is possible to extract the effective coupling as
+
+.. math::
+
+    \text{J}_\text{eff}/ 2 \pi = \frac{f^{\pi}_\text{Rabi} - f_\text{Rabi}}{2}
+
+
+where :math:`f^{\pi}_\text{Rabi}` and :math:`f_\text{Rabi}` are the frequencies of the
+fitted Rabi oscillations on the target qubit.
+
+Sweeping amplitude of the CR pulse
+----------------------------------
+
+Similarly it is possible to sweep the amplitude of the CR pulse and measure both the
+target and control qubit.
+
+
+Parameters
+^^^^^^^^^^
+
+.. autoclass:: qibocal.protocols.two_qubit_interaction.cross_resonance.length.CrossResonanceLengthParameters
+  :noindex:
+
+Example
+^^^^^^^
+
+A possible runcard to launch the experiment could be the following:
+
+.. code-block:: yaml
+
+  - id: CR amplitude
+    operation: cross_resonance_amplitude
+    parameters:
+      targets: [[0,1]]
+      max_amp: 0.05
+      min_amp: 0.01
+      step_amp: 0.005
+      pulse_duration: 100
+      nshots: 2000
+      relaxation_time: 50000
+
+
+The expected output is the following:
+
+.. image:: amplitude.png
+
+Post-processing
+^^^^^^^^^^^^^^^
+
+The probability of the target qubit is fitted in both cases to a cosine function.
+
+Hamiltonian Tomography measurement
+----------------------------------
+
+Although from the two previous experiments it is possible to perform an initial
+calibration of the CR gate, by performing a state tomography on the target qubit it is
+possible to reconstruct the effective Hamiltonian of the system :cite:p:`CRDrag`:
+
+.. math::
+
+    H_\text{eff} = \frac{\nu_\text{ZX}}{2} \text{ZX} + \frac{\nu_\text{ZY}}{2} \text{ZY} +
+                    \frac{\nu_\text{ZZ}}{2} \text{ZZ} + \frac{\nu_\text{IX}}{2} \text{IX} +
+                    \frac{\nu_\text{IY}}{2} \text{IY} + \frac{\nu_\text{IZ}}{2} \text{IZ}
+
+In particular, by sweeping the duration of the CR pulse and measuring the expectation
+values of the target qubit :math:`\langle X \rangle`, :math:`\langle Y \rangle` and :math:`\langle Z \rangle`
+when the control qubit is prepared in :math:`\ket{0}` and :math:`\ket{1}` we can compute all terms in
+the effective Hamiltonian following the procedure in :cite:p:`CRDrag`.
+
+Parameters
+^^^^^^^^^^
+
+
+.. autoclass:: qibocal.protocols.two_qubit_interaction.cross_resonance.hamiltonian_tomography.length.HamiltonianTomographyCRLengthParameters
+  :noindex:
+
+Example
+^^^^^^^
+
+A possible runcard to launch the experiment could be the following:
+
+.. code-block:: yaml
+
+  - id: Hamiltonian tomography CR
+    operation: cross_resonance_amplitude
+    parameters:
+      targets: [[0,1]]
+      nshots: 2000
+      pulse_amplitude: 0.1
+      pulse_duration_end: 400
+      pulse_duration_start: 10
+      pulse_duration_step: 20
+
+
+The expected output is the following:
+
+.. image:: tomography_length.png
+
+
+
+Requirements
+^^^^^^^^^^^^
+
+To run these experiments single qubit gates for both target and control qubit needs
+to be calibrated.
diff --git a/doc/source/protocols/cross_resonance/length.png b/doc/source/protocols/cross_resonance/length.png
new file mode 100644
index 0000000000..a04dfc7595
Binary files /dev/null and b/doc/source/protocols/cross_resonance/length.png differ
diff --git a/doc/source/protocols/cross_resonance/tomography_length.png b/doc/source/protocols/cross_resonance/tomography_length.png
new file mode 100644
index 0000000000..582646f995
Binary files /dev/null and b/doc/source/protocols/cross_resonance/tomography_length.png differ
diff --git a/doc/source/protocols/index.rst b/doc/source/protocols/index.rst
index 45628506fa..ab0ad6697e 100644
--- a/doc/source/protocols/index.rst
+++ b/doc/source/protocols/index.rst
@@ -40,6 +40,7 @@ In this section we introduce the basics of all protocols supported by ``qibocal`
     chevron
     virtual_z
     state_tomographies
+    cross_resonance/cross_resonance
     coherence/index
     chsh
     twpa_calibration/twpa
diff --git a/doc/source/refs.bib b/doc/source/refs.bib
index d8dfdd2e63..e9f5741431 100644
--- a/doc/source/refs.bib
+++ b/doc/source/refs.bib
@@ -262,6 +262,69 @@ @misc{reed2013entanglementquantumerrorcorrection
       url={https://arxiv.org/abs/1311.6759},
 }
 
+@article{CR_First,
+  title = {Microwave-induced coupling of superconducting qubits},
+  author = {Paraoanu, G. S.},
+  journal = {Phys. Rev. B},
+  volume = {74},
+  issue = {14},
+  pages = {140504},
+  numpages = {4},
+  year = {2006},
+  month = {Oct},
+  publisher = {American Physical Society},
+  doi = {10.1103/PhysRevB.74.140504},
+  url = {https://link.aps.org/doi/10.1103/PhysRevB.74.140504}
+}
+
+@article{CR_Righetti,
+  title = {Fully microwave-tunable universal gates in superconducting qubits with linear couplings and fixed transition frequencies},
+  author = {Rigetti, Chad and Devoret, Michel},
+  journal = {Phys. Rev. B},
+  volume = {81},
+  issue = {13},
+  pages = {134507},
+  numpages = {7},
+  year = {2010},
+  month = {Apr},
+  publisher = {American Physical Society},
+  doi = {10.1103/PhysRevB.81.134507},
+  url = {https://link.aps.org/doi/10.1103/PhysRevB.81.134507}
+}
+
+@article{CR_Second,
+author = {Groot, P. and Lisenfeld, Jürgen and Schouten, R. and Ashhab, S. and Lupascu, Adrian and Harmans, Kees and Mooij, Hans},
+year = {2010},
+month = {08},
+pages = {},
+title = {Selective darkening of degenerate transitions demonstrated with two
+superconducting quantum bits},
+volume = {6},
+journal = {Nature Physics},
+doi = {10.1038/nphys1733}
+}
+
+@book{Manenti:2023zzn,
+    author = "Manenti, Riccardo and Motta, Mario",
+    title = "{Quantum Information Science}",
+    isbn = "978-0-19-878748-8",
+    publisher = "Oxford University Press",
+    month = "8",
+    year = "2023"
+}
+
+@article{CRDrag,
+author = {Li, Boxi and Calarco, Tommaso and Motzoi, Felix},
+year = {2024},
+month = {07},
+pages = {},
+title = {Experimental error suppression in Cross-Resonance gates via multi-derivative pulse shaping},
+volume = {10},
+journal = {npj Quantum Information},
+doi = {10.1038/s41534-024-00863-4}
+}
+
+
 @article{Klimov_2018,
    title={Fluctuations of Energy-Relaxation Times in Superconducting Qubits},
    volume={121},
diff --git a/platforms/qubit/parameters.json b/platforms/qubit/parameters.json
index f1cbe19bd4..c0c42ed7e1 100644
--- a/platforms/qubit/parameters.json
+++ b/platforms/qubit/parameters.json
@@ -12,7 +12,7 @@
   },
   "hamiltonian":{
     "transmon_levels": 2,
-    "single_qubit": {
+    "qubits": {
       "0": {
         "frequency": 5e9,
         "anharmonicity": -200e6,
diff --git a/platforms/qutrit/parameters.json b/platforms/qutrit/parameters.json
index 19d861dd01..dd0433fd6c 100644
--- a/platforms/qutrit/parameters.json
+++ b/platforms/qutrit/parameters.json
@@ -12,7 +12,7 @@
     },
     "hamiltonian":{
       "transmon_levels": 3,
-      "single_qubit": {
+      "qubits": {
         "0": {
           "frequency": 5e9,
           "anharmonicity": -200e6,
diff --git a/platforms/qutrits/calibration.json b/platforms/qutrits/calibration.json
new file mode 100644
index 0000000000..def074c85e
--- /dev/null
+++ b/platforms/qutrits/calibration.json
@@ -0,0 +1,75 @@
+{
+    "single_qubits": {
+        "0": {
+            "resonator": {
+                "bare_frequency": 0.0,
+                "dressed_frequency": 0.0,
+                "depletion_time": 0,
+                "bare_frequency_amplitude": null
+            },
+            "qubit": {
+                "frequency_01": 5114000000.0,
+                "frequency_12": 4784000000.0,
+                "maximum_frequency": 5114000000.0,
+                "asymmetry": 0.0,
+                "sweetspot": 0.0,
+                "flux_coefficients": null
+            },
+            "readout": {
+                "fidelity": 0.0,
+                "coupling": null,
+                "effective_temperature": null,
+                "ground_state": [
+                    0.0,
+                    1.0
+                ],
+                "excited_state": [
+                    1.0,
+                    0.0
+                ],
+                "qudits_frequency": {}
+            },
+            "t1": null,
+            "t2": null,
+            "t2_spin_echo": null,
+            "rb_fidelity": null
+        },
+        "1": {
+            "resonator": {
+                "bare_frequency": 0.0,
+                "dressed_frequency": 0.0,
+                "depletion_time": 0,
+                "bare_frequency_amplitude": null
+            },
+            "qubit": {
+                "frequency_01": 4914000000.0,
+                "frequency_12": 4584000000.0,
+                "maximum_frequency": 4914000000.0,
+                "asymmetry": 0.0,
+                "sweetspot": 0.0,
+                "flux_coefficients": null
+            },
+            "readout": {
+                "fidelity": 0.0,
+                "coupling": null,
+                "effective_temperature": null,
+                "ground_state": [
+                    0.0,
+                    1.0
+                ],
+                "excited_state": [
+                    1.0,
+                    0.0
+                ],
+                "qudits_frequency": {}
+            },
+            "t1": null,
+            "t2": null,
+            "t2_spin_echo": null,
+            "rb_fidelity": null
+        }
+    },
+    "two_qubits": {},
+    "readout_mitigation_matrix": null,
+    "flux_crosstalk_matrix": null
+}
diff --git a/platforms/qutrits/parameters.json b/platforms/qutrits/parameters.json
new file mode 100644
index 0000000000..1b2f29020c
--- /dev/null
+++ b/platforms/qutrits/parameters.json
@@ -0,0 +1,357 @@
+{
+    "settings": {
+        "nshots": 1024,
+        "relaxation_time": 0
+    },
+    "configs": {
+        "emulator/bounds": {
+            "kind": "bounds",
+            "waveforms": 1000000.0,
+            "readout": 50,
+            "instructions": 200
+        },
+        "hamiltonian": {
+            "kind": "hamiltonian",
+            "transmon_levels": 3,
+            "qubits": {
+                "0": {
+                    "frequency": 5114000000.0,
+                    "anharmonicity": -330000000.0,
+                    "t1": {
+                        "0-1": 38000.0,
+                        "1-2": 19000.0
+                    },
+                    "t2": {
+                        "0-1": 50000.0
+                    }
+                },
+                "1": {
+                    "frequency": 4914000000.0,
+                    "anharmonicity": -330000000.0,
+                    "t1": {
+                        "0-1": 42000.0,
+                        "1-2": 21000.0
+                    },
+                    "t2": {
+                        "0-1": 61000.0
+                    }
+                }
+            },
+            "pairs": {
+                "0-1": {
+                    "coupling": 3800000.0
+                }
+            }
+        },
+        "0/drive": {
+            "kind": "drive-emulator",
+            "frequency": 5114000000.0,
+            "rabi_frequency": 50000000.0,
+            "scale_factor": 10.0
+        },
+        "01/drive": {
+            "kind": "drive-emulator",
+            "frequency": 4914000000.0,
+            "rabi_frequency": 50000000.0,
+            "scale_factor": 10.0
+        },
+        "0/drive12": {
+            "kind": "drive-emulator",
+            "frequency": 4784000000.0,
+            "rabi_frequency": 50000000.0,
+            "scale_factor": 10.0
+        },
+        "1/drive": {
+            "kind": "drive-emulator",
+            "frequency": 4914000000.0,
+            "rabi_frequency": 50000000.0,
+            "scale_factor": 10.0
+        },
+        "1/drive12": {
+            "kind": "drive-emulator",
+            "frequency": 4584000000.0,
+            "rabi_frequency": 50000000.0,
+            "scale_factor": 10.0
+        },
+        "0/probe": {
+            "kind": "iq",
+            "frequency": 5500000000.0
+        },
+        "0/acquisition": {
+            "kind": "acquisition",
+            "delay": 0.0,
+            "smearing": 0.0,
+            "threshold": 0.0,
+            "iq_angle": 0.0,
+            "kernel": null
+        },
+        "1/probe": {
+            "kind": "iq",
+            "frequency": 5500000000.0
+        },
+        "1/acquisition": {
+            "kind": "acquisition",
+            "delay": 0.0,
+            "smearing": 0.0,
+            "threshold": 0.0,
+            "iq_angle": 0.0,
+            "kernel": null
+        }
+    },
+    "native_gates": {
+        "single_qubit": {
+            "0": {
+                "RX": [
+                    [
+                        "0/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.200449,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ]
+                ],
+                "RX90": [
+                    [
+                        "0/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.1002245,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ]
+                ],
+                "RX12": [
+                    [
+                        "0/drive12",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.1426586,
+                            "envelope": {
+                                "kind": "gaussian",
+                                "rel_sigma": 0.1
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ]
+                ],
+                "MZ": [
+                    [
+                        "0/acquisition",
+                        {
+                            "kind": "readout",
+                            "acquisition": {
+                                "kind": "acquisition",
+                                "duration": 10.0
+                            },
+                            "probe": {
+                                "kind": "pulse",
+                                "duration": 10.0,
+                                "amplitude": 0.1,
+                                "envelope": {
+                                    "kind": "rectangular"
+                                },
+                                "relative_phase": 0.0
+                            }
+                        }
+                    ]
+                ],
+                "CP": null
+            },
+            "1": {
+                "RX": [
+                    [
+                        "1/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.200792,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ]
+                ],
+                "RX90": [
+                    [
+                        "1/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.100396,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ]
+                ],
+                "RX12": [
+                    [
+                        "1/drive12",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.138545,
+                            "envelope": {
+                                "kind": "gaussian",
+                                "rel_sigma": 0.1
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ]
+                ],
+                "MZ": [
+                    [
+                        "1/acquisition",
+                        {
+                            "kind": "readout",
+                            "acquisition": {
+                                "kind": "acquisition",
+                                "duration": 10.0
+                            },
+                            "probe": {
+                                "kind": "pulse",
+                                "duration": 10.0,
+                                "amplitude": 0.1,
+                                "envelope": {
+                                    "kind": "rectangular"
+                                },
+                                "relative_phase": 0.0
+                            }
+                        }
+                    ]
+                ],
+                "CP": null
+            }
+        },
+        "coupler": {},
+        "two_qubit": {
+            "0-1": {
+                "CZ": null,
+                "CNOT": [
+                    [
+                        "01/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 50.0,
+                            "amplitude": 0.1,
+                            "envelope": {
+                                "kind": "rectangular"
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ],
+                    [
+                        "0/drive",
+                        {
+                            "kind": "delay",
+                            "duration": 50.0
+                        }
+                    ],
+                    [
+                        "0/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.200449,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ],
+                    [
+                        "01/drive",
+                        {
+                            "kind": "delay",
+                            "duration": 20.0
+                        }
+                    ],
+                    [
+                        "01/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 50.0,
+                            "amplitude": -0.1,
+                            "envelope": {
+                                "kind": "rectangular"
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ],
+                    [
+                        "0/drive",
+                        {
+                            "kind": "delay",
+                            "duration": 50.0
+                        }
+                    ],
+                    [
+                        "0/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.200449,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ],
+                    [
+                        "1/drive",
+                        {
+                            "kind": "delay",
+                            "duration": 140.0
+                        }
+                    ],
+                    [
+                        "1/drive",
+                        {
+                            "kind": "pulse",
+                            "duration": 20.0,
+                            "amplitude": 0.100396,
+                            "envelope": {
+                                "kind": "drag",
+                                "rel_sigma": 0.1,
+                                "beta": 0.25
+                            },
+                            "relative_phase": 0.0
+                        }
+                    ],
+                    [
+                        "0/drive",
+                        {
+                            "kind": "virtualz",
+                            "phase": -1.5707963267948966
+                        }
+                    ]
+                ],
+                "iSWAP": null
+            }
+        }
+    }
+}
diff --git a/platforms/qutrits/platform.py b/platforms/qutrits/platform.py
new file mode 100644
index 0000000000..988a8b7501
--- /dev/null
+++ b/platforms/qutrits/platform.py
@@ -0,0 +1,45 @@
+import pathlib
+
+from qibolab import ConfigKinds
+from qibolab._core.components import IqChannel
+from qibolab._core.instruments.emulator.emulator import EmulatorController
+from qibolab._core.instruments.emulator.hamiltonians import (
+    DriveEmulatorConfig,
+    HamiltonianConfig,
+)
+from qibolab._core.platform import Platform
+from qibolab._core.qubits import Qubit
+
+FOLDER = pathlib.Path(__file__).parent
+
+ConfigKinds.extend([HamiltonianConfig, DriveEmulatorConfig])
+
+
+def create() -> Platform:
+    """Create a dummy platform using the dummy instrument."""
+    qubits = {}
+    channels = {}
+
+    qubits[0] = qubit = Qubit.default(
+        0, drive_extra={(1, 2): "0/drive12", 1: "01/drive"}
+    )
+    channels |= {
+        qubit.drive: IqChannel(mixer=None, lo=None),
+        qubits[0].drive_extra[1, 2]: IqChannel(mixer=None, lo=None),
+        qubits[0].drive_extra[1]: IqChannel(mixer=None, lo=None),
+    }
+    qubits[1] = qubit = Qubit.default(1, drive_extra={(1, 2): "1/drive12"})
+    channels |= {
+        qubit.drive: IqChannel(mixer=None, lo=None),
+        qubits[1].drive_extra[1, 2]: IqChannel(mixer=None, lo=None),
+    }
+    # register the instruments
+    instruments = {
+        "dummy": EmulatorController(address="0.0.0.0", channels=channels),
+    }
+
+    return Platform.load(
+        path=FOLDER,
+        instruments=instruments,
+        qubits=qubits,
+    )
diff --git a/src/qibocal/auto/transpile.py b/src/qibocal/auto/transpile.py
index a38872bc1d..0dd180d272 100644
--- a/src/qibocal/auto/transpile.py
+++ b/src/qibocal/auto/transpile.py
@@ -124,7 +124,11 @@ def natives(platform) -> dict[str, NativeContainer]:
         # add two qubit natives only if there are pairs
         pair = next(iter(platform.pairs))
         two_qubit_natives_container = platform.natives.two_qubit[pair]
-        two_qubit_natives = list(two_qubit_natives_container.model_fields)
+        two_qubit_natives = [
+            i
+            for i in list(two_qubit_natives_container.model_fields)
+            if getattr(two_qubit_natives_container, i) is not None
+        ]
     else:
         two_qubit_natives = []
     # Solve Qibo-Qibolab mismatch
diff --git a/src/qibocal/protocols/rabi/utils.py b/src/qibocal/protocols/rabi/utils.py
index 03b6ccbe19..4aadf70a90 100644
--- a/src/qibocal/protocols/rabi/utils.py
+++ b/src/qibocal/protocols/rabi/utils.py
@@ -361,12 +361,24 @@ def fit_amplitude_function(
     )
     if signal is False:
         perr = np.sqrt(np.diag(perr))
-    if None not in y_limits and None not in x_limits:
-        popt = [
-            y_limits[0] + (y_limits[1] - y_limits[0]) * popt[0],
-            (y_limits[1] - y_limits[0]) * popt[1],
-            popt[2] * (x_limits[1] - x_limits[0]),
-            popt[3] - 2 * np.pi * x_limits[0] / (x_limits[1] - x_limits[0]) / popt[2],
-        ]
+    if None not in x_limits:
+        if None not in y_limits:
+            popt = [
+                y_limits[0] + (y_limits[1] - y_limits[0]) * popt[0],
+                (y_limits[1] - y_limits[0]) * popt[1],
+                popt[2] * (x_limits[1] - x_limits[0]),
+                popt[3]
+                - 2 * np.pi * x_limits[0] / (x_limits[1] - x_limits[0]) / popt[2],
+            ]
+        else:
+            popt = [
+                popt[0],
+                popt[1],
+                popt[2] * (x_limits[1] - x_limits[0]),
+                popt[3]
+                - 2 * np.pi * x_limits[0] / (x_limits[1] - x_limits[0]) / popt[2],
+            ]
     pi_pulse_parameter = popt[2] / 2 * period_correction_factor(phase=popt[3])
+    if not isinstance(popt, list):
+        popt = popt.tolist()
     return popt, perr, pi_pulse_parameter
diff --git a/src/qibocal/protocols/two_qubit_interaction/__init__.py b/src/qibocal/protocols/two_qubit_interaction/__init__.py
index f912a08f52..d71845f43e 100644
--- a/src/qibocal/protocols/two_qubit_interaction/__init__.py
+++ b/src/qibocal/protocols/two_qubit_interaction/__init__.py
@@ -1,9 +1,19 @@
 from .chevron import chevron, chevron_signal
 from .chsh import chsh
+from .cross_resonance import (
+    cross_resonance_amplitude,
+    cross_resonance_length,
+    hamiltonian_tomography_cr_length,
+)
 from .optimize import optimize_two_qubit_gate
 from .virtual_z_phases import correct_virtual_z_phases
 
 __all__ = []
 __all__ += ["chevron", "chevron_signal"]
 __all__ += ["optimize_two_qubit_gate", "correct_virtual_z_phases"]
+__all__ += [
+    "cross_resonance_amplitude",
+    "hamiltonian_tomography_cr_length",
+    "cross_resonance_length",
+]
 __all__ += ["chsh"]
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/__init__.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/__init__.py
new file mode 100644
index 0000000000..39a95575af
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/__init__.py
@@ -0,0 +1,9 @@
+from .amplitude import cross_resonance_amplitude
+from .hamiltonian_tomography import hamiltonian_tomography_cr_length
+from .length import cross_resonance_length
+
+__all__ = [
+    "cross_resonance_amplitude",
+    "hamiltonian_tomography_cr_length",
+    "cross_resonance_length",
+]
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/amplitude.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/amplitude.py
new file mode 100644
index 0000000000..6d9626849e
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/amplitude.py
@@ -0,0 +1,195 @@
+"""Protocol for cross resonance with sweep on amplitude of the pulse."""
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import numpy.typing as npt
+from qibolab import (
+    AcquisitionType,
+    AveragingMode,
+    Parameter,
+    Sweeper,
+)
+
+from ....auto.operation import (
+    Data,
+    Parameters,
+    QubitId,
+    QubitPairId,
+    Results,
+    Routine,
+)
+from ....calibration import CalibrationPlatform
+from ....result import probability
+from ...rabi.utils import fit_amplitude_function, rabi_amplitude_function
+from .utils import SetControl, cr_fit, cr_plot, cr_sequence
+
+CrossResonanceAmplitudeType = np.dtype(
+    [
+        ("prob_target", np.float64),
+        ("error_target", np.float64),
+        ("prob_control", np.float64),
+        ("error_control", np.float64),
+        ("x", np.float64),
+    ]
+)
+"""Custom dtype for cross resonance amplitude."""
+
+
+@dataclass
+class CrossResonanceAmplitudeParameters(Parameters):
+    """CrossResonanceAmplitude runcard inputs."""
+
+    min_amp: float
+    """Minimum amplitude."""
+    max_amp: float
+    """Maximum amplitude."""
+    step_amp: float
+    """Step amplitude."""
+    pulse_duration: int
+    """CR pulse duration in ns."""
+    echo: bool = False
+    """Apply echo sequence or not."""
+
+    @property
+    def amplitude_range(self):
+        return np.arange(self.min_amp, self.max_amp, self.step_amp)
+
+
+@dataclass
+class CrossResonanceAmplitudeResults(Results):
+    """CrossResonanceAmplitude outputs."""
+
+    fitted_parameters: dict[tuple[QubitPairId, str], list] = field(default_factory=dict)
+
+    def __contains__(self, pair: QubitPairId):
+        return all(key[:2] == pair for key in list(self.fitted_parameters))
+
+
+@dataclass
+class CrossResonanceAmplitudeData(Data):
+    """Data structure for CR amplitude."""
+
+    data: dict[
+        tuple[QubitId, QubitId, str], npt.NDArray[CrossResonanceAmplitudeType]
+    ] = field(default_factory=dict)
+    """Raw data acquired."""
+
+    @property
+    def pairs(self):
+        return {(i[0], i[1]) for i in self.data}
+
+
+def _acquisition(
+    params: CrossResonanceAmplitudeParameters,
+    platform: CalibrationPlatform,
+    targets: list[QubitPairId],
+) -> CrossResonanceAmplitudeData:
+    """Data acquisition for CR amplitude.
+
+    We measure the probabilities of both the target and the control qubit after
+    applying the CR sequence specified by the input parameters. We repeat the
+    measurement twice for each target qubit, once with the control qubit in state 0
+    and once with the control qubit in state 1.
+    """
+
+    data = CrossResonanceAmplitudeData()
+
+    for pair in targets:
+        control, target = pair
+        pair = (control, target)
+        for setup in SetControl:
+            sequence, cr_pulses, _, _ = cr_sequence(
+                platform=platform,
+                control=control,
+                target=target,
+                setup=setup,
+                amplitude=params.min_amp,
+                duration=params.pulse_duration,
+                echo=params.echo,
+            )
+            sweeper = Sweeper(
+                parameter=Parameter.amplitude,
+                values=params.amplitude_range,
+                pulses=cr_pulses,
+            )
+
+            updates = []
+            updates.append(
+                {
+                    platform.qubits[control].drive_extra[target]: {
+                        "frequency": platform.config(
+                            platform.qubits[target].drive
+                        ).frequency
+                    }
+                }
+            )
+            results = platform.execute(
+                [sequence],
+                [[sweeper]],
+                nshots=params.nshots,
+                relaxation_time=params.relaxation_time,
+                acquisition_type=AcquisitionType.DISCRIMINATION,
+                averaging_mode=AveragingMode.SINGLESHOT,
+                updates=updates,
+            )
+
+            target_acq_handle = list(
+                sequence.channel(platform.qubits[target].acquisition)
+            )[-1].id
+            control_acq_handle = list(
+                sequence.channel(platform.qubits[control].acquisition)
+            )[-1].id
+            prob_target = probability(results[target_acq_handle], state=1)
+            prob_control = probability(results[control_acq_handle], state=1)
+            data.register_qubit(
+                CrossResonanceAmplitudeType,
+                (control, target, setup),
+                dict(
+                    x=sweeper.values,
+                    prob_target=prob_target,
+                    error_target=np.sqrt(
+                        prob_target * (1 - prob_target) / params.nshots
+                    ).tolist(),
+                    prob_control=prob_control,
+                    error_control=np.sqrt(
+                        prob_control * (1 - prob_control) / params.nshots
+                    ).tolist(),
+                ),
+            )
+    return data
+
+
+def _fit(
+    data: CrossResonanceAmplitudeData,
+) -> CrossResonanceAmplitudeResults:
+    """Post-processing function for CrossResonanceAmplitude.
+
+    The target qubit probabilities are fitted with cosine oscillations.
+
+    """
+
+    fitted_parameters = cr_fit(data=data, fitting_function=fit_amplitude_function)
+    return CrossResonanceAmplitudeResults(
+        fitted_parameters=fitted_parameters,
+    )
+
+
+def _plot(
+    data: CrossResonanceAmplitudeData,
+    target: QubitPairId,
+    fit: CrossResonanceAmplitudeResults,
+):
+    """Plotting function for CrossResonanceAmplitude."""
+    figs, fitting_report = cr_plot(
+        data=data, target=target, fit=fit, fitting_function=rabi_amplitude_function
+    )
+    figs[0].update_layout(
+        xaxis_title="Cross resonance pulse amplitude [a.u.]",
+        yaxis_title="Excited state population",
+    )
+    return figs, fitting_report
+
+
+cross_resonance_amplitude = Routine(_acquisition, _fit, _plot)
+"""CrossResonance Routine object."""
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/__init__.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/__init__.py
new file mode 100644
index 0000000000..7197098af1
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/__init__.py
@@ -0,0 +1,3 @@
+from .length import (
+    hamiltonian_tomography_cr_length as hamiltonian_tomography_cr_length,
+)
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/fitting.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/fitting.py
new file mode 100644
index 0000000000..4b0a07c70e
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/fitting.py
@@ -0,0 +1,49 @@
+"""Fitting function for CR tomography."""
+
+import numpy as np
+
+
+def fit_Z_exp(t: np.ndarray, wx: float, wy: float, wz: float, w: float) -> np.ndarray:
+    """Fitting Z expectation value for CR tomography.
+
+    See https://arxiv.org/pdf/2303.01427 Eq. S10.
+    """
+    return ((wx**2 + wy**2) * np.cos(w * t) + wz**2) / w**2
+
+
+def fit_X_exp(t: np.ndarray, wx: float, wy: float, wz: float, w: float) -> np.ndarray:
+    """Fitting X expectation value for CR tomography.
+
+    See https://arxiv.org/pdf/2303.01427 Eq. S10.
+    """
+    return (-wx * wz * np.cos(w * t) + w * wy * np.sin(t * w) + wx * wz) / w**2
+
+
+def fit_Y_exp(t: np.ndarray, wx: float, wy: float, wz: float, w: float) -> np.ndarray:
+    """Fitting Y expectation value for CR tomography.
+
+    See https://arxiv.org/pdf/2303.01427 Eq. S10.
+    """
+    return (-w * wx * np.sin(w * t) - wy * wz * np.cos(t * w) + wy * wz) / w**2
+
+
+def combined_fit(
+    t: np.ndarray,
+    wx: float,
+    wy: float,
+    wz: float,
+) -> np.ndarray:
+    """Simulateneous fit for X, Y and Z expectation values.
+
+    We also constrain w to be the norm of the w vector with component
+    wx, wy, wz."""
+
+    w = np.sqrt(wx**2 + wy**2 + wz**2)
+    t1, t2, t3 = np.split(t, 3)
+    return np.concatenate(
+        [
+            fit_X_exp(t1, wx, wy, wz, w),
+            fit_Y_exp(t2, wx, wy, wz, w),
+            fit_Z_exp(t3, wx, wy, wz, w),
+        ]
+    )
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/length.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/length.py
new file mode 100644
index 0000000000..32e51b45eb
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/length.py
@@ -0,0 +1,266 @@
+"""Hamiltonian tomography protocol for CR gate calibration.
+
+This protocol computes the expectation values for X, Y and Z for the target qubit
+after the application of a cross resonance sequence. The CR pulses are played on the control drive
+channel with frequency set to the frequency of the target drive channel.
+"""
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import numpy.typing as npt
+from qibolab import (
+    AcquisitionType,
+    AveragingMode,
+    Parameter,
+    Sweeper,
+)
+from scipy.constants import kilo
+
+from .....auto.operation import (
+    Data,
+    Parameters,
+    QubitId,
+    QubitPairId,
+    Results,
+    Routine,
+)
+from .....calibration import CalibrationPlatform
+from .....result import probability
+from ....utils import table_dict, table_html
+from ..utils import Basis, SetControl, cr_sequence
+from .utils import (
+    HamiltonianTerm,
+    extract_hamiltonian_terms,
+    tomography_cr_fit,
+    tomography_cr_plot,
+)
+
+HamiltonianTomographyCRLengthType = np.dtype(
+    [
+        ("prob_target", np.float64),
+        ("error_target", np.float64),
+        ("prob_control", np.float64),
+        ("error_control", np.float64),
+        ("x", np.int64),
+    ]
+)
+"""Custom dtype for CR length."""
+
+
+@dataclass
+class HamiltonianTomographyCRLengthParameters(Parameters):
+    """HamiltonianTomographyCRLength runcard inputs."""
+
+    pulse_duration_start: float
+    """Initial duration of CR pulse [ns]."""
+    pulse_duration_end: float
+    """Final duration of CR pulse [ns]."""
+    pulse_duration_step: float
+    """Step CR pulse duration [ns]."""
+    pulse_amplitude: float
+    """CR pulse amplitude"""
+    phase: float = 0
+    """Phase of CR pulse."""
+    target_amplitude: float = 0
+    """Amplitude of cancellation pulse."""
+    target_phase: float = 0
+    """Phase of target pulse."""
+    interpolated_sweeper: bool = False
+    """Use real-time interpolation if supported by instruments."""
+    echo: bool = False
+    """Apply echo sequence or not.
+
+    The ECR is described in https://arxiv.org/pdf/1210.7011
+    """
+
+    @property
+    def duration_range(self) -> np.ndarray:
+        """Duration range for CR pulses."""
+        return np.arange(
+            self.pulse_duration_start, self.pulse_duration_end, self.pulse_duration_step
+        )
+
+
+@dataclass
+class HamiltonianTomographyCRLengthResults(Results):
+    """HamiltonianTomographyCRLength outputs."""
+
+    hamiltonian_terms: dict[QubitId, QubitId, HamiltonianTerm] = field(
+        default_factory=dict
+    )
+    """Terms in effective Hamiltonian."""
+    fitted_parameters: dict[tuple[QubitId, QubitId, Basis, SetControl], list] = field(
+        default_factory=dict
+    )
+    """Fitted parameters from X,Y,Z expectation values."""
+
+    def __contains__(self, pair: QubitPairId) -> bool:
+        return all(key[:2] == pair for key in list(self.fitted_parameters))
+
+
+@dataclass
+class HamiltonianTomographyCRLengthData(Data):
+    """Data structure for CR length."""
+
+    data: dict[
+        tuple[QubitId, QubitId, Basis, SetControl],
+        npt.NDArray[HamiltonianTomographyCRLengthType],
+    ] = field(default_factory=dict)
+    """Raw data acquired."""
+
+    @property
+    def pairs(self):
+        return {(i[0], i[1]) for i in self.data}
+
+
+def _acquisition(
+    params: HamiltonianTomographyCRLengthParameters,
+    platform: CalibrationPlatform,
+    targets: list[QubitPairId],
+) -> HamiltonianTomographyCRLengthData:
+    """Data acquisition for Hamiltonian tomography CR protocol.
+
+    We measure the expectation values X,Y and Z on the target qubit after
+    applying the CR sequence specified by the input parameters. We repeat the
+    measurement twice for each target qubit, once with the control qubit in state 0
+    and once with the control qubit in state 1.
+
+    We store the probability of the control qubit and the expectation value of the target qubit.
+
+    """
+
+    data = HamiltonianTomographyCRLengthData()
+
+    for pair in targets:
+        control, target = pair
+        pair = (control, target)
+        for basis in Basis:
+            for setup in SetControl:
+                sequence, cr_pulses, cr_target_pulses, delays = cr_sequence(
+                    platform=platform,
+                    control=control,
+                    target=target,
+                    setup=setup,
+                    amplitude=params.pulse_amplitude,
+                    phase=params.phase,
+                    target_amplitude=params.target_amplitude,
+                    target_phase=params.target_phase,
+                    duration=params.pulse_duration_end,
+                    interpolated_sweeper=params.interpolated_sweeper,
+                    echo=params.echo,
+                    basis=basis,
+                )
+
+                if params.interpolated_sweeper:
+                    sweeper = Sweeper(
+                        parameter=Parameter.duration_interpolated,
+                        values=params.duration_range,
+                        pulses=cr_pulses + cr_target_pulses,
+                    )
+                else:
+                    sweeper = Sweeper(
+                        parameter=Parameter.duration,
+                        values=params.duration_range,
+                        pulses=cr_pulses + cr_target_pulses + delays,
+                    )
+
+                updates = []
+                updates.append(
+                    {
+                        platform.qubits[control].drive_extra[target]: {
+                            "frequency": platform.config(
+                                platform.qubits[target].drive
+                            ).frequency
+                        }
+                    }
+                )
+                results = platform.execute(
+                    [sequence],
+                    [[sweeper]],
+                    nshots=params.nshots,
+                    relaxation_time=params.relaxation_time,
+                    acquisition_type=AcquisitionType.DISCRIMINATION,
+                    averaging_mode=AveragingMode.SINGLESHOT,
+                    updates=updates,
+                )
+                target_acq_handle = list(
+                    sequence.channel(platform.qubits[target].acquisition)
+                )[-1].id
+                control_acq_handle = list(
+                    sequence.channel(platform.qubits[control].acquisition)
+                )[-1].id
+                prob_target = probability(results[target_acq_handle], state=1)
+                prob_control = probability(results[control_acq_handle], state=1)
+                # TODO: possibly drop control probablity even if it might be useful later on
+                # to compute leakage
+                data.register_qubit(
+                    HamiltonianTomographyCRLengthType,
+                    (control, target, basis, setup),
+                    dict(
+                        x=sweeper.values,
+                        prob_target=1 - 2 * prob_target,
+                        error_target=(
+                            2 * np.sqrt(prob_target * (1 - prob_target) / params.nshots)
+                        ).tolist(),
+                        prob_control=prob_control,
+                        error_control=np.sqrt(
+                            prob_control * (1 - prob_control) / params.nshots
+                        ).tolist(),
+                    ),
+                )
+    return data
+
+
+def _fit(
+    data: HamiltonianTomographyCRLengthData,
+) -> HamiltonianTomographyCRLengthResults:
+    """Post-processing function for HamiltonianTomographyCRLength.
+
+    We fit the expectation values using the Eq. S10 from the paper https://arxiv.org/pdf/2303.01427.
+    Afterwards, we extract the Hamiltonian terms from the fitted parameters.
+
+    """
+    fitted_parameters = tomography_cr_fit(
+        data=data,
+    )
+    hamiltonian_terms = {}
+    for pair in data.pairs:
+        hamiltonian_terms |= extract_hamiltonian_terms(
+            pair=pair, fitted_parameters=fitted_parameters
+        )
+
+    return HamiltonianTomographyCRLengthResults(
+        hamiltonian_terms=hamiltonian_terms,
+        fitted_parameters=fitted_parameters,
+    )
+
+
+def _plot(
+    data: HamiltonianTomographyCRLengthData,
+    target: QubitPairId,
+    fit: HamiltonianTomographyCRLengthResults,
+):
+    """Plotting function for HamiltonianTomographyCRLength."""
+    figs, fitting_report = tomography_cr_plot(data, target, fit)
+    figs[0].update_layout(
+        xaxis3_title="CR pulse length [ns]",
+    )
+    if fit is not None:
+        fitting_report = table_html(
+            table_dict(
+                6 * [target],
+                [f"{term.name} [MHz]" for term in HamiltonianTerm],
+                [
+                    fit.hamiltonian_terms[target[0], target[1], term] * kilo
+                    for term in HamiltonianTerm
+                ],
+            )
+        )
+    else:
+        fitting_report = ""
+    return figs, fitting_report
+
+
+hamiltonian_tomography_cr_length = Routine(_acquisition, _fit, _plot)
+"""HamiltonianTomography Routine object."""
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/utils.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/utils.py
new file mode 100644
index 0000000000..6cf1997f6d
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/hamiltonian_tomography/utils.py
@@ -0,0 +1,342 @@
+from enum import Enum
+from typing import Optional, Union
+
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from scipy.optimize import curve_fit
+
+from .....auto.operation import QubitId, QubitPairId
+from .....config import log
+from ....utils import fallback_period, guess_period
+from ..utils import Basis, SetControl
+from . import fitting
+
+
+class HamiltonianTerm(str, Enum):
+    """Hamiltonian terms for CR effective Hamiltonian."""
+
+    IX = "IX"
+    IY = "IY"
+    IZ = "IZ"
+    ZX = "ZX"
+    ZY = "ZY"
+    ZZ = "ZZ"
+
+
+def tomography_cr_fit(
+    data: Union[
+        "HamiltonianTomographyCRLengthData",  # noqa: F821
+        "HamiltonianTomographyCRAmplitudeData",  # noqa: F821
+    ],
+) -> dict[tuple[QubitId, QubitId, Basis, SetControl], list]:
+    """Perform fitting on expectation values for CR tomography.
+
+    We first fit the Z expectation value to get the frequency of the CR pulse.
+    We then fit both the X and Y component.
+    Finally we perform a simultaneous fit all three components taking into account
+    constraint on the parameters.
+    """
+    fitted_parameters = {}
+    for pair in data.pairs:
+        for setup in SetControl:
+            pair_data = data[pair[0], pair[1], Basis.Z, setup]
+            period = fallback_period(guess_period(pair_data.x, pair_data.prob_target))
+            omega = 2 * np.pi / period
+            pguess = [
+                omega / np.sqrt(2),
+                omega / np.sqrt(2),
+                0,
+                omega,
+            ]
+            try:
+                popt, _ = curve_fit(
+                    fitting.fit_Z_exp,
+                    pair_data.x,
+                    pair_data.prob_target,
+                    maxfev=int(1e6),
+                    p0=pguess,
+                    sigma=pair_data.error_target,
+                    bounds=(
+                        [-5 * omega, -5 * omega, -5 * omega, 0],
+                        [
+                            5 * omega,
+                            5 * omega,
+                            5 * omega,
+                            5 * omega,
+                        ],
+                    ),
+                )
+                fitted_parameters[pair[0], pair[1], Basis.Z, setup] = popt.tolist()
+            except Exception as e:  # pragma: no cover
+                log.warning(f"CR Z fit failed for pair {pair} due to {e}.")
+
+    for pair in data.pairs:
+        for setup in SetControl:
+            pair_data = data[pair[0], pair[1], Basis.X, setup]
+            omega = fitted_parameters[pair[0], pair[1], Basis.Z, setup][3]
+            pguess = [0, 0, 0, omega]
+
+            try:
+                popt, _ = curve_fit(
+                    fitting.fit_X_exp,
+                    pair_data.x,
+                    pair_data.prob_target,
+                    maxfev=int(1e6),
+                    p0=pguess,
+                    sigma=pair_data.error_target,
+                    absolute_sigma=True,
+                    bounds=(
+                        [-omega, -omega, -omega, 0.99 * omega],
+                        [
+                            omega,
+                            omega,
+                            omega,
+                            1.01 * omega,
+                        ],
+                    ),
+                )
+                fitted_parameters[pair[0], pair[1], Basis.X, setup] = popt.tolist()
+            except Exception as e:  # pragma: no cover
+                log.warning(f"CR fit failed X for pair {pair} due to {e}.")
+
+    for pair in data.pairs:
+        for setup in SetControl:
+            pair_data = data[pair[0], pair[1], Basis.Y, setup]
+            omega = fitted_parameters[pair[0], pair[1], Basis.Z, setup][3]
+            pguess = [0, 0, 0, omega]
+            try:
+                popt, _ = curve_fit(
+                    fitting.fit_Y_exp,
+                    pair_data.x,
+                    pair_data.prob_target,
+                    maxfev=int(1e6),
+                    sigma=pair_data.error_target,
+                    absolute_sigma=True,
+                    bounds=(
+                        [-omega, -omega, -omega, 0.99 * omega],
+                        [
+                            omega,
+                            omega,
+                            omega,
+                            1.01 * omega,
+                        ],
+                    ),
+                )
+                fitted_parameters[pair[0], pair[1], Basis.Y, setup] = popt.tolist()
+            except Exception as e:  # pragma: no cover
+                log.warning(f"CR Y fit failed for pair {pair} due to {e}.")
+
+    for pair in data.pairs:
+        for setup in SetControl:
+            fitted_parameters[pair[0], pair[1], setup] = fitted_parameters[
+                pair[0], pair[1], Basis.Y, setup
+            ][:3]
+            pguess = fitted_parameters[pair[0], pair[1], setup]
+            popt, _ = curve_fit(
+                fitting.combined_fit,
+                np.concatenate([pair_data.x, pair_data.x, pair_data.x]),
+                np.concatenate(
+                    [
+                        data[pair[0], pair[1], Basis.X, setup].prob_target,
+                        data[pair[0], pair[1], Basis.Y, setup].prob_target,
+                        data[pair[0], pair[1], Basis.Z, setup].prob_target,
+                    ]
+                ),
+                maxfev=int(1e6),
+                p0=pguess,
+                sigma=np.concatenate(
+                    [
+                        data[pair[0], pair[1], Basis.X, setup].error_target,
+                        data[pair[0], pair[1], Basis.Y, setup].error_target,
+                        data[pair[0], pair[1], Basis.Z, setup].error_target,
+                    ]
+                ),
+            )
+            fitted_parameters[pair[0], pair[1], setup] = popt.tolist()
+    return fitted_parameters
+
+
+def extract_hamiltonian_terms(pair: QubitPairId, fitted_parameters: dict) -> dict:
+    """Extract Hamiltonian terms from fitted parameters.
+
+    We follow the procedure presented in the paper https://arxiv.org/pdf/2303.01427.
+    """
+    hamiltonian_terms = {}
+    hamiltonian_terms[pair[0], pair[1], HamiltonianTerm.ZX] = 0.5 * (
+        fitted_parameters[pair[0], pair[1], SetControl.Id][0]
+        - fitted_parameters[pair[0], pair[1], SetControl.X][0]
+    )
+    hamiltonian_terms[pair[0], pair[1], HamiltonianTerm.IX] = 0.5 * (
+        fitted_parameters[pair[0], pair[1], SetControl.Id][0]
+        + fitted_parameters[pair[0], pair[1], SetControl.X][0]
+    )
+    hamiltonian_terms[pair[0], pair[1], HamiltonianTerm.ZY] = 0.5 * (
+        fitted_parameters[pair[0], pair[1], SetControl.Id][1]
+        - fitted_parameters[pair[0], pair[1], SetControl.X][1]
+    )
+    hamiltonian_terms[pair[0], pair[1], HamiltonianTerm.IY] = 0.5 * (
+        fitted_parameters[pair[0], pair[1], SetControl.Id][1]
+        + fitted_parameters[pair[0], pair[1], SetControl.X][1]
+    )
+    hamiltonian_terms[pair[0], pair[1], HamiltonianTerm.ZZ] = 0.5 * (
+        fitted_parameters[pair[0], pair[1], SetControl.Id][2]
+        - fitted_parameters[pair[0], pair[1], SetControl.X][2]
+    )
+    hamiltonian_terms[pair[0], pair[1], HamiltonianTerm.IZ] = 0.5 * (
+        fitted_parameters[pair[0], pair[1], SetControl.Id][2]
+        + fitted_parameters[pair[0], pair[1], SetControl.X][2]
+    )
+    return hamiltonian_terms
+
+
+def tomography_cr_plot(
+    data: Union[
+        "HamiltonianTomographyCRLengthData",  # noqa: F821
+        "HamiltonianTomographyCRAmplitudeData",  # noqa: F821
+    ],
+    target: QubitPairId,
+    fit: Optional[
+        Union[
+            "HamiltonianTomographyCRLengthResults",  # noqa: F821
+            "HamiltonianTomographyCRAmplitudeResults",  # noqa: F821
+        ]
+    ] = None,
+) -> tuple[list[go.Figure], str]:
+    """Plotting function for HamiltonianTomographyCRLength."""
+    fig = make_subplots(
+        rows=3,
+        cols=1,
+        horizontal_spacing=0.1,
+        vertical_spacing=0.05,
+        shared_xaxes=True,
+        shared_yaxes=True,
+    )
+    for i, basis in enumerate(Basis):
+        for setup in SetControl:
+            target = target if target in data.pairs else (target[1], target[0])
+            pair_data = data.data[target[0], target[1], basis, setup]
+            fig.add_trace(
+                go.Scatter(
+                    x=pair_data.x,
+                    y=pair_data.prob_target,
+                    name=f"Target when Control at {0 if setup is SetControl.Id else 1}",
+                    showlegend=True if basis is Basis.Z else False,
+                    legendgroup=f"Target when Control at {0 if setup is SetControl.Id else 1}",
+                    mode="markers",
+                    marker=dict(color="blue" if setup is SetControl.Id else "red"),
+                    error_y=dict(
+                        type="data",
+                        array=pair_data.error_target,
+                        visible=True,
+                    ),
+                ),
+                row=i + 1,
+                col=1,
+            )
+            if fit is not None:
+                x = np.linspace(pair_data.x.min(), pair_data.x.max(), 100)
+                if basis == Basis.Z:
+                    fig.add_trace(
+                        go.Scatter(
+                            x=x,
+                            y=fitting.fit_Z_exp(
+                                x,
+                                *fit.fitted_parameters[
+                                    target[0], target[1], basis, setup
+                                ],
+                            ),
+                            name=f"Single target when control at {0 if setup is SetControl.Id else 1}",
+                            showlegend=True if basis is Basis.Z else False,
+                            legendgroup=f"Single target when control at {0 if setup is SetControl.Id else 1}",
+                            mode="lines",
+                            line=dict(
+                                color="blue" if setup is SetControl.Id else "red",
+                            ),
+                        ),
+                        row=i + 1,
+                        col=1,
+                    )
+                elif basis == Basis.X:
+                    fig.add_trace(
+                        go.Scatter(
+                            x=x,
+                            y=fitting.fit_X_exp(
+                                x,
+                                *fit.fitted_parameters[
+                                    target[0], target[1], basis, setup
+                                ],
+                            ),
+                            name=f"Single target when control at {0 if setup is SetControl.Id else 1}",
+                            showlegend=True if basis is Basis.Z else False,
+                            legendgroup=f"Single target when control at {0 if setup is SetControl.Id else 1}",
+                            mode="lines",
+                            line=dict(
+                                color="blue" if setup is SetControl.Id else "red",
+                            ),
+                        ),
+                        row=i + 1,
+                        col=1,
+                    )
+                elif basis == Basis.Y:
+                    fig.add_trace(
+                        go.Scatter(
+                            x=x,
+                            y=fitting.fit_Y_exp(
+                                x,
+                                *fit.fitted_parameters[
+                                    target[0], target[1], basis, setup
+                                ],
+                            ),
+                            name=f"Single target when control at {0 if setup is SetControl.Id else 1}",
+                            showlegend=True if basis is Basis.Z else False,
+                            legendgroup=f"Single target when control at {0 if setup is SetControl.Id else 1}",
+                            mode="lines",
+                            line=dict(
+                                color="blue" if setup is SetControl.Id else "red",
+                            ),
+                        ),
+                        row=i + 1,
+                        col=1,
+                    )
+
+                fig.add_trace(
+                    go.Scatter(
+                        x=x,
+                        y=getattr(fitting, f"fit_{basis.name}_exp")(
+                            x,
+                            wx=fit.fitted_parameters[target[0], target[1], setup][0],
+                            wy=fit.fitted_parameters[target[0], target[1], setup][1],
+                            wz=fit.fitted_parameters[target[0], target[1], setup][2],
+                            w=np.sqrt(
+                                np.sum(
+                                    i**2
+                                    for i in fit.fitted_parameters[
+                                        target[0], target[1], setup
+                                    ]
+                                )
+                            ),
+                        ),
+                        name=f"Simultaneous Fit of target when control at {0 if setup is SetControl.Id else 1}",
+                        showlegend=True if basis is Basis.Z else False,
+                        legendgroup=f"Simultaneous Fit target when control at {0 if setup is SetControl.Id else 1}",
+                        mode="lines",
+                        line=dict(
+                            color="green" if setup is SetControl.Id else "orange",
+                        ),
+                    ),
+                    row=i + 1,
+                    col=1,
+                )
+
+    fig.update_layout(
+        yaxis1=dict(range=[-1.2, 1.2]),
+        yaxis2=dict(range=[-1.2, 1.2]),
+        yaxis3=dict(range=[-1.2, 1.2]),
+        height=600,
+    )
+    fig.update_yaxes(title_text="<X(t)>", row=1, col=1)
+    fig.update_yaxes(title_text="<Y(t)>", row=2, col=1)
+    fig.update_yaxes(title_text="<Z(t)>", row=3, col=1)
+
+    return [fig], ""
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/length.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/length.py
new file mode 100644
index 0000000000..441696f11a
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/length.py
@@ -0,0 +1,238 @@
+"""Protocol to measure CR interaction varying drive amplitude."""
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import numpy.typing as npt
+from qibolab import (
+    AcquisitionType,
+    AveragingMode,
+    Parameter,
+    Sweeper,
+)
+from scipy.constants import kilo
+
+from ....auto.operation import (
+    Data,
+    Parameters,
+    QubitId,
+    QubitPairId,
+    Results,
+    Routine,
+)
+from ....calibration import CalibrationPlatform
+from ....result import probability
+from ...rabi.utils import fit_length_function, rabi_length_function
+from ...utils import table_dict, table_html
+from .utils import SetControl, cr_fit, cr_plot, cr_sequence
+
+CrossResonanceLengthType = np.dtype(
+    [
+        ("prob_target", np.float64),
+        ("error_target", np.float64),
+        ("prob_control", np.float64),
+        ("error_control", np.float64),
+        ("x", np.int64),
+    ]
+)
+"""Custom dtype for CR length."""
+
+
+@dataclass
+class CrossResonanceLengthParameters(Parameters):
+    """CrossResonanceLength runcard inputs."""
+
+    pulse_duration_start: float
+    """Initial pi pulse duration [ns]."""
+    pulse_duration_end: float
+    """Final pi pulse duration [ns]."""
+    pulse_duration_step: float
+    """Step pi pulse duration [ns]."""
+    pulse_amplitude: float
+    """CR pulse amplitude"""
+    interpolated_sweeper: bool = False
+    """Use real-time interpolation if supported by instruments."""
+    echo: bool = False
+    """Apply echo sequence or not."""
+
+    @property
+    def duration_range(self):
+        return np.arange(
+            self.pulse_duration_start, self.pulse_duration_end, self.pulse_duration_step
+        )
+
+
+@dataclass
+class CrossResonanceLengthResults(Results):
+    """CrossResonanceLength outputs."""
+
+    effective_coupling: dict[tuple[QubitId, QubitId], float] = field(
+        default_factory=dict
+    )
+    fitted_parameters: dict[tuple[QubitPairId, str], list] = field(default_factory=dict)
+
+    def __contains__(self, pair: QubitPairId):
+        return all(key[:2] == pair for key in list(self.fitted_parameters))
+
+
+@dataclass
+class CrossResonanceLengthData(Data):
+    """Data structure for CR length."""
+
+    anharmonicity: dict[QubitPairId, float] = field(default_factory=dict)
+    detuning: dict[QubitPairId, float] = field(default_factory=dict)
+    data: dict[tuple[QubitId, QubitId, str], npt.NDArray[CrossResonanceLengthType]] = (
+        field(default_factory=dict)
+    )
+    """Raw data acquired."""
+
+    @property
+    def pairs(self):
+        return {(i[0], i[1]) for i in self.data}
+
+
+def _acquisition(
+    params: CrossResonanceLengthParameters,
+    platform: CalibrationPlatform,
+    targets: list[QubitPairId],
+) -> CrossResonanceLengthData:
+    """Data acquisition for cross resonance protocol."""
+
+    data = CrossResonanceLengthData()
+
+    for pair in targets:
+        control, target = pair
+        pair = (control, target)
+        data.detuning[pair] = (
+            platform.config(platform.qubits[control].drive).frequency
+            - platform.config(platform.qubits[target].drive).frequency
+        )
+        data.anharmonicity[pair] = platform.calibration.single_qubits[
+            control
+        ].qubit.anharmonicity
+        for setup in SetControl:
+            sequence, cr_pulses, cr_target_pulses, delays = cr_sequence(
+                platform=platform,
+                control=control,
+                target=target,
+                setup=setup,
+                amplitude=params.pulse_amplitude,
+                duration=params.pulse_duration_end,
+                interpolated_sweeper=params.interpolated_sweeper,
+                echo=params.echo,
+            )
+
+            if params.interpolated_sweeper:
+                sweeper = Sweeper(
+                    parameter=Parameter.duration_interpolated,
+                    values=params.duration_range,
+                    pulses=cr_pulses + cr_target_pulses,
+                )
+            else:
+                sweeper = Sweeper(
+                    parameter=Parameter.duration,
+                    values=params.duration_range,
+                    pulses=cr_pulses + cr_target_pulses + delays,
+                )
+
+            updates = []
+            updates.append(
+                {
+                    platform.qubits[control].drive_extra[target]: {
+                        "frequency": platform.config(
+                            platform.qubits[target].drive
+                        ).frequency
+                    }
+                }
+            )
+            # execute the sweep
+            results = platform.execute(
+                [sequence],
+                [[sweeper]],
+                nshots=params.nshots,
+                relaxation_time=params.relaxation_time,
+                acquisition_type=AcquisitionType.DISCRIMINATION,
+                averaging_mode=AveragingMode.SINGLESHOT,
+                updates=updates,
+            )
+            target_acq_handle = list(
+                sequence.channel(platform.qubits[target].acquisition)
+            )[-1].id
+            control_acq_handle = list(
+                sequence.channel(platform.qubits[control].acquisition)
+            )[-1].id
+            prob_target = probability(results[target_acq_handle], state=1)
+            prob_control = probability(results[control_acq_handle], state=1)
+            data.register_qubit(
+                CrossResonanceLengthType,
+                (control, target, setup),
+                dict(
+                    x=sweeper.values,
+                    prob_target=prob_target,
+                    error_target=np.sqrt(
+                        prob_target * (1 - prob_target) / params.nshots
+                    ).tolist(),
+                    prob_control=prob_control,
+                    error_control=np.sqrt(
+                        prob_control * (1 - prob_control) / params.nshots
+                    ).tolist(),
+                ),
+            )
+    # finally, save the remaining data
+    return data
+
+
+def _fit(
+    data: CrossResonanceLengthData,
+) -> CrossResonanceLengthResults:
+    """Post-processing function for CrossResonanceLength.
+
+    After fitting the data with dumped cosine function, the effective coupling
+    is computed as specified in https://arxiv.org/pdf/1905.11480.
+
+    """
+    fitted_parameters = cr_fit(data=data, fitting_function=fit_length_function)
+    effective_coupling = {}
+    for pair in data.pairs:
+        try:
+            effective_coupling[pair] = (
+                1 / fitted_parameters[pair[0], pair[1], SetControl.X][2]
+                - 1 / fitted_parameters[pair[0], pair[1], SetControl.Id][2]
+            ) / 2
+        except KeyError:  # pragma: no cover
+            pass
+    return CrossResonanceLengthResults(
+        effective_coupling=effective_coupling,
+        fitted_parameters=fitted_parameters,
+    )
+
+
+def _plot(
+    data: CrossResonanceLengthData,
+    target: QubitPairId,
+    fit: CrossResonanceLengthResults,
+):
+    """Plotting function for CrossResonanceLength."""
+    figs, fitting_report = cr_plot(
+        data=data, target=target, fit=fit, fitting_function=rabi_length_function
+    )
+    if fit is not None:
+        fitting_report = table_html(
+            table_dict(
+                [target],
+                [
+                    "Effective coupling [MHz]",
+                ],
+                [fit.effective_coupling[target] * kilo],
+            )
+        )
+
+    figs[0].update_layout(
+        xaxis_title="Cross resonance pulse duration [ns]",
+        yaxis_title="Excited state population",
+    )
+    return figs, fitting_report
+
+
+cross_resonance_length = Routine(_acquisition, _fit, _plot)
+"""CrossResonance Routine object."""
diff --git a/src/qibocal/protocols/two_qubit_interaction/cross_resonance/utils.py b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/utils.py
new file mode 100644
index 0000000000..aba748be13
--- /dev/null
+++ b/src/qibocal/protocols/two_qubit_interaction/cross_resonance/utils.py
@@ -0,0 +1,279 @@
+from enum import Enum
+from typing import Callable, Optional, Union
+
+import numpy as np
+import plotly.graph_objects as go
+from qibolab import Delay, Platform, Pulse, PulseSequence, Rectangular
+
+from ....auto.operation import QubitId, QubitPairId
+from ....config import log
+from ....update import replace
+from ...utils import fallback_period, guess_period
+
+
+class SetControl(str, Enum):
+    """Helper to create sequence with control set to X or I."""
+
+    Id = "Id"
+    X = "X"
+
+
+class Basis(str, Enum):
+    """Measurement basis."""
+
+    X = "X"
+    Y = "Y"
+    Z = "Z"
+
+
+def cr_sequence(
+    platform: Platform,
+    control: QubitId,
+    target: QubitId,
+    setup: SetControl,
+    amplitude: float,
+    duration: int,
+    target_amplitude: float = 0,
+    target_phase: float = 0,
+    interpolated_sweeper: bool = False,
+    echo: bool = False,
+    basis: Basis = Basis.Z,
+    phase: float = 0,
+) -> tuple[PulseSequence, list[Pulse], list[Pulse], list[Delay]]:
+    """Creates sequence for CR experiment on ``control`` and ``target`` qubits.
+
+    With ``setup`` it is possible to set the control qubit to 1 or keep it at 0.
+    If ``echo`` is set to ``True`` a ECR gate will be played.
+    With ``basis`` it is possible to set the measurement basis. If it is not provided
+    the default is Z."""
+
+    cr_pulses = []
+    cr_target_pulses = []
+    sequence = PulseSequence()
+    natives_control = platform.natives.single_qubit[control]
+    natives_target = platform.natives.single_qubit[target]
+    cr_channel = platform.qubits[control].drive_extra[target]
+    cr_drive_pulse = Pulse(
+        duration=duration,
+        amplitude=amplitude,
+        relative_phase=phase,
+        # envelope=GaussianSquare(rel_sigma=0.2, risefall=15),
+        envelope=Rectangular(),
+    )
+    target_drive_pulse = Pulse(
+        duration=duration,
+        amplitude=target_amplitude,
+        relative_phase=target_phase,
+        # envelope=GaussianSquare(rel_sigma=0.2, risefall=15),
+        envelope=Rectangular(),
+    )
+    cr_pulses.append(cr_drive_pulse)
+    cr_target_pulses.append(target_drive_pulse)
+    control_drive_channel, control_drive_pulse = natives_control.RX()[0]
+    target_drive_channel, _ = natives_target.RX()[0]
+    ro_channel, ro_pulse = natives_target.MZ()[0]
+    ro_channel_control, ro_pulse_control = natives_control.MZ()[0]
+    if setup == SetControl.X:
+        control_delay = Delay(duration=control_drive_pulse.duration)
+        sequence.append((control_drive_channel, control_drive_pulse))
+        sequence.append((target_drive_channel, control_delay))
+        sequence.append((ro_channel, control_delay))
+        sequence.append((ro_channel_control, control_delay))
+        sequence.append((cr_channel, control_delay))
+
+    if echo:
+        delays = 6 * [Delay(duration=cr_drive_pulse.duration)]
+        control_delay = Delay(duration=control_drive_pulse.duration)
+        cr_pulse_minus = replace(cr_drive_pulse, relative_phase=np.pi)
+        target_pulse_minus = replace(target_drive_pulse, relative_phase=np.pi)
+        cr_pulses.append(cr_pulse_minus)
+        cr_target_pulses.append(target_pulse_minus)
+        sequence.append((cr_channel, cr_drive_pulse))
+        sequence.append((control_drive_channel, delays[-1]))
+        sequence.append((target_drive_channel, target_drive_pulse))
+        sequence.append((control_drive_channel, control_drive_pulse))
+        sequence.append((cr_channel, control_delay))
+        sequence.append((target_drive_channel, control_delay))
+        sequence.append((cr_channel, cr_pulse_minus))
+        sequence.append((control_drive_channel, delays[-2]))
+        sequence.append((target_drive_channel, target_pulse_minus))
+        sequence.append((control_drive_channel, control_drive_pulse))
+        sequence.append((target_drive_channel, control_delay))
+
+    else:
+        delays = 2 * [Delay(duration=cr_drive_pulse.duration)]
+        sequence.append((cr_channel, cr_drive_pulse))
+        sequence.append((target_drive_channel, target_drive_pulse))
+
+    if interpolated_sweeper:
+        sequence.align(
+            [
+                cr_channel,
+                target_drive_channel,
+                control_drive_channel,
+                ro_channel,
+                ro_channel_control,
+            ]
+        )
+    else:
+        sequence.append((ro_channel, delays[0]))
+        sequence.append((ro_channel_control, delays[1]))
+        if echo:
+            sequence.append((ro_channel, delays[2]))
+            sequence.append((ro_channel_control, delays[3]))
+            sequence.append(
+                (ro_channel, Delay(duration=2 * control_drive_pulse.duration))
+            )
+            sequence.append(
+                (ro_channel_control, Delay(duration=2 * control_drive_pulse.duration))
+            )
+
+    if basis == Basis.X:
+        sequence.append(
+            (
+                target_drive_channel,
+                natives_target.R(theta=np.pi / 2, phi=np.pi / 2)[0][1],
+            )
+        )
+    elif basis == Basis.Y:
+        sequence.append(
+            (
+                target_drive_channel,
+                natives_target.R(theta=np.pi / 2, phi=0)[0][1],
+            )
+        )
+
+    target_delay = Delay(
+        duration=natives_target.R(theta=np.pi / 2, phi=np.pi / 2)[0][1].duration
+    )
+    sequence.append((ro_channel, target_delay))
+    sequence.append((ro_channel_control, target_delay))
+    sequence.append((ro_channel, ro_pulse))
+    sequence.append((ro_channel_control, ro_pulse_control))
+    return sequence, cr_pulses, cr_target_pulses, delays
+
+
+def cr_fit(
+    data: Union[
+        "CrossResonanceLengthData",  # noqa: F821
+        "CrossResonanceAmplitudeData",  # noqa: F821
+    ],
+    fitting_function: Callable,
+) -> dict[tuple[QubitId, QubitId, SetControl], list]:
+    """Perform fitting on CR data for probabilities.
+
+    We fit oscillations observed in the target qubit. Using a cosine function.
+    When on the x axis we change the duration of the CR pulse we include an exponential
+    term to address the relaxation time of the qubit.
+    """
+    fitted_parameters = {}
+    for pair in data.pairs:
+        for setup in SetControl:
+            pair_data = data[pair[0], pair[1], setup]
+            pair = (pair[0], pair[1])
+            raw_x = pair_data.x
+            min_x = np.min(raw_x)
+            max_x = np.max(raw_x)
+            y = pair_data.prob_target
+            x = (raw_x - min_x) / (max_x - min_x)
+
+            period = fallback_period(guess_period(x, y))
+            pguess = (
+                [0, 0.5, period, 0, 0]
+                if fitting_function.__name__ == "fit_length_function"
+                else [0, 0.5, period, 0]
+            )
+
+            try:
+                popt, _, _ = fitting_function(
+                    x,
+                    y,
+                    pguess,
+                    sigma=pair_data.error_target,
+                    signal=False,
+                    x_limits=(min_x, max_x),
+                )
+                fitted_parameters[pair[0], pair[1], setup] = popt
+            except Exception as e:  # pragma: no cover
+                log.warning(f"CR fit failed for pair {pair} due to {e}.")
+    return fitted_parameters
+
+
+def cr_plot(
+    data: Union[
+        "CrossResonanceLengthData",  # noqa: F821
+        "CrossResonanceAmplitudeData",  # noqa: F821
+    ],
+    target: QubitPairId,
+    fit: Optional[
+        Union[
+            "CrossResonanceLengthResults",  # noqa: F821
+            "CrossResonanceAmplitudeResults",  # noqa: F821
+        ]
+    ] = None,
+    fitting_function: Optional[Callable] = None,
+) -> tuple[list[go.Figure], str]:
+    """Plotting function for CR protocols."""
+    fig = go.Figure()
+    for setup in SetControl:
+        target = target if target in data.pairs else (target[1], target[0])
+        pair_data = data.data[target[0], target[1], setup]
+        fig.add_trace(
+            go.Scatter(
+                x=pair_data.x,
+                y=pair_data.prob_target,
+                name=f"Target when Control at {0 if setup is SetControl.Id else 1}",
+                showlegend=True,
+                legendgroup=f"Target when Control at {0 if setup is SetControl.Id else 1}",
+                mode="markers",
+                marker=dict(color="blue" if setup is SetControl.Id else "red"),
+                error_y=dict(
+                    type="data",
+                    array=pair_data.error_target,
+                    visible=True,
+                ),
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=pair_data.x,
+                y=pair_data.prob_control,
+                name=f"Control at {0 if setup is SetControl.Id else 1}",
+                showlegend=True,
+                legendgroup=f"Control at {0 if setup is SetControl.Id else 1}",
+                mode="markers",
+                marker=dict(color="green" if setup is SetControl.Id else "orange"),
+                error_y=dict(
+                    type="data",
+                    array=pair_data.error_control,
+                    visible=True,
+                ),
+            )
+        )
+        if fit is not None:
+            if (target[0], target[1], setup) in fit.fitted_parameters:
+                x = np.linspace(pair_data.x.min(), pair_data.x.max(), 100)
+                fig.add_trace(
+                    go.Scatter(
+                        x=x,
+                        y=fitting_function(
+                            x,
+                            *fit.fitted_parameters[target[0], target[1], setup],
+                        ),
+                        name=f"Fit target when control at {0 if setup is SetControl.Id else 1}",
+                        showlegend=True,
+                        legendgroup=f"Fit target when control at {0 if setup is SetControl.Id else 1}",
+                        mode="lines",
+                        line=dict(
+                            color="blue" if setup is SetControl.Id else "red",
+                        ),
+                    )
+                )
+
+    fig.update_layout(
+        yaxis1=dict(range=[-0.1, 1.1]),
+        yaxis2=dict(range=[-0.1, 1.1]),
+        yaxis3=dict(range=[-0.1, 1.1]),
+        height=600,
+    )
+    return [fig], ""
diff --git a/tests/platforms/mock/parameters.json b/tests/platforms/mock/parameters.json
index 73088cd713..4ae09c6fcd 100644
--- a/tests/platforms/mock/parameters.json
+++ b/tests/platforms/mock/parameters.json
@@ -14,6 +14,10 @@
       "kind": "iq",
       "frequency": 4000000000.0
     },
+    "01/drive": {
+      "kind": "iq",
+      "frequency": 4200000000.0
+    },
     "1/drive": {
       "kind": "iq",
       "frequency": 4200000000.0
diff --git a/tests/platforms/mock/platform.py b/tests/platforms/mock/platform.py
index c324b924d5..5457c97136 100644
--- a/tests/platforms/mock/platform.py
+++ b/tests/platforms/mock/platform.py
@@ -21,19 +21,28 @@ def create_mock_hardware() -> Hardware:
     channels = {}
     # attach the channels
     pump_name = "twpa_pump"
-    for q in range(2):
-        drive12 = f"{q}/drive12"
-        qubits[q] = qubit = Qubit.default(q, drive_extra={(1, 2): drive12})
-        channels |= {
-            qubit.probe: IqChannel(mixer=None, lo="01/probe_lo"),
-            qubit.acquisition: AcquisitionChannel(
-                twpa_pump=pump_name, probe=qubit.probe
-            ),
-            qubit.drive: IqChannel(mixer=None, lo=f"{q}/drive_lo"),
-            drive12: IqChannel(mixer=None, lo=f"{q}/drive_lo"),
-            qubit.flux: DcChannel(),
-        }
-
+    qubits[0] = Qubit.default(0, drive_extra={(1, 2): "0/drive12", 1: "01/drive"})
+
+    channels |= {
+        qubits[0].probe: IqChannel(mixer=None, lo="01/probe_lo"),
+        qubits[0].acquisition: AcquisitionChannel(
+            twpa_pump=pump_name, probe=qubits[0].probe
+        ),
+        qubits[0].drive: IqChannel(mixer=None, lo="0/drive_lo"),
+        qubits[0].drive_extra[1, 2]: IqChannel(mixer=None, lo="0/drive_lo"),
+        qubits[0].drive_extra[1]: IqChannel(mixer=None, lo="0/drive_lo"),
+        qubits[0].flux: DcChannel(),
+    }
+    qubits[1] = Qubit.default(1, drive_extra={(1, 2): "0/drive12"})
+    channels |= {
+        qubits[1].probe: IqChannel(mixer=None, lo="01/probe_lo"),
+        qubits[1].acquisition: AcquisitionChannel(
+            twpa_pump=pump_name, probe=qubits[1].probe
+        ),
+        qubits[1].drive: IqChannel(mixer=None, lo="1/drive_lo"),
+        qubits[1].drive_extra[1, 2]: IqChannel(mixer=None, lo="1/drive_lo"),
+        qubits[1].flux: DcChannel(),
+    }
     couplers = {}
     couplers["01"] = coupler = Qubit(flux="coupler_01/flux")
     channels |= {coupler.flux: DcChannel()}
diff --git a/tests/runcards/protocols.yml b/tests/runcards/protocols.yml
index 679c84eb0c..363c2908d4 100644
--- a/tests/runcards/protocols.yml
+++ b/tests/runcards/protocols.yml
@@ -973,6 +973,24 @@ actions:
       flux_pulse_amplitude: 0.1
       relaxation_time: 50_000
 
+  - id: cr length
+    operation: cross_resonance_length
+    targets: [[0,1]]
+    parameters:
+      pulse_duration_start: 1
+      pulse_duration_end: 10
+      pulse_duration_step: 1
+      pulse_amplitude: 0.1
+
+  - id: cr amp
+    operation: cross_resonance_amplitude
+    targets: [[0,1]]
+    parameters:
+      min_amp: 0.1
+      max_amp: 1
+      step_amp: 0.1
+      pulse_duration: 10
+
   - id: Qubit VZ
     operation: qubit_vz
     parameters:
@@ -982,6 +1000,59 @@ actions:
       nshots: 45
       relaxation_time: 100_000
 
+  - id: cross_resonance amp
+    operation: cross_resonance_amplitude
+    targets: [[0, 1]]
+    parameters:
+      min_amp: 0.01
+      max_amp: 0.1
+      step_amp: 0.01
+      echo: true
+      nshots: 2000
+      pulse_duration: 10
+
+  - id: cross_resonance length
+    operation: cross_resonance_length
+    targets: [[0, 1]]
+    parameters:
+      pulse_duration_start: 10
+      pulse_duration_end: 20
+      pulse_duration_step: 1
+      pulse_amplitude: 0.1
+      nshots: 2000
+
+  - id: cross_resonance length interpolated
+    operation: cross_resonance_length
+    targets: [[0, 1]]
+    parameters:
+      pulse_duration_start: 10
+      pulse_duration_end: 20
+      pulse_duration_step: 1
+      nshots: 2000
+      pulse_amplitude: 0.1
+      interpolated_sweeper: true
+
+  - id: CR tomography
+    operation: hamiltonian_tomography_cr_length
+    targets: [[0, 1]]
+    parameters:
+      pulse_duration_start: 10
+      pulse_duration_end: 20
+      pulse_duration_step: 1
+      nshots: 2000
+      pulse_amplitude: 0.1
+
+
+  - id: CR tomography interpolated
+    operation: hamiltonian_tomography_cr_length
+    targets: [[0, 1]]
+    parameters:
+      pulse_duration_start: 10
+      pulse_duration_end: 20
+      pulse_duration_step: 1
+      nshots: 2000
+      pulse_amplitude: 0.1
+      interpolated_sweeper: true
   - id: twpa_calibration
     operation: twpa_calibration
     parameters: