--- a/crates/ipu-codegen/src/place.rs
+++ b/crates/ipu-codegen/src/place.rs
@@ -1716,8 +1716,8 @@
         let mut config = PipelineConfig::new(4).with_input(input, format.clone());
         config.operator_candidates = vec![crate::ConcreteOperatorCandidate::new(
             crate::MidOperator::Gelu,
-            [crate::OperandRequirement::new(format.clone(), 8)],
-            crate::OperandRequirement::new(format, 8),
+            [crate::OperandRequirement::new(format.clone())],
+            crate::OperandRequirement::new(format),
         )]
         .into_iter()
         .map(crate::OperatorCandidate::Concrete)
--- a/crates/ipu-codegen/src/low/expand/tests.rs
+++ b/crates/ipu-codegen/src/low/expand/tests.rs
@@ -17,7 +17,7 @@
 use crate::{
     AccumulationPrecision, AxisTiling, ComputeGraph, ElementOrder, GemmDistribution, GridOrder,
     Ipu21CostModel, Layout, MemoryClass, MidOperator, OperandRequirement, OperatorCandidate,
-    OperatorDispatch, Padding, PipelineConfig, Precision, TensorAxis, TensorFormat, TensorTiling,
+    OperatorDispatch, OutputAliasing, Padding, PipelineConfig, Precision, TensorAxis, TensorFormat, TensorTiling,
     TileKernelSpec, lower,
 };
 use std::collections::BTreeSet;
@@ -456,10 +456,10 @@
         let candidate = ConcreteOperatorCandidate::new(
             operator,
             [
-                OperandRequirement::new(left_format.clone(), 32),
-                OperandRequirement::new(right_format.clone(), 32),
+                OperandRequirement::new(left_format.clone()),
+                OperandRequirement::new(right_format.clone()),
             ],
-            OperandRequirement::new(output_format, 32),
+            OperandRequirement::new(output_format),
         )
         .with_dispatch(OperatorDispatch::BlockedGemm {
             inner_block: 64,
@@ -626,10 +626,10 @@
                 accumulate: crate::AccumulationPrecision::F16,
             },
             [
-                OperandRequirement::new(left_format, 32).with_access_tail(16),
-                OperandRequirement::new(right_format, 32),
+                OperandRequirement::new(left_format),
+                OperandRequirement::new(right_format),
             ],
-            OperandRequirement::new(output_format, 32),
+            OperandRequirement::new(output_format),
         )]
         .into_iter()
         .map(OperatorCandidate::Concrete)
@@ -676,8 +676,8 @@
         let mut config = PipelineConfig::new(tiles).with_input(input, tensor_format.clone());
         config.operator_candidates = vec![ConcreteOperatorCandidate::new(
             MidOperator::Gelu,
-            [OperandRequirement::new(tensor_format.clone(), 8)],
-            OperandRequirement::new(tensor_format, 8),
+            [OperandRequirement::new(tensor_format.clone())],
+            OperandRequirement::new(tensor_format),
         )]
         .into_iter()
         .map(OperatorCandidate::Concrete)
@@ -862,8 +862,8 @@
         let mut config = PipelineConfig::new(tiles).with_input(input, input_format.clone());
         config.operator_candidates = vec![ConcreteOperatorCandidate::new(
             MidOperator::Gelu,
-            [OperandRequirement::new(input_format, 8)],
-            OperandRequirement::new(output_format, 8),
+            [OperandRequirement::new(input_format)],
+            OperandRequirement::new(output_format),
         )]
         .into_iter()
         .map(OperatorCandidate::Concrete)
@@ -931,8 +931,8 @@
         let mut config = PipelineConfig::new(tiles).with_input(input, input_format);
         config.operator_candidates = vec![ConcreteOperatorCandidate::new(
             MidOperator::Gelu,
-            [OperandRequirement::new(target_format.clone(), 8)],
-            OperandRequirement::new(target_format, 8),
+            [OperandRequirement::new(target_format.clone())],
+            OperandRequirement::new(target_format),
         )]
         .into_iter()
         .map(OperatorCandidate::Concrete)
@@ -1763,10 +1763,10 @@
                 accumulate: crate::AccumulationPrecision::F32,
             },
             [
-                crate::OperandRequirement::new(left_format, 32).with_access_tail(16),
-                crate::OperandRequirement::new(right_format, 32).with_local_staging(local_staging),
+                crate::OperandRequirement::new(left_format),
+                crate::OperandRequirement::new(right_format).with_local_staging(local_staging),
             ],
-            crate::OperandRequirement::new(output_format, 32),
+            crate::OperandRequirement::new(output_format),
         )]
         .into_iter()
         .map(OperatorCandidate::Concrete)
@@ -2152,8 +2152,8 @@
     graph.set_outputs([output]).unwrap();
     let mut candidate = ConcreteOperatorCandidate::new(
         MidOperator::Gelu,
-        [OperandRequirement::new(format.clone(), 8)],
-        OperandRequirement::new(format.clone(), 8),
+        [OperandRequirement::new(format.clone())],
+        OperandRequirement::new(format.clone()),
     );
     candidate.plan.requirements.output_aliasing = OutputAliasing::MayAliasInputs(vec![0]);
     let mut config = PipelineConfig::new(4).with_input(input, format);
--- a/crates/ipu-codegen/src/low/expand/repeat.rs
+++ b/crates/ipu-codegen/src/low/expand/repeat.rs
@@ -166,19 +166,7 @@
                 && value_can_alias(operation.inputs[input], target, operations)
         });
     }
-    let Some(plan) = operation.operator_plan() else {
-        return false;
-    };
-    let indices = match &plan.requirements.output_aliasing {
-        OutputAliasing::Fresh => return false,
-        OutputAliasing::MayAliasInputs(indices) => indices.as_slice(),
-    };
-    indices.iter().any(|index| {
-        operation
-            .inputs
-            .get(usize::from(*index))
-            .is_some_and(|input| value_can_alias(*input, target, operations))
-    })
+    false
 }
 
 fn repeat_yield_can_alias(
@@ -221,14 +209,6 @@
                     access_tail = access_tail.max(8 * multiply.bytes() as u32);
                 }
             }
-            let requirement = operation
-                .operator_plan()
-                .and_then(|plan| plan.requirements.inputs.get(index))
-                .or_else(|| operation.conversion_plan().map(|plan| &plan.input));
-            if let Some(requirement) = requirement {
-                alignment = alignment.max(requirement.alignment);
-                access_tail = access_tail.max(requirement.access_tail_bytes);
-            }
         }
     }
     (alignment, access_tail)