diff --git a/lib/modules/core/core_test.go b/lib/modules/core/core_test.go
index 23037c0..d8a2a1d 100644
--- a/lib/modules/core/core_test.go
+++ b/lib/modules/core/core_test.go
@@ -241,7 +241,7 @@
 	srvSession := expect.NewSession(t, srv.Stdout(), time.Minute)
 	srvSession.ExpectVar("NAME")
 	addr := srvSession.ExpectVar("ADDR")
-	addr = naming.JoinAddressName(addr, "//")
+	addr = naming.JoinAddressName(addr, "")
 
 	// Resolve an object
 	resolver, err := sh.Start(core.ResolveCommand, nil, rootName+"/"+echoName)
@@ -260,7 +260,7 @@
 	}
 
 	// Resolve to a mount table using a rooted name.
-	addr = naming.JoinAddressName(mountAddrs[mtName], "//echo")
+	addr = naming.JoinAddressName(mountAddrs[mtName], "echo")
 	resolver, err = sh.Start(core.ResolveMTCommand, nil, rootName+"/"+echoName)
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
diff --git a/lib/modules/core/echo.go b/lib/modules/core/echo.go
index 1062779..b1b8877 100644
--- a/lib/modules/core/echo.go
+++ b/lib/modules/core/echo.go
@@ -59,7 +59,7 @@
 	if err := server.ServeDispatcher(mp, disp); err != nil {
 		return err
 	}
-	fmt.Fprintf(stdout, "NAME=%s\n", naming.MakeTerminal(naming.JoinAddressName(ep.String(), "")))
+	fmt.Fprintf(stdout, "NAME=%s\n", naming.JoinAddressName(ep.String(), ""))
 	fmt.Fprintf(stdout, "ADDR=%s\n", ep.String())
 	fmt.Fprintf(stdout, "PID=%d\n", os.Getpid())
 	modules.WaitForEOF(stdin)
diff --git a/runtimes/google/ipc/full_test.go b/runtimes/google/ipc/full_test.go
index 19252f1..2c721d9 100644
--- a/runtimes/google/ipc/full_test.go
+++ b/runtimes/google/ipc/full_test.go
@@ -1112,8 +1112,6 @@
 	}{
 		{"[foo/bar]", "", "foo/bar", ""},
 		{"[x/y/...]/", "x/y/...", "", "/"},
-		{"[foo/...]//", "", "foo/...", "//"},
-		{"[foo]//abc@@/foo", "", "foo", "//abc@@/foo"},
 		{"[foo]a", "", "foo", "a"},
 		{"[foo]/a", "foo", "", "/a"},
 		{"[foo]/a/[bar]", "foo", "bar", "/a"},
diff --git a/runtimes/google/ipc/server.go b/runtimes/google/ipc/server.go
index 840ddd0..be28592 100644
--- a/runtimes/google/ipc/server.go
+++ b/runtimes/google/ipc/server.go
@@ -391,13 +391,9 @@
 	return ep, nil
 }
 
+// TODO(cnicolaou): Take this out or make the ServesMountTable bit work in the endpoint.
 func (s *server) publishEP(ep *inaming.Endpoint, servesMountTable bool) string {
 	var name string
-	if !s.servesMountTable {
-		// Make sure that client MountTable code doesn't try and
-		// ResolveStep past this final address.
-		name = "//"
-	}
 	ep.IsMountTable = servesMountTable
 	return naming.JoinAddressName(ep.String(), name)
 }
diff --git a/runtimes/google/lib/publisher/publisher.go b/runtimes/google/lib/publisher/publisher.go
index 96e39f4..eece0f7 100644
--- a/runtimes/google/lib/publisher/publisher.go
+++ b/runtimes/google/lib/publisher/publisher.go
@@ -213,7 +213,6 @@
 	deadline time.Time                 // deadline for the next sync call
 	names    map[string]bool           // names that have been added
 	servers  map[string]bool           // servers that have been added, true
-	servesMT map[string]bool           // true if server is a mount table server
 	mounts   map[mountKey]*mountStatus // map each (name,server) to its status
 	//   if server is a mount table server
 }
diff --git a/runtimes/google/naming/namespace/all_test.go b/runtimes/google/naming/namespace/all_test.go
index cf66324..da85431 100644
--- a/runtimes/google/naming/namespace/all_test.go
+++ b/runtimes/google/naming/namespace/all_test.go
@@ -197,9 +197,6 @@
 		boom(t, "Failed to serve mount table at %s: %s", mountPoint, err)
 	}
 	name := naming.JoinAddressName(ep.String(), "")
-	if !mt {
-		name = name + "//"
-	}
 	return &serverEntry{mountPoint: mountPoint, server: s, endpoint: ep, name: name}
 }
 
@@ -291,21 +288,17 @@
 	// as the address portion of the terminal name for those mounttables.
 	testResolveToMountTable(t, r, ns, "", root.name)
 	for _, m := range []string{mt2MP, mt3MP, mt5MP} {
-		rootMT := naming.MakeTerminal(naming.Join(root.name, m))
+		rootMT := naming.Join(root.name, m)
 		// All of these mount tables are hosted by the root mount table
 		testResolveToMountTable(t, r, ns, m, rootMT)
-		testResolveToMountTable(t, r, ns, "//"+m, rootMT)
 
 		// The server registered for each mount point is a mount table
 		testResolve(t, r, ns, m, mts[m].name)
 
 		// ResolveToMountTable will walk through to the sub MountTables
 		mtbar := naming.Join(m, "bar")
-		subMT := naming.MakeTerminal(naming.Join(mts[m].name, "bar"))
+		subMT := naming.Join(mts[m].name, "bar")
 		testResolveToMountTable(t, r, ns, mtbar, subMT)
-
-		// ResolveToMountTable will not walk through if the name is terminal
-		testResolveToMountTable(t, r, ns, "//"+mtbar, naming.Join(rootMT, "bar"))
 	}
 
 	for _, j := range []string{j1MP, j2MP, j3MP} {
@@ -343,7 +336,7 @@
 		boom(t, "Failed to Mount %s: %s", mt2a, err)
 	}
 
-	mt2mt := naming.MakeTerminal(naming.Join(mts[mt2MP].name, "a"))
+	mt2mt := naming.Join(mts[mt2MP].name, "a")
 	// The mt2/a is served by the mt2 mount table
 	testResolveToMountTable(t, r, ns, mt2a, mt2mt)
 	// The server for mt2a is mt3server from the second mount above.
@@ -365,9 +358,9 @@
 
 	// We now have 3 mount tables prepared to serve mt2/a
 	testResolveToMountTable(t, r, ns, "mt2/a",
-		mts[mt2MP].name+"//a",
-		mts[mt4MP].name+"//a",
-		mts[mt5MP].name+"//a")
+		naming.JoinAddressName(mts[mt2MP].name, "a"),
+		naming.JoinAddressName(mts[mt4MP].name, "a"),
+		naming.JoinAddressName(mts[mt5MP].name, "a"))
 	testResolve(t, r, ns, "mt2", mts[mt2MP].name, mts[mt4MP].name, mts[mt5MP].name)
 }
 
@@ -388,10 +381,11 @@
 	}
 
 	testResolveToMountTable(t, r, ns, "mt4/foo",
-		mts[mt4MP].name+"//foo")
+		naming.JoinAddressName(mts[mt4MP].name, "foo"))
 	testResolveToMountTable(t, r, ns, "mt4/foo/bar",
-		mts["mt4/foo"].name+"//bar")
-	testResolveToMountTable(t, r, ns, "mt4/foo/baz", mts["mt4/foo"].name+"//baz")
+		naming.JoinAddressName(mts["mt4/foo"].name, "bar"))
+	testResolveToMountTable(t, r, ns, "mt4/foo/baz",
+		naming.JoinAddressName(mts["mt4/foo"].name, "baz"))
 }
 
 // TestServers tests invoking RPCs on simple servers
@@ -413,8 +407,8 @@
 		jokes[gj] = runServer(t, r, disp, globalName)
 		testResolve(t, r, ns, "mt4/"+j, jokes[gj].name)
 		knockKnock(t, r, "mt4/"+j)
-		testResolveToMountTable(t, r, ns, "mt4/"+j, naming.MakeTerminal(globalName))
-		testResolveToMountTable(t, r, ns, "mt4/"+j+"/garbage", naming.MakeTerminal(globalName+"/garbage"))
+		testResolveToMountTable(t, r, ns, "mt4/"+j, globalName)
+		testResolveToMountTable(t, r, ns, "mt4/"+j+"/garbage", globalName+"/garbage")
 	}
 }
 
diff --git a/runtimes/google/naming/namespace/cache.go b/runtimes/google/naming/namespace/cache.go
index be7b469..8d5293f 100644
--- a/runtimes/google/naming/namespace/cache.go
+++ b/runtimes/google/naming/namespace/cache.go
@@ -45,15 +45,6 @@
 	return false
 }
 
-// normalize removes any single trailing slash.  Added for idiots who seem to
-// like adding trailing slashes.
-func normalize(name string) string {
-	if strings.HasSuffix(name, "//") {
-		return name
-	}
-	return strings.TrimSuffix(name, "/")
-}
-
 // randomDrop randomly removes one cache entry.  Assumes we've already locked the cache.
 func (c *ttlCache) randomDrop() {
 	n := rand.Intn(len(c.entries))
@@ -90,6 +81,7 @@
 	// Remove suffix.  We only care about the name that gets us
 	// to the mounttable from the last mounttable.
 	prefix = normalize(prefix)
+	entry.Name = normalize(entry.Name)
 	prefix = naming.TrimSuffix(prefix, entry.Name)
 	// Copy the entry.
 	var ce naming.MountEntry
@@ -97,8 +89,6 @@
 		ce.Servers = append(ce.Servers, s)
 	}
 	ce.SetServesMountTable(entry.ServesMountTable())
-	// All keys must be terminal.
-	prefix = naming.MakeTerminal(prefix)
 	c.Lock()
 	// Enforce an upper limit on the cache size.
 	if len(c.entries) >= maxCacheEntries {
diff --git a/runtimes/google/naming/namespace/cache_test.go b/runtimes/google/naming/namespace/cache_test.go
index 0f4cffd..e12cd69 100644
--- a/runtimes/google/naming/namespace/cache_test.go
+++ b/runtimes/google/naming/namespace/cache_test.go
@@ -46,8 +46,8 @@
 		{"/h2//c/d", "d", "/h3", true},
 		{"/h3//d", "", "/h4:1234", true},
 		{"/notintcache", "", "", false},
-		{"/h1//a/b/f//g", "f//g", "/h2", true},
-		{"/h3//d//e", "//e", "/h4:1234", true},
+		{"/h1//a/b/f//g", "f/g", "/h2", true},
+		{"/h3//d//e", "e", "/h4:1234", true},
 	}
 	for _, p := range tests {
 		e, err := c.lookup(p.name)
diff --git a/runtimes/google/naming/namespace/namespace.go b/runtimes/google/naming/namespace/namespace.go
index 1b966d7..7458858 100644
--- a/runtimes/google/naming/namespace/namespace.go
+++ b/runtimes/google/naming/namespace/namespace.go
@@ -1,6 +1,7 @@
 package namespace
 
 import (
+	"strings"
 	"sync"
 	"time"
 
@@ -96,6 +97,7 @@
 // rootName 'roots' a name: if name is not a rooted name, it prepends the root
 // mounttable's OA.
 func (ns *namespace) rootName(name string) []string {
+	name = normalize(name)
 	if address, _ := naming.SplitAddressName(name); len(address) == 0 {
 		var ret []string
 		ns.RLock()
@@ -110,6 +112,7 @@
 
 // rootMountEntry 'roots' a name creating a mount entry for the name.
 func (ns *namespace) rootMountEntry(name string) (*naming.MountEntry, bool) {
+	name = normalize(name)
 	e := new(naming.MountEntry)
 	expiration := time.Now().Add(time.Hour) // plenty of time for a call
 	address, suffix := naming.SplitAddressName(name)
@@ -178,3 +181,21 @@
 	}
 	return nil
 }
+
+// normalize removes any single trailing slash and compresses
+// multiple consecutive slashes to one.
+// TODO(p): Transitionally it also removes a leading double
+// slash that used to mean something but doesn't any more.
+// I should remove that in a week or so when we've killed off
+// all code inserting this double slash.
+func normalize(name string) string {
+	// Eradicate leading double slash (for now).  Eventually we
+	// should get ris of this.
+	name = strings.TrimPrefix(name, "//")
+	// Eradicate duplicate slashes and trailing slashes.  We
+	// could use path.Clean but it has other side effects.
+	for strings.Contains(name, "//") {
+		name = strings.Replace(name, "//", "/", -1)
+	}
+	return strings.TrimSuffix(name, "/")
+}
diff --git a/runtimes/google/naming/namespace/resolve.go b/runtimes/google/naming/namespace/resolve.go
index 5943b6a..1d6e572 100644
--- a/runtimes/google/naming/namespace/resolve.go
+++ b/runtimes/google/naming/namespace/resolve.go
@@ -58,12 +58,7 @@
 }
 
 func terminal(e *naming.MountEntry) bool {
-	for _, s := range e.Servers {
-		if !naming.Terminal(naming.JoinAddressName(s.Server, e.Name)) {
-			return false
-		}
-	}
-	return true
+	return len(e.Name) == 0
 }
 
 // ResolveX implements veyron2/naming.Namespace.
@@ -130,7 +125,7 @@
 	}
 	last := e
 	for remaining := ns.maxResolveDepth; remaining > 0; remaining-- {
-		vlog.VI(2).Infof("ResolveToMountTable(%s) loop %v", name, e)
+		vlog.VI(2).Infof("ResolveToMountTableX(%s) loop %v", name, e)
 		var err error
 		curr := e
 		// If the next name to resolve doesn't point to a mount table, we're done.
@@ -245,7 +240,6 @@
 		// Walk the cache as we would in a resolution.  Unlike a resolution, we have to follow
 		// all branches since we want to flush all entries at which we might end up whereas in a resolution,
 		// we stop with the first branch that works.
-		n := naming.MakeTerminal(n)
 		if e, err := ns.resolutionCache.lookup(n); err == nil {
 			// Recurse.
 			for _, s := range e.Servers {
diff --git a/services/mgmt/node/impl/config_invoker.go b/services/mgmt/node/impl/config_invoker.go
index 7e191ac..97ccc35 100644
--- a/services/mgmt/node/impl/config_invoker.go
+++ b/services/mgmt/node/impl/config_invoker.go
@@ -78,7 +78,7 @@
 
 func (c *callbackState) listenFor(key string) callbackListener {
 	id := c.generateID()
-	callbackName := naming.MakeTerminal(naming.Join(c.name, configSuffix, id))
+	callbackName := naming.Join(c.name, configSuffix, id)
 	// Make the channel buffered to avoid blocking the Set method when
 	// nothing is receiving on the channel.  This happens e.g. when
 	// unregisterCallbacks executes before Set is called.
diff --git a/services/mgmt/node/impl/impl_test.go b/services/mgmt/node/impl/impl_test.go
index 600dd5c..a5670c2 100644
--- a/services/mgmt/node/impl/impl_test.go
+++ b/services/mgmt/node/impl/impl_test.go
@@ -143,7 +143,7 @@
 	defer rt.R().Cleanup()
 	server, endpoint := newServer()
 	defer server.Stop()
-	name := naming.MakeTerminal(naming.JoinAddressName(endpoint, ""))
+	name := naming.JoinAddressName(endpoint, "")
 	vlog.VI(1).Infof("Node manager name: %v", name)
 
 	// Satisfy the contract described in doc.go by passing the config state
diff --git a/services/mgmt/node/impl/node_invoker.go b/services/mgmt/node/impl/node_invoker.go
index 1712a0a..8b07f0d 100644
--- a/services/mgmt/node/impl/node_invoker.go
+++ b/services/mgmt/node/impl/node_invoker.go
@@ -254,7 +254,7 @@
 		return errOperationFailed
 	}
 	// Check that invoking Update() succeeds.
-	childName = naming.MakeTerminal(naming.Join(childName, "nm"))
+	childName = naming.Join(childName, "nm")
 	nmClient, err := node.BindNode(childName)
 	if err != nil {
 		vlog.Errorf("BindNode(%v) failed: %v", childName, err)
diff --git a/services/mgmt/node/noded/main.go b/services/mgmt/node/noded/main.go
index 47faac9..f1b9a2d 100644
--- a/services/mgmt/node/noded/main.go
+++ b/services/mgmt/node/noded/main.go
@@ -50,7 +50,7 @@
 	if err != nil {
 		vlog.Fatalf("Listen(%s) failed: %v", roaming.ListenSpec, err)
 	}
-	name := naming.MakeTerminal(naming.JoinAddressName(endpoint.String(), ""))
+	name := naming.JoinAddressName(endpoint.String(), "")
 	vlog.VI(0).Infof("Node manager object name: %v", name)
 	configState, err := config.Load()
 	if err != nil {
diff --git a/tools/mounttable/impl.go b/tools/mounttable/impl.go
index 1c88cc7..b37d5f6 100644
--- a/tools/mounttable/impl.go
+++ b/tools/mounttable/impl.go
@@ -177,11 +177,14 @@
 	}
 	ctx, cancel := rt.R().NewContext().WithTimeout(time.Minute)
 	defer cancel()
-	c, err := bindMT(ctx, args[0])
+	call, err := rt.R().Client().StartCall(ctx, args[0], "ResolveStepX", []interface{}{}, options.NoResolve(true))
 	if err != nil {
-		return fmt.Errorf("bind error: %v", err)
+		return err
 	}
-	entry, err := c.ResolveStepX(ctx)
+	var entry types.MountEntry
+	if ierr := call.Finish(&entry, &err); ierr != nil {
+		return ierr
+	}
 	if err != nil {
 		return err
 	}
diff --git a/tools/mounttable/impl_test.go b/tools/mounttable/impl_test.go
index 4a7deaf..fdfc5d1 100644
--- a/tools/mounttable/impl_test.go
+++ b/tools/mounttable/impl_test.go
@@ -126,7 +126,8 @@
 	stdout.Reset()
 
 	// Test the 'resolvestep' command.
-	if err := cmd.Execute([]string{"resolvestep", naming.JoinAddressName(endpoint.String(), "//name")}); err != nil {
+	vlog.Infof("resovestep %s", naming.JoinAddressName(endpoint.String(), "name"))
+	if err := cmd.Execute([]string{"resolvestep", naming.JoinAddressName(endpoint.String(), "name")}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if expected, got := `Servers: [{server1 123}] Suffix: "name" MT: false`, strings.TrimSpace(stdout.String()); got != expected {