diff --git a/engine/v8_inspector/inspector_backend_mojo.cc b/engine/v8_inspector/inspector_backend_mojo.cc
index 136d34ef3ec..df8a08833a2 100644
--- a/engine/v8_inspector/inspector_backend_mojo.cc
+++ b/engine/v8_inspector/inspector_backend_mojo.cc
@@ -24,13 +24,15 @@ namespace blink {
 
 class InspectorBackendMojoImpl
     : public InspectorFrontendChannel,
-      public mojo::InterfaceImpl<sky::InspectorBackend> {
+      public sky::InspectorBackend,
+      public mojo::InterfaceFactory<sky::InspectorBackend> {
  public:
   explicit InspectorBackendMojoImpl(inspector::InspectorHost*);
   ~InspectorBackendMojoImpl();
 
   void Connect();
 
+ private:
   // InspectorBackend:
   void OnConnect();
   void OnMessage(const mojo::String& message) override;
@@ -41,8 +43,13 @@ class InspectorBackendMojoImpl
   // TODO(eseidel): Unclear if flush is needed.
   void flush() override {}
 
+  // mojo::InterfaceFactory<sky::InspectorBackend>
+  void Create(mojo::ApplicationConnection* connection,
+              mojo::InterfaceRequest<sky::InspectorBackend> request) override;
+
   inspector::InspectorHost* host_;
   sky::InspectorFrontendPtr frontend_;
+  mojo::ServiceProviderImpl inspector_service_provider_;
 
   OwnPtr<InspectorFrontend> old_frontend_;
   RefPtr<InspectorBackendDispatcher> dispatcher_;
@@ -51,6 +58,8 @@ class InspectorBackendMojoImpl
   OwnPtr<InspectorState> inspector_state_;
   OwnPtr<InstrumentingAgents> agents_;
 
+  mojo::Binding<sky::InspectorBackend> binding_;
+
   DISALLOW_COPY_AND_ASSIGN(InspectorBackendMojoImpl);
 };
 
@@ -88,7 +97,8 @@ class InspectorHostResolverImpl : public PageScriptDebugServer::InspectorHostRes
 
 InspectorBackendMojoImpl::InspectorBackendMojoImpl(
     inspector::InspectorHost* host)
-    : host_(host) {
+    : host_(host), binding_(this) {
+  inspector_service_provider_.AddService(this);
 }
 
 InspectorBackendMojoImpl::~InspectorBackendMojoImpl() {
@@ -96,11 +106,13 @@ InspectorBackendMojoImpl::~InspectorBackendMojoImpl() {
 
 void InspectorBackendMojoImpl::Connect() {
   mojo::Shell* shell = host_->GetShell();
-  mojo::ServiceProviderPtr inspector_service_provider;
+  mojo::InterfaceRequest<mojo::ServiceProvider> service_provider_request;
+  mojo::MessagePipe pipe;
+  service_provider_request.Bind(pipe.handle0.Pass());
+  inspector_service_provider_.BindToHandle(pipe.handle1.Pass());
   shell->ConnectToApplication("mojo:sky_inspector_server",
-                              GetProxy(&inspector_service_provider));
-  mojo::ConnectToService(inspector_service_provider.get(), &frontend_);
-  frontend_.set_client(this);
+                              service_provider_request.Pass());
+  mojo::ConnectToService(&inspector_service_provider_, &frontend_);
 
   // Theoretically we should load our state from the inspector cookie.
   inspector_state_ =
@@ -149,6 +161,12 @@ void InspectorBackendMojoImpl::OnMessage(const mojo::String& message) {
     dispatcher_->dispatch(wtf_message);
 }
 
+void InspectorBackendMojoImpl::Create(
+    mojo::ApplicationConnection* connection,
+    mojo::InterfaceRequest<sky::InspectorBackend> request) {
+  binding_.Bind(request.Pass());
+}
+
 }  // namespace blink
 
 namespace inspector {
diff --git a/framework/inspector/inspector.sky b/framework/inspector/inspector.sky
index 62c53fb3bf2..4d5107de19a 100644
--- a/framework/inspector/inspector.sky
+++ b/framework/inspector/inspector.sky
@@ -1,6 +1,7 @@
 <import src="/mojo/public/sky/connection.sky" as="connection" />
 <import src="/mojo/public/sky/core.sky" as="core" />
 <import src="/mojo/public/sky/support.sky" as="support" />
+<import src="/mojo/services/public/sky/application.sky" as="application" />
 <import src="/sky/services/inspector/inspector.mojom.sky" as="inspector" />
 <import src="console-agent.sky" as="ConsoleAgent" />
 <import src="dom-agent.sky" as="DOMAgent" />
@@ -11,7 +12,6 @@
 <import src="css-agent.sky" as="CSSAgent" />
 <script>
 function InspectorBackend(frontend) {
-  this.frontend = frontend;
   var domAgent = new DOMAgent(this);
   this.agents = {
     Console: new ConsoleAgent(),
@@ -104,7 +104,7 @@ InspectorBackend.prototype.sendResponse = function(message_id, result) {
   };
   if (typeof result !== "undefined")
     response.result = result;
-  this.frontend.sendMessage(JSON.stringify(response));
+  window.frontend.sendMessage(JSON.stringify(response));
 }
 
 InspectorBackend.prototype.sendMessage = function(method, params) {
@@ -112,15 +112,16 @@ InspectorBackend.prototype.sendMessage = function(method, params) {
     method: method,
     params: params,
   });
-  this.frontend.sendMessage(message);
+  window.frontend.sendMessage(message);
 };
 
-var frontendHandle = internals.connectToService(
-    "mojo:sky_inspector_server", inspector.InspectorFrontend.name);
-window.frontendConnection = new connection.Connection(
-    frontendHandle,
-    InspectorBackend,
-    inspector.InspectorFrontend.proxyClass);
+(function() {
+  var app = new application.Application(internals.passShellProxyHandle());
+  var tracingApp = app.shell.connectToApplication("mojo:sky_inspector_server");
+  tracingApp.provideService(inspector.InspectorBackend, InspectorBackend);
+
+  window.frontend = tracingApp.requestService(inspector.InspectorFrontend);
+})();
+
 
-window.frontend = frontendConnection.remote;
 </script>
diff --git a/services/inspector/inspector.mojom b/services/inspector/inspector.mojom
index 4d65b439716..2208720cb8d 100644
--- a/services/inspector/inspector.mojom
+++ b/services/inspector/inspector.mojom
@@ -8,12 +8,10 @@ interface InspectorServer {
   Listen(int32 port) => ();
 };
 
-[Client=InspectorBackend]
 interface InspectorFrontend {
   SendMessage(string message);
 };
 
-[Client=InspectorFrontend]
 interface InspectorBackend {
   OnConnect();
   OnDisconnect();
diff --git a/services/inspector/server.cc b/services/inspector/server.cc
index 3cb300cd548..c5cd23e58bb 100644
--- a/services/inspector/server.cc
+++ b/services/inspector/server.cc
@@ -4,6 +4,7 @@
 
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/common/weak_binding_set.h"
+#include "mojo/common/weak_interface_ptr_set.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
@@ -38,6 +39,12 @@ class Server : public mojo::ApplicationDelegate,
       mojo::ApplicationConnection* connection) override {
     connection->AddService<InspectorFrontend>(this);
     connection->AddService<InspectorServer>(this);
+    // The application connecting to us may implement InspectorBackend,
+    // attempt to establish a connection to find out. If it doesn't then this
+    // pipe will close.
+    InspectorBackendPtr backend;
+    connection->ConnectToService(&backend);
+    backends_.AddInterfacePtr(backend.Pass());
     return true;
   }
 
@@ -72,6 +79,7 @@ class Server : public mojo::ApplicationDelegate,
   int connection_id_;
   scoped_ptr<net::HttpServer> web_server_;
 
+  mojo::WeakInterfacePtrSet<InspectorBackend> backends_;
   mojo::WeakBindingSet<InspectorFrontend> frontend_bindings_;
   mojo::Binding<InspectorServer> server_binding_;
 
@@ -98,27 +106,26 @@ void Server::OnWebSocketRequest(
   }
   web_server_->AcceptWebSocket(connection_id, info);
   connection_id_ = connection_id;
-  frontend_bindings_.ForAllBindings(
-      [](InspectorFrontend::Client* client) { client->OnConnect(); });
+  backends_.ForAllPtrs([](InspectorBackend* backend) { backend->OnConnect(); });
 }
 
 void Server::OnWebSocketMessage(
     int connection_id, const std::string& data) {
   DCHECK_EQ(connection_id, connection_id_);
-  frontend_bindings_.ForAllBindings(
-      [data](InspectorFrontend::Client* client) { client->OnMessage(data); });
+  backends_.ForAllPtrs(
+      [data](InspectorBackend* backend) { backend->OnMessage(data); });
 }
 
 void Server::OnClose(int connection_id) {
   if (connection_id != connection_id_)
     return;
   connection_id_ = kNotConnected;
-  frontend_bindings_.ForAllBindings(
-      [](InspectorFrontend::Client* client) { client->OnDisconnect(); });
+  backends_.ForAllPtrs(
+      [](InspectorBackend* backend) { backend->OnDisconnect(); });
 }
 
 void Server::Listen(int32_t port, const mojo::Closure& callback) {
-  frontend_bindings_.CloseAllBindings();  // Assume caller represents a new app.
+  backends_.CloseAll();  // Assume caller represents a new app.
 
   // TODO(eseidel): Early-out here if we're already bound to the right port.
   web_server_.reset();