diff --git a/Cargo.toml b/Cargo.toml
index 45584d84..48a27a86 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,6 +36,7 @@ members = [
     "crates/kiss/monitor",
     "crates/kiss/operator",
     "crates/kubegraph/analyzer/llm",
+    "crates/kubegraph/annotator",
     "crates/kubegraph/api",
     "crates/kubegraph/connector/fake",
     "crates/kubegraph/connector/local",
@@ -47,8 +48,11 @@ members = [
     "crates/kubegraph/operator",
     "crates/kubegraph/parser",
     "crates/kubegraph/runner/simulator",
+    "crates/kubegraph/simulator",
     "crates/kubegraph/solver/ortools",
+    "crates/kubegraph/visualizer",
     "crates/kubegraph/vm/http",
+    "crates/kubegraph/vm/lazy",
     "crates/kubegraph/vm/local",
     "crates/straw/api",
     "crates/straw/provider",
@@ -113,6 +117,9 @@ deltalake = { version = "0.17", features = [
 ] }
 derivative = { version = "2.2" }
 dirs = { version = "5.0" }
+eframe = { version = "0.27" }
+egui = { version = "0.27" }
+egui_graphs = { version = "0.20" }
 email_address = { version = "0.2" }
 futures = { version = "0.3" }
 gethostname = { version = "0.4" }
@@ -176,6 +183,7 @@ ordered-float = { version = "4.2", default-features = false, features = [
     "serde",
     "std",
 ] }
+petgraph = { version = "0.6" }
 polars = { version = "0.40", features = [
     "diagonal_concat",
     "diff",
diff --git a/crates/kubegraph/annotator/Cargo.toml b/crates/kubegraph/annotator/Cargo.toml
new file mode 100644
index 00000000..a666afff
--- /dev/null
+++ b/crates/kubegraph/annotator/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "kubegraph-annotator"
+
+authors = { workspace = true }
+description = { workspace = true }
+documentation = { workspace = true }
+edition = { workspace = true }
+include = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+readme = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+version = { workspace = true }
+
+[lints]
+workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+kubegraph-api = { path = "../api" }
+kubegraph-vm-lazy = { path = "../vm/lazy" }
+
+anyhow = { workspace = true }
+async-trait = { workspace = true }
diff --git a/crates/kubegraph/annotator/src/lib.rs b/crates/kubegraph/annotator/src/lib.rs
new file mode 100644
index 00000000..a653c755
--- /dev/null
+++ b/crates/kubegraph/annotator/src/lib.rs
@@ -0,0 +1,22 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use kubegraph_api::{annotator::NetworkAnnotationSpec, vm::Script};
+
+pub struct NetworkAnnotator {}
+
+#[async_trait]
+impl<G> ::kubegraph_api::annotator::NetworkAnnotator<G> for NetworkAnnotator
+where
+    G: Send,
+{
+    async fn annotate(
+        &self,
+        graph: G,
+        spec: &NetworkAnnotationSpec,
+    ) -> Result<NetworkAnnotationSpec<Script>>
+    where
+        G: 'async_trait,
+    {
+        todo!()
+    }
+}
diff --git a/crates/kubegraph/api/Cargo.toml b/crates/kubegraph/api/Cargo.toml
index 4611b252..7fa506b2 100644
--- a/crates/kubegraph/api/Cargo.toml
+++ b/crates/kubegraph/api/Cargo.toml
@@ -42,7 +42,14 @@ df-polars = ["dep:polars"]
 function-full = ["function-dummy"]
 function-dummy = []
 
+# Virtual Machines
+vm-entrypoint = ["ark-core"]
+
 [dependencies]
+ark-core = { path = "../../ark/core", optional = true, features = [
+    "actix-web",
+    "signal",
+] }
 ark-core-k8s = { path = "../../ark/core/k8s", features = ["data"] }
 
 anyhow = { workspace = true }
diff --git a/crates/kubegraph/api/src/annotator.rs b/crates/kubegraph/api/src/annotator.rs
new file mode 100644
index 00000000..c1379525
--- /dev/null
+++ b/crates/kubegraph/api/src/annotator.rs
@@ -0,0 +1,49 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use kube::CustomResource;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::vm::Script;
+
+#[async_trait]
+pub trait NetworkAnnotator<G>
+where
+    G: Send,
+{
+    async fn annotate(
+        &self,
+        graph: G,
+        spec: &NetworkAnnotationSpec,
+    ) -> Result<NetworkAnnotationSpec<Script>>
+    where
+        G: 'async_trait;
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema, CustomResource)]
+#[kube(
+    group = "kubegraph.ulagbulag.io",
+    version = "v1alpha1",
+    kind = "NetworkAnnotation",
+    root = "NetworkAnnotationCrd",
+    shortname = "nf",
+    namespaced,
+    printcolumn = r#"{
+        "name": "created-at",
+        "type": "date",
+        "description": "created time",
+        "jsonPath": ".metadata.creationTimestamp"
+    }"#,
+    printcolumn = r#"{
+        "name": "version",
+        "type": "integer",
+        "description": "annotation version",
+        "jsonPath": ".metadata.generation"
+    }"#
+)]
+#[serde(rename_all = "camelCase")]
+pub struct NetworkAnnotationSpec<Script = String> {
+    #[serde(default)]
+    pub filter: Option<Script>,
+    pub script: Script,
+}
diff --git a/crates/kubegraph/api/src/function/mod.rs b/crates/kubegraph/api/src/function/mod.rs
index 64392c78..f83f2416 100644
--- a/crates/kubegraph/api/src/function/mod.rs
+++ b/crates/kubegraph/api/src/function/mod.rs
@@ -5,7 +5,7 @@ use kube::CustomResource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::{graph::GraphScope, resource::NetworkResource};
+use crate::{annotator::NetworkAnnotationSpec, graph::GraphScope, resource::NetworkResource};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema, CustomResource)]
 #[kube(
@@ -33,23 +33,13 @@ pub struct NetworkFunctionSpec {
     #[serde(flatten)]
     pub kind: NetworkFunctionKind,
     #[serde(flatten)]
-    pub metadata: NetworkFunctionMetadata,
+    pub metadata: NetworkAnnotationSpec,
 }
 
 impl NetworkResource for NetworkFunctionCrd {
     type Filter = ();
 }
 
-#[derive(
-    Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, JsonSchema,
-)]
-#[serde(rename_all = "camelCase")]
-pub struct NetworkFunctionMetadata<Script = String> {
-    #[serde(default)]
-    pub filter: Option<Script>,
-    pub script: Script,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 #[non_exhaustive]
diff --git a/crates/kubegraph/api/src/lib.rs b/crates/kubegraph/api/src/lib.rs
index 8d05560b..586587e1 100644
--- a/crates/kubegraph/api/src/lib.rs
+++ b/crates/kubegraph/api/src/lib.rs
@@ -2,6 +2,7 @@
 extern crate polars as pl;
 
 pub mod analyzer;
+pub mod annotator;
 pub mod connector;
 pub mod frame;
 pub mod function;
diff --git a/crates/kubegraph/api/src/vm.rs b/crates/kubegraph/api/src/vm.rs
index ef78d16d..a63cbe54 100644
--- a/crates/kubegraph/api/src/vm.rs
+++ b/crates/kubegraph/api/src/vm.rs
@@ -33,6 +33,49 @@ pub trait NetworkVirtualMachineExt
 where
     Self: NetworkVirtualMachine,
 {
+    #[cfg(feature = "vm-entrypoint")]
+    async fn main<F>(handlers: F)
+    where
+        Self: 'static + Sized,
+        F: Send + FnOnce(&Self) -> Vec<::tokio::task::JoinHandle<()>>,
+    {
+        ::ark_core::tracer::init_once();
+        info!("Welcome to kubegraph!");
+
+        let signal = ::ark_core::signal::FunctionSignal::default().trap_on_panic();
+        if let Err(error) = signal.trap_on_sigint() {
+            error!("{error}");
+            return;
+        }
+
+        info!("Booting...");
+        let vm = match <Self as NetworkVirtualMachine>::try_default().await {
+            Ok(vm) => vm,
+            Err(error) => {
+                signal
+                    .panic(anyhow!("failed to init network virtual machine: {error}"))
+                    .await
+            }
+        };
+
+        info!("Registering side workers...");
+        let handlers = handlers(&vm);
+
+        info!("Ready");
+        signal.wait_to_terminate().await;
+
+        info!("Terminating...");
+        for handler in handlers {
+            handler.abort();
+        }
+
+        if let Err(error) = vm.close().await {
+            error!("{error}");
+        };
+
+        signal.exit().await
+    }
+
     #[instrument(level = Level::INFO, skip(self))]
     async fn loop_forever(&self) {
         let fallback_interval = self.fallback_interval();
@@ -200,6 +243,10 @@ where
 
     fn interval(&self) -> Option<Duration>;
 
+    async fn try_default() -> Result<Self>
+    where
+        Self: Sized;
+
     async fn infer_edges(
         &self,
         problem: &VirtualProblem,
@@ -244,6 +291,13 @@ where
         <T as NetworkVirtualMachine>::interval(&**self)
     }
 
+    #[instrument(level = Level::INFO)]
+    async fn try_default() -> Result<Self> {
+        <T as NetworkVirtualMachine>::try_default()
+            .await
+            .map(Self::new)
+    }
+
     #[instrument(level = Level::INFO, skip(self, problem, nodes))]
     async fn infer_edges(
         &self,
diff --git a/crates/kubegraph/gateway/Cargo.toml b/crates/kubegraph/gateway/Cargo.toml
index 47ce9866..340a64e3 100644
--- a/crates/kubegraph/gateway/Cargo.toml
+++ b/crates/kubegraph/gateway/Cargo.toml
@@ -39,8 +39,8 @@ full = [
 # Configure Analyzers
 analyzer-full = ["analyzer-llm"]
 analyzer-llm = [
-    "kubegraph-vm-local?/analyzer-llm",
     "kubegraph-api/analyzer-llm",
+    "kubegraph-vm-local?/analyzer-llm",
 ]
 
 # Configure Connectors
@@ -87,8 +87,8 @@ vm-full = ["vm-local"]
 vm-local = ["kubegraph-vm-local"]
 
 [dependencies]
-ark-core = { path = "../../ark/core", features = ["actix-web", "signal"] }
-kubegraph-api = { path = "../api" }
+ark-core = { path = "../../ark/core" }
+kubegraph-api = { path = "../api", features = ["vm-entrypoint"] }
 kubegraph-vm-local = { path = "../vm/local", optional = true, default-features = false }
 
 actix-web = { workspace = true }
diff --git a/crates/kubegraph/gateway/problems/warehouse.yaml b/crates/kubegraph/gateway/problems/warehouse.yaml
index 242748e7..ce47b27d 100644
--- a/crates/kubegraph/gateway/problems/warehouse.yaml
+++ b/crates/kubegraph/gateway/problems/warehouse.yaml
@@ -16,8 +16,6 @@ metadata:
   name: warehouse-sample-a
   namespace: kubegraph
 spec:
-  metadata:
-    supply: payload
   fake:
     nodes:
       count: 1
@@ -45,8 +43,6 @@ metadata:
   name: warehouse-sample-b
   namespace: kubegraph
 spec:
-  metadata:
-    supply: payload
   fake:
     nodes:
       count: 1
@@ -69,6 +65,16 @@ spec:
           valueType: I64
 ---
 apiVersion: kubegraph.ulagbulag.io/v1alpha1
+kind: NetworkAnnotation
+metadata:
+  name: warehouse
+  namespace: kubegraph
+spec:
+  filter: src != sink and src.supply > 0 and src.supply > sink.supply + 1
+  script: |
+    supply = payload;
+---
+apiVersion: kubegraph.ulagbulag.io/v1alpha1
 kind: NetworkProblem
 metadata:
   name: warehouse
@@ -85,7 +91,7 @@ metadata:
   namespace: kubegraph
 spec:
   dummy: {}
-  filter: src != sink and src.supply > 0 and src.supply > sink.supply
+  filter: src != sink and src.supply > 0 and src.supply > sink.supply + 1
   script: |
     capacity = min(50, (src.supply - sink.supply) / 2);
     unit_cost = 1;
diff --git a/crates/kubegraph/gateway/src/main.rs b/crates/kubegraph/gateway/src/main.rs
index f5bc8dab..2ba4bb7b 100644
--- a/crates/kubegraph/gateway/src/main.rs
+++ b/crates/kubegraph/gateway/src/main.rs
@@ -2,46 +2,11 @@ mod actix;
 mod routes;
 mod vm;
 
-use anyhow::anyhow;
 use kubegraph_api::vm::NetworkVirtualMachineExt;
 use tokio::spawn;
-use tracing::{error, info};
 
 #[tokio::main]
 async fn main() {
-    ::ark_core::tracer::init_once();
-    info!("Welcome to kubegraph!");
-
-    let signal = ::ark_core::signal::FunctionSignal::default().trap_on_panic();
-    if let Err(error) = signal.trap_on_sigint() {
-        error!("{error}");
-        return;
-    }
-
-    info!("Booting...");
-    let vm = match self::vm::try_init().await {
-        Ok(vm) => vm,
-        Err(error) => {
-            signal
-                .panic(anyhow!("failed to init network virtual machine: {error}"))
-                .await
-        }
-    };
-
-    info!("Registering side workers...");
-    let handlers = vec![spawn(crate::actix::loop_forever(vm.clone()))];
-
-    info!("Ready");
-    signal.wait_to_terminate().await;
-
-    info!("Terminating...");
-    for handler in handlers {
-        handler.abort();
-    }
-
-    if let Err(error) = vm.close().await {
-        error!("{error}");
-    };
-
-    signal.exit().await
+    self::vm::NetworkVirtualMachine::main(|vm| vec![spawn(crate::actix::loop_forever(vm.clone()))])
+        .await
 }
diff --git a/crates/kubegraph/gateway/src/vm.rs b/crates/kubegraph/gateway/src/vm.rs
index dbd9a98c..95f74c14 100644
--- a/crates/kubegraph/gateway/src/vm.rs
+++ b/crates/kubegraph/gateway/src/vm.rs
@@ -1,6 +1,2 @@
-use anyhow::Result;
-
 #[cfg(feature = "vm-local")]
-pub async fn try_init() -> Result<::kubegraph_vm_local::NetworkVirtualMachine> {
-    ::kubegraph_vm_local::NetworkVirtualMachine::try_default().await
-}
+pub type NetworkVirtualMachine = ::kubegraph_vm_local::NetworkVirtualMachine;
diff --git a/crates/kubegraph/operator/src/ctx/annotation.rs b/crates/kubegraph/operator/src/ctx/annotation.rs
new file mode 100644
index 00000000..103d19b7
--- /dev/null
+++ b/crates/kubegraph/operator/src/ctx/annotation.rs
@@ -0,0 +1,31 @@
+use std::{sync::Arc, time::Duration};
+
+use anyhow::Result;
+use ark_core_k8s::manager::Manager;
+use async_trait::async_trait;
+use kube::{runtime::controller::Action, Error, ResourceExt};
+use kubegraph_api::annotator::NetworkAnnotationCrd;
+use tracing::{instrument, Level};
+
+#[derive(Default)]
+pub struct Ctx {}
+
+#[async_trait]
+impl ::ark_core_k8s::manager::Ctx for Ctx {
+    type Data = NetworkAnnotationCrd;
+
+    const NAME: &'static str = crate::consts::NAME;
+    const NAMESPACE: &'static str = ::kubegraph_api::consts::NAMESPACE;
+    const FALLBACK: Duration = Duration::from_secs(30); // 30 seconds
+
+    #[instrument(level = Level::INFO, skip_all, fields(name = %_data.name_any(), namespace = _data.namespace()), err(Display))]
+    async fn reconcile(
+        _manager: Arc<Manager<Self>>,
+        _data: Arc<<Self as ::ark_core_k8s::manager::Ctx>::Data>,
+    ) -> Result<Action, Error>
+    where
+        Self: Sized,
+    {
+        Ok(Action::await_change())
+    }
+}
diff --git a/crates/kubegraph/operator/src/ctx/mod.rs b/crates/kubegraph/operator/src/ctx/mod.rs
index 142014c7..46b78036 100644
--- a/crates/kubegraph/operator/src/ctx/mod.rs
+++ b/crates/kubegraph/operator/src/ctx/mod.rs
@@ -1,3 +1,4 @@
+pub mod annotation;
 pub mod connector;
 pub mod function;
 pub mod problem;
diff --git a/crates/kubegraph/operator/src/main.rs b/crates/kubegraph/operator/src/main.rs
index cf3d6ab9..ae5c9fa1 100644
--- a/crates/kubegraph/operator/src/main.rs
+++ b/crates/kubegraph/operator/src/main.rs
@@ -10,6 +10,7 @@ pub(crate) mod consts {
 #[tokio::main]
 async fn main() {
     join!(
+        self::ctx::annotation::Ctx::spawn_crd(),
         self::ctx::connector::Ctx::spawn_crd(),
         self::ctx::function::Ctx::spawn_crd(),
         self::ctx::problem::Ctx::spawn_crd(),
diff --git a/crates/kubegraph/simulator/Cargo.toml b/crates/kubegraph/simulator/Cargo.toml
new file mode 100644
index 00000000..321b3b30
--- /dev/null
+++ b/crates/kubegraph/simulator/Cargo.toml
@@ -0,0 +1,54 @@
+[package]
+name = "kubegraph-simulator"
+
+authors = { workspace = true }
+description = { workspace = true }
+documentation = { workspace = true }
+edition = { workspace = true }
+include = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+readme = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+version = { workspace = true }
+
+[lints]
+workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = ["full"]
+full = ["analyzer-full", "solver-full"]
+
+# Configure Analyzers
+analyzer-full = ["analyzer-llm"]
+analyzer-llm = ["kubegraph-api/analyzer-llm", "kubegraph-vm-local/analyzer-llm"]
+
+# Configure Solvers
+solver-full = ["solver-ortools"]
+solver-ortools = ["kubegraph-vm-local/solver-ortools"]
+
+[dependencies]
+kubegraph-api = { path = "../api", default-features = false, features = [
+    "connector-fake",
+    "connector-local",
+    "df-polars",
+    "function-dummy",
+    "vm-entrypoint",
+] }
+kubegraph-vm-local = { path = "../vm/local", default-features = false, features = [
+    "connector-fake",
+    "connector-local",
+    "df-polars",
+    "function-dummy",
+    "graph-memory",
+    "runner-simulator",
+] }
+kubegraph-visualizer = { path = "../visualizer", default-features = false, features = [
+    "df-polars",
+] }
+
+tokio = { workspace = true, features = ["full"] }
diff --git a/crates/kubegraph/simulator/src/main.rs b/crates/kubegraph/simulator/src/main.rs
new file mode 100644
index 00000000..e1d87ce2
--- /dev/null
+++ b/crates/kubegraph/simulator/src/main.rs
@@ -0,0 +1,6 @@
+use kubegraph_api::vm::NetworkVirtualMachineExt;
+
+#[tokio::main]
+async fn main() {
+    ::kubegraph_vm_local::NetworkVirtualMachine::main(|_| vec![]).await
+}
diff --git a/crates/kubegraph/visualizer/Cargo.toml b/crates/kubegraph/visualizer/Cargo.toml
new file mode 100644
index 00000000..1fecca37
--- /dev/null
+++ b/crates/kubegraph/visualizer/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+name = "kubegraph-visualizer"
+
+authors = { workspace = true }
+description = { workspace = true }
+documentation = { workspace = true }
+edition = { workspace = true }
+include = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+readme = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+version = { workspace = true }
+
+[lints]
+workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = ["full"]
+full = ["df-full"]
+
+# DataFrame
+df-full = ["df-polars"]
+df-polars = ["dep:polars"]
+
+[dependencies]
+kubegraph-api = { path = "../api" }
+
+anyhow = { workspace = true }
+eframe = { workspace = true }
+egui = { workspace = true }
+egui_graphs = { workspace = true }
+petgraph = { workspace = true }
+polars = { workspace = true, optional = true }
diff --git a/crates/kubegraph/visualizer/src/lib.rs b/crates/kubegraph/visualizer/src/lib.rs
new file mode 100644
index 00000000..b93cf3ff
--- /dev/null
+++ b/crates/kubegraph/visualizer/src/lib.rs
@@ -0,0 +1,14 @@
+pub fn add(left: u64, right: u64) -> u64 {
+    left + right
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+}
diff --git a/crates/kubegraph/visualizer/src/main.rs b/crates/kubegraph/visualizer/src/main.rs
new file mode 100644
index 00000000..637c4f7d
--- /dev/null
+++ b/crates/kubegraph/visualizer/src/main.rs
@@ -0,0 +1,64 @@
+use eframe::{run_native, App, CreationContext};
+use egui::Context;
+use egui_graphs::{
+    DefaultEdgeShape, DefaultNodeShape, Graph, GraphView, SettingsInteraction, SettingsStyle,
+};
+use petgraph::stable_graph::StableGraph;
+
+pub struct InteractiveApp {
+    g: Graph<(), ()>,
+}
+
+impl InteractiveApp {
+    fn new(_: &CreationContext<'_>) -> Self {
+        let g = generate_graph();
+        Self { g }
+    }
+}
+
+impl App for InteractiveApp {
+    fn update(&mut self, ctx: &Context, _: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            let interaction_settings = &SettingsInteraction::new()
+                .with_dragging_enabled(true)
+                .with_node_clicking_enabled(true)
+                .with_node_selection_enabled(true)
+                .with_node_selection_multi_enabled(true)
+                .with_edge_clicking_enabled(true)
+                .with_edge_selection_enabled(true)
+                .with_edge_selection_multi_enabled(true);
+            let style_settings = &SettingsStyle::new().with_labels_always(true);
+            ui.add(
+                &mut GraphView::<_, _, _, _, DefaultNodeShape, DefaultEdgeShape>::new(&mut self.g)
+                    .with_styles(style_settings)
+                    .with_interactions(interaction_settings),
+            );
+        });
+    }
+}
+
+fn generate_graph() -> Graph<(), ()> {
+    let mut g = StableGraph::new();
+
+    let a = g.add_node(());
+    let b = g.add_node(());
+    let c = g.add_node(());
+
+    g.add_edge(a, a, ());
+    g.add_edge(a, b, ());
+    g.add_edge(a, b, ());
+    g.add_edge(b, c, ());
+    g.add_edge(c, a, ());
+
+    Graph::from(&g)
+}
+
+fn main() {
+    let native_options = eframe::NativeOptions::default();
+    run_native(
+        "egui_graphs_interactive_demo",
+        native_options,
+        Box::new(|cc| Box::new(InteractiveApp::new(cc))),
+    )
+    .unwrap();
+}
diff --git a/crates/kubegraph/vm/lazy/Cargo.toml b/crates/kubegraph/vm/lazy/Cargo.toml
new file mode 100644
index 00000000..49524760
--- /dev/null
+++ b/crates/kubegraph/vm/lazy/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "kubegraph-vm-lazy"
+
+authors = { workspace = true }
+description = { workspace = true }
+documentation = { workspace = true }
+edition = { workspace = true }
+include = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+readme = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+version = { workspace = true }
+
+[lints]
+workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+kubegraph-api = { path = "../../api" }
+kubegraph-parser = { path = "../../parser" }
+
+anyhow = { workspace = true }
diff --git a/crates/kubegraph/vm/local/src/lazy.rs b/crates/kubegraph/vm/lazy/src/lib.rs
similarity index 99%
rename from crates/kubegraph/vm/local/src/lazy.rs
rename to crates/kubegraph/vm/lazy/src/lib.rs
index d11bc8bf..32ff9595 100644
--- a/crates/kubegraph/vm/local/src/lazy.rs
+++ b/crates/kubegraph/vm/lazy/src/lib.rs
@@ -53,7 +53,7 @@ mod impl_call {
     };
 
     impl super::LazyVirtualMachine {
-        pub(crate) fn call(
+        pub fn call(
             &self,
             problem: &VirtualProblem,
             function: &FunctionMetadata,
@@ -65,11 +65,7 @@ mod impl_call {
                 .and_then(|ctx| ctx.try_into_edges(&problem.spec.metadata.function(), function))
         }
 
-        pub(crate) fn call_filter(
-            &self,
-            problem: &VirtualProblem,
-            nodes: LazyFrame,
-        ) -> Result<LazySlice> {
+        pub fn call_filter(&self, problem: &VirtualProblem, nodes: LazyFrame) -> Result<LazySlice> {
             Context::try_new(problem, nodes)?
                 .call(&self.local_variables, None)
                 .and_then(|ctx| ctx.try_into_filter())
diff --git a/crates/kubegraph/vm/local/Cargo.toml b/crates/kubegraph/vm/local/Cargo.toml
index 3e49af49..ca44775c 100644
--- a/crates/kubegraph/vm/local/Cargo.toml
+++ b/crates/kubegraph/vm/local/Cargo.toml
@@ -85,6 +85,7 @@ solver-ortools = ["kubegraph-solver-ortools"]
 
 [dependencies]
 kubegraph-analyzer-llm = { path = "../../analyzer/llm", optional = true, default-features = false }
+kubegraph-annotator = { path = "../../annotator" }
 kubegraph-api = { path = "../../api" }
 kubegraph-connector-fake = { path = "../../connector/fake", optional = true, default-features = false }
 kubegraph-connector-local = { path = "../../connector/local", optional = true, default-features = false }
@@ -95,6 +96,7 @@ kubegraph-graph-memory = { path = "../../graph/memory", optional = true, default
 kubegraph-parser = { path = "../../parser" }
 kubegraph-runner-simulator = { path = "../../runner/simulator", optional = true, default-features = false }
 kubegraph-solver-ortools = { path = "../../solver/ortools", optional = true, default-features = false }
+kubegraph-vm-lazy = { path = "../lazy" }
 
 anyhow = { workspace = true }
 async-trait = { workspace = true }
diff --git a/crates/kubegraph/vm/local/src/function.rs b/crates/kubegraph/vm/local/src/function.rs
index 8aaa1239..62b8f1b4 100644
--- a/crates/kubegraph/vm/local/src/function.rs
+++ b/crates/kubegraph/vm/local/src/function.rs
@@ -1,14 +1,12 @@
 use anyhow::{anyhow, Result};
 use kubegraph_api::{
+    annotator::NetworkAnnotationSpec,
     frame::LazyFrame,
-    function::{
-        FunctionMetadata, NetworkFunctionCrd, NetworkFunctionMetadata, NetworkFunctionSpec,
-    },
+    function::{FunctionMetadata, NetworkFunctionCrd, NetworkFunctionSpec},
     graph::{GraphEdges, GraphScope},
     problem::VirtualProblem,
 };
-
-use crate::lazy::LazyVirtualMachine;
+use kubegraph_vm_lazy::LazyVirtualMachine;
 
 pub trait NetworkFunctionExt {
     fn infer_edges(
@@ -41,7 +39,7 @@ impl NetworkFunctionExt for NetworkFunctionSpec {
     }
 }
 
-impl NetworkFunctionExt for NetworkFunctionMetadata {
+impl NetworkFunctionExt for NetworkAnnotationSpec {
     fn infer_edges(
         &self,
         problem: &VirtualProblem,
@@ -52,7 +50,7 @@ impl NetworkFunctionExt for NetworkFunctionMetadata {
     }
 }
 
-impl<'a> NetworkFunctionExt for NetworkFunctionMetadata<&'a str> {
+impl<'a> NetworkFunctionExt for NetworkAnnotationSpec<&'a str> {
     fn infer_edges(
         &self,
         problem: &VirtualProblem,
@@ -63,7 +61,7 @@ impl<'a> NetworkFunctionExt for NetworkFunctionMetadata<&'a str> {
     }
 }
 
-impl NetworkFunctionExt for NetworkFunctionMetadata<LazyVirtualMachine> {
+impl NetworkFunctionExt for NetworkAnnotationSpec<LazyVirtualMachine> {
     fn infer_edges(
         &self,
         problem: &VirtualProblem,
@@ -83,17 +81,17 @@ impl NetworkFunctionExt for NetworkFunctionMetadata<LazyVirtualMachine> {
 
 fn parse_metadata<T>(
     function: &FunctionMetadata,
-    metadata: &NetworkFunctionMetadata<T>,
-) -> Result<NetworkFunctionMetadata<LazyVirtualMachine>>
+    metadata: &NetworkAnnotationSpec<T>,
+) -> Result<NetworkAnnotationSpec<LazyVirtualMachine>>
 where
     T: AsRef<str>,
 {
     let FunctionMetadata {
         scope: GraphScope { namespace, name },
     } = function;
-    let NetworkFunctionMetadata { filter, script } = metadata;
+    let NetworkAnnotationSpec { filter, script } = metadata;
 
-    Ok(NetworkFunctionMetadata {
+    Ok(NetworkAnnotationSpec {
         filter: filter
             .as_ref()
             .map(|input| LazyVirtualMachine::with_lazy_filter(input.as_ref()))
@@ -125,7 +123,7 @@ mod tests {
         .into();
 
         // Step 2. Add a function
-        let function_template = NetworkFunctionMetadata {
+        let function_template = NetworkAnnotationSpec {
             filter: None,
             script: r"
                 capacity = 50;
@@ -171,7 +169,7 @@ mod tests {
         .into();
 
         // Step 2. Add a function
-        let function_template = NetworkFunctionMetadata {
+        let function_template = NetworkAnnotationSpec {
             filter: Some("src != sink and src.supply >= 50 and sink.capacity >= 50"),
             script: r"
                 capacity = 50;
@@ -207,7 +205,7 @@ mod tests {
     fn expand_polars_dataframe(
         nodes: LazyFrame,
         function_name: &str,
-        function: NetworkFunctionMetadata<&'static str>,
+        function: NetworkAnnotationSpec<&'static str>,
     ) -> ::pl::frame::DataFrame {
         use kubegraph_api::{
             graph::{GraphFilter, GraphScope},
diff --git a/crates/kubegraph/vm/local/src/lib.rs b/crates/kubegraph/vm/local/src/lib.rs
index 6c4e7b93..08a60dcf 100644
--- a/crates/kubegraph/vm/local/src/lib.rs
+++ b/crates/kubegraph/vm/local/src/lib.rs
@@ -4,7 +4,6 @@ extern crate polars as pl;
 mod analyzer;
 mod function;
 mod graph;
-mod lazy;
 mod reloader;
 mod resource;
 mod runner;
@@ -38,32 +37,6 @@ pub struct NetworkVirtualMachine {
     vm_runner: Arc<Mutex<Option<NetworkVirtualMachineRunner>>>,
 }
 
-impl NetworkVirtualMachine {
-    pub async fn try_default() -> Result<Self> {
-        // Step 1. Initialize components
-        let vm = Self {
-            analyzer: self::analyzer::NetworkAnalyzer::try_default().await?,
-            graph_db: self::graph::NetworkGraphDB::try_default().await?,
-            resource_db: self::resource::NetworkResourceDB::default(),
-            resource_worker: Arc::new(Mutex::new(None)),
-            runner: self::runner::NetworkRunner::try_default().await?,
-            solver: self::solver::NetworkSolver::try_default().await?,
-            vm_runner: Arc::new(Mutex::new(None)),
-        };
-
-        // Step 2. Spawn workers
-        vm.resource_worker
-            .lock()
-            .await
-            .replace(self::resource::NetworkResourceWorker::try_spawn(&vm).await?);
-        vm.vm_runner
-            .lock()
-            .await
-            .replace(NetworkVirtualMachineRunner::spawn(vm.clone()));
-        Ok(vm)
-    }
-}
-
 #[async_trait]
 impl ::kubegraph_api::vm::NetworkVirtualMachine for NetworkVirtualMachine {
     type Analyzer = self::analyzer::NetworkAnalyzer;
@@ -97,6 +70,31 @@ impl ::kubegraph_api::vm::NetworkVirtualMachine for NetworkVirtualMachine {
         Some(Duration::from_secs(5))
     }
 
+    #[instrument(level = Level::INFO)]
+    async fn try_default() -> Result<Self> {
+        // Step 1. Initialize components
+        let vm = Self {
+            analyzer: self::analyzer::NetworkAnalyzer::try_default().await?,
+            graph_db: self::graph::NetworkGraphDB::try_default().await?,
+            resource_db: self::resource::NetworkResourceDB::default(),
+            resource_worker: Arc::new(Mutex::new(None)),
+            runner: self::runner::NetworkRunner::try_default().await?,
+            solver: self::solver::NetworkSolver::try_default().await?,
+            vm_runner: Arc::new(Mutex::new(None)),
+        };
+
+        // Step 2. Spawn workers
+        vm.resource_worker
+            .lock()
+            .await
+            .replace(self::resource::NetworkResourceWorker::try_spawn(&vm).await?);
+        vm.vm_runner
+            .lock()
+            .await
+            .replace(NetworkVirtualMachineRunner::spawn(vm.clone()));
+        Ok(vm)
+    }
+
     #[instrument(level = Level::INFO, skip(self, problem, nodes))]
     async fn infer_edges(
         &self,