diff --git a/docs/core_logic.md b/docs/core_logic.md
index d5b5806..86c7a85 100644
--- a/docs/core_logic.md
+++ b/docs/core_logic.md
@@ -36,18 +36,18 @@ The context stores the following data:
 - `operator_to_qubits`: a map from a logical operator's ID to the ID of the logical qubit it belongs to.
 - `qubit_to_code`: similar to the previous one, but for logical qubits belonging to a code.
 - `detector_port`: a state object used to create detectors between primitives. See the [primitives guide](qec_primitives.md) for more details.
-- `quantum_memory`: a `QuantumMemory` object that stores the assignment of physical qubits to Tanner-graph nodes.
+- `quantum_memory`: a `QuantumMemory` object that stores the assignment of physical qubits to the data nodes and a pool of ancilla available for the gadget to reserve.
 - `measurement_record`: a `MeasurementRecord` object that stores all measurements, alongside indexing that allows them to be explored efficiently.
 - `compilation_time`: a kind of internal clock tracking which cycle we are in. This is not really used, though.
 
 Although the logic is quite straightforward, the following points are worth noting:
- - First, when codes are allocated, they are added to the context's memory alongside their logical qubits and the corresponding logical operators. The context stores these structures until they are freed. While they are stored, we expect that nothing will modify them, except for logical-operator corrections, which are handled only by the compiler itself.
+ - First, when codes are allocated, they are added to the context's memory alongside their logical qubits and the corresponding logical operators. The context stores these structures until they are freed. While they are stored, we expect that nothing will modify them, except for logical-operator corrections, which are handled only by the compiler itself. When allocated, physical qubits are assigned to each data qubits of the code (not to checks, as they aren't necessary map 1-1 with physical qubits).
 
 - Second, logical-operator corrections are added to the logical operators at the end of each gadget, in `ctx.add_updates(lop_updates)` in the pseudocode. They are stored within the `LogicalOperator` object itself as a list of measurements, which will flip the observable outcome if their outcome parity is odd.
 
 - Finally, observables are "resolved" when they are added to the context. This means that we append to their set of measurements the corrections that exist in each of the logical operators involved in the observables, and we correctly refer the measurements to those created by the primitives.
 
-Also, the context is supposed to be modified only by the compiler, so we tried, as much as possible, to provide only views of the different objects to gadgets and primitives. Quantum memory is still allocated inside primitives, which is not ideal. This will be fixed in the near future; see the targeted design fix here.
+Also, the context is supposed to be modified only by the compiler, so we tried, as much as possible, to provide only views of the different objects to gadgets and primitives. Quantum memory is given to gadgets, that are allowed to lock/free ancillas. This is not ideal, and we'll eventually find a way to restrict the interface.
  
 
 
diff --git a/docs/getting_started.ipynb b/docs/getting_started.ipynb
index 3daafdd..0807256 100644
--- a/docs/getting_started.ipynb
+++ b/docs/getting_started.ipynb
@@ -16,7 +16,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 13,
    "id": "19bc88b3",
    "metadata": {},
    "outputs": [],
@@ -41,7 +41,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 14,
    "id": "8689def6",
    "metadata": {},
    "outputs": [],
@@ -122,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 15,
    "id": "f5112dfb",
    "metadata": {},
    "outputs": [],
@@ -147,10 +147,471 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 16,
    "id": "6c785daf",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RX 34 7 28 8 1 33 32 31 6 30 29 5 0 27 2 4 3\n",
+      "# RSC syndrome extraction \n",
+      "RZ 31 33 27 30 34 32 29 28\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 27 34 32 29\n",
+      "   TICK\n",
+      "   CX 7 31 6 33 27 3 1 30 34 2 32 5\n",
+      "   TICK\n",
+      "   CX 3 31 5 33 27 6 8 30 34 1 32 0\n",
+      "   TICK\n",
+      "   CX 2 31 8 33 27 4 34 6 29 7 3 28\n",
+      "   TICK\n",
+      "   CX 6 31 0 33 27 5 34 8 29 2 4 28\n",
+      "   TICK\n",
+      "   H 27 34 32 29\n",
+      "   TICK\n",
+      "   MRZ 31 33 27 30 34 32 29 28\n",
+      "}\n",
+      "RZ 29 10 32 17 33 15 16 34 13 14 28 12 31 27 30 9 11\n",
+      "# RSC syndrome extraction \n",
+      "RZ 31 33 27 30 34 32 29 28\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 31 30 34 32\n",
+      "   TICK\n",
+      "   CX 31 13 15 33 30 14 34 12 11 29 10 28\n",
+      "   TICK\n",
+      "   CX 31 11 12 33 30 16 34 10 17 29 14 28\n",
+      "   TICK\n",
+      "   CX 31 10 13 33 12 27 34 9 32 15 17 28\n",
+      "   TICK\n",
+      "   CX 31 17 10 33 9 27 34 14 32 13 16 28\n",
+      "   TICK\n",
+      "   H 31 30 34 32\n",
+      "   TICK\n",
+      "   MRZ 31 33 27 30 34 32 29 28\n",
+      "}\n",
+      "RZ 31 18 28 32 25 30 29 22 20 19 27 24 26 21 23 33 34\n",
+      "# RSC syndrome extraction \n",
+      "RZ 31 33 27 30 34 32 29 28\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 31 33 27 30\n",
+      "   TICK\n",
+      "   CX 31 19 33 20 27 22 23 34 25 32 18 29\n",
+      "   TICK\n",
+      "   CX 31 25 33 24 27 18 19 34 20 32 21 29\n",
+      "   TICK\n",
+      "   CX 31 26 27 25 30 23 22 34 21 32 19 28\n",
+      "   TICK\n",
+      "   CX 31 20 27 21 30 22 25 34 24 32 26 28\n",
+      "   TICK\n",
+      "   H 31 33 27 30\n",
+      "   TICK\n",
+      "   MRZ 31 33 27 30 34 32 29 28\n",
+      "}\n",
+      "RX 40 37 31 28 32 29 43\n",
+      "# RSC syndrome extraction rsc_surgery_merged_syndrome_MZZ_ac\n",
+      "RZ 42 30 43 46 37 49 44 34 32 27 36 35 29 41 45 47 38 48 33 39\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 42 49 34 36 35 38 48 33\n",
+      "   TICK\n",
+      "   CX 42 13 7 30 4 43 15 46 31 37 49 14 11 44 34 5 35 3 0 29 6 45 1 47 38 2 48 12 33 40 10 39\n",
+      "   TICK\n",
+      "   CX 42 11 3 30 40 43 12 46 13 37 49 16 17 44 34 0 35 6 28 29 5 45 8 47 38 1 48 10 33 31 14 39\n",
+      "   TICK\n",
+      "   CX 42 10 2 30 5 43 13 46 28 37 34 31 40 32 12 27 36 7 35 4 3 41 8 45 38 6 48 9 33 15 17 39\n",
+      "   TICK\n",
+      "   CX 42 17 6 30 31 43 10 46 11 37 34 28 15 32 9 27 36 2 35 5 4 41 0 45 38 8 48 14 33 13 16 39\n",
+      "   TICK\n",
+      "   H 42 49 34 36 35 38 48 33\n",
+      "   TICK\n",
+      "   MRZ 42 30 43 46 37 49 44 34 32 27 36 35 29 41 45 47 38 48 33 39\n",
+      "}\n",
+      "MX 28 40 31\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MZZ_ac\n",
+      "RZ 42 46 27 49 48 33 44 39\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 42 49 48 33\n",
+      "   TICK\n",
+      "   CX 42 13 15 46 49 14 48 12 11 44 10 39\n",
+      "   TICK\n",
+      "   CX 42 11 12 46 49 16 48 10 17 44 14 39\n",
+      "   TICK\n",
+      "   CX 42 10 13 46 12 27 48 9 33 15 17 39\n",
+      "   TICK\n",
+      "   CX 42 17 10 46 9 27 48 14 33 13 16 39\n",
+      "   TICK\n",
+      "   H 42 49 48 33\n",
+      "   TICK\n",
+      "   MRZ 42 46 27 49 48 33 44 39\n",
+      "}\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MZZ_ac\n",
+      "RZ 30 45 35 47 38 34 36 41\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 35 38 34 36\n",
+      "   TICK\n",
+      "   CX 7 30 6 45 35 3 1 47 38 2 34 5\n",
+      "   TICK\n",
+      "   CX 3 30 5 45 35 6 8 47 38 1 34 0\n",
+      "   TICK\n",
+      "   CX 2 30 8 45 35 4 38 6 36 7 3 41\n",
+      "   TICK\n",
+      "   CX 6 30 0 45 35 5 38 8 36 2 4 41\n",
+      "   TICK\n",
+      "   H 35 38 34 36\n",
+      "   TICK\n",
+      "   MRZ 30 45 35 47 38 34 36 41\n",
+      "}\n",
+      "RZ 29 37 49 28 36 42 27\n",
+      "# RSC syndrome extraction rsc_surgery_merged_syndrome_MXX_ct\n",
+      "RZ 30 35 37 44 41 34 48 40 43 46 49 32 45 28 39 31 47 38 33 36\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 35 37 44 34 43 46 49 28 31 47 38 36\n",
+      "   TICK\n",
+      "   CX 7 30 35 19 37 29 44 22 25 41 34 5 23 48 46 3 49 21 27 32 6 45 1 39 31 2 47 20 18 33 36 42\n",
+      "   TICK\n",
+      "   CX 3 30 35 25 37 7 44 18 20 41 34 0 19 48 46 6 49 27 42 32 5 45 8 39 31 1 47 24 21 33 36 4\n",
+      "   TICK\n",
+      "   CX 2 30 35 26 37 27 44 25 21 41 22 48 19 40 43 7 46 4 49 24 3 32 8 45 28 18 31 6 38 23 29 33\n",
+      "   TICK\n",
+      "   CX 6 30 35 20 37 3 44 21 24 41 25 48 26 40 43 2 46 5 49 42 4 32 0 45 28 29 31 8 38 22 27 33\n",
+      "   TICK\n",
+      "   H 35 37 44 34 43 46 49 28 31 47 38 36\n",
+      "   TICK\n",
+      "   MRZ 30 35 37 44 41 34 48 40 43 46 49 32 45 28 39 31 47 38 33 36\n",
+      "}\n",
+      "MZ 27 42 29\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MXX_ct\n",
+      "RZ 30 45 46 39 31 34 43 32\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 46 31 34 43\n",
+      "   TICK\n",
+      "   CX 7 30 6 45 46 3 1 39 31 2 34 5\n",
+      "   TICK\n",
+      "   CX 3 30 5 45 46 6 8 39 31 1 34 0\n",
+      "   TICK\n",
+      "   CX 2 30 8 45 46 4 31 6 43 7 3 32\n",
+      "   TICK\n",
+      "   CX 6 30 0 45 46 5 31 8 43 2 4 32\n",
+      "   TICK\n",
+      "   H 46 31 34 43\n",
+      "   TICK\n",
+      "   MRZ 30 45 46 39 31 34 43 32\n",
+      "}\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MXX_ct\n",
+      "RZ 35 47 44 38 48 41 33 40\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 35 47 44 38\n",
+      "   TICK\n",
+      "   CX 35 19 47 20 44 22 23 48 25 41 18 33\n",
+      "   TICK\n",
+      "   CX 35 25 47 24 44 18 19 48 20 41 21 33\n",
+      "   TICK\n",
+      "   CX 35 26 44 25 38 23 22 48 21 41 19 40\n",
+      "   TICK\n",
+      "   CX 35 20 44 21 38 22 25 48 24 41 26 40\n",
+      "   TICK\n",
+      "   H 35 47 44 38\n",
+      "   TICK\n",
+      "   MRZ 35 47 44 38 48 41 33 40\n",
+      "}\n",
+      "MZ 14 9 10 16 15 13 11 17 12\n",
+      "MZ 5 4 1 6 3 0 2 7 8\n",
+      "MZ 24 19 20 21 23 18 26 25 22\n",
+      "DETECTOR rec[-321] rec[-313]\n",
+      "DETECTOR rec[-313] rec[-305]\n",
+      "DETECTOR rec[-320] rec[-312]\n",
+      "DETECTOR rec[-312] rec[-304]\n",
+      "DETECTOR rec[-319]\n",
+      "DETECTOR rec[-319] rec[-311]\n",
+      "DETECTOR rec[-311] rec[-303]\n",
+      "DETECTOR rec[-318] rec[-310]\n",
+      "DETECTOR rec[-310] rec[-302]\n",
+      "DETECTOR rec[-317]\n",
+      "DETECTOR rec[-317] rec[-309]\n",
+      "DETECTOR rec[-309] rec[-301]\n",
+      "DETECTOR rec[-316]\n",
+      "DETECTOR rec[-316] rec[-308]\n",
+      "DETECTOR rec[-308] rec[-300]\n",
+      "DETECTOR rec[-315]\n",
+      "DETECTOR rec[-315] rec[-307]\n",
+      "DETECTOR rec[-307] rec[-299]\n",
+      "DETECTOR rec[-314] rec[-306]\n",
+      "DETECTOR rec[-306] rec[-298]\n",
+      "DETECTOR rec[-297] rec[-289]\n",
+      "DETECTOR rec[-289] rec[-281]\n",
+      "DETECTOR rec[-296]\n",
+      "DETECTOR rec[-296] rec[-288]\n",
+      "DETECTOR rec[-288] rec[-280]\n",
+      "DETECTOR rec[-295]\n",
+      "DETECTOR rec[-295] rec[-287]\n",
+      "DETECTOR rec[-287] rec[-279]\n",
+      "DETECTOR rec[-294] rec[-286]\n",
+      "DETECTOR rec[-286] rec[-278]\n",
+      "DETECTOR rec[-293] rec[-285]\n",
+      "DETECTOR rec[-285] rec[-277]\n",
+      "DETECTOR rec[-292] rec[-284]\n",
+      "DETECTOR rec[-284] rec[-276]\n",
+      "DETECTOR rec[-291]\n",
+      "DETECTOR rec[-291] rec[-283]\n",
+      "DETECTOR rec[-283] rec[-275]\n",
+      "DETECTOR rec[-290]\n",
+      "DETECTOR rec[-290] rec[-282]\n",
+      "DETECTOR rec[-282] rec[-274]\n",
+      "DETECTOR rec[-273] rec[-265]\n",
+      "DETECTOR rec[-265] rec[-257]\n",
+      "DETECTOR rec[-272] rec[-264]\n",
+      "DETECTOR rec[-264] rec[-256]\n",
+      "DETECTOR rec[-271] rec[-263]\n",
+      "DETECTOR rec[-263] rec[-255]\n",
+      "DETECTOR rec[-270] rec[-262]\n",
+      "DETECTOR rec[-262] rec[-254]\n",
+      "DETECTOR rec[-269]\n",
+      "DETECTOR rec[-269] rec[-261]\n",
+      "DETECTOR rec[-261] rec[-253]\n",
+      "DETECTOR rec[-268]\n",
+      "DETECTOR rec[-268] rec[-260]\n",
+      "DETECTOR rec[-260] rec[-252]\n",
+      "DETECTOR rec[-267]\n",
+      "DETECTOR rec[-267] rec[-259]\n",
+      "DETECTOR rec[-259] rec[-251]\n",
+      "DETECTOR rec[-266]\n",
+      "DETECTOR rec[-266] rec[-258]\n",
+      "DETECTOR rec[-258] rec[-250]\n",
+      "DETECTOR rec[-249] rec[-281]\n",
+      "DETECTOR rec[-249] rec[-229]\n",
+      "DETECTOR rec[-229] rec[-209]\n",
+      "DETECTOR rec[-248] rec[-305]\n",
+      "DETECTOR rec[-248] rec[-228]\n",
+      "DETECTOR rec[-228] rec[-208]\n",
+      "DETECTOR rec[-247] rec[-227]\n",
+      "DETECTOR rec[-227] rec[-207]\n",
+      "DETECTOR rec[-246] rec[-280]\n",
+      "DETECTOR rec[-246] rec[-226]\n",
+      "DETECTOR rec[-226] rec[-206]\n",
+      "DETECTOR rec[-245] rec[-225]\n",
+      "DETECTOR rec[-225] rec[-205]\n",
+      "DETECTOR rec[-244] rec[-278]\n",
+      "DETECTOR rec[-244] rec[-224]\n",
+      "DETECTOR rec[-224] rec[-204]\n",
+      "DETECTOR rec[-243] rec[-275]\n",
+      "DETECTOR rec[-243] rec[-223]\n",
+      "DETECTOR rec[-223] rec[-203]\n",
+      "DETECTOR rec[-242] rec[-300]\n",
+      "DETECTOR rec[-242] rec[-222]\n",
+      "DETECTOR rec[-222] rec[-202]\n",
+      "DETECTOR rec[-241] rec[-221]\n",
+      "DETECTOR rec[-221] rec[-201]\n",
+      "DETECTOR rec[-240] rec[-279]\n",
+      "DETECTOR rec[-240] rec[-220]\n",
+      "DETECTOR rec[-220] rec[-200]\n",
+      "DETECTOR rec[-239] rec[-299]\n",
+      "DETECTOR rec[-239] rec[-219]\n",
+      "DETECTOR rec[-219] rec[-199]\n",
+      "DETECTOR rec[-238] rec[-303]\n",
+      "DETECTOR rec[-238] rec[-218]\n",
+      "DETECTOR rec[-218] rec[-198]\n",
+      "DETECTOR rec[-237] rec[-217]\n",
+      "DETECTOR rec[-217] rec[-197]\n",
+      "DETECTOR rec[-236] rec[-298]\n",
+      "DETECTOR rec[-236] rec[-216]\n",
+      "DETECTOR rec[-216] rec[-196]\n",
+      "DETECTOR rec[-235] rec[-304]\n",
+      "DETECTOR rec[-235] rec[-215]\n",
+      "DETECTOR rec[-215] rec[-195]\n",
+      "DETECTOR rec[-234] rec[-302]\n",
+      "DETECTOR rec[-234] rec[-214]\n",
+      "DETECTOR rec[-214] rec[-194]\n",
+      "DETECTOR rec[-233] rec[-301]\n",
+      "DETECTOR rec[-233] rec[-213]\n",
+      "DETECTOR rec[-213] rec[-193]\n",
+      "DETECTOR rec[-232] rec[-277]\n",
+      "DETECTOR rec[-232] rec[-212]\n",
+      "DETECTOR rec[-212] rec[-192]\n",
+      "DETECTOR rec[-231] rec[-276]\n",
+      "DETECTOR rec[-231] rec[-211]\n",
+      "DETECTOR rec[-211] rec[-191]\n",
+      "DETECTOR rec[-230] rec[-274]\n",
+      "DETECTOR rec[-230] rec[-210]\n",
+      "DETECTOR rec[-210] rec[-190]\n",
+      "DETECTOR rec[-186] rec[-209]\n",
+      "DETECTOR rec[-186] rec[-178]\n",
+      "DETECTOR rec[-178] rec[-170]\n",
+      "DETECTOR rec[-185] rec[-206]\n",
+      "DETECTOR rec[-185] rec[-177]\n",
+      "DETECTOR rec[-177] rec[-169]\n",
+      "DETECTOR rec[-184] rec[-200]\n",
+      "DETECTOR rec[-184] rec[-176]\n",
+      "DETECTOR rec[-176] rec[-168]\n",
+      "DETECTOR rec[-183] rec[-204]\n",
+      "DETECTOR rec[-183] rec[-175]\n",
+      "DETECTOR rec[-175] rec[-167]\n",
+      "DETECTOR rec[-182] rec[-192]\n",
+      "DETECTOR rec[-182] rec[-174]\n",
+      "DETECTOR rec[-174] rec[-166]\n",
+      "DETECTOR rec[-181] rec[-191] rec[-188] rec[-187]\n",
+      "DETECTOR rec[-181] rec[-173]\n",
+      "DETECTOR rec[-173] rec[-165]\n",
+      "DETECTOR rec[-180] rec[-203]\n",
+      "DETECTOR rec[-180] rec[-172]\n",
+      "DETECTOR rec[-172] rec[-164]\n",
+      "DETECTOR rec[-179] rec[-190]\n",
+      "DETECTOR rec[-179] rec[-171]\n",
+      "DETECTOR rec[-171] rec[-163]\n",
+      "DETECTOR rec[-162] rec[-208]\n",
+      "DETECTOR rec[-162] rec[-154]\n",
+      "DETECTOR rec[-154] rec[-146]\n",
+      "DETECTOR rec[-161] rec[-195]\n",
+      "DETECTOR rec[-161] rec[-153]\n",
+      "DETECTOR rec[-153] rec[-145]\n",
+      "DETECTOR rec[-160] rec[-198]\n",
+      "DETECTOR rec[-160] rec[-152]\n",
+      "DETECTOR rec[-152] rec[-144]\n",
+      "DETECTOR rec[-159] rec[-194]\n",
+      "DETECTOR rec[-159] rec[-151]\n",
+      "DETECTOR rec[-151] rec[-143]\n",
+      "DETECTOR rec[-158] rec[-193]\n",
+      "DETECTOR rec[-158] rec[-150]\n",
+      "DETECTOR rec[-150] rec[-142]\n",
+      "DETECTOR rec[-157] rec[-202] rec[-189] rec[-187]\n",
+      "DETECTOR rec[-157] rec[-149]\n",
+      "DETECTOR rec[-149] rec[-141]\n",
+      "DETECTOR rec[-156] rec[-199]\n",
+      "DETECTOR rec[-156] rec[-148]\n",
+      "DETECTOR rec[-148] rec[-140]\n",
+      "DETECTOR rec[-155] rec[-196]\n",
+      "DETECTOR rec[-155] rec[-147]\n",
+      "DETECTOR rec[-147] rec[-139]\n",
+      "DETECTOR rec[-138] rec[-146]\n",
+      "DETECTOR rec[-138] rec[-118]\n",
+      "DETECTOR rec[-118] rec[-98]\n",
+      "DETECTOR rec[-137] rec[-257]\n",
+      "DETECTOR rec[-137] rec[-117]\n",
+      "DETECTOR rec[-117] rec[-97]\n",
+      "DETECTOR rec[-136] rec[-116]\n",
+      "DETECTOR rec[-116] rec[-96]\n",
+      "DETECTOR rec[-135] rec[-255]\n",
+      "DETECTOR rec[-135] rec[-115]\n",
+      "DETECTOR rec[-115] rec[-95]\n",
+      "DETECTOR rec[-134] rec[-252]\n",
+      "DETECTOR rec[-134] rec[-114]\n",
+      "DETECTOR rec[-114] rec[-94]\n",
+      "DETECTOR rec[-133] rec[-141]\n",
+      "DETECTOR rec[-133] rec[-113]\n",
+      "DETECTOR rec[-113] rec[-93]\n",
+      "DETECTOR rec[-132] rec[-253]\n",
+      "DETECTOR rec[-132] rec[-112]\n",
+      "DETECTOR rec[-112] rec[-92]\n",
+      "DETECTOR rec[-131] rec[-250]\n",
+      "DETECTOR rec[-131] rec[-111]\n",
+      "DETECTOR rec[-111] rec[-91]\n",
+      "DETECTOR rec[-130] rec[-140]\n",
+      "DETECTOR rec[-130] rec[-110]\n",
+      "DETECTOR rec[-110] rec[-90]\n",
+      "DETECTOR rec[-129] rec[-144]\n",
+      "DETECTOR rec[-129] rec[-109]\n",
+      "DETECTOR rec[-109] rec[-89]\n",
+      "DETECTOR rec[-128] rec[-108]\n",
+      "DETECTOR rec[-108] rec[-88]\n",
+      "DETECTOR rec[-127] rec[-139]\n",
+      "DETECTOR rec[-127] rec[-107]\n",
+      "DETECTOR rec[-107] rec[-87]\n",
+      "DETECTOR rec[-126] rec[-145]\n",
+      "DETECTOR rec[-126] rec[-106]\n",
+      "DETECTOR rec[-106] rec[-86]\n",
+      "DETECTOR rec[-125] rec[-105]\n",
+      "DETECTOR rec[-105] rec[-85]\n",
+      "DETECTOR rec[-124] rec[-143]\n",
+      "DETECTOR rec[-124] rec[-104]\n",
+      "DETECTOR rec[-104] rec[-84]\n",
+      "DETECTOR rec[-123] rec[-142]\n",
+      "DETECTOR rec[-123] rec[-103]\n",
+      "DETECTOR rec[-103] rec[-83]\n",
+      "DETECTOR rec[-122] rec[-256]\n",
+      "DETECTOR rec[-122] rec[-102]\n",
+      "DETECTOR rec[-102] rec[-82]\n",
+      "DETECTOR rec[-121] rec[-254]\n",
+      "DETECTOR rec[-121] rec[-101]\n",
+      "DETECTOR rec[-101] rec[-81]\n",
+      "DETECTOR rec[-120] rec[-251]\n",
+      "DETECTOR rec[-120] rec[-100]\n",
+      "DETECTOR rec[-100] rec[-80]\n",
+      "DETECTOR rec[-119] rec[-99]\n",
+      "DETECTOR rec[-99] rec[-79]\n",
+      "DETECTOR rec[-75] rec[-98]\n",
+      "DETECTOR rec[-75] rec[-67]\n",
+      "DETECTOR rec[-67] rec[-59]\n",
+      "DETECTOR rec[-74] rec[-86]\n",
+      "DETECTOR rec[-74] rec[-66]\n",
+      "DETECTOR rec[-66] rec[-58]\n",
+      "DETECTOR rec[-73] rec[-89]\n",
+      "DETECTOR rec[-73] rec[-65]\n",
+      "DETECTOR rec[-65] rec[-57]\n",
+      "DETECTOR rec[-72] rec[-84]\n",
+      "DETECTOR rec[-72] rec[-64]\n",
+      "DETECTOR rec[-64] rec[-56]\n",
+      "DETECTOR rec[-71] rec[-83]\n",
+      "DETECTOR rec[-71] rec[-63]\n",
+      "DETECTOR rec[-63] rec[-55]\n",
+      "DETECTOR rec[-70] rec[-93]\n",
+      "DETECTOR rec[-70] rec[-62]\n",
+      "DETECTOR rec[-62] rec[-54]\n",
+      "DETECTOR rec[-69] rec[-90]\n",
+      "DETECTOR rec[-69] rec[-61]\n",
+      "DETECTOR rec[-61] rec[-53]\n",
+      "DETECTOR rec[-68] rec[-87] rec[-78] rec[-77]\n",
+      "DETECTOR rec[-68] rec[-60]\n",
+      "DETECTOR rec[-60] rec[-52]\n",
+      "DETECTOR rec[-51] rec[-97]\n",
+      "DETECTOR rec[-51] rec[-43]\n",
+      "DETECTOR rec[-43] rec[-35]\n",
+      "DETECTOR rec[-50] rec[-82]\n",
+      "DETECTOR rec[-50] rec[-42]\n",
+      "DETECTOR rec[-42] rec[-34]\n",
+      "DETECTOR rec[-49] rec[-95]\n",
+      "DETECTOR rec[-49] rec[-41]\n",
+      "DETECTOR rec[-41] rec[-33]\n",
+      "DETECTOR rec[-48] rec[-81]\n",
+      "DETECTOR rec[-48] rec[-40]\n",
+      "DETECTOR rec[-40] rec[-32]\n",
+      "DETECTOR rec[-47] rec[-92]\n",
+      "DETECTOR rec[-47] rec[-39]\n",
+      "DETECTOR rec[-39] rec[-31]\n",
+      "DETECTOR rec[-46] rec[-94]\n",
+      "DETECTOR rec[-46] rec[-38]\n",
+      "DETECTOR rec[-38] rec[-30]\n",
+      "DETECTOR rec[-45] rec[-80] rec[-78] rec[-76]\n",
+      "DETECTOR rec[-45] rec[-37]\n",
+      "DETECTOR rec[-37] rec[-29]\n",
+      "DETECTOR rec[-44] rec[-91]\n",
+      "DETECTOR rec[-44] rec[-36]\n",
+      "DETECTOR rec[-36] rec[-28]\n",
+      "DETECTOR rec[-25] rec[-19] rec[-22] rec[-23] rec[-169]\n",
+      "DETECTOR rec[-19] rec[-26] rec[-168]\n",
+      "DETECTOR rec[-21] rec[-20] rec[-164]\n",
+      "DETECTOR rec[-27] rec[-24] rec[-20] rec[-25] rec[-163]\n",
+      "DETECTOR rec[-11] rec[-14] rec[-15] rec[-12] rec[-59]\n",
+      "DETECTOR rec[-18] rec[-15] rec[-10] rec[-13] rec[-58]\n",
+      "DETECTOR rec[-16] rec[-10] rec[-56]\n",
+      "DETECTOR rec[-17] rec[-14] rec[-52]\n",
+      "DETECTOR rec[-2] rec[-8] rec[-5] rec[-1] rec[-31]\n",
+      "DETECTOR rec[-6] rec[-9] rec[-2] rec[-7] rec[-30]\n",
+      "DETECTOR rec[-6] rec[-4] rec[-29]\n",
+      "DETECTOR rec[-3] rec[-8] rec[-28]\n",
+      "OBSERVABLE_INCLUDE(0) rec[-23] rec[-22] rec[-21]\n",
+      "OBSERVABLE_INCLUDE(1) rec[-208] rec[-207] rec[-205] rec[-201] rec[-197] rec[-196] rec[-195] rec[-194] rec[-76] rec[-16] rec[-12] rec[-11] rec[-5] rec[-4] rec[-1]\n"
+     ]
+    }
+   ],
    "source": [
     "from pathlib import Path\n",
     "\n",
@@ -170,7 +631,9 @@
     ")\n",
     "\n",
     "stim_observables = [[\"readout_LZ_control\"], [\"rsc_surgery_MZZ_ac\", \"readout_LZ_ancilla\", \"readout_LZ_target\"]]\n",
-    "stim_program = compiled_program.to_stim_program(stim_observables, noise_model)"
+    "stim_program = compiled_program.to_stim_program(stim_observables)\n",
+    "\n",
+    "print(stim_program)"
    ]
   },
   {
@@ -183,7 +646,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 17,
    "id": "cc1797b2",
    "metadata": {},
    "outputs": [],
@@ -250,13 +713,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 18,
    "id": "050500c7",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 768x576 with 1 Axes>"
       ]
@@ -284,7 +747,7 @@
     "    num_workers=4,\n",
     "    tasks=tasks,\n",
     "    decoders=[\"pymatching\"],\n",
-    "    max_shots=100_000,\n",
+    "    max_shots=1_000_000,\n",
     "    max_errors=500,\n",
     ")\n",
     "fig, ax = plt.subplots(1, 1)\n",
@@ -294,7 +757,7 @@
     "    x_func=lambda stats: stats.json_metadata[\"p\"],\n",
     "    group_func=lambda stats: stats.json_metadata[\"d\"],\n",
     ")\n",
-    "ax.set_ylim(1e-9, 1e-0)\n",
+    "ax.set_ylim(1e-7, 1e-0)\n",
     "ax.set_xlim(1e-4, 1e-1)\n",
     "ax.loglog()\n",
     "ax.set_title(\"CNOT Code Error Rates\")\n",
diff --git a/docs/qec_gadget.md b/docs/qec_gadget.md
index b382068..1b63ff7 100644
--- a/docs/qec_gadget.md
+++ b/docs/qec_gadget.md
@@ -15,6 +15,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode], # List[Tuple[LogicalQubit, StabilizerCode]]
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -22,6 +23,7 @@ def compile(
 
 The function is given the resolved targets, which are codes for `CodeGadget` and logical qubits with their host codes for `LogicGadget`. It also receives the following information from the compiler:
 - A view of the measurement record, which is an object maintained by the compiler that contains the measurements performed so far. *Why though? I'm not sure anymore, and I should remove this parameter ASAP.*
+- An access to the quantum memory, to reserve eventally needed ancilla and to be aware of the data qubits assignement.
 - The timestep, which indicates the position at which this gadget was processed by the compiler.
 - The objective distance of the whole experiment. This can typically be used to determine how many rounds of error correction should be performed.
 
@@ -50,6 +52,7 @@ class RSCSurgery(LogicGadget):
         self,
         resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         record,
+        quantum_memory,
         timestep,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -80,10 +83,21 @@ class RSCSurgery(LogicGadget):
             code1.tanner_graph | code2.tanner_graph, connecting_edges
         )
 
+        # Get ancilla for the ancilla data qubits in the merge
+        # And for the checks, so that we can use them to measure the stabilizser
+        # Make sure to unlock them at the end
+        ancilla = quantum_memory.lock_ancilla_qubits(n=len(ancilla_system.variable_nodes + merged_code.check_nodes), requestor_id=self.id)
+
+        # map ancilla to node so we always reuse the same
+        # This is not strictly necessary, and we could for example reserve less ancilla and use them to measure several different stabilizers
+        ancilla_qubits_to_node = {...}
+
         # Primitive 1: initialize the ancilla qubits in the right basis.
         init_ancilla = ApplyGate(
             target=ancilla_system,
             target_nodes=ancilla_system.variable_nodes | ancilla_system.check_nodes,  # type: ignore
+            physical_data_qubits={k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},  # type: ignore
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             gates=(
                 ["RX"] if m_type == PauliChar.Z else ["RZ"]
             ),  # Initialize in the dual basis of the merge type.
@@ -92,6 +106,11 @@ class RSCSurgery(LogicGadget):
         # Primitive 2: do d rounds of syndrome measurement on the merged system.
         merged_syndrome = ExtractSyndrome(
             target=merged_system,
+            physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                merged_system.variable_nodes
+            )
+            | {k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             rounds=objective_distance,
             tag=f"rsc_surgery_merged_syndrome_{self.tag}",
         )
@@ -99,6 +118,12 @@ class RSCSurgery(LogicGadget):
         # Primitive 3: read out the ancilla system in the right basis.
         ancilla_readout = Readout(
             target=ancilla_system,
+            physical_data_qubits={
+                k: v
+                for k, v in ancilla_qubits_to_node.items()
+                if isinstance(k, VariableNode)
+            },
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             readout_basis=m_type.dual(),
             tag=f"rsc_surgery_measurement_{self.tag}",
         )
@@ -107,6 +132,10 @@ class RSCSurgery(LogicGadget):
         split_syndrome = [
             ExtractSyndrome(
                 target=initial_code,
+                physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                    initial_code.variable_nodes
+                ),
+                physical_ancilla_qubits=ancilla_qubits_to_node,
                 rounds=objective_distance,
                 tag=f"rsc_surgery_split_syndrome_{self.tag}",
             )
@@ -151,6 +180,10 @@ class RSCSurgery(LogicGadget):
             ),
         }
 
+        quantum_memory.unlock_ancilla_qubits(
+            qubits=list(ancilla), owner_id=self.id
+        )
+
         return correction, observable, primitives
 ```
 
@@ -159,6 +192,7 @@ Although the full implementation may require some tedious computation to navigat
 We now state some important points to remember when implementing a gadget:
 - The state, meaning the Tanner-graph structure, of the stabilizer-code object must not be changed by the gadget. To build the merged code, for example, we build a Tanner graph that uses references to the code's graph, but we do not modify it.
 - The logical operators must not be changed directly. We only provide `LogicalOperatorUpdate`, which will be processed by the compiler after the gadget is processed. These corrections will be effective only in the next gadget. A logical-operator update can also remap the logical operator to some other support, as long as it stays within the same code.
+- All the ancilla reserved (locked) should be unlock. Otherwise they will not be reusable by the next gadgets.
 - The measurements in the observables and corrections must include the primitive ID and the gadget ID. Then the compiler will associate them with the last measurement instruction of the given node ID that was added in the corresponding primitive.
 - The observable's tag is used as the variable name for it.
 - If the observable corresponds to a logical measurement, it must specify which logical operators are associated with it. This is required so that the compiler can complete it with the corrections previously added to these logical operators.
diff --git a/docs/qec_primitives.md b/docs/qec_primitives.md
index dfb1878..c0c00ff 100644
--- a/docs/qec_primitives.md
+++ b/docs/qec_primitives.md
@@ -25,8 +25,6 @@ class ImplementationName(PrimitiveImplementation[ApplyGate]):
     def compile(
         self,
         instruction: ApplyGate,
-        memory: QuantumMemory,
-        
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -38,7 +36,6 @@ The class must inherit from `PrimitiveImplementation[<...>]`, where the placehol
 `QECPrimitive` instruction that is implemented. The `compile` method then builds the expected information.
 It receives the following as input:
 - An instruction, which is the implemented `QECPrimitive`.
-- The quantum memory being used. This is important because primitives are responsible for allocating qubits if necessary.
 - A view of the measurement record, which can be used when building detectors between two primitives.
 - A detector graph port, which provides information on the states of the qubits in the previous primitive in order to build detectors correctly.
 - The ID of the gadget using the primitive.
@@ -59,7 +56,6 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -71,16 +67,16 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
         measurements_ordered: List[Measurement] = []
         detectors: List[Detector] = []
 
-        # Allocate the nodes that are not allocated yet.
-        to_alloc: List[TannerNode] = []
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        # Physical qubits that we are allowed to used are given in the instruction.
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+        data_qubits = instruction.physical_data_qubits
+        node_to_qubit = {**checks_qubits, **data_qubits}
 
         # Reset the ancilla used to measure the syndromes.
         stim_instructions.extend(
-            f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+            f"RZ {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
         )
 
         # Build the syndrome-extraction circuit for one round.
@@ -122,20 +118,20 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
 
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         for t in [t1, t2, t3, t4]:
             single_round_instructions.append(
-                f"CX {" ".join(f"{str(memory.get_slot(con))} {str(memory.get_slot(tar))}" for con, tar in t)}"
+                f"CX {" ".join(f"{str(node_to_qubit[con].integer_index)} {str(node_to_qubit[tar].integer_index)}" for con, tar in t)}"
             )
             single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"MRZ {" ".join(str(memory.get_slot(c)) for c in node_measured)}"
+            f"MRZ {" ".join(str(node_to_qubit[c].integer_index) for c in node_measured)}"
         )
 
         # Repeat the round.
diff --git a/src/epic/core/compilation/compilation_context.py b/src/epic/core/compilation/compilation_context.py
index c44011e..a104c9f 100644
--- a/src/epic/core/compilation/compilation_context.py
+++ b/src/epic/core/compilation/compilation_context.py
@@ -5,18 +5,20 @@
 from uuid import UUID
 import warnings
 
-from epic.core.qec_object.detector import (
-    Detector,
-    DetectorGraphPort,
-    QubitPortState,
-)
-from epic.core.qec_object.measurement import Measurement
-
 from .compiled_experiment import CompiledExperiment
 from .measurement_record import MeasurementRecord
 from .quantum_memory import QuantumMemory
 from ..data_structure.tanner_node import TannerNode
-from ..qec_object import LogicalOperator, LogicalQubit, Observable, StabilizerCode
+from ..qec_object import (
+    LogicalOperator,
+    LogicalQubit,
+    Observable,
+    StabilizerCode,
+    Measurement,
+    Detector,
+    DetectorGraphPort,
+    QubitPortState,
+)
 
 TargetT = TypeVar("TargetT", LogicalQubit, StabilizerCode)
 
@@ -34,7 +36,7 @@ class CompilationContext:
         measurement_record: Tracks measurements emitted by compiled primitives.
     """
 
-    def __init__(self):
+    def __init__(self, memory_size: int = -1) -> None:
         """Initialize the compilation state and all its registers. At the start, everything is empty."""
         self._uuid_memory: Dict[UUID, Any] = {}
         self._naming_registry: Dict[str, UUID] = {}
@@ -45,7 +47,7 @@ def __init__(self):
         self._circuit_instructions = []
         self._detectors = []
 
-        self.quantum_memory = QuantumMemory()
+        self.quantum_memory = QuantumMemory(size_limit=memory_size)
         self.measurement_record = MeasurementRecord()
 
         self._compilation_time = (0, 0)
@@ -160,7 +162,10 @@ def get_observable_by_tag(self, tag: str) -> Observable:
     def register_code(
         self, lqb_name: List[str], code: StabilizerCode, code_varname: str
     ):
-        """Register a code, its logical qubits, and their logical operators."""
+        """
+        Register a code, its logical qubits, and their logical operators.
+        Allocate physical qubits for the data qubits nodes
+        """
         self._uuid_memory[code.id] = code
         self._naming_registry[code_varname] = code.id
         for idx, qubit in enumerate(code.logical_qubits):
@@ -170,6 +175,9 @@ def register_code(
             for op in [qubit.logical_x, qubit.logical_z]:
                 self._uuid_memory[op.id] = op
                 self._operator_to_qubit[op.id] = qubit.id
+        self.quantum_memory.allocate_qubits(
+            qubits=list(code.tanner_graph.variable_nodes)
+        )
 
     def unregister_code(self, code_varname: str):
         """Remove a registered code and all objects derived from it."""
@@ -197,6 +205,7 @@ def unregister_code(self, code_varname: str):
                 del self._operator_to_qubit[op.id]
         del self._uuid_memory[code_id]
         del self._naming_registry[code_varname]
+        self.quantum_memory.free_qubits(qubits=list(code.tanner_graph.variable_nodes))
 
     def allocated_code_varnames(self) -> List[str]:
         """Return the variable names of all currently registered codes."""
diff --git a/src/epic/core/compilation/compiled_experiment.py b/src/epic/core/compilation/compiled_experiment.py
index 4250ea5..456ec04 100644
--- a/src/epic/core/compilation/compiled_experiment.py
+++ b/src/epic/core/compilation/compiled_experiment.py
@@ -6,9 +6,10 @@
 from epic.core.experiment.noise_model import NoiseModel
 
 from ..qec_object import Measurement
-from .measurement_record import MeasurementRecord
 from ..qec_object import Detector, Observable
 
+from .measurement_record import MeasurementRecord
+
 
 class CompiledExperiment(BaseModel):
     """Immutable compiled representation of an experiment ready for Stim export."""
diff --git a/src/epic/core/compilation/measurement_record.py b/src/epic/core/compilation/measurement_record.py
index 8356a87..0b99d45 100644
--- a/src/epic/core/compilation/measurement_record.py
+++ b/src/epic/core/compilation/measurement_record.py
@@ -1,7 +1,7 @@
 from uuid import UUID
 from collections.abc import Iterable
 
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, PrivateAttr
 
 from ..qec_object import Measurement
 
diff --git a/src/epic/core/compilation/qec_compiler.py b/src/epic/core/compilation/qec_compiler.py
index e147767..b453284 100644
--- a/src/epic/core/compilation/qec_compiler.py
+++ b/src/epic/core/compilation/qec_compiler.py
@@ -2,19 +2,17 @@
 from typing import Any, List, Mapping, Sequence, Tuple
 import warnings
 
-from epic.core.language.qec_gadget import AllocCode, CodeGadget, FreeCode, LogicGadget
-from epic.core.qec_object.logical_qubit import LogicalQubit
-from epic.core.qec_object.observable import Observable
-from epic.core.qec_object.stabilizer_code import StabilizerCode
 from debug.warnings import CodeBelowDistanceWarning
-from epic.core.visualization.tanner_graph_vis import TannerGraphVisualizer
 
 from .compiled_experiment import CompiledExperiment
 from .compilation_context import CompilationContext
-from ..language import QECGadget
+from ..qec_object import LogicalQubit, StabilizerCode, Observable
+from ..language import QECGadget, AllocCode, CodeGadget, FreeCode, LogicGadget
 from ..qec_primitives.interfaces import QECPrimitive
 from ..qec_primitives import PrimitiveCompiler
 
+from epic.core.visualization.tanner_graph_vis import TannerGraphVisualizer
+
 
 class QECCompiler:
     """Compile high-level QEC gadgets into a compiled experiment."""
@@ -28,7 +26,8 @@ def __init__(self, config: dict[str, Any]) -> None:
         """
         self.config = config
         self.distance = self.config.get("objective_distance", 0)
-        self.ctx = CompilationContext()
+        self.quantum_memory_limit = self.config.get("physical_qubits_limit", -1)
+        self.ctx = CompilationContext(memory_size=self.quantum_memory_limit)
         self.primitive_compiler = PrimitiveCompiler(config=config)
         # self.gadget_compiler = GadgetCompiler(config)
 
@@ -162,6 +161,7 @@ def compile(
                         gadget.compile(
                             resolved_targets,
                             self.ctx.measurement_record.view(),
+                            self.ctx.quantum_memory,
                             self.ctx.t_gadget,
                             self.distance,
                         )
@@ -174,6 +174,7 @@ def compile(
                         gadget.compile(
                             resolved_targets,
                             self.ctx.measurement_record.view(),
+                            self.ctx.quantum_memory,
                             self.ctx.t_gadget,
                             self.distance,
                         )
@@ -181,15 +182,11 @@ def compile(
                 case _:
                     raise ValueError(f"Unsupported gadget type: {type(gadget)}")
 
-            # TODO
-            # lock = self.ctx.quantum_memory.acquire_lock(ctx_nodes, ancilla_cost) <= dict node->idx, list[reserved idx]
-            # => alloc ancilla_cost
             gadget_measurements = []
             for p_op in primitive_code_instructions:
                 c_instructions, measurements, detectors, new_dg_port = (
                     self.primitive_compiler.compile(
                         p_op,
-                        self.ctx.quantum_memory,
                         self.ctx.measurement_record.view(),
                         self.ctx.detector_graph_port_view(),
                         parent_gadget_id=gadget.id,
@@ -213,7 +210,6 @@ def compile(
                         observables,
                         gadget.tag,
                     )
-            # => release lock, dealloc ancillas
 
             # Should I apply the frame correction the Observable with or without the gadget's own logical correction ? ???
             if observables is not None:
diff --git a/src/epic/core/compilation/quantum_memory.py b/src/epic/core/compilation/quantum_memory.py
index 42ab314..c2a07d3 100644
--- a/src/epic/core/compilation/quantum_memory.py
+++ b/src/epic/core/compilation/quantum_memory.py
@@ -1,88 +1,180 @@
 from collections.abc import Mapping, Sequence
 from types import MappingProxyType
+from typing import Set
+from uuid import UUID
 
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
-from ..data_structure.tanner_node import TannerNode
+from ..data_structure import VariableNode, PhysicalQubit
 
 
 class QuantumMemory(BaseModel):
     """Track slot allocation for physical qubits during compilation."""
 
+    size_limit: int = Field(
+        description="Total number of qubits in the quantum memory. -1 indicates unbounded memory that can grow as needed.",
+        default=-1,
+    )
     size: int = Field(
-        description="Total number of qubits in the quantum memory.",
+        description="Current number of qubits in the quantum memory. -1 indicates unbounded memory that can grow as needed.",
         default=0,
     )
-    _slots: list[int] = PrivateAttr(default_factory=list)
-    _free_slots: list[int] = PrivateAttr(default_factory=list)
-    _allocation: dict[TannerNode, int] = PrivateAttr(default_factory=dict)
+
+    @model_validator(mode="after")
+    def validate_size(cls, model):
+        if model.size_limit == -1:
+            return model
+        else:
+            model.size = model.size_limit
+            model._existing_qubits.update(
+                PhysicalQubit(integer_index=i) for i in range(model.size_limit)
+            )
+            model._free_qubits.update(
+                PhysicalQubit(integer_index=i) for i in range(model.size_limit)
+            )
+            return model
+
+    _existing_qubits: set[PhysicalQubit] = PrivateAttr(default_factory=set)
+    _free_qubits: set[PhysicalQubit] = PrivateAttr(default_factory=set)
+
+    _data_qubits_allocation: dict[VariableNode, PhysicalQubit] = PrivateAttr(
+        default_factory=dict
+    )
+
+    _data_qubits_locked: dict[PhysicalQubit, UUID] = PrivateAttr(default_factory=dict)
+    _ancilla_locked: dict[PhysicalQubit, UUID] = PrivateAttr(default_factory=dict)
 
     @property
-    def slots(self) -> tuple[int, ...]:
+    def slots(self) -> tuple[PhysicalQubit, ...]:
         """Return all slot indices that have been created so far."""
-        return tuple(self._slots)
+        return tuple(self._existing_qubits)
 
     @property
-    def free_slots(self) -> tuple[int, ...]:
-        """Return the currently unallocated slot indices."""
-        return tuple(self._free_slots)
+    def free_slots(self) -> tuple[PhysicalQubit, ...]:
+        """Return the currently unallocated physical qubits."""
+        return tuple(self._free_qubits)
 
-    @property
-    def allocation(self) -> Mapping[TannerNode, int]:
-        """Return a read-only mapping from qubits to their allocated slot."""
-        # Expose a read-only view so external callers cannot mutate memory state.
-        return MappingProxyType(self._allocation)
+    def data_qubits_allocation_snapshot(
+        self, subset_keys: Set[VariableNode]
+    ) -> MappingProxyType[VariableNode, PhysicalQubit]:
+        """Return a snapshot of the current data qubits allocation for the requested subset of variable nodes."""
 
-    def is_allocated(self, qubit_id: TannerNode) -> bool:
-        """Return whether a qubit currently has a slot assignment."""
-        return qubit_id in self._allocation
+        subset = {
+            k: self._data_qubits_allocation[k]
+            for k in subset_keys
+            if k in self._data_qubits_allocation
+        }
 
-    def get_slot(self, qubit_id: TannerNode) -> int:
-        """Return the slot assigned to a previously allocated qubit."""
-        return self._allocation[qubit_id]
+        return MappingProxyType(subset)
 
-    def allocate_qubits(self, qubits: TannerNode | Sequence[TannerNode]) -> list[int]:
-        """Allocate one or more qubits and return their assigned slots."""
+    def is_allocated(self, variable_node: VariableNode) -> bool:
+        """Return whether a variable node currently has a slot assignment."""
+        return variable_node in self._data_qubits_allocation
 
-        if isinstance(qubits, TannerNode):
+    def get_physical_qubit(self, variable_node: VariableNode) -> PhysicalQubit:
+        """Return the physical qubit assigned to a data node."""
+        return self._data_qubits_allocation[variable_node]
+
+    def allocate_qubits(
+        self, qubits: VariableNode | Sequence[VariableNode]
+    ) -> list[PhysicalQubit]:
+        """Allocate one or more qubits to data nodes and return their assigned slots."""
+
+        if isinstance(qubits, VariableNode):
             qubits = [qubits]
 
-        if len(self._free_slots) < len(qubits):
-            new_slots = len(qubits) - len(self._free_slots)
-            self._slots.extend(range(self.size, self.size + new_slots))
-            self._free_slots.extend(range(self.size, self.size + new_slots))
+        if len(self._free_qubits) < len(qubits):
+            if self.size_limit != -1:
+                raise RuntimeError(
+                    f"Not enough free qubits to allocate {len(qubits)} qubits. Only {len(self._free_qubits)} free qubits available."
+                )
+            new_slots = len(qubits) - len(self._free_qubits)
+            self._existing_qubits.update(
+                PhysicalQubit(integer_index=i)
+                for i in range(self.size, self.size + new_slots)
+            )
+            self._free_qubits.update(
+                PhysicalQubit(integer_index=i)
+                for i in range(self.size, self.size + new_slots)
+            )
             self.size += new_slots
 
         for qid in qubits:
-            slot = self._free_slots.pop(0)
-            self._allocation[qid] = slot
-        return [self._allocation[qid] for qid in qubits]
+            slot = self._free_qubits.pop()
+            self._data_qubits_allocation[qid] = slot
+        return [self._data_qubits_allocation[qid] for qid in qubits]
 
-    def free_qubits(self, qubits: TannerNode | Sequence[TannerNode]) -> None:
+    def free_qubits(self, qubits: VariableNode | Sequence[VariableNode]) -> None:
         """Release one or more qubits and return their slots to the free pool."""
-        if isinstance(qubits, TannerNode):
+        if isinstance(qubits, VariableNode):
             qubits = [qubits]
         for qid in qubits:
-            slot = self._allocation.pop(qid)
-            self._free_slots.append(slot)
+            if qid not in self._data_qubits_allocation:
+                raise RuntimeError(
+                    f"Tried to free a data node {qid.tag} that is not currently allocated."
+                )
+            pqb = self._data_qubits_allocation.pop(qid)
+            self._free_qubits.add(pqb)
         return None
 
-
-# class TopologicalMemory(QuantumMemory):
-#     """Class representing a topological quantum memory, which is a specific type of quantum memory used in quantum error correction codes.
-#     In topological memories, physical qubits are associated with a position in a n-dimensional lattice.
-#     """
-
-#     dimension: int = Field(
-#         description="Dimension of the lattice in which the physical qubits are embedded.",
-#         default=2,
-#     )
-#     bounds: Tuple[int, ...] = Field(
-#         description="Bounds of the lattice in each dimension, defining the size of the lattice.",
-#         default=(),
-#     )
-#     slot_positions: dict[int, Tuple[int, ...]] = Field(
-#         description="Mapping from slot index to the coordinates of the corresponding physical qubit in the lattice.",
-#         default_factory=dict,
-#         init=False,
-#     )
+    def lock_data_qubits(
+        self, qubits: Sequence[PhysicalQubit], requestor_id: UUID
+    ) -> None:
+        """Lock the given qubits for data use by a specific compiler pass."""
+        for q in qubits:
+            if q in self._data_qubits_locked:
+                raise RuntimeError(
+                    f"Physical qubit {q} is already locked for data use."
+                )
+            self._data_qubits_locked[q] = requestor_id
+
+    def unlock_data_qubits(
+        self, qubits: Sequence[PhysicalQubit], owner_id: UUID
+    ) -> None:
+        """Unlock the given qubits for data use by a specific compiler pass."""
+        for q in qubits:
+            if self._data_qubits_locked.get(q) != owner_id:
+                raise RuntimeError(
+                    f"Physical qubit {q} is not locked by requestor {owner_id}."
+                )
+            del self._data_qubits_locked[q]
+
+    def lock_ancilla_qubits(self, n: int, requestor_id: UUID) -> Set[PhysicalQubit]:
+        """Lock n ancilla qubits for ancilla use by a specific compiler pass."""
+        if len(self._free_qubits) < n:
+            if self.size_limit == -1:
+                new_slots = n - len(self._free_qubits)
+                self._existing_qubits.update(
+                    PhysicalQubit(integer_index=i)
+                    for i in range(self.size, self.size + new_slots)
+                )
+                self._free_qubits.update(
+                    PhysicalQubit(integer_index=i)
+                    for i in range(self.size, self.size + new_slots)
+                )
+                self.size += new_slots
+            else:
+                raise RuntimeError(
+                    f"Not enough free qubits to lock {n} ancilla qubits. Only {len(self._free_qubits)} free qubits available."
+                )
+
+        locked_qubits = set()
+        for _ in range(n):
+            q = self._free_qubits.pop()
+            self._ancilla_locked[q] = requestor_id
+            locked_qubits.add(q)
+
+        return locked_qubits
+
+    def unlock_ancilla_qubits(
+        self, qubits: Sequence[PhysicalQubit], owner_id: UUID
+    ) -> None:
+        """Unlock the given ancilla qubits for ancilla use by a specific compiler pass."""
+        for q in qubits:
+            if self._ancilla_locked.get(q) != owner_id:
+                raise RuntimeError(
+                    f"Physical qubit {q} is not locked by requestor {owner_id}."
+                )
+            del self._ancilla_locked[q]
+            self._free_qubits.add(q)
+        return None
diff --git a/src/epic/core/data_structure/__init__.py b/src/epic/core/data_structure/__init__.py
index e93e87f..237b024 100644
--- a/src/epic/core/data_structure/__init__.py
+++ b/src/epic/core/data_structure/__init__.py
@@ -4,6 +4,7 @@
 from .tanner_node import CheckNode, TannerNode, VariableNode
 from .tanner_graph import TannerEdge, TannerGraph
 from .graph_algorithm import GraphAlgorithm
+from .physical_qubit import PhysicalQubit
 
 __all__ = [
     "TannerNode",
@@ -14,4 +15,5 @@
     "PauliChar",
     "PauliEigenState",
     "PauliString",
+    "PhysicalQubit",
 ]
diff --git a/src/epic/core/data_structure/physical_qubit.py b/src/epic/core/data_structure/physical_qubit.py
new file mode 100644
index 0000000..b9d2cdd
--- /dev/null
+++ b/src/epic/core/data_structure/physical_qubit.py
@@ -0,0 +1,23 @@
+from uuid import UUID, uuid4
+
+from pydantic import Field
+from pydantic.dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalQubit:
+    """Class representing a physical qubit in the quantum memory."""
+
+    integer_index: int = Field(
+        description="Index refs used in Stim",
+    )
+
+    position: tuple[float, ...] = Field(
+        description="Position of the physical qubit in a multi-dimensional space.",
+        default=(),
+    )
+
+    id: UUID = Field(
+        description="Unique identifier of the physical qubit",
+        default_factory=uuid4,
+    )
diff --git a/src/epic/core/data_structure/tanner_graph.py b/src/epic/core/data_structure/tanner_graph.py
index f624e90..929531f 100644
--- a/src/epic/core/data_structure/tanner_graph.py
+++ b/src/epic/core/data_structure/tanner_graph.py
@@ -4,6 +4,7 @@
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 from scipy.sparse import csr_matrix
+
 from .tanner_node import TannerNode, VariableNode, CheckNode
 from .pauli import PauliChar
 
diff --git a/src/epic/core/language/qec_gadget.py b/src/epic/core/language/qec_gadget.py
index 02dba94..c4aab0c 100644
--- a/src/epic/core/language/qec_gadget.py
+++ b/src/epic/core/language/qec_gadget.py
@@ -5,6 +5,7 @@
 from pydantic import BaseModel, ConfigDict, Field
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.qec_object.logical_qubit import LogicalQubit
 
 from ..qec_object import (
@@ -53,6 +54,7 @@ def compile(
         self,
         resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -71,6 +73,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
diff --git a/src/epic/core/qec_object/__init__.py b/src/epic/core/qec_object/__init__.py
index 84eee26..57d7986 100644
--- a/src/epic/core/qec_object/__init__.py
+++ b/src/epic/core/qec_object/__init__.py
@@ -1,6 +1,6 @@
 """QEC object-model exports."""
 
-from .detector import Detector
+from .detector import Detector, DetectorGraphPort, NodeKnowledge, QubitPortState
 from .logical_operator import LogicalOperator, LogicalOperatorUpdate
 from .logical_qubit import LogicalQubit
 from .measurement import Measurement
@@ -9,6 +9,9 @@
 
 __all__ = [
     "Detector",
+    "DetectorGraphPort",
+    "NodeKnowledge",
+    "QubitPortState",
     "LogicalOperator",
     "LogicalOperatorUpdate",
     "LogicalQubit",
diff --git a/src/epic/core/qec_primitives/interfaces/extract_syndrome.py b/src/epic/core/qec_primitives/interfaces/extract_syndrome.py
index 8c39398..4d965cb 100644
--- a/src/epic/core/qec_primitives/interfaces/extract_syndrome.py
+++ b/src/epic/core/qec_primitives/interfaces/extract_syndrome.py
@@ -35,7 +35,10 @@ def _detector_round_zero(
         tag: str,
     ) -> Detector | None:
         measurement_in_detectors = [round_zero_measurement]
-        check_knowledge = dgp[check].knowledge
+        if check not in dgp:
+            check_knowledge = NodeKnowledge.UNKNOWN
+        else:
+            check_knowledge = dgp[check].knowledge
         match check_knowledge:
             case NodeKnowledge.STABLE:
                 # By default, if a check was stable, we expect it to have the same parity as the previous round
diff --git a/src/epic/core/qec_primitives/interfaces/qec_primitive.py b/src/epic/core/qec_primitives/interfaces/qec_primitive.py
index 9d8d862..3934ee1 100644
--- a/src/epic/core/qec_primitives/interfaces/qec_primitive.py
+++ b/src/epic/core/qec_primitives/interfaces/qec_primitive.py
@@ -1,13 +1,15 @@
 from abc import ABC
-from typing import Any, Generic, List, Protocol, Tuple, TypeVar
+from typing import Any, Generic, List, Mapping, Protocol, Set, Tuple, TypeVar
 from uuid import UUID, uuid4
 
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from epic.core.data_structure.tanner_node import TannerNode, VariableNode
 
 from ...qec_object.detector import DetectorGraphPort
 from ...compilation.measurement_record import MeasurementRecordView
-from ...compilation.quantum_memory import QuantumMemory
+from ...compilation.quantum_memory import PhysicalQubit, QuantumMemory
 from ...data_structure import TannerGraph
 from ...qec_object import Detector, Measurement
 
@@ -16,6 +18,13 @@ class QECPrimitive(ABC, BaseModel):
     """Abstract base class for primitives compiled against a Tanner graph."""
 
     target: TannerGraph
+    physical_data_qubits: Mapping[VariableNode, PhysicalQubit] = Field(
+        default_factory=dict
+    )
+    physical_ancilla_qubits: Mapping[TannerNode, PhysicalQubit] = Field(
+        default_factory=dict
+    )
+
     tag: str = ""
     distance: int = 0
 
@@ -28,6 +37,21 @@ def validate_distance(cls, distance):
             raise ValueError("Distance must be a non-negative integer.")
         return distance
 
+    @model_validator(mode="after")
+    def validate_qubits_in_target(cls, model):
+        """Ensure all data node in the primitive's Tanner graph target have corresponding physical qubits."""
+        if not model.physical_data_qubits:
+            return model
+
+        target_nodes = set(model.target.variable_nodes)
+        allocated_nodes = set(model.physical_data_qubits.keys())
+        if not target_nodes.issubset(allocated_nodes):
+            missing = target_nodes - allocated_nodes
+            raise ValueError(
+                f"Data nodes {missing} in the primitive's target do not have corresponding physical data qubits allocated."
+            )
+        return model
+
     def to_payload(self) -> dict[str, Any]:
         """Serialize the primitive while preserving its Tanner-graph target."""
         data = self.model_dump(exclude={"target"})
@@ -48,7 +72,6 @@ class PrimitiveImplementation(Protocol, Generic[T]):
     def compile(
         self,
         instruction: T,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
diff --git a/src/epic/core/qec_primitives/primitive_compiler.py b/src/epic/core/qec_primitives/primitive_compiler.py
index c05357d..dcfd60c 100644
--- a/src/epic/core/qec_primitives/primitive_compiler.py
+++ b/src/epic/core/qec_primitives/primitive_compiler.py
@@ -69,7 +69,6 @@ def model_post_init(self, __context: Any) -> None:
     def compile(
         self,
         primitive_instruction: QECPrimitive,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: MappingProxyType[TannerNode, QubitPortState],
         parent_gadget_id: UUID,
@@ -82,7 +81,6 @@ def compile(
 
         result = implementation.compile(
             instruction=primitive_instruction,
-            memory=memory,
             record=record,
             det_graph_port=det_graph_port,
             parent_gadget_id=parent_gadget_id,
diff --git a/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py b/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py
index 854ef35..b9fab8f 100644
--- a/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py
+++ b/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py
@@ -3,6 +3,7 @@
 
 from pydantic import model_validator
 
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure import PauliChar, TannerGraph
 from epic.core.language import LogicGadget
 from epic.core.qec_object import LogicalOperatorUpdate, Measurement, Observable
@@ -26,7 +27,12 @@ def validate_basis_len(self):
         return self
 
     def compile(
-        self, resolved_targets, record, timestep, objective_distance
+        self,
+        resolved_targets,
+        record,
+        quantum_memory: QuantumMemory,
+        timestep,
+        objective_distance,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
         primitives = []
         lop_targets: List[LogicalOperator] = []
@@ -42,13 +48,18 @@ def compile(
                     )
 
         for lop in lop_targets:
+            target = TannerGraph(
+                variable_nodes=set(lop.target_nodes),
+                check_nodes=set(),
+                edges=set(),
+            )
             primitives.append(
                 Readout(
-                    target=TannerGraph(
-                        variable_nodes=set(lop.target_nodes),
-                        check_nodes=set(),
-                        edges=set(),
+                    target=target,
+                    physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                        target.variable_nodes
                     ),
+                    physical_ancilla_qubits={},  # no ancilla needed since no check in target nodes
                     readout_basis=lop.logical_type,
                     tag=f"measurement_{self.tag}_{lop.id}",
                 )
diff --git a/src/epic/modules/qec_gadgets/logical_resets/init_code.py b/src/epic/modules/qec_gadgets/logical_resets/init_code.py
index 41476ab..0f628bc 100644
--- a/src/epic/modules/qec_gadgets/logical_resets/init_code.py
+++ b/src/epic/modules/qec_gadgets/logical_resets/init_code.py
@@ -1,10 +1,14 @@
+from collections import defaultdict
 from typing import Dict, List, Set, Tuple, cast
 from uuid import UUID
 
 from pydantic import Field
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure import PauliEigenState, TannerNode
+from epic.core.data_structure.physical_qubit import PhysicalQubit
+from epic.core.data_structure.tanner_graph import TannerGraph
 from epic.core.language import CodeGadget
 from epic.core.qec_object import LogicalOperatorUpdate, Observable
 from epic.core.qec_object.stabilizer_code import StabilizerCode
@@ -25,6 +29,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -43,24 +48,44 @@ def compile(
                     "Unsupported initial eigenstate, only X and Z basis are allowed"
                 )
         primitives: List[QECPrimitive] = []
+        # Lock 1 ancilla per checks:
+        ancilla_locked: Dict[UUID, Dict[TannerNode, PhysicalQubit]] = defaultdict(dict)
         for code in resolved_targets:
-            target_nodes = cast(
-                Set[TannerNode],
-                code.tanner_graph.variable_nodes | code.tanner_graph.check_nodes,
+            anc = quantum_memory.lock_ancilla_qubits(
+                n=len(code.tanner_graph.check_nodes), requestor_id=self.id
             )
+            ancilla_locked[code.id] = {
+                n: q for n, q in zip(code.tanner_graph.check_nodes, anc)
+            }
+
+        for code in resolved_targets:
             primitives.append(
                 ApplyGate(
                     target=code.tanner_graph,
-                    target_nodes=target_nodes,
+                    physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                        code.tanner_graph.variable_nodes
+                    ),
+                    physical_ancilla_qubits=ancilla_locked[code.id],
+                    target_nodes=code.tanner_graph.variable_nodes
+                    | code.tanner_graph.check_nodes,  # type: ignore
                     gates=gates,
                 )
             )
             primitives.append(
                 ExtractSyndrome(
                     target=code.tanner_graph,
+                    physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                        code.tanner_graph.variable_nodes
+                    ),
+                    physical_ancilla_qubits=ancilla_locked[code.id],
                     distance=objective_distance,
                     rounds=objective_distance,
                 )
             )
 
+        for code, anc_checks_map in ancilla_locked.items():
+            quantum_memory.unlock_ancilla_qubits(
+                list(anc_checks_map.values()), owner_id=self.id
+            )
+
         return {}, [], primitives
diff --git a/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py b/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py
index e0fff76..35d0821 100644
--- a/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py
+++ b/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py
@@ -2,6 +2,7 @@
 
 from pydantic import field_validator
 
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure.pauli import PauliChar
 from epic.core.data_structure.tanner_graph import TannerEdge, TannerGraph
 from epic.core.data_structure.tanner_node import CheckNode, CheckNode
@@ -38,7 +39,6 @@ def validate_product_to_measure(cls, v):
 
     def _check_axis(
         self,
-        resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         lop_involved,
     ) -> int:
 
@@ -206,6 +206,7 @@ def compile(
         self,
         resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         record,
+        quantum_memory: QuantumMemory,
         timestep,
         objective_distance: int,
     ):
@@ -238,7 +239,7 @@ def compile(
         merge_type = self.product_to_measure.string[0]
 
         # Get axis along which the merge occurs, horizontal (0) or vertical (1)
-        axis = self._check_axis(resolved_targets, lop_involved)
+        axis = self._check_axis(lop_involved)
 
         ## Compute translated lop, i.e. the chain that is on the merge boundary.
         # The current lop.target_nodes may represent a chain far from the merge boundary.
@@ -285,20 +286,44 @@ def compile(
         primitives = []
         lop_updates = {}
 
+        ancilla_qubits_to_node = dict()
+        ancilla_qubits_locked = quantum_memory.lock_ancilla_qubits(
+            n=len(merged_system.check_nodes) + len(ancilla_system.variable_nodes),
+            requestor_id=self.id,
+        )
+        for node, phys_qubit in zip(
+            merged_system.check_nodes | ancilla_system.variable_nodes,
+            ancilla_qubits_locked,
+        ):
+            ancilla_qubits_to_node[node] = phys_qubit
+
         init_ancilla = ApplyGate(
             target=ancilla_system,
             target_nodes=ancilla_system.variable_nodes | ancilla_system.check_nodes,  # type: ignore
+            physical_data_qubits={k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},  # type: ignore
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             gates=(
                 ["RX"] if merge_type == PauliChar.Z else ["RZ"]
             ),  # Init in dual of the merge type.
         )
         merged_syndrome = ExtractSyndrome(
             target=merged_system,
+            physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                merged_system.variable_nodes
+            )
+            | {k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},  # type: ignore
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             rounds=objective_distance,
             tag=f"rsc_surgery_merged_syndrome_{self.tag}",
         )
         ancilla_readout = Readout(
             target=ancilla_system,
+            physical_data_qubits={
+                k: v
+                for k, v in ancilla_qubits_to_node.items()
+                if isinstance(k, VariableNode)
+            },
+            physical_ancilla_qubits=ancilla_qubits_to_node,  # readout look only at data qubits, no need for ancilla.
             readout_basis=merge_type.dual(),
             tag=f"rsc_surgery_measurement_{self.tag}",
         )
@@ -306,6 +331,10 @@ def compile(
         split_syndrome = [
             ExtractSyndrome(
                 target=initial_code,
+                physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                    initial_code.variable_nodes
+                ),
+                physical_ancilla_qubits=ancilla_qubits_to_node,
                 rounds=objective_distance,
                 tag=f"rsc_surgery_split_syndrome_{self.tag}",
             )
@@ -357,4 +386,8 @@ def compile(
             )
         ]
 
+        quantum_memory.unlock_ancilla_qubits(
+            qubits=list(ancilla_qubits_locked), owner_id=self.id
+        )
+
         return lop_updates, observable, primitives
diff --git a/src/epic/modules/qec_gadgets/readout_code.py b/src/epic/modules/qec_gadgets/readout_code.py
index 4b4c856..c71e474 100644
--- a/src/epic/modules/qec_gadgets/readout_code.py
+++ b/src/epic/modules/qec_gadgets/readout_code.py
@@ -2,6 +2,7 @@
 from uuid import UUID
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure.pauli import PauliChar
 from epic.core.language.qec_gadget import CodeGadget
 from epic.core.qec_object import LogicalOperatorUpdate, Observable
@@ -19,6 +20,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -27,6 +29,10 @@ def compile(
         for code in resolved_targets:
             ro = Readout(
                 target=code.tanner_graph,
+                physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                    code.tanner_graph.variable_nodes
+                ),
+                physical_ancilla_qubits={},  # readout look only at data qubits
                 readout_basis=PauliChar.Z,
                 tag=f"readout_{code.name}",
             )
diff --git a/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py b/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py
index 6d37b9a..1caed3f 100644
--- a/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py
+++ b/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py
@@ -1,15 +1,11 @@
 from typing import List, Set, Tuple, Union, cast
 from uuid import UUID
 
-from epic.core.compilation import QuantumMemory
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.data_structure import TannerNode
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import (
-    DetectorGraphPort,
-    NodeKnowledge,
-    QubitPortState,
-)
+from epic.core.data_structure import TannerNode, VariableNode
+from epic.core.qec_object import Detector, Measurement, DetectorGraphPort, NodeKnowledge
+
+from epic.core.qec_object.detector import QubitPortState
 from epic.core.qec_primitives.interfaces import ApplyGate, PrimitiveImplementation
 
 
@@ -19,7 +15,7 @@ class SimpleGateApplication(PrimitiveImplementation[ApplyGate]):
     @staticmethod
     def _sanitize_target_nodes(
         target_nodes: Union[Set[TannerNode], Set[Tuple[TannerNode, ...]]],
-    ) -> Set[Tuple[TannerNode, ...]]:
+    ) -> Set[Tuple[VariableNode, ...]]:
         """Normalize targets to a set of tuples and validate homogeneous tuple sizes."""
         if not target_nodes:
             raise ValueError("ApplyGate instruction must specify target_nodes.")
@@ -28,7 +24,7 @@ def _sanitize_target_nodes(
 
         if isinstance(first, tuple):
             sanitized_targets = set(
-                cast(Tuple[TannerNode, ...], group) for group in target_nodes
+                cast(Tuple[VariableNode, ...], group) for group in target_nodes
             )
 
             tuple_lengths = {len(group) for group in sanitized_targets}
@@ -43,15 +39,14 @@ def _sanitize_target_nodes(
 
         if any(isinstance(item, tuple) for item in target_nodes):
             raise ValueError(
-                "target_nodes must be either a set of TannerNode or a set of tuple[TannerNode, ...]."
+                "target_nodes must be either a set of VariableNode or a set of tuple[VariableNode, ...]."
             )
 
-        return {(cast(TannerNode, node),) for node in target_nodes}
+        return {(cast(VariableNode, node),) for node in target_nodes}
 
     def compile(
         self,
         instruction: ApplyGate,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -72,23 +67,24 @@ def compile(
             "RX": NodeKnowledge.RX,
         }
 
+        mem = {
+            **instruction.physical_data_qubits,
+            **instruction.physical_ancilla_qubits,
+        }
+
         if instruction.gates[-1] in gate_to_knowledge:
             node_knowledge = gate_to_knowledge[instruction.gates[-1]]
         else:
             node_knowledge = NodeKnowledge.UNKNOWN
 
-        for targets in sanitized_targets:
-            to_alloc = []
-            for node in targets:
-                if not memory.is_allocated(node):
-                    to_alloc.append(node)
-                new_dg_port[node] = QubitPortState(knowledge=node_knowledge)
-
-            memory.allocate_qubits(to_alloc)
+        if node_knowledge != NodeKnowledge.UNKNOWN:
+            for t in sanitized_targets:
+                for node in t:
+                    new_dg_port[node] = QubitPortState(knowledge=node_knowledge)
 
         for gate in instruction.gates:
             slots = " ".join(
-                str(memory.get_slot(node)) for t in sanitized_targets for node in t
+                str(mem[node].integer_index) for t in sanitized_targets for node in t
             )
             stim_instructions.append(f"{gate} {slots}")
 
diff --git a/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py b/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py
index ee294f2..aab1fab 100644
--- a/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py
+++ b/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py
@@ -1,10 +1,7 @@
-from types import MappingProxyType
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from uuid import UUID
 
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.data_structure import TannerNode
 from epic.core.qec_object import Detector, Measurement
 from epic.core.qec_object.detector import DetectorGraphPort
 from epic.core.qec_primitives.interfaces import PrimitiveImplementation, QECProcedure
@@ -14,9 +11,8 @@ class EmptyProcedure(PrimitiveImplementation[QECProcedure]):
     def compile(
         self,
         instruction: QECProcedure,
-        memory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
     ) -> Tuple[List[str], List[Measurement], List[Detector], DetectorGraphPort]:
-        return [], [], [], {}
+        return [], [], [], DetectorGraphPort()
diff --git a/src/epic/modules/qec_primitives/readouts/naive_readout.py b/src/epic/modules/qec_primitives/readouts/naive_readout.py
index c99e3e9..9e3001a 100644
--- a/src/epic/modules/qec_primitives/readouts/naive_readout.py
+++ b/src/epic/modules/qec_primitives/readouts/naive_readout.py
@@ -1,14 +1,15 @@
-from types import MappingProxyType
-from typing import Dict, List, Tuple, cast
+from typing import Dict, List, Tuple
 from uuid import UUID
 
-from epic.core.compilation import QuantumMemory
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.data_structure import CheckNode, TannerNode
-from epic.core.data_structure.pauli import PauliChar
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import DetectorGraphPort, QubitPortState
+from epic.core.data_structure import PauliChar
+from epic.core.qec_object import (
+    Detector,
+    Measurement,
+    DetectorGraphPort,
+    QubitPortState,
+    NodeKnowledge,
+)
 from epic.core.qec_primitives.interfaces import PrimitiveImplementation, Readout
 
 
@@ -18,7 +19,6 @@ class NaiveReadout(PrimitiveImplementation[Readout]):
     def compile(
         self,
         instruction: Readout,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -33,11 +33,7 @@ def compile(
         )
         nm = []
         for node in instruction.target.variable_nodes:
-            if not memory.is_allocated(node):
-                raise ValueError(
-                    f"Cannot measure node {node.id} in gadget={parent_gadget_id} as it is not allocated in memory."
-                )
-            nm.append(str(memory.get_slot(node)))
+            nm.append(str(instruction.physical_data_qubits[node].integer_index))
             new_m = Measurement(
                 node_id=node.id,
                 parent_gadget_id=parent_gadget_id,
@@ -45,6 +41,7 @@ def compile(
                 tag=f"readout_{node.tag}",
             )
             new_measurements[node.id] = new_m
+
         instructions.append(f"M{instruction.readout_basis.value} {' '.join(nm)}")
 
         detectors: List[Detector] = []
@@ -101,6 +98,5 @@ def compile(
         new_dg_port = DetectorGraphPort()
         for node in instruction.target.variable_nodes:
             new_dg_port[node] = QubitPortState(knowledge=new_port_state)
-        memory.free_qubits(list(instruction.target.variable_nodes))
 
         return instructions, list(new_measurements.values()), detectors, new_dg_port
diff --git a/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py b/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py
index acb23c1..953d994 100644
--- a/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py
+++ b/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py
@@ -2,14 +2,17 @@
 from uuid import UUID
 
 
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import (
     MeasurementRecordView,
 )
-from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import DetectorGraphPort, QubitPortState
+from epic.core.qec_object import (
+    Detector,
+    Measurement,
+    DetectorGraphPort,
+    QubitPortState,
+    NodeKnowledge,
+)
 from epic.core.qec_primitives.interfaces import ExtractSyndrome, PrimitiveImplementation
 
 
@@ -19,7 +22,6 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -33,22 +35,30 @@ def compile(
         measurements_ordered: List[Measurement] = []
         detectors: List[Detector] = []
 
-        to_alloc: List[TannerNode] = []
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        if len(check_nodes) > len(instruction.physical_ancilla_qubits):
+            raise ValueError(f"""
+                Not enough physical ancilla qubits provided for syndrome extraction.
+                Required: {len(check_nodes)}, Provided: {len(instruction.physical_ancilla_qubits)}
+                This schedule expect 1 ancilla per check node.
+                """)
+
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+        data_qubits = instruction.physical_data_qubits
+
+        node_to_qubit = {**checks_qubits, **data_qubits}
 
         # RESET ANCILLA
 
         match instruction.ancilla_reset_state:
             case PauliEigenState.Z_plus:
                 reset_ancilla_instructions.append(
-                    f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RZ {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case PauliEigenState.X_plus:
                 reset_ancilla_instructions.append(
-                    f"RX {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RX {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case _:
                 raise ValueError(
@@ -115,20 +125,20 @@ def compile(
 
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         for t in [t1, t2, t3, t4]:
             single_round_instructions.append(
-                f"CX {" ".join(f"{str(memory.get_slot(con))} {str(memory.get_slot(tar))}" for con, tar in t)}"
+                f"CX {" ".join(f"{str(node_to_qubit[con].integer_index)} {str(node_to_qubit[tar].integer_index)}" for con, tar in t)}"
             )
             single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"MRZ {" ".join(str(memory.get_slot(c)) for c in node_measured)}"
+            f"MRZ {" ".join(str(node_to_qubit[c].integer_index) for c in node_measured)}"
         )
 
         stim_instructions.append(f"REPEAT {instruction.rounds} {{")
diff --git a/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py b/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py
index d30a8bb..1efab30 100644
--- a/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py
+++ b/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py
@@ -3,16 +3,18 @@
 from uuid import UUID
 import warnings
 
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import (
-    MeasurementRecord,
     MeasurementRecordView,
 )
-from epic.core.compilation.quantum_memory import QuantumMemory
-from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode
-from epic.core.data_structure.tanner_node import CheckNode
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import DetectorGraphPort, QubitPortState
+
+from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode, CheckNode
+from epic.core.qec_object import (
+    Detector,
+    Measurement,
+    DetectorGraphPort,
+    QubitPortState,
+    NodeKnowledge,
+)
 from epic.core.qec_primitives.interfaces import ExtractSyndrome, PrimitiveImplementation
 
 
@@ -22,7 +24,6 @@ class SimpleSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -34,22 +35,29 @@ def compile(
         measurements: Dict[TannerNode, List[Measurement]] = {}
         measurements_ordered: List[Measurement] = []
         detectors: List[Detector] = []
-        to_alloc: List[TannerNode] = []
 
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        if len(check_nodes) > len(instruction.physical_ancilla_qubits):
+            raise ValueError(f"""
+                Not enough physical ancilla qubits provided for syndrome extraction.
+                Required: {len(check_nodes)}, Provided: {len(instruction.physical_ancilla_qubits)}
+                This schedule expect 1 ancilla per check node.
+                """)
+
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+
+        data_qubits = instruction.physical_data_qubits
 
         # RESET ANCILLA
 
         if instruction.ancilla_reset_state == PauliEigenState.Z_plus:
             reset_ancilla_instructions.append(
-                f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                f"RZ {" ".join([str(checks_qubits[check].integer_index) for check in check_nodes])}"
             )
         elif instruction.ancilla_reset_state == PauliEigenState.X_plus:
             reset_ancilla_instructions.append(
-                f"RX {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                f"RX {" ".join([str(checks_qubits[check].integer_index) for check in check_nodes])}"
             )
         else:
             raise ValueError(
@@ -66,9 +74,9 @@ def compile(
             )  # for clarity in the generated stim code
             if check.check_type:
                 check_circuit = self._extract_check_circuit(
-                    memory.get_slot(check),
+                    checks_qubits[check].integer_index,
                     [
-                        memory.get_slot(n)
+                        data_qubits[n].integer_index  # type: ignore
                         for n in instruction.target.get_neighbourhood(check)
                     ],
                     check.check_type,
@@ -81,7 +89,7 @@ def compile(
             [f"    {instr}" for instr in single_round_instructions]
         )
         stim_instructions.append(
-            f"    MRZ {" ".join(str(memory.get_slot(n)) for n in node_measured)}"
+            f"    MRZ {" ".join(str(checks_qubits[n].integer_index) for n in node_measured)}"
         )
         stim_instructions.append("}")
 
diff --git a/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py b/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py
index a824548..83391f3 100644
--- a/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py
+++ b/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py
@@ -2,19 +2,16 @@
 from uuid import UUID
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.compilation.quantum_memory import QuantumMemory
-from epic.core.data_structure.pauli import PauliChar, PauliEigenState
-from epic.core.data_structure.tanner_node import TannerNode
-from epic.core.qec_object.detector import (
+from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode, TannerEdge
+from epic.core.qec_object import (
     Detector,
     DetectorGraphPort,
     NodeKnowledge,
     QubitPortState,
+    Measurement,
 )
-from epic.core.qec_object.measurement import Measurement
 from epic.core.qec_primitives.interfaces.extract_syndrome import ExtractSyndrome
 from epic.core.qec_primitives.interfaces.qec_primitive import PrimitiveImplementation
-from epic.core.data_structure.tanner_graph import TannerEdge
 
 
 class ZXColoringExtraction(PrimitiveImplementation[ExtractSyndrome]):
@@ -52,22 +49,29 @@ def _color_edges(edges: set[TannerEdge]) -> Tuple[Dict[TannerEdge, int], int]:
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
     ) -> Tuple[List[str], List[Measurement], List[Detector], DetectorGraphPort]:
 
+        check_nodes = instruction.target.check_nodes
         stim_instructions = []
         detectors = []
         measurements = []
 
-        # Alloc qubits if needed
-        to_alloc: List[TannerNode] = []
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        if len(check_nodes) > len(instruction.physical_ancilla_qubits):
+            raise ValueError(f"""
+                    Not enough physical ancilla qubits provided for syndrome extraction.
+                    Required: {len(check_nodes)}, Provided: {len(instruction.physical_ancilla_qubits)}
+                    This schedule expect 1 ancilla per check node.
+                    """)
+
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+        data_qubits = instruction.physical_data_qubits
+
+        node_to_qubit = {**checks_qubits, **data_qubits}
 
         # Separate X and Z edges
         tanner = instruction.target
@@ -99,11 +103,11 @@ def compile(
         match instruction.ancilla_reset_state:
             case PauliEigenState.Z_plus:
                 stim_instructions.append(
-                    f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RZ {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case PauliEigenState.X_plus:
                 stim_instructions.append(
-                    f"RX {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RX {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case _:
                 raise ValueError(
@@ -117,13 +121,13 @@ def compile(
         # X checks:
         if x_checks:
             single_round_instructions.append(
-                f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+                f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
             )
             single_round_instructions.append("TICK")
         x_cnot_steps = [[] for _ in range(x_color_count + 1)]
         for edge in x_edges:
-            var_slot = memory.get_slot(edge.variable_node)
-            check_slot = memory.get_slot(edge.check_node)
+            var_slot = node_to_qubit[edge.variable_node].integer_index
+            check_slot = node_to_qubit[edge.check_node].integer_index
             color = x_coloring[edge]
             x_cnot_steps[color].append((check_slot, var_slot))
         for step in x_cnot_steps:
@@ -135,15 +139,15 @@ def compile(
             single_round_instructions.append("TICK")
         if x_checks:
             single_round_instructions.append(
-                f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+                f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
             )
             single_round_instructions.append("TICK")
 
         # Z checks:
         z_cnot_steps = [[] for _ in range(z_color_count + 1)]
         for edge in z_edges:
-            var_slot = memory.get_slot(edge.variable_node)
-            check_slot = memory.get_slot(edge.check_node)
+            var_slot = node_to_qubit[edge.variable_node].integer_index
+            check_slot = node_to_qubit[edge.check_node].integer_index
             color = z_coloring[edge]
             z_cnot_steps[color].append((check_slot, var_slot))
         for step in z_cnot_steps:
@@ -157,7 +161,7 @@ def compile(
         # Measure ancilla qubits
         check_order = list(instruction.target.check_nodes)
         single_round_instructions.append(
-            f"MRZ {" ".join(str(memory.get_slot(c)) for c in check_order)}"
+            f"MRZ {" ".join(str(node_to_qubit[c].integer_index) for c in check_order)}"
         )
         stim_instructions.append(f"REPEAT {instruction.rounds} {{")
         stim_instructions.extend(
diff --git a/tests/core/compilation/test_qec_compiler.py b/tests/core/compilation/test_qec_compiler.py
index d1d48a5..618e7f4 100644
--- a/tests/core/compilation/test_qec_compiler.py
+++ b/tests/core/compilation/test_qec_compiler.py
@@ -29,9 +29,17 @@ class DummyCodeGadget(CodeGadget):
     updates: dict[UUID, LogicalOperatorUpdate] = Field(default_factory=dict)
     call_log: dict[str, Any] = Field(default_factory=dict)
 
-    def compile(self, resolved_targets, record, timestep, objective_distance):
+    def compile(
+        self,
+        resolved_targets,
+        record,
+        quantum_memory,
+        timestep,
+        objective_distance,
+    ):
         self.call_log["resolved_targets"] = resolved_targets
         self.call_log["record_size"] = len(record.measurements())
+        self.call_log["quantum_memory"] = quantum_memory
         self.call_log["timestep"] = timestep
         self.call_log["objective_distance"] = objective_distance
         primitives = cast(list[QECPrimitive], [self.primitive])
@@ -44,9 +52,17 @@ class DummyLogicGadget(LogicGadget):
     updates: dict[UUID, LogicalOperatorUpdate] = Field(default_factory=dict)
     call_log: dict[str, Any] = Field(default_factory=dict)
 
-    def compile(self, resolved_targets, record, timestep, objective_distance):
+    def compile(
+        self,
+        resolved_targets,
+        record,
+        quantum_memory,
+        timestep,
+        objective_distance,
+    ):
         self.call_log["resolved_targets"] = resolved_targets
         self.call_log["record_size"] = len(record.measurements())
+        self.call_log["quantum_memory"] = quantum_memory
         self.call_log["timestep"] = timestep
         self.call_log["objective_distance"] = objective_distance
         primitives = cast(list[QECPrimitive], [self.primitive])
@@ -85,7 +101,6 @@ def test_compile_runs_code_gadget_and_collects_outputs(
         def fake_compile(
             self,
             primitive_instruction,
-            memory,
             record,
             det_graph_port,
             parent_gadget_id,
@@ -112,6 +127,7 @@ def fake_compile(
 
         assert gadget.call_log["resolved_targets"] == [stabilizer_code]
         assert gadget.call_log["record_size"] == 0
+        assert gadget.call_log["quantum_memory"] == qec_compiler.ctx.quantum_memory
         assert gadget.call_log["timestep"] == 0
         assert gadget.call_log["objective_distance"] == 1
         assert compiled.record.view().measurements() == (measurement_a,)
@@ -149,7 +165,6 @@ def test_compile_runs_logic_gadget_and_visualization_hook(
         def fake_compile(
             self,
             primitive_instruction,
-            memory,
             record,
             det_graph_port,
             parent_gadget_id,
@@ -176,6 +191,7 @@ def fake_visualize(
         )
 
         assert gadget.call_log["resolved_targets"] == [(logical_qubit, stabilizer_code)]
+        assert gadget.call_log["quantum_memory"] == qec_compiler.ctx.quantum_memory
         assert compiled.circuit_instructions == ["M 0"]
         assert visualized["path"] == Path("visuals/out.svg")
         assert visualized["primitive"] == primitive
diff --git a/tests/core/compilation/test_quantum_memory.py b/tests/core/compilation/test_quantum_memory.py
index 2901359..fe5686c 100644
--- a/tests/core/compilation/test_quantum_memory.py
+++ b/tests/core/compilation/test_quantum_memory.py
@@ -6,6 +6,7 @@
 import pytest
 
 from epic.core.compilation.quantum_memory import QuantumMemory
+from epic.core.data_structure.physical_qubit import PhysicalQubit
 from epic.core.data_structure.tanner_node import VariableNode
 
 
@@ -21,13 +22,16 @@ def test_allocate_qubits_grows_capacity_and_assigns_slots(
         memory = QuantumMemory()
 
         slots = memory.allocate_qubits(memory_nodes[:2])
+        allocation = memory.data_qubits_allocation_snapshot(set(memory_nodes[:2]))
 
-        assert slots == [0, 1]
+        assert len(slots) == 2
+        assert all(isinstance(slot, PhysicalQubit) for slot in slots)
         assert memory.size == 2
-        assert memory.slots == (0, 1)
+        assert {slot.integer_index for slot in slots} == {0, 1}
+        assert {slot.integer_index for slot in memory.slots} == {0, 1}
         assert memory.free_slots == ()
-        assert memory.get_slot(memory_nodes[0]) == 0
-        assert memory.get_slot(memory_nodes[1]) == 1
+        assert allocation[memory_nodes[0]] == slots[0]
+        assert allocation[memory_nodes[1]] == slots[1]
         assert memory.is_allocated(memory_nodes[0])
         assert memory.is_allocated(memory_nodes[1])
 
@@ -35,37 +39,41 @@ def test_allocate_qubits_reuses_freed_slots_before_growing(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
-        memory.allocate_qubits(memory_nodes[:2])
+        initial_slots = memory.allocate_qubits(memory_nodes[:2])
         memory.free_qubits([memory_nodes[0]])
 
         slots = memory.allocate_qubits([memory_nodes[2]])
 
-        assert slots == [0]
+        assert slots == [initial_slots[0]]
         assert memory.size == 2
-        assert memory.get_slot(memory_nodes[2]) == 0
+        assert (
+            memory.data_qubits_allocation_snapshot(
+                cast(set[VariableNode], {cast(Any, memory_nodes[2])})
+            )[memory_nodes[2]]
+            == initial_slots[0]
+        )
         assert not memory.is_allocated(memory_nodes[0])
         assert memory.free_slots == ()
 
-    def test_allocate_qubits_partially_reuses_free_slots_and_expands(
+    def test_allocate_qubits_raises_when_request_exceeds_available_capacity(
         self, memory_nodes: list[VariableNode]
     ) -> None:
-        memory = QuantumMemory()
+        memory = QuantumMemory(size_limit=2)
         memory.allocate_qubits(memory_nodes[:2])
         memory.free_qubits([memory_nodes[1]])
 
-        slots = memory.allocate_qubits(memory_nodes[2:4])
+        with pytest.raises(RuntimeError, match="Not enough free qubits"):
+            memory.allocate_qubits(memory_nodes[2:4])
 
-        assert slots == [1, 2]
-        assert memory.size == 3
-        assert memory.slots == (0, 1, 2)
-        assert memory.get_slot(memory_nodes[2]) == 1
-        assert memory.get_slot(memory_nodes[3]) == 2
+        assert memory.size == 2
+        assert not memory.is_allocated(memory_nodes[2])
+        assert not memory.is_allocated(memory_nodes[3])
 
     def test_free_qubits_releases_slots_and_updates_allocation(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
-        memory.allocate_qubits(memory_nodes[:3])
+        allocated_qubits = memory.allocate_qubits(memory_nodes[:3])
 
         result = memory.free_qubits(memory_nodes[:2])
 
@@ -73,34 +81,36 @@ def test_free_qubits_releases_slots_and_updates_allocation(
         assert not memory.is_allocated(memory_nodes[0])
         assert not memory.is_allocated(memory_nodes[1])
         assert memory.is_allocated(memory_nodes[2])
-        assert memory.free_slots == (0, 1)
+        assert set(memory.free_slots) == set(allocated_qubits[:2])
 
-    def test_get_slot_raises_for_unallocated_qubit(
+    def test_get_physical_qubit_raises_for_unallocated_qubit(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
 
         with pytest.raises(KeyError):
-            memory.get_slot(memory_nodes[0])
+            memory.get_physical_qubit(memory_nodes[0])
 
     def test_free_qubits_raises_for_unallocated_qubit(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
 
-        with pytest.raises(KeyError):
+        with pytest.raises(RuntimeError, match="is not currently allocated"):
             memory.free_qubits([memory_nodes[0]])
 
-    def test_allocation_property_exposes_read_only_view(
+    def test_data_qubits_allocation_snapshot_exposes_read_only_view(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
-        memory.allocate_qubits([memory_nodes[0]])
+        allocated_qubit = memory.allocate_qubits([memory_nodes[0]])[0]
 
-        allocation = memory.allocation
+        allocation = memory.data_qubits_allocation_snapshot(
+            cast(set[VariableNode], {cast(Any, memory_nodes[0])})
+        )
         unsafe_allocation = cast(Any, allocation)
 
         assert isinstance(allocation, MappingProxyType)
-        assert allocation[memory_nodes[0]] == 0
+        assert allocation[memory_nodes[0]] == allocated_qubit
         with pytest.raises(TypeError):
-            unsafe_allocation[memory_nodes[1]] = 1
+            unsafe_allocation[memory_nodes[1]] = allocated_qubit