diff --git a/bin/netemul_runner/BUILD.gn b/bin/netemul_runner/BUILD.gn
new file mode 100644
index 0000000..313485b
--- /dev/null
+++ b/bin/netemul_runner/BUILD.gn
@@ -0,0 +1,59 @@
+# Copyright 2018 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/package.gni")
+
+executable("bin") {
+  testonly = true
+  output_name = "netemul_sandbox"
+  sources = [
+    "main.cc",
+    "managed_environment.cc",
+    "managed_environment.h",
+    "managed_launcher.cc",
+    "managed_launcher.h",
+    "sandbox.cc",
+    "sandbox.h",
+    "sandbox_env.h",
+  ]
+
+  deps = [
+    "//garnet/lib/cmx:cmx",
+    "//garnet/lib/process",
+    "//garnet/public/fidl/fuchsia.sys",
+    "//garnet/public/lib/component/cpp",
+    "//garnet/public/lib/component/cpp/testing",
+    "//garnet/public/lib/fsl",
+    "//garnet/public/lib/fxl",
+    "//garnet/public/lib/netemul/fidl:network",
+    "//garnet/public/lib/netemul/network:network_service",
+    "//third_party/rapidjson",
+    "//zircon/public/lib/async-cpp",
+    "//zircon/public/lib/async-default",
+    "//zircon/public/lib/async-loop-cpp",
+    "//zircon/public/lib/fdio",
+    "//zircon/public/lib/zx",
+  ]
+}
+
+package("netemul_sandbox") {
+  testonly = true
+
+  deps = [
+    ":bin",
+  ]
+
+  binaries = [
+    {
+      name = "netemul_sandbox"
+    },
+  ]
+
+  meta = [
+    {
+      path = rebase_path("meta/netemul_sandbox.cmx")
+      dest = "netemul_sandbox.cmx"
+    },
+  ]
+}
diff --git a/bin/netemul_runner/MAINTAINERS b/bin/netemul_runner/MAINTAINERS
new file mode 100644
index 0000000..c891e99
--- /dev/null
+++ b/bin/netemul_runner/MAINTAINERS
@@ -0,0 +1 @@
+brunodalbo@google.com
diff --git a/bin/netemul_runner/main.cc b/bin/netemul_runner/main.cc
new file mode 100644
index 0000000..03da980
--- /dev/null
+++ b/bin/netemul_runner/main.cc
@@ -0,0 +1,61 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <lib/async-loop/cpp/loop.h>
+#include <lib/component/cpp/termination_reason.h>
+#include <lib/fxl/command_line.h>
+#include <lib/fxl/log_settings_command_line.h>
+#include <lib/fxl/logging.h>
+#include <iostream>
+#include "sandbox.h"
+
+using namespace netemul;
+
+void PrintUsage() {
+  fprintf(stderr, R"(
+Usage: netemul_sandbox <package_url> [arguments...]
+
+       *package_url* takes the form of component manifest URL which uniquely
+       identifies a component. Example:
+          fuchsia-pkg://fuchsia.com/component_hello_world#meta/hello.cmx
+)");
+}
+
+int main(int argc, const char** argv) {
+  auto command_line = fxl::CommandLineFromArgcArgv(argc, argv);
+  if (!fxl::SetLogSettingsFromCommandLine(command_line))
+    return 1;
+
+  async::Loop loop(&kAsyncLoopConfigNoAttachToThread);
+  async_set_default_dispatcher(loop.dispatcher());
+
+  SandboxArgs args;
+
+  auto posargs = command_line.positional_args().begin();
+  if (posargs == command_line.positional_args().end()) {
+    PrintUsage();
+    return 1;
+  }
+  args.package = *posargs++;
+  args.args.insert(args.args.end(), posargs,
+                   command_line.positional_args().end());
+
+  FXL_LOG(INFO) << "Starting netemul sandbox for " << args.package;
+
+  Sandbox sandbox(std::move(args));
+  sandbox.SetTerminationCallback([](int64_t exit_code,
+                                    Sandbox::TerminationReason reason) {
+    FXL_LOG(INFO) << "Sandbox terminated with (" << exit_code << ") reason: "
+                  << component::HumanReadableTerminationReason(reason);
+    if (reason != Sandbox::TerminationReason::EXITED) {
+      exit_code = 1;
+    }
+    zx_process_exit(exit_code);
+  });
+
+  sandbox.Start();
+  loop.Run();
+
+  return 0;
+}
\ No newline at end of file
diff --git a/bin/netemul_runner/managed_environment.cc b/bin/netemul_runner/managed_environment.cc
new file mode 100644
index 0000000..7b8f5f6
--- /dev/null
+++ b/bin/netemul_runner/managed_environment.cc
@@ -0,0 +1,42 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "managed_environment.h"
+
+namespace netemul {
+
+using component::testing::EnclosingEnvironment;
+using component::testing::EnvironmentServices;
+
+ManagedEnvironment::Ptr ManagedEnvironment::CreateRoot(
+    const fuchsia::sys::EnvironmentPtr& parent,
+    const SandboxEnv::Ptr& sandbox_env) {
+  auto services = EnvironmentServices::Create(parent);
+
+  fuchsia::sys::EnvironmentOptions options = {.kill_on_oom = true,
+                                              .allow_parent_runners = false,
+                                              .inherit_parent_services = true};
+
+  auto enclosing = EnclosingEnvironment::Create("root", parent,
+                                                std::move(services), options);
+
+  return ManagedEnvironment::Ptr(
+      new ManagedEnvironment(std::move(enclosing), sandbox_env));
+}
+
+ManagedEnvironment::ManagedEnvironment(
+    std::unique_ptr<component::testing::EnclosingEnvironment> env,
+    const SandboxEnv::Ptr& sandbox_env)
+    : sandbox_env_(sandbox_env), env_(std::move(env)), launcher_(this) {
+  env_->SetRunningChangedCallback([this](bool running) {
+    if (running && running_callback_) {
+      running_callback_();
+    }
+  });
+}
+
+component::testing::EnclosingEnvironment& ManagedEnvironment::environment() {
+  return *env_;
+}
+}  // namespace netemul
diff --git a/bin/netemul_runner/managed_environment.h b/bin/netemul_runner/managed_environment.h
new file mode 100644
index 0000000..b2a1014
--- /dev/null
+++ b/bin/netemul_runner/managed_environment.h
@@ -0,0 +1,57 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_BIN_NETEMUL_RUNNER_MANAGED_ENVIRONMENT_H_
+#define GARNET_BIN_NETEMUL_RUNNER_MANAGED_ENVIRONMENT_H_
+
+#include <lib/component/cpp/testing/enclosing_environment.h>
+#include <lib/svc/cpp/services.h>
+#include <memory>
+#include "managed_launcher.h"
+#include "sandbox_env.h"
+
+namespace netemul {
+
+class ManagedEnvironment {
+ public:
+  using EnvironmentRunningCallback = fit::closure;
+  using Ptr = std::unique_ptr<ManagedEnvironment>;
+  static Ptr CreateRoot(const fuchsia::sys::EnvironmentPtr& parent,
+                        const SandboxEnv::Ptr& sandbox_env);
+
+  const SandboxEnv::Ptr& sandbox_env() const { return sandbox_env_; }
+
+  const std::shared_ptr<component::Services>& services() {
+    if (!services_) {
+      services_ = std::make_shared<component::Services>();
+    }
+    return services_;
+  }
+
+  ManagedLauncher& launcher() { return launcher_; }
+
+  void SetRunningCallback(EnvironmentRunningCallback cb) {
+    running_callback_ = std::move(cb);
+  }
+
+ protected:
+  friend ManagedLauncher;
+
+  component::testing::EnclosingEnvironment& environment();
+
+ private:
+  ManagedEnvironment(
+      std::unique_ptr<component::testing::EnclosingEnvironment> env,
+      const SandboxEnv::Ptr& sandbox_env);
+
+  SandboxEnv::Ptr sandbox_env_;
+  std::unique_ptr<component::testing::EnclosingEnvironment> env_;
+  ManagedLauncher launcher_;
+  std::shared_ptr<component::Services> services_;
+  EnvironmentRunningCallback running_callback_;
+};
+
+}  // namespace netemul
+
+#endif  // GARNET_BIN_NETEMUL_RUNNER_MANAGED_ENVIRONMENT_H_
diff --git a/bin/netemul_runner/managed_launcher.cc b/bin/netemul_runner/managed_launcher.cc
new file mode 100644
index 0000000..c67f6ed
--- /dev/null
+++ b/bin/netemul_runner/managed_launcher.cc
@@ -0,0 +1,38 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "managed_launcher.h"
+#include <lib/fdio/io.h>
+#include <lib/fxl/logging.h>
+#include <lib/fxl/strings/concatenate.h>
+#include <zircon/status.h>
+#include "garnet/lib/process/process_builder.h"
+#include "managed_environment.h"
+
+namespace netemul {
+
+using fuchsia::sys::TerminationReason;
+using process::ProcessBuilder;
+
+struct LaunchArgs {
+  std::string binary;
+  fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller;
+};
+
+void ManagedLauncher::CreateComponent(
+    fuchsia::sys::LaunchInfo launch_info,
+    fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller) {
+  // Just pass through to real launcher.
+  real_launcher_->CreateComponent(std::move(launch_info),
+                                  std::move(controller));
+}
+
+ManagedLauncher::ManagedLauncher(ManagedEnvironment* environment)
+    : env_(environment) {
+  env_->environment().ConnectToService(real_launcher_.NewRequest());
+}
+
+ManagedLauncher::~ManagedLauncher() = default;
+
+}  // namespace netemul
diff --git a/bin/netemul_runner/managed_launcher.h b/bin/netemul_runner/managed_launcher.h
new file mode 100644
index 0000000..eecf6d8
--- /dev/null
+++ b/bin/netemul_runner/managed_launcher.h
@@ -0,0 +1,31 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_BIN_NETEMUL_RUNNER_MANAGED_LAUNCHER_H_
+#define GARNET_BIN_NETEMUL_RUNNER_MANAGED_LAUNCHER_H_
+
+#include <fuchsia/sys/cpp/fidl.h>
+#include <string>
+
+namespace netemul {
+class ManagedEnvironment;
+class ManagedLauncher {
+ public:
+  explicit ManagedLauncher(ManagedEnvironment* environment);
+
+  ~ManagedLauncher();
+
+  void CreateComponent(
+      fuchsia::sys::LaunchInfo launch_info,
+      fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller);
+
+ private:
+  // Pointer to parent environment. Not owned.
+  ManagedEnvironment* env_;
+  fuchsia::sys::LauncherPtr real_launcher_;
+};
+
+}  // namespace netemul
+
+#endif  // GARNET_BIN_NETEMUL_RUNNER_MANAGED_LAUNCHER_H_
diff --git a/bin/netemul_runner/meta/netemul_sandbox.cmx b/bin/netemul_runner/meta/netemul_sandbox.cmx
new file mode 100644
index 0000000..21fd9b1
--- /dev/null
+++ b/bin/netemul_runner/meta/netemul_sandbox.cmx
@@ -0,0 +1,12 @@
+{
+    "program": {
+        "binary": "bin/netemul_sandbox"
+    },
+    "sandbox": {
+        "services": [
+            "fuchsia.sys.Environment",
+            "fuchsia.sys.Loader",
+            "fuchsia.sys.Launcher"
+        ]
+    }
+}
diff --git a/bin/netemul_runner/runner/BUILD.gn b/bin/netemul_runner/runner/BUILD.gn
new file mode 100644
index 0000000..e7fb80d
--- /dev/null
+++ b/bin/netemul_runner/runner/BUILD.gn
@@ -0,0 +1,46 @@
+# Copyright 2018 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/package.gni")
+
+executable("bin") {
+  testonly = true
+  output_name = "netemul_runner"
+  sources = [
+    "main.cc",
+    "runner.cc",
+    "runner.h",
+  ]
+
+  deps = [
+    "//garnet/lib/cmx:cmx",
+    "//garnet/public/fidl/fuchsia.sys",
+    "//garnet/public/lib/component/cpp",
+    "//garnet/public/lib/fsl",
+    "//garnet/public/lib/fxl",
+    "//garnet/public/lib/pkg_url",
+    "//third_party/rapidjson",
+    "//zircon/public/lib/async-cpp",
+    "//zircon/public/lib/async-default",
+    "//zircon/public/lib/async-loop-cpp",
+  ]
+}
+
+package("netemul_runner") {
+  testonly = true
+
+  deps = [
+    ":bin",
+    "//garnet/bin/netemul_runner:netemul_sandbox",
+  ]
+
+  binary = "netemul_runner"
+
+  meta = [
+    {
+      path = rebase_path("meta/netemul_runner.cmx")
+      dest = "netemul_runner.cmx"
+    },
+  ]
+}
diff --git a/bin/netemul_runner/runner/main.cc b/bin/netemul_runner/runner/main.cc
new file mode 100644
index 0000000..848bc27
--- /dev/null
+++ b/bin/netemul_runner/runner/main.cc
@@ -0,0 +1,28 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <lib/async-loop/cpp/loop.h>
+#include <lib/fxl/command_line.h>
+#include <lib/fxl/log_settings_command_line.h>
+#include <lib/fxl/logging.h>
+#include <iostream>
+#include "runner.h"
+
+using namespace netemul;
+
+int main(int argc, const char** argv) {
+  auto command_line = fxl::CommandLineFromArgcArgv(argc, argv);
+  if (!fxl::SetLogSettingsFromCommandLine(command_line))
+    return 1;
+
+  async::Loop loop(&kAsyncLoopConfigNoAttachToThread);
+  async_set_default_dispatcher(loop.dispatcher());
+
+  FXL_LOG(INFO) << "Starting netemul runner";
+
+  Runner r(loop.dispatcher());
+  loop.Run();
+
+  return 0;
+}
\ No newline at end of file
diff --git a/bin/netemul_runner/runner/meta/netemul_runner.cmx b/bin/netemul_runner/runner/meta/netemul_runner.cmx
new file mode 100644
index 0000000..ef8c26b
--- /dev/null
+++ b/bin/netemul_runner/runner/meta/netemul_runner.cmx
@@ -0,0 +1,11 @@
+{
+    "program": {
+        "binary": "bin/app"
+    },
+    "sandbox": {
+        "services": [
+            "fuchsia.sys.Launcher",
+            "fuchsia.sys.Loader"
+        ]
+    }
+}
diff --git a/bin/netemul_runner/runner/runner.cc b/bin/netemul_runner/runner/runner.cc
new file mode 100644
index 0000000..210ba68
--- /dev/null
+++ b/bin/netemul_runner/runner/runner.cc
@@ -0,0 +1,107 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "runner.h"
+
+#include <lib/async/default.h>
+#include <lib/fsl/io/fd.h>
+#include <lib/fxl/files/unique_fd.h>
+#include <lib/fxl/logging.h>
+#include <lib/pkg_url/fuchsia_pkg_url.h>
+#include "garnet/lib/cmx/cmx.h"
+
+namespace netemul {
+using component::StartupContext;
+static const char* kSandbox =
+    "fuchsia-pkg://fuchsia.com/netemul_sandbox#meta/netemul_sandbox.cmx";
+
+Runner::Runner(async_dispatcher_t* dispatcher) {
+  if (dispatcher == nullptr) {
+    dispatcher = async_get_default_dispatcher();
+  }
+  dispatcher_ = dispatcher;
+
+  startup_context_ = StartupContext::CreateFromStartupInfo();
+  startup_context_->ConnectToEnvironmentService(
+      launcher_.NewRequest(dispatcher_));
+  startup_context_->ConnectToEnvironmentService(
+      loader_.NewRequest(dispatcher_));
+  startup_context_->outgoing().AddPublicService(
+      bindings_.GetHandler(this, dispatcher_));
+}
+
+struct RunnerArgs {
+  fuchsia::sys::StartupInfo startup_info;
+  fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller;
+};
+
+void Runner::StartComponent(
+    fuchsia::sys::Package package, fuchsia::sys::StartupInfo startup_info,
+    fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller) {
+  FXL_LOG(INFO) << "resolved URL: " << package.resolved_url;
+
+  // args needs to be shared ptr 'cause Loader fidl
+  // uses std::function and not fit::function (i.e. legacy callbacks)
+  std::shared_ptr<RunnerArgs> args = std::make_shared<RunnerArgs>();
+  args->startup_info = std::move(startup_info);
+  args->controller = std::move(controller);
+
+  // go through loader to get information, 'cause info is not complete
+  // from caller (missing directory and other stuff)
+  loader_->LoadUrl(
+      package.resolved_url, [this, args](fuchsia::sys::PackagePtr package) {
+        RunComponent(std::move(package), std::move(args->startup_info),
+                     std::move(args->controller));
+      });
+}
+
+void Runner::RunComponent(
+    fuchsia::sys::PackagePtr package, fuchsia::sys::StartupInfo startup_info,
+    fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller) {
+  if (!package) {
+    // TODO(brunodalbo) expose errors correctly through interface request
+    FXL_LOG(ERROR) << "Can't load package";
+    return;
+  }
+  // extract and parse cmx:
+  component::FuchsiaPkgUrl fp;
+  if (!fp.Parse(package->resolved_url.get())) {
+    FXL_LOG(ERROR) << "can't parse fuchsia URL " << package->resolved_url;
+    // TODO(brunodalbo) expose errors correctly through interface request
+    return;
+  }
+
+  if (!package->directory.is_valid()) {
+    FXL_LOG(ERROR) << "Package directory not provided";
+    return;
+  }
+
+  component::CmxMetadata cmx;
+  fxl::UniqueFD fd =
+      fsl::OpenChannelAsFileDescriptor(std::move(package->directory));
+
+  json::JSONParser json_parser;
+  if (!cmx.ParseFromFileAt(fd.get(), fp.resource_path(), &json_parser)) {
+    FXL_LOG(ERROR) << "cmx file failed to parse: " << json_parser.error_str();
+    // TODO(brunodalbo) expose errors correctly through interface request
+    return;
+  }
+
+  std::stringstream launchpkg;
+  launchpkg << "fuchsia-pkg://fuchsia.com/" << fp.package_name() << "#"
+            << cmx.program_meta().data();
+
+  auto sandbox_arg = launchpkg.str();
+
+  auto linfo = std::move(startup_info.launch_info);
+  linfo.url = kSandbox;
+  linfo.arguments->push_back(sandbox_arg);
+  linfo.arguments->insert(linfo.arguments->end(),
+                          startup_info.launch_info.arguments->begin(),
+                          startup_info.launch_info.arguments->end());
+
+  launcher_->CreateComponent(std::move(linfo), std::move(controller));
+}
+
+}  // namespace netemul
diff --git a/bin/netemul_runner/runner/runner.h b/bin/netemul_runner/runner/runner.h
new file mode 100644
index 0000000..1c837cf
--- /dev/null
+++ b/bin/netemul_runner/runner/runner.h
@@ -0,0 +1,37 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_BIN_NETEMUL_RUNNER_RUNNER_RUNNER_H_
+#define GARNET_BIN_NETEMUL_RUNNER_RUNNER_RUNNER_H_
+
+#include <lib/component/cpp/startup_context.h>
+#include <lib/fidl/cpp/binding_set.h>
+#include "fuchsia/sys/cpp/fidl.h"
+
+namespace netemul {
+class Runner : public fuchsia::sys::Runner {
+ public:
+  using FRunner = fuchsia::sys::Runner;
+  explicit Runner(async_dispatcher_t* dispatcher = nullptr);
+
+  void StartComponent(fuchsia::sys::Package package,
+                      fuchsia::sys::StartupInfo startup_info,
+                      fidl::InterfaceRequest<fuchsia::sys::ComponentController>
+                          controller) override;
+
+ private:
+  void RunComponent(
+      fuchsia::sys::PackagePtr package, fuchsia::sys::StartupInfo startup_info,
+      fidl::InterfaceRequest<fuchsia::sys::ComponentController> controller);
+
+  async_dispatcher_t* dispatcher_;
+  std::unique_ptr<component::StartupContext> startup_context_;
+  fidl::BindingSet<FRunner> bindings_;
+  fuchsia::sys::LauncherPtr launcher_;
+  fuchsia::sys::LoaderPtr loader_;
+};
+
+}  // namespace netemul
+
+#endif  // GARNET_BIN_NETEMUL_RUNNER_RUNNER_RUNNER_H_
diff --git a/bin/netemul_runner/sandbox.cc b/bin/netemul_runner/sandbox.cc
new file mode 100644
index 0000000..1b8e89a
--- /dev/null
+++ b/bin/netemul_runner/sandbox.cc
@@ -0,0 +1,95 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "sandbox.h"
+#include <fcntl.h>
+#include <lib/async/default.h>
+#include <lib/component/cpp/startup_context.h>
+#include <lib/component/cpp/testing/test_util.h>
+#include <lib/fdio/watcher.h>
+#include <lib/fsl/io/fd.h>
+#include <lib/fxl/logging.h>
+#include <lib/fxl/strings/concatenate.h>
+#include <lib/pkg_url/fuchsia_pkg_url.h>
+#include <zircon/status.h>
+#include "garnet/lib/cmx/cmx.h"
+
+namespace netemul {
+
+Sandbox::Sandbox(SandboxArgs args) : args_(std::move(args)) {
+  auto startup_context = component::StartupContext::CreateFromStartupInfo();
+  startup_context->ConnectToEnvironmentService(parent_env_.NewRequest());
+  startup_context->ConnectToEnvironmentService(loader_.NewRequest());
+}
+
+void Sandbox::Start() {
+  if (!parent_env_ || !loader_) {
+    Terminate(TerminationReason::INTERNAL_ERROR);
+  }
+
+  loader_->LoadUrl(args_.package, [this](fuchsia::sys::PackagePtr package) {
+    if (!package) {
+      Terminate(TerminationReason::PACKAGE_NOT_FOUND);
+      return;
+    } else if (!package->directory) {
+      Terminate(TerminationReason::INTERNAL_ERROR);
+    }
+    LoadPackage(std::move(package));
+  });
+}
+
+void Sandbox::Terminate(int64_t exit_code, Sandbox::TerminationReason reason) {
+  if (termination_callback_) {
+    termination_callback_(exit_code, reason);
+  }
+}
+
+void Sandbox::Terminate(Sandbox::TerminationReason reason) {
+  Terminate(-1, reason);
+}
+void Sandbox::LoadPackage(fuchsia::sys::PackagePtr package) {
+  // package is loaded, proceed to parsing cmx and starting child env
+  component::FuchsiaPkgUrl pkgUrl;
+  if (!pkgUrl.Parse(package->resolved_url)) {
+    FXL_LOG(ERROR) << "Can't parse fuchsia url: " << package->resolved_url;
+    Terminate(TerminationReason::INTERNAL_ERROR);
+    return;
+  }
+
+  fxl::UniqueFD dirfd =
+      fsl::OpenChannelAsFileDescriptor(std::move(package->directory));
+  sandbox_env_ = std::make_shared<SandboxEnv>(args_.package, std::move(dirfd));
+
+  component::CmxMetadata cmx;
+
+  json::JSONParser json_parser;
+  if (!cmx.ParseFromFileAt(sandbox_env_->dir().get(), pkgUrl.resource_path(),
+                           &json_parser)) {
+    FXL_LOG(ERROR) << "cmx file failed to parse: " << json_parser.error_str();
+    Terminate(TerminationReason::INTERNAL_ERROR);
+    return;
+  }
+
+  root_ = ManagedEnvironment::CreateRoot(parent_env_, sandbox_env_);
+
+  // TODO(brunodalbo) parameterize environment based on
+  // facets in cmx file
+
+  root_->SetRunningCallback([this] {
+    root_proc_.events().OnTerminated = [this](int64_t code,
+                                              TerminationReason reason) {
+      Terminate(code, reason);  // mimic termination of root process
+    };
+
+    // start root test process:
+    fuchsia::sys::LaunchInfo linfo;
+    linfo.url = sandbox_env_->name();
+    linfo.out = component::testing::CloneFileDescriptor(STDOUT_FILENO);
+    linfo.err = component::testing::CloneFileDescriptor(STDERR_FILENO);
+    root_->launcher().CreateComponent(std::move(linfo),
+                                      root_proc_.NewRequest());
+  });
+}
+
+}  // namespace netemul
\ No newline at end of file
diff --git a/bin/netemul_runner/sandbox.h b/bin/netemul_runner/sandbox.h
new file mode 100644
index 0000000..71bd3a2
--- /dev/null
+++ b/bin/netemul_runner/sandbox.h
@@ -0,0 +1,50 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_BIN_NETEMUL_RUNNER_SANDBOX_H_
+#define GARNET_BIN_NETEMUL_RUNNER_SANDBOX_H_
+
+#include <fuchsia/sys/cpp/fidl.h>
+#include "managed_environment.h"
+#include "sandbox_env.h"
+
+namespace netemul {
+
+class SandboxArgs {
+ public:
+  std::string package;
+  std::vector<std::string> args;
+};
+
+class Sandbox {
+ public:
+  using TerminationReason = fuchsia::sys::TerminationReason;
+  using TerminationCallback =
+      fit::function<void(int64_t code, TerminationReason reason)>;
+  explicit Sandbox(SandboxArgs args);
+
+  void SetTerminationCallback(TerminationCallback callback) {
+    termination_callback_ = std::move(callback);
+  }
+
+  void Start();
+
+ private:
+  void LoadPackage(fuchsia::sys::PackagePtr package);
+  void Terminate(TerminationReason reason);
+  void Terminate(int64_t exit_code, TerminationReason reason);
+  void StartRootEnvironment();
+
+  SandboxArgs args_;
+  SandboxEnv::Ptr sandbox_env_;
+  TerminationCallback termination_callback_;
+  fuchsia::sys::EnvironmentPtr parent_env_;
+  fuchsia::sys::LoaderPtr loader_;
+  ManagedEnvironment::Ptr root_;
+  fuchsia::sys::ComponentControllerPtr root_proc_;
+};
+
+}  // namespace netemul
+
+#endif  // GARNET_BIN_NETEMUL_RUNNER_SANDBOX_H_
diff --git a/bin/netemul_runner/sandbox_env.h b/bin/netemul_runner/sandbox_env.h
new file mode 100644
index 0000000..671fcb8
--- /dev/null
+++ b/bin/netemul_runner/sandbox_env.h
@@ -0,0 +1,32 @@
+#include <utility>
+
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_BIN_NETEMUL_RUNNER_SANDBOX_ENV_H_
+#define GARNET_BIN_NETEMUL_RUNNER_SANDBOX_ENV_H_
+
+#include <lib/fxl/files/unique_fd.h>
+#include <memory>
+#include <string>
+
+namespace netemul {
+class SandboxEnv {
+ public:
+  using Ptr = std::shared_ptr<SandboxEnv>;
+
+  SandboxEnv(std::string package_name, fxl::UniqueFD dir)
+      : package_name_(std::move(package_name)), package_dir_(std::move(dir)) {}
+
+  const std::string& name() const { return package_name_; }
+
+  const fxl::UniqueFD& dir() const { return package_dir_; }
+
+ private:
+  std::string package_name_;
+  fxl::UniqueFD package_dir_;
+};
+}  // namespace netemul
+
+#endif  // GARNET_BIN_NETEMUL_RUNNER_SANDBOX_ENV_H_
diff --git a/bin/netemul_runner/test/BUILD.gn b/bin/netemul_runner/test/BUILD.gn
new file mode 100644
index 0000000..e4d1e5f
--- /dev/null
+++ b/bin/netemul_runner/test/BUILD.gn
@@ -0,0 +1,24 @@
+# Copyright 2018 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/test/test_package.gni")
+
+test_package("netemul_sandbox_test") {
+  deps = [
+    "//garnet/bin/netemul_runner/test/svc_list",
+  ]
+
+  meta = [
+    {
+      path = rebase_path("meta/svc_list_run.cmx")
+      dest = "svc_list_run.cmx"
+    },
+  ]
+
+  tests = [
+    {
+      name = "svc_list"
+    },
+  ]
+}
diff --git a/bin/netemul_runner/test/meta/svc_list.cmx b/bin/netemul_runner/test/meta/svc_list.cmx
new file mode 100644
index 0000000..bd906ba
--- /dev/null
+++ b/bin/netemul_runner/test/meta/svc_list.cmx
@@ -0,0 +1,6 @@
+{
+    "program": {
+        "data": "meta/svc_list_run.cmx"
+    },
+    "runner": "fuchsia-pkg://fuchsia.com/netemul_runner#meta/netemul_runner.cmx"
+}
diff --git a/bin/netemul_runner/test/meta/svc_list_run.cmx b/bin/netemul_runner/test/meta/svc_list_run.cmx
new file mode 100644
index 0000000..1f58670
--- /dev/null
+++ b/bin/netemul_runner/test/meta/svc_list_run.cmx
@@ -0,0 +1,5 @@
+{
+    "program": {
+        "binary": "test/svc_list"
+    }
+}
diff --git a/bin/netemul_runner/test/svc_list/BUILD.gn b/bin/netemul_runner/test/svc_list/BUILD.gn
new file mode 100644
index 0000000..206acbb
--- /dev/null
+++ b/bin/netemul_runner/test/svc_list/BUILD.gn
@@ -0,0 +1,18 @@
+# Copyright 2018 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/package.gni")
+import("//build/rust/rustc_binary.gni")
+
+rustc_binary("svc_list") {
+  name = "svc_list"
+  edition = "2018"
+  deps = [
+    "//garnet/lib/rust/ethernet",
+    "//garnet/public/rust/fuchsia-async",
+    "//garnet/public/rust/fuchsia-zircon",
+    "//third_party/rust-crates/rustc_deps:failure",
+    "//third_party/rust-crates/rustc_deps:futures-preview",
+  ]
+}
diff --git a/bin/netemul_runner/test/svc_list/src/main.rs b/bin/netemul_runner/test/svc_list/src/main.rs
new file mode 100644
index 0000000..b5e921b
--- /dev/null
+++ b/bin/netemul_runner/test/svc_list/src/main.rs
@@ -0,0 +1,29 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::fs;
+use std::io;
+use std::path::Path;
+
+fn visit_dirs(dir: &Path) -> io::Result<()> {
+    if dir.is_dir() {
+        for entry in fs::read_dir(dir)? {
+            let entry = entry?;
+            let path = entry.path();
+            let str = path.to_str().expect("paths need strings?");
+            println!("{}", str);
+            visit_dirs(dir.join(path).as_path())?;
+        }
+    }
+    Ok(())
+}
+
+fn main() -> io::Result<()> {
+    println!("Hello World");
+    visit_dirs(Path::new("/"))?;
+
+    // TODO(brunodalbo) the idea of this test is to find the sandbox services and ensure they're there
+
+    Ok(())
+}
diff --git a/packages/testing/all b/packages/testing/all
index 1a2bb15..5e5803d 100644
--- a/packages/testing/all
+++ b/packages/testing/all
@@ -1,5 +1,6 @@
 {
     "imports": [
-        "garnet/packages/testing/run_test_component"
+        "garnet/packages/testing/run_test_component",
+        "garnet/packages/testing/netemul_runner"
     ]
 }
diff --git a/packages/testing/netemul_runner b/packages/testing/netemul_runner
new file mode 100644
index 0000000..7a11092
--- /dev/null
+++ b/packages/testing/netemul_runner
@@ -0,0 +1,6 @@
+{
+    "packages": [
+        "//garnet/bin/netemul_runner/runner:netemul_runner",
+        "//garnet/bin/netemul_runner:netemul_sandbox"
+    ]
+}
diff --git a/packages/tests/netemul b/packages/tests/netemul
index 8a97dcc..d5cb344 100644
--- a/packages/tests/netemul
+++ b/packages/tests/netemul
@@ -1,8 +1,10 @@
 {
     "imports": [
-        "garnet/packages/prod/netstack"
+        "garnet/packages/prod/netstack",
+        "garnet/packages/testing/netemul_runner"
     ],
     "packages": [
-        "//garnet/public/lib/netemul/network:netemul_network_test"
+        "//garnet/public/lib/netemul/network:netemul_network_test",
+        "//garnet/bin/netemul_runner/test:netemul_sandbox_test"
     ]
 }
diff --git a/public/lib/netemul/MAINTAINERS b/public/lib/netemul/MAINTAINERS
new file mode 100644
index 0000000..c891e99
--- /dev/null
+++ b/public/lib/netemul/MAINTAINERS
@@ -0,0 +1 @@
+brunodalbo@google.com