diff --git a/Makefile b/Makefile
index aec95d9..c56efcc 100644
--- a/Makefile
+++ b/Makefile
@@ -26,6 +26,7 @@
 
 VANADIUM_JS:=$(JIRI_ROOT)/release/javascript/core
 SOURCE_FILES = $(shell find src -name "*")
+GO_FILES = $(shell find src -name "*.go")
 
 ifndef TMPDIR
 	export TMPDIR:=/tmp
@@ -75,7 +76,7 @@
 	make -C $(JIRI_ROOT)/infrastructure/deploy browser-staging
 
 # Creating the bundle JS file.
-public/bundle.js: $(SOURCE_FILES) node_modules src/services/sample-world/ifc/index.js
+public/bundle.js: $(SOURCE_FILES) node_modules
 	:;jshint src # lint all src JavaScript files.
 ifdef NOMINIFY
 	$(call BROWSERIFY,src/app.js,$@)
@@ -88,6 +89,7 @@
 	:;vulcanize --output public/bundle.html web-component-dependencies.html --inline
 
 # Generate VDL for JavaScript
+# TODO(alexfandrianto): The JS Sample World is unused, so we can remove this.
 src/services/sample-world/ifc/index.js:
 	VDLPATH=$(JIRI_ROOT)/release/projects/browser/src \
 		vdl generate -lang=javascript \
@@ -98,9 +100,6 @@
 node_modules: package.json
 	:;node $(NPM) prune
 	:;node $(NPM) install --quiet
-	# TODO(aghassemi) Temporarily use local release/javascript/core add github/npm to package.json later
-	cd "$(JIRI_ROOT)/release/javascript/core" && node $(NPM) link
-	:;node $(NPM) link vanadium
 
 	touch node_modules
 
@@ -110,9 +109,20 @@
 	:;bower install --config.interactive=false --quiet
 	touch bower_components
 
-go/bin: directories
+go/bin: $(GO_FILES)
+	jiri go install v.io/x/ref/cmd/principal
 	jiri go install v.io/x/ref/services/mounttable/mounttabled
 	jiri go install v.io/x/browser/runner
+	jiri go install v.io/x/browser/namespace-browserd
+
+credentials: go/bin
+	./go/bin/principal seekblessings
+
+.PHONY: start-browserd
+# Runs namespace browser with the credentials from V23_CREDENTIALS
+start-browserd: credentials go/bin/namespace-browserd
+	./go/bin/namespace-browserd
+
 
 # PHONY targets:
 
diff --git a/bower.json b/bower.json
index e379da3..f0f9b79 100644
--- a/bower.json
+++ b/bower.json
@@ -4,5 +4,8 @@
     "polymer": "Polymer/polymer#0.5.4",
     "core-elements": "Polymer/core-elements#0.5.4",
     "paper-elements": "Polymer/paper-elements#0.5.4"
+  },
+  "resolutions": {
+    "webcomponentsjs": "0.7.1"
   }
 }
diff --git a/go/src/v.io/x/browser/namespace-browserd/main.go b/go/src/v.io/x/browser/namespace-browserd/main.go
new file mode 100644
index 0000000..510f0ad
--- /dev/null
+++ b/go/src/v.io/x/browser/namespace-browserd/main.go
@@ -0,0 +1,294 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"time"
+
+	"v.io/v23"
+	"v.io/v23/context"
+	"v.io/v23/namespace"
+	"v.io/v23/naming"
+	"v.io/v23/rpc"
+	"v.io/v23/vdl"
+	"v.io/v23/vdlroot/signature"
+
+	_ "v.io/x/ref/runtime/factories/generic"
+)
+
+const (
+	RPC_TIMEOUT = 15 // 15 seconds per RPC
+
+	// TODO(alexfandrianto): Make this configurable here and on the JS end.
+	// https://github.com/vanadium/issues/issues/1268
+	SERVER_ADDRESS = "localhost:9002"
+)
+
+type NamespaceBrowser struct {
+	// The base Vanadium context. Used for all RPCs.
+	ctx       *context.T
+	namespace namespace.T
+	client    rpc.Client
+}
+
+// NamespaceBrowser factory
+func NewNamespaceBrowser(ctx *context.T) *NamespaceBrowser {
+	return &NamespaceBrowser{
+		ctx:       ctx,
+		namespace: v23.GetNamespace(ctx),
+		client:    v23.GetClient(ctx),
+	}
+}
+
+func (b *NamespaceBrowser) timed() *context.T {
+	ctx, _ := context.WithTimeout(b.ctx, RPC_TIMEOUT*time.Second)
+	return ctx
+}
+
+func writeAndFlush(rw http.ResponseWriter, data interface{}) {
+	// Make sure that the writer supports flushing.
+	flusher, ok := rw.(http.Flusher)
+	if !ok {
+		http.Error(rw, "The HTTP response writer cannot flush, so we cannot stream results!", http.StatusInternalServerError)
+		return
+	}
+
+	// Write data and flush
+	encoded, err := json.Marshal(data)
+	if err != nil {
+		log.Printf("Failed to encode data: %v, %v", data, err)
+	}
+	fmt.Fprintf(rw, "data: %s\n\n", string(encoded))
+	flusher.Flush()
+}
+
+func extractJsonString(params string) (s string, err error) {
+	err = json.Unmarshal([]byte(params), &s)
+	return
+}
+
+func extractJsonMap(params string) (m map[string]interface{}, err error) {
+	err = json.Unmarshal([]byte(params), &m)
+	return
+}
+
+/* ServeHTTP must handle EventSource requests from the browser.
+ * The requests have a "request" and "params" portion.
+ * The format is as follows:
+ *
+ * accountName: <no parameters>  => { accountName: <string>, err: <err> }
+ * glob: string pattern  => a stream of responses
+ *   { globRes: <glob res>, globErr: <glob err>, globEnd: <bool>, err: <err> }
+ * permissions: string name =>  { permissions: <permissions>, err: <err> }
+ * deleteMountPoint: string name => { err: <err string> }
+ * resolveToMounttable: string name => { addresses: []<string>, err: <err> }
+ * objectAddresses: string name => { addresses: []<string>, err: <err> }
+ * remoteBlessings: string name => { blessings: []<string>, err: <err> }
+ * signature: string name => { signature: <signature>, err: <err> }
+ * makeRPC: { name: <string>, methodName: <string>, args: []<string>,
+ *            numOutArgs: <int> } =>
+ *          { response: <undefined, output, OR []outputs>, err: <err> }
+ */
+func (b *NamespaceBrowser) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	// Set the headers related to event streaming.
+	rw.Header().Set("Content-Type", "text/event-stream")
+	rw.Header().Set("Cache-Control", "no-cache")
+	rw.Header().Set("Connection", "keep-alive")
+	rw.Header().Set("Access-Control-Allow-Origin", "*")
+
+	request, err := url.QueryUnescape(req.FormValue("request"))
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	params, err := url.QueryUnescape(req.FormValue("params"))
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Println("request", request, "params", params)
+
+	// The response depends on the request type.
+	switch request {
+	case "accountName":
+		// Obtain the default blessing and return that.
+		blessing, _ := v23.GetPrincipal(b.ctx).BlessingStore().Default()
+		writeAndFlush(rw, accountNameReturn{AccountName: blessing.String()})
+	case "glob":
+		pattern, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Obtain the glob stream.
+		globCh, err := b.namespace.Glob(b.timed(), pattern)
+		if err != nil {
+			writeAndFlush(rw, globReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+
+		// Afterwards, go through the stream and forward results and errors.
+		writeAndFlush(rw, globReturn{})
+		for entry := range globCh { // These GlobReply could be a reply or an error.
+			switch v := entry.(type) {
+			case *naming.GlobReplyEntry:
+				writeAndFlush(rw, globReturn{GlobRes: &v.Value})
+			case *naming.GlobReplyError:
+				writeAndFlush(rw, globReturn{GlobErr: &v.Value})
+			}
+		}
+		writeAndFlush(rw, globReturn{GlobEnd: true})
+	case "deleteMountPoint":
+		name, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Delete the chosen name from the namespace.
+		err = b.namespace.Delete(b.timed(), name, true)
+		if err != nil {
+			writeAndFlush(rw, deleteReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+		writeAndFlush(rw, deleteReturn{})
+	case "resolveToMounttable":
+		name, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Use the MountEntry for this name to find its server addresses.
+		entry, err := b.namespace.ResolveToMountTable(b.timed(), name)
+		if err != nil {
+			writeAndFlush(rw, addressesReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+		addrs := []string{}
+		for _, server := range entry.Servers {
+			addrs = append(addrs, server.Server)
+		}
+		writeAndFlush(rw, addressesReturn{Addresses: addrs})
+	case "objectAddresses":
+		name, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Use the MountEntry for this name to find its object addresses.
+		entry, err := b.namespace.Resolve(b.timed(), name)
+		if err != nil {
+			writeAndFlush(rw, addressesReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+		addrs := []string{}
+		for _, server := range entry.Servers {
+			addrs = append(addrs, server.Server)
+		}
+		writeAndFlush(rw, addressesReturn{Addresses: addrs})
+	case "permissions":
+		name, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Obtain the mount table permissions at this name.
+		perms, _, err := b.namespace.GetPermissions(b.timed(), name)
+		if err != nil {
+			writeAndFlush(rw, permissionsReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+		writeAndFlush(rw, permissionsReturn{Permissions: perms})
+	case "remoteBlessings":
+		name, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Obtain the remote blessings for the server running at this name.
+		clientCall, err := b.client.StartCall(b.timed(), name, rpc.ReservedMethodSignature, nil)
+		defer clientCall.Finish()
+
+		if err != nil {
+			writeAndFlush(rw, blessingsReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+		rbs, _ := clientCall.RemoteBlessings()
+		writeAndFlush(rw, blessingsReturn{Blessings: rbs})
+	case "signature":
+		name, err := extractJsonString(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		// Obtain the signature(s) of the server running at this name.
+		var sig []signature.Interface
+		err = b.client.Call(b.timed(), name, rpc.ReservedSignature, nil, []interface{}{&sig})
+		if err != nil {
+			writeAndFlush(rw, signatureReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+		convertedSig := convertSignature(sig)
+		writeAndFlush(rw, signatureReturn{Signature: convertedSig})
+	case "makeRPC":
+		data, err := extractJsonMap(params)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		name := data["name"].(string)
+		method := data["methodName"].(string)
+		params := data["args"].([]interface{})
+		fmt.Printf("Make RPC: %s %s %v\n", name, method, params)
+		numOutArgs := int(data["numOutArgs"].(float64))
+
+		// Prepare outargs as *vdl.Value
+		outargs := make([]*vdl.Value, numOutArgs)
+		outptrs := make([]interface{}, numOutArgs)
+		for i := range outargs {
+			outptrs[i] = &outargs[i]
+		}
+
+		// Make the call to name's method with the given params.
+		err = b.client.Call(b.timed(), name, method, params, outptrs)
+		if err != nil {
+			writeAndFlush(rw, makeRPCReturn{Err: fmt.Sprintf("%v", err)})
+			return
+		}
+
+		// Convert the *vdl.Value outputs to readable strings
+		resStrings := []string{}
+		for _, outarg := range outargs {
+			resStrings = append(resStrings, outarg.String())
+		}
+		writeAndFlush(rw, makeRPCReturn{Response: resStrings})
+	default:
+		writeAndFlush(rw, "Please connect from the namespace browser.")
+	}
+
+	// I think this keeps the connection open until the other side closes it?
+	notify := rw.(http.CloseNotifier).CloseNotify()
+	<-notify
+}
+
+func main() {
+	ctx, shutdown := v23.Init()
+	defer shutdown()
+
+	browser := NewNamespaceBrowser(ctx)
+	log.Fatal("HTTP server error: ", http.ListenAndServe(SERVER_ADDRESS, browser))
+}
diff --git a/go/src/v.io/x/browser/namespace-browserd/types.go b/go/src/v.io/x/browser/namespace-browserd/types.go
new file mode 100644
index 0000000..8059e8f
--- /dev/null
+++ b/go/src/v.io/x/browser/namespace-browserd/types.go
@@ -0,0 +1,171 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+/*
+ * Defines types to organize the HTTP response values.
+ * Since json.Marshal only works on exported fields, the types here force the
+ * fields to be converted to lowercase (for better JS consumption).
+ */
+
+import (
+	"v.io/v23/naming"
+	"v.io/v23/security/access"
+	"v.io/v23/vdl"
+	"v.io/v23/vdlroot/signature"
+)
+
+type accountNameReturn struct {
+	AccountName string `json:"accountName"`
+	Err         string `json:"err"`
+}
+
+type globReturn struct {
+	GlobRes *naming.MountEntry `json:"globRes"`
+	GlobErr *naming.GlobError  `json:"globErr"`
+	GlobEnd bool               `json:"globEnd"`
+	Err     string             `json:"err"`
+}
+
+type deleteReturn struct {
+	Err string `json:"err"`
+}
+
+type addressesReturn struct {
+	Addresses []string `json:"addresses"`
+	Err       string   `json:"err"`
+}
+
+type permissionsReturn struct {
+	Permissions access.Permissions `json:"permissions"`
+	Err         string             `json:"err"`
+}
+
+type blessingsReturn struct {
+	Blessings []string `json:"blessings"`
+	Err       string   `json:"err"`
+}
+
+type signatureReturn struct {
+	Signature []pInterface `json:"signature"`
+	Err       string       `json:"err"`
+}
+
+type makeRPCReturn struct {
+	Response []string `json:"response"`
+	Err      string   `json:"err"`
+}
+
+// pInterface describes the signature of an interface.
+// This is a parallel data structure to signature.Interface.
+// The reason to do this is so that Type and Tags can be converted to strings
+// before being sent along the wire.
+type pInterface struct {
+	Name    string    `json:"name"`
+	PkgPath string    `json:"pkgPath"`
+	Doc     string    `json:"doc"`
+	Embeds  []pEmbed  `json:"embeds"`  // No special ordering.
+	Methods []pMethod `json:"methods"` // Ordered by method name.
+}
+
+// pEmbed describes the signature of an embedded interface.
+type pEmbed struct {
+	Name    string `json:"name"`
+	PkgPath string `json:"pkgPath"`
+	Doc     string `json:"doc"`
+}
+
+// pMethod describes the signature of an interface method.
+type pMethod struct {
+	Name      string   `json:"name"`
+	Doc       string   `json:"doc"`
+	InArgs    []pArg   `json:"inArgs"`    // Input arguments
+	OutArgs   []pArg   `json:"outArgs"`   // Output arguments
+	InStream  *pArg    `json:"inStream"`  // Input stream (optional)
+	OutStream *pArg    `json:"outStream"` // Output stream (optional)
+	Tags      []string `json:"tags"`      // Method tags
+}
+
+// pArg describes the signature of a single argument.
+type pArg struct {
+	Name string `json:"name"`
+	Doc  string `json:"doc"`
+	Type string `json:"type"` // Type of the argument.
+}
+
+// Helper method to convert []signature.Interface to the parallel data
+// structure, []pInterface.
+func convertSignature(sig []signature.Interface) []pInterface {
+	ret := []pInterface{}
+	for _, ifc := range sig {
+		pIfc := pInterface{
+			Name:    ifc.Name,
+			PkgPath: ifc.PkgPath,
+			Doc:     ifc.Doc,
+			Embeds:  convertEmbeds(ifc.Embeds),
+			Methods: convertMethods(ifc.Methods),
+		}
+		ret = append(ret, pIfc)
+	}
+	return ret
+}
+
+func convertEmbeds(embeds []signature.Embed) []pEmbed {
+	ret := []pEmbed{}
+	for _, e := range embeds {
+		pE := pEmbed{
+			Name:    e.Name,
+			PkgPath: e.PkgPath,
+			Doc:     e.Doc,
+		}
+		ret = append(ret, pE)
+	}
+	return ret
+}
+
+func convertMethods(methods []signature.Method) []pMethod {
+	ret := []pMethod{}
+	for _, m := range methods {
+		pM := pMethod{
+			Name:      m.Name,
+			Doc:       m.Doc,
+			InArgs:    convertArgs(m.InArgs),
+			OutArgs:   convertArgs(m.OutArgs),
+			InStream:  convertOptArg(m.InStream),
+			OutStream: convertOptArg(m.OutStream),
+			Tags:      convertTags(m.Tags),
+		}
+		ret = append(ret, pM)
+	}
+	return ret
+}
+
+func convertArgs(args []signature.Arg) []pArg {
+	ret := []pArg{}
+	for _, a := range args {
+		pA := *convertOptArg(&a)
+		ret = append(ret, pA)
+	}
+	return ret
+}
+
+func convertOptArg(arg *signature.Arg) *pArg {
+	if arg == nil {
+		return nil
+	}
+	return &pArg{
+		Name: arg.Name,
+		Doc:  arg.Doc,
+		Type: arg.Type.String(),
+	}
+}
+
+func convertTags(tags []*vdl.Value) []string {
+	ret := []string{}
+	for _, t := range tags {
+		ret = append(ret, t.String())
+	}
+	return ret
+}
diff --git a/package.json b/package.json
index 40b83f0..e80e96b 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,6 @@
     "browserify": "^4.2.3",
     "exorcist": "^0.1.6",
     "jshint": "^2.6.0",
-    "prova": "git+https://github.com/aghassemi/prova#0.0.4",
     "proxyquireify": "^0.5.0",
     "rework": "^1.0.1",
     "rework-import": "^1.2.1",
diff --git a/src/app.js b/src/app.js
index 3bd8ef3..1ebb55b 100644
--- a/src/app.js
+++ b/src/app.js
@@ -4,7 +4,6 @@
 
 var uuid = require('uuid');
 var mercury = require('mercury');
-var vanadium = require('vanadium');
 var addDelegatedEvents = require('./lib/mercury/add-delegated-events');
 var onboarding = require('./onboarding');
 var router = require('./router');
@@ -17,7 +16,6 @@
 var views = require('./components/browse/views');
 var userAccount = require('./components/user-account');
 var namespaceService = require('./services/namespace/service');
-var sampleWorld = require('./services/sample-world');
 var stateService = require('./services/state/service');
 var errorRoute = require('./routes/error');
 var browseRoute = require('./routes/browse');
@@ -264,16 +262,9 @@
  */
 function initVanadium() {
   viewport.setSplashMessage('Initializing Vanadium...');
-  namespaceService.initVanadium().then(function(vruntime) {
-    vruntime.once('crash', onVanadiumCrash);
-
+  namespaceService.getEmailAddress().then(function(email) {
     // Onboarding Hook for new users (async). Currently does not block.
-    onboarding(vruntime, state);
-
-    window.addEventListener('beforeunload', function() {
-      log.debug('closing runtime');
-      vruntime.close();
-    });
+    onboarding(email, state);
 
     if (state.demo()) {
       return intializeDemo();
@@ -293,7 +284,10 @@
      * Initialized the demo mode
      */
     function intializeDemo() {
-      viewport.setSplashMessage('Initializing Sample World Demo...');
+      // TODO(alexfandrianto): With JS deprecated, we may want to delete the old
+      // demo code. Instead, demo services should be launched by cmdline or Go.
+      initialized();
+      /*viewport.setSplashMessage('Initializing Sample World Demo...');
       var sampleWorldDirectory = '';
       return sampleWorld.getRootedName().then(function(name) {
         sampleWorldDirectory = name;
@@ -307,22 +301,11 @@
             viewType: 'tree'
           })
         });
-      });
+      });*/
     }
   }).catch(function(err) {
-    if (err instanceof vanadium.verror.ExtensionNotInstalledError) {
-      vanadium.extension.promptUserToInstallExtension();
-    } else {
-      var isError = true;
-      viewport.setSplashMessage(err.toString(), isError);
-      log.error(err);
-    }
+    var isError = true;
+    viewport.setSplashMessage(err.toString(), isError);
+    log.error(err);
   });
 }
-
-/*
- * Handler if Vanadium runtime crashes
- */
-function onVanadiumCrash(crashErr) {
-  events.browse.error(crashErr);
-}
\ No newline at end of file
diff --git a/src/components/browse/item-details/method-form/index.js b/src/components/browse/item-details/method-form/index.js
index 8ab341b..80c5b7d 100644
--- a/src/components/browse/item-details/method-form/index.js
+++ b/src/components/browse/item-details/method-form/index.js
@@ -146,9 +146,12 @@
  */
 function initializeInputArguments(state) {
   var param = getMethodData(state.interface(), state.methodName());
-  var startingArgs = _.range(param.inArgs.length).map(function() {
-    return ''; // Initialize array with empty string values using lodash.
-  });
+  var startingArgs = [];
+  if (param.inArgs) {
+    startingArgs = _.range(param.inArgs.length).map(function() {
+      return ''; // Initialize array with empty string values using lodash.
+    });
+  }
   setMercuryArray(state.args, startingArgs);
 }
 
@@ -161,9 +164,11 @@
     interface: state.interface(),
     methodName: state.methodName(),
   };
+  var inArgList = param.inArgs || [];
+
   return Promise.all(
     // For each argname, predict which inputs should be suggested.
-    param.inArgs.map(function(inArg, i) {
+    inArgList.map(function(inArg, i) {
       return smartService.predict(
         'learner-method-input',
         _.assign({argName: inArg.name}, input)
@@ -388,7 +393,7 @@
   var tooltip = methodSig.doc || '<no description>';
 
   // If the method takes input, add documentation about the input arguments.
-  if (methodSig.inArgs.length > 0) {
+  if (methodSig.inArgs && methodSig.inArgs.length > 0) {
     tooltip += '\n\nParameters';
     methodSig.inArgs.forEach(function(inArg) {
       tooltip += '\n';
@@ -400,7 +405,7 @@
   }
 
   // If the method returns output, add documentation about the output arguments.
-  if (methodSig.outArgs.length > 0) {
+  if (methodSig.outArgs && methodSig.outArgs.length > 0) {
     tooltip += '\n\nOutput';
     methodSig.outArgs.forEach(function(outArg) {
       tooltip += '\n';
@@ -412,11 +417,11 @@
   }
 
   // If the method has tags, show the tag types and values.
-  if (methodSig.tags.length > 0) {
+  if (methodSig.tags && methodSig.tags.length > 0) {
     tooltip += '\n\nTags';
     methodSig.tags.forEach(function(tag) {
       tooltip += '\n';
-      tooltip += '- ' + tag.val + ': ' + tag._type.name;
+      tooltip += '- ' + tag;
     });
   }
 
@@ -459,12 +464,13 @@
   var methodName = state.methodName;
   var param = getMethodData(state.interface, methodName);
   var text = methodName;
-  var hasArgs = (param.inArgs.length > 0);
+  var inArgList = param.inArgs || [];
+  var hasArgs = (inArgList.length > 0);
   if (hasArgs) {
     text += '(';
   }
   if (args !== undefined) {
-    for (var i = 0; i < param.inArgs.length; i++) {
+    for (var i = 0; i < inArgList.length; i++) {
       if (i > 0) {
         text += ', ';
       }
@@ -674,10 +680,13 @@
  * from state.args, a starred invocation's arguments, or a recommendation's.
  */
 function getRunEvent(state, events, args) {
+  var methodData = getMethodData(state.interface, state.methodName);
+  var outArgList = methodData.outArgs || [];
   return mercury.event(events.runAction, {
     name: state.itemName,
     methodName: state.methodName,
-    args: args
+    args: args,
+    numOutArgs: outArgList.length
   });
 }
 
diff --git a/src/components/browse/item-details/method-form/make-rpc.js b/src/components/browse/item-details/method-form/make-rpc.js
index c1b3093..04eed02 100644
--- a/src/components/browse/item-details/method-form/make-rpc.js
+++ b/src/components/browse/item-details/method-form/make-rpc.js
@@ -30,8 +30,8 @@
     }
   });
 
-  return namespaceService.makeRPC(data.name, data.methodName, args).catch(
-    function(err) {
+  return namespaceService.makeRPC(
+    data.name, data.methodName, args, data.numOutArgs).catch(function(err) {
       log.error('Error during RPC',
         data.name,
         data.methodName,
diff --git a/src/components/browse/item-details/mount-point-details/display-mountpoint-details.js b/src/components/browse/item-details/mount-point-details/display-mountpoint-details.js
index 2bd3733..7b83c93 100644
--- a/src/components/browse/item-details/mount-point-details/display-mountpoint-details.js
+++ b/src/components/browse/item-details/mount-point-details/display-mountpoint-details.js
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-var vanadium = require('vanadium');
 var namespaceService = require('../../../../services/namespace/service');
 
 var log = require('../../../../lib/log')(
@@ -74,7 +73,9 @@
         state.put('permissions', permissions);
       }
     }).catch(function(err) {
-      if (err instanceof vanadium.verror.NoAccessError) {
+      // TODO(alexfandrianto): We don't have access to VErrors, so this is the
+      // closest we can get to determining "notAuthorizedToSeePermissions".
+      if (err.toString().contains('NoAccess')) {
         state.put('notAuthorizedToSeePermissions', true);
       }
       log.error('Failed to get mountpoint permissions for:', name, err);
diff --git a/src/onboarding.js b/src/onboarding.js
index 66be5a8..6273fd2 100644
--- a/src/onboarding.js
+++ b/src/onboarding.js
@@ -10,11 +10,11 @@
 module.exports = onboarding;
 
 // When a new user visits the namespace browser, do a simple onboarding.
-function onboarding(rt, appState) {
+function onboarding(email, appState) {
   store.getValue('returning_user').then(function(returning) {
     if (!returning) {
       log.debug('Welcome to the Vanadium Namespace Browser!');
-      addDefaultBookmarks(rt);
+      addDefaultBookmarks(email);
 
       // TODO(alexfandrianto): We can improve the onboarding experience
       // By changing the appState variable, we can do other things to help a new
@@ -27,13 +27,11 @@
 }
 
 // Add default bookmarks to the user's store.
-function addDefaultBookmarks(rt) {
+function addDefaultBookmarks(email) {
   function bookmarkFail(err) {
     log.warn('Could not add default bookmark', err);
   }
 
-  var email = getEmailFromAccountName(rt.accountName);
-
   // Determine the default bookmarks.
   var globalMT = '/ns.dev.v.io:8101';
   var personal;
@@ -61,11 +59,6 @@
   }).catch(bookmarkFail);
 }
 
-function getEmailFromAccountName(accountName) {
-  // Use a regular expression to extract the email.
-  return /dev.v.io\/u\/(.*?)\//.exec(accountName)[1];
-}
-
 // Set the returning_user flag to true.
 function completeOnboarding() {
   store.setValue('returning_user', true).catch(function(err) {
diff --git a/src/services/namespace/interface-util.js b/src/services/namespace/interface-util.js
index be6b62a..0f30ec5 100644
--- a/src/services/namespace/interface-util.js
+++ b/src/services/namespace/interface-util.js
@@ -33,9 +33,10 @@
 function hashInterface(interface) {
   var pkgPath = interface.pkgPath + '.' + interface.name;
   var methods = interface.methods.map(function(methodData) {
+    var inArgList = methodData.inArgs || [];
     return {
       name: methodData.name,
-      inArgs: methodData.inArgs.map(function(inArg) {
+      inArgs: inArgList.map(function(inArg) {
         return inArg.name;
       })
     };
diff --git a/src/services/namespace/naming-util.js b/src/services/namespace/naming-util.js
new file mode 100644
index 0000000..5379fb4
--- /dev/null
+++ b/src/services/namespace/naming-util.js
@@ -0,0 +1,175 @@
+// Copyright 2016 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+ * @fileoverview Helpers for manipulating vanadium names.
+ * See vanadium/release/go/src/v.io/v23/naming/parse.go for the
+ * corresponding operations in golang.
+ * @private
+ */
+
+module.exports = {
+  clean: clean,
+  join: join,
+  isRooted: isRooted,
+  basename: basename,
+  stripBasename: stripBasename,
+  splitAddressName: splitAddressName,
+};
+
+/**
+ * Normalizes a name by collapsing multiple slashes and removing any
+ * trailing slashes.
+ * @param {string} name The vanadium name.
+ * @returns {string} The clean name.
+ * @memberof module:vanadium.naming
+ */
+function clean(name) {
+  return _removeTailSlash(_squashMultipleSlashes(name));
+}
+
+/**
+ * <p>Joins parts of a name into a whole. The joined name will be cleaned; it
+ * only preserved the rootedness of the name components.</p>
+ * <p>Examples:</p>
+ * <pre>
+ * join(['a, b']) -> 'a/b'
+ * join('/a/b/', '//d') -> '/a/b/d'
+ * join('//a/b', 'c/') -> '/a/b/c'
+ * </pre>
+ * @param {...string} parts Either a single array that contains the strings
+ * to join or a variable number of string arguments that will be joined.
+ * @return {string} A joined string.
+ * @memberof module:vanadium.naming
+ */
+function join(parts) {
+  if (Array.isArray(parts)) {
+    while (parts.length > 0 && parts[0] === '') {
+      parts.splice(0, 1); // Remove empty strings; they add nothing to the join.
+    }
+    var joined = parts.join('/');
+    return clean(joined);
+  }
+  return join(Array.prototype.slice.call(arguments));
+}
+
+/**
+ * Determines if a name is rooted, that is beginning with a single '/'.
+ * @param {string} name The vanadium name.
+ * @return {boolean} True iff the name is rooted.
+ * @memberof module:vanadium.naming
+ */
+function isRooted(name) {
+  return name[0] === '/';
+}
+
+/**
+ * SplitAddressName takes an object name and returns the server address and
+ * the name relative to the server.
+ * The name parameter may be a rooted name or a relative name; an empty string
+ * address is returned for the latter case.
+ * @param {string} name The vanadium name.
+ * @return {Object.<string, string>}  An object with the address and suffix
+ * split. Returned object will be in the format of:
+ * <pre>
+ * {address: string, suffix: string}
+ * </pre>
+ * Address may be in endpoint format or host:port format.
+ * @memberof module:vanadium.naming
+ */
+function splitAddressName(name) {
+  name = clean(name);
+
+  if (!isRooted(name)) {
+    return {
+      address: '',
+      suffix: name
+    };
+  }
+  name = name.substr(1); // trim the beginning "/"
+  if (name.length === 0) {
+    return {
+      address: '',
+      suffix: ''
+    };
+  }
+
+  if (name[0] === '@') { // <endpoint>/<suffix>
+    var split = _splitIntoTwo(name, '@@/');
+    if (split.suffix.length > 0) { // The trailing "@@" was stripped, restore
+      split.address = split.address + '@@';
+    }
+    return split;
+  }
+  if (name[0] === '(') { // (blessing)@host:[port]/suffix
+    var tmp = _splitIntoTwo(name, ')@').suffix;
+    var suffix = _splitIntoTwo(tmp, '/').suffix;
+    return {
+      address: _trimEnd(name, '/' + suffix),
+      suffix: suffix
+    };
+  }
+  // host:[port]/suffix
+  return _splitIntoTwo(name, '/');
+
+  function _splitIntoTwo(str, separator) {
+    var elems = str.split(separator);
+    return {
+      address: elems[0],
+      suffix: elems.splice(1).join(separator)
+    };
+  }
+}
+
+/**
+ * Gets the basename of the given vanadium name.
+ * @param {string} name The vanadium name.
+ * @return {string} The basename of the given name.
+ * @memberof module:vanadium.naming
+ */
+function basename(name) {
+  name = clean(name);
+  var split = splitAddressName(name);
+  if (split.suffix !== '') {
+    return split.suffix.substring(split.suffix.lastIndexOf('/') + 1);
+  } else {
+    return split.address;
+  }
+}
+
+/**
+ * Retrieves the parent of the given name.
+ * @param {string} name The vanadium name.
+ * @return {string | null} The parent's name or null, if there isn't one.
+ * @memberof module:vanadium.naming
+ */
+function stripBasename(name) {
+  name = clean(name);
+  var split = splitAddressName(name);
+  if (split.suffix !== '') {
+    return name.substring(0, name.lastIndexOf('/'));
+  } else {
+    return '';
+  }
+}
+
+// Replace every group of slashes in the string with a single slash.
+function _squashMultipleSlashes(s) {
+  return s.replace(/\/{2,}/g, '/');
+}
+
+// Remove the last slash in the string, if any.
+function _removeTailSlash(s) {
+  return s.replace(/\/$/g, '');
+}
+
+// Helper util that removes the given suf from the end of str
+function _trimEnd(str, suf) {
+  var index = str.lastIndexOf(suf);
+  if (index + suf.length === str.length) {
+    return str.substring(0, index);
+  } else {
+    return str;
+  }
+}
diff --git a/src/services/namespace/service.js b/src/services/namespace/service.js
index 97451fe..7c418fe 100644
--- a/src/services/namespace/service.js
+++ b/src/services/namespace/service.js
@@ -2,16 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-var vanadium = require('vanadium');
 var mercury = require('mercury');
 var LRU = require('lru-cache');
 var EventEmitter = require('events').EventEmitter;
-var vanadiumConfig = require('../../vanadium-config');
 var itemFactory = require('./item');
 var freeze = require('../../lib/mercury/freeze');
 var sortedPush = require('../../lib/mercury/sorted-push-array');
 var log = require('../../lib/log')('services:namespace:service');
-var naming = vanadium.naming;
+var naming = require('./naming-util.js');
 naming.parseName = parseName;
 
 module.exports = {
@@ -20,42 +18,97 @@
   getRemoteBlessings: getRemoteBlessings,
   getSignature: getSignature,
   getAccountName: getAccountName,
+  getEmailAddress: getEmailAddress,
   getObjectAddresses: getObjectAddresses,
   getPermissions: getPermissions,
   resolveToMounttable: resolveToMounttable,
   makeRPC: makeRPC,
   search: search,
   util: naming,
-  initVanadium: getRuntime,
   clearCache: clearCache,
   deleteMountPoint: deleteMountPoint,
   prefixes: prefixes
 };
 
-//TODO(aghassemi) What's a good timeout? It should be shorter than this.
-//Can we use ML to dynamically change the timeout?
-//Should this be a user settings?
-var RPC_TIMEOUT = 15 * 1000;
 
 /*
- * Lazy getter and initializer for Vanadium runtime
+ * Returns an EventSource object connected to the local network.
+ * Only certain types of requests are allowed.
+ *
+ * accountName: <no parameters>  => { accountName: <string>, err: <err> }
+ * glob: string pattern  => a stream of responses
+ *   { globRes: <glob res>, globErr: <glob err>, globEnd: <bool>, err: <err> }
+ * permissions: string name =>  { permissions: <permissions>, err: <err> }
+ * deleteMountPoint: string name => { err: <err string> }
+ * resolveToMounttable: string name => { addresses: []<string>, err: <err> }
+ * objectAddresses: string name => { addresses: []<string>, err: <err> }
+ * remoteBlessings: string name => { blessings: []<string>, err: <err> }
+ * signature: string name => { signature: <signature>, err: <err> }
+ * makeRPC: { name: <string>, methodName: <string>, args: []<string>,
+ *            numOutArgs: <int> } =>
+ *          { response: <undefined, output, OR []outputs>, err: <err> }
  */
-var _runtimePromiseInstance;
+// TODO(alexfandrianto): Make this configurable here and on the Go end.
+// https://github.com/vanadium/issues/issues/1268
+var eventSourceURL = 'http://127.0.0.1:9002';
+function connectToEventSource(requestType, parameters) {
+  parameters = parameters || '';
+  var requestData = eventSourceURL +
+    '?request=' + encodeURIComponent(requestType) +
+    '&params=' + encodeURIComponent(JSON.stringify(parameters));
 
-function getRuntime() {
-  if (!_runtimePromiseInstance) {
-    _runtimePromiseInstance = vanadium.init(vanadiumConfig);
-  }
-  return _runtimePromiseInstance;
+  // Create the EventSource. Note: node does not have EventSource.
+  return new EventSource(requestData); // jshint ignore:line
+}
+
+/*
+ * Returns a Promise<value> drawn from the connected Event Source.
+ * See connectToEventSource.
+ */
+function getSingleEvent(type, params, field) {
+  return new Promise(function(resolve, reject) {
+    var ev = connectToEventSource(type, params);
+    ev.addEventListener('message', function(message) {
+      ev.close();
+      try {
+        var data = JSON.parse(message.data);
+        if (data.err) {
+          reject(data.err);
+        } else {
+          resolve(data[field]);
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+    ev.addEventListener('error', function(err) {
+      ev.close();
+      reject(err);
+    });
+  });
 }
 
 /*
  * Returns the accountName for the currently logged in user
  * @return {Promise.<string>}
  */
+var _accountNamePromise;
 function getAccountName() {
-  return getRuntime().then(function(rt) {
-    return rt.accountName;
+  if (!_accountNamePromise) {
+    _accountNamePromise =
+      getSingleEvent('accountName', undefined, 'accountName');
+  }
+  return _accountNamePromise;
+}
+
+/*
+ * Returns the email address for the currently logged in user
+ * @return {Promise.<string>}
+ */
+function getEmailAddress() {
+  return getAccountName().then(function(accountName) {
+    // TODO(alexfandrianto): Assumes a lot about the format of the blessings.
+    return accountName.split(':')[2];
   });
 }
 
@@ -104,43 +157,92 @@
   var globItemsObservArr = mercury.array([]);
   var immutableResult = freeze(globItemsObservArr);
   immutableResult.events = new EventEmitter();
-  var ctx;
   var globItemsObservArrPromise =
-    getRuntime().then(function callGlobOnNamespace(rt) {
-      ctx = rt.getContext().withTimeout(RPC_TIMEOUT);
-      // TODO(aghassemi) use watchGlob when available
-      var namespace = rt.getNamespace();
-      return namespace.glob(ctx, pattern).stream;
-    }).then(function updateResult(globStream) {
-      globStream.on('data', function createItem(globResult) {
-        // Create an item as glob results come in and add the item to result
-        var item = createNamespaceItem(globResult);
+    Promise.resolve().then(function callGlobOnNamespace() {
+      return new Promise(function (resolve, reject) {
+        var ev = connectToEventSource('glob', pattern);
+        ev.addEventListener('error', function(err) {
+          ev.close();
+          reject(err);
+        });
 
-        var existingItem = globItemsObservArr.filter(function(curItem) {
-          return curItem().objectName === item().objectName;
-        }).get(0);
-        if (existingItem) {
-          // override the old one if new item has server
-          if (item().hasServer) {
-            var index = globItemsObservArr.indexOf(existingItem);
-            globItemsObservArr.put(index, item);
+        function handleMessageConnectionResponse(response) {
+          try {
+            var data = JSON.parse(response.data);
+            if (data.err) {
+              ev.close();
+              reject(data.err);
+            } else {
+              // We have successfully established the stream.
+              // Keep the event source open to listen for more.
+              resolve();
+            }
+          } catch (err) {
+            ev.close();
+            reject(err);
           }
-        } else {
-          var sorter = 'mountedName';
-          sortedPush(globItemsObservArr, item, sorter);
         }
-      });
 
-      globStream.on('end', function() {
-        immutableResult.events.emit('end');
-        immutableResult._hasEnded = true;
-      });
+        function handleStreamEvent(message) {
+          try {
+            var data = JSON.parse(message.data);
 
-      globStream.on('error', function emitGlobErrorAndLog(err) {
-        immutableResult.events.emit('globError', err);
-        log.warn('Glob stream error for', name, err);
-      });
+            if (data.globRes) {
+              var globResult = data.globRes;
 
+              // Handle a glob result by creating an item.
+              var item = createNamespaceItem(lowercasifyJSONObject(globResult));
+
+              var existingItem = globItemsObservArr.filter(function(curItem) {
+                return curItem().objectName === item().objectName;
+              }).get(0);
+              if (existingItem) {
+                // override the old one if new item has server
+                if (item().hasServer) {
+                  var index = globItemsObservArr.indexOf(existingItem);
+                  globItemsObservArr.put(index, item);
+                }
+              } else {
+                var sorter = 'mountedName';
+                sortedPush(globItemsObservArr, item, sorter);
+              }
+
+            } else if (data.globErr) {
+              var err = data.globErr;
+              // Handle a glob error by emitting that event.
+              immutableResult.events.emit('globError', err);
+              log.warn('Glob stream error', err);
+            } else if (data.globEnd) {
+              // Handle a glob end by emitting it. Close event source.
+              immutableResult.events.emit('end');
+              immutableResult._hasEnded = true;
+              ev.close();
+            } else {
+              // There was a data error. Close event source.
+              log.error('Event source error for', name, data.err);
+              ev.close();
+
+              // If this were an RPC, we probably would have failed earlier.
+              // So, we must also clear the cache key.
+              globCache.del(cacheKey);
+            }
+          } catch (err) {
+            log.error(err);
+          }
+        }
+
+        var initialResponse = false;
+        ev.addEventListener('message', function(response) {
+          if (!initialResponse) {
+            // Check whether the RPC and stream connection was established.
+            initialResponse = true;
+            handleMessageConnectionResponse(response);
+          } else {
+            // Handle the Glob Results and Errors from the stream.
+            handleStreamEvent(response);
+          }
+        });
+      });
     }).then(function cacheAndReturnResult() {
       globCache.set(cacheKey, immutableResult);
       return immutableResult;
@@ -215,28 +317,29 @@
  * vanadium.security.Permissions object.
  */
 function getPermissions(name) {
-  return getRuntime().then(function(rt) {
-    var ctx = rt.getContext().withTimeout(RPC_TIMEOUT);
-    var ns = rt.getNamespace();
-    return ns.getPermissions(ctx, name);
-  }).then(function(results) {
-    // getPermissions return multiple results, permissions is at
-    // outArg position 0
-    return mercury.value(results[0]);
+  return getSingleEvent('permissions', name, 'permissions').then(
+    function(perms) {
+      // perms is an object, but we want a map instead.
+      var p2 = new Map();
+      for (var key in perms) {
+        if (perms.hasOwnProperty(key)) {
+          p2.set(key, lowercasifyJSONObject(perms[key]));
+        }
+      }
+      return mercury.value(p2);
   });
 }
 
+
+
 /*
  * Deletes a mount point.
  * @param {string} name mountpoint name to delete.
  * @return {Promise<void>} Success or failure promise.
  */
 function deleteMountPoint(name) {
-  return getRuntime().then(function(rt) {
-    var ctx = rt.getContext().withTimeout(RPC_TIMEOUT);
-    var ns = rt.getNamespace();
-    return ns.delete(ctx, name, true);
-  });
+  // Note: The return value on success is undefined.
+  return getSingleEvent('deleteMountPoint', name, 'deleteMountPoint');
 }
 
 /*
@@ -246,12 +349,9 @@
  * objectAddress strings.
  */
 function resolveToMounttable(name) {
-  return getRuntime().then(function(rt) {
-    var ctx = rt.getContext().withTimeout(RPC_TIMEOUT);
-    var ns = rt.getNamespace();
-    return ns.resolveToMounttable(ctx, name);
-  }).then(function(objectAddresses) {
-    return mercury.array(objectAddresses);
+  return getSingleEvent('resolveToMounttable', name, 'addresses').then(
+    function(objectAddresses) {
+      return mercury.array(objectAddresses);
   });
 }
 
@@ -262,12 +362,9 @@
  * array of string objectAddresses
  */
 function getObjectAddresses(name) {
-  return getRuntime().then(function resolve(rt) {
-    var resolveCtx = rt.getContext().withTimeout(RPC_TIMEOUT);
-    var ns = rt.getNamespace();
-    return ns.resolve(resolveCtx, name);
-  }).then(function(objectAddresses) {
-    return mercury.array(objectAddresses);
+  return getSingleEvent('objectAddresses', name, 'addresses').then(
+    function(objectAddresses) {
+      return mercury.array(objectAddresses);
   });
 }
 
@@ -292,14 +389,11 @@
   if (cacheHit) {
     return Promise.resolve(cacheHit);
   }
-  return getRuntime().then(function invokeRemoteBlessingsMethod(rt) {
-    var ctx = rt.getContext().withTimeout(RPC_TIMEOUT);
-    var client = rt.getClient();
-    return client.remoteBlessings(ctx, objectName);
-  }).then(function cacheAndReturnRemoteBlessings(remoteBlessings) {
-    // Remote Blessings is []string representing the principals of the service.
-    remoteBlessingsCache.set(cacheKey, remoteBlessings);
-    return remoteBlessings;
+  return getSingleEvent('remoteBlessings', objectName, 'blessings').then(
+    function cacheAndReturnRemoteBlessings(remoteBlessings) {
+      // Remote Blessings is []string of the service's blessings.
+      remoteBlessingsCache.set(cacheKey, remoteBlessings);
+      return remoteBlessings;
   });
 }
 
@@ -324,40 +418,66 @@
   if (cacheHit) {
     return Promise.resolve(cacheHit);
   }
-  return getRuntime().then(function invokeSignatureMethod(rt) {
-    var ctx = rt.getContext().withTimeout(RPC_TIMEOUT);
-    var client = rt.getClient();
-    return client.signature(ctx, objectName);
-  }).then(function cacheAndReturnSignature(signature) {
-    // Signature is []interface; each interface contains method data.
-    signatureCache.set(cacheKey, signature);
-    return signature;
+  return getSingleEvent('signature', objectName, 'signature').then(
+    function cacheAndReturnSignature(signature) {
+      // Signature is []interface; each interface contains method data.
+      signatureCache.set(cacheKey, signature);
+      return signature;
   });
 }
 
+// Go through the JSON object and lowercase everything recursively.
+// We need this because it is annoying to change every Go struct to have the
+// json annotation to lowercase its field name.
+function lowercasifyJSONObject(obj) {
+  // number, string, boolean, or null
+  if (typeof obj !== 'object' || obj === null) {
+    return obj; // It's actually primitive.
+  }
+
+  // array
+  if (Array.isArray(obj)) {
+    var a = [];
+    for (var i = 0; i < obj.length; i++) {
+      a[i] = lowercasifyJSONObject(obj[i]);
+    }
+    return a;
+  }
+
+  // object
+  var cp = {};
+  for (var k in obj) {
+    if (obj.hasOwnProperty(k)) {
+      var lowerK = k[0].toLowerCase() + k.substr(1);
+      cp[lowerK] = lowercasifyJSONObject(obj[k]);
+    }
+  }
+  return cp;
+}
+
 /*
  * Make an RPC call on a service object.
  * name: string representing the name of the service
  * methodName: string for the service method name
  * args (optional): array of arguments for the service method
  */
-function makeRPC(name, methodName, args) {
-  // Adapt the method name to be lowercase again.
-  methodName = methodName[0].toLowerCase() + methodName.substr(1);
-
-  var ctx;
-  return getRuntime().then(function bindToName(rt) {
-    ctx = rt.getContext();
-    var client = rt.getClient();
-    return client.bindTo(ctx, name);
-  }).then(function callMethod(service) {
-    log.debug('Calling', methodName, 'on', name, 'with', args);
-    args.unshift(ctx.withTimeout(RPC_TIMEOUT));
-    return service[methodName].apply(null, args);
-  }).then(function returnResult(result) {
+function makeRPC(name, methodName, args, numOutArgs) {
+  log.debug('Calling', methodName, 'on', name, 'with', args, 'for', numOutArgs);
+  var call = {
+    name: name,
+    methodName: methodName,
+    args: args,
+    numOutArgs: numOutArgs
+  };
+  return getSingleEvent('makeRPC', call, 'response').then(function (result) {
     // If the result was for 0 outArg, then this returns undefined.
     // If the result was for 1 outArg, then it gets a single output.
     // If the result was for >1 outArgs, then we return []output.
+    if (numOutArgs === 0) {
+      return;
+    } else if (numOutArgs === 1) {
+      return result[0];
+    }
     return result;
   });
 }
@@ -371,18 +491,16 @@
  * about an item.
  */
 function createNamespaceItem(mountEntry) {
-
   var name = mountEntry.name;
 
   // mounted name relative to parent
   var mountedName = naming.basename(name);
   var isLeaf = mountEntry.isLeaf;
-  var hasServer = mountEntry.servers.length > 0 ||
-    !mountEntry.servesMountTable;
-  var hasMountPoint = mountEntry.servers.length > 0 ||
-    mountEntry.servesMountTable;
-  var isMounttable = mountEntry.servers.length > 0 &&
-    mountEntry.servesMountTable;
+  var hasServers = (mountEntry.servers && mountEntry.servers.length > 0);
+
+  var hasServer = hasServers || !mountEntry.servesMountTable;
+  var hasMountPoint = hasServers || mountEntry.servesMountTable;
+  var isMounttable = hasServers && mountEntry.servesMountTable;
 
   var item = itemFactory.createItem({
     objectName: name,
@@ -399,8 +517,8 @@
 /*
  * Given an arbitrary Vanadium name, parses it into an array
  * of strings.
- * For example, if name is "/ns.dev.v.io:8101/global/rps"
- * returns ["ns.dev.v.io:8101", "global", "rps"]
+ * For example, if name is '/ns.dev.v.io:8101/global/rps'
+ * returns ['ns.dev.v.io:8101', 'global', 'rps']
  * Can use namespaceService.util.isRooted to see if the name
  * is rooted (begins with a slash).
  * Note that the address part can contain slashes.
diff --git a/src/vanadium-config.js b/src/vanadium-config.js
deleted file mode 100644
index 04d6d21..0000000
--- a/src/vanadium-config.js
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-var logLevels = require('vanadium').vlog.levels;
-var vanadiumConfig = {
-  logLevel: logLevels.INFO
-};
-
-module.exports = vanadiumConfig;