diff --git a/Cargo.lock b/Cargo.lock
index 3b321d5..0a4d64e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -781,7 +781,9 @@ dependencies = [
  "futures-util",
  "golem-client",
  "golem-examples",
+ "h2",
  "http 1.0.0",
+ "hyper",
  "indoc",
  "itertools",
  "libtest-mimic",
@@ -803,6 +805,7 @@ dependencies = [
  "tokio-tungstenite",
  "tonic",
  "tonic-health",
+ "tower",
  "tracing",
  "tracing-subscriber",
  "tungstenite",
@@ -812,9 +815,9 @@ dependencies = [
 
 [[package]]
 name = "golem-client"
-version = "0.0.60"
+version = "0.0.62"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53724dee78bac0a83d83e0eac7aca899b011950ba9fc76bcb109a845ff792b89"
+checksum = "a4065eef9f11a5de373bbccda58c585123a745242a628e3cfba122094079cc34"
 dependencies = [
  "async-trait",
  "bytes",
@@ -2403,6 +2406,7 @@ version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
+ "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
diff --git a/Cargo.toml b/Cargo.toml
index 985dea3..2482016 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,7 +23,7 @@ clap = { version = "4.4.12", features = ["derive"] }
 clap-verbosity-flag = "2.1.1"
 derive_more = "0.99.17"
 futures-util = "0.3.30"
-golem-client = "0.0.60"
+golem-client = "0.0.62"
 golem-examples = "0.1.11"
 http = "1.0.0"
 indoc = "2.0.4"
@@ -43,6 +43,10 @@ url = "2.5.0"
 uuid = "1.6.1"
 dirs = "5.0.1"
 tracing-subscriber = "0.3.18"
+h2 = "0.3.24"
+hyper = "0.14.28"
+tower = "0.4.13"
+testcontainers-modules = { version = "0.3.2", features = ["postgres", "redis"] }
 
 [dev-dependencies]
 env_logger = "0.11.1"
diff --git a/src/clients/template.rs b/src/clients/template.rs
index 109ed81..98bc5ef 100644
--- a/src/clients/template.rs
+++ b/src/clients/template.rs
@@ -17,7 +17,8 @@ use std::io::Read;
 use async_trait::async_trait;
 use golem_client::model::{
     Export, ExportFunction, ExportInstance, FunctionParameter, FunctionResult, NameOptionTypePair,
-    NameTypePair, Template, Type, TypeEnum, TypeFlags, TypeRecord, TypeTuple, TypeVariant,
+    NameTypePair, ResourceMode, Template, Type, TypeEnum, TypeFlags, TypeRecord, TypeTuple,
+    TypeVariant,
 };
 use serde::{Deserialize, Serialize};
 use tokio::fs::File;
@@ -151,6 +152,10 @@ fn render_type(typ: &Type) -> String {
         Type::U8 { .. } => "u8".to_string(),
         Type::S8 { .. } => "s8".to_string(),
         Type::Bool { .. } => "bool".to_string(),
+        Type::Handle(handle) => match handle.mode {
+            ResourceMode::Borrowed => format!("&handle<{}>", handle.resource_id),
+            ResourceMode::Owned => format!("handle<{}>", handle.resource_id),
+        },
     }
 }
 
@@ -187,7 +192,7 @@ impl<C: golem_client::api::TemplateClient + Sync + Send> TemplateClient for Temp
 
         let name = name.map(|n| n.0);
 
-        let templates: Vec<Template> = self.client.get(name.as_deref()).await?;
+        let templates: Vec<Template> = self.client.get_all_templates(name.as_deref()).await?;
         let views = templates.iter().map(|c| c.into()).collect();
         Ok(views)
     }
@@ -205,7 +210,7 @@ impl<C: golem_client::api::TemplateClient + Sync + Send> TemplateClient for Temp
                     .await
                     .map_err(|e| GolemError(format!("Can't open template file: {e}")))?;
 
-                self.client.post(&name.0, file).await?
+                self.client.upload_template(&name.0, file).await?
             }
             PathBufOrStdin::Stdin => {
                 let mut bytes = Vec::new();
@@ -214,7 +219,7 @@ impl<C: golem_client::api::TemplateClient + Sync + Send> TemplateClient for Temp
                     .read_to_end(&mut bytes) // TODO: steaming request from stdin
                     .map_err(|e| GolemError(format!("Failed to read stdin: {e:?}")))?;
 
-                self.client.post(&name.0, bytes).await?
+                self.client.upload_template(&name.0, bytes).await?
             }
         };
 
@@ -234,7 +239,7 @@ impl<C: golem_client::api::TemplateClient + Sync + Send> TemplateClient for Temp
                     .await
                     .map_err(|e| GolemError(format!("Can't open template file: {e}")))?;
 
-                self.client.template_id_upload_put(&id.0, file).await?
+                self.client.update_template(&id.0, file).await?
             }
             PathBufOrStdin::Stdin => {
                 let mut bytes = Vec::new();
@@ -243,7 +248,7 @@ impl<C: golem_client::api::TemplateClient + Sync + Send> TemplateClient for Temp
                     .read_to_end(&mut bytes) // TODO: steaming request from stdin
                     .map_err(|e| GolemError(format!("Failed to read stdin: {e:?}")))?;
 
-                self.client.template_id_upload_put(&id.0, bytes).await?
+                self.client.update_template(&id.0, bytes).await?
             }
         };
 
diff --git a/src/clients/worker.rs b/src/clients/worker.rs
index 3f5ff0f..4e4b5ba 100644
--- a/src/clients/worker.rs
+++ b/src/clients/worker.rs
@@ -104,7 +104,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         Ok(self
             .client
-            .template_id_workers_post(
+            .launch_new_worker(
                 &template_id.0,
                 &WorkerCreationRequest {
                     name: name.0,
@@ -124,7 +124,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         let key = self
             .client
-            .template_id_workers_worker_name_key_post(&template_id.0, &name.0)
+            .get_invocation_key(&template_id.0, &name.0)
             .await?;
 
         Ok(key_api_to_cli(key))
@@ -152,7 +152,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         Ok(self
             .client
-            .template_id_workers_worker_name_invoke_and_await_post(
+            .invoke_and_await_function(
                 &template_id.0,
                 &name.0,
                 &invocation_key.0,
@@ -174,12 +174,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         let _ = self
             .client
-            .template_id_workers_worker_name_invoke_post(
-                &template_id.0,
-                &name.0,
-                &function,
-                &parameters,
-            )
+            .invoke_function(&template_id.0, &name.0, &function, &parameters)
             .await?;
         Ok(())
     }
@@ -193,7 +188,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         let _ = self
             .client
-            .template_id_workers_worker_name_interrupt_post(&template_id.0, &name.0, Some(false))
+            .interrupt_worker(&template_id.0, &name.0, Some(false))
             .await?;
         Ok(())
     }
@@ -207,7 +202,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         let _ = self
             .client
-            .template_id_workers_worker_name_interrupt_post(&template_id.0, &name.0, Some(true))
+            .interrupt_worker(&template_id.0, &name.0, Some(true))
             .await?;
         Ok(())
     }
@@ -215,10 +210,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
     async fn delete(&self, name: WorkerName, template_id: RawTemplateId) -> Result<(), GolemError> {
         info!("Deleting worker {}/{}", template_id.0, name.0);
 
-        let _ = self
-            .client
-            .template_id_workers_worker_name_delete(&template_id.0, &name.0)
-            .await?;
+        let _ = self.client.delete_worker(&template_id.0, &name.0).await?;
         Ok(())
     }
 
@@ -231,7 +223,7 @@ impl<C: golem_client::api::WorkerClient + Sync + Send> WorkerClient for WorkerCl
 
         Ok(self
             .client
-            .template_id_workers_worker_name_get(&template_id.0, &name.0)
+            .get_worker_metadata(&template_id.0, &name.0)
             .await?)
     }
 
diff --git a/src/main.rs b/src/main.rs
index 8f6f106..16c890b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -78,6 +78,10 @@ struct GolemCommand {
 
     #[arg(short = 'u', long)]
     /// Golem base url. Default: GOLEM_BASE_URL environment variable or http://localhost:9881.
+    ///
+    /// You can also specify different URLs for different services
+    /// via GOLEM_TEMPLATE_BASE_URL and GOLEM_WORKER_BASE_URL
+    /// environment variables.
     golem_url: Option<String>,
 
     #[command(subcommand)]
@@ -117,7 +121,14 @@ async fn async_main(cmd: GolemCommand) -> Result<(), Box<dyn std::error::Error>>
         .golem_url
         .or_else(|| std::env::var("GOLEM_BASE_URL").ok())
         .unwrap_or("http://localhost:9881".to_string());
-    let url = Url::parse(&url_str).unwrap();
+    let template_url_str = std::env::var("GOLEM_TEMPLATE_BASE_URL")
+        .ok()
+        .unwrap_or(url_str.to_string());
+    let worker_url_str = std::env::var("GOLEM_WORKER_BASE_URL")
+        .ok()
+        .unwrap_or(url_str);
+    let template_url = Url::parse(&template_url_str).unwrap();
+    let worker_url = Url::parse(&worker_url_str).unwrap();
     let allow_insecure_str = std::env::var("GOLEM_ALLOW_INSECURE").unwrap_or("false".to_string());
     let allow_insecure = allow_insecure_str != "false";
 
@@ -127,14 +138,19 @@ async fn async_main(cmd: GolemCommand) -> Result<(), Box<dyn std::error::Error>>
     }
     let client = builder.connection_verbose(true).build()?;
 
-    let context = Context {
-        base_url: url.clone(),
+    let template_context = Context {
+        base_url: template_url.clone(),
+        client: client.clone(),
+    };
+
+    let worker_context = Context {
+        base_url: worker_url.clone(),
         client: client.clone(),
     };
 
     let template_client = TemplateClientLive {
         client: golem_client::api::TemplateClientLive {
-            context: context.clone(),
+            context: template_context,
         },
     };
     let template_srv = TemplateHandlerLive {
@@ -142,9 +158,9 @@ async fn async_main(cmd: GolemCommand) -> Result<(), Box<dyn std::error::Error>>
     };
     let worker_client = WorkerClientLive {
         client: golem_client::api::WorkerClientLive {
-            context: context.clone(),
+            context: worker_context.clone(),
         },
-        context: context.clone(),
+        context: worker_context.clone(),
         allow_insecure,
     };
     let worker_srv = WorkerHandlerLive {
diff --git a/test-templates/auction.wasm b/test-templates/auction.wasm
index fec0f38..ed3ee51 100755
Binary files a/test-templates/auction.wasm and b/test-templates/auction.wasm differ
diff --git a/test-templates/auction_registry_composed.wasm b/test-templates/auction_registry_composed.wasm
index b1d2604..58b1895 100644
Binary files a/test-templates/auction_registry_composed.wasm and b/test-templates/auction_registry_composed.wasm differ
diff --git a/test-templates/environment-service.wasm b/test-templates/environment-service.wasm
index 83bc130..e3a0f6e 100755
Binary files a/test-templates/environment-service.wasm and b/test-templates/environment-service.wasm differ
diff --git a/test-templates/interruption.wasm b/test-templates/interruption.wasm
index b7d3b54..32d2794 100755
Binary files a/test-templates/interruption.wasm and b/test-templates/interruption.wasm differ
diff --git a/test-templates/write-stdout.wasm b/test-templates/write-stdout.wasm
index d4f5482..1430555 100644
Binary files a/test-templates/write-stdout.wasm and b/test-templates/write-stdout.wasm differ
diff --git a/tests/cli.rs b/tests/cli.rs
index 3238e7d..864cdee 100644
--- a/tests/cli.rs
+++ b/tests/cli.rs
@@ -1,4 +1,4 @@
-use crate::context::golem_service::GolemServiceInfo;
+use crate::context::ContextInfo;
 use libtest_mimic::Failed;
 use serde::de::DeserializeOwned;
 use serde_json::Value;
@@ -36,7 +36,8 @@ pub trait Cli {
 #[derive(Debug, Clone)]
 pub struct CliLive {
     pub config: CliConfig,
-    golem_port: u16,
+    golem_template_port: u16,
+    golem_worker_port: u16,
     golem_cli_path: PathBuf,
 }
 
@@ -44,7 +45,8 @@ impl CliLive {
     pub fn with_short_args(&self) -> Self {
         CliLive {
             config: CliConfig { short_args: true },
-            golem_port: self.golem_port,
+            golem_template_port: self.golem_template_port,
+            golem_worker_port: self.golem_worker_port,
             golem_cli_path: self.golem_cli_path.clone(),
         }
     }
@@ -52,18 +54,27 @@ impl CliLive {
     pub fn with_long_args(&self) -> Self {
         CliLive {
             config: CliConfig { short_args: false },
-            golem_port: self.golem_port,
+            golem_template_port: self.golem_template_port,
+            golem_worker_port: self.golem_worker_port,
             golem_cli_path: self.golem_cli_path.clone(),
         }
     }
 
-    pub fn make(golem: &GolemServiceInfo) -> Result<CliLive, Failed> {
+    // TODO; Use NginxInfo
+    pub fn make(context: &ContextInfo) -> Result<CliLive, Failed> {
         let golem_cli_path = PathBuf::from("./target/debug/golem-cli");
 
+        println!(
+            "CLI with template port {} and worker port {}",
+            context.golem_template_service.local_http_port,
+            context.golem_worker_service.local_http_port
+        );
+
         if golem_cli_path.exists() {
             Ok(CliLive {
                 config: CliConfig { short_args: false },
-                golem_port: golem.local_http_port,
+                golem_template_port: context.golem_template_service.local_http_port,
+                golem_worker_port: context.golem_worker_service.local_http_port,
                 golem_cli_path,
             })
         } else {
@@ -75,8 +86,12 @@ impl CliLive {
         }
     }
 
-    fn base_url(&self) -> String {
-        format!("http://localhost:{}", self.golem_port)
+    fn template_base_url(&self) -> String {
+        format!("http://localhost:{}", self.golem_template_port)
+    }
+
+    fn worker_base_url(&self) -> String {
+        format!("http://localhost:{}", self.golem_worker_port)
     }
 
     fn run_inner<S: AsRef<OsStr> + Debug>(&self, args: &[S]) -> Result<String, Failed> {
@@ -86,9 +101,11 @@ impl CliLive {
         );
 
         let output = Command::new(&self.golem_cli_path)
-            .env("GOLEM_BASE_URL", self.base_url())
+            .env("GOLEM_TEMPLATE_BASE_URL", self.template_base_url())
+            .env("GOLEM_WORKER_BASE_URL", self.worker_base_url())
             .arg(self.config.arg('F', "format"))
             .arg("json")
+            .arg("-v")
             .args(args)
             .output()?;
 
@@ -138,7 +155,8 @@ impl Cli for CliLive {
         );
 
         let mut child = Command::new(&self.golem_cli_path)
-            .env("GOLEM_BASE_URL", self.base_url())
+            .env("GOLEM_TEMPLATE_BASE_URL", self.template_base_url())
+            .env("GOLEM_WORKER_BASE_URL", self.worker_base_url())
             .arg(self.config.arg('F', "format"))
             .arg("json")
             .args(args)
diff --git a/tests/context.rs b/tests/context.rs
index a0bb76c..a8d7875 100644
--- a/tests/context.rs
+++ b/tests/context.rs
@@ -1,11 +1,13 @@
 pub mod db;
-pub mod golem_service;
+pub mod golem_template_service;
+pub mod golem_worker_service;
 pub mod redis;
 pub mod shard_manager;
 pub mod worker;
 
 use crate::context::db::{Db, DbInfo};
-use crate::context::golem_service::{GolemService, GolemServiceInfo};
+use crate::context::golem_template_service::{GolemTemplateService, GolemTemplateServiceInfo};
+use crate::context::golem_worker_service::{GolemWorkerService, GolemWorkerServiceInfo};
 use crate::context::redis::{Redis, RedisInfo};
 use crate::context::shard_manager::{ShardManager, ShardManagerInfo};
 use crate::context::worker::{WorkerExecutors, WorkerExecutorsInfo};
@@ -14,7 +16,7 @@ use std::path::PathBuf;
 use testcontainers::clients;
 
 const NETWORK: &str = "golem_test_network";
-const TAG: &str = "v0.0.60";
+const TAG: &str = "v0.0.62";
 
 #[derive(Debug, Clone)]
 pub struct EnvConfig {
@@ -67,7 +69,8 @@ pub struct Context<'docker_client> {
     db: Db<'docker_client>,
     redis: Redis<'docker_client>,
     shard_manager: ShardManager<'docker_client>,
-    golem_service: GolemService<'docker_client>,
+    golem_template_service: GolemTemplateService<'docker_client>,
+    golem_worker_service: GolemWorkerService<'docker_client>,
     worker_executors: WorkerExecutors<'docker_client>,
 }
 
@@ -80,13 +83,24 @@ impl Context<'_> {
         let db = Db::start(docker, &env_config)?;
         let redis = Redis::make(docker, &env_config)?;
         let shard_manager = ShardManager::start(docker, &env_config, &redis.info())?;
-        let golem_service =
-            GolemService::start(docker, &env_config, &shard_manager.info(), &db.info())?;
+
+        let golem_template_service = GolemTemplateService::start(docker, &env_config, &db.info())?;
+
+        let golem_worker_service = GolemWorkerService::start(
+            docker,
+            &env_config,
+            &shard_manager.info(),
+            &db.info(),
+            &redis.info(),
+            &golem_template_service.info(),
+        )?;
+
         let worker_executors = WorkerExecutors::start(
             docker,
             &env_config,
             &redis.info(),
-            &golem_service.info(),
+            &golem_worker_service.info(),
+            &golem_template_service.info(),
             &shard_manager.info(),
         )?;
 
@@ -95,7 +109,8 @@ impl Context<'_> {
             db,
             redis,
             shard_manager,
-            golem_service,
+            golem_template_service,
+            golem_worker_service,
             worker_executors,
         })
     }
@@ -106,7 +121,8 @@ impl Context<'_> {
             db: self.db.info(),
             redis: self.redis.info(),
             shard_manager: self.shard_manager.info(),
-            golem_service: self.golem_service.info(),
+            golem_template_service: self.golem_template_service.info(),
+            golem_worker_service: self.golem_worker_service.info(),
             worker_executors: self.worker_executors.info(),
         }
     }
@@ -123,6 +139,7 @@ pub struct ContextInfo {
     pub db: DbInfo,
     pub redis: RedisInfo,
     pub shard_manager: ShardManagerInfo,
-    pub golem_service: GolemServiceInfo,
+    pub golem_template_service: GolemTemplateServiceInfo,
+    pub golem_worker_service: GolemWorkerServiceInfo,
     pub worker_executors: WorkerExecutorsInfo,
 }
diff --git a/tests/context/db.rs b/tests/context/db.rs
index 7661023..84cba19 100644
--- a/tests/context/db.rs
+++ b/tests/context/db.rs
@@ -142,6 +142,10 @@ impl DbInfo {
                         .expect("Invalid Sqlite database path")
                         .to_string(),
                 ),
+                (
+                    "GOLEM__DB__CONFIG__MAX_CONNECTIONS".to_string(),
+                    "10".to_string(),
+                ),
             ]
             .into(),
         }
diff --git a/tests/context/golem_service.rs b/tests/context/golem_template_service.rs
similarity index 60%
rename from tests/context/golem_service.rs
rename to tests/context/golem_template_service.rs
index 45a9e29..9a7d301 100644
--- a/tests/context/golem_service.rs
+++ b/tests/context/golem_template_service.rs
@@ -1,5 +1,5 @@
 use crate::context::db::DbInfo;
-use crate::context::{EnvConfig, ShardManagerInfo, NETWORK, TAG};
+use crate::context::{EnvConfig, NETWORK, TAG};
 use golem_cli::clients::template::{TemplateClient, TemplateClientLive};
 use libtest_mimic::Failed;
 use std::collections::HashMap;
@@ -12,19 +12,19 @@ use testcontainers::{clients, Container, Image, RunnableImage};
 use url::Url;
 
 #[derive(Debug)]
-struct GolemServiceImage {
+struct GolemTemplateServiceImage {
     grpc_port: u16,
     http_port: u16,
     env_vars: HashMap<String, String>,
 }
 
-impl GolemServiceImage {
+impl GolemTemplateServiceImage {
     pub fn new(
         grpc_port: u16,
         http_port: u16,
         env_vars: HashMap<String, String>,
-    ) -> GolemServiceImage {
-        GolemServiceImage {
+    ) -> GolemTemplateServiceImage {
+        GolemTemplateServiceImage {
             grpc_port,
             http_port,
             env_vars,
@@ -32,11 +32,11 @@ impl GolemServiceImage {
     }
 }
 
-impl Image for GolemServiceImage {
+impl Image for GolemTemplateServiceImage {
     type Args = ();
 
     fn name(&self) -> String {
-        "golemservices/golem-service".to_string()
+        "golemservices/golem-template-service".to_string()
     }
 
     fn tag(&self) -> String {
@@ -56,20 +56,20 @@ impl Image for GolemServiceImage {
     }
 }
 
-pub struct GolemService<'docker_client> {
+pub struct GolemTemplateService<'docker_client> {
     host: String,
     local_http_port: u16,
     http_port: u16,
     grpc_port: u16,
-    inner: GolemServiceInner<'docker_client>,
+    inner: GolemTemplateServiceInner<'docker_client>,
 }
 
-enum GolemServiceInner<'docker_client> {
+enum GolemTemplateServiceInner<'docker_client> {
     Process(Child),
-    Docker(Container<'docker_client, GolemServiceImage>),
+    Docker(Container<'docker_client, GolemTemplateServiceImage>),
 }
 
-impl<'docker_client> GolemService<'docker_client> {
+impl<'docker_client> GolemTemplateService<'docker_client> {
     fn wait_for_health_check(http_port: u16) {
         let client = TemplateClientLive {
             client: golem_client::api::TemplateClientLive {
@@ -103,41 +103,41 @@ impl<'docker_client> GolemService<'docker_client> {
     pub fn start(
         docker: &'docker_client clients::Cli,
         env_config: &EnvConfig,
-        shard_manager: &ShardManagerInfo,
         db: &DbInfo,
-    ) -> Result<GolemService<'docker_client>, Failed> {
+    ) -> Result<GolemTemplateService<'docker_client>, Failed> {
         if env_config.local_golem {
-            GolemService::start_process(env_config, shard_manager, db)
+            GolemTemplateService::start_process(env_config, db)
         } else {
-            GolemService::start_docker(docker, env_config, shard_manager, db)
+            GolemTemplateService::start_docker(docker, env_config, db)
         }
     }
 
     fn start_docker(
         docker: &'docker_client clients::Cli,
         env_config: &EnvConfig,
-        shard_manager: &ShardManagerInfo,
         db: &DbInfo,
-    ) -> Result<GolemService<'docker_client>, Failed> {
-        println!("Starting Golem Service docker with shard manager: {shard_manager:?}");
+    ) -> Result<GolemTemplateService<'docker_client>, Failed> {
+        println!("Starting Golem Template Service docker");
 
         let http_port = 8081;
         let grpc_port = 9091;
 
-        let env_vars = GolemService::env_vars(grpc_port, http_port, env_config, shard_manager, db);
-        let name = "golem_service";
+        let env_vars = GolemTemplateService::env_vars(grpc_port, http_port, env_config, db);
+        let name = "golem_template_service";
 
-        let image = RunnableImage::from(GolemServiceImage::new(grpc_port, http_port, env_vars))
-            .with_container_name(name)
-            .with_network(NETWORK);
+        let image = RunnableImage::from(GolemTemplateServiceImage::new(
+            grpc_port, http_port, env_vars,
+        ))
+        .with_container_name(name)
+        .with_network(NETWORK);
         let node = docker.run(image);
 
-        Ok(GolemService {
+        Ok(GolemTemplateService {
             host: name.to_string(),
             local_http_port: node.get_host_port_ipv4(http_port),
             http_port,
             grpc_port,
-            inner: GolemServiceInner::Docker(node),
+            inner: GolemTemplateServiceInner::Docker(node),
         })
     }
 
@@ -145,7 +145,6 @@ impl<'docker_client> GolemService<'docker_client> {
         grpc_port: u16,
         http_port: u16,
         env_config: &EnvConfig,
-        shard_manager: &ShardManagerInfo,
         db: &DbInfo,
     ) -> HashMap<String, String> {
         let log_level = if env_config.verbose { "debug" } else { "info" };
@@ -156,18 +155,9 @@ impl<'docker_client> GolemService<'docker_client> {
             ("RUST_BACKTRACE"                             , "1"),
             ("GOLEM__WORKSPACE"                           , "ittest"),
             ("ENVIRONMENT"                         , "local"),
-            ("GOLEM__ENVIRONMENT"                         , "ittest"),
-            ("GOLEM__ROUTING_TABLE__HOST"                 , &shard_manager.host),
-            ("GOLEM__ROUTING_TABLE__PORT"                 , &shard_manager.grpc_port.to_string()),
-            ("GOLEM__ACCOUNTS__ROOT__TOKEN"               , "0868571c-b6cc-4817-bae8-048cbcef91a0"),
-            ("GOLEM__ACCOUNTS__ROOT__ID"                  , "test-account"),
-            ("GOLEM__ACCOUNTS__MARKETING__TOKEN"          , "7868571c-b6cc-4817-bae8-048cbcef91a0"),
-            ("GOLEM__ED_DSA__PRIVATE_KEY"                 , "MC4CAQAwBQYDK2VwBCIEIDSMbnKaWIjXt+LQaA8pVudt6KBwVBaBecRPWZRvmwUW"),
-            ("GOLEM__ED_DSA__PUBLIC_KEY"                  , "MCowBQYDK2VwAyEAVLrTJ1Q5Cl438J8/bQ1Ib+zfvb9VrOQjwzxKgVRoY7w="),
-            ("GOLEM__TEMPLATES__STORE__CONFIG__ROOT_PATH" , "/tmp/ittest-local-object-store/golem"),
-            ("GOLEM__TEMPLATES__STORE__TYPE", "Local"),
-            ("GOLEM__TEMPLATES__STORE__CONFIG__OBJECT_PREFIX", ""),
-            ("GOLEM__TEMPLATES__STORE__CONFIG__ROOT_PATH", "../target/template_store"),
+            ("GOLEM__TEMPLATE_STORE__TYPE", "Local"),
+            ("GOLEM__TEMPLATE_STORE__CONFIG__OBJECT_PREFIX", ""),
+            ("GOLEM__TEMPLATE_STORE__CONFIG__ROOT_PATH", "/tmp/ittest-local-object-store/golem"),
             ("GOLEM__GRPC_PORT", &grpc_port.to_string()),
             ("GOLEM__HTTP_PORT", &http_port.to_string()),
 
@@ -187,17 +177,16 @@ impl<'docker_client> GolemService<'docker_client> {
 
     fn start_process(
         env_config: &EnvConfig,
-        shard_manager: &ShardManagerInfo,
         db: &DbInfo,
-    ) -> Result<GolemService<'docker_client>, Failed> {
-        println!("Starting Golem Service");
+    ) -> Result<GolemTemplateService<'docker_client>, Failed> {
+        println!("Starting Golem Template Service");
 
-        let service_dir = Path::new("../golem-service/");
-        let service_run = Path::new("../target/debug/golem-service");
+        let service_dir = Path::new("../golem-template-service/");
+        let service_run = Path::new("../target/debug/golem-template-service");
 
         if !service_run.exists() {
             return Err(format!(
-                "Expected to have precompiled Cloud Service at {}",
+                "Expected to have precompiled Golem Template Service at {}",
                 service_run.to_str().unwrap_or("")
             )
             .into());
@@ -210,12 +199,8 @@ impl<'docker_client> GolemService<'docker_client> {
 
         let mut child = Command::new(service_run)
             .current_dir(service_dir)
-            .envs(GolemService::env_vars(
-                grpc_port,
-                http_port,
-                env_config,
-                shard_manager,
-                db,
+            .envs(GolemTemplateService::env_vars(
+                grpc_port, http_port, env_config, db,
             ))
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
@@ -227,14 +212,14 @@ impl<'docker_client> GolemService<'docker_client> {
         let stdout = child
             .stdout
             .take()
-            .ok_or::<Failed>("Can't get golem service stdout".into())?;
+            .ok_or::<Failed>("Can't get golem template service stdout".into())?;
 
         // TODO: use tokio
         std::thread::spawn(move || {
             let reader = BufReader::new(stdout);
             for line in reader.lines() {
                 if !quiet {
-                    println!("[golemsvc]   {}", line.unwrap())
+                    println!("[golemtemplate]   {}", line.unwrap())
                 }
             }
         });
@@ -242,30 +227,30 @@ impl<'docker_client> GolemService<'docker_client> {
         let stderr = child
             .stderr
             .take()
-            .ok_or::<Failed>("Can't get golem service stderr".into())?;
+            .ok_or::<Failed>("Can't get golem template service stderr".into())?;
 
         std::thread::spawn(move || {
             let reader = BufReader::new(stderr);
             for line in reader.lines() {
                 if !quiet {
-                    eprintln!("[golemsvc]   {}", line.unwrap())
+                    eprintln!("[golemtemplate]   {}", line.unwrap())
                 }
             }
         });
 
-        GolemService::wait_for_health_check(http_port);
+        GolemTemplateService::wait_for_health_check(http_port);
 
-        Ok(GolemService {
+        Ok(GolemTemplateService {
             host: "localhost".to_string(),
             local_http_port: http_port,
             http_port,
             grpc_port,
-            inner: GolemServiceInner::Process(child),
+            inner: GolemTemplateServiceInner::Process(child),
         })
     }
 
-    pub fn info(&self) -> GolemServiceInfo {
-        GolemServiceInfo {
+    pub fn info(&self) -> GolemTemplateServiceInfo {
+        GolemTemplateServiceInfo {
             host: self.host.clone(),
             local_http_port: self.local_http_port,
             http_port: self.http_port,
@@ -274,25 +259,25 @@ impl<'docker_client> GolemService<'docker_client> {
     }
 }
 
-impl Drop for GolemService<'_> {
+impl Drop for GolemTemplateService<'_> {
     fn drop(&mut self) {
         match &mut self.inner {
-            GolemServiceInner::Process(child) => {
+            GolemTemplateServiceInner::Process(child) => {
                 // TODO: SIGTERM, maybe with nix crate.
                 match child.kill() {
-                    Ok(_) => println!("Killed Golem Service process"),
-                    Err(e) => eprintln!("Failed to kill Golem Service process: {e:? }"),
+                    Ok(_) => println!("Killed Golem Template Service process"),
+                    Err(e) => eprintln!("Failed to kill Golem Template Service process: {e:? }"),
                 }
             }
-            GolemServiceInner::Docker(_) => {}
+            GolemTemplateServiceInner::Docker(_) => {}
         }
 
-        println!("Stopped Golem Service")
+        println!("Stopped Golem Template Service")
     }
 }
 
 #[derive(Debug)]
-pub struct GolemServiceInfo {
+pub struct GolemTemplateServiceInfo {
     pub host: String,
     pub local_http_port: u16,
     pub http_port: u16,
diff --git a/tests/context/golem_worker_service.rs b/tests/context/golem_worker_service.rs
new file mode 100644
index 0000000..9328d07
--- /dev/null
+++ b/tests/context/golem_worker_service.rs
@@ -0,0 +1,303 @@
+use crate::context::db::DbInfo;
+use crate::context::golem_template_service::GolemTemplateServiceInfo;
+use crate::context::redis::RedisInfo;
+use crate::context::{EnvConfig, ShardManagerInfo, NETWORK, TAG};
+use libtest_mimic::Failed;
+use std::collections::HashMap;
+use std::io::{BufRead, BufReader};
+use std::path::Path;
+use std::process::{Child, Command, Stdio};
+use testcontainers::core::WaitFor;
+use testcontainers::{clients, Container, Image, RunnableImage};
+
+#[derive(Debug)]
+struct GolemWorkerServiceImage {
+    grpc_port: u16,
+    http_port: u16,
+    custom_request_port: u16,
+    env_vars: HashMap<String, String>,
+}
+
+impl GolemWorkerServiceImage {
+    pub fn new(
+        grpc_port: u16,
+        http_port: u16,
+        custom_request_port: u16,
+        env_vars: HashMap<String, String>,
+    ) -> GolemWorkerServiceImage {
+        GolemWorkerServiceImage {
+            grpc_port,
+            http_port,
+            custom_request_port,
+            env_vars,
+        }
+    }
+}
+
+impl Image for GolemWorkerServiceImage {
+    type Args = ();
+
+    fn name(&self) -> String {
+        "golemservices/golem-worker-service".to_string()
+    }
+
+    fn tag(&self) -> String {
+        TAG.to_owned()
+    }
+
+    fn ready_conditions(&self) -> Vec<WaitFor> {
+        vec![WaitFor::message_on_stdout("server started")]
+    }
+
+    fn env_vars(&self) -> Box<dyn Iterator<Item = (&String, &String)> + '_> {
+        Box::new(self.env_vars.iter())
+    }
+
+    fn expose_ports(&self) -> Vec<u16> {
+        vec![self.grpc_port, self.http_port, self.custom_request_port]
+    }
+}
+
+pub struct GolemWorkerService<'docker_client> {
+    host: String,
+    local_http_port: u16,
+    http_port: u16,
+    grpc_port: u16,
+    custom_request_port: u16,
+    inner: GolemWorkerServiceInner<'docker_client>,
+}
+
+enum GolemWorkerServiceInner<'docker_client> {
+    Process(Child),
+    Docker(Container<'docker_client, GolemWorkerServiceImage>),
+}
+
+impl<'docker_client> GolemWorkerService<'docker_client> {
+    pub fn start(
+        docker: &'docker_client clients::Cli,
+        env_config: &EnvConfig,
+        shard_manager: &ShardManagerInfo,
+        db: &DbInfo,
+        redis: &RedisInfo,
+        template: &GolemTemplateServiceInfo,
+    ) -> Result<GolemWorkerService<'docker_client>, Failed> {
+        if env_config.local_golem {
+            GolemWorkerService::start_process(env_config, shard_manager, db, redis, template)
+        } else {
+            GolemWorkerService::start_docker(docker, env_config, shard_manager, db, redis, template)
+        }
+    }
+
+    fn start_docker(
+        docker: &'docker_client clients::Cli,
+        env_config: &EnvConfig,
+        shard_manager: &ShardManagerInfo,
+        db: &DbInfo,
+        redis: &RedisInfo,
+        template: &GolemTemplateServiceInfo,
+    ) -> Result<GolemWorkerService<'docker_client>, Failed> {
+        println!("Starting Golem Worker Service docker with shard manager: {shard_manager:?}");
+
+        let http_port = 8082;
+        let grpc_port = 9092;
+        let custom_request_port = 9093;
+
+        let env_vars = GolemWorkerService::env_vars(
+            grpc_port,
+            http_port,
+            custom_request_port,
+            env_config,
+            shard_manager,
+            db,
+            redis,
+            template,
+        );
+        let name = "golem_worker_service";
+
+        let image = RunnableImage::from(GolemWorkerServiceImage::new(
+            grpc_port,
+            http_port,
+            custom_request_port,
+            env_vars,
+        ))
+        .with_container_name(name)
+        .with_network(NETWORK);
+        let node = docker.run(image);
+
+        Ok(GolemWorkerService {
+            host: name.to_string(),
+            local_http_port: node.get_host_port_ipv4(http_port),
+            http_port,
+            grpc_port,
+            custom_request_port,
+            inner: GolemWorkerServiceInner::Docker(node),
+        })
+    }
+
+    fn env_vars(
+        grpc_port: u16,
+        http_port: u16,
+        custom_request_port: u16,
+        env_config: &EnvConfig,
+        shard_manager: &ShardManagerInfo,
+        db: &DbInfo,
+        redis: &RedisInfo,
+        template: &GolemTemplateServiceInfo,
+    ) -> HashMap<String, String> {
+        let log_level = if env_config.verbose { "debug" } else { "info" };
+
+        let vars: &[(&str, &str)] = &[
+            ("RUST_LOG"                                   , &format!("{log_level},cranelift_codegen=warn,wasmtime_cranelift=warn,wasmtime_jit=warn,h2=warn,hyper=warn,tower=warn")),
+            ("WASMTIME_BACKTRACE_DETAILS"                             , "1"),
+            ("RUST_BACKTRACE"                             , "1"),
+            ("GOLEM__WORKSPACE"                           , "ittest"),
+            ("GOLEM__REDIS__HOST"                         , &redis.host),
+            ("GOLEM__REDIS__PORT"                        , &redis.port.to_string()),
+            ("GOLEM__REDIS__DATABASE"                     , "1"),
+            ("GOLEM__TEMPLATE_SERVICE__HOST"              , &template.host),
+            ("GOLEM__TEMPLATE_SERVICE__PORT"              , &template.grpc_port.to_string()),
+            ("GOLEM__TEMPLATE_SERVICE__ACCESS_TOKEN"      , "5C832D93-FF85-4A8F-9803-513950FDFDB1"),
+            ("ENVIRONMENT"                                , "local"),
+            ("GOLEM__ENVIRONMENT"                         , "ittest"),
+            ("GOLEM__ROUTING_TABLE__HOST"                 , &shard_manager.host),
+            ("GOLEM__ROUTING_TABLE__PORT"                 , &shard_manager.grpc_port.to_string()),
+            ("GOLEM__CUSTOM_REQUEST_PORT"                 , &custom_request_port.to_string()),
+            ("GOLEM__WORKER_GRPC_PORT", &grpc_port.to_string()),
+            ("GOLEM__PORT", &http_port.to_string()),
+
+        ];
+
+        let mut vars: HashMap<String, String> = vars
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect();
+
+        for (k, v) in db.env().into_iter() {
+            vars.insert(k, v);
+        }
+
+        vars
+    }
+
+    fn start_process(
+        env_config: &EnvConfig,
+        shard_manager: &ShardManagerInfo,
+        db: &DbInfo,
+        redis: &RedisInfo,
+        template: &GolemTemplateServiceInfo,
+    ) -> Result<GolemWorkerService<'docker_client>, Failed> {
+        println!("Starting Golem Worker Service");
+
+        let service_dir = Path::new("../golem-worker-service/");
+        let service_run = Path::new("../target/debug/golem-worker-service");
+
+        if !service_run.exists() {
+            return Err(format!(
+                "Expected to have precompiled Golem Worker Service at {}",
+                service_run.to_str().unwrap_or("")
+            )
+            .into());
+        }
+
+        println!("Starting {}", service_run.to_str().unwrap_or(""));
+
+        let http_port = 8082;
+        let grpc_port = 9092;
+        let custom_request_port = 9093;
+
+        let mut child = Command::new(service_run)
+            .current_dir(service_dir)
+            .envs(GolemWorkerService::env_vars(
+                grpc_port,
+                http_port,
+                custom_request_port,
+                env_config,
+                shard_manager,
+                db,
+                redis,
+                template,
+            ))
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+
+        let quiet = env_config.quiet;
+
+        let stdout = child
+            .stdout
+            .take()
+            .ok_or::<Failed>("Can't get golem worker service stdout".into())?;
+
+        // TODO: use tokio
+        std::thread::spawn(move || {
+            let reader = BufReader::new(stdout);
+            for line in reader.lines() {
+                if !quiet {
+                    println!("[golemworker]   {}", line.unwrap())
+                }
+            }
+        });
+
+        let stderr = child
+            .stderr
+            .take()
+            .ok_or::<Failed>("Can't get golem worker service stderr".into())?;
+
+        std::thread::spawn(move || {
+            let reader = BufReader::new(stderr);
+            for line in reader.lines() {
+                if !quiet {
+                    eprintln!("[golemworker]   {}", line.unwrap())
+                }
+            }
+        });
+
+        // TODO; Wait for healthcheck
+
+        Ok(GolemWorkerService {
+            host: "localhost".to_string(),
+            local_http_port: http_port,
+            http_port,
+            grpc_port,
+            custom_request_port,
+            inner: GolemWorkerServiceInner::Process(child),
+        })
+    }
+
+    pub fn info(&self) -> GolemWorkerServiceInfo {
+        GolemWorkerServiceInfo {
+            host: self.host.clone(),
+            local_http_port: self.local_http_port,
+            http_port: self.http_port,
+            grpc_port: self.grpc_port,
+            custom_request_port: self.custom_request_port,
+        }
+    }
+}
+
+impl Drop for GolemWorkerService<'_> {
+    fn drop(&mut self) {
+        match &mut self.inner {
+            GolemWorkerServiceInner::Process(child) => {
+                // TODO: SIGTERM, maybe with nix crate.
+                match child.kill() {
+                    Ok(_) => println!("Killed Golem Worker Service process"),
+                    Err(e) => eprintln!("Failed to kill Golem Worker Service process: {e:? }"),
+                }
+            }
+            GolemWorkerServiceInner::Docker(_) => {}
+        }
+
+        println!("Stopped Golem Worker Service")
+    }
+}
+
+#[derive(Debug)]
+pub struct GolemWorkerServiceInfo {
+    pub host: String,
+    pub local_http_port: u16,
+    pub http_port: u16,
+    pub grpc_port: u16,
+    pub custom_request_port: u16,
+}
diff --git a/tests/context/worker.rs b/tests/context/worker.rs
index 9eed7bb..ede19a5 100644
--- a/tests/context/worker.rs
+++ b/tests/context/worker.rs
@@ -1,5 +1,7 @@
+use crate::context::golem_template_service::GolemTemplateServiceInfo;
+use crate::context::golem_worker_service::GolemWorkerServiceInfo;
 use crate::context::redis::RedisInfo;
-use crate::context::{EnvConfig, GolemServiceInfo, ShardManagerInfo, NETWORK, TAG};
+use crate::context::{EnvConfig, ShardManagerInfo, NETWORK, TAG};
 use libtest_mimic::Failed;
 use std::collections::HashMap;
 use std::io::{BufRead, BufReader};
@@ -76,13 +78,29 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
         shard_id: u16,
         env_config: &EnvConfig,
         redis: &RedisInfo,
-        golem: &GolemServiceInfo,
+        worker: &GolemWorkerServiceInfo,
+        template: &GolemTemplateServiceInfo,
         shard_manager: &ShardManagerInfo,
     ) -> Result<WorkerExecutor<'docker_client>, Failed> {
         if env_config.local_golem {
-            WorkerExecutor::start_process(shard_id, env_config, redis, golem, shard_manager)
+            WorkerExecutor::start_process(
+                shard_id,
+                env_config,
+                redis,
+                worker,
+                template,
+                shard_manager,
+            )
         } else {
-            WorkerExecutor::start_docker(docker, shard_id, env_config, redis, golem, shard_manager)
+            WorkerExecutor::start_docker(
+                docker,
+                shard_id,
+                env_config,
+                redis,
+                worker,
+                template,
+                shard_manager,
+            )
         }
     }
 
@@ -91,7 +109,8 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
         shard_id: u16,
         env_config: &EnvConfig,
         redis: &RedisInfo,
-        golem: &GolemServiceInfo,
+        worker: &GolemWorkerServiceInfo,
+        template: &GolemTemplateServiceInfo,
         shard_manager: &ShardManagerInfo,
     ) -> Result<WorkerExecutor<'docker_client>, Failed> {
         println!("Starting Worker Executor {shard_id} docker");
@@ -99,8 +118,15 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
         let port = 9000 + shard_id;
         let http_port = 9100 + shard_id;
 
-        let env_vars =
-            WorkerExecutor::env_vars(port, http_port, env_config, redis, golem, shard_manager);
+        let env_vars = WorkerExecutor::env_vars(
+            port,
+            http_port,
+            env_config,
+            redis,
+            worker,
+            template,
+            shard_manager,
+        );
         let name = format!("golem_worker_executor{shard_id}");
 
         let image = RunnableImage::from(WorkerExecutorImage::new(port, http_port, env_vars))
@@ -120,7 +146,8 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
         http_port: u16,
         env_config: &EnvConfig,
         redis: &RedisInfo,
-        golem: &GolemServiceInfo,
+        worker: &GolemWorkerServiceInfo,
+        template: &GolemTemplateServiceInfo,
         shard_manager: &ShardManagerInfo,
     ) -> HashMap<String, String> {
         let log_level = if env_config.verbose { "debug" } else { "info" };
@@ -133,11 +160,11 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
             ("GOLEM__REDIS__HOST"                            , &redis.host),
             ("GOLEM__REDIS__PORT"                            , &redis.port.to_string()),
             ("GOLEM__REDIS__KEY_PREFIX"                      , &env_config.redis_key_prefix),
-            ("GOLEM__PUBLIC_WORKER_API__HOST"                , &golem.host),
-            ("GOLEM__PUBLIC_WORKER_API__PORT"                , &golem.grpc_port.to_string()),
+            ("GOLEM__PUBLIC_WORKER_API__HOST"                , &worker.host),
+            ("GOLEM__PUBLIC_WORKER_API__PORT"                , &worker.grpc_port.to_string()),
             ("GOLEM__PUBLIC_WORKER_API__ACCESS_TOKEN"        , "2A354594-7A63-4091-A46B-CC58D379F677"),
-            ("GOLEM__TEMPLATE_SERVICE__CONFIG__HOST"         , &golem.host),
-            ("GOLEM__TEMPLATE_SERVICE__CONFIG__PORT"         , &golem.grpc_port.to_string()),
+            ("GOLEM__TEMPLATE_SERVICE__CONFIG__HOST"         , &template.host),
+            ("GOLEM__TEMPLATE_SERVICE__CONFIG__PORT"         , &template.grpc_port.to_string()),
             ("GOLEM__TEMPLATE_SERVICE__CONFIG__ACCESS_TOKEN" , "2A354594-7A63-4091-A46B-CC58D379F677"),
             ("GOLEM__COMPILED_TEMPLATE_SERVICE__TYPE"        , "Disabled"),
             // ("GOLEM__COMPILED_TEMPLATE_SERVICE__TYPE"        , "Local"),
@@ -163,7 +190,8 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
         shard_id: u16,
         env_config: &EnvConfig,
         redis: &RedisInfo,
-        golem: &GolemServiceInfo,
+        worker: &GolemWorkerServiceInfo,
+        template: &GolemTemplateServiceInfo,
         shard_manager: &ShardManagerInfo,
     ) -> Result<WorkerExecutor<'docker_client>, Failed> {
         let port = 9000 + shard_id;
@@ -191,7 +219,8 @@ impl<'docker_client> WorkerExecutor<'docker_client> {
                 http_port,
                 env_config,
                 redis,
-                golem,
+                worker,
+                template,
                 shard_manager,
             ))
             .stdin(Stdio::piped())
@@ -344,7 +373,8 @@ impl<'docker_client> WorkerExecutors<'docker_client> {
         docker: &'docker_client clients::Cli,
         env_config: &EnvConfig,
         redis: &RedisInfo,
-        golem: &GolemServiceInfo,
+        worker: &GolemWorkerServiceInfo,
+        template: &GolemTemplateServiceInfo,
         shard_manager: &ShardManagerInfo,
     ) -> Result<WorkerExecutors<'docker_client>, Failed> {
         let shards = 3;
@@ -357,7 +387,8 @@ impl<'docker_client> WorkerExecutors<'docker_client> {
                 shard_id.try_into().unwrap(),
                 env_config,
                 redis,
-                golem,
+                worker,
+                template,
                 shard_manager,
             )?)
         }
diff --git a/tests/template.rs b/tests/template.rs
index 7d3c560..0d26798 100644
--- a/tests/template.rs
+++ b/tests/template.rs
@@ -29,18 +29,14 @@ pub fn all(context: Arc<ContextInfo>) -> Vec<Trial> {
     let mut short_args = make(
         "_short",
         "CLI short",
-        CliLive::make(&context.golem_service)
-            .unwrap()
-            .with_short_args(),
+        CliLive::make(&context).unwrap().with_short_args(),
         context.clone(),
     );
 
     let mut long_args = make(
         "_long",
         "CLI long",
-        CliLive::make(&context.golem_service)
-            .unwrap()
-            .with_long_args(),
+        CliLive::make(&context).unwrap().with_long_args(),
         context.clone(),
     );
 
diff --git a/tests/worker.rs b/tests/worker.rs
index 282d9b1..e19edd6 100644
--- a/tests/worker.rs
+++ b/tests/worker.rs
@@ -52,17 +52,13 @@ fn make(suffix: &str, name: &str, cli: CliLive, context: Arc<ContextInfo>) -> Ve
 }
 
 pub fn all(context: Arc<ContextInfo>) -> Vec<Trial> {
-    let short_cli = CliLive::make(&context.golem_service)
-        .unwrap()
-        .with_short_args();
+    let short_cli = CliLive::make(&context).unwrap().with_short_args();
     let mut short_args = make("_short", "CLI_short", short_cli.clone(), context.clone());
 
     let mut long_args = make(
         "_long",
         "CLI_long",
-        CliLive::make(&context.golem_service)
-            .unwrap()
-            .with_long_args(),
+        CliLive::make(&context).unwrap().with_long_args(),
         context.clone(),
     );